Discussion :

[bm]

bonjour ,

Code :

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
23
24
25
26
27
28
29
30
31
32
from numpy import random
import numpy as np
import matplotlib.pyplot as plt
 
def f(x):
    """Fonction de Rosenbrock a deux variables"""
    return (1-x[0])**2+(x[1]-x[0]**2)**2
 
import numpy as np
import matplotlib.pyplot as plt
import time
x1 , x2 = np.meshgrid(np.linspace(0,2,201),np.linspace(0,2,201))
 
subplot(212)
a=plt.contourf(x1,x2,f([x1,x2]),np.linspace(0,1,21))
# plt.colorbar()
 
import scipy.optimize as op
t1 = time.time()
op.fmin(f,(0.0,0.0))
t2 = time.time() - t1
print 'Temps d\'exécution : '+str(t2*1000)+' milli seconde'
 
solsimplexe = op.fmin(f,(0.0,0.0),retall=1)
"""
Le chemin suivit par l’algorithme est stocké
dans la variable solsimplexe[1]
 """
subplot(211)
plt.title('Graphe avec le simplex');
 
show

Comment introduire la variable solsimplexe[1] pour obtenir
un deuxième graphe avec le tracé du simplex ?

Une piste ou idée ...

[__dardanos__]

Salut,
Ce que tu veux obtenir n'est pas clair. Une idée comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
solsimplexe = op.fmin(f, (0.0,0.0), retall=True)
_, path = solsimplexe
Y = [y for x, y in path]
 
plt.subplot(211)
plt.title('Graphe avec le simplex')
plt.scatter(range(len(Y)), Y)
 
plt.subplot(212)
plt.contourf(x1, x2, f([x1,x2]), np.linspace(0,1,21))
 
plt.show()

[bm]

La source est ici :

http://kmdb.pagesperso-orange.fr/_sr...oindres-carres

Il manque des transitions python, pour tracer direct sur le graphe ..

[__dardanos__]

C'est plus simple. Il faut tracer 2 graphes.

Code :

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

1
2
3
4
5
6
7
solsimplexe = op.fmin(f, (0.0,0.0), retall=True)
_, path = solsimplexe
 
plt.title('Graphe avec le simplex')
plt.contourf(x1, x2, f([x1,x2]), np.linspace(0,1,21))
plt.plot(*zip(*path), color="black", marker="o", markerfacecolor="white")
plt.show()

[bm]

ok, merci :

Code :

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
23
24
25
26
27
subplot(212)
plt.title('Graphe sans le simplex')
plt.contourf(x1,x2,f([x1,x2]),np.linspace(0,1,21))
plt.colorbar()
plt.show()
 
import scipy.optimize as op
t1 = time.time()
op.fmin(f,(0.0,0.0))
t2 = time.time() - t1
print 'Temps d\'exécution : '+str(t2*1000)+' milli seconde'
 
"""
Le chemin suivit par l’algorithme est stocké
dans la variable solsimplexe[1]
 """
subplot(211)
 
solsimplexe_cg = op.fmin_cg(f, (0.0,0.0), retall=True)
solsimplexe = op.fmin(f, (0.0,0.0), retall=True)
_, path = solsimplexe
 
plt.title('Graphe avec le simplex')
plt.colorbar()
plt.contourf(x1, x2, f([x1,x2]), np.linspace(0,1,21))
plt.plot(*zip(*path), color="black", marker="o", markerfacecolor="white")
plt.show()

subplot permet le tracé de 2 graphiques ( mais undefinited subplot : quelle librairie ? )

