Discussion :

[romainmill]

Bonjour à tous,

Voici mon problème. J'ai l'équation suivante x=a*cos(b-psi)+c*tan(alpha), avec x et psi des images de 1201x1201.

Du coup, je connais x, psi et alpha et j'aimerai trouvé a, b et c. On m'a dit que je peux utiliser scipy.optimize, mais je vous avouerai que j'ai du mal à m'en servir.

J'ai essayé d'utilisé ce forum mais j'ai du mal à adapter mon problème : http://stackoverflow.com/questions/7...quares-fitting .

Auriez vous des conseils pour m'éclairer, merci d'avance

Merci d'avance pour votre aide

[Julien N]

Salut Romainmill,

Je suis loin d'être un expert en optimisation, mais j'en ai fait un peu. Il existe différentes méthodes plus ou moins complexes pour cela. La plus simple et la plus connue c'est sans doute la méthode des moindres carrés (least mean squares). Scipy vient avec une excellente bibliothèques de fonctions dont leastsq.

La doc est plutôt pas mal, surtout la version PDF. Tu peux notamment y trouver l’exemple sur la fonction de Rosenbrock :

Code :

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

1
2
3
4
5
6
7
8
9
10
from scipy.optimize import fmin
 
def rosen(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
 
x0 = [1.3, 0.7, 0.8, 1.9, 1.2]
xopt = fmin(rosen, x0, xtol=1e-8)
 
print xopt

Ici on cherche a minimiser la somme. Dans ton cas on peut essayer ceci (exemple):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
from scipy.optimize import fmin
 
def romainmill(x, *args):
    psi = args[0]
    alpha = args[1]
    target = args[2]
    return target - (x[0]*np.cos(x[1]-psi) + x[2]*np.tan(alpha))
 
x0 = [1.0, 2.0, 3.0]
xopt = fmin(romainmill, x0, args=(4.0, 5.0, 0.0))
 
print xopt

La function accepte une liste en entrée (x) qui sont pour toi les trois paramètres à trouver (a, b et c). En plus, une liste d'argument est donnée te permettant de definir alpha, psi et une target (pour minimiser il faut un objectif).

x0 est la liste des valeurs initiales de a, b et c. Les chosir influence le résultat.

C'est vraiment très basique, non linéaire, mais aussi très peu efficace. Tu peux faire bien plus compliqué, mais commence par faire simple.

Ju

[romainmill]

Ok cool merci beaucoup ! c'est plus clair maintenant !

[romainmill]

mais du coup la liste je dois spécifier psi, alpha et target en argument du coup ? et a,b,c aussi ?du genre :

romainmill([a,b,c],[psi,alpha,target]) (cela plante car a, b,c ne sont pas définis

(désolé je commence juste python),

Par ailleurs, quelle est la différence avec la fonction leastsq ?

[Julien N]

Tout à fait, a, b et c ne sont pas définis en tant que tels. Ce sont dans l'ordre les éléments de x, la liste passée en paramètre. Peut-être que le nom x porte à confusion...

En somme on part d'une base, x0. La méthode fmin fonctionne comme une bille sur une surface vallonnée, elle tend à rouler vers le point le bas. Si la surface est très vallonnée, il existe de multiples "vallées" dans lesquelles la bille peut s'arrêter, il existe donc de multiple solution au problème. Je rappel qu'on cherche ici à "minimiser" une quantité, pas à trouver une solution exacte. C'est pourquoi le choix des valeurs initiales est primordiale pour obtenir un résultats intéressant.

Fmin implémente la méthode "simplex":
http://docs.scipy.org/doc/scipy/refe...mize.fmin.html

Leastq fonctionne un peu différemment. Le principe c'est que l'on a une série de valeurs et une loi/fonction que l'on veut coller. En somme trouver une "courbe" (si on est en 2D) passant au plus près des points (valeurs). Pour cela on calcul l'erreur entre notre fonction et les valeurs connues. Cette erreur est élevée au carrée, c'est aussi selon le point de vue une "distance" entre la courbe de la fonction et les points. On somme ces erreurs puis on cherche à minimiser cette somme.

C'est ce que fait excel lorsqu'on cherche à effectuer une régression linéaire.

Bref,

Il ne faut pas faire romainmill([a,b,c],[psi,alpha,target]). Tu peux voir si la fonction romainmill te semble correcte en faisant quelque chose comme ceci:

Code :

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

1
2
3
4
5
6
7
8
a, b, c = 1.0, 2.0, 3.0
psi = 4.0
alpha = 5.0
target = 42.0
args = [psi, alpha, target]
 
err = romainmill([a,b,c], *args)
print err

Fmin va essayer de trouver x[0], x[1], x[2] (qui sont pour toi a, b, c) de telle sorte que x[0]*np.cos(x[1]-psi) + x[2]*np.tan(alpha) soit au plus proche de target = 42.0

Bon tout ça ne résoud pas ton problème. Fmin n'est pas forcément la méthode qui te convient. Est-ce que tu peux nous donner plus de précisions sur tes matrices?

Ouaf, je te laisse digérer ça !

J

[romainmill]

Merci encore pour cette réponse détaillée!

Alors mon problème j'ai deux images de 1201x1201 pixels, identique en apparence mais en fait légérement décalées, je veux évaluer le décalage entre ces deux images.
Celui ci est régis par l'équation que j'ai posté dans le premier message.
En fait a, b et c sont la norme, la direction et la composante verticale du vecteur entre les deux images. Je pensais donc que least square était mieux, car on pouvait évaluer l'erreur entre les deux images (quand l'écart type entre l'image maitre et l'esclave et infèrieure à 2% je dois arrêter les itérations).
Je vais quand même essayé avec fmin pour voir les résultats que cela donne, et après si j'arrive à comprendre leastsq comparer les résultats.