Cours

Cours.TME3 History

Hide minor edits - Show changes to output

October 04, 2017, at 08:25 AM EST by 132.227.207.127 -
Changed line 57 from:
           data[classe].append ( map ( lambda x: float(x), champs ) )   
to:
           data[classe].append ( list ( map ( lambda x: float(x), champs ) ) )
Changed line 285 from:
   x = y = linspace ( 0, 9, 10 )
to:
   x = y = np.linspace ( 0, 9, 10 )
Changed line 194 from:
{$$\log p(x_0,\ldots,x_{255}) = \sum_{i=0}^{255} \log p(x_i) = \sum_{i=0}^{255} \left[- \frac{1}{2} \log(2 pi \sigma_i^2) - \frac{1}{2} \frac{(x_i - \mu_i)^2}{\sigma_i^2}\right]$$}
to:
{$$\log p(x_0,\ldots,x_{255}) = \sum_{i=0}^{255} \log p(x_i) = \sum_{i=0}^{255} \left[- \frac{1}{2} \log(2 \pi \sigma_i^2) - \frac{1}{2} \frac{(x_i - \mu_i)^2}{\sigma_i^2}\right]$$}
Changed line 194 from:
{$$\log p(x_0,\ldots,x_{255}) = \sum_{i=0}^{255} \log p(x_i) = \sum_{i=0}^{255} \left[- \frac{1}{2} \log(2\pi) - \log(\sigma_i) - \frac{1}{2} \left(\frac{x_i - \mu_i}{\sigma_i}\right)^2\right]$$}
to:
{$$\log p(x_0,\ldots,x_{255}) = \sum_{i=0}^{255} \log p(x_i) = \sum_{i=0}^{255} \left[- \frac{1}{2} \log(2 pi \sigma_i^2) - \frac{1}{2} \frac{(x_i - \mu_i)^2}{\sigma_i^2}\right]$$}
Changed lines 264-265 from:
Ecrivez maintenant une fonction '''classify_all_images''' @@: float np.array np.array np.array x (np.array,np.array) list -> float 2D-np.array@@ qui, étant donné le tableau @@test_data@@ des images du fichiers 2015_tme3_usps_test.txt tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).
to:
Ecrivez maintenant une fonction '''classify_all_images''' @@: float np.array np.array np.array x (np.array,np.array) list -> float np.2D-array@@ qui, étant donné le tableau @@test_data@@ des images du fichiers 2015_tme3_usps_test.txt tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).
Changed lines 269-270 from:
* '''T'''[2][3] = 0.040404040404040407
* '''T'''[5][3] = 0.050000000000000003
to:
* '''T'''[2,3] = 0.040404040404040407
* '''T'''[5,3] = 0.050000000000000003
Added lines 257-261:
----
!! %part%Partie optionnelle%%
----

Changed lines 264-267 from:
Ecrivez maintenant une fonction '''classify_all_images''' ( test_data, parameters ) qui, étant donné l'ensemble des images du fichiers USPS test tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).\\\


[+
'''%quest%7. Affichage du résultat des classifications%%'''+]
to:
Ecrivez maintenant une fonction '''classify_all_images''' @@: float np.array np.array np.array x (np.array,np.array) list -> float 2D-np.array@@ qui, étant donné le tableau @@test_data@@ des images du fichiers 2015_tme3_usps_test.txt tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).

Vous pourrez vérifier que:

* '''T'''[0,0] = 0.84958217
* '''T'''[2][3] = 0.040404040404040407
* '''T'''[5][3] = 0.050000000000000003

\\


[+'''%quest%8
. Affichage du résultat des classifications%%'''+]
Changed lines 203-204 from:
log_likelihood ( training_data[2][3], parameters[1] )
to:
test_data = read_file ( "2015_tme3_usps_test.txt" )
log_likelihood ( test
_data[2][3], parameters[1] )
Changed lines 207-208 from:
 -5519082.5638052924
to:
 -36631213.400524415
Changed line 210 from:
[ log_likelihood ( training_data[0][0], parameters[i] ) for i in range ( 10 ) ]
to:
[ log_likelihood ( test_data[0][0], parameters[i] ) for i in range ( 10 ) ]
Changed lines 213-216 from:
 [-149.62443954381081, -504197585.22396958, -382.00655932352549, -525.07933804053516,
  -1296.1912904988885, -470.24501959665633, -577.56381627528958, -488231.56186023896,
  -1096.4664169412206, -62150.816788906537]
to:
 [-80.594309481001218, -2030714328.0707991, -339.70961551873495, -373.97785273732529,
  -678.16479308314922, -364.62227994586954, -715.4508284953547,  -344286.66839952325,
  -499.88159107145611, -35419.208662902507]
Changed line 226 from:
log_likelihoods ( training_data[1][5], parameters )
to:
log_likelihoods ( test_data[1][5], parameters )
Changed lines 229-232 from:
 array([ -792.42878748156.17697398, -192.63706571, -274.26641292,
         -147.42010644, -213.90932792,  -63.77968814, -291.73180338,
         -116.81162003,  -70.7570653 ])
to:
 array([-889.22508387184.03163176, -185.29589129, -265.13424326,
        -149.54804688, -215.85994204,  -94.86965712, -255.60771575,
        -118.95170104,  -71.5970028 ])
