Enoncé :

1.1      Exercice 1 (moindres carrés)

Le but de cet exercice est d’écrire une fonction permettant d’approcher au sens des moindres carrés la fonction  sur l’intervalle [0, π] à l’aide de polynômes, lorsque l’on ne dispose que d’un échantillon bruité de cette fonction.

• construire un échantillon de n = 100 points de la fonction cos.
• construire l’estimateur au sens des moindres carrées de cette fonction à l’aide de polynômes de degré d = 12 3.
• que se passe-t-il si l’on change l’ordre du polynôme : d = 0, 1, 2, 35, 10, 15, 20

1.2      Exercice 2 (méthode de moindres carrés)

Nous cherchons dans cet exemple à approcher une fonction quelconque  à partir d’un échantillon bruité de couples  avec :

 

Où  est un bruit gaussien de variance . Afin d’illustrer la méthode, nous allons prendre la fonction cosinus comme fonction cible en prétendant que nous ne la connaissons pas.

• Générer 100 points aléatoirement entre 0 et 1 suivant la distribution uniforme. Ordonnez ces points.
• Pour chaque point calculer
• Pour caque point , générer une observation bruitée , avec suivant une loi normale de variance 0.01
• Tracer la courbe de la fonction cosinus
• Affichez sur la même figure les couples (xi , yi), i = 1, .., n à partir desquels nous allons approcher la fonction cosinus.
• Dessiner la fonction pour   sur une deuxième figure
• La méthode des moindres carrés consiste à estimer la fonction supposée inconnue par une fonction connue   (ici un polynôme de degré p) dont on va trouver les coefficients , j = 1, p en minimisant les carrés des erreurs sur les points (xi , yi), i = 1, n dont nous disposons. Mathématiquement le problème s’écrit :

 

1. Reformulez matriciellement l’équation précédente, c’est à dire écrivez la sous la forme

 

Avec  deux vecteurs et  une matrice dont on précisera la dimension. Calculer la matrice .

1. Calculer la valeur du gradient de la fonction cout d’optimisation

 

1. calculez une estimation en forme close de la solution
2. donnez le système linéaire associé
3. visualisez votre approximation au sens des moindres carrés

 

Solution :

Compte-rendu_TP2_ED3_Rogé_Poupa

 

Code Python :

import numpy as np
import math as mp
import matplotlib.pyplot as plt
from random import uniform
from numpy.polynomial import Polynomial

#####1######

def graph_cos(n):
X=[]
Y=[]
for i in range(0,n):
a=uniform(0,mp.pi)
b=mp.cos(a)

X.append(a)
Y.append(b)
plt.scatter(X,Y,label=’ fonction cosinus echantilonée’)
plt.title(« fonction cosinus échantillonnée »)
return(X,Y)

#####2#####
def moindres_carres(n,d):
k=d+1
X = sorted(graph_cos(n)[0])
Y = np.cos(X)
A= np.zeros((k,k))

#Calcul de la matrice A si on prend le probleme sous la forme A.I=B
for l in range(1,k+1):
for j in range(1,k+1):
Somme=0
for i in range(1,n+1):
Somme+=X[i-1]**(j+l-2)
A[l-1,j-1]=Somme

#Calcul de B
B= np.zeros((k,1))
for j in range(1,k+1):
Somme=0
for i in range(1,n+1):
Somme+=Y[i-1]*X[i-1]**(j-1)
B[j-1,0]=Somme

#Calcul de I
I=np.linalg.solve(A,B)

#Generation du polynome#
L=I.tolist()
C=[]
for i in range(len(L)):
C.append(L[i][0])
p=Polynomial(C)

###Graphique#####
W=[]
for i in range (n):
W.append(p(X[i]))
plt.plot(X,W,’r’,label=’moindes carrés de cosinus’)
plt.legend()

###Exercice 2####

####1#####
n=100
x=np.asarray(sorted(np.random.rand(n)))

###2###
f=np.cos(np.pi*x)

###3###
sigma=0.1
e=np.random.randn(n)
y=f+sigma*e

####4###
plt.plot(x,f,label=’fonction cosinus échantillonnée’)

###5####
plt.scatter(x,y,s=20,c=’r’,marker=’+’,label=’points approchant la fonction cos’)
plt.legend()

###6###
def g (x) :
return (1+x-3*x**2+x**3+x**4+x**5-x**6)

# Affichage

B = np.linspace(0,1,500)
C = g(B)
plt.figure()
plt.plot(B,C, label = ‘Fonction g’)
plt.xlabel(‘x’)
plt.ylabel(‘g(x)’)
plt.title(‘Représentatin de la fonction g’)
plt.legend()
plt.show()

####7#####

###a### en pièce jointe pour la partie théorique

def moindres_carres2(n,p):

X = x
Y = y
A= np.zeros((p,p))

#Calcul de la matrice A si on prend le probleme sous la forme A.I=B
for l in range(1,p+1):
for j in range(1,p+1):
Somme=0
for i in range(1,n+1):
Somme+=X[i-1]**(j+l-2)

A[l-1,j-1]=Somme

#Calcul de B

B= np.zeros((p,1))
for j in range(1,p+1):
Somme=0
for i in range(1,n+1):
Somme+=Y[i-1]*X[i-1]**(j-1)
B[j-1,0]=Somme

#Calcul de I

I=np.linalg.solve(A,B)

return(I) #on retourne I qui est l’equivalent du X dans l’énoncé

#on lance avec n=100 et p=12

moindres_carres2(100,12)

###b####

def cout_optimisation(n,p):

X=moindres_carres2(n,p)
Xt=np.transpose(X)
X_alpha=np.zeros((p,1))

for i in range(0,p):

X_alpha[i][0]=X[i][0]+(i+1)

return(Xt.dot(X_alpha-y))

#on lance avec n=100 et p=12
cout_optimisation(100,12)

###c/d/e###
def moindres_carres3(n,p):

X = x
Y = y
A= np.zeros((p,p))

#Calcul de la matrice A si on prend le probleme sous la forme A.I=B
for l in range(1,p+1):
for j in range(1,p+1):
Somme=0
for i in range(1,n+1):
Somme+=X[i-1]**(j+l-2)
A[l-1,j-1]=Somme

#Calcul de B
B= np.zeros((p,1))
for j in range(1,p+1):
Somme=0
for i in range(1,n+1):
Somme+=Y[i-1]*X[i-1]**(j-1)
B[j-1,0]=Somme

#Calcul de I
I=np.linalg.solve(A,B)

#Generation du polynome#
L=I.tolist()
C=[]
for i in range(len(L)):
C.append(L[i][0])
p=Polynomial(C)

###Graphique#####
W=[]
for i in range (n):
W.append(p(X[i]))

plt.figure()
plt.plot(X,W,label=’moindes carrés de cosinus’) # On trace l’approximation au sens des moindres carrés de la fonction cosinus
plt.scatter(x,y,s=20,c=’r’,marker=’+’,label=’courbe à approximer’) # On ajoute la courbe que l’on souhaite approximer

w=np.linspace(0,1,100)

plt.plot(w,np.cos(np.pi*w),label=’fonction cosinus’)# On ajoute la fonction cosinus réelle pour vérifier la concordance avec
#notre approximation
plt.title(« Visualisation de l’approximation au sens des moindres carrés »)
plt.grid()
plt.legend()
plt.show()