solsimplexe_cg = op.fmin_cg(f, (0.0,0.0), retall=True) : est le gradient conjugué ( comment l'ajouter dans le path, au gradient simple?)

[__dardanos__]

Les graphes doivent être dans le même graphique. Il ne faut pas utiliser subplot.
Pour tracer les résultats du gradient conjugué, il faut tracer un autre graphe.
Voila le code autonome :

Code :

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
23
24
25
26
27
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
import scipy.optimize as op
 
def f(x):
    """Fonction de Rosenbrock a deux variables"""
    return (1 - x[0])**2 + (x[1] - x[0]**2)**2
 
def main():
    x1, x2 = np.meshgrid(np.linspace(0,1.5,201),np.linspace(-0.5,1.5,201))
 
    solsimplexe_cg = op.fmin_cg(f, (0.0,0.0), retall=True)
    _, path_cg = solsimplexe_cg
 
    solsimplexe = op.fmin(f, (0.0,0.0), retall=True)
    _, path = solsimplexe
 
    plt.title('Graphe avec le simplex')
    plt.contourf(x1, x2, f([x1,x2]), np.linspace(0,1,21))
    plt.plot(*zip(*path), lw=4, color="black", marker="o", markerfacecolor="white")
    plt.plot(*zip(*path_cg), lw=4, color="green", marker="o", markerfacecolor="white")
    plt.show()
 
if __name__ == '__main__':
    main()

[bm]

Double graphe :



[Résolu]

[bm]

Pour terminer avec cette source :

http://kmdb.pagesperso-orange.fr/_sr...oindres-carres

Code :

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
23
import numpy as np
import scipy.optimize as op
import matplotlib.pyplot as plt
 
donnees = np.loadtxt('donnees-moindrescarres.dat', skiprows=1, delimiter=';')
t , yb = donnees[:,0] , donnees[:,1]
 
plt.plot(t,yb,'bo')
plt.grid(True)
plt.xlabel(r'$t$',size=20)
plt.ylabel(r'$\tilde{y}$',size=20)
plt.title(r'Graphe data experience',size=18)
 
def y(t,p):
    """Exponentielle decroissante."""
    return p[0]*np.exp(-p[1]*t)
 
def residu(p):
    """Residu."""
    return y(t,p)-yb
 
LM = op.leastsq(residu,[1.0,1.0],full_output=1)
print LM[0]

Un fichier de data compatible pour la courbe de moindres carrées : http://bmil.free.fr/donnees-moindrescarres.dat

Comment intégrer cette courbe à la distribution des points ?

@+

[__dardanos__]

Salut,
Il reste à appeler la fonction d'ajustement y avec les paramètres retournés par leastsq (LM). Il faut déterminer un domaine d'ajustement, pour augmenter ou réduire le nombre de points suivant le besoin, et dans ce cas précis pour avoir des valeurs classées par ordre croissant.
Et ensuite il ne reste plus qu'à tracer sur le même graphique que la distribution de points.

Code :

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
23
24
25
26
27
28
29
30
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import numpy as np
import scipy.optimize as op
import matplotlib.pyplot as plt
 
def y(t,p):
    """Exponentielle decroissante."""
    return p[0]*np.exp(-p[1]*t)
 
def residu(p):
    """Residu."""
    return y(t,p)-yb
 
if __name__ == '__main__':
    donnees = np.loadtxt('donnees-moindrescarres.dat', skiprows=1, delimiter=';')
    t , yb = donnees[:,0] , donnees[:,1]
 
    x, cov_x, infodict, mesg, ler = op.leastsq(residu,[1.0,1.0],full_output=1)
    t_fit = np.linspace(t.min(), t.max(), 128)
    y_fit = y(t_fit, x)
 
    plt.grid(True)
    plt.xlabel(r'$t$',size=20)
    plt.ylabel(r'$\tilde{y}$',size=20)
    plt.title(r'Graphe data experience',size=18)
    plt.scatter(t, yb)
    plt.plot(t_fit, y_fit, c='r', lw=2)
    plt.show()

[bm]

Je n'ai pas de cours sur cette optimisation :

Code :

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

1
2
LM = op.leastsq(residu,[1.0,1.0],full_output=1)
print LM[0]

Que fait op.leastsq ?
[1.0,1.0] représente-il p[0], p[1] ?
En fixant les valeurs que l'on cherche, c'est bizarre ..

[__dardanos__]

Qu'est ce que tu ne comprends pas dans la doc ? Tout y est.
leastsq cherche le minimum de l'ensemble d'équations défini par residu, par la méthode des moindres carrés. [1, 1] est l'estimation initiale de la solution. Donner une estimation en entrée est nécessaire pour la résolution par MC. L'algo peut ne pas converger ou converger vers un minimum local différent de celui recherché.
Change la condition initiale pour voir si tu retrouves bien la même solution x (ou p avec tes notations).

[bm]

Code :

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

x, cov_x, infodict, mesg, ler = op.leastsq(residu,[3.5,1.5],full_output=1)

ok, c'est la même convergence .

scipy.optimize.leastsq(func, x0, args=(), Dfun=None, full_output=0, col_deriv=0, ftol=1.49012e-08, xtol=1.49012e-08, gtol=0.0, maxfev=0, epsfcn=None, factor=100, diag=None)

func : residu
x0 : [3.5,1.5]
...
full_output=1
----------------

c'est ce groupement de variable 'x, cov_x, infodict, mesg, ler ='
et la relation implicite qui va avec que je ne vois pas ?

[__dardanos__]

La doc est claire:

Code :

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

1
2
3
full_output : bool
 
    non-zero to return all optional outputs.

et on liste facilement qu'il y a 5 objets retournés dans un tuple.

J'ai choisi d'affecter chaque objet dans une variable mais tu peux aussi mettre le tout dans un tuple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> x = list(range(3))
>>> x
[0, 1, 2]
>>> a, b, c = list(range(3))
>>> a
0
>>> b
1
>>> c
2
>>>

[bm]

Je vois que tout le tuple n'est pas utilisé dans le plot :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 x, cov_x, infodict, mesg, ler = op.leastsq(residu,[1.0,1.0],full_output=1)
    t_fit = np.linspace(t.min(), t.max(), 128)
    y_fit = y(t_fit, x)
 
    plt.grid(True)
    plt.xlabel(r'$t$',size=20)
    plt.ylabel(r'$\tilde{y}$',size=20)
    plt.title(r'Graphe data experience',size=18)
    plt.scatter(t, yb)
    plt.plot(t_fit, y_fit, c='r', lw=2)
    plt.show()

cov_x, infodict, mesg, ler , peuvent servir à quoi
avec plusieurs résidus pour voir leurs variations ?

[__dardanos__]

cov_x, infodict, mesg, ler , peuvent servir à quoi
avec plusieurs résidus pour voir leurs variations ?

Je me répète mais tout est dans la documentation. Cette fonction permet de traiter des problèmes d'optimisation différents (nombre d'équations, nombre de variables, etc...). Les autres objets retournés servent à quantifier la qualité de la solution.
Le problème n'a de sens qu'avec un seul "residu".

[bm]

[Résolu]