1

STATA POUR LES NULS

Olivier Cadot
Juin 2012


Contents
Comment mal dmarrer : leon un...................................................................................... 3
Do- et log-files ................................................................................................................ 3
Garbage in, garbage out : Formatage de loutput ........................................................... 6
Manipuler des donnes : comment faire du faux avec du vrai ........................................... 6
Importer des donnes ...................................................................................................... 7
Trier les variables et les maltraiter .................................................................................. 9
Gnrer des expressions vides de sens.......................................................................... 11
Moyenne, cart-type, max et min ............................................................................. 11
Compter les sous-catgories lintrieur de catgories ............................................ 12
Variables alatoires ................................................................................................... 12
Variables en diffrences et retardes (mentales) .......................................................... 16
Variables muettes, aveugles et idiotes .......................................................................... 16
Variables en string ........................................................................................................ 17
Mettre le string et lenlever ....................................................................................... 17
Manipuler des variables en string ............................................................................. 18
Fusionner des fichiers ................................................................................................... 20
Fusion horizontale ............................................................................................... 20
Fusion verticale ................................................................................................... 22
Variables avec indices (boucles) ................................................................................... 23
Principe gnral ........................................................................................................ 23
Itrations ....................................................................................................................... 24
Boucles sur des observations .................................................................................... 25
Matrices et vecteurs ...................................................................................................... 25
Mettre une matrice en vecteur-colonne..................................................................... 25
Mettre un vecteur-colonne en matrice ...................................................................... 27
Multiplier une matrice par un vecteur ....................................................................... 28
Cylindrer un panel......................................................................................................... 29
Un peu de programmation pour les ado ............................................................................ 30
Programme .................................................................................................................... 30
Fichiers ado ................................................................................................................... 30
If/else............................................................................................................................. 31
While ............................................................................................................................. 33
Estimation : quelques bidouillages ................................................................................... 33
Sauvegarder des rsultats, mme quand ils sont absurdes ............................................ 33
Sauvegarder des statistiques descriptives ................................................................. 33
2
Sauvegarder valeurs prdites et rsidus .................................................................... 33
Sauvegarder des coefficients absurdes ...................................................................... 33
Estimation ..................................................................................................................... 36
OLS and WLS ........................................................................................................... 36
Panels ........................................................................................................................ 36
Sure ........................................................................................................................... 37
2sls ............................................................................................................................ 37
GMM......................................................................................................................... 38
Variables dpendantes limites ................................................................................. 39
Switching reg ............................................................................................................ 42
Propensity score matching ........................................................................................ 42
Analyse de survie ...................................................................................................... 45
Graphiques ........................................................................................................................ 49
Graphiques avec courbes ou barres ............................................................................... 50
Nuages de points ........................................................................................................... 51
Regressions non paramtriques ( smoother reg ) ...................................................... 55
Enqutes sur les scnes de mnages ................................................................................. 56
Statistiques descriptives et manipulation de donnes ................................................... 56
Moyennes, totaux et corrlations .............................................................................. 56
Calculer des indices dingalit ................................................................................ 58
Densits ..................................................................................................................... 58
Effet de changements de prix par tranche de revenu .................................................... 59
Estimation sur des enqutes .......................................................................................... 62
Modles de slection ................................................................................................. 62
Quelques trucs en Mata ..................................................................................................... 64






3
Comment mal dmarrer : leon un

I think there is a world market for about five computers.
Thomas J. Watson
Chairman of the Board, IBM.
1


Do- et log-files
Ds les premires manipulations malheureuses, il faut regrouper toutes les erreurs, y
compris celles qui mettent les donnes dfinitivement cul par-dessus tte, dans un
(dont)-do-file avec le do-file editor de Stata qui est ici :














A la fin, le fichier en question (ou la squence de fichiers) doit prendre les donnes de
base et garantir la traabilit totale de toutes les neries que vous avez faites. Cest
seulement ainsi que vous saurez pourquoi vous avez des rsultats absurdes depuis six
mois. Les premires commandes du do-file devraient tre


1
http://www.gocreate.com/QuotAmaze/qlun.htm. Cit dans le manuel de reference de Shazam v.8,
McGraw-Hill, 1997. Il faut prciser que la citation est de 1943.
4



Explication des commandes de dpart :
clear vide la mmoire

