Projet Econométrie
Utilisation de Regression
Paul Salmon
Faculté des Sciences économiques
Université de Rennes 1
Février 2003
Dans le cadre de l’enseignement sur les options entre autres, nous avons ressentis, le professeur Alain Galesne et moi, le besoin de donner aux étudiants une formation de type classique sur les aspects théoriques mais qui devrait aussi tenir compte des outils actuellement disponibles et des pratiques constatées, voire même aller au delà. Il n’est pas difficile de trouver des programmes de calcul de la formule de Black-Scholes et des Greeks par exemple. Il est plus difficile d’élaborer des produits et de trouver les programmes pour les calculer et les simuler.
Ils nous a semblé cependant nécessaire d’aller dans cette direction, au delà de ces aspects classiques. Ainsi nous permettrons aux étudiants d’apprendre à développer une chaîne complète d’élaboration d’un produit s’appuyant sur les bases théoriques, débouchant sur la mise place des calculs, des possibilités de simulation et allant jusqu’à la prise de décision.
La mise en pratique de cet objectif pédagogique nécessite la mise en place d’un ensemble de moyens pour les étudiants. Il est en fait difficilement concevable de faire réaliser la totalité du travail nécessaire à la formation des étudiants dans le cadre d’un enseignement se déroulant sur six mois. Nous avons alors eu l’idée de préparer un kit que l’étudiant aurait à assembler en fonction de ses besoins. Cette approche est d’autant plus intéressante qu’elle correspond avec l’évolution de la programmation informatique depuis une bonne dizaine d’années. Nous avons essayé de trouver une approche qui pouvait utiliser au mieux les acquis des étudiants, leurs futurs besoins professionnels et les contraintes de temps liés à un programme universitaire.
Nous avons donc recherché ce qui était disponible et de quelle manière nous pouvions l’utiliser pour notre objectif. Notre programme de travail est loin d’être achevé mais il est suffisamment avancé pour contenir tous les éléments de base nécessaires à nos objectifs.
Au moment où nous écrivons ces lignes,
Le langage de programmation utilisé dans le cadre du Dess Finance d’Entreprise est le Visual Basic de Microsoft dans sa version 6.
Sans nous étendre sur le choix de ce langage, nous dirons simplement qu’il a été guidé par les outils traditionnellement disponibles pour les cadres financiers dans les entreprises : un système d’exploitation de type Windows, un pack Office. Dans une telle configuration, il devient logique ou plus évident d’utiliser le Visual Basic. Ainsi le cadre pourra soit écrire ses programmes avec Visual basic soit en VBA[2] dans les applications Microsoft voire dans les autres outils mis à sa disposition[3].
Cette note présente au lecteur le moyen d’utiliser le sous-programme Regression que nous mettons à la disposition des étudiants. Le code du sous-programme est disponible sur le site du Dess Finance d’Entreprise On Line.
Principes de base : un résumé
Regression a pour but de vous permettre de faire des calculs de régression. En d’autre terme, il vous permet d’estimer les coefficients d’une relation linéaire comme celle qui suit.
La méthode pour rechercher les valeurs des coefficients en fonction de l’échantillon de d[S1]onnées dont vous disposez, est appelée la méthode des moindres carrés ordinaires. Elle est apparue à la fin du XIXième dans les travaux de Carl Friedrich Gauss. La première publication sur cette méthode est due à Alphonse Quetelet.
Nous ne rentrerons pas ici dans le détail des calculs. Ceux qui voudraient plus de détails, se reporteront à des manuels de méthodes statistiques de l’économétrie. Les ouvrages de Maddala (1999, 1999), de Gujarati (1999) de Pindick-RubinFeld (1981 et autres éditions) constituent de très bonnes introductions en langue anglaise. Pour la langue française, vous pouvez vous reporter aux ouvrages de Bourbonnais (1999) ou de Giraud et Chaix (1999)[PS2].
Pour les adeptes du Web, vous pourrez lire avec le plus grands profits la présentation de Clopper Almon dans « The craft of economic modeling ». Cette présentation est particulièrement orientée vers la compréhension de l’utilisation des moindres carrés ordinaires.
La formulation matricielle de (1) s’écrit
dans laquelle
où
Le développement des calculs que vous trouverez dans un des ouvrages cités ci-dessus, vous amènera à voir que la principale relation pour les calculs est la suivante :
où
C’est à partir de la formule (3) qu’est construit le programme.
L’organisation
des calculs dans Regression.
La difficulté principale dans l’écriture d’un
programme de régression réside dans le calcul de l’inverse de la matrice
Dans le cas de Regression, nous avons retenu l’approche de l’inversion de matrice de Gauss-Jordan telle qu’elle est présentée dans l’ouvrage de Clopper Almon (1967)[5].
Cette approche nécessite la construction d’une
matrice
Nous supposons que les données correspondants à
Cette matrice est le seul argument nécessaire au sous-programme Regression.
Il n’est pas nécessaire ici d’introduire les dimensions de la matrice. Celles-ci nous serons connues grâce aux fonctions Lbound et Ubound de Visual basic. Ces deux fonctions permettent de connaître les dimensions d’un tableau. Leurs utilisations conjointes avec l’instruction ReDim permettent d’utiliser des matrices de toutes tailles.
Dans sa version actuelle, Regression n’a donc pas de
limitation dans le nombre de variables explicatives si ce n’est que les
contraintes de Visual Basic et de l’espace mémoire. Même si le nombre de
variables explicatives n’est pas limité, il n’est pas conseillé d’aller au delà
de 30 car dans ce cas, quelles que soient les données le
Dans la suite, lorsque nous parlerons de
Dans les calculs d’inversion de matrice qui suivent,
nous ne les appliquons pas sur la matrice
Le calcul de
Si l’on regarde de plus près les éléments de la
matrice
où
z, est
un élément de la matrice
i, correspond au nombre d’observations,
kh, correspond aux lignes de la matrice transposée,
kv, correspond aux colonnes de la matrice transposée,
La matrice
Le pseudocode[6] de ce calcul s’écrit :
1 for
kh from 0 to NC by 1 do 2 for
kv from 0 to NC by 1 do 3 A(kh,
kv) ← 0 4 for
i from 0 to NO by 1 do 5 A(kh,kv)
← A(kh,kh) + X(i,kh) * X(i,kv) 6 stop 7 A(kv,kh)←A(kh,kv) 8 stop 9 stop |
Encadré 1 :Pseudocode
du produit
Les
lignes 1,2 et 4 définissent le début des boucles imbriquées, les lignes 6,8 et
9 marquent la fin des boucles imbriquées. La ligne 3 contient l’initialisation
à 0 de l’élément A(kh,kv). La Ligne 5 contient l’affectation dans l’élément
A(kh,kv) du cumul des produits X(i,kh) * X(i,kv). On remarquera que de la ligne
1 à la ligne 6, le pseudocode permet seulement de remplir la diagonale et la
partie située au dessus de cette diagonale. La ligne 7 contient le code qui
affecte le contenu de A(kh,kv) à A(kv,kh).
L’Encadré 1 contient les lignes de code en Visual
Basic 6 correspondant au produit des matrices
'--------------------------------------------------------------- ' Construction de la
Matrice X'X augmentée '--------------------------------------------------------------- ' For i = 0 To NC For j = 0 To NC '------------------------------------------------------- ' Initialisation à 0. de l'élément
(i,j) de A '------------------------------------------------------- A(i, j) = 0# '------------------------------------------------------- ' Calcul de la matrice symétrique X'X '------------------------------------------------------- For n = 0 To NO A(i, j) = A(i, j) +
X(n, i) * X(n, j) Next n '------------------------------------------------------- ' Remplissage de la partie inférieure
de la matrice '------------------------------------------------------- A(j, i) = A(i, j) ' Next j Next i |
Encadré 2 : Construction de la
matrice
La matrice A construite, il nous faut maintenant l’inverser.
L’approche utilisée par Clopper Almon, fonctionne dans le cas où une constante est présente. Cette approche est particulièrement intéressante car elle prête une attention particulière à ce que représente chaque opération dans le processus de Gauss-Jordan. Cette analyse va nous conduire à sauvegarder au cours du processus un ensemble de résultats qui n’auront pas à être recalculés une fois la matrice inverse calculée.
Pour illustrer notre propos, nous reprenons l’exemple du chapitre 2.
|
Matrice X |
Colonne Y |
Ecart à la moyenne |
|||||
X1 |
X2 |
X3 |
|
|
||||
1 |
1 |
10 |
5 |
17 |
0 |
5 |
0 |
2 |
2 |
1 |
5 |
1 |
10 |
0 |
0 |
-4 |
-5 |
3 |
1 |
0 |
6 |
12 |
0 |
-5 |
1 |
-3 |
4 |
1 |
10 |
3 |
16 |
0 |
5 |
-2 |
1 |
5 |
1 |
0 |
10 |
20 |
0 |
-5 |
5 |
5 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Tableau 1 |
5 |
25 |
25 |
75 |
|
|
|
25 |
225 |
85 |
380 |
|
|
|
|
25 |
85 |
171 |
415 |
|
|
|
|
75 |
380 |
415 |
1189 |
|
|
|
|
Tableau 2 |
1 |
5 |
5 |
15 |
|
|
|
0 |
100 |
-40 |
5 |
100 |
-40 |
5 |
|
0 |
-40 |
46 |
40 |
-40 |
46 |
40 |
|
0 |
5 |
40 |
64 |
5 |
40 |
64 |
|
Tableau 3 |
1 |
0 |
7 |
14.75 |
|
|
|
0 |
1 |
-0.4 |
0.05 |
|
|
|
|
0 |
0 |
30 |
42 |
|
|
|
|
0 |
0 |
42 |
63.75 |
|
|
|
|
Tableau 4 |
1 |
0 |
0 |
4.95 |
|
|
|
0 |
1 |
0 |
0.61 |
|
|
|
|
0 |
0 |
1 |
1.40 |
|
|
|
|
0 |
0 |
0 |
4.95 |
|
|
|
'-------------------------------------------------------------- ' Inversion de la matrice
X'X "augmentée" '-------------------------------------------------------------- ' For i = 0 To NVI '---------------------------------------------------------- ' Initialisation du pivot de la ligne '---------------------------------------------------------- Pivot = A(i, i) '---------------------------------------------------------- ' Division du pivot de la ligne par
lui-même '---------------------------------------------------------- A(i, i) = 1 '----------------------------------------------------------- ' Division du pivot élément par le pivot
ligne '----------------------------------------------------------- For k = 0 To NC If Pivot <> 0 Then A(i, k) = A(i, k) /
Pivot Else Debug.Print "Le pivot est
pour la variable " & i & _ ". Le programme
est arrété." End End If Next k '----------------------------------------------------------- ' Réduction des lignes non pivot '----------------------------------------------------------- For j = 0 To NC '------------------------------------------------------- ' Sauter la ligne pivot '------------------------------------------------------- If i <> j Then ' ' ' AJI = A(j, i) ' ' ' A(j, i) = 0# ' For k = 0 To NC A(j, k) = A(j,
k) - A(i, k) * AJI '----------------------------------------------- ' Récupération des valeurs
des moyennes et ' des variances-covariances. '----------------------------------------------- If
i = 0 Then If k = 0
Then Temp(0,
k) = 1# Temp(j,
k) = -A(j, k) Else Temp(0, k) = 0# Temp(j,
k) = A(j, k) End If End If '----------------------------------------------- ' Récupération de la Variance
de Y '----------------------------------------------- If (j = NC) And
(k = NC) Then TempS(i)
= A( End If ' Next k End If Next j Next
i |
Encadré 3 : Le code en Visual basic de l’inversion de la
matrice A dans Regression.
Bibliographie
Webographie
Annexe 1
Le code du sous-programme Regression
21/02/2003
Public Sub Regression(X() As Double) ' '---------------------------------------------------------------------------------------- ' Regression - Moindres carrés ordinaires avec constante '---------------------------------------------------------------------------------------- ' ' Ce programme de régression est tiré de : ' '
Almon Clopper (1967), "Matrix in economics", Addison Wesley,
' Chapiter 1-3, pp. 1-57. ' ' Il s'agit ici d'une version écrite en utilisant le langage de programmation '
Visual Basic 6 de Microsoft. ' '---------------------------------------------------------------------------------------- ' ' NVI : Nombre de variables indépendantes (NIV number of independant variables in Almon) ' NC : NVI + 1, colonne de X contenant la variable à expliquée. ' NO : Nombre d'observations (idem dans Almon) ' ' ' '---------------------------------------------------------------------------------------- ' © 2003 - Paul Salmon '---------------------------------------------------------------------------------------- ' ' Déclarations locales ' Dim NVI As Long ' Nombre de Variables Indépendantes Dim NO As Long ' Nombre d'Observations Dim NC As Long ' Nombre de colonnes de la matrice X (NVI + 1) Dim NCR As Long ' Dim NOR As Long ' Dim NVIR As Long ' Dim A() As Double ' Matrice contenant les résultats des calculs ' intermédiaires et terminal de la matrice inverse ' de X'X augmentée Dim Temp() As Double ' Dim Pivot As Double ' Valeur du pivot Dim AJI As Double ' Dim DP() As Double ' Dim TempS() As Double ' Dim NorRes() As Double ' Dim SY2 As Double ' Dim SR2 As Double ' Dim SEE As Double ' Dim R2 As Double ' Dim RBSQR As Double ' Dim s2 As Double ' Dim SigmaCoef() As Double ' Dim tstudent() As Double ' Dim Beta() As Double ' Dim Elasticity() As Double ' Dim Mean() As Double ' Dim FTest ' Dim nobs As Long ' Dim DoFree As Long ' Dim YHAT() As Double ' Dim Resid() As Double ' Dim DW As Double ' Dim Dim lresid As Double ' Dim somme1 As Double ' Dim errp1 As Double ' Dim SEEP1 As Double ' Dim Mexval() As Double ' Dim MAPETEMP As Double ' Dim MAPE As Double ' Dim i As Long ' Indice de boucle Dim j As Long ' Indice de boucle Dim k As Long ' Indice de boucle Dim n As Long ' Indice de boucle Dim LigneCoeff As String ' Dim LignePD As String ' Dim LigMatVarCorCoef As String ' ' ReDim RegData(0 To UBound(X, 1), 0
To 3) ' ' Initialisation des variables ' NC = UBound(X, 2) ' NVI = NC - 1 ' NO = UBound(X, 1) ' ' NCR = NC + 1 ' NVIR = NVI + 1 ' NOR = NO + 1 ' ' 'Debug.Print "NC = "
& NC & " NVI = " & NVI & " NO = " &
NO ' ' Dimensionnement des Vecteurs et tableaux ' ReDim A(0 To NC, 0 To NC) ' ReDim Beta(0 To NVI) ' ReDim DP(0 To NC, 0 To NC) ' ReDim Elasticity(0 To NVI) ' ReDim MatCrossCorr(0 To NC, 0 To
NC) ' ReDim MatVarCovCoef(0 To NVI, 0 To
NVI) ' ReDim Mean(0 To NC) ' ReDim Mexval(0 To NVI) ' ReDim NorRes(0 To NVI) ' ReDim PD(0 To NVI, 0 To NVI) ' ReDim Resid(0 To NO) ' ReDim SigmaCoef(0 To NVI) ' ReDim Temp(0 To NC, 0 To NC) ' ReDim TempS(0 To NVI) ' ReDim tstudent(0 To NVI) ' ReDim YHAT(0 To NO) ' ReDim Coef(0 To NVI, 0 To 8) ' ReDim StatReg(0 To 10) ' '---------------------------------------------------------------------------------------- ' Construction de la Matrice X'X augmentée '---------------------------------------------------------------------------------------- ' For i = 0 To NC
For j = 0 To NC ' ' Initialisation à 0. de l'élément (i,j) de A ' A(i, j) = 0# ' ' Calcul de la matrice symétrique X'X ' For n = 0 To NO A(i, j) = A(i, j) + X(n, i) *
X(n, j) Next n ' ' Remplissage de la partie inférieure de la matrice ' A(j, i) = A(i, j) '
Next j Next i ' '---------------------------------------------------------------------------------------- ' Inversion de la matrice X'X "augmentée" '---------------------------------------------------------------------------------------- ' For i = 0 To NVI ' ' Initialisation du pivot de la ligne ' Pivot = A(i, i) ' ' Division du pivot de la ligne par lui-même ' A(i, i) = 1 ' ' Division du pivot élément par le pivot ligne '
For k = 0 To NC If Pivot <> 0 Then A(i, k) = A(i, k) / Pivot Else Debug.Print "Le pivot est pour la variable " & i & ". Le programme est arrété." End End If Next k ' ' Réduction des lignes non pivot ' For j = 0 To NC ' ' Sauter la ligne pivot ' If i <> j Then ' ' ' AJI = A(j, i) ' ' ' A(j, i) = 0# ' ' ' For k = 0 To NC A(j, k) = A(j, k) - A(i, k) *
AJI ' ' Récupération des valeurs des moyennes et des variances-covariances. ' If i = 0 Then If k = 0 Then Temp(0, k) = 1# Temp(j, k) = -A(j, k) Else Temp(0, k) = 0# Temp(j, k) = A(j, k) End If End If ' ' Récupération de la Variance de Y ' If (j = NC) And (k = NC) Then TempS(i) = A( End If ' Next k End If
Next j Next i ' '---------------------------------------------------------------------------------------- ' Calculs des diverses matrices et statistiques de diagnostic '---------------------------------------------------------------------------------------- ' ' Dérivées partielles de la régression ' 'Debug.Print "Dérivées partielles des coefficients" 'Debug.Print
"------------------------------------" & vbCrLf For i = 0 To NVI
For k = 0 To i For j = 0 To i PD(k, j) = A(j, k) / A(j, j) 'Debug.Print "PD(" & k
& ", " & j & ") = " & PD(k, j) Next j
Next k Next i ' ' Matrice de corrélation ' For i = 1 To NC
For j = 1 To NC If i = j Then MatCrossCorr(i, j) = 1# Else MatCrossCorr(i, j) = Temp(i, j) /
(Sqr(Temp(i, i) * Temp(j, j))) End If
Next j Next i ' ' Pour faciliter la lecture des formules. ' SR2 = TempS(NVI) SY2 = TempS(0) ' ' Standard Error of Estimate ' ' Cas Particulier suivant les directives de Clopper Almon. ' SEE = Sqr(SR2 / NOR) ' ' Calcul du R2 ' R2 = 1 - (SR2 / SY2) ' ' Calcul RBSQ ' RBSQR = 1 - ((SR2 / (NOR - NVIR))
/ (SY2 / (NOR - 1))) ' ' Ecart-tye des résidus ' s2 = SR2 / (NOR - NVIR) ' ' Calcul de la matrice de Variance-covariance des coefficients ' For i = 0 To NVI
For j = 0 To NVI MatVarCovCoef(i, j) = s2 * A(i, j)
Next j Next i ' ' Nombre d'observations ' nobs = NO + 1 ' ' Degrés de liberté ' DoFree = nobs - NVI - 1 ' ' Calcul de l'écart-type des coefficients et du t-student ' For i = 0 To NVI
'
' Coefficients
'
Coef(i, 0) = A(i, NC)
'
' MexVal
'
Coef(i, 1) = 100 * (Sqr(1 + (A(i, NC) ^ 2 / (A(i, i) * A(
Mexval(i) = 100 * (Sqr(1 + (A(i, NC) ^ 2 / (A(i, i) * A( ' ' Elasticité par rapport à la moyenne '
Coef(i, 2) = A(i, NC) * (Temp(i, 0) / Temp(NC, 0))
Elasticity(i) = A(i, NC) * (Temp(i, 0) / Temp(NC, 0)) ' ' NorRes ' Coef(i, 3) = TempS(i) / TempS(NVI) NorRes(i) = TempS(i) / TempS(NVI) ' ' Ecart-Type du coefficient '
Coef(i, 4) = Sqr(MatVarCovCoef(i, i))
SigmaCoef(i) = Sqr(MatVarCovCoef(i, i)) ' ' Moyenne de la variable '
If i = 0 Then Mean(i) = 1#
Else Mean(i) = Temp(i, 0)
End If
Coef(i, 5) = Mean(i)
'
' Beta
'
Coef(i, 6) = A(i, NC) * (Sqr(Temp(i, i)) / Sqr(Temp(
Beta(i) = A(i, NC) * (Sqr(Temp(i, i)) / Sqr(Temp( ' ' T de Student du coefficient '
Coef(i, 7) = A(i, NC) / SigmaCoef(i)
tstudent(i) = A(i, NC) / SigmaCoef(i)
'
' Fisher
'
Coef(i, 8) = (R2 / (1 - R2)) * ((NOR - NVIR) / (NVIR - 1))
FTest = (R2 / (1 - R2)) * ((NOR - NVIR) / (NVIR - 1)) Next i ' ' YHAT, valeur calculée de Y ' For j = 0 To NVI
For i = 0 To NO YHAT(i) = YHAT(i) + (A(j, NC) * X(i,
j)) Next i ' ' Calcul des résidus ' For i = 0 To NO Resid(i) = X(i, NC) - YHAT(i)
Next i Next j ' ' MAPE ' For i = 0 To NO
MAPETEMP = MAPETEMP + Abs(Resid(i) / X(i, NC)) Next i MAPE = 100 * (MAPETEMP / NOR) ' ' ' For i = 0 To NO - 1
DW = DW + (Resid(i) - Resid(i + 1)) ^ 2 Next i DW = DW / SR2 ' ' SEE+1 ' lresid = 0# For i = 0 To NO
errp1 = Resid(i) -
somme1 = somme1 + errp1 * errp1
lresid = Resid(i) Next i SEEP1 = Sqr(somme1 / (NO + 1)) ' ' Impression "scalaire" ' StatReg(0) = SEE StatReg(1) = R2 StatReg(2) = StatReg(3) = nobs StatReg(4) = 1 StatReg(5) = SEEP1 StatReg(6) = RBSQR StatReg(7) = DW StatReg(8) = DoFree StatReg(9) = NO + 1 StatReg(10) = MAPE ' ' 0 : les numéros des observations ' 1 : Les observations de Y ' 2 : Les observations de Yhat ' 3 : Les observations des résidus ' For i = 0 To UBound(X, 1)
RegData(i, 0) = i + 1
RegData(i, 1) = X(i, NC)
RegData(i, 2) = YHAT(i)
RegData(i, 3) = Resid(i)
Debug.Print RegData(i, 0) & " " & RegData(i, 1)
& " " & RegData(i, 2) & " " & RegData(i,
3) Next i 'Debug.Print "MeanY = "
& Temp(NC, 0) ' 'Debug.Print "Sigma = " & s2 ' 'Debug.Print "SigmaY = "
& Sqr(Temp( ' '---------------------------------------------------------------------------------------- ' Fin du sous-programme de régression. '---------------------------------------------------------------------------------------- ' End Sub |
[1] Si
vous êtes un utilisateur de produit comme Word ou encore Excel vous êtes donc
un utilisateur d’interface de type MDI. Dans une MDI vous avez la possibilité
de faire ouvrir simultanément des
feuilles qui s’ouvrent dans une fenêtre.
[2] VBA signifie Visual Basic
Application. Avec les diverses versions du pack Office et de Visual
Basic, il n’y a plus de differences enr VBA et VB. Seules des mises en garde
dans l’approche (on est déjà dans l’application ou non) constituent des différences.
Il n’est pas très difficile d’y remédier.
[3] Nous rappelerons simplement que des outils comme SPSS, Stata, SygmaPlot, ou encore plus récemment SAP se sont engagés dans cette direction du Visual basic.
[4] Pour les étudiants ayant des difficultés avec le calcul matriciel, ils pourront se reporter aux divers manuels déjà cités. Un chapitre y est généralement. Ils consulteront avec profit la note de méthode sur les moindres carrés ordinaires.
[5] Almon Clopper Jr (1967), « Matrix methods
in economics », Addison-Wesley,
[6] Le pseudocode est un langage utilisé pour décrire les étapes individuelles des algorithmes. Pour plus de détail, le lecteur se reportera à la note sur le pseudocode.