Changed lines 238-252 from:
Ecrivez une fonction '''classify_image''' @@: float np.array x (float np.array,np.array) list -> float np.array@@ qui, étant donné une image et l'ensemble de paramètres déterminés dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.
to:
Ecrivez une fonction '''classify_image''' @@: float np.array x (float np.array,np.array) list -> int@@ qui, étant donné une image et l'ensemble de paramètres déterminés dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.

Vous pourrez vérifier que vous obtenez les mêmes résultats que ci-dessous:

(:source lang=python:)
classify_image( test_data[1][5], parameters )
(:sourceend:)

 1

(:source lang=python:)
classify_image( test_data[4][1], parameters )
(:sourceend:)

 9
Changed lines 178-179 from:

to:
\\
Changed lines 185-186 from:
[+'''%quest%4. Vraisemblance d'une image%%'''+]
to:
[+'''%quest%4. Log-vraisemblance d'une image%%'''+]
Changed lines 188-206 from:
[[(Attach:)2015_tme3_usps_test.txt | USPS test]]. Ce fichier a exactement le même format que celui d'apprentissage et peut donc être lu grâce à la fonction '''read_file'''. En particulier, pour chaque image, nous avons le chiffre auquel elle correspond, ce qui nous permettra de vérifier que notre classifieur fonctionne correctement. Téléchargez le fichier et lisez-le en utilisant '''read_file'''.

Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminés dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0).\\\


[+'''%quest%5. Classification d'une image%%'''+]

Ecrivez une fonction '''classify_image ( image, parameters )''' qui, étant donné une image et l'ensemble de paramètres déterminés dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.\\\


[+'''%quest%6. Classification de toutes les images%%'''+]

Ecrivez maintenant une fonction '''classify_all_images''' ( test_data, parameters ) qui, étant donné l'ensemble des images du fichiers USPS test tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).\\\


[+'''%quest%7. Affichage du résultat des classifications%%'''+]

Afin de visualiser les résultats obtenus par votre classifieur, exécutez la fonction suivante, qui prend en paramètres le tableau obtenu à la question précédente. Si votre classifieur est performant, vous devriez observer des pics sur la diagonale.

to:
[[(Attach:)2015_tme3_usps_test.txt | 2015_tme3_usps_test.txt]]. Ce fichier a exactement le même format que celui d'apprentissage et peut donc être lu grâce à la fonction '''read_file'''. En particulier, pour chaque image, nous avons le chiffre auquel elle correspond, ce qui nous permettra de vérifier que notre classifieur fonctionne correctement. Téléchargez le fichier et lisez-le en utilisant '''read_file'''.

Ecrivez une fonction '''log_likelihood''' @@: float np.array x (float np.array,np.array) -> float@@ qui, étant donné une image (donc un tableau de 256 nombres réels) et un couple
( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) ),
renvoie la log-vraisemblance qu'aurait l'image selon cet ensemble de {$\mu_i$} et {$\sigma_i$}. Rappelez-vous que:

{$$\log p(x_0,\ldots,x_{255}) = \sum_{i=0}^{255} \log p(x_i) = \sum_{i=0}^{255} \left[- \frac{1}{2} \log(2\pi) - \log(\sigma_i) - \frac{1}{2} \left(\frac{x_i - \mu_i}{\sigma_i}\right)^2\right]$$}

Notez que le module '''math''' contient une constante @@math.pi@@.
'''Attention:''' dans la liste @@parameters@@ calculée dans la question précédente, pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0).

Vous pourrez vérifier que vous obtenez les mêmes résultats que ci-dessous:

(:source lang=python:)
parameters = learnML_all_parameters ( training_data )
log_likelihood ( training_data[2][3], parameters[1] )
(:sourceend:)

 -5519082.5638052924

(:source lang=python:)
[ log_likelihood ( training_data[0][0], parameters[i] ) for i in range ( 10 ) ]
(:sourceend:)

 [-149.62443954381081, -504197585.22396958, -382.00655932352549, -525.07933804053516,
  -1296.1912904988885, -470.24501959665633, -577.56381627528958, -488231.56186023896,
  -1096.4664169412206, -62150.816788906537]

\\

[+'''%quest%5. Log-vraisemblance d'une image (bis)%%'''+]

Ecrivez une fonction '''log_likelihoods''' @@: float np.array x (float np.array,np.array) list -> float np.array@@ qui, étant donné une image (donc un tableau de 256 nombres réels) et la liste de paramètres déterminés dans la question 3, renvoie un tableau contenant, pour chaque chiffre possible entre 0 et 9, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3".

Vous pourrez vérifier que vous obtenez les mêmes résultats que ci-dessous:

(:source lang=python:)
log_likelihoods ( training_data[1][5], parameters )
(:sourceend:)

 array([ -792.42878748,  156.17697398, -192.63706571, -274.26641292,
        -147.42010644, -213.90932792,  -63.77968814, -291.73180338,
        -116.81162003,  -70.7570653 ])

\\


[+'''%quest%6. Classification d'une image%%'''+]

Ecrivez une fonction '''classify_image''' @@: float np.array x (float np.array,np.array) list -> float np.array@@ qui, étant donné une image et l'ensemble de paramètres déterminés dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.

\\


