CCPINP 2019 Pelletier Sylvain PSI, LMSC

(1)

CCPINP 2019

Pelletier Sylvain PSI, LMSC

Partie II : Analyse de données Q1. C’est une selection :

1 S E L E C T i d p a t i e n t F R O M M E D I C A L W H E R E e t a t = " h e r n i e d i s c a l e "

(on pourrait ajouter le mot clé DISTINCT si il y a plusieurs enregistrements pour un même patient dans la table MEDICAL).

1 S E L E C T D I S T I N C T i d p a t i e n t F R O M M E D I C A L W H E R E e t a t = " h e r n i e d i s c a l e "

Q2. Il faut faire une jointure avec la table PATIENT :

1 S E L E C T P A T I E N T . nom , P A T I E N T . p r e n o m F R O M M E D I C A L

3 J O I N P A T I E N T ON P A T I E N T . id = M E D I C A L . i d p a t i e n t W H E R E e t a t = " s p o n d y l o l i s t h é sis "

Q3. C’est une agrégation par état et l’application de la fonction d’agrégation COUNT pour chacun des états.

Si l’on considère qu’il n’y a qu’un enregistrement par patient dans MEDICAL : S E L E C T etat , C O U N T(*) F R O M M E D I C A L G R O U P BY e t a t

sinon :

1 S E L E C T etat , C O U N T( D I S T I N C T i d p a t i e n t ) F R O M M E D I C A L G R O U P BY e t a t

Q4. Dans le cas présent, c’est plutôt le fait que les tableaux prennent le minimum de place en mémoire qui est intéressant.

Dans le cas d’une liste, comme la taille de la liste peut changer, Python alloue plus d’espace que nécessaire pour stocker la liste. Dans le cas d’un array, comme la taille est fixe, Python alloue exactement la taille nécessaire au stockage.

Q5. On aN×nréels stockés sur 32 bits dansdata. Dansetaton aNentiers sur 8 bits. Au final, on a : N×n×32+N×8

AvecN=100000 etn=6, cela donne : 20000000, ainsi 20Go.

Q6. On propose plusieurs méthodes :

1 def s e p a r a t i o n P a r G R o u p e( data , e t a t ):

"""

3 e n t r é e : d a t a = 2 d a r r a y Nxn

= d o n n é es m é d i c a l e s

5 e t a t = 1 d a r r a y N

= e t a t de c h a q u e p a t i e n t

7

s o r t i e : L0 , L1 , L2 = N a r r a y

9 = d o n n é es m é d i c a l e s p o u r c h a c u n des é t a t s

"""

11 N , n = s h a p e( d a t a )

13 # e x t r a c t i o n d ’ une l i g n e a j o u t é par a p p e n d L0 = []

15 for i in r a n g e( N ):

if e t a t [ i ] == 0 :

17 L0 . a p p e n d ( d a t a [ i , : ] )

19 # l i s t e en c o m p r é h e n s i o n

L1 = [ d a t a [ i ,:] for i in r a n g e( N ) if e t a t [ i ] == 1]

21

# i d e m s a n s u t i l i s e r l ’ e x t r a c t i o n de l i g n e

(2)

23 L2 = []

for i in r a n g e( N ):

25 if e t a t [ i ] == 2:

L t m p = []

27 for k in r a n g e( n ):

L t m p . a p p e n d ( d a t a [ i , k ] )

29 L2 . a p p e n d ( L t m p )

31 r e t u r n L0 , L1 , L2

Autre idée :

1 L = [ [] , [] , [] ] # les t r o i s l i s t e s a c t u e l l e m e n t v i d e s for i in r a n g e( N ):

3 L [ e t a t [ i ]]. a p p e n d ( d a t a [ i ,:] ) r e t u r n L

Q7. Pour l’instruction l13, il s’agit de choisir le graphique ligneicolonne jdans un ensemble den×ngraphiques, sachant que les graphiques sont numérotés à partir de 1 et de haut gauche vers le bas droite. Cela donne donc ;

ax1 = plt . s u b p l o t ( n , n , i * n + j +1)

Pour l’instruction l18, il s’agit de tracer l’attributien fonction de jpour l’étatk. Ces données se trouvent dans les colonnesiet jdu tableaugroupe[k]

Cela donne donc :

ax1 . s c a t t e r ( g r o u p e s [ k ][: , i ] , g r o u p e s [ k ][: , j ] , m a r k e r = m a r k [ k ])

Pour le test l15, il s’agit de savoir si on n’est sur la diagonale :

1 if i != j :

Pour l’instruction l21, il s’agit de dessiner un histogramme de la colonne jdedata:

