Discussion :

[Deep_Blue_20GC]

Bonjour,
Je ne savais pas trop où poster mon post donc je le poste ici.
Je suis actuellement en stage et je fait face à un problème depuis quelque jours. Je débute en programmation informatique, et je dois écrire un algorithme d'optimisation. Malheureusement, j'ai vraiment du mal à savoir comment m'y prendre.

Je travaille sur le stockage de l'énergie, et je dois optimiser la gestion de l'unité de stockage, pour minimiser le coût pour le particulier.
On considère que ce dernier à une production et une consommation d'énergie connue un jour à l'avance.
Lorsqu'il consomme plus qu'il ne produit, il a 2 solutions pour rétablir l'équilibre : utiliser son stock d'énergie si celui-ci n'est pas vide, ou soutirer de l'énergie sur le réseau.
Dans le cas inverse où il produit plus qu'il ne consomme, il peut soit stocker son énergie ou alors la réinjecter sur le réseau.
Le but de cette optimisation est de minimiser le coût/maximiser le profit pour le particulier : il doit donc déstocker quand l'énergie du réseau est cher, et soutirer quand celle ci est peu chère. Quand il produit plus qu'il ne consomme, il vaut mieux vendre quand le prix de revente est cher, et stocker quand celui ci est peu cher. On considère bien entendu que les prix de revente et d'achat sont connus 24h à l'avance, et l'optimisation se fait sur ces 24h.