[+'''%quest%7. Classification de toutes les images%%'''+]
Changed lines 130-131 from:
%block text-align=center% ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) )\\\
to:
%block text-align=center% ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) )
Changed line 182 from:
En utilisant la fonction de la question précédente, écrivez une fonction '''learnML_all_parameters''' ( train_data ) qui, étant donné le tableau retourné par la fonction '''read_file''' (donc contenant toutes les images de toutes les classes), renvoie une '''liste''' de couples ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) ). Vous exécuterez cette fonction sur vos données d'apprentissage et sauvegarderez le résultat dans une variable '''parameters'''.\\\
to:
En utilisant la fonction de la question précédente, écrivez une fonction '''learnML_all_parameters''' @@: float np.array np.array np.array -> (float np.array x float np.array) list@@ qui, étant donné le tableau @@training_data@@ retourné par la fonction '''read_file''' (donc contenant toutes les images de toutes les classes), renvoie une '''liste''' de couples ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) ). Vous exécuterez cette fonction sur vos données d'apprentissage et sauvegarderez le résultat dans une variable '''parameters'''.\\\
Changed line 91 from:
La base qui va vous servir pour votre apprentissage de paramètres s'appelle [[(Attach:)2015_tme3_usps_train.txt | 2015_tme3_usps_train.txt]]. Téléchargez-la. La fonction '''read_file''' contenue dans le code python ci-dessus permet de lire ce fichier.
to:
La base qui va vous servir pour votre apprentissage de paramètres s'appelle [[(Attach:)2015_tme3_usps_train.txt | 2015_tme3_usps_train.txt]]. Téléchargez-la. La fonction '''read_file''' @@: string -> float np.array n.array np.array@@ contenue dans le code python ci-dessus permet de lire ce fichier.
Changed line 122 from:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images (en fait, nous allons étudier la fonction de densité car on travaille sur des variables aléatoires continues) . Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$p(X_0,\ldots,X_{255})$} représente la fonction de densité des teintes de gris des images de la classe et:
to:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images (en fait, nous allons étudier sa fonction de densité car on travaille sur des variables aléatoires continues) . Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$p(X_0,\ldots,X_{255})$} représente la fonction de densité des teintes de gris des images de la classe et:
Changed lines 128-129 from:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$} (autrement dit, {$p$}(@@X_i@@) = {$\cal{N}(\mu_i,\sigma^2_i)$}). Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe tel que retourné par la fonction '''read_file''', renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255. C'est-à-dire que '''learnML_class_parameters''' ( classe ) renverra un objet similaire à :
to:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$} (autrement dit, {$p$}(@@X_i@@) = {$\cal{N}(\mu_i,\sigma^2_i)$}). Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' @@: float np.array np.array -> float np.array x float np.array@@ qui, étant donné le tableau d'images d'une classe tel que retourné par la fonction '''read_file''' (autrement dit un tableau de tableaux de 256 nombres réels), renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255. C'est-à-dire que '''learnML_class_parameters''' ( classe ) renverra un objet similaire à :
Added lines 131-176:

Grâce à votre fonction '''learnML_class_parameters''', vous pouvez verifier que:

(:source lang=python:)
learnML_class_parameters ( training_data[0] )
(:sourceend:)

 (array([ 1.37185930e-03,  4.60217755e-03,  1.50770519e-02,
          5.87487437e-02,  1.66657454e-01,  4.28577052e-01,
          8.68415410e-01,  1.15260804e+00,  1.04628392e+00,
          6.46298995e-01,  2.58751256e-01,  7.90837521e-02,
          ...............................
          1.28302848e+00,  1.52802513e+00,  1.43905193e+00,
          1.04248827e+00,  5.32985762e-01,  1.74494137e-01,
          3.24891122e-02,  3.47487437e-03,  6.36515913e-05,
          0.00000000e+00]),
  array([ 2.24522353e-03,  6.60664324e-03,  1.95906222e-02,
          6.29011999e-02,  1.80366523e-01,  3.72113773e-01,
          5.31683397e-01,  5.38201451e-01,  5.62586277e-01,
          4.57620803e-01,  2.35928060e-01,  8.26775407e-02,
          ...............................
          4.46902042e-01,  3.40271867e-01,  1.30177809e-01,
          2.49171310e-02,  1.77752743e-03,  4.23882955e-06,
          0.00000000e+00] ) )

(:source lang=python:)
learnML_class_parameters ( training_data[1] )

(:sourceend:)

 (array([ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,
          0.00000000e+00,  3.98009950e-06,  1.27223881e-02,
          3.64843781e-01,  1.47724776e+00,  9.99703483e-01,
          1.18331343e-01,  4.97313433e-03,  0.00000000e+00,
          ...............................
          4.32477612e-01,  3.99064677e-02,  3.73731343e-03,
          6.62686567e-04,  4.67661692e-04,  0.00000000e+00,
          0.00000000e+00]),
  array([ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,
          0.00000000e+00,  1.59045568e-08,  7.47939656e-03,
          2.52206480e-01,  2.13186449e-01,  3.40351753e-01,
          7.76266554e-02,  3.64318435e-03,  0.00000000e+00,
          ...............................
          3.20651061e-01,  4.13332529e-02,  4.10675488e-03,
          4.40910100e-04,  2.19582288e-04,  0.00000000e+00,
          0.00000000e+00] ) )
Changed line 91 from:
La base qui va vous servir pour votre apprentissage de paramètres s'appelle [[(Attach:)2015_tme3_usps_train.txt | USPS training]]. Téléchargez-la. La fonction '''read_file''' contenue dans le code python ci-dessus permet de lire ce fichier.
to:
La base qui va vous servir pour votre apprentissage de paramètres s'appelle [[(Attach:)2015_tme3_usps_train.txt | 2015_tme3_usps_train.txt]]. Téléchargez-la. La fonction '''read_file''' contenue dans le code python ci-dessus permet de lire ce fichier.
Changed line 122 from:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images (en fait, la fonction de densité car on travaille sur des variables aléatoires continues) . Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$p(X_0,\ldots,X_{255})$} représente la fonction de densité des teintes de gris des images de la classe et:
to:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images (en fait, nous allons étudier la fonction de densité car on travaille sur des variables aléatoires continues) . Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$p(X_0,\ldots,X_{255})$} représente la fonction de densité des teintes de gris des images de la classe et:
Changed lines 109-115 from:
read_file ( usps_train.txt
to:
training_data = read_file ( "2015_tme3_usps_train.txt" )

# affichage du 1er chiffre "2" de la base:
display_image ( training_data[2][0] )

# affichage du 5ème chiffre "3" de la base:
display_image ( training_data[3][4] )
Added line 117:
Changed lines 25-27 from:
Vous allez tout d'abord télécharger la base qui va vous servir pour votre apprentissage de paramètres : [[(Attach:)2015_tme3_usps_train.txt | USPS training]]. Le format de ce fichier est décrit dans
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer, grâce à nos lois normales, à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite. Par exemple, si '''read_file'''("fichier") retourne un objet training_data, alors training_data[2] est le tableau de toutes les images du chiffre 2, training_data[2][3] correspond à la 4ème image du chiffre 2, autrement dit à un tableau de 256 nombres réels représentant cette image
.
to:
Vous allez tout d'abord copier-coller le code ci-dessous dans votre éditeur de python. Ne perdez pas de temps à essayer de comprendre les instructions de ces fonctions. Leur utilité est décrite en dessous du code.
Changed lines 31-32 from:
to:
import matplotlib.pyplot as plt
Changed lines 66-72 from:
(:sourceend:)

Afin de visualiser les images que vous allez manipuler, nous vous proposons ci-dessous une fonction '''display_image''' qui prend en argument une image (c'est-à-dire un tableau de 256 nombres réels) et qui l'affiche dans une fenêtre. Exécutez cette fonction sur quelques images de votre base d'apprentissage afin de visualiser les données que vous allez manipuler par la suite.

(:source lang=python:)
import matplotlib.pyplot as plt

to:
Changed line 69 from:
   Etant donné un tableau de 256 flotants représentant une image de 16x16
to:
   Etant donné un tableau X de 256 flotants représentant une image de 16x16
Added lines 89-109:
(:sourceend:)

La base qui va vous servir pour votre apprentissage de paramètres s'appelle [[(Attach:)2015_tme3_usps_train.txt | USPS training]]. Téléchargez-la. La fonction '''read_file''' contenue dans le code python ci-dessus permet de lire ce fichier.
Cette fonction renvoie un tableau de tableaux d'images:

* Chaque image a une taille de 16x16 pixels et représente un chiffre entre 0 et 9. Par exemple :

%block text-align=center% %width=200px%  Attach:2015_tme3_digit4.jpg Attach:2015_tme3_digit5.jpg Attach:2015_tme3_digit8.jpg

* Chaque image est modélisée par un tableau numpy de 256 nombres réels compris entre 0 et 2, qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels).

* Les images correspondant au même chiffre manuscript (0,...,9) sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer, grâce à nos lois normales, à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''.

* Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite. Par exemple, si '''read_file'''("fichier") retourne un objet @@training_data@@, alors @@training_data[2]@@ est le tableau de toutes les images du chiffre 2, et @@training_data[2][3]@@ correspond à la 4ème image du chiffre 2 (les indices des tableaux débutant à 0), autrement dit à un tableau de 256 nombres réels représentant cette image.

\\

La fonction '''display_image''', quant à elle, permet de visualiser les images que vous allez manipuler. Celle-ci prend donc en argument une image (c'est-à-dire un tableau de 256 nombres réels) et l'affiche dans une fenêtre. Exécutez cette fonction sur quelques images de votre base d'apprentissage afin de visualiser les données que vous allez manipuler par la suite. Par exemple, vous pouvez tester:

(:source lang=python:)
read_file ( usps_train.txt
Changed lines 20-22 from:
%block text-align=center% %width=200px%  Attach:2014_tme3_digit4.jpg Attach:2014_tme3_digit5.jpg Attach:2014_tme3_digit8.jpg

to:
%block text-align=center% %width=200px%  Attach:2015_tme3_digit4.jpg Attach:2015_tme3_digit5.jpg Attach:2015_tme3_digit8.jpg

Changed line 25 from:
Vous allez tout d'abord télécharger la base qui va vous servir pour votre apprentissage de paramètres : [[(Attach:)2014_tme3_usps_train.txt | USPS training]]. Le format de ce fichier est décrit dans
to:
Vous allez tout d'abord télécharger la base qui va vous servir pour votre apprentissage de paramètres : [[(Attach:)2015_tme3_usps_train.txt | USPS training]]. Le format de ce fichier est décrit dans
Changed lines 120-121 from:
[[(Attach:)2014_tme3_usps_test.txt | USPS test]]. Ce fichier a exactement le même format que celui d'apprentissage et peut donc être lu grâce à la fonction '''read_file'''. En particulier, pour chaque image, nous avons le chiffre auquel elle correspond, ce qui nous permettra de vérifier que notre classifieur fonctionne correctement. Téléchargez le fichier et lisez-le en utilisant '''read_file'''.
to:
[[(Attach:)2015_tme3_usps_test.txt | USPS test]]. Ce fichier a exactement le même format que celui d'apprentissage et peut donc être lu grâce à la fonction '''read_file'''. En particulier, pour chaque image, nous avons le chiffre auquel elle correspond, ce qui nous permettra de vérifier que notre classifieur fonctionne correctement. Téléchargez le fichier et lisez-le en utilisant '''read_file'''.
Changed line 150 from:
%block text-align=center% %width=450px%  Attach:2014_tme3_classified.jpg
to:
%block text-align=center% %width=450px%  Attach:2015_tme3_classified.jpg
Changed lines 3-4 from:
to:
%define=part apply=block bgcolor=#e6d8c0%
Added lines 6-7:

!! %part%Partie obligatoire%%
Changed line 97 from:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images. Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$P(X_0,\ldots,X_{255})$} représente la distribution de probabilité des teintes de gris des images de la classe et:
to:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images (en fait, la fonction de densité car on travaille sur des variables aléatoires continues) . Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$p(X_0,\ldots,X_{255})$} représente la fonction de densité des teintes de gris des images de la classe et:
Changed lines 99-103 from:
{$$P(X_0,\ldots,X_{255}) = \prod_{i=0}^{255} P(X_i).$$}

Ainsi, en choisissant au hasard une image dans l'ensemble de toutes les images possibles de la classe, on a une probabilité {$P$}(@@x_0,...,x_255@@) = {$\prod_{i=0}^{255} P$}(@@x_i@@) d'obtenir l'image @@np.array([x_0,...,x_255])@@, où les @@x_i@@ sont des nombres réels compris entre 0 et 2.

Nous allons de plus supposer que chaque
{$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe tel que retourné par la fonction '''read_file''', renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255. C'est-à-dire que '''learnML_class_parameters''' ( classe ) renverra un objet similaire à :
to:
{$$p(X_0,\ldots,X_{255}) = \prod_{i=0}^{255} p(X_i).$$}

Ainsi, en choisissant au hasard une image dans l'ensemble de toutes les images possibles de la classe, si celle-ci correspond au tableau @@np.array([x_0,...,x_255])@@, où les @@x_i@@ sont des nombres réels compris entre 0 et 2, alors la valeur de la fonction de densité de l'image est égale à {$p$}(@@x_0,...,x_255@@) = {$\prod_{i=0}^{255} p$}(@@x_i@@).

Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$} (autrement dit, {$p$}(@@X_i@@) = {$\cal{N}(\mu_i,\sigma^2_i)$})
. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe tel que retourné par la fonction '''read_file''', renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255. C'est-à-dire que '''learnML_class_parameters''' ( classe ) renverra un objet similaire à :
Added lines 26-27:
# -*- coding: utf-8 -*-
Changed lines 127-129 from:
Ecrivez maintenant une fonction '''classify_all_images''' ( test_data, parameters ) qui, étant donné l'ensemble des images du fichiers USPS test tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le nombre d'images correspondant dans la réalité au chiffre i et classées dans la classe j par votre classifieur.\\\

to:
Ecrivez maintenant une fonction '''classify_all_images''' ( test_data, parameters ) qui, étant donné l'ensemble des images du fichiers USPS test tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le pourcentage d'images correspondant dans la réalité au chiffre i que votre classifieur a classées dans la classe j (pour tout i, {$\sum_{j=0}^{9}$} '''T'''[i,{$j$}] = 100%).\\\

Changed line 145 from:
%block text-align=center% %width=400px%  Attach:2014_tme3_classified.jpg
to:
%block text-align=center% %width=450px%  Attach:2014_tme3_classified.jpg
Changed lines 134-145 from:
%block text-align=center% %width=200px%  Attach:2014_tme3_classified.jpg
to:
(:source lang=python:)
from mpl_toolkits.mplot3d import Axes3D

def dessine ( classified_matrix ):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    x = y = linspace ( 0, 9, 10 )
    X, Y = np.meshgrid(x, y)
    ax.plot_surface(X, Y, classified_matrix, rstride = 1, cstride=1 )
(:sourceend:)

%block text-align=center% %width=400px
%  Attach:2014_tme3_classified.jpg
Changed lines 117-119 from:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminés dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0) si le pixel de l'image a la même valeur que le {$\mu$} du pixel, et 0 sinon.\\\

to:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminés dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0).\\\

Added line 129:
Added lines 131-134:

Afin de visualiser les résultats obtenus par votre classifieur, exécutez la fonction suivante, qui prend en paramètres le tableau obtenu à la question précédente. Si votre classifieur est performant, vous devriez observer des pics sur la diagonale.

%block text-align=center% %width=200px%  Attach:2014_tme3_classified.jpg
Changed lines 117-120 from:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminé dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0).\\\


to:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminés dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0) si le pixel de l'image a la même valeur que le {$\mu$} du pixel, et 0 sinon.\\\

Changed lines 122-124 from:
Ecrivez une fonction '''classify_image ( image, parameters )''' qui, étant donné une image et l'ensemble de paramètres déterminé dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.\\\

to:
Ecrivez une fonction '''classify_image ( image, parameters )''' qui, étant donné une image et l'ensemble de paramètres déterminés dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.\\\

Changed line 127 from:
to:
Ecrivez maintenant une fonction '''classify_all_images''' ( test_data, parameters ) qui, étant donné l'ensemble des images du fichiers USPS test tel que retourné par la fonction '''read_file''' et l'ensemble de paramètres déterminés dans la question 3, renvoie un tableau numpy bi-dimensionnel '''T''' de taille 10x10 tel que '''T'''[i,j] représente le nombre d'images correspondant dans la réalité au chiffre i et classées dans la classe j par votre classifieur.\\\
Changed lines 117-121 from:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminé dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3".\\\



to:
Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminé dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3". '''Attention:''' pour certains pixels de certaines classes, la valeur de {$\sigma^2$} est égale à 0 (toutes les images de la base d'apprentissage avaient exactement la même valeur sur ce pixel). Dans ce cas, la vraisemblance de toute image sur ce pixel doit être de 1 (et donc sa log-vraisemblance doit être égale à 0).\\\


Added lines 123-125:
Ecrivez une fonction '''classify_image ( image, parameters )''' qui, étant donné une image et l'ensemble de paramètres déterminé dans la question 3, renvoie la classe la plus probable de l'image, c'est-à-dire celle dont la log-vraisemblance est la plus grande.\\\

Added lines 127-128:

Changed line 95 from:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images. Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$P(X_0,\ldots,X_{255})$} représente la distribution de probabilité des teintes de gris des images et:
to:
Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images. Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$P(X_0,\ldots,X_{255})$} représente la distribution de probabilité des teintes de gris des images de la classe et:
Changed lines 97-101 from:
{$$P(X_0,\ldots,X_{255}) = \prod_{i=0}^{255} P(X_i)$$}.

Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i
,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe, renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\

to:
{$$P(X_0,\ldots,X_{255}) = \prod_{i=0}^{255} P(X_i).$$}

Ainsi, en choisissant au hasard une image dans l'ensemble de toutes les images possibles de la classe
, on a une probabilité {$P$}(@@x_0,...,x_255@@) = {$\prod_{i=0}^{255} P$}(@@x_i@@) d'obtenir l'image @@np.array([x_0,...,x_255])@@, où les @@x_i@@ sont des nombres réels compris entre 0 et 2.

Nous allons de plus supposer que chaque
{$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe tel que retourné par la fonction '''read_file''', renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255. C'est-à-dire que '''learnML_class_parameters''' ( classe ) renverra un objet similaire à :

%block text-align=center% ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) )\\\


Added lines 109-111:
En utilisant la fonction de la question précédente, écrivez une fonction '''learnML_all_parameters''' ( train_data ) qui, étant donné le tableau retourné par la fonction '''read_file''' (donc contenant toutes les images de toutes les classes), renvoie une '''liste''' de couples ( array ( [{$\mu_0,\ldots,\mu_{255}$}] ), array ( [{$\sigma_0^2,\ldots,\sigma_{255}^2$}] ) ). Vous exécuterez cette fonction sur vos données d'apprentissage et sauvegarderez le résultat dans une variable '''parameters'''.\\\

Added lines 113-120:

Nous allons maintenant tester si, étant donné de nouvelles images, on peut classer celles-ci correctement, c'est-à-dire si on peut retrouver les chiffres auxquelles elles correspondent. Pour cela, nous allons utiliser de nouvelles images se trouvant dans le fichier
[[(Attach:)2014_tme3_usps_test.txt | USPS test]]. Ce fichier a exactement le même format que celui d'apprentissage et peut donc être lu grâce à la fonction '''read_file'''. En particulier, pour chaque image, nous avons le chiffre auquel elle correspond, ce qui nous permettra de vérifier que notre classifieur fonctionne correctement. Téléchargez le fichier et lisez-le en utilisant '''read_file'''.

Ecrivez une fonction '''log_likelihoods''' ( image, parameters ) qui, étant donné une image (donc un tableau de 256 nombres réels) et l'ensemble de paramètres déterminé dans la question précédente, renvoie un tableau contenant, pour chaque chiffre possible, la log-vraisemblance qu'aurait l'image si celle-ci correspondait à ce chiffre. Ainsi, si tab = '''log_likelihoods''' ( image, parameters ), tab est un tableau de 10 éléments (les 10 chiffres possibles) et tab[3] est égal à la log-vraisemblance de l'image dans la classe "chiffre = 3".\\\


Changed line 99 from:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters'''( classe ) qui, étant donné le tableau d'images d'une classe renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\
to:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' ( classe ) qui, étant donné le tableau d'images d'une classe, renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\
Changed line 99 from:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' qui, étant donné le tableau d'images d'une classe renvoie une couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\
to:
Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters'''( classe ) qui, étant donné le tableau d'images d'une classe renvoie un couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\
Added lines 94-100:

Dans ce TME, nous allons étudier la distribution de probabilité des teintes de gris des images. Nous allons faire l'hypothèse (certes un peu forte mais tellement pratique) que, dans chaque classe, les '''teintes des pixels sont mutuellement indépendantes'''. Autrement dit, si {$X_i$}, {$i=$}0,...,255, représente la variable aléatoire "intensité de gris du ''i''ème pixel", alors {$P(X_0,\ldots,X_{255})$} représente la distribution de probabilité des teintes de gris des images et:
 
{$$P(X_0,\ldots,X_{255}) = \prod_{i=0}^{255} P(X_i)$$}.

Nous allons de plus supposer que chaque {$X_i$} suit une distribution normale de paramètres {$(\mu_i,\sigma^2_i)$}. Par maximum de vraisemblance, estimez, pour une classe donnée, l'ensemble des paramètres {$(\mu_0,\ldots,\mu_{255})$} et {$(\sigma_0^2,\ldots,\sigma_{255}^2)$}. Pour cela, écrivez une fonction '''learnML_class_parameters''' qui, étant donné le tableau d'images d'une classe renvoie une couple de tableaux, le premier élément du couple correspondant à l'ensemble des {$\mu_i$} et le 2ème à l'ensemble des {$\sigma_i^2$}, {$i=$}0,...,255.\\\
 
Changed lines 23-24 from:
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer grâce à nos lois normales à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite. Par exemple, si '''read_file'''("fichier") retourne un objet training_data, alors training_data[2] est le tableau de toutes les images du chiffre 2, training_data[2][3] correspond à la 4ème image du chiffre 2, autrement dit à un tableau de 256 nombres réels représentant cette image.
to:
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer, grâce à nos lois normales, à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite. Par exemple, si '''read_file'''("fichier") retourne un objet training_data, alors training_data[2] est le tableau de toutes les images du chiffre 2, training_data[2][3] correspond à la 4ème image du chiffre 2, autrement dit à un tableau de 256 nombres réels représentant cette image.
Added lines 92-103:

[+'''%quest%2. Maximum de vraisemblance pour une classe%%'''+]

[+'''%quest%3. Maximum de vraisemblance pour toutes les classes%%'''+]

[+'''%quest%4. Vraisemblance d'une image%%'''+]