#delimit ; dfinit le symbole que Stata comprendra comme la fin dune commande ;
par dfaut, cest un retour la ligne (quon retrouve avec #delimit cr); utile si on a des
commandes trs longues et quon souhaite revenir la ligne pour pouvoir tout lire
lcran ; par contre, il ne faudra plus loublier la fin de toutes les commandes. Si on
choisit cette syntaxe, les lignes de commentaires doivent tre crites comme

* commentaire ;

Alternativement, si on veut crire sans point-virgule, les commentaires scrivent

// commentaire

et les commandes longues peuvent tre casses en plusieurs lignes avec /// :

dbut de la commande ///
suite de la commande
commande suivante

Attention il faut imprativement un espace avant ///.

Le bloc de commandes

cd d:\Papiers\paperdir ;
cap chdir d:\Papiers\Paperdir ;
local path d:\Papiers\Paperdir ;

indique Stata de se mettre sur le rpertoire d:\Papiers\paperdir et de sen souvenir.
La commande set mem est inutile partir de Stata 12. Le bloc de commandes

local pathdata d:\Papiers\Paperdir\data ;
5
local pathdo d:\Papiers\Paperdir\dofiles ;
local pathresult d:\Papiers\Paperdir\results ;

met dans sa mmoire des sentiers qui mnent vers trois rpertoires (quil aura bien sr
fallu crer avant dans le file manager) : data, o on met les donnes, dofiles o on met les
programmes, et results o on met les rsultats. Ce dpart permet de garder la suite dans
un semblant dordre. On pourra alors se rfrer ces sentiers sous forme abrge ; par
exemple, on appelle le fichier donnes par la commande

use `pathdata\datafile.dta ;

au lieu de mettre tout le sentier. Ne pas oublier de mettre les guillemets comme ils sont
(noter le sens !).

set logtype text ; enregistre le fichier log sous format texte au lieu dun format
Stata (par dfaut)

capture log close ; permet au programme de sarrter sans bug mme si, par
exemple, on linterrompt par /* sans refermer linterruption par */ avant log close (qui
signale la fin). en fait, capture est galement utile devant dautres commandes sensibles
pour viter des bugs. Ceci dit a bugge quand mme ; par exemple, chaque fois quun do-
file est interrompu par une erreur, le log ne se ferme pas et on a la fois suivante un
message derreur log file already open .

set more off ; permet a tout le programme de se drouler sur lcran

log using filename.log, replace ; cre un fichier log nomm filename ; si ce nom
de fichier existe dj replace remplace lancien par ce nouveau fichier log

log close ; ferme le fichier log;

La commande save datafile1.dta est trs importante : elle sauvegarde le fichier-
donnes (.dta) modifi par le programme sous un autre nom que le fichier initial, ce qui
permet de laisser ce dernier intouch. Sinon on altre le fichier initial de faon
permanente, ce qui est en gnral un dsastre.

De faon gnrale, les guillemets (comme dans cd c:\path\directory) sont
obligatoires quand les noms spcifis ne sont pas lis en un seul mot ; par exemple, Stata
comprend use le nom que je veux.dta mais pas use le nom que je
veux.dta.

Si on a fait une srie de commandes sans do-file (ce qui une mauvaise ide, trs souvent)
et que tout dun coup on voudrait pouvoir les reproduire, on peut crer un log file aprs
coup avec

log using filename.log
# review x
log close
6

ce qui va imprimer, dans le nouveau log file cr, les x dernires commandes (autant que
lon veut).

Sur un Mac, la syntaxe pour les sentiers nest pas tout fait la mme puisque le systme
dopration est fond sur Unix et non sur le DOS. Pour ouvrir un fichier, on tape :

use "/Users/admin/Documents/subdirectory/filename.dta"

Les commandes sadaptent facilement :

cd /Users/admin/Documents/subdirectory
local pathdata /Users/admin/Documents/subdirectory/data

etc. Les gros fichiers peuvent tre compresss par la commande

compress x y z

Il faut mettre toute la liste de variables et on peut rduire dun tiers au moins la taille du
fichier sans perte dinformation bien sr.

Garbage in, garbage out : Formatage de loutput
Si lon veut que les variables apparaissent dans loutput sous un autre nom (par exemple
sous un nom plus simple) que celui donn par le dingue qui a fait les premires
manipulations de donnes, et ceci tout en prservant le nom original des variables, on
utilise la commande label comme ceci :

label variable lnparcellesexpl land ;

Manipuler des donnes : comment faire du faux avec du
vrai

When the President does it, that means it is not illegal.
Richard Nixon
2


Un petit prambule. Pourquoi manipuler les donnes en Stata et pas en Excel ? La raison
est simple : pas mal des commandes que lon va voir ci-dessous existent aussi en Excel et
sont certes quelquefois plus simples (si on arrive les trouver), mais par contre on perd
vite le fil de ce que lon a fait subir aux donnes avant de passer lestimation, et cest
parfois l que se cachent soit les quelques erreurs lorigine de rsultats grotesques soit,
au contraire, les mauvais traitements infligs aux chiffres pour obtenir le rsultat dsir.

2
Citation encore trouve dans le manuel de Shazam, p. 51.
7
Avec Stata, on peut garder la trace de toutes les manipulations dans le do-file. Celui-ci
doit contenir toutes les commandes permettant de passer du fichier-donnes brut celui
qui est prt lestimation. Il est alors facile de retrouver lerreur qui tue ou bien de
vrifier ce que les chiffres ont subi entre les mains du bourreau avant davouer.

Importer des donnes
On peut copier-coller partir dexcel, mais cest trop facile. Supposons que lon veuille
importer un fichier-donnes avec la tte suivante :



Horrible voir, nest-il pas. Mais tout va se passer dans la bonne humeur. On commence
par

insheet using mali_hs6.TXT

et le fichier vient tout gentiment. Puis on se dbarrasse de toutes les cochonneries dont on
na pas besoin et on renomme la variable tradevalue000 tv ce qui, vous en
conviendrez, est plus commode :

keep reporter year product tradevalue000 product
rename tradevalue000 tv

ce qui donne ceci :



8
Nettement plus clair. Par contre, observez le monstre tapi dans lombre : la ligne 11544,
la variable tv a une virgule pour les milliers. Cette virgule va profondment perturber
stata et il faut tout prix sen dbarrasser. A la bonne heure ! Rien de plus facile. On tape

split tv, parse(,)
egen export = concat(tv1 tv2)

et le tour est jou. Il ny a plus de virgule (on a cass la variable autour de la virgule
puis on a runi les deux parties, nommes automatiquement tv1 et tv2 par stata, sans la
virgule). Notez dailleurs que linterdiction des virgules dans les nombres est une preuve
(de plus) du complot anglo-saxon pour tuer la culture franaise.

Pour viter de passer par excel qui nadmet que 65'000 observations et met
automatiquement les variables chiffres (genre classification hs) en mode numrique, ce
qui limine inopportunment les zros du dbut, on peut tlcharger les donnes en
spcifiant quon les veut spares par des espaces pour pouvoir utiliser infile au lieu de
insheet (qui nadmet pas quon spcifie un format string pour certaines variables). Il
faut commencer par sauvegarder le fichier donnes en ASCII (en lui donnant lextension
.txt). Si la premire variable est hs8 par exemple et doit tre en string et la deuxime
est value , la commande est alors

Infile str10 hs8 value using path/filename.txt.

On note que les sries de quantits physiques doivent tre tlcharges avec un dlimiteur
(tab, point-virgule) mais surtout pas des espaces car la dfinition des units est
quelquefois forme de plusieurs mots, ce qui produit un galimatias.

Pour contrler la faon dont stata formate les variables dans le data editor, on tape
quelque chose comme

format firm_name %15s

pour les string, o % contrle le formattage, 15 donne le nombre despaces dans la
colonne (plus il y en a plus elle est large), un moins (optionnel) aligne les entres
gauche dans la colonne, et le s est pour string. Voir aussi la section Mettre le string et
lenlever . Si cest des donnes numriques, on tape

format var %11.3f

o 11 donne le nombre de chiffres gauche de la virgule, 3 donne le nombre de
dcimales, et f impose la notation dcimale (par opposition la notation scientifique).

9
Trier les variables et les maltraiter
Les maniaco-dpressifs tendance paranoaque dsirent parfois voir les variables
apparatre sur lcran dans un certain ordre, de gauche droite. Cest totalement futile
mais si cest votre cas, ne vous privez pas : il suffit de taper

order x y z

On trie les variables (verticalement, en fonction de leurs observations) par sort ou
gsort. La premire ne peut les trier que par ordre ascendant, alors que la seconde peut les
trier par ordre ascendant ou descendant. Pour trier une variable x par ordre descendant, on
ajoute un signe devant la variable, par exemple

gsort x

Pour gnrer une variable t indexant les observations (par exemple le temps), la
commande est

gen t=_n

Pour modifier des valeurs ou des groupes de valeurs dans une variable, on utilise la
commande recode. Par exemple,

recode x .=0
recode y 1/12 = 1

changent toutes les valeurs manquantes dans x ( . ) en 0 et toutes les valeurs de y
comprises entre 1 et 12 en 1, respectivement. Cela fonctionne aussi avec un if.
Attention distinguer les commandes recode et replace. recode x .=value
semploie si on veut remplacer x par une constante (ici value) quand x est gale une
certaine valeur (ici une valeur manquante). La commande

replace x=log(x) if x!=0

semploie si on veut remplacer la variable x par une variable (ici son log), ventuellement
quand x satisfait une condition (ici, nest pas gale 0 ). Noter la syntaxe lgrement
diffrente. Pour renommer simplement une variable, cest

rename year81 yr81

Si lon veut additionner deux variables, x et y, qui ont des valeurs manquantes, la
commande

gen z = x + y

10
va gnrer une nouvelle variable qui aura une valeur manquante pour chaque observation
o soit x soit y a une valeur manquante. Pour viter cela, utiliser la commande rsum avec
egen (extensions plus labores de la commande gen):

egen z = rsum(x y)

qui traitera les valeurs manquantes comme des zros. (On peut utiliser des commandes
similaires pour dautres fonctions comme rmean, rmax, rmin ; toutes avec egen et toutes
sans virgules dans la parenthse). Si on veut faire la somme des observations dune
variable et non pas une somme de variables, la commande est:

egen sumx = sum(x)

Pour faire des manipulations sur les observations dune variable x, les suffixes sont [_n],
[_n-1], etc. Supposons que lon veuille vrifier si un code (disons hs8) nest pas rpt
(cest--dire quon na pas deux entres pour le mme code). On compte ces doublons
possibles avec la commande

count if hs8==hs8[_n-1]

Sinon, llimination des doublons complets (deux observations ayant les mmes valeurs
pour toutes les variables dans la base de donnes) la commande est

duplicate drop

Quand il ny a pas assez derreurs dans les donnes, on peut en fabriquer en interpolant et
en extrapolant linairement avec la commande ipolate:

ipolate x year, gen(new_x)

Loption gen (obligatoire) gnre une nouvelle variable au lieu dcraser lancienne (non
interpole) ce qui permet de vrifier si le rsultat a du sens ou pas. En ajoutant loption
epolate, on interpole et on extrapole :

ipolate x year, gen(new_x) epolate

En panel avec une variable dindividus, disons individual, on ajoute by individual

by individual : ipolate x year, gen(new_x) epolate

Les statistiques descriptives sont gnres par sum x ( sum pour summarize, pas
somme). Pour leur sauvegarde voir la section Estimation/Sauvegarder des rsultats. On
peut utiliser aussi codebook pour avoir une ide plus complte de la distribution dune
variable ; en particulier pour savoir combien de valeurs distinctes elle prend.


11
Gnrer des expressions vides de sens
Moyenne, cart-type, max et min
Pour crer des nouvelles variables (constantes) gales respectivement la moyenne, la
mdiane, lcart-type, le minimum ou le maximum dune variable existante, les
commandes sont

egen x_bar = mean(x)
egen x_med = pctile(x)
egen x_sd = sd(x)
egen maxy = max(y)
egen miny = min(y)

Ne pas oublier quil sagit dun egen et non dun gen.

Si lon a n variables, x
1
x
n
, (dont on va appeler lnumration sans virgule varlist) et
que lon veut exporter la matrice des corrlations, voici la squence de commandes :

corr varlist
mat c = r(C)
svmat c
outsheet varlist using filename

ce qui donne un fichier .out qui peut tre import en Excel.

Max de deux variables (i.e. la plus grande des deux)

Pour crer une expression du style { } max , y x c = o c est une constante, la commande
est

gen y=x if x>=c
recode y .=c

La premire ligne cre des valeurs manquantes dans y quand x c < . La deuxime
remplace ces valeurs manquantes par c. Attention, cependant : si la variable x a dj elle-
mme des valeurs manquantes, celles-ci seront codes par Stata comme 999 dans sa
petite tte et vont alors tre interprtes comme de grandes valeurs de y et rendues gales
la constante. Le problme est alors de prserver les valeurs manquantes comme telles,
par exemple en adoptant une convention ad hoc:

recode x .=-989898
gen y=x if x>=c & x !=-989898
recode y .=c

12
Compter les sous-catgories lintrieur de catgories
Supposons que lon ait une catgorie large x, lintrieur de laquelle on a une sous-
catgorie y, et que lon veuille avoir une nouvelle variable indiquant, pour chaque x,
combien il y a de valeurs diffrentes de y (par exemple, combien de produits par firme).
Il y a plusieurs faons de le faire, mais une faon simple consiste compter les
changements de valeur de y (avec un by x)

bysort x: egen nbry = count(y == y[_n-1])

Plus compliqu: supposons que lon ait deux sous-catgories, y et z, variant lintrieur
de x (par exemple des produits et des destinations). On veut avoir maintenant deux
variables caractrisant chaque x: combien de valeurs diffrentes de y et combien de
valeurs diffrentes de z.

Pour y, on fait

* Number of y per x

sort x y
by x: gen newy = (y != y[_n-1])
by x: egen nbry = sum(newy)

Pour z, cest symtrique:

* Number of z per x

sort x z
by x: gen newz = (z != z[_n-1])
by x: egen nbrz = sum(newz)
Variables alatoires
Pour gnrer une variable alatoire dune distribution uniforme, la commande est

gen x=uniform()

pour une variable x avec une distribution uniforme sur un intervalle unitaire. set seed
donne la valeur avec laquelle Stata va commencer lalgorithme de gnration de
nombres pseudo-alatoires. Par dfaut, Stata prend ce chiffre sur la montre de
lordinateur ; set seed est donc ncessaire seulement si lon veut pouvoir reproduire
exactement les rsultats.

Stata peut gnrer des variables alatoires de distributions autre que la distribution
uniforme. Pour cela, il utilise la fonction quantile qui est linverse de la distribution
cumulative : si F(x) = u alors u = Q(x). Pour gnrer une variable tire dune distribution
normale, Stata gnre dabord une variable uniforme u, puis gnre x avec la fonction Q,
comme le montre la Figure 1 dans laquelle les u sont 0.1, 0.3,, 0.9 et les x gnrs
13
graphiquement par la courbe F(.). On voit dans le graphique du dessus que leur frquence
correspond (bien logiquement) la densit normale.

14
Figure 1
Gnration dune variable normale par Stata


































Les commandes pour gnrer cent observations dune variable tire dune distribution
standard normale centre sur zro sont donc

set obs 100
gen u=uniform()
gen x=invnorm(u)

o invnorm est la fonction quantile gaussienne ; ou bien, tout simplement,

gen x=invnorm(uniform())

u = F(x)
x = Q(u)
Distribution
uniforme
des u
u = F(x)
x = Q(u)
Distribution
uniforme
des u
15
Stata peut galement gnrer des variables alatoires tires dautres distributions (gamma
etc.). Par exemple pour gnrer une variable alatoire non-ngative tire dune
distribution Gamma avec paramtre 1, cest

gen u=uniform()
gen x=invgammap(1,u)

Pour les distributions qui ne sont pas pr-programmes, on peut rentrer directement la
forme algbrique de la fonction quantile (quand on la connat) dans la troisime ligne. Par
exemple, pour gnrer les dates de 100 vnements tirs dun processus dans lequel le
temps dattente entre deux vnements suit une distribution de Weibull avec paramtre p
= 3, on utilise la fonction quantile de Weibull ( ) ( )
1/
ln 1
p
Q u u = (

pour crire

set obs 100
gen u=uniform()
gen t=(-ln(1-u))^(1/3)

o t la date alatoire de chacun des 100 vnements observs.

Pour gnrer deux variables tires dune distribution gaussienne bivarie avec un
coefficient de corrlation de son choix, la commande est

matrix C = (1.0, ///
0.5, 1.0)
drawnorm u v, corr(C) cstorage(lower) seed(1.0)

La matrice C donne les corrlations sous la forme dune matrice triangulaire infrieure
(ici le coefficient de corrlation est 0.5), ce qui est indiqu Stata par loption
cstorage(lower) ; et la commande optionnelle seed(1.0) permet de gnrer le
mme vecteur de variables alatoires chaque tirage.

Les excits de la gravit (qui se reconnaitront) peuvent gnrer une variable alatoire de
type zero-inflated Poisson , par exemple pour faire des simulations, avec la srie de
commandes suivante
3
:

clear
set obs 1000
gen x = uniform()
gen u = x
local lambda = 10
local p0 = .4
local cp = 0
local n = 0
while `cp'<=.99999 {
local p = `p0'*(`n'==0) + ///
(1-`p0')*exp(-1*`lambda')*(`lambda'^`n')/exp(lnfactorial(`n'))
local cp= `cp'+`p'
local pcp = `cp'-`p'

3
Source: http://www.ats.ucla.edu/stat/stata/code/discrete_rv_v2.htm
16
quietly recode x (`pcp'/`cp' = `n')
local n = `n' + 1
}

Variables en diffrences et retardes (mentales)
On gnre les premires diffrences dune variable x par la commande gen dx = D.x et
des lags par la commande gen lx = L.x. Mais dabord il faut dclarer lchantillon soit
comme une srie temporelle par la commande

tsset year

(si year est la variable qui indice le temps) soit comme un panel par la commande

xtset ind year

o ind est la variable marquant les individus (toujours dans cet ordre). Attention quand
les individus sont marqus par des strings Stata va couiner. Pour le calmer il va falloir
taper

egen newind = group(ind)
xtset newind year
sort newind year
gen dx = D.x
gen lx = L.x

cest--dire quil ny a plus besoin de lui dire by ind pour le D.x (ou pour le L.x) il
va comprendre tout seul dans sa petite tte.

Variables muettes, aveugles et idiotes
Pour gnrer une variable muette gale 1 quand flowname est Export (et 0 quand
flowname nest pas Export), la commande est

gen export=(flowname==Export)

Attention, Stata distingue les majuscules. Si la vraie variable est export et non
Export la commande renverra un message derreur.

Pour gnrer une variable muette quon veut appeler dummy partir dune variable
numrique x (gale 1 quand x est gale value1 ou
4
value2 et 0 sinon) la commande est

gen dummy=(x==value1 | x==value2)

4
Le signe | nest pas toujours prsent sur les claviers. On peut le copier-coller depuis laide de Stata :
help operator ou search op_logical
17

Pour gnrer plusieurs variables muettes partir dune variable continue,

gen dummy1=(x<=value1)
gen dummy2=(x>value1 & x<=value2)
gen dummy3=(x>value2 & x != .)

Il faut noter la condition dans la troisime ligne. Stata code les valeurs manquantes
comme 9999 ou quelque chose comme cela, et il faut donc viter de les attraper par
erreur. On vrifier que les variables muettes correspondent bien ce que lon veut et que
les valeurs manquantes sont prserves avec

tab x dummy3, missing

Pour crer un vecteur de variables muettes partir dune variable numrique servant
didentifiant (disons countrycode) allant de 1 n, la commande de base est

tab countrycode, gen(country)

et Stata cre n variables muettes quil appellera country1-countryn
5
. On note que cette
commande fonctionne aussi lorsque lon a une liste de codes-pays avec des trous : avec
trois pays dont les codes sont 21, 47, 803, la commande tab/gen va donner trois dummies
country1-country3. Pour effacer toutes ces nouvelles variables, il suffit de taper

drop country1-countryn

La commande xi permet de gnrer facilement des variables muettes partir de
catgories. Supposons que lon veuille rgresser y sur x, z et un vecteur de variables
muettes codant les rgions. La syntaxe est

xi: reg y x z i.location


Variables en string
Mettre le string et lenlever
Pour changer une variable numrique en une variable alphanumrique
6
( string ), la
commande est

tostring x, replace
Si on veut se compliquer la vie, on peut aussi taper


5
Par exemple, country4 vaudra 1 pour toutes les observations qui ont la mme (quatrime) valeur dans
countrycode, 0 sinon.
6
Les strings sont rouges dans le Data Editor.
18
gen str8 newvar=string(oldvar,8.0f)

o str8 indique combien de chiffres (ici, huit) la nouvelle variable (ici newvar) doit
avoir, au maximum. Si la variable initiale (oldvar) contenait des nombres plus de huit
chiffres, Stata ne gardera que les huit premiers dentre eux ( partir de la gauche). Si on
ne met pas loption %8.0f, partir de huit chiffres ce crtin de Stata met mme les
strings sous forme exponentielle et a fait du galimatia par exemple quand on agrge. Par
contre des fois il naime pas cette option, voir.

Pour changer une variable alphanumrique en numrique la commande est

destring oldvar, replace

et pour gnrer sa sur jumelle en version numrique (noter les parenthses) :

destring oldvar, gen(newvar)

Souvent dans les donnes brutes il y a un mlange de donnes chiffres et de
cochonneries mal tapes style XXX. Pour transformer ces codes-lettres en valeurs
manquantes sans sen soucier, on utilise loption force :

destring oldvar, replace force

mais attention, on ne voit alors pas ce quon fait On peut faire des dgts sans sen
rendre compte. Plus prudent, quand on a repr un certain type de cochonneries
nettoyer, on peut spcifier loption ignore XXX .

Manipuler des variables en string
Pour changer la valeur dune variable alphanumrique pour certaines observations, la
commande recode ne fonctionne pas : il faut employer replace et ne pas oublier les
guillemets. Exemple :

replace reporter=Bahamas, The if reporter==Bahamas

Supposons quune question denqute (disons la question code comme variable q85)
comprenne six sous-questions, chacune admettant une rponse de 1 (tout fait daccord)
4 (pas du tout daccord). Les rponses aux six sous-questions sont codes dans une
seule variable en format string 6, style 412232. Le problme est dextraire la rponse
la sous-question 4, quon appelle newvar. La commande est alors

gen str1 newvar=substr(q85,4,1)

o largument 4 de la commande substring est la place du chiffre garder en partant
de la gauche et largument 1 est le nombre de chiffres garder. Si on voulait garder le
quatrime et le cinquime chiffres et pas seulement le quatrime, la commande serait
19

gen str2 newvar=substr(q85,4,2)

Supposons maintenant que lon sintresse la fin dun string et pas son dbut. Il y a
alors une ruse. Le principe est le mme : le premier argument entre parenthses indique
o il faut commencer et le deuxime le nombre de caractres garder. Mais si le premier
argument est ngatif, stata compte en partant de la gauche et garde le nombre de
caractres donns par le deuxime argument en allant vers la droite. Par exemple si
dutyrate est gal 1.23%, avec

gen str1 newvar=substr(dutyrate,-1,1)

stata dmarre au dernier caractre de dutyrate et le garde, ce qui donne le % ; avec

gen str1 newvar=substr(dutyrate,-2,1)

stata dmarre lavant dernier (le 3) et ne garde que celui-l ; avec

gen str2 newvar=substr(dutyrate,-2,2)

stata dmarre encore lavant dernier et en garde deux, ce qui donne 3% .

Supposons quon ait trois variables alphanumriques : reporter, partner et flowname,
cette dernire tant soit Import soit Export. Les deux premires sont des codes de pays
trois lettres. On peut gnrer une nouvelle variable gale reporter quand flowname est
Export et partner quand flowname est Import par

gen str3 exporter1=reporter if flowname==Export
gen str3 exporter2=partner if flowname==Import

Pour crire des commandes conditionnelles sur la longueur du string, la fonction est
length(). Par exemple si on veut ajouter un 0 au dbut dun string quand il a deux
caractres (par exemple parce que le 0 a disparu quand un code a t enregistr en
numrique) la commande serait

gen str1 zero=0 ;
gen str3 newcode = zero + oldcode if length(oldcode)==2 ;
replace newcode oldcode if length(oldcode)!=2 ;
drop oldcode ;


Avec exactement le mme exemple mais en voulant ajouter deux 0, la deuxime ligne
serait

gen str3 newcode = zero + zero + oldcode if length(oldcode)==2 ;

Supposons que lon ait un ensemble de variables en string (des noms de produits par
exemple) chacun revenant plusieurs fois dans lchantillon (pour chaque mnage par
exemple) et que lon veuille crer un indice pour ces produits allant de 1 n. Une faon
20
de le faire est la suivante : on garde seulement la variable nom de produit et on la
sauvegarde dans un fichier part. Dans ce fichier, on cre une variable indiant les
observations, et on collapse cette variable par le nom du produit. Puis on la supprime et
on la remplace par une nouvelle variable indiant les observations, qui va maintenant
aussi indicer les produits de 1 n. On sauvegarde et on fusionne avec le fichier original :

keep product_name
gen n=_n
collapse n, by(product_name)
drop n
gen prod_id=_n
sort product_name
save products, replace

use original_file, clear
sort product_name
merge products using product_name

et voil.

Fusionner des fichiers
On ne le dira jamais assez : les grands dsastres commencent souvent par un merge mal
fait. Regardez cinq fois le rsultat du merge de la faon la plus souponneuse. Vous
gagnerez du temps !
Fusion horizontale
Pour fusionner deux fichiers contenant des variables diffrentes mais aussi une variable
commune (identificatrice), la variable identificatrice (var) doit avoir le mme nom dans
les fichiers fusion1.dta et fusion2.dta. La premire chose faire est un tri des deux
fichiers par cette variable. Procdure :

use fusion1 ;
sort var ;
save fusion1, replace ;
clear ;
use fusion2 ;
sort var ;
save fusion2, replace ;

On fait la fusion a partir de fusion2.dta (le fichier ouvert) comme suit : La syntaxe a
chang dans Stata 12. Lancienne syntaxe tait

merge var using fusion1
save fusion3
La nouvelle est

Merge m:1 var using fusion1
21
save fusion3

si on a plusieurs observations dans le fichier maitre associer une obervation dans le
fichier esclave, 1:m si cest le contraire, 1:1 si cest un pour un, et m :m si cest plusieurs
pour plusieurs (lancien joinby, je crois).

Les valeurs manquantes dans un fichier apparaissent dans le fichier fusionn. Les lignes
omises dans un fichier (ici, fusion2.dta) apparaissent dans le fichier fusionn avec une
valeur manquante pour les variables de ce fichier mais en bas du fichier fusionn, qui doit
alors tre re-tri.
La fusion horizontale comporte un grave risque. Il se peut que la variable commune
(identificatrice) ne soit pas suffisante pour identifier chaque observation : dans notre cas,
il se peut que plusieurs observations aient la mme valeur dans class. Ds lors, il convient
de trier les donnes avec le maximum de variables communes possibles, par exemple

use fusion1 ;
sort class code country year id ;
save fusion1, replace ;
clear ;
use fusion2 ;
sort class code country year id ;
save fusion2, replace ;

Puis, nouveau,

merge class code country year id using fusion1 ;
save fusion3 ;

Attention, beaucoup de dsastres ont leur origine dans des fusions hasardeuses. Sil y a
une chose vrifier cent fois cest celle-l. Exemple : imaginons que lon veuille
fusionner un fichier dans lequel les entreprises sont classes par leur code NACE avec un
fichier de tarifs par code HS comprenant une concordance NACE-HS (NACE et HS sont
des nomenclatures de produits). Le fichier entreprises est



et le fichier concordance est



22
On les fusionne par NACE et on obtient



du pipi de chat ! Lentreprise 1 est classe dans hs1 et a donc un tarif de 10%,
lentreprise dans hs2 avec un tarif de 15%, alors que rien dans le fichier-entreprises ne
permet de dire quelles sont diffrencies par code HS (puisque le fichier-entreprises na
pas de code HS !). Le problme, cest que chaque catgorie NACE a plusieurs images
la fois dans le fichier entreprises et dans le fichier concordance, et Stata les apparie selon
sa fantaisie.

Il y a plusieurs possibilits dans ce cas. On peut dabord calculer un tarif moyen par code
NACE, puis faire un collapse (voir la section agrger des donnes ) par code NACE,
et ensuite seulement faire la fusion. Ou bien (plus lgant) utiliser la commande

joinby varlist using file2

ce qui va clater la variable nace par hs et entreprise (cest--dire faire un produit
cartsien de toutes les combinaisons de hs et firmes), ce qui donne



et on peut, partir de ce fichier (dont la taille a bien sr augment), calculer des
moyennes simples de tarifs par entreprise.

Fusion verticale
Pour fusionner deux fichiers contenant les mmes variables mais des observations
diffrentes (par exemple sils sont tellement gros quils ont t pralablement
saucissonns), cest encore plus simple :

use fusion1;
append using fusion2 ;
23
save fusion3 ;

Variables avec indices (boucles)
Principe gnral
Deux commandes : foreach et forvalues. Supposons que lon veuille crer une srie
de variables muettes marquant cinq catgories codes dans une variable type allant de 1
5. On peut crire

foreach i of numlist 1/5 {;
gen dummy`i = (type==`i) ;
} ;

en notant que 1/5 signifie de 1 5 et numlist est (videmment) une liste de nombres.
On peut aussi numrer toute la liste, sans virgule, ou combiner :

foreach i of numlist 1 2 3/5 {;
gen dummy`i = (type==`i) ;
} ;

Cest justement la combinaison qui rend foreach flexible (au cas ou une boucle plante
on peut la sauter par exemple). Par contre foreach nadmet que des valeurs numriques.
Si on veut numrer jusqu la fin de lchantillon sans prciser sa taille en utilisant _N
(par exemple pour une procdure rpter sur des chantillons de taille variable), il faut
utiliser forvalues.

La syntaxe pour forvalues consiste donner le i initial (le premier 1), lincrment
du i (le 1 entre parenthses), et le i final. Pour lexemple prcdent, on crit

local N = _N
forvalues i = 1(1) N {
gen dummy`i' = (type==`i)
}

Donc

forvalues i = 0(2) 4 {
gen x`i' = 1990 + `i'
}

donne trois nouvelles variables, x0=1990, x2=1992 et x4=1994, la valeur entre
parenthses (2) disant Stata de sauter de deux en deux.

Comme exemple de lapplication de foreach, supposons que lon veuille calculer un
poverty gap par anne pour quatre annes : 1993, 97, 99 et 2001. On a dans la base de
donnes quatre variables binaires appeles txchange1993 txchange2001 et une autre
24
appele year qui prend comme valeur le chiffre de lanne (1993 2001). Soit j lindice
marquant les annes (j = 1993, etc) On dfinit les variables avec lindice j de la faon
suivante

foreach j of numlist 1993 1997 1999 2001{

gen dollardep`j' = dep/txchange`j' if year==`j'
gen dollarperday`j' = dollardep`j'/360

gen gap`j' = 1 - dollarperday`j'
mean gap`j' if gap`j' <=.
display gap`j'
}

Itrations
Jusqu prsent on a considr des boucles consistant rpter une commande (ou un
bloc de commandes) pour chaque valeur de lindice i, disons de un n. Il ne sagit pas
ditrations proprement parler puisque chaque boucle est indpendante de la suivante.
On considre maintenant une srie de commandes dans lesquelles la valeur initiale dune
itration est la valeur donne par litration prcdente. Supposons que lon veuille
gnrer un processus de Markov


1 t t t
x x u

= +

o u
t
est un choc avec une distribution normale, 0.9 = et une valeur initiale
0
1 x = . La
liste de commandes pour cinq iterations est

gen x0=1 ;
gen lambda=0.9 ;
foreach i of numlist 1/5 {;
local j = `i'-1 ;
set seed 0 ;
gen u`j'=invnorm(uniform()) ;
gen x`i' = lambda*x`j' + u`j' ;
};
display valeur finale egale a x5 ;
end ;

On note que
t
x et
t
u sont en fait des vecteurs si on a plusieurs observations. Les
conditions et les commandes qui suivent sont interprter en gardant cela lesprit.

Si on veut choisir le nombre ditrations simplement en appelant le programme, on mettra
le bloc de commandes sous forme dun programme (ou dun fichier ado) et on utilisera
forvalues:

program drop newloop ;
program define newloop ;
25

gen x0=1 ;
gen lambda=0.9 ;
local n = `1' ;
forvalues i = 1(1) `n' {;
local j = `i'-1 ;
set seed 0 ;
gen u`j'=invnorm(uniform()) ;
gen x`i' = lambda*x`j' + u`j' ;
};
display "valeur finale egale a " x`n' ;
end ;

newloop 100 ;

Boucles sur des observations
Attention : forvalues ne fonctionne pas sur des observations. Par exemple, supposons
que lon veuille gnrer une variable de stock de capital K partir dune variable
dinvestissement I par linventaire perptuel. La commande

local N = _N
gen K = 100
forvalues j = 2(1)N {
replace K = 0.9*K[_n-1] + I[_n-1] if _n == `j'
}

ne fonctionne pas. Il ny a pas besoin de boucle explicite. Il suffit dcrire

gen K = 100
replace K = 0.9*K[_n-1] + I[_n-1] if _n != 1

et stata procde squentiellement en commenant par la deuxime observation.

Matrices et vecteurs
Si on veut vraiment faire des oprations matricielles, Stata a un sous-programme, Mata,
avec sa propre syntaxe (voir une petite introduction a Mata la fin de cet aide-mmoire).
On ne prsente ici que quelques manipulations trs simples.

Mettre une matrice en vecteur-colonne
Avec la commande reshape. On dmarre avec une matrice 3x2 de la forme suivante

26

Lindice de lindustrie-source est i = 1,2,3 dans la premire colonne et lindice de
lindustrie-destination est j = 1,2 dans le suffixe des ttes de la deuxime et troisime
colonnes. Les variables (coefficients input-output si cest une matrice IO mais jai pris
une matrice rectangulaire pour montrer que la procdure ne demande pas une matrice
carre) sont x
11
= 3, x
12
= 2, x
21
= 5, x
22
= 4 x
31
= 7 et x
32
= 6. Cet exemple est dans le
fichier IOwide.dta dans DATA. On suppose aussi, cest en gnral le cas, que la premire
colonne est en format string (le code du secteur).

La srie de commandes est

destring source, replace ;
reshape long dest, i(source) j(destination) ;
gen coeff=dest ;
drop dest ;

Lcran de Stata donne alors les dtails de lopration :



dont le rsultat est



les coefficients input-output tant maintenant stocks dans la variable coeff. La variable
destination correspondant lindice j a t cre.

Pour que la syntaxe marche, on note que le nom des variables correspondant aux secteurs
de destination doit avoir un suffixe correspondant la variable i (code-produit). Je
suppose quil faut donc renommer toutes les colonnes la main, un peu casse-pieds mais
27
bon. Il faut aussi que le code du secteur i soit numrisable, cest--dire ne contienne pas
de lettres ou despaces.

Mettre un vecteur-colonne en matrice
On repart du tableau ci-dessus, et on veut remettre destination en colonnes. La commande
est

reshape wide coeff, i(source) j(destination)

et les deux variables correspondant "source" et "destination" dans notre exemple
doivent tre toutes les deux numriques, sauf si on utilise loption string (voir ci-
dessous). Si on a une variable qui ne change pas pour un i donn on a pas besoin de la
mettre dans la liste de variables de reshape (exemple, i est lidentifiant dun individu et
la variable est son sexe). Bien videmment on ne peut mettre qu'une seule variable dans
la matrice.

Plus vicieux : supposons que lon ait des donnes du type



cest--dire 3 catgories de produits et deux annes mais (i) des valeurs manquantes et (ii)
des lignes carrment omises pour ces valeurs, au lieu de lignes vides (typique des
donnes commerce). On veut construire un tableau avec hs6 en ligne et les annes en
colonne (hs6 va donc jouer le rle de source et year de destination dans lexemple
prcdent), et des cellules vides pour les valeurs manquantes. Dautre part on veut garder
hs6 en format string, sinon le zro du dbut va disparatre.

Il faut commencer par trier les donnes dabord par hs6 puis par anne, sinon a ne
fonctionnera pas. Supposons que year et hs6 soient toutes les deux en string au dpart.
Pour le tri il faut les mettre en format numrique, mais en gardant une version string de
hs6 puisque lon en aura besoin plus tard (la transformation nest pas neutre cause du
zro au dbut alors que pour year elle lest). La liste de commandes est alors

destring hs6, gen(nhs6) ;
destring year, replace ;
sort nhs6 year ;

Aprs le tri, comme on veut hs6 en string, il faudra utiliser loption string dans reshape
et il faudra alors que les deux variables (hs6 et year) soient en string, ce qui veut dire les
transformer et supprimer leurs versions numriques :

28
gen str4 syear=string(year) ;
drop nhs6 year ;

enfin on peut utiliser la commande reshape wide

reshape wide value, i(hs6) j(syear) string ;

et on obtient



Multiplier une matrice par un vecteur
Voil le programme concoct partir des fichiers IOlong.dta et vector.dta, tous les deux
dans le rpertoire DATA. La matrice dans le fichier IOlong.dta doit dj avoir t mise en
format long (voir section prcdente). Soit i la source (lignes) et j la destination
(colonnes) si on a en tte une matrice input-output par exemple. On commence par les
bidouillages habituels:

use IOlong.dta ;
destring source, replace ;
sort destination ;
save matrix.dta, replace ;

puis on fait la mme chose avec le fichier contenant le vecteur-colonne:

clear ;
use vector.dta ;
sort destination ;
save newvector.dta, replace ;

Ensuite on fusionne les deux fichiers sur la base de lindice j (appel destination et
contenu dans la deuxime colonne du fichier matrice en format long)

merge destination using matrix ;
drop _merge ;
save matrixvector.dta, replace ;

Puis on gnre les produits par cellule x
ij*
y
j
que lon appelle product:

gen product=coeff*y ;
sort source destination coeff product ;

Enfin on somme ces produits sur j, cest--dire que lon gnre les expressions
ij j
j
x y

. Attention, on va utiliser loption by source qui en Stata signifie que lon

29
garde i constant, cest--dire que lon somme sur j. En dautres termes, by indique
lindice (la variable) gard constant et non pas lindice (la variable) sur lequel on somme.

by source: egen final=sum(product) ;
collapse final, by(source) ;
save matrixvector.dta, replace ;

et surprise, a marche, si, si. Mais franchement a va plus vite avec Mata (voir ci-
dessous).

Cylindrer un panel
Supposons que lon veuille cylindrer un panel en rajoutant des zros pour les priodes
manquantes pour chaque individu. Pour fixer les ides, les variables sont firm
(exportateur), hs6 (produit), iso3 (code destination) et value.

La commande est fillin, mais elle va mettre des valeurs manquantes pour toutes les
variables (y compris value) dans les lignes quelle remplit. Pour value, qui est une
variable numrique, on remplacera simplement les valeurs manquantes par des zros. Par
contre, pour les autres variables qui sont des string, cest plus compliqu. Deux mthodes
pour que firm, hs6 et iso3 soient renseignes dans chaque ligne, les deux un peu
bourrin.

Mthode 1

egen cell = concat(firm hs6 iso3), punct(,)
fillin cell year
split cell, parse(,)
drop firm hs6 iso3
rename cell1 firm
rename cell2 hs6
rename cell3 iso3

Mthode 2
On utilise le fait que value va tre code en valeur manquante pour toutes les annes
rajoutes par fillin. En faisant un sort par value, Stata mettra les valeurs renseignes en
premier. Aprs, on lui dit de remplacer chaque ligne par la ligne prcdente lintrieur
de chaque cellule (firm hs6 iso3) :

sort firm hs6 iso3 value
by firm hs6 iso3: gen n = _n

by firm hs6 iso3: replace firm = firm[_n-1] if n > 1
by firm hs6 iso3: replace hs6 = hs6[_n-1] if n > 1
by firm hs6 iso3: replace iso3 = iso3[_n-1] if n > 1


Finalement on remplace les valeurs manquantes de value par des zeros:
30

replace value = 0 if value == .
Un peu de programmation pour les ado
Programme
On peut inclure un programme lintrieur du do-file. Attention, si on fait marcher le do-
file plusieurs fois de suite (par exemple pour debugger) on aura le message derreur
program dummy already defined . A partir de la deuxime fois il faudra donc crire
program drop dummy avant program define dummy (pas trs lgant mais bon). La
syntaxe de base pour ouvrir et fermer le programme (par exemple de cration des
variables muettes) est

program define dummy ;
forvalues i = 1(1) 3 {;
gen type`i' = (type==`i) ;
} ;
end ;
dummy

et le programme est excut par le do-file par la dernire commande qui est simplement
son nom (les lignes qui prcdent ne font que le dfinir).

Fichiers ado
Une alternative plus lgante linclusion dun programme dans le do-file (par exemple
sil est long) est de crer un fichier .ado (en utilisant notepad ou nimporte quel diteur
ASCII). Si on veut utiliser le programme en lappelant par une commande il doit tre
sauvegard dans c:\Stata\ado\personal ou plus simplement dans un rpertoire ado
directement sur c:\ avec des sous-rpertoires chacun ayant comme nom une lettre le
lalphabet. On classe les fichiers ado dans le rpertoire de son initiale. Un fichier ado est
mis en route dans le fichier .do par une commande portant simplement son nom (juste le
nom, pas le chemin pour y arriver) suivie du nombre de boucles faire sil y a des
boucles (voir ci-dessous pour les macros).

Macros. Premire chose utile savoir : comment crer un macro (au vin blanc). Stata en
a de deux sortes : local et global. Un macro local dfini dans un fichier ado ne peut pas
tre utilis dans un autre fichier ado. Par contre, un macro global est dfini une fois pour
toutes et peut tre utilis par tous les fichiers ado (donc utiliser prudemment). Un
exemple de macro local consiste donner un nom une liste de variables, disons x y z en
lappelant truc :

local truc x y z

31
On peut alors utiliser `truc (avec un simple guillemet) dans nimporte quelle commande,
style

sum `truc
reg depvar `truc

Par contre les doubles guillemets dans la dfinition du macro sont optionnels. On peut
bien sr combiner le macro avec une boucle. Supposons que lon veuille mettre au carr
10 variables nommes respectivement z
1
-z
10
. On commence par faire un macro local avec
la liste des variables, puis on fait la boucle, ce qui donne

local truc z1-z10 ;
foreach x of local truc { ;
gen new`x=`x^2 ;
} ;

On note que le nom de la variable gnrique de la boucle (x) est libre. Jusque-l, le macro
peut tre utilis dans un do-file normal, il ny a rien qui require un programme.

Supposons maintenant quon ait 100 types possibles dune variable, indexs dans une
variable-code allant de 1 100. Pour crer des variables muettes disons pour les 50
derniers types, le contenu du fichier ado pour crer la liste de variables muettes serait:

program define dummy ;
local n = `1 ;
forvalues i = 50(1) `n {;
gen type`i' = (type==`i) ;
} ;
end ;

qui est appel dans le do-file par

dummy 100

cest--dire avec le nom du programme (dummy) et le numro de la dernire boucle
dsire (100). La signification de la ligne local n = `1 nest pas trop claire mais bon.
La dfinition du macro local par `1 avec des guillemets uniques ne peut tre utilise que
dans un programme. Lintrt de cette syntaxe est que la fin des boucles peut maintenant
tre choisie directement par la commande dappel du programme dummy.

If/else
Supposons maintenant que lon veuille faire de zro une barrire absorbante, cest--dire
que ds que le processus passe zro ou en-dessous, il reste coinc zro. On utilise la
commande if/else :

gen x0=1 ;
gen lambda=0.9 ;
32
foreach i of numlist 1/100 {;
local j = `i'-1 ;
set seed 0 ;
gen u`j'=invnorm(uniform()) ;
if x`j' <= 0 {;
gen x`i' = 0 ;
};
else {;
gen x`i' = lambda*x`j' + u`j' ;
};
};
display "x100 =" x100 ;

Attention la syntaxe est trs sensible. Louverture daccolade doit tre sur la mme ligne
que le if, la commande en dessous, et la fermeture daccolade sur une ligne part.

En utilisant forvalues on peut mettre aussi une barrire endogne en disant Stata
de sarrter ds que la diffrence entre
t
x et
1 t
x

est plus petite que 0.1, ce qui illustre en

mme temps limbrication de commandes if/else :

gen x0=1 ;
egen X0=mean(x0) ;
gen lambda=0.9 ;

program drop newloop ;
program define newloop ;

local n = `1' ;
forvalues i = 1(1) `n' {;
local j = `i'-1 ;
set seed 0 ;
gen u`j'=invnorm(uniform()) ;
gen x`i' = lambda*x`j' + u`j' ;
egen X`i' = mean(x`i') ;
if X`j+1'-X`j' > -0.01 {;
continue ;
};
else if x`j'>5 {;
continue ;
else {;
break ;
};
};
};
display "valeur finale " X`n' ;
end ;

newloop 20 ;

et l encore on peut choisir combien de boucles on fait (ce qui ne sert pas forcment
grandchose si larrt est endogne ! Mais bon). On note que la condition du if (X`j+1'-
X`j' > -0.01) est exprime en termes de lindice j, pas i.

33
While
La syntaxe de while est en gros la mme que celle de if/else :

while condition { ;
command ;
} ;

A utiliser prudemment, while peut facilement produire des boucles sans fin

Estimation : quelques bidouillages
Sauvegarder des rsultats, mme quand ils sont absurdes
Sauvegarder des statistiques descriptives

sum x ;
gen x_bar = r(mean) ;
gen sigma_x = r(sd) ;

Sauvegarder valeurs prdites et rsidus
Pour sauvegarder les valeurs prdites (en gnrant une nouvelle variable yhat) et rsidus
(en gnrant une nouvelle variable residuals), les commandes sont

predict yhat
predict e, residuals

Par dfaut cest les valeurs prdites qui sortent.

Sauvegarder des coefficients absurdes
Deux faons de sauvegarder des estims. On peut le faire simplement par la commande

gen beta_1 = _b[x1]
gen constant = _b[_cons] ;

pour les coefficients, et

gen sigma_1 = _se[x1]

34
pour les carts-types. Plus gnralement, toutes les commandes de stata gardent leur
rsultat en mmoire dans trois types de macros, les r , les e et les s . On peut
accder la liste de ces macros en tapant return list, ereturn list ou sreturn list.

Alternativement, les estims de rgression et leurs variances sont sauvegards sous forme
de macros dans e(.), et on peut les transformer en variables apparaissant dans la base de
donnes (sur la premire ligne uniquement, puisquil sagit de scalaires) en tapant :

reg y x
mat b=e(b)
svmat b

La premire commande (mat b=e(b)) gnre un vecteur-ligne b dont les lments sont
ceux de e(b), i.e. les coefficients. La deuxime (svmat b) gnre k variables b
1
, b
2
.... b
k
,
chacune avec une seule observation (sur la premire ligne), correspondant aux k
coefficients estims par la rgression prcdente, mais attention le coefficient de la
constante vient toujours en dernier, donc on peut ajouter rename bk b0 pour tre sr de
ne pas confondre. Pour viter de charger la base de donnes, on peut dfinir un scalaire
par coefficient :

scalar beta1 = b1
scalar beta0 = b2

et faire des oprations dessus du genre

gen yhat = beta0 + beta1*x1

On peut donner le nom quon veut la place de b. Si on voulait garder les coefficients
dans une seule variable A1 (en colonne), on sauverait la transpos de la matrice e(b),

mat b=e(b) ;
svmat b ;

Pour sauvegarder la matrice de variances-covariances des coefficients, la commande est

mat v=e(V) ;
svmat v ;

On note que largument dans e(V)est en majuscule. Ce quon obtient est une matrice
k k (ou k est le nombre de coefficients y compris celui de la constante, qui vient
toujours en dernier dans stata) et les variances sont sur la diagonale (donc
( )
2
1

o | est sur
la premire ligne et la premire colonne, et ainsi de suite jusqu
( )
2

k
o | , la variance du
coefficient sur la constante, qui est sur la k-ime ligne et la k-ime colonne.

35
Gnrer un tableau de rgressions
Si lon veut sauvegarder des rsultats destimation sous une forme directement exportable
dans excel, la commande qui vient immdiatement aprs la commande destimation est

outreg varlist using table1, br coefastr 3aster bdec(3) tdec(3)
bfmt(fc) replace;

qui gnre un fichier (table1.out) contenant un tableau de rsultats avec les statistiques t
entre crochets (br) pour quExcel ne les prenne pas pour des nombres ngatifs
7
, des
astrisques par niveau de significativit (coefastr 3aster: trois pour 1%, 2 pour 5% et
une pour 10%), trois chiffres aprs la virgule pour les coefficients (bdec(3)) et les
statistiques t (tdec(3)) et des coefficients formats en fixe (et non en notation
scientifique, pas pratique) et avec une virgule pour les milliers (bfmt(fc)). Par dfaut,
outreg utilise les labels et non les noms de variables.

Pour que plusieurs colonnes de rsultats soient regroupes dans un seul tableau, la
commande outreg est comme ci-dessus aprs la premire estimation mais pour les
suivantes, on ajoute loption append en gardant le mme nom de fichier et les mmes
options de formatage ; style

reg y x1 x2 x3;
outreg x1 x2 x3 using table1, coefastr 3aster replace;
reg y x2 x3 x4;
outreg x2 x3 x4 using table1, append coefastr 3aster replace;

La commande outreg nest pas dans le package standard de Stata8 (ni de Stata9
dailleurs) et doit tre tlcharge depuis le web avec findit outreg. Une fois quun
fichier excel est gnr par outreg, il peut tre r-export vers Latex en incorporant dans
Excel la macro Excel2Latex (fichier tlchargeable depuis ma page web, il suffit de
cliquer dessus et il se met tout seul dans Excel)
8
.

7
Si on veut garder des parenthses et pas des crochets, quand on ouvre le fichier table1.out, la troisime
(dernire) tape du wizard il faut slectionner chaque colonne et la formater en texte. Excel ne changera
alors pas les parenthses en nombres ngatifs.
8
A propos, pour passer dun format de page portrait landscape pour des tableaux larges, les commandes
en latex sont:
Au dbut du document: \usepackage{rotating}
Dans le document, juste avant le tableau:
\clearpage
\begin{sidewaystable}[!h]
\centering
\begin{tabular}
Donnes du tableau
\end{tabular}
\caption{Le nom de mon tableau}
\end{sidewaystable}
\clearpage
36



Estimation
OLS and WLS
OLS cest

reg y x

Avec des contraintes (par exemple
1
1 | = et
2 3
| | = ) cest

constraint define 1 x1 = 1
constraint define 2 x2 = x3
cnsreg y x1 x2 x3, c(1,2)

Pour WLS, la commande est

reg y x [aweight = z], options

o [aweight = z] nest pas une option mais vient avant la liste des options (par
exemple nocons)

Le clustering des carts-type se fait par loption vce(cluster clustervariable).

Panels
Tant de choses dire ! Le mieux est daller voir le manuel de Stata. Quelques trucs
noter en priorit, cependant. La commande pour indiquer Stata que lchantillon est un
panel avec product comme variable de coupe et year comme variable temporelle est

xtset product year

Aprs quoi on peut utiliser toutes les commandes qui commencent par xt. Si la variable
qui indice les individus est en string, exemple un code HS, Stata va couiner ; il faut alors
la dclarer comme groupe :

egen product = group(hs6)


Attention a ne marche pas trs bien en Scientific Workplace. A propos de tableaux en SW, quand un
tableau se met nimporte o dans le fichier, en gnral cest quil manque le caption . Il se peut aussi que
les donnes rentres par le macro latex aient des lignes sautes, auquel cas SW va couiner.
37
Si lon a un panel multidimensionnel (par exemple pays importateur produit) on dfinit
comme nouvel individu une paire pays importateur produit que lon appelle un
groupe . La commande est alors

egen mgroup=group(reporter sitc2)
xtset mgroup year

On peut utiliser foreach pour des estimations spares par anne. Supposons que la
variable dpendante est y
t
avec t = 2001, 2002,200 3 et les rgresseurs x
t
et z
t
. La
commande est tout simplement

foreach t of numlist 2001 2002 2003 { ;
reg y x z if year==`t ;
} ;

et on pourra rcuprer les valeurs prdites et les rsidus anne par anne, par exemple,
avec

predict yhat`j ;
predict resid`j', resid ;

Supposons quon estime un effet de traitement en DID. La correction suggre par
Bertrand Duflo et Mulainathan (2004) pour la corrlation srielle de la variable de
traitement est de permettre une matrice de covariances non-contrainte pour chaque
individu dans la dimension temporelle. Supposons que ce soient des firmes, loption est
alors

egen newfirm = group(firm)
xtset newfirm year
xtreg y x year1-year10, fe vce(cluster newfirm)


Sure
La commande est

sureg (eq1 : y1 x1 x2 x3, options) (eq2 : y2 x1 x2)
predict y1hat, equation(eq1) ;

Parmi les options, aweight et fweight fonctionnent mais pas pweight.

2sls
Supposons que lon veuille estimer le systme suivant

38

0 1 1 2 2 3 3
1 0 1 2 2 3 3
.
y x x x u
x y z z v
o o o o
| | | |
= + + + +
= + + + +


La commande est alors

ivreg y x2 x3 (x1 = z1 z2 z3)

et la plupart des options de reg (OLS) sont permises. Le test dendognit de Hausman
est entr de la faon suivante :

ivreg y x2 x3 (x1 = z1 z2 z3) ;
hausman, save ;
reg y x1 x2 x3 ;
hausman, constant sigmamore ;

et loutput dit si la diffrence des coefficients entre les deux regressions (un chi carr) est
significative ou non. Si elle est significative (Prob>chi2 infrieure 0.05) lhypothse
nulle (pas dendognit) est rejete et les estims OLS sont inconsistants.

Si pour une raison ou pour une autre on veut calculer des carts-types par bootstrap, il y a
plusieurs commandes. Supposons par exemple quon veuille calculer lcart-type du
coefficient sur x1 par bootstrap. On peut utiliser la commande

bootstrap _se[x1] _se[x2] _se[_cons], reps(#) saving(filename, replace)
: command

o # est le nombre de rptitions et command est la commande de rgression (ou autre).
Si la procdure est plus complique quune commande en une ligne, il faut utiliser un ado
file.

GMM
Si on veut utiliser lestimateur dit system-GMM de Blundell et Bond, le programme
doit tre descendu du web par findit xtabond2. Le system GMM estime une quation
simultanment en niveaux et en diffrences et instrumente les niveaux par les diffrences
contemporaines et les diffrences par les niveaux retards. Si on na pas dinstruments
externes, la commande est

xtabond2 y L.y x_exo x_endo, gmmstyle(y, lag(2 2) collapse) \\\
gmmstyle(L.y x_endo, lag(2 2) collapse) \\\
ivstyle(x_exo) robust h(2) nomata

Lestimateur utilise par dfaut toutes les valeurs retardes des variables endognes
disponibles dans lchantillon. Il y a alors souvent trop dinstruments, un problme qui se
manifeste dans une p-value du test de Hansen proche de 1. En gnral il vaut mieux quil
ny ait pas plus dinstruments que dindividus dans le panel. Loption lag(2 2) permet
39
de limiter le nombre de retards utiliss deux priodes. Loption robust contrle
lhtroscdasticit. Loption nomata vite un problme que je nai jamais compris (il y
a toute une explication dans le help).

Si on a un vecteur z dinstruments, la commande est

xtabond2 y L.y x_exo x_endo, gmmstyle(y, lag(2 2) collapse) \\\
gmmstyle(x_endo, lag(2 2) collapse) \\\
ivstyle(x_exo z) robust h(2) nomata

Pour utiliser le GMM efficient en deux tapes, on ajoute loption twostep. Attention il
faut faire un tsset avant la commande.

Variables dpendantes limites
Tobit

Supposons que lon veuille rgresser une variable y censure zro et un sur x. La
commande est

tobit y x z, ll(0) ul(1)

o ll(.) est ul(.) sont les bornes infrieures et suprieures respectivement. Pour avoir
les effets marginaux, il faut descendre dtobit2 en tapant findit dtobit2 (Dieu sait
pourquoi la commande dtobit bugge). Sinon on peut utiliser la commande postestimation

mfx compute

mais elle est bestialement gourmande en calculs.

Probit

Lestimation et les effets marginaux sobtiennent de la faon suivante. Soient x, y, et z
trois variables respectivement catgorielle (x), binaire (y) et continue (z). La variable
dpendante est y. Supposons qux aille de 1 8 et que lon veuille son effet marginal la
valeur x = 7. Les commandes sont

probit y x z
matrix xvalue=(7)
dprobit y x z, at(xvalue)

La premire ligne estime le probit de faon conventionnelle et donne les coefficients. La
seconde dfinit la valeur laquelle leffet marginal est calcul (par dfaut, cest--dire
sans la seconde ligne et loption dans la troisime, cest la moyenne). La troisime ligne
demande les rsultats sous forme deffets marginaux plutt que de coefficients. Loption
robust peut tre utilise avec probit.
40

Supposons que lon veuille compter le nombre dobservations pour lesquelles y = 1 et
lquation donne Prob(y=1) > 0.5 ou bien y = 0 et Prob(y=1) < 0.5 (une mesure ad hoc
du fit de lquation). La srie de commandes est

predict yhat ;
gen predicted=(yhat>=0.5) ;
count if (predicted==1 & y ==1) | (predicted==0 & y ==0) ;

Enfin, noter que outreg utilis avec un probit ne donne pas par dfaut le pseudo-R2. Il
faut prciser

outreg x1 x2, addstat(Pseudo R-squared, e(r2_p))

A savoir: on peut pas interprter le coefficient sur un terme dinteraction comme leffet
de linteraction des deux variables dans un modle non-linaire (logit, probit ou autre), a
se voit en cinq mn dans lalgbre. Sil ny a pas de terme exponentiel, on peut utiliser la
commande inteff:

logit y age educ ageeduc male ins_pub ins_uni x, cluster(pid)
inteff y age educ ageeduc male ins_pub ins_uni x, ///
savedata(d:\data\logit_inteff,replace) savegraph1(d:\data\figure1,
replace) savegraph2(d:\data\figure2, replace)

La commande donne leffet correct de linteraction, lcart-type et la stat z pour chaque
observation. On peut se donner une ide de ce que inteff produit avec le petit programme
suivant

clear
set obs 1000
gen x = invnorm(uniform())
gen z = invnorm(uniform())
gen latent = x - z + x*z + invnorm(uniform())
gen y = (latent > 0)
gen interact = x*z

probit y x z interact
inteff y x z interact, ///
savedata(d:\databases\made_up\inteff1,replace) ///
savegraph1(d:\databases\made_up\inteff_figure1,replace) ///
savegraph2(d:\databases\made_up\inteff_figure2, replace)

ce qui produit les graphiques bizarroides suivants:


41
-.4
-.2
0
.2
.4
I
n
t
e
r
a
c
t
i
o
n

E
f
f
e
c
t

(
p
e
r
c
e
n
t
a
g
e

p
o
i
n
t
s
)
0 .2 .4 .6 .8 1
Predicted Probability that y = 1
Correct interaction effect Incorrect marginal effect
Interaction Effects after Probit

-5
0
5
10
z
-
s
t
a
t
i
s
t
i
c
0 .2 .4 .6 .8 1
Predicted Probability that y = 1
z-statistics of Interaction Effects after Probit



Variables instrumentales en probit :

La commande est ivprobit et la syntaxe est

ivprobit y x2 x3 (x1 = z1 z2 z3)

o x1 est le regresseur endogne et z1-z3 sont les instruments.

Multinomial logit

Syntaxe du multilogit : soit { }
1 2
, ,... y y y e la variable de choix. La commande pour
choisir la catgorie de base par rapport laquelle tous les coefficients seront calculs
(disons y
1
) est

mlogit y x1 x2 x3, basecategory(y1)

En mlogit les coefficients ne sont pas interprtables directement (ratios de probabilits) ;
les effets marginaux des variables x1 et x2 (par dfaut toutes) calculs aux valeurs
valeur1 et valeur2 (par dfaut aux moyennes) sur la catgorie y1 (par dfaut toutes) sont
obtenus avec

prchange x1 x2, x(x1=valeur1) x(x2=valeur2), outcome(1)

Pour les rgresseurs binaires le delta par dfaut est de un. A noter, prchange ne
fonctionne pas avec svymlogit, la commande de multilogit pour les enqutes.

Une commande alternative qui fonctionne avec svymlogit est

mfx compute, predict (outcome(1)), eyex at(median x1)

qui donne galement les carts-type et peut donner des lasticits directement (eyex) ou
en semi-log (voir [R] mfx), et peut tre value l o on veut (ici mdiane du rgresseur
42
x1). Il faut rpter la commande pour chaque catgorie de la variable dpendante.
Attention le calcul est lourd et prend quatre sicles.

Negative binomial

nbreg y x, exposure(z)


Switching reg
Les programmes de Laure (des ado-file qui sont sur mon disque dur) sont les suivants:
Pour un switching inconnu et exogne, cest switch_exo, pour un switching inconnu et
endogne, cest switch_endo, il y a des help files pour la syntaxe exacte (cest un
cauchemard). On peut faire tourner une grid search (option gs) ou un algorithme EM
(option em) mais il faut mettre un cierge lglise pour que a tourne.

Une fois quon a fait tourner lun des deux et quon a trouv le switchpoint, on peut faire
tourner movestayl qui est pour le switchpoint connu mais endogne qui tourne beaucoup
plus vite et qui peut gnrer quelques fonctions post-estimations (valeurs prdites etc.,
voir le fichier help movestay).

Si tout foire on peut utiliser le premier do file que Laure a fait qui sappelle
switchshventeprod.do. Si si cest bien a le nom. Il fait une boucle sur movestayl pour le
grid search.

Propensity score matching
La commande psmatch2 ( googler et descendre) permet de faire des comparaisons
doutcomes entre un groupe de traitement et un groupe de contrle construit par PSM.

Premire tape : Propensity score estimation

Supposons que la variable muette marquant le groupe de traitement soit TG. Le
propensity score sobtient en faisant un probit sur les caractristiques individuelles X1 et
x2 en utilisant tout lchantillon, en utilisant la commande pscore :

pscore TG x1 x2, pscore(pscore) blockid(blockf1) comsup level(0.001)
outreg using `pathresults'\pscore_file, 3aster replace

On vrifie le support commun avec des densits (voir ci-dessous pour les kernel
densities) et des histogrammes en miroir

gen treated = pscore if TG == 1
gen untreated = pscore if TG == 0

43
* Densities
twoway (kdensity untreated) (kdensity treated)
graph save Graph `pathresults'\densities, replace

* Mirror histograms
psgraph, treated (TG) pscore(pscore)
graph save Graph `pathresults'\mirror_histograms, replace

Seconde tape : Matching

Pour la procdure elle-mme (comparaison de la valeur moyenne de la variable outcome
pour les deux groupes), la commande de base est psmatch2. On peut en fait sauter ltape
pscore car la commande psmatch2 fait cette tape elle-mme et gnre le pscore
(_pscore). Dans ce cas on ne met pas loption pscore().

Matching avec la mthode des n nearest neighbors (si cest 1 on met 1!) :

psmatch2 TG, outcome(y) pscore(pscore) neighbor(n) com cal(0.01)

La variable TG est la muette qui dfinit le groupe de traitement (construite pralablement).
Loption pscore(pscore) utilise la variable pscore construite et sauvegarde dans la
premire tape. Loption com dfinit le support commun en excluant les individus traits
ayant un score plus grand que tous les non traits et vice-versa. Loption cal(0.01) met
la distance maximum entre voisins (le caliper ) 0.01. Matching en kernels :

psmatch2 treatment, outcome(y) pscore(pscore) kernel com

et on peut choisir le type de poids dans les kernels (voir le help).

La commande psmatch2 gnre automatiquement plusieurs variables qui apparaissent
dans le fichier-donnes. _treated est la variable de traitement (gale TG ici). _support
est une muette gale un si lobservation est dans le support commun. _pscore est le
score. _weight est gnre par le nearest neighbor est indique la frquence avec laquelle
lobservation est utilise comme match ; elle est donc plus grande ou gale un. _id est
un identifiant ad-hoc utilis pour _n1, qui est une tiquette mise toutes les observations
traites indiquant lidentit de son match dans le groupe de contrle si on utilise le
nearest neighbor (si on utilise les n nearest neighbors, cest le premier). Par exemple, si
lobservation 1 dans le groupe de traitement est matche avec lobservation 3 dans le
groupe de contrle, _n1 = 3 pour lobservation 1. Cest clair ? Toujours avec le nearest
neighbor, _nn donne le nombre de matches pour chaque observation traite. Enfin
_pdif donne la distance au voisin.

Il y a plusieurs balancing tests (pour vrifier que les caractristiques individuelles
moyennes ne diffrent pas trop entre le groupe de contrle et le groupe de traitement. La
source est Smith & Todd (1985, 1986). La commande de base est

pstest TG x1 x2, support(_support), summ

44
o la variable _support est gnre par la procdure psmatch2 (voir ci-dessus). La
commande pstest fait deux choses. La premire est une rgression de chaque covari
x1, , xn sur la variable TG et donne le t-test. Sil nest pas significatif, il ny a pas de
diffrence significative entre le groupe de traitement et le groupe de contrle pour la
variable xi. La rgression est courue avant matching sur tout lchantillon, et aprs
matching sur le support commun en moindres carrs pondrs utilisant les poids dfinis
dans _weight. La deuxime donne le standardized bias pour le covari x dfini dans
Rosenbaum et Rubin (1985) :

( )
( )
( ) ( )
100 /
var var / 2
i ij j
i TG
i TG
i CG
n x w x
SB x
x x
e
e
e

=
(
+

Il ny a pas de thorie sur la valeur maximale admissible de SB(x) mais on considre
gnralement que 20 cest dj beaucoup. Si on a peur de sennuyer, on peut aussi courir
une rgression polynomiale dordre 4 pour chaque covari x de la forme


( ) ( )
4 4
1 1

k k
j k j k j j j
k k
x p TG p u o |
= =
= + + +



o
j
p est le score pour lobservation j (pas tout fait sr pour le terme dinteraction avec
TG vrifier). On peut faire des MCP en utilisant _weight aussi si on veut. Si les
sont conjointement non significatifs (F-test), cest bon ! En pratique, la commande est
donc

foreach j of numlist 1/4 {
gen pscore`j = pscore^`j
gen interact`j = TG*pscore`j
}

set seed 123456789
qui reg x pscore1-pscore4 interact1-interact4 if com == 1,
[iweight=_weight]
testparm TG interact1-interact4

Pour faire du matching diff-in-diff, il faut dfinir la variable doutcome en premires
diffrences :

gen dy = D.y
psmatch2 treatment, outcome(dy) pscore(pscore) kernel com

Mais attention ! Cest l que les vraies difficults commencent. Premire difficult : la
priode de traitement est bien dfinie pour les firmes traites, mais pas pour les firmes
non traites. Il faudrait contraindre psmatch2 ne prendre comme contrles pour une
firme traite en 2005 que des firmes non traites en 2005 aussi, mais il ne le fait pas. Il y
a une variante appele matchyear qui est cense le faire, dveloppe par Jens Arnold,
mais chaque fois que jai essay de la faire marcher jai d amener lordinateur la
rparation.
45

Deuxime problme. Supposons quune firme soit observe entre 2000 et 2010 et quelle
se fasse traiter en 2005. Premire possibilit, on dfinit la priode de traitement comme
2005-2010. La variable TGTP (groupe de traitement et priode de traitement) est gale
1 pour toutes les annes partir de 2005. Alors psmatch2 va faire un test joint de la
diffrence entre traitement et contrle pour y2005-y2004 (la premire anne de
traitement), mais aussi pour y2006-y2005, et ainsi de suite. Pourtant il ny a pas de raison
que y2009-y2008 soit plus lev pour une firme traite : cest 4 ans aprs le traitement !
Deuxime possibilit, par contre, si on dfinit la priode de traitement comme seulement
2005 et quon laisse la variable TGTP retourner zro partir de 2006, alors psmatch2
risque de prendre la firme traite en 2008 comme contrle pour elle-mme en 2005. Pour
viter ce problme, la mthode ad-hoc consiste remplacer la variable TGTP par des
valeurs manquantes, pour toutes les firmes traites, partir de lanne aprs le traitement
(2006-2010 pour la firme traite en 2005).

Dernire chose noter, on peut courir une rgression en WLS avec des poids gaux 1
pour le groupe de traitement et r = _pscore/(1-_pscore) pour le groupe de contrle, et on
obtient des rsultats trs voisins du matching DID (voir Morgan et Harding 2006), avec
lavantage que comme cest une rgression on peut ajouter des contrles additionnels (par
exemple lanne calendaire de traitement).
Analyse de survie
Supposons que lon ait des donnes dexportation par firme, anne, produit et march de
destination sous la forme suivante :



La premire chose faire est de gnrer des zros pour les combinaisons (firm hs6
marked_d year) pour lesquelles il ny a pas dexportation, qui napparaissent pas ici. En
dautres termes, il faut crer un panel cylindr. On fait cela avec la commande
fillin (voir les dtails dans la section xx) puis on remplace les valeurs manquantes par
des zros (ici il faut exponentier les exportations puisquelles sont en logs) :

egen indiv = group(firm hs6 market_d)
fillin indiv year

gen outcome = exp(ln_value)
replace outcome = 0 if outcome == .


46
Ensuite on marque les vnements de dbut et de mort des spells par les muettes
suivantes :

gen start = (outcome != 0 & outcome[_n-1] == 0) | (outcome != 0 & year
== 1)
gen fail = (outcome==0 & outcome[_n-1]!=0) & year!=1

Puis on donne une tiquette (spell_id) chaque spell. On marque chaque ligne par n,
puis on sauve (sous un nouveau nom, ici survival2). Ensuite, on gnre un fichier avec
seulement la muette marquant le dpart de chaque spell et n (keep n start), on limine
toutes les observations autres que les dmarrages de spells (keep if start == 1), et on
gnre ltiquette (spell_id) comme lidentifiant de ligne (_n) dans ce nouveau fichier.

sort countrypair year
keep countrypair year start fail outcome
order countrypair year start fail outcome

* Tag spells

gen n = _n
sort n
save survival2, replace

keep n start
keep if start == 1
gen spell_id = _n
sort n

ce qui donne



Enfin on fusionne par n avec le fichier survival2 pour attacher chaque dmarrage de
spell lidentifiant spell_id :

merge n using survival2
sort n
drop _merge n

et on remplace toutes les valeurs manquantes de ltiquette (spell_id):

replace spell_id = spell_id[_n-1] if (spell_id==. & spell_id[_n-1]!=. &
outcome > 0)
order countrypair year spell_id start fail outcome

47
ce qui donne




Dans ltape suivante, on gnre des caractristiques de spell (par exemple dure, valeur
maximum, valeur initiale)

gen spell_alive = (outcome > 0)
sort spell_id year
by spell_id: egen duration = sum(spell_alive)
by spell_id: egen startyear = min(year)
by spell_id: egen endyear = max(year)
gen failtime = endyear + 1

by spell_id: egen max_outcome = max(outcome)
gen start_outcome = outcome if year == startyear
replace start_outcome = start_outcome[_n-1] if (start_outcome ==. &
start_outcome[_n-1]!=. & outcome > 0)

La base de donnes est maintenant prte tre transforme de faon dfinir la spell
comme unit dobservation, ce qui va rduire considrablement sa dimensionalit :

collapse(mean) countrypair startyear endyear failtime duration
max_outcome, by(spell_id)
gen lcensored = (startyear == 1)
gen rcensored = (endyear == 10)
gen fail2 = 1 - rcensored



On peut maintenant la dclarer comme base de donnes de survie par la commande stset :

stset failtime, id(spell_id) failure(fail2==1) origin(time startyear)

ce qui gnre un certain nombre de variables ad hoc :

48


La variable _st indique les observations qui seront gardes pour lanalyse de survie (ici,
toutes). La variable _d est gale un pour les observations non censures droite (elle est
gale 1 rcensored). La variable _origin indique lanne de dpart de la spell (elle
est gale startyear). Enfin stset gnre une variable _t0 ici gale zro pour
toutes les observationspas clair ce quelle est cense faire.

Les caractristiques de la base sont rsumes sur lcran stata :


Ce qui permet de vrifier un peu la bouille de tout le truc. On peut maintenant faire
tourner une rgression de Cox sur les donnes non censures gauche (la censure droite
est contrle par la procdure destimation) avec la commande

stcox max_outcome if lcensored==0, nohr

dans laquelle loption nohr donne des coefficients plutt que des ratios de taux de succs
(cest--dire des coefficients non exponentis). On teste le postulat de proportionnalit
des taux de succs avec un test de Schnfeld. Pour cela, il faut dabord utiliser les options
suivantes dans la rgression :

stcox max_outcome start_outcome if lcensored==0, nohr schoenfeld(sch*)
scaledsch(sca*)

puis la commande

stphtest, log detail

qui donne loutput suivant

49


Lhypothse nulle est celle de proportionnalit des taux de succs, sous laquelle la
rgression de Cox est valide. Ici, par exemple, elle est accepte (p value = 0.1830) pour
lensemble des rgresseurs, mais pas pour max_outcome. On peut aussi faire un nuage
des rsidus de Schnfeld en fonction du temps (en logs) avec une rgression smoother
(voir ci-dessous). Lhypothse nulle est que la pente du smoother est zro partout

-
5
0
5
1
0
1
5
s
c
a
l
e
d

S
c
h
o
e
n
f
e
l
d

-

m
a
x
_
o
u
t
c
o
m
e
2 4 6 8 10
Time
bandwidth = .8
Running mean smoother


Ce qui nest pas forcment trs facile vrifier comme on peut le constater.

Dans le cas de temps discret et quand le postulat de proportionalit des taux de succs est
viol, lalternative est de courir un probit en effets alatoires (xtprobit) sur la base de
donnes avant de lavoir transforme en spells. Il faut simplement remplacer la variable
doutcome par missing lanne aprs la mort du spell. Pour fixer les ides, supposons
quil sagisse dexportations. On garde toutes les annees dune spell partir du moment
o la valeur est positive (on ignore les annes avant) plus la premire annes o elles
retournent zro.

Graphiques
La commande de base est twoway suivie du type de graphique (line, bar, scatter, hist) et
des variables, dabord celle sur laxe vertical puis celle sur laxe horizontal. Pour
sauvegarder un graphique, on tape

graph save graph1, replace

et pour le r-ouvrir,

50
graph use graph1

Graphiques avec courbes ou barres
Pour un graphe avec des courbes cest

graph twoway line y x, xscale(range(0 100)) yscale(range(0 100)
xlabel(0(2)18)

o xscale et yscale donnent le minimum et le maximum sur les axes (utile par
exemple si on veut une symtrie), xlabel(0 10 to 100) et ylabel(0 10 to 100)
fixent les marques sur les axes (ici toutes les 10 units), c(l) dit Stata de relier les
points par une ligne, et s(i) lui dit de rendre les marqueurs invisibles, ce qui donne une
simple ligne. Les variables apparaissent automatiquement sous leur label et pas sous leur
nom de variable si on a spcifi un label par la commande

label variable x nimporte quoi

Il y a plusieurs faons de mettre deux courbes sur le mme graphique. En voici une :

twoway line y1 x, lpattern(l) xtitle() ytitle() || line y2 x,
lpattern(_)

o lpattern(l) indique que la ligne reprsentant y1 sera pleine et lpattern(_) que la
ligne reprsentant y2 aura des tirets longs.

Pour des barres avec ajustement de la couleur, cest

twoway bar count revokey, fcolor(gs15) xtitle(Revocation year) ytitle(#
of cases) ;

o gs15 donne un gris trs clair (pour economiser lencre de limprimante).

Pour un histogramme de la variable x, la commande la plus simple est

hist x, bin(10) xscale(range(0 100)) xtick(0(10)100) xlabel(0(10)100)

et le nom de la variable devra tre mis dans loption xtitle(my title). Si on veut la
densit la place dun histogramme, la commande est

kdensity x, n(100) width(0.01) normal ;
twoway (kdensity GDPpc, gaussian width(0.01) n(100))

o loption n(100) donne le nombre dobservations utilises (plus il y en a moins la
densit est lisse), width(0.01) dtermine la largeur des intervalles (important pour
viter que le graphique ne bave sur des valeurs hors de lintervalle permissible droite et
51
gauche) et loption normal superimpose sur le tout une distribution normale (je
suppose avec les mmes moyennes et variances) pour amuser le lecteur.

Si on veut raffiner la prsentation, on peut donner des prcisions sur lapparence des
lignes, ce qui peut tre important quand on veut superimposer plusieurs courbes sur le
mme graphique ; exemple

twoway (kdensity x, lpattern(longdash) lwidth(medthick)) ///
(kdensity y, lwidth(medthick) lcolor(red)) ///
(kdensity z, lpattern(shortdash_dot) lwidth(medthick) lcolor(blue))

On peut aussi spcifier des sous-options. Ainsi dans

hist x, width(10) xlabel(0(20)220, alternate format(%9.0fc)) percent

la sous-option alternate lintrieur de xlabel(0(20)220,) fait alterner la position
des chiffres le long de laxe pour quils ne se chevauchent pas et la sous-option
format(%9.0fc) limine les dcimales de ces chiffres, ce qui donne

0
1
0
2
0
3
0
4
0
P
e
r
c
e
n
t
0
20
40
60
80
100
120
140
160
180
200
220
avepm

On note que les tiquettes sarrtent 220 alors que les donnes vont plus loin ; viter
bien sr.

Nuages de points
Pour un nuage de points la commande est

graph twoway scatter y x, xtitle() ytitle()

De la mme faon, un scatterplot de y sur x avec la droite de rgression sera obtenu par

reg y x
twoway (scatter y x) (lfit y x)
52

ou bien

reg y x
twoway scatter y x || lfit y x

Si on veut avoir une courbe pour une rgression polynomiale, on peut taper

twoway (scatter y x) (qfit y x)

et si on veut lintervalle de confiance autour des valeurs prdites on tape lfitci ou
qfitci au lieu de lfit ou qfit, ce qui donne le joli graphe

-
2
0
2
4
6
-2 -1 0 1 2
x
y 95% CI
Fitted values


Un nuage de points pour la corrlation partielle entre une variable explicative x et une
variable dpendante y, contrlant pour les autres variables explicatives (disons z)
sobtient soit en crivant

reg y x z
gen bz = _b[z]
gen y_tilde = y bz*z
twoway scatter y_tilde x || lfit y_tilde x

ou plus simplement

reg y x z
avplot x

mais la droite de rgression ne sera pas en rouge et on ne peut pas raffiner avec qfit ou
avec les intervalles de confiance par exemple.

Lorsque lon veut mettre lun des axes (disons laxe horizontal) en logs, on peut soit
mettre la variable sur laxe horizontal en logs avec gen lx = ln(x) et garder une
chelle normale soit ajouter loption xscale(log). Si lon choisit la premire solution la
droite de rgression obtenue avec lfit a une drle de tte, avec un coude la fin. Si on
choisit la seconde, la droite de rgression a la bonne tte mais par contre la lecture est
53
moins facile (si on a des parts sur laxe horizontal, par exemple, on aura des logs
ngatifs).

Supposons maintenant que lon veuille un scatterplot de y par rapport x avec une droite
reprsentant la diagonale. On veut donc viter de relier les observations de y en fonction
de x (un nuage) mais par contre on veut relier les observations le long de la diagonale
pour avoir une ligne 45
o
. La srie de commandes est alors

gen diagonal=x ;
label variable y "Zambia's stats (log scale)" ;
label variable x "mirrored stats (log scale)" ;
twoway (scatter d x) (line diagonal x), xscale(range(018))
yscale(range(0 18)) xlabel(0(2)18) ylabel(0(2)18) ;

Le tout donne

mirrored stats (log scale)
Zambia's stats (log scale) diagonal
0 2 4 6 8 10 12 14 16 18
0
2
4
6
8
10
12
14
16
18

ce qui ne paye peut-tre pas de mine mais en couleur est beaucoup mieux (pas la moindre
ide comment rcuprer les couleurs, par contre). En loccurrence le nuage est tronqu
horizontalement 6 parce quil ny a pas de valeur miroir au-dessous de e
6
=403'000
dollars (pas de raison spciale).

Pour un nuage de points avec pour chacun une tiquette donne par la variable cty_name,
la commande est

twoway scatter y x, mlabel(cty_name) legend(off)

Souvent le problme est que les etiquettes se chevauchent ou sont trop prs, comme cest
le cas ici avec Canada et South Africa:

54
Argentina
Australia
Canada
China
EU
Mexico
New Zealand
South Africa
South Korea
Taiwan
Turkey
USA
Venezuela
2
0
4
0
6
0
8
0
1
0
0
A
v
e
r
a
g
e

m
e
a
s
u
r
e
s

d
u
r
a
t
i
o
n
0 50 100 150 200
Average duty rate


Le problme se rsout en gnrant une variable, pos, dont la valeur est la position de
ltiquette par rapport au point exprime en heure dhorloge (12 = en haut, 3 = droite, 6
= en bas etc.), et en ajustant cette variable :

gen pos = 3
replace pos = 11 if cty_name=="EU"
replace pos = 4 if cty_name=="South Africa"
replace pos = 2 if cty_name=="Canada"

twoway scatter l_bar t_bar, mlabel(cty_name) mlabv(pos) legend(off)

ce qui donne

Argentina
Australia
Canada
China
EU
Mexico
New Zealand
South Africa
South Korea
Taiwan
Turkey
USA
Venezuela
2
0
4
0
6
0
8
0
1
0
0
A
v
e
r
a
g
e

m
e
a
s
u
r
e
s

d
u
r
a
t
i
o
n
0 50 100 150 200
Average duty rate


Si on ne veut des tiquettes que pour certains points, il faut dfinir une nouvelle variable
comme ceci

gen show_tag =
(cty_name=="ARG" | cty_name=="BRA" | cty_name=="BEL" | cty_name=="BRA"
| cty_name=="CHL" | cty_name=="COL" | cty_name=="ECU" | cty_name=="PER"
| cty_name=="PRY" | cty_name=="URY" | cty_name=="VEN") ;

55
gen str3 tag = cty_name if show_tag==1 ;
twoway scatter l_bar t_bar, mlabel(tag) mlab(pos) legend(off)

Si on veut des boulettes vides pour tous les pays et des boulettes rouges pour disons le
botswana, la faon bourrin de le faire cest

gen t2 = t if countrycode == "BWA"
replace t = . if countrycode == "BWA"
label variable t "Theil index"
label variable t2 "Theil index, Botswana"

twoway scatter t gdp_pc_PPP_2005, mfcolor(black) mlwidth(thin) ///
|| scatter t2 gdp_pc_PPP_2005, mfcolor(red) mlwidth(thin)

Lotion mfcolor cest pour le fill des points, et mlwidth cest pour leur entourage. Si
la place des points on veut avoir des bulles, disons bleues, avec une bordure mince, et
dont la taille est proportionnelle une troisime variable z, la commande devient

twoway scatter y x [weight = z], msymbol(circle) mfcolor(ltblue)
mlwidth(thin)

Si on veut des bulles et des tiquettes, il faut superimposer deux graphes, un nuage avec
les etiquettes sans bulles et un avec bulles sans tiquettes, en mettant celui avec les
tiquettes en dernier pour que les tiquettes ne soient pas caches par les bulles :

twoway scatter y x [w=z], msymbol(circle) mfcolor(gs15) mlwidth(thin)
|| scatter y x, mlabel(cty_name) msymbol(none) mlabcolor(black)

Pour la couleur, gs15 cest gris clair, cest le mieux.

Regressions non paramtriques ( smoother reg )
Pour une rgression non paramtrique dune variable x sur les centiles dune distribution
(disons le coefficient de Gini calcul sur les exportations dun pays, rgress sur le
revenu par habitant pour voir comment la diversification volue avec le revenu), la
commande est

xtile centile = gdpcap, nquantiles(100) ;
collapse(mean) Gini gdpcap, by(centile) ;
lowess Gini centile, bwidth(0.8) ;

On revient sur cette mthode plus bas pour les effets de changements de prix par tranche
de revenu.


56
Enqutes sur les scnes de mnages
The goverment are very keen on amassing statistics. They collect them, add them, raise them to
the nth power, take the cube root and prepare wonderful diagrams. But you must never forget that
every one of these figures comes in the first instance from the village watchman, who just puts
down what he damn well pleases.
Anonyme, cit dand Sir Josiah Stamp,
Some Economic Factors in Modern Life.
9


Les commandes statistiques ordinaires (moyenne, regression etc.) appliques une
enqute de mnages donnent des estims biaiss (voir Deaton 1997). Stata a plusieurs
commandes qui permettent de tenir compte de la structure de lenqute.

Supposons que l'enqute soit divise en diffrentes strates, que dans chaque strate, on ait
tir au sort un certain nombre de villages (qu'on appelle Primary Sampling Unit, ou PSU)
et que dans chaque village un certain nombre de mnages soit tir. Supposons aussi que
la variable identifiant la strate s'appelle strataid, que celle identifiant le village s'appelle
id_comm et que celle indiquant le poids du mnage s'appelle poids. La syntaxe pour
indiquer cette structure stata est

svyset [pweight=poids], strata(strataid) psu(id_comm)

Une fois que cette structure est dclare on na pas besoin de la rpter chaque
commande destimation. La commande svydes donne une description de lenqute sous
forme de tableau (combien de strates, de PSU etc)


Statistiques descriptives et manipulation de donnes
Moyennes, totaux et corrlations
La commande de moyenne est svymean et la commande de somme est svytotal. Celle-
ci nest pas exactement equivalente sum car on ne peut pas enregistrer le rsultat
comme une nouvelle variable comme dans egen somme = sum(output). A la place, la
procdure est

svytotal output;
mat A=e(b);
svmat A;
rename A1 somme;

La premire ligne calcule la somme de output mais n'enregistre pas le rsultat qui est
stock momentanment dans e(b). La deuxime ligne gnre un scalaire A gal e(b),

9
Toujours le manuel de Shazam
57
dont la troisime fait une variable (A1) que la dernire renomme somme . Cette
nouvelle variable est la somme sur toutes les observations de la variable output dans
laquelle chaque observation est pondre selon la structure de lenqute. Pour trouver la
moyenne, mme chose avec svymean au lieu de svytotal.

Les moyennes conditionnelles ne peuvent pas non plus se faire avec la commande by,
comme par exemple by year: egen average=mean(output). On est oblig de faire a
catgorie par catgorie, par example

svymean output if year==1993;
mat B=e(b);
svmat B;
rename B1 average93;

et ainsi de suite pour chaque anne.

Supposons que lon veuille calculer les valeurs mdianes dun certain nombre de
variables. Il y a une faon subtile dutiliser la procdure introduite pour des variables
indices :

foreach x in "lnfamily" "lnchefmage" "lnchefmage2"
"chefmeduc" "lnmembresage" "inputs" "lndepenses"
"lnparcellesexpl" {;
gen `x'x=`x';

On note que la procdure foreach est ici utilise avec des variables sans indice, le x tant
la variable elle-mme ; les huit variables gnres sont lnfamilyx, lnchefmagex etc.
Ensuite on refait une procdure similaire pour les indicer par anne


foreach j of numlist 1993 1997 1999 2001{;

/*egen `x'p`j'=median(`x') if year==`j';*/

svymean `x' if year==`j';
mat A=e(b);
svmat A;
egen `x'p`j'=mean(A1);
mat drop A;
drop A1;
};
};

Les corrlations sont difficiles calculer en tenant compte des strates, clusters etc Or si
lon nen tient pas compte les estims risquent dtre gravement biaiss. La commande
pour les calculer est

corr_svy

qui peut tre descendue du web par findit corr_svy.

58
Calculer des indices dingalit
Il y a quelques trucs descendre du web en commenant par search ineqerr, do
Stata dirige sur son site pour descendre les fichiers ncessaires. Il y a aussi une
commande inequal mais je ne sais pas quelle est la diffrence. La commande ineqerr
donne le coefficient de Gini et lindice dentropie de Theil. Je crois quelle admet les
poids de redressement et tous les bidouillages utiliss dans les enqutes de mnage mais
pas trs clair comment. La syntaxe pour calculer par exemple les indices dingalit pour
le revenu des mnages ruraux (income avec une variable muette rural gale un) est

ineqerr income if rural==1

Loutput donne aussi les carts-type des estims de ces indices calculs par bootstrapping
(par dfaut, le nombre de tirages est 100).

La commande en Sata 7 pour les courbes de Lorenz est glcurve7 et la syntaxe est la
suivante. Supposons que les poids de redressement (fw) soient donns par la variable
wgt :

glcurve7 income fw=wgt if rural==1, Lorenz saving lorenz1.wmf ;

Supposons que lon veuille comparer la courbe de Lorenz en 1993 et 1997. Loption
saving lorenz1.wmf sert exporter le graphique en format .wmf, qui souvre en
ACDSee ou autre chose et peut tre copi-coll dans word ou import dans latex.

Si la base de donnes contient une variable year gale 1993 ou 1997 selon les
observations (on suppose quon a mlang deux enqutes de mnages), on dfinit dans la
commande une variable gl(income) que Sata va appeler, dans le graphe, income_1993 ou
income_1997, et on lui prcise by(year) et split :

glcurve7 income fw=wgt if rural==1, gl(income) by(year) split Lorenz
saving lorenz1.wmf ;

et on a les deux courbes sur le mme graphique.

Densits
Pour tracer une distribution du revenu (variable income), on utilise la commande de
kernel density de la faon suivante :

kdensity income [fweight=poids], nogr gen(y fy) ;

Quelquefois la densit est crase par des outliers. On lui met alors une borne suprieure
avec if income<=level. Les intervalles sur lesquels la densit est calcule sont ajusts
par loption width(#) o # est exprim en termes de income (la variable sur laxe
horizontal). Plus il est petit moins la densit est lisse. Il est possible que la densit
59
dmarre un niveau de revenu ngatif invent , cest juste que lintervalle sur lequel
la premire observation est centre dborde sur les chiffres ngatifs. Il se peut aussi que
la courbe soit plus lisse sans les poids, cest voir.

Si on veut plusieurs densits sur le mme graphique, la srie de commandes est un peu
plus complique :

kdensity income [fweight=poids] if income<=level, nogr gen(y fy) ;
kdensity income [fweight=poids] if year==1993 & income<=level93, nogr
gen(fy93) at(y) ;
kdensity income [fweight=poids] if year==1999 & income<=level99, nogr
gen(fy99) at(y) ;
label var fy93 "1993" ;
label var fy99 "1999" ;
gr fy93 fy99 y, c(ll) xlab ylab ;

La premire commande gnre la densit pour les deux annes et les variables y (income)
et fy (frquence). La deuxime et la troisime font la mme chose pour les annes 1993 et
99 sparment. Les deux commandes label font apparatre les labels plutt que les noms
de variables sur le graphique ; enfin la dernire gnre le graphique combin, avec des
lignes (ll) dans la commande c(ll) (c est pour connect ) et les labels sur les axes
horizontal (xlab) et vertical (ylab). Les symboles sur les courbes (triangles etc.) sont
choisis avec la commande s().


Effet de changements de prix par tranche de revenu
Une procdure sympa consiste tracer une courbe reprsentant limpact dun
changement de prix par tranche de revenu (disons centiles). La procdure est la suivante.
Soit 1993 lanne de base sur laquelle on analyse limpact du changement de prix
(delta_p) sur le revenu (income). La premire commande gnre les centiles de la
distribution du revenu :

xtile centile = income, nquantiles(100) ;

puis pour chaque centile on calcule le delta_p moyen

foreach j of numlist 1/100{ ;
svymean delta_p if centile==`j' ;

et on sauvegarde le rsultat par la procdure habituelle

mat A=e(b) ;
svmat A ;
rename A1 delta_p`j' ;
mat drop A ;

60
On a alors cent variables delta_p`j que lon veut combiner en une seule. Problme: elles
ont toutes le mme format, savoir un chiffre positif sur la premire ligne (premire
observation) et des valeurs manquantes pour tout le reste. On les transforme alors en
gnrant cent nouvelles variables delta2_p`j, des constantes dans lesquelles toutes les
valeurs manquantes sont remplaces par la valeur positive de la premire ligne:

egen delta2_p`j=mean(delta_p`j') ;

puis on transforme une nouvelle fois ces constantes pour quelles soient gales cette
valeur positive seulement dans le bon centile j (et codes comme valeurs manquantes
pour tous les autres centiles):

egen delta3_p`j'=mean(delta2_p`j) if centile==`j' ;

puis on laisse tomber les variables de calculs intermediaries et on ferme laccolade car on
na plus besoin de lindice j:

drop delta_p`j delta2_p`j ;
} ;

et on combine ces cent variables delta3_p`j en une seule en en faisant la somme
horizontale (avec egen, ce qui permet dadditionner travers les valeurs manquantes)

egen newdelta_p=rsum(delta3_p1-delta3_p100) ;

enfin on garde seulement ce dont on a besoin (on ne met ici que newdelta_p et centile
mais on peut vouloir garder dautres variables pour autre chose!)

collapse newdelta_p, by(centile) ;

et finalement on rgresse newdelta_p sur centile en utilisant le lowess smoother qui
recalcule la pente de la droite de regression pour chaque observation en prenant 40% de
lchantillon gauche de lobservation et 40% droite, soit 80% en tout (ce qui peut tre
ajust avec bwidth()).

lowess newdelta_p centile, bwidth(0.8) ;

Le rsultat est une courbe indiquant que le changement de prix est favorable aux pauvres
si elle est pente ngative et favorable aux riches si elle est pente ngative. Une
procdure similaire peut tre utilise pour calculer leffet dun tarif par tranche de revenu
(le delta p est alors leffet du tarif sur le revenu rel moyen des mnages dans la tranche,
soit via les prix la consommation soit via les revenus soit les deux). Exemple :
61
-
.
5
0
.
5
1
1
.
5
2
P
r
o
d
u
c
e
r

p
r
i
c
e

i
n
d
e
x
0 20 40 60 80 100
Centile
bandwidth = .8
Lowess smoother


Ici (Madagascar 1999-2001) le changement des prix la production est une fonction
ngative des centiles (classs par ordre croissant de revenu, les plus riches droite), donc
il est pro-pauvre . On note la distribution uniforme des points le long de laxe
horizontal : cest parce que lon a bien rgress les p sur les centiles et non sur les
niveaux de revenu. Pas trs intuitif, certes, mais on saperoit vite lusage que la
rgression sur les niveaux de revenu donne un graphique compltement diffrent. A
noter, aussi, avant de sexciter, que le sous-chantillon glissant recalcul par Stata
pour chaque observation est plus petit aux extrmes quau milieu (bien ncessairement,
sinon il ne pourrait pas tre diffrent pour chaque observation). Les non-linarits plus
marques observes souvent prs des extrmes en sont le reflet, donc interprter
prudemment.

Pour samuser voici un do-file qui fait la procdure (avec les commandes jour pour
Stata 12) sur un toy sample

/* THIS FILE GENERATES A SMOOTHER REG */

clear
set more off

* Create bogus data with 1000 people and lognormal income distribution

set obs 1000
gen lincome = invnorm(uniform())
gen income = exp(lincome)
gen delta_p = uniform() + 0.1*income

* Give it HH survey format, with psu as indiv. and random[0,1] sampling
weights

gen psu = _n
gen weight = uniform()
svyset psu [pweight=weight]

* generate delta p by centile

xtile centile = income, nquantiles(100)
sort centile income
62

foreach j of numlist 1/100{
svy: mean delta_p if centile==`j'
mat A=e(b)
svmat A
rename A1 delta_p`j'
mat drop A
egen delta2_p`j'=mean(delta_p`j')
replace delta2_p`j'= 0 if centile!=`j'
drop delta_p`j'
}

egen newdelta_p = rsum(delta2_p1-delta2_p100)
collapse newdelta_p, by(centile)

* Run smoother reg

ksm newdelta_p centile, bwidth(0.25)

Et voila.
Estimation sur des enqutes
Une fois que lon a indiqu Stata la structure de lenqute avec svyset/svydes, on
peut utiliser les commandes spciales (svyreg, svyprobit, svyivreg,
svyheckman,) sans avoir prciser chaque fois les poids, les clusters et les strates de
lchantillon, par exemple

svyreg y x1 x2 x3 ;

Si par contre on na rien dclar au dbut comme structure denqute, la commande est

svyreg [pweight=poids], strata(strataid) psu(id_comm);


Modles de slection
Supposons que lon veuille estimer sur des donnes denqute le modle

1
*
2
,
,
1 si * 0
0 sinon,
y X u
I Z u
I
I
|

= +
= +
=

>

avec u
1
and u
2
suivant une distribution normale avec moyenne zro et variances
2
et un
respectivement, et correlation . La version la plus simple de la commande est

63
svyheckman y x1 x2 x3, select(I=x1 x2 z1 z2)

et bien entendu de nombreux raffinements peuvent tre ajouts.

64
Quelques trucs en Mata


Pour construire une matrice mata avec des variables sauvegardes dans un fichier stata, la
commande est

st_view(X=.,.,("x1","x2"))

o le premier argument donne le nom, le deuxime lui dit de prendre toutes les
observations, et le troisime dfinit les colonnes par le nom des variables. La fonction
st_view fait la mme chose que la fonction st_data mais prend moins de mmoire car
elle ne fait que regarder les donnes au lieu de les stocker sparment.

Pour gnrer des variables mata contenant le nombre dobservations et de paramtres,
cest

N = rows(X)
k = cols(X)

Pour gnrer le vecteur beta en mata aprs une regression stata, cest pareil:

reg y x1 x2
mat coeff = e(b)
svmat coeff

mata
st_view(b=.,1,("coeff1","coeff2","coeff3"))
end

o le deuxime argument lui dit de ne garder que la premire observation, ce qui
transforme les variables stata cres par mat coeff = e(b) en un vecteur-ligne 1 x k.

Si on veut calculer en mata lestimateur des moindres carrs partir dun chantillon
fabriqu pour samuser, voil le programme :

set obs 100 ;
gen const = 1 ;
gen x1 = invnormal(uniform()) ;
gen x2 = invnormal(uniform()) ;
save regressors, replace ;

use regressors, clear ;
gen u = 3*invnormal(uniform()) ;
gen y = 2 + 3*x1 -4*x2 + u ;

mata ;

st_view(y=.,.,"y") ;
65
st_view(X=.,.,("const","x1","x2")) ;
b = invsym(X'X)*X'y ;
b ;

e = y - X*b ;
n = rows(X) ;
k = cols(X) ;
s2 = (e'e)/(n-k) ;
s2 ;

end ;

Pour dfinir un vecteur-colonne mx1 contenant des 0 , on peut taper

real matrix iota(real scalar m) {
real matrix iota
iota = J(m,1,0)
return(iota)
}

Une variable contenant la trace dun produit de matrices se dfinit par

t = trace(A,B)

pour tr(AB) et

t = trace(A,B,1)

pour tr(AB).

Pour introduire une commande stata dans mata, cest

{
stata(`"drop _all"')
}

Je nai pas trouv comment faire de programme mata dans un programme : deux end
lun aprs lautre le font capoter. Il faut donc mettre toutes les commandes mata une par
une avec le prfixe mata : au dbut de chaque commande.