1 ax1 . h i s t ( d a t a [: , j ]

Q8. Les diagrammes sur la diagonale indique la répartition d’un attribut dans la population.

Les diagrammes hors de la diagonale montrent la corrélation entre deux attributs.

Partie III : Apprentissage et prédiction III-1 Méthode KNN

Q9. On suppose que l’on fait une correction linéaire : x_j= x_j−min(X)

max(X)−min(X) Q10. C’est très classique :

1 def m i n _ m a x( X ):

m i n i = m a x i = X [0]

3 for x in X :

if x < m i n i :

5 m i n i = x

e l i f x > m a x i :

7 m a x i = x

r e t u r n mini , m a x i

Q11. Il faut faire la distance euclidienne usuelle : def d i s t a n c e( z , d a t a ):

2 """

e n t r é e : z = 1 d a r r a y de t a i l l e n

4 = d o n n é es sur un n o u v e a u p a t i e n t d a t a = 2 d a r r a y Nxn

6 = d o n n é es d a n s la b a s e

(3)

s o r t i e : D = 1 d a r r a y de t a i l l e N

8 = D [ i ] est la d i s t a n c e e u c l i d i e n n e e n t r e les d o n n é es du n o u v e a u p a t i e n t et les d o n n é es du p a t i e n t i

10 """

N , n = s h a p e( d a t a )

12 D = z e r o s ( N )

14 D [ i ] = s q r t( sum ( ( d a t a [ i ,:] - z ) * * 2 ) ) Une autre solution (à la place de la dernière ligne) :

2 D [ i ] = 0 # i n u t i l e car D est i n i t i a l i s é a v e c des 0 for k in r a n g e( n ):

4 D [ i ] += ( d a t a [ i , k ] - z [ k ] ) * * 2 D [ i ] = s q r t( D [ i ])

Q12. C’est un tri fusion, la fonctionfcteffectue la fusion. Ce tri est plus rapide (complexité enO(nln(n))) que le tri par insertion (complexité enO(n)), mais il n’est pas fait sur place : il est nécessaire de stocker créer des copies de parties du tableau (l6-8 et l9-12)

Q13. C’est l’algorithme de fusion qui est fait dans la fonctionfct: def fct( T1 , T2 ):

2 if T1 == [] :

r e t u r n T2

4 if T2 == []

r e t u r n T1

6 if T1 [ 0 ] [ 0 ] < T2 [ 0 ] [ 0 ]

r e t u r n [ T1 [ 0 ] ] + fct ( T1 [1 ,:] , T2 )

8 e l s e:

r e t u r n [ T2 [ 0 ] ] + fct ( T1 , T2 [1 ,:])

Q14. La partie 1 crée et trie une listeT de couple de la forme[dist(i), i], pour chaque patientienregistré dansdata.

Les couples sont triés en fonction de la distance. En regardant la deuxième composante de chaque couple, on peut alors connaître quels sont les patients les plus proches. En particulier, lesKpremiers éléments de cette liste sont lesK patients les plus proches.

Dans la partie 2, on compte pour chaque état combien de patient sont dans cet état dans le groupe desKplus proche patient. Après ces lignes,select[k]contiendra le nombre de patient dans l’étatkparmi lesKplus proches dez.

Pour les partie 3, on recherche l’indice le plus grand dansselect, autrement dit, on recherche l’état avec le plus grand nombre de patient parmi lesKplus proches dez.

Ainsi :

• dist contient la liste des distances :dist(i)est la distance entre les données du patientiet du patientz.

• T contient une liste de couple de la forme[dist(i), i], pour chaque patientienregistré dansdata.

• selectest une liste de la taille le nombre d’état :select[k]le nombre de patient dans l’étatkparmi lesKplus proches dez.

• indest un indice dansselect: c’est l’indicekoùselect[k]est le plus grand, c’est donc l’état avec le plus grand nombre de patient parmi lesKplus proches dez.

Q15. Sur la diagonale on a le nombre d’état bien déterminé par l’algorithme.

La première ligne indique :

• 23 patients (de la basedataset) dont on sait qu’ils sont dans l’état 0, ont été détectés dans l’état 0 par l’algorithme.

La première colonne indique :

Cette matrice permet ainsi de mesurer la qualité de la détection et de déterminer le nombre d’erreurs.

Q16. Le taux de réussite peut être considéré comme croissant jusqu’àK=8, puis constant jusqu’àK=13, puis décroissant.

L’idée est que :

• si on ne prend pas assez de voisins, alors on n’exploite pas suffisamment les données. Dans le cas extrême où on ne prend qu’un seul voisin, on est sensible aux erreurs de mesures.

(4)

• si on prend trop de voisins, alors on ajoute des fausses détections, puisqu’on prend en compte des patients«loin» du patient à tester.

Cet algorithme est donc critiquable car la valeur du paramètreKest difficile à déterminer.

R PlusKest grand plus l’algorithme est lent.

III-3 Méthode de classification naïve bayésienne Q17. C’est un classique de cours :

def m o y e n n e( x ) :

2 n = len( x ) r e t u r n sum( x )/ n

En supposant que l’on manipule des array, on peut écrire :

1 def v a r i a n c e( x ) : n = len( x )

3 m = m o y e n n e ( x )

r e t u r n sum( ( x - m ) * * 2 ) / n

Q18. Il faut découper en groupe puis appliquer les fonction précédentes sur chacun des groupes : def s y n t h e s e( data , e t a t ) :

2 """

e n t r é e : v o i r p l u s haut ,

4 s o r t i e : l i s t e M o y V a r = l i s t e de c o u p l e s de t a i l l e nb x n nb nbr de g r o u p e s

6 n nbr d ’ a t t r i b u t s

= l i s t e de la f o r m e [ moy , var ]

8 à la l i g n e k c o l o n n e j d o n n e la m o y e n n e et v a r i a n c e de l ’ a t t r i b u t j p o u r le g r o u p e k

"""

10

# on r é cup è re les g r o u p e s

12 g r o u p e s = s e p a r a t i o n P a r G r o u p e ( data , e t a t )

# c o n v e r s i o n c o m m e Q7 :

14 nb = len( g r o u p e s ) for k in r a n g e( nb ):

16 g r o u p e s [ k ] = a r r a y ( g r o u p e s [ k ])

18 # n est le n o m b r e d ’ a t t r i b u t ( ne d é p e n d pas du g r o u p e )

# NG est le n o m b r e d ’ i n d i v i d u d a n s le g r o u p e

20 NG , n = len( g r o u p e s [ 0 ] )

22 # i n i t i a l i s a t i o n de la s o r t i e

l i s t e M o y V a r = [ [ [0 ,0] for j in r a n g e( n )] for k in r a n g e( nb )]

24

26 for k in r a n g e( nb ) : for j in r a n g e( n ) :

28 mu , sig = m o y e n n e ( g r o u p e s [ k ][: , j ]) , s q r t( v a r i a n c e ( g r o u p e s [ k ][: , j ])) l i s t M o y V a r [ k ][ j ] = [ mu , sig ]

30

r e t u r n l i s t M o y V a r

Q19. Il suffit d’appliquer la formule (attention à la confusion variance / écart-type) :

1 def g a u s s i e n n e( a , moy , v ):

"""

3 e n t r é e : a = f l o a t = d o n n é e moy = f l o a t = m o y e n n e

5 v = f l o a t = v a r i a n c e

s o r t i e : f l o a t = v a l e u r de P ( X = a ) p o u r X qui s u i t une g a u s s i e n n e

7 """

r e t u r n exp ( -( a - mu ) * * 2 / (2* v ) ) / s q r t(2* pi * v )

(5)

Q20. On peut faire :

def p r o b a b i l i t e G r o u p e( z , data , e t a t ):

2 l s y n = s y n t h e s e ( data , e t a t ) # l i s t e de l i s t e de c o u p l e nb = len( l s y n ) # nbr d ’ é tat (3 sur l ’ e x e m p l e )

4 n = len( z ) # nbr d ’ a t t r i b u t s l p r o b a = [ 0 for i in r a n g e( nb ) ]

6 for e t a t in r a n g e( nb ):

p r o b a = 1

8 for i in r a n g e( n ):

moy , sig = l s y n [ e t a t ][ i ]

10 p r o b a *= g a u s s i e n n e ( z [ i ] , moy , sig * * 2 ) l p r o b a [ e t a t ] = p r o b a

12 r e t u r n l p r o b a

Q21. c’est une simple recherche de l’indice maximum : def p r e d i c t i o n( z , data , e t a t ):

2 l p r o b a = p r o b a b i l i t e G r o u p e ( z , data , e t a t )

4 e t a t = 0

for i in r a n g e(len( l p r o b a )):

6 if l p r o b a [ i ] > l p r o b a [ e t a t ]:

e t a t = i

8 r e t u r n e t a t Q22. Plusieurs explications :

• On utilise des valeurs plutôt petite (entre 0 et 1).

• Cela permet de remplacer le produit par une somme.

Q23. Le pourcentage de réussite peut se calculer ainsi : def t a u x R e u s s i t e( m a t C o n f u s i o n ) :

2 """

e n t r é e : m a t C o n f u s i o n = a r r a y nxn

4 = m a t r i c e de c o n f u s i o n

s o r t i e : t a u x = f l o a t

6 = t a u x de r é u s s i t e

"""

8 n , m = s h a p e( m a t C o n f u s i o n )

10 a s s e r t n == m , " m a t r i c e de c o n f u s i o n pas c a r r é e "

12 n b r P a t i e n t = 0 for i in r a n g e( n ):

14 for j in r a n g e( n ) :

n b r P a t i e n t += m a t C o n f u s i o n [ i , j ]

16

n b r R e u s s i t e = 0:

18 for i in r a n g e( n ):

n b r R e u s s i t e += m a t C o n f u s i o n [ i , i ]

20

t a u x = n b r R e u s s i t e / n b r P a t i e n t

22 r e t u r n t a u x

24 M1 = a r r a y ( [[23 , 4 , 7] , [7 , 11 , 1] ,

26 [5 , 2 , 4 0 ] ] )

M2 = a r r a y ( [[23 , 9 , 8] ,

28 [9 , 10 , 1] ,

[10 , 1 , 4 9 ] ] )

30 p r i n t(" t a u x de r é u s s i t e KNN : ", t a u x R e u s s i t e ( M1 ))

p r i n t(" t a u x de r é u s s i t e Bay é s i e n n e : ", t a u x R e u s s i t e ( M2 ))