[+'''%quest%5. Classification d'une image%%'''+]

[+'''%quest%6. Classification de toutes les images%%'''+]

[+'''%quest%7. Affichage du résultat des classifications%%'''+]
Changed lines 23-24 from:
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer grâce à nos lois normales à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite.
to:
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer grâce à nos lois normales à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite. Par exemple, si '''read_file'''("fichier") retourne un objet training_data, alors training_data[2] est le tableau de toutes les images du chiffre 2, training_data[2][3] correspond à la 4ème image du chiffre 2, autrement dit à un tableau de 256 nombres réels représentant cette image.
Added lines 62-63:

Afin de visualiser les images que vous allez manipuler, nous vous proposons ci-dessous une fonction '''display_image''' qui prend en argument une image (c'est-à-dire un tableau de 256 nombres réels) et qui l'affiche dans une fenêtre. Exécutez cette fonction sur quelques images de votre base d'apprentissage afin de visualiser les données que vous allez manipuler par la suite.
Changed lines 8-9 from:
Dans ce TME, l'objectif est d'apprendre grâce à l'estimateur de maximum de vraisemblance les paramètres d'un ensemble de lois normales à partir d'une base de données. Ces lois normales seront ensuite exploitées pour faire de la classification (comme nous l'avions vu en cours avec les images de désert, forêt, mer et paysages enneigés).
to:
Dans ce TME, l'objectif est d'apprendre grâce à l'estimateur de maximum de vraisemblance les paramètres de lois normales à partir d'un ensemble de données. Ces lois normales seront ensuite exploitées pour faire de la classification (comme nous l'avions vu en cours avec les images de désert, forêt, mer et paysages enneigés).
Changed lines 22-23 from:
Téléchargez la base qui va vous servir pour votre apprentissage :
[[(Attach:)2014_tme3_usps_train.txt | USPS training]]
to:
Vous allez tout d'abord télécharger la base qui va vous servir pour votre apprentissage de paramètres : [[(Attach:)2014_tme3_usps_train.txt | USPS training]]. Le format de ce fichier est décrit dans
[[http://www-i6.informatik.rwth-aachen.de/~keysers/usps.html | format ]] mais, pour simplifier le TME, nous vous proposons ci-dessous une fonction qui permet de lire le fichier usps. Cette fonction renvoie un tableau de tableaux d'images. Chaque image est un tableau numpy de 256 nombres réels compris entre 0 et 2 qui caractérisent l'intensité des pixels dans l'image (16x16 = 256 pixels). Les images correspondant au même chiffre manuscript sont placées dans un même tableau. Le fichier usps indique en effet pour chaque image à quel chiffre celle-ci correspond. Dans le jargon de l'apprentissage, les chiffres sont appelés '''classes''' et, lorsque nous aurons de nouvelles images dont nous essayerons de déterminer grâce à nos lois normales à quel chiffre elles correspondent, nous dirons que nous faisons de la '''classification'''. Enfin, apprendre les paramètres de nos lois normales à partir d'un fichier qui contient pour chaque image sa classe s'appelle de l''''apprentissage supervisé'''. Pour terminer la description de l'objet retourné par la fonction '''read_file''', les tableaux d'images correspondant à chaque chiffre sont eux-mêmes stockés dans un tableau et c'est ce dernier qui est renvoyé. Chaque élément de ce tableau correspond donc à l'ensemble des images d'une classe. Le premier élément contient ainsi toutes les images du chiffre 0, le 2ème toutes celles du chiffre 1, et ainsi de suite.
Added lines 24-90:

(:source lang=python:)
import numpy as np

def read_file ( filename ):
    """
    Lit un fichier USPS et renvoie un tableau de tableaux d'images.
    Chaque image est un tableau de nombres réels.
    Chaque tableau d'images contient des images de la même classe.
    Ainsi, T = read_file ( "fichier" ) est tel que T[0] est le tableau
    des images de la classe 0, T[1] contient celui des images de la classe 1,
    et ainsi de suite.
    """
    # lecture de l'en-tête
    infile = open ( filename, "r" )   
    nb_classes, nb_features = [ int( x ) for x in infile.readline().split() ]

    # creation de la structure de données pour sauver les images :
    # c'est un tableau de listes (1 par classe)
    data = np.empty ( 10, dtype=object ) 
    filler = np.frompyfunc(lambda x: list(), 1, 1)
    filler( data, data )

    # lecture des images du fichier et tri, classe par classe
    for ligne in infile:
        champs = ligne.split ()
        if len ( champs ) == nb_features + 1:
            classe = int ( champs.pop ( 0 ) )
            data[classe].append ( map ( lambda x: float(x), champs ) )   
    infile.close ()

    # transformation des list en array
    output  = np.empty ( 10, dtype=object )
    filler2 = np.frompyfunc(lambda x: np.asarray (x), 1, 1)
    filler2 ( data, output )
   
    return output
(:sourceend:)

(:source lang=python:)
import matplotlib.pyplot as plt

def display_image ( X ):
    """
    Etant donné un tableau de 256 flotants représentant une image de 16x16
    pixels, la fonction affiche cette image dans une fenêtre.
    """
    # on teste que le tableau contient bien 256 valeurs
    if X.size != 256:
        raise ValueError ( "Les images doivent être de 16x16 pixels" )
   
    # on crée une image pour imshow: chaque pixel est un tableau à 3 valeurs
    # (1 pour chaque canal R,G,B). Ces valeurs sont entre 0 et 1
    Y = X / X.max ()
    img = np.zeros ( ( Y.size, 3 ) )
    for i in range ( 3 ):
        img[:,i] = X
       
    # on indique que toutes les images sont de 16x16 pixels
    img.shape = (16,16,3)
   
    # affichage de l'image
    plt.imshow( img )
    plt.show ()
(:sourceend:)

Changed line 23 from:
[[(Attach:)2014_tme3_usps_train.jf | USPS training]]
to:
[[(Attach:)2014_tme3_usps_train.txt | USPS training]]
Changed lines 17-21 from:
%block text-align=center% %width=300px%  Attach:2014_tme3_digit4.jpg Attach:2014_tme3_digit4.jpg



[+'''%quest%1. Loi de Bernoulli%%'''+]
to:
%block text-align=center% %width=200px%  Attach:2014_tme3_digit4.jpg Attach:2014_tme3_digit5.jpg Attach:2014_tme3_digit8.jpg


[+'''%quest%1. Préparation / visualisation%%'''+]

Téléchargez la base qui va vous servir pour votre apprentissage :
[[(Attach:)2014_tme3_usps_train.jf | USPS training]
]
Added line 17:
%block text-align=center% %width=300px%  Attach:2014_tme3_digit4.jpg Attach:2014_tme3_digit4.jpg
Changed lines 1-20 from:
xx
to:
%define=exo color=red%
%define=quest color=blue%

! Apprentissage de paramètres par max de vraisemblance

----

Dans ce TME, l'objectif est d'apprendre grâce à l'estimateur de maximum de vraisemblance les paramètres d'un ensemble de lois normales à partir d'une base de données. Ces lois normales seront ensuite exploitées pour faire de la classification (comme nous l'avions vu en cours avec les images de désert, forêt, mer et paysages enneigés).

Ici, notre base de données d'apprentissage est la base
%target=_blank% [[https://www.otexts.org/1577 | USPS]]%%. Celle-ci contient les images réelles de chiffres provenant de codes postaux écrits manuellement et scannés par le service des postes américain. Ces données scannées ont été normalisées de manière à ce qu'elles soient toutes des images de 16x16 pixels en teintes de gris, cf. Le Cun et al., 1990:

Y. LeCun, O. Matan, B. Boser, J. S. Denker, ''et al.'' (1990) "Handwritten zip code recognition with multilayer networks". In ICPR, volume II, pages 35–40.

Voici quelques exemples d'images de cette base :




[+'''%quest%1. Loi de Bernoulli%%'''+]
Added line 1:
xx