Je raisonne en puissance et voila l'expression du coût que j'ai trouvé dans le cas ou l'on consomme plus qu'on ne produit :
On note Pdst la puissance de déstockage et Psout celle de soutirage, et diff=conso-prod
Par ailleurs ak correspond au prix de revente de l'énergie, et bk le prix de soutirage sur le réseau. ak étant strictement inférieur à bk quelque soit k.
Déstocker de l'énergie revient à la payer au prix de revente car on aurait pu la revendre au lieu de l'utiliser. (pour l'instant je considère les rendements de stockage et de déstockage égaux à 1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
cout[k]=ak*Pdst[k]+bk*Psout
=ak*Pdst[k]+bk*(diff[k]-Pdst[k])
=(ak-bk)*Pdst[k]+bk*diff[k]
 
cout= somme(cout[k]pour k=1...24)

Le but est donc de choisir le bon Pdst[k] à chaque heure.

Les contraintes sont les suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 Pmin<=Pdst[k]<=max(Pmax, stock[k-1]/pas)

Et à chaque tour de boucle je dois calculer le nouveau stock qui à l'expression suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 stock[k]=stock[k-1]-Pdst[k]*pas

J'espère que c'est assez clair, n'hésitez pas à me poser des questions dans le cas contraire. J'aurais vraiment besoin d'un petit coup de pouce, car je ne trouve pas d'algorithme d'optimisation dont les contraintes dépendes du temps...

[vttman]

Bonjour Deep_Blue_20GC,

Si personne ne répond dans les prochaines minutes, heures ?
=>
ça serait bien, alors , à mon avis de donner des exemples concrets et simples de ce qui va demander une optimisation
"J'ai telles données en entrée et voici ce que je calcule et compare avec ces paramètres ensuite selon le résultat ...
je boucle avec un changement de paramètres ? jusqu'à obtenir etc."

[dourouc05]

Tu as plein d'algorithmes qui peuvent prendre en compte le temps : simplexe, point intérieur, criss cross, descente de gradient, etc. Dans le domaine, c'est super classique (surtout simplexe et point intérieur) — ou alors de l'apprentissage par renforcement, mais ça semble hors de propos pour toi pour le moment.

De ce que je comprends, tu cherches à effectuer de l'optimisation mathématique : tu prépares une formulation mathématique (idéalement linéaire, sinon convexe ça va aussi, plus des variables entières si besoin), tu la refourgues à un solveur d'optimisation. Par exemple, tu peux utiliser JuMP (pour la formulation) avec un solveur comme Cbc/Clp (pour obtenir une solution), en Julia : https://tcuvelier.developpez.com/tut...on-rapide-1.1/ et https://tcuvelier.developpez.com/tut...ion-jump-0.21/ .

Petit exemple :

Code Julia :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using JuMP, Clp
 
T = 24
stockinit = 5
stockmax = 10
# …
 
m = Model(Clp.Optimizer)
 
@variable(m, 0 <= stock[0:24] <= stockmax)
@variable(m, Pdst[0:24] >= 0)
@variable(m, Pout[0:24] >= 0)
 
@objective(m, Min, sum(a[t] * Pdst[t] + b[t] * Pout[t] for t in 0:24))
 
@constraint(m, stock[0] == stockinit)
for t in 1:24
    @constraint(m, stock[t] == stock[t-1] - Pdst[t] * pas)
end
# …
 
optimize!(m)

[Flodelarab]

Bonjour

Je ne vois pas où est le choix.

Est-ce que la production est supérieure à la consommation ?

• Oui.
  Le réseau est-il moins cher que le stockage ?
  
  • Oui. On vend.
  • Non. On stocke.
• Non.
  Le réseau est-il moins cher que le stockage ?
  
  • Oui. On achète.
  • Non. On déstocke.

Il n'y a pas de choix. Il suffit de garder la mémoire.

Si tu vois plus loin, c'est que tu fais de la spéculation sur le prix de l'électricité. Est-ce ce que tu veux faire ?

[dourouc05]

Si tu vois plus loin, c'est que tu fais de la spéculation sur le prix de l'électricité. Est-ce ce que tu veux faire ?

Dans la demande initiale, il y a une forme de spéculation : on considère les prix donnés vingt-quatre heures à l'avance.

[Deep_Blue_20GC]

Bonjour Deep_Blue_20GC,

Si personne ne répond dans les prochaines minutes, heures ?
=>
ça serait bien, alors , à mon avis de donner des exemples concrets et simples de ce qui va demander une optimisation
"J'ai telles données en entrée et voici ce que je calcule et compare avec ces paramètres ensuite selon le résultat ...
je boucle avec un changement de paramètres ? jusqu'à obtenir etc."

Pardon si je ne suis pas claire, je vais essayer de l'être le plus possible.

Les données de départ sont la consommation, la production, ainsi que les tarifs d'achat et de revente d'électricité sur les 24 prochaines heures. On considérera dans un premier temps que tarif d'achat est toujours supérieur au tarif de revente pour éviter un achat d'électricité dans le seul but de la revendre.

Données:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
conso=[conso[0],conso[1],...,conso[23]]
prod=[prod[0],prod[1],...prod[23]]
prix_rev=[a[0],a[1],...,a[23]]
prix_ach=[b[0],b[1],...,b[23]]
diff=conso-prod

On note également :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

P=[P[0],P[1],...P[23]]

vecteur dont il faut trouver les valeurs pour maximiser le coût, représentant la puissance de stockage/déstockage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cout=[cout[0],cout[1],...,cout[23]]
stock=[stock[0],stock[1],...,stock[23]]

vecteurs dont les coordonnées découlent de celles de P

Le but est de minimiser le coût pour le gérant de l'installation.
Ce coût, lorsque la consommation est plus grande que la production est défini par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

coût[k]=bk*diff[k] + (ak-bk)P[k]

en reprenant les notations précédentes.
Dans le cas où la production est plus grande que la consommation, on peut parler de bénéfice qui s'écrirait comme tel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

benef[k]=ak*Préinj[k]=ak*(P[k]-diff[k])

. La différence entre la puissance stockée et diff=conso-prod, est égale à la puissance réinjectée dans le réseau, vendu au tarif ak, d'où l'expression précédente du bénéfice. Le coût, que l'on peut considérer comme l'opposé du bénéfice, serait égal à -bénéfice, on aurait donc un 'coût négatif'.

Mon objectif est donc de minimiser ce coût (ou de maximiser le bénéfice), en stockant/déstockant plus ou moins à chaque pas de temps.
On peut écrire le coût de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
cout_tot= somme(cout[k]) pour k appartenant à [0,23]
for k in range(24):
   if diff[k]<0:
      cout[k]=-a[k]*(P[k]-diff[k])
   else :
      cout[k]= b[k]*diff[k]+(a[k]-b[k])*P[k]

Mon seul degré de liberté et donc mon paramètre à choisir, est cette puissance de stockage, toutes les autres données (consommation, production, tarifs) étant des données.

Ma seule contrainte pour l'instant sur le stockage est la suivante :
dans le cas d'un surplus de consommation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Pmin<Pdst[k]<min(Pmax,stock[k-1]/pas)

dans le cas d'un surplus de production :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Pmin<Pst[k]<min(Pmax,(capacité-stock[k-1])/pas)

Et le stock s'actualise à chaque tour de boucle (donc à chaque pas horaire) comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

stock[k]=stock[k-1]-P[k]*pas

(la puissance étant négative quand on stock et positive quand on déstocke, on a bien une augmentation du stock lorsque l'on stock et une diminution lorsque l'on déstocke).

J'espère avoir été plus claire... n'hésitez pas à me redemander des précisions si nécessaire.

Merci dourouc05, je vais regarder JuMP, mais malheureusement je crains que mon problème à résoudre n'est pas linéaire à cause du if... Dois-je forcément le réécrire de manière linéaire ou alors existe-t-il un moyen de résoudre des problèmes de la sorte ?

Et Flodelarab, au début je pensais comme toi, mais en fait cela est seulement si on réfléchit heure par heure. En réfléchissant sur 24h, on pourrait très bien utiliser le stockage alors que le réseau est moins cher, parce que ce réseau sera encore moins cher l'heure suivante. Le but est que le coût soit minimale sur les 24h et non pas heure par heure, ce qui complexifie le problème.

Merci à tous en tout cas d'essayer de m'aider !

[Flodelarab]

Ahhhhh, ok. C'est beaucoup plus clair. Je croyais à quelque chose de dynamique en temps réel. Alors que ton problème est statique et tout est connu.

Ce qui est pervers, c'est que tu peux avoir intérêt à acheter de l'électricité, pendant une heure de surproduction, car acheter de l'électricité à un autre moment serait plus cher .
Joli casse-tête.

Il peut y avoir une fuite dans ton problème. Si, à un moment, le prix de revente est supérieur au prix d'achat antérieur, tu peux avoir envie d'acheter une infinité d'électricité dans le but de revendre une infinité. Ce qui n'est évidemment pas possible.
À l'inverse, si tout prix d'achat est supérieur à tout prix de vente, il faut absolument commencer par éviter les achats. Et remplacer les achats onéreux par des achats moins onéreux (comme déjà dit).

Soit un fichier csv avec heure, production, consommation, prix d'achat, prix de vente

1       7224    4006    105     98
2       1130    3193    144     41
3       5147    1066    148     64
4       4680    6864    145     8
5       9099    7850    104     78
6       730     37      119     34
7       9353    3624    115     38
8       2753    2063    108     38
9       7669    6857    182     90
10      2616    1211    141     3
11      9359    5314    167     12
12      1481    6853    151     29
13      2188    7363    139     54
14      5036    5754    126     45
15      4842    7632    118     24
16      8400    9010    148     75
17      7086    8643    193     62
18      4315    8320    147     95
19      200     9180    113     67
20      2486    1954    195     37
21      464     8397    143     66
22      7384    7936    177     37
23      4345    7720    122     41
24      1346    2578    164     31

On en déduit ceci, trié par coût/bénéfice pour chaque unité.

17      7086    8643    193     62      manque  1557    193
22      7384    7936    177     37      manque  552     177
24      1346    2578    164     31      manque  1232    164
12      1481    6853    151     29      manque  5372    151
16      8400    9010    148     75      manque  610     148
18      4315    8320    147     95      manque  4005    147
4       4680    6864    145     8       manque  2184    145
2       1130    3193    144     41      manque  2063    144
21      464     8397    143     66      manque  7933    143
13      2188    7363    139     54      manque  5175    139
14      5036    5754    126     45      manque  718     126
23      4345    7720    122     41      manque  3375    122
15      4842    7632    118     24      manque  2790    118
19      200     9180    113     67      manque  8980    113
1       7224    4006    105     98      trop    3218    98
9       7669    6857    182     90      trop    812     90
5       9099    7850    104     78      trop    1249    78
3       5147    1066    148     64      trop    4081    64
7       9353    3624    115     38      trop    5729    38
8       2753    2063    108     38      trop    690     38
20      2486    1954    195     37      trop    532     37
6       730     37      119     34      trop    693     34
11      9359    5314    167     12      trop    4045    12
10      2616    1211    141     3       trop    1405    3

Par suite, tu sais que la première chose à optimiser est la 17e heure. Car sinon, chaque unité ( kW ? ) te coûtera 193 ( € ? ). Tu peux optimiser en déstockant (idéal), ou achetant au prix plus bas précédent la 17ème heure (pis-aller).
Et tu continues par ordre d'importance jusqu'en bas de la liste triée.

En tout cas, je partirais sur cet algorithme.
Bonne chance

[dourouc05]

Merci dourouc05, je vais regarder JuMP, mais malheureusement je crains que mon problème à résoudre n'est pas linéaire à cause du if... Dois-je forcément le réécrire de manière linéaire ou alors existe-t-il un moyen de résoudre des problèmes de la sorte ?

Ce n'est pas une petite condition de rien du tout comme ça qui va poser problème ! Par contre, il faudra utiliser des variables binaires.

Dans ton objectif, c'est normal la discontinuité en diff[k] == 0 ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
   if diff[k]<0:
      cout[k]=-a[k]*(P[k]-diff[k])
   else :
      cout[k]= b[k]*diff[k]+(a[k]-b[k])*P[k]

Sinon, l'astuce est de définir une variable binaire qui détermine si diff[k] (noté d_k) est positif (d_k = 0) ou négatif (d_k = 1), en considérant que d_k est dans l'intervalle [-M, M] :



J'espère que c'est suffisant pour te débloquer.

[Deep_Blue_20GC]

Ce qui est pervers, c'est que tu peux avoir intérêt à acheter de l'électricité, pendant une heure de surproduction, car acheter de l'électricité à un autre moment serait plus cher .
Joli casse-tête.

Il peut y avoir une fuite dans ton problème. Si, à un moment, le prix de revente est supérieur au prix d'achat antérieur, tu peux avoir envie d'acheter une infinité d'électricité dans le but de revendre une infinité. Ce qui n'est évidemment pas possible.
À l'inverse, si tout prix d'achat est supérieur à tout prix de vente, il faut absolument commencer par éviter les achats. Et remplacer les achats onéreux par des achats moins onéreux (comme déjà dit).

Ah super merci beaucoup, je crois avoir compris le principe je vais tester ça !

[Deep_Blue_20GC]

Dans ton objectif, c'est normal la discontinuité en diff[k] == 0 ?

[…]

Sinon, l'astuce est de définir une variable binaire qui détermine si diff[k] (noté d_k) est positif (d_k = 0) ou négatif (d_k = 1), en considérant que d_k est dans l'intervalle [-M, M] :



J'espère que c'est suffisant pour te débloquer.

Hum normalement il n'y pas de discontinuité en diff=0, car pour une différence nulle, on consomme autant qu'on produit donc on ne stock rien, P=0 également et donc le coût est nul.

Je vais aussi chercher par ta méthode, je pense avoir compris l'histoire du d_k binaire, merci !