machine learning : exercices en python

Machine learning Exercices en python

Emmanuelle Jardat

Udacity scikit-learn openclassroomhellipand co

httpsopenclassroomscomfrcourses4011851-initiez-vous-

au-machine-learning

httpsopenclassroomscomfrcourses4379436-explorez-

vos-donnees-avec-des-algorithmes-non-supervises

httpwwwxavierduprefrappensae_teaching_cshelpsphinx

notebooks_gs2a_ml_basehtml

httpsjakevdpgithubioPythonDataScienceHandbook

httpsfutureoflifeorgbackgroundbenefits-risks-of-artificial-

intelligence

httpwwwxavierduprefrappactuariat_pythonhelpsphinxno

tebooksseance4_projection_population_correctionhtml

httpsmakina-corpuscomblogmetier2017initiation-au-

machine-learning-avec-python-pratique

Avant propos ce cours regroupe des

informations et exercices venant des

sites udacity openclassroom ens

makina corpus sklearn et du livre de

Prateek Joshi et surtout celui de

ChloeAgathe Azencott

Toutes vos reacutefeacuterences nous seront

inteacuteressantes remontez-les nous

Second avant-propos jrsquoai deacutecouvert ce scheacutema qui reacutesume tout ce que jrsquoai essayeacute

de comprendre depuis pas mal de temps donc si vous cherchez apregraves le cours ou

degraves maintenant une fiche antisegraveche pour savoir quel algorithme utiliser dans quel

cas la voici

httpsscikit-learnorgstabletutorialmachine_learning_map

troisiegraveme avant-propos eacutetant moi-mecircme en formation je sais que rien ne vaut de

faire des exercices et de faire soi-mecircme tout le cours est donc baseacute sur des

exercices (vieux rose avec leurs corrections slide suivant) avec des rappels

theacuteoriques (rose clair) positionneacutes quand il me semble neacutecessaire mais que vous

pouvez consulter agrave tout moment (ou passer si vous connaissez deacutejagrave) Les

reacutefeacuterences sont donneacutees pour info et pour vous permettre drsquoaller plus loin mais a

priori vous devez pouvoir exeacutecuter tout ceci sans aller piocher dans ces reacutefeacuterences

(je lrsquoai fait pour vous ) sauf demande explicite pour vous habituer agrave aller chercher

lrsquoinfo

Correction annonceacutee slide

suivant

Slide de correction

Eacutenonceacute drsquoexercice

Reacutefeacuterence internet

Chapitre theacuteorique

EXERCICE GOOGLE CAR

httpsclassroomudacitycomcoursesud120lessons2254358555concepts24307885370923

httpsscikit-

learnorgstablemodulesgeneratedsklearnnaive_bayesGaussianNBhtml

Lrsquoexercice qui suit est librement inspireacute des sites suivants que je vous conseille vivement

Udacity est le site (en anglais) des MOOC des eacutetudiants de Stanford MIT et Georgia Tech

Sklearn est la bible (en anglais) du machine leanrning Ce pendant il faut avoir de bonnes

notions de maths (algegravebre lineacuteaire et probabiliteacutes) pour comprendre les exemples de sklearn

seul

Nous essaierons de rendre le cours le plus facile agrave comprendre en vous donnantredonnant les

notions matheacutematiques neacutecessaires

Google car Peacutedagogie

On srsquoappuie sur lrsquoexemple du MOOC drsquoUdacity (le MOOC des eacutetudiants du MIT et de Stanford)

sur un vrai exemple de machine learning les voitures autonomes

Le but de cet exercice est

bull De deacutecouvrir des notions de machine learning

bull Les donneacutees de deacutepart

bull Les donneacutees preacutedites

bull De choisir un modegravele pour deacutecider de surface de deacutecision

bull Drsquoappliquer ce modegravele agrave nos donneacutees drsquoentreacutee

bull Drsquoen tirer des donneacutees de preacutediction

bull De deacutecouvrir scikit learn

bull De deacutecouvrir le theacuteroegraveme de Bayes

bull De se rappeler la loi normale la courbe de Gauss

bull De comprendre pouvoir on applique lrsquoalgorithme Naive Bayes

bull Drsquoavoir vu une premiegravere fois la logique drsquoun modegravele superviseacute on prend les donneacutees on

choisit un modegravele on lrsquoapplique (on le fait lsquofitterrsquo ) agrave nos donneacutees drsquoentreacutee on en tire un

preacutediction pour une nouvelle donneacutee drsquoentreacutee

A la fin de cet exercice on aura

Fait tourner un algorithme de machine learning en python

Appliqueacute un theacuteoregraveme naive bayes sur une gaussienne et compris agrave quoi cela pouvait servir

drsquoautre

Contribueacute agrave apprendre agrave la google car agrave conduire

Google car

Dans cet exercice nous allons regarder comment programmer la google car Comme vous le

voyez ci-dessous la google car roule et deacutecide de tourner acceacuteleacuterer freiner sans que lrsquoon

ait les mains sur le volanthellip il a fallu lui apprendre agrave faire ceci crsquoest ce que nous allons faire

dans cet exercice


Google car

Tout drsquoabord dessiner les 6 points donneacutes ci-dessous sur un plan agrave deux dimensions

([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])

Ensuite mettez des eacutetiquettes (appeleacutees aussi labels) 1 ou 2 sur chacun de ces points

dans cet ordre respectif ci-dessous

([1 1 1 2 2 2])


Correction slide suivant ndash agrave ne regarder que si vous ecirctes perdus ou si vous avez fini

Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car

En fait les axes de notre plan correspondent agrave

Axe x les bosses sur la route (avec 0 bosses en moins lrsquoinfini = vers la gauche de lrsquoaxe x

horizontal et beaucoup de bosses en plus lrsquoinfini agrave droite)

Axe y la pente de la route (avec 0 pente en moins lrsquoinfini = vers le bas de lrsquoaxe y vertical et

plein de bosses vers plus lrsquoinfini en haut de lrsquoaxe y)

Positionnez les images suivantes sur votre sheacutema



Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

Les points sont des moments ougrave le conducteur de la google car (pour lrsquoinstant elle ne sait pas

conduire toute seule) va freiner ou acceacuteleacuterer

Drsquoapregraves vous

bull les laquo 1 raquo repreacutesentent-ils le freinage ou lrsquoacceacuteleacuteration


Positionnez les images sur les points de donneacutees que vous avez positionneacutes preacuteceacutedemment



Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Ici le conducteur freine

Ici le conducteur peut

acceacuteleacuterer car il nrsquoy a pas de

pente et pas de bosses une

belle route toute plate

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

Question quizz parmi tous les capteurs ci-dessous lesquels ont eacuteteacute utiliseacutes pour

obtenir les donneacutees de notre exercice (correction ici httpspaulkhuatduywordpresscomles-

capteurs )



Google car httpsclassroomudacitycomcoursesud120lessons2254358555concepts24307885370923


correction

Deteacutecteur de mouvement acceacuteleacuterateur acceacuteleacuteromegravetre gyroscope

Capteur drsquoinduction

thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps

Capteur sensitif drsquoappui

frein


correction

acceacuteleacuterateur

acceacuteleacuteromegravetre gyroscope

frein

Les bosses seront prises en

compte par un acceacuteleacuteromegravetre

La pente par un gyroscope

Il faut reacutecupeacuterer dans la voiture

les informations jrsquoai freineacute ou

jrsquoai acceacuteleacutereacute il faut donc que

ces informations soient capteacutees

quelque part

Google car

Le but est maintenant de geacuteneacuteraliser tout cela La google car se promegravene dans la

Silicon Valley mais le but est qursquoelle se conduise toute seule que le conducteur puisse

ne pas toucher le volant ni les peacutedales puisse ecirctre handicapeacute puisse y dormirhellipsur

toute route il va donc falloir agrave partir de nos points de donneacutees geacuteneacuteraliser


Google car Si on est sur une nouvelle route (et donc nouvelles donneacutees de bosses et pentes la

voiture devra t elle acceacuteleacuterer ou freiner) quel est votre avis pour les points

nouveaux lsquoet icirsquo


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car

Certains points (en gras) semblent plus faciles agrave positionner que drsquoautres


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car

Comment laquo couper raquo la surface Pour deacutecrire une surface de deacutecision Dessinez

une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car

Comment laquo couper raquo la surface Ici avec un trait (en gras)


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car

Comment laquo couper raquo la surface Ici avec le trait on partitionne en une zone jaune

je freine un zone bleue jrsquoacceacutelegravere


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car

Ici crsquoest une courbe


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car

Les surfaces de freinage et drsquoacceacuteleacuteration deviennent ainsi


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

On peut mecircme imaginer couper exactement selon tous les points que lrsquoon aurait

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Avec de nouvelles surfaces pour freiner ou acceacuteleacuterer

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

On peut mecircme imaginer couper exactement selon tous les points que lrsquoon aurait de

maniegravere toute carreacutee

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car

Dans les exemples ci-dessus on voit que lrsquoon doit deacutecider parmi deux actions

acceacuteleacuterer ou freiner crsquoest une classification binaire

On peut deacutecider de seacuteparer par une droite il srsquoagira de reacutegression lineacuteaire

On peut deacutecider de seacuteparer par une courbe un courbe de Gauss souvent (car

on suppose quand on ne sait pas que les points ont une distribution normale)

Ou une seacuteparation toute carreacutee (crsquoest ce qui se fera avec les arbres de

deacutecision)

On peut deacutecider de faire une surface totalement adapteacutee agrave nos jeux de tests

et lagrave on voit le risque du surapprentissage notre surface de deacutecision

correspondra exactement agrave nos donneacutees drsquoentreacutee mais pas du tout agrave de

nouvelles donneacutees sur une nouvelle route la voiture se mettra agrave acceacuteleacuterer ou

freiner agrave des moments qui sembleront lsquobizarresrsquo aux passagers


Google car

Saisir dans votre python les donneacutees suivantes et expliquer ce que

lrsquoon fait les reacuteponses de votre ordinateur

gtgtgt import numpy as np

gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])

gtgtgt Y = nparray([1 1 1 2 2 2])

gtgtgt from sklearnnaive_bayes import GaussianNB

gtgtgt clf = GaussianNB()

gtgtgt clffit(X Y)

GaussianNB(priors=None var_smoothing=1e-09)

gtgtgt print(clfpredict([[-08 -1]]))

[1]



Google car on importe les bibliothegraveques dont on a besoin numpy pour traiter des tableaux lsquoarrayrsquo en python

(on regardera en deacutetail plus tard)


on saisit des points de donneacutees

gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])

on saisit des points de labels ce sont les eacutetiquettes des points preacuteceacutedents leur valeur cible

(comme Y=f(X)=


on importe de la bibliothegraveque sklearn lrsquoalgorithme qui srsquoappelle naive bayes avec la meacutethode

gaussian NB (NB pour naive bayes) pour plus drsquoexplications je regarde dans sklearn httpsscikit-



on donne le nom clf agrave notre classificateur en creacuteant une instance de gaussianNB


on dit au classificateur de se lsquofitterrsquo donc de se calculer par rapport agrave nos donneacutees drsquoentreacutee X et

leurs labels y on applique gaussianNB agrave nos donneacutees X et Y

gtgtgt clffit(X Y)


on veut preacutedire la classification drsquoun nouveau point -08 -1 on est donc sur une nouvelle route

et els capteurs de la voiture remontent des bosses avec une donneacutee de -08 et une pente -1


[1]

le classificateur nous a donneacute 1 = on peut acceacuteleacuterer avec ces donneacutees de bosses et de pente


correction

Annexes theacuteoriques Google car Pour ceux qui ne seraient pas agrave lrsquoaise avec les Courbes de Gauss la loi normale et le

theacuteoregraveme de Bayes nous vous proposons les chapitres et exercices annexes en

pages suivantes httpsfrwikipediaorgwikiClassification_naC3AFve_bayC3A9sienne

httpswwwyoutubecomwatchv=zrbnfb_tpOA

httpswwwyoutubecomwatchv=cpCo6mtdAnE

httpswwwresearchgatenetfigureIllustration-of-how-a-Gaussian-

Naive-Bayes-GNB-classifier-works-For-each-data-

point_fig8_255695722

httpsstatsstackexchangecomquestions142215how-is-naive-

bayes-a-linear-classifier

machine learning

bullLOI NORMALE

machine learning loi normale

bull Exercice vous disposez de n deacutes agrave six faces vous les lancez sommez vos points (vous obtenez le chiffre s)

bull Quelle peut ecirctre la somme maximale

bull Dessinez sur un scheacutema

bull Axe des x les possibiliteacutes que la S somme du tirage des n deacutes soit 12 hellipsomme maximale

bull Axe des y la probabiliteacute que cette somme apparaisse

bull Dessinez le scheacutema pour n=1

bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5

httpsfrwikipediaorgwikiLoi_normale


machine learningloi normale

bull La somme maximale est n6

bull Pour n = 1

bull On a un seul deacute

bull Il peut prendre les valeurs

bull 1 2 3 456 quand on le lance et ainsi la somme du tirage est 1 2 3 456

bull Chaque chiffre a la probabiliteacute 16 drsquoapparaitre

bull Donc chaque somme a la possibiliteacute 16 drsquoapparaitre

bull Sur le scheacutema ce sera ainsi


16

1 2 3 4 5 6

Correction n=1

Correction pour n= 2 slide suivant ndash agrave ne regarder que si vous ecirctes perdus ou si vous avez fini

machine learningloi normale bull Pour n=2

bull On a deux deacutes

bull Chacun peut prendre la valeur 1 2 3 456 quand on le lance

bull Si on lance les deux la somme peut ecirctre 2 3 456 7 8 9 10 11 12

bull Mais on voit bien que la somme 6 peut ecirctre obtenue par plusieurs tirages 3+3 ou 2+4 ou 4+2 ou 1+ 5 ou 5+1 soit 5 possibiliteacutes

bull Alors que la somme 2 ne peut ecirctre obtenue que par 1+1

bull Donc certaines sommes sont susceptibles drsquoapparaitre plus que drsquoautres


1 2 3 4 5 6 7 8 9 10 11 12

correction



bull On a trois deacutes


bull Si on lance les trois la somme peut ecirctre 3 456 7 8 9 10 11 12 131415161718

bull Mais on voit bien que la somme 9 peut ecirctre obtenue par plusieurs tirages 1+2+6 (ou 1+6+2 ou 6+2+1 ou 6+1+2 ou 2+1+6 ou 2+6+1) ou 1+3+5 (et les 5 autres lieacutees) ou 1+4+4 (ou 4+1+4 ou 4+4+1)ou 2+2+5 (et 2 autres) ou 2+3+4 (et 5 autres) ou 3+3+3

bull Alors que la somme 3 ne peut ecirctre obtenue que par 1+1+1 soit une seule possibiliteacute



1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction


bull Pour un nombre infini de deacutes on obtient la courbe de gauss


correction

machine learningloi normale exercice

Imaginez une planche

ainsi ougrave des billes

peuvent tomber agrave

chaque fois drsquoun cocircteacute ou

de lrsquoautre des points

Crsquoest la Planche

de Galton

Drsquoapregraves vous les billes en bas seront

bull Eacutequitablement reacuteparties

bull Plutocirct sur les cocircteacutes

bull Plutocirct vers le milieu



Elles seront plus vers le centre elles dessinent la loi normale une courbe de gauss

httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction


bull En theacuteorie des probabiliteacutes et en statistique la loi normale est lune des lois de probabiliteacute les plus adapteacutees pour modeacuteliser des pheacutenomegravenes naturels issus de plusieurs eacuteveacutenements aleacuteatoires Elle est en lien avec de nombreux objets matheacutematiques dont le mouvement brownien le bruit blanc gaussien ou dautres lois de probabiliteacute Elle est eacutegalement appeleacutee loi gaussienne loi de Gauss ou loi de Laplace-Gauss des noms de Laplace (1749-1827) et Gauss (1777-1855) deux matheacutematiciens astronomes et physiciens qui lont eacutetudieacutee


Exercice qui

reconnaissez-vous

sur ces photos


bull Plus formellement cest une loi de probabiliteacute absolument continue qui deacutepend de deux paramegravetres son espeacuterance un nombre reacuteel noteacute μ et son eacutecart type un nombre reacuteel positif noteacute σ La densiteacute de probabiliteacute de la loi normale est donneacutee par

bull La courbe de cette densiteacute est appeleacutee courbe de Gauss ou courbe en cloche entre autres Cest la repreacutesentation la plus connue de cette loi La loi normale de moyenne nulle et deacutecart type unitaire est appeleacutee loi normale centreacutee reacuteduite ou loi normale standard

bull Lorsquune variable aleacuteatoire X suit la loi normale elle est dite gaussienne ou normale et il est habituel dutiliser la notation avec la variance σ2


machine learningloi normale httpsfrwikipediaorgwikiLoi_normale

bull exercice une usine construit des clous qui doivent avoir une longueur de 3cm La directrice de lrsquousine indique que ses clous ont un eacutecart-type de 1 mm

bull Sur 1000 clous combien auront une taille comprise entre 29 et 31 cm

bull combien de clous avec sont entre 24 et 36 cm

bull Sigma correspond au point drsquoinflexion de la courbe autour de la moyenne et en srsquoarrecirctant agrave sigma on a 68 des cas



bull Et la notion de 6-sigma deacutecoule aiseacutement du graphique ci-dessus pour une population normale la quasi-totaliteacute des individus se retrouvent dans une fourchette comprenant la moyenne plus ou moins 6 fois leacutecart-type On peut mecircme dire que toujours pour une population normale seuls deux individus sur un milliard se retrouveront hors de cette fourchette

bull Ici mu est de 3 cm et sigma de 1 mm

bull 29 agrave 31 cm correspond agrave mu plus 2 sigmas ce qui fait 68 des clous ndash qui vraisemblablement suivent une loi normale

bull Donc 680 clous sur 1000 seront dans cet intervalle [29 ndash 31cm]

bull Et 9999 dans lrsquointervalle 23-36cm car cela fait 6 sigma

correction

machine learning

bullTHEOREME DE BAYES

machine learning bayes

le theacuteroeme de BAYES


Exercice De quelle urne vient la boule

Agrave titre drsquoexemple imaginons deux urnes remplies de boules La

premiegravere contient dix (10) boules noires et trente (30) blanches la

seconde en a vingt (20) de chaque On tire sans preacutefeacuterence particuliegravere

une des urnes au hasard et dans cette urne on tire une boule au

hasard La boule est blanche Quelle est la probabiliteacute quon ait tireacute cette

boule dans la premiegravere urne sachant quelle est blanche



Intuitivement on comprend bien quil est plus probable que cette boule

provienne de la premiegravere urne que de la seconde Donc cette

probabiliteacute devrait ecirctre supeacuterieure agrave 50

La reacuteponse exacte (60 ) peut se calculer agrave partir du theacuteoregraveme de

Bayes

correction


Soit H1 lrsquohypothegravese laquo On tire dans la premiegravere urne raquo et H2 lrsquohypothegravese laquo On tire dans la

seconde urne raquo Comme on tire sans preacutefeacuterence particuliegravere P(H1) = P(H2) de plus

comme on a certainement tireacute dans une des deux urnes la somme des deux probabiliteacutes

vaut 1 chacune vaut 50

Notons D lrsquoinformation donneacutee laquo On tire une boule blanche raquo Comme on tire une boule

au hasard dans une des urnes la probabiliteacute de D sachant lhypothegravese H1 reacutealiseacutee vaut

De mecircme la probabiliteacute de D sachant lhypothegravese H2 reacutealiseacutee vaut

La formule de Bayes dans le cas discret nous donne donc

Avant que lrsquoon regarde la couleur de la boule la probabiliteacute drsquoavoir choisi la premiegravere urne

est une probabiliteacute a-priori P(H1) soit 50 Apregraves avoir regardeacute la boule on reacutevise notre

jugement et on considegravere P(H1|D) soit 60 ce qui confirme notre intuition premiegravere

correction


Exercice Appliquons le theacuteoregraveme de Bayes agrave CHRIS et SARA

CHRIS et SARA ont un vocabulaire tregraves limiteacute ils ne disent que les mots

LOVE DEAL LIFE mais ne les emploient pas chacun de la mecircme faccedilon

CHRIS dit LOVE dans 10 de ses phrases LIFE dans 10 aussi et DEAL est

employeacute agrave 80 de son vocabulaire

Pour SARA LOVE repreacutesente 50 (dsl des steacutereacuteotypeshellipje ferai passer agrave

Udacity le message) DEAL 20 de son vocabulaire et LIFE 30

Exercice le message LOVE LIFE vient drsquoarriver quelle est la probabiliteacute que ce

message vienne de CHRIS de SARA


Correction avec les mots LIFE et DEAL

La probabiliteacute que un message vienne de CHRIS ou de SARA est de 50 = 05

(ils ne sont que 2)

Pour CHRIS life 01 et deal 08 donc 010805 = 004

Pour SARA life 03 et deal 02 donc 030205 = 003

correction


Exercice agrave vous de faire pour LOVE DEAL


Exercice Pensez-vous que le theacuteoregraveme de Bayes puisse aider agrave

ndash Trouver les spams dans une messagerie

ndash Trouver les reacutesultats du loto

ndash Deviner ce que les gens vont dire

ndash Trouver qui est lrsquoauteur drsquoun livre

Suppleacutement donnez les dates de Thomas Bayes



Trouver les spams dans une messagerie

ndash Oui De nombreux anti-spams fonctionnent ainsi le pheacutenomegravene

est le mecircme que le vocabulaire de Chris et Sara avec un vocabulaire particulier( amour ceacutelibataire performances argent gagneacutehellip) (httpswwwprovectiofractualitesfiltrage-bayesien-technique-pour-lutter-contre-le-spamhtml )


ndash Non Sauf si les boules sont pipeacutees httpsforumsfutura-sciencescomdebats-

scientifiques494974-optimisation-chances-de-gagner-loto-2html

ndash Deviner ce que les gens vont dire ndash Non( on verra ccedila plutocirct avec les reacuteseaux de neurones

et le deep learning)


ndash Oui JK Rowling a eacuteteacute deacutecouverte ainsi on a compareacute le

vocabulaire de Harry Potter avec drsquoautres livres qursquoelles disait ne pas avoir eacutecrits

correction


Exercice compleacutement pourquoi dit-on naive bayes et pas Bayes tout court

httpsfrwikipediaorgwikiClassification_naC3AFve_bayC3A9sienne



Parce qursquoon considegravere ici les variables comme indeacutependantes peu importe leur ordre

Ainsi peu importe que CHRIS dise LOVE LIFE ou LIFE LOVE

On calcule avec le mecircme reacutesultat

Les variables sont indeacutependantes entre elles

correction


Exercice Drsquoapregraves vous quelle recherche a eacuteteacute faite sur google pour ce reacutesultat et quel algorithme utilise le moteur de recherche



Google aujourdhui avec laquo chicago bulls raquo

Avec naive bayes (google drsquoil y a 20 ans) la mecircme recherche donnait

ndash

correction

Quizz1


1 Annie utilise un algorithme GaussianNB pour classifier des donneacutees que

signifie le laquo gaussian raquo dans le nom de cet algorithme

2 Problegraveme de MontyHall un jeu oppose Aline et Bernard Aline fait face agrave

trois portes closes Derriegravere lrsquoune drsquoelles Bernard a cacheacute une voiture

Derriegravere chacune des deux autres portes se trouve une chegravevre Aline choisit

une porte Bernard ouvre une des deux autres portes derriegravere laquelle il sait

qursquoil y aune chegravevre Aline peut modifier son choix et remporter ce qursquoil ya

derriegravere la porte (elle veut la voiture) Aline a-t-elle inteacuterecirct agrave modifier son

choix

EXERCICE LOYERS

httpsopenclassroomscomfrcourses4011851-initiez-vous-au-machine-learning

Loyers (open classroom) Peacutedagogie

On srsquoappuie maintenant sur lrsquoexemple openclassroom sur un nouvel exemple de machine

learning la determination de loyers


bull De consolider ce que lrsquoon a deacutecouvert en notions de machine learning






bull De revoir la reacutegression lineacuteaire

bull De srsquoinitier agrave la meacutethode des moindres carreacutes

bull De revoir la logique on prend les donneacutees on choisit un modegravele on lrsquoapplique (on le fait

lsquofitterrsquo ) agrave nos donneacutees drsquoentreacutee on en tire un preacutediction pour une nouvelle donneacutee

drsquoentreacutee


Fait tourner un algorithme de reacutegression lineacuteaire en python

Ecrit soi-mecircme toute seule un vrai programme de regression lineacuteaire en python

Revu ou appris quelques notions drsquoalgegravebre lineacuteaire

Deacutecouvert si on payait trop cher son loyer (parisien)

Loyers (version simplifieacutee) On vous propose maintenant de reprendre les notions deacutejagrave vues avec une reacutegression lineacuteaire Le but de cet exercice est que vous puissiez expliquer ce que lrsquoon fait dans lrsquoexercice suivant

On fait chercher les donneacutees housecsv httpsopenclassroomscomfrcourses4011851-initiez-vous-au-machine-learning4121986-tp-decomposez-lapprentissage-dune-regression-lineaire puis house_datacsv dans un deuxiegraveme temps httpexercicesopenclassroomscomassessment597id=4011851ampslug=initiez-vous-au-machine-learningamplogin=7030493amptk=e9c1d184ecb2c74e88912cfbfbb7dd0aampsbd=2016-02-01ampsbdtk=fa78d6dd3126b956265a25af9b322d55 et appliquer un modegravele de regression lineacuteaire

On aura besoin pour cela des librairies numpy que lrsquoon nommera np et de matplotlibpyplot que lrsquoon nommera plt

On chargera le dataset input_file = housecsvlsquo gracircce agrave nploadtxt(input_file delimiter= dtype = float)

Regarder les donneacutees et deacutecider quels sont les X et les y

On affichera ensuite les donneacutees avec matplotlib

pltscatter(X y color=green)

pltxticks(())

pltyticks(())

pltshow()

Loyers (version simplifieacutee) import numpy as np

import matplotlibpyplot as plt

input_file = housecsv

data = nploadtxt(input_file delimiter= dtype = float)

print(data)

On voit que la donneacutee drsquoentreacutee est la surface en seconde position dans le fichier sur chaque ligne et le y le loyer est en premiegravere position

X y = data[ 1] data[ 0]

print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()

Loyers (version simplifieacutee) Maintenant il nous faut calculer la regression lineacuteaire et tracer la droite de regression sur le sheacutema

1ere solution avec sklearn from sklearn import linear_model

Puis prendre la regression lineaire

regressor = linear_modelLinearRegression()

et on fait fitter les donneacutees sur le modegravele de regression

regressorfit(X y)

2de solution avec scipy from scipy import stats

linregress() renvoie plusieurs variables de retour On sinteressera

particulierement au slope et intercept

slope intercept r_value p_value std_err = statslinregress(X y)

def predict(x)

return slope x + intercept

la variable fitLine sera un tableau de valeurs preacutedites depuis la tableau de variables X

fitLine = predict(X)

on affiche l aregression lineacuteaire fitLine

pltplot(X fitLine c=r)

pb avec taille de X

Loyers (version simplifieacutee) from scipy import stats


def predict(x)




print (slope intercept r_value p_value std_err)

on dessine les points


pltxticks(())

pltyticks(())


pltshow()

Loyers open classrooms Voici la correction openclassroom

On importe les librairies dont on aura besoin pour ce tp

import numpy as np

import pandas as pd


On charge le dataset

house_data = pdread_csv(housecsv)

On affiche le nuage de points dont on dispose

pltplot(house_data[surface] house_data[loyer] ro markersize=4)

pltshow() On deacutecompose le dataset et on le transforme en matrices pour pouvoir effectuer notre

calcul on ajoute une colonne de 1 pour faire les calculs dans la matrice X

X = npmatrix([npones(house_datashape[0])house_data[surface]as_matrix()])T

y = npmatrix(house_data[loyer])T

On effectue le calcul exact du paramegravetre theta

theta = nplinalginv(XTdot(X))dot(XT)dot(y)

print(theta)

Loyers open classrooms [[ 29430011913] [ 3004180999]]

Loyers open classrooms

pltxlabel(Surface)

pltylabel(Loyer)


On affiche la droite entre 0 et 250

pltplot([0250] [thetaitem(0)thetaitem(0) + 250 thetaitem(1)] linestyle=--

c=000000)

pltshow()

from sklearn import linear_model

regr =

linear_modelLinearRegression()

regrfit(surface loyer)

regrpredict(donnee_test)


Exercice

De quelles donneacutees dispose-t-on au deacutepart

Que veut-on faire avec ces donneacutees

Quel algorithme applique trsquoon

Donner la formule pour obtenir des donneacutees

Quel serait le loyer drsquoun logement de surface 100m2

Et pour 50m2

Et pour 200m2

Etes-vous plutocirct sur de votre reacuteponse pour 50100ou 200m2

Pourquoi

Comment est-ce que vous estimeriez que votre algorithme est un bon algorithme ou

pas




Des loyers selon la surface


On veut essayer de calculer un loyer pour une surface donneacutee


Une regression lineacuteaire


Quel serait le loyer drsquoun logement de surface 100(m2)

30100+2943 = 32943 (eurosmois)

Et pour 50m2 3050+2943 = 17943 (eurosmois)


Etes-vous plutocirct sur de votre reacuteponse pour 50100ou 200m2 Euhhellip

Pourquoi Pour 200m2 on nrsquoa aucun exemple en faithellipen revanche de nombreux points

existent pour 50m2 mais le loyer varie de 1000 jusque 4000 parfois


pas Crsquoest le cours suivant

correction

Regression lineacuteaire Exercice

Eacutecrire un programme en python pour trouver la reacutegression lineacuteaire des points suivants

attention X est agrave deux dimensions

Imaginons le prix du loyer y deacutepend de la surface et du nombre drsquoeacutetages

Voici

un appartement de surface 100m~2 et sur 1 eacutetage et qui vaut 600keuro

un appartement de surface 100m~2 et sur 2 eacutetages et qui vaut 800keuro


un appartement de surface 200m~2 et sur 3 eacutetages et qui vaut 11Meuro

Exprimez vos points X gracircce agrave array de numpy et vos y comme un tuple agrave 4 eacuteleacutements

Deacuteterminez la regression lineacuteaire gracircce agrave LinearRegression de sklearnlinear_model

Nrsquooubliez pas de faire fitter votre modegravele agrave vos donneacutees drsquoentreacutee (Xy) gracircce agrave fit(X y)

Donnez le coefficient de regression (le coefficient linaire) gracircce agrave coef_

Donnez lrsquoordonneacutee agrave lrsquoorigine gracircce agrave intercept_

Ecrire la formule de la regression lineacuteaire y = en fonction de X[0] et de X[1]

Calculez le score (si proche de 1 tregraves bon si 0 tregraves mauvais) R~2 gracircce agrave score(X y)

Commentez

Donnez le loyer preacutevu pour un appartement de 300m~2 et 5 eacutetages

httpsscikit-learnorgstablemodulesgeneratedsklearnlinear_modelLinearRegressionhtml


Regression lineacuteaire

import numpy as np

from sklearnlinear_model import LinearRegression

X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)

reg = LinearRegression()fit(X y)

a = regscore(X y)

print (le score est de a)

b=regcoef_

print (le coefficient lineacuteaire est b)

c =regintercept_

print (lordonneacutee agrave lorigine est c)

print (pour une appart de 300m~2 et 5 eacutetagesregpredict(nparray([[300 5]])))


correction



correction

Ici le score est de 1 en effet les donneacutees Xy sont lineacuteaires dans lrsquoeacutenonceacute

Le prix en keuro est la surface en m~2 + 200 fois le nombre drsquoeacutetages plus 300

Y = X[0] + 200X[1] + 300

Notre reacutegression est parfaite (car les points eacutetaient deacutejagrave laquo aligneacutes raquo)

Plus de deacutetail sur R2 dans le deacutetail lsquoregression lineacuteairersquo qui suit

machine learning

bullREGRESSION LINEAIRE

machine learning regression lineacuteaire

httpswwwyoutubecomwatchv=mfLHA7C88vc

Pour ceux qui veulent savoir comment on calcule la formule de reacutegression lineacuteaire ndash en dimension 1 -( le coefficient agrave lrsquoorigine et le coefficient de regression lineacuteaire) des moindres carreacutes vous avez ici une videacuteo (longue) mais simple agrave comprendre


Dans wikipedia

httpsfrwikipediaorgwikiRC3A9gression_linC3A9ai

re vous retrouvez ces formules

La meacutethode des moindres carreacutes minimise les traits en verts

sur le scheacutema ci-contre crsquoest-agrave-dire les distances (au carreacute)

entre les points preacutevus par la droite de regression f(x) et leur

vrai eacutetiquette de donneacutee drsquoentreacutee y

Beta 0 est le coefficient agrave lrsquoorigine

Et beta1 est le coefficient de regression

On met des chapeaux accents circonflexes car ce sont des

estimateurs on calcule lrsquoestimation par une regression

lineacuteaire


Dans lrsquoexercice sur les loyers avec 2 variables drsquoentreacutee on demande le score R2 ceci nous permet de travailler sur la qualiteacute de la preacutediction

Qualiteacute de la preacutediction Pour eacutevaluer la qualiteacute de la preacutediction on peut utiliser diffeacuterents critegraveres

Dans un premier temps rappelons que

S S R = est la variation expliqueacutee par la reacutegression (Sum of Squares Regression en franccedilais SCE Somme des Carreacutes Expliqueacutee [par la reacutegression]) on regarde chaque ^yi (donc etiquette preacutevue) par rapport agrave la moyenne des vraies eacutetiquettes y

S S E = S C R = est la variation expliqueacutee par les reacutesidus (Sum of Squares Errors en franccedilais SCR Somme des Carreacutes Reacutesiduelle) on somme els distances (au carreacute) entre les vraies eacutetiquettes y et leur preacutevisions ^y

S S T = S S E + S S R = est la variation totale (Sum of Squares Total en franccedilais SCT Somme des Carreacutes Totale) les eacutetiquettes vraies y par rapport agrave leur moyenne

Nous pouvons alors deacutefinir le coefficient de deacutetermination (R2) comme le ratio entre la somme des carreacutes des eacutecarts agrave la moyenne des valeurs preacutedites par la reacutegression et la somme des carreacutes des eacutecarts agrave la moyenne totale

Le coefficient de deacutetermination varie entre 0 et 1 Lorsquil est proche de 0 le pouvoir preacutedictif du modegravele est faible et lorsquil est proche de 1 le pouvoir preacutedictif du modegravele est fort

httpsfrwikipediaorgwikiRC3A9gression_linC3A9aire


Pour ceux qui sont bien agrave lrsquoaise et veulent avoir la formule en dimension p (et non plus

1) nrsquoheacutesitez pas agrave suivre le MOOC drsquoopen classroom de Chloe Agathe Azencott

httpsopenclassroomscomfrcourses4444646-entrainez-un-modele-predictif-

lineaire4444653-trouvez-une-combinaison-lineaire-de-variables-qui-approxime-leurs-

etiquettes

On considegravere que les erreurs (les diffeacuterences entre les preacutedictions (= la droite) et les vraies eacutetiquettes

(en bleu) sont distribueacutees de faccedilon normale = par une loi normale = en courbe de Gauss


Accrochez-vous crsquoest parti httpsopenclassroomscomfrcourses4444646-entrainez-un-modele-

predictif-lineaire4444653-trouvez-une-combinaison-lineaire-de-variables-qui-approxime-leurs-etiquettes

on va maximiser la vraisemblance

La vraisemblance est la probabiliteacute drsquoobserver nos donneacutees D

eacutetant donneacute B (le vecteur beta 0 et beta 1)

Eacutetant donneacute Beta (le vecteur beta 0 et beta 1)

On va donc chercher le vecteur Beta qui rend cette probabiliteacute maximale

Pour deacuteterminer beta0 etbeta1de lrsquoeacutequation


On va consideacuterer que nos points D (xi et yi) sont indeacutependants et identiquement

distribueacutes srsquoils sont indeacutependants alors la probabiliteacute de D(xi yi) entiegravere

sachant beta est eacutegale au produit chacune des probabiliteacute de xi yi sachant

beta

Or la probabiliteacute de x y est eacutegale agrave la probabiliteacute de y sachant x la probabiliteacute de x

(p ex la probabiliteacute que jrsquoaille au bureau et que mon fils prenne son veacutelo est eacutegale agrave

la probabiliteacute que mon fils prenne son veacutelo sachant que je vais au bureau la

probabiliteacute que jrsquoaille au bureauhellipeuh convaincus Sinon a vu ccedila dans le theacuteoregraveme

de Bayes )






On en eacutetait agrave

On va donc chercher beta qui maximise le maximum de vraisemblance on cherche

donc agrave reacutesoudre ceci




On peut enlever p(x) car la probabiliteacute des x ne deacutepend pas de beta on peut aussi

passer au log car maximise quelquechose revient agrave maximiser son log on en est


Or on se souvient que la probabiliteacute drsquoobtenir y sachant x est justement noramelement

distribueacute et donneacute par cette formule

Et qursquoune loi normale peut aussi se noter ainsi en math

Donc on en est agrave




Donc on peut noter ainsi

Et on doit donc maximser la somme des log de ce qursquoil y au-dessus

Par ailleurs log (ab) = log a+ log b

Donc log a est (=log de 1 sur racine de 2 pi sigma) une constante

Et le log de lrsquoexponentielle est lrsquoidentiteacute donc on en est agrave maximiser cela




Et maximiser un constante ou le 2pi sigma qui est aussi constante revient agrave

maximiser seulement ceci

Et maximiser un nombre neacutegatif revient agrave minimiser le nombre positif correspondant

On retrouve la meacutethode des moindres carreacutes




Prenons beta et X dans un

espace agrave p dimensions

Et on cherche agrave trouver beta

Ceci revient agrave reacutesoudre

les moindres carreacutes ici




On va ajouter une colonne

de 1 agrave X pour transformer

notre eacutequation ci apregraves en

produit matriciel

Notre eacutequation devient donc

Et la somme des moindres carreacutes

devient




pour minimiser le produit quadratique on calcule le gradient et on lrsquoannule (en

dimension 1 minimiser une fonction est quand sa deacuteriveacutee est nulle)


et donc beta est eacutegal agrave

CQFD


httpsopenclassroomscomfrcourses4011851-initiez-vous-au-machine-

learning4121986-tp-decomposez-lapprentissage-dune-regression-lineaire

bull Pour bien comprendre la formule theta dans la regression lineacuteaire de lrsquoexercice open classrroom

machine learning

bullMOYENNE VARIANCE ECARTS-TYPES and CO

calculer

- la moyenne des x

- la moyenne des y

- la variance de x (= eacutecart-type

au carreacute)

- la variance de y

- le coefficient de correacutelation r

- la regression lineacuteaire y = ax+b

covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)

b=moy(y) ndash amoy(x)

coeff de correlation

moyennes

Voici un petit exercice pour vous rafraichir la meacutemoire et srsquoamuser avec la

visualisation des donneacutees


datavisualisation

correction httpsdocsscipyorgdoc

numpyreferencegenerat

ednumpystdhtml

datavisualisation

Reprendre le mecircme exercice avec ces donneacutees-lagrave et repreacutesenter les donneacutees sur

un scheacutema


datavisualisation

correction

httpsdocsscipyorgdocnumpyreferencegeneratednumpystdhtml

httpsmatplotliborggalleryspecialty_plotsanscombehtml


import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs

print(mean=12f std=12f r=12f (npmean(y) npstd(y)

npcorrcoef(x y)[0][1]) )

datavisualisation ndash Anscombe quartet

correction

Cet exemple est connu sous le nom drsquoAnscombe quartet il montre que les calculs

des donneacutees moyenne ecart type etc peuvent ecirctre les mecircmes mais ne suffisent pas

agrave cateacutegoriser les donneacutees

2 exercices IRIS un plutocirct en culture geacuteneacuterale et en lecture le second

totalement hands-on

httpsmakina-corpuscomblogmetier2017initiation-au-machine-learning-avec-python-

pratique

et

httppython-prepagithubioateliersdata_mininghtml

IRIS (makina corpus et ens) Peacutedagogie

On srsquoappuie maintenant sur lrsquoexemple des IRIS pour comprendre lrsquoensemble du machine learning

et de scikit learn


bull De voir un exemple complet avec de vraies donneacutees drsquoentreacutee un vrai exemple scientifique

donc un vrai inteacuterecirct scientifique

bull De voir comment des algorithmes diffeacuterents peuvent donner des reacutesultats

bull De deacutecouvrir scikitlearn

bull Drsquoavoir une premiegravere vue de certains algorithmes

bull Naives Bayes gaussian

bull Mais aussi

bull SVM

bull KNN

bull PCA

bull Gaussian mixture

bull De voir lrsquointeacuterecirct de seacuteparer les donneacutees drsquoentreacutee en deux jeux de tests et drsquoentrainement

bull De nous inteacuteresser agrave la qualiteacute de la preacutediction


-utiliseacute de nombreuses fonctionnaliteacutes de sklearn

-deacutecouvertredeacutecouvert gaussian NB mais aussi KNN et SVM PCA gaussian mixture

-On aura suivi toute la logique du machine learning reacutecupeacuteration des donneacutees observation des

donneacutees seacuteparation en jeu drsquoentrainement et jeu de test comparaison drsquoalgorithme

-Deacutecouvert des sortes drsquoiris

Introduction agrave Scikit Learn httpsscikit-learnorgstable

Introduction agrave Scikit Learn

Scikits-Learn est une librairie dapprentissage automatique couvrant lensemble

de la discipline

Les types dapprentissage superviseacute non superviseacute par renforcement par

transfert

Les algorithmes

Linear Regression (reacutegression lineacuteaire)

Logistic Regression (reacutegression logistique)

Decision Tree (arbre de deacutecision)

SVM (machines agrave vecteur de support)

Naive Bayes (classification naiumlve bayeacutesienne)

KNN (Plus proches voisins)

Dimensionality Reduction Algorithms

Gradient Boost amp Adaboost

Reacuteseaux de neuronnes


Exercice aller sur scikit learn et retrouvez les algorithmes preacuteceacutedents dans le

sheacutema ci-contre permettant de les comparer

Pourquoi deacutebuter avec Scikit-Learn

Cest une bonne ideacutee de deacutebuter la deacutecouverte de lapprentissage

automatique avec cette librairie

Elle dispose dune excellente documentation fournissant de nombreux

exemples

Elle dispose dune API uniforme entre tous les algorithmes ce qui fait quil est

facile de basculer de lun agrave lautre

Elle est tregraves bien inteacutegreacutee avec les Librairies Pandas et Seaborn

Elle dispose dune grande communauteacute et de plus de 800 contributeurs

reacutefeacuterenceacutes sur GitHub

Cest un projet open source

Son code est rapide certaines parties sont impleacutementeacutees en Cython

Ensuite quand vous en aurez fait le tour vous pourrez basculer vers dautres

librairies plus optimiseacutees ou speacutecialiseacutees sur une sujet preacutecis (type

dapprentissage algorithme mateacuteriel ) Notre chapitre de preacutesentation du

Machine Learning propose deacutejagrave un bon panel des autres solutions agrave votre

disposition

Les concepts de la librairie

Les donneacutees

Vos donneacutees sont repreacutesenteacutees par des tableaux agrave 2 dimensions

Typiquement des tableaux Numpy ou Pandas ou Python

Les lignes repreacutesentent les enregistrements

Les colonnes les attributs (hauteur longueur couleur autre information)

Une donneacutee est un vecteur de paramegravetres geacuteneacuteralement des reacuteels mais

les entiers booleacuteens et valeurs discregravetes sont autoriseacutees dans certains

cas

Les labels peuvent ecirctre de diffeacuterents types geacuteneacuteralement des entiers ou

chaicircnes

Les labels sont contenus dans un tableau agrave une dimension sauf rares cas

ougrave ils peuvent ecirctre dans le vecteur de paramegravetres


Exercice

httpswwwcourspythoncomtableaux-numpyhtml

Donner les fonctions de numpy qui permettent

Drsquoinverser une matrice

De transposer une matrice

De calculer un produit matriciel

Drsquoajouter des 1 agrave une matrice Que fait numpyshape() Que fait numpyarray()


Les concepts de la librairie httpswwwcourspythoncomtableaux-numpyhtml

Drsquoinverser une matrice numpylinalginv() gtgtgt from numpylinalg import inv gtgtgt a = nparray([[1 3 3] [1 4 3] [1 3 4]]) gtgtgt inv(a) array([[ 7 -3 -3] [-1 1 0] [-1 0 1]])

De transposer une matrice T

bullgtgtgt a = nparray([[1 2 3] [4 5 6]])

bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])

bullDe calculer un produit matriciel dot(ab)


bullgtgtgt b = nparray([[4] [2] [1]])

bullgtgtgt npdot(ab) array([[11] [32]])

bullLe produit drsquoune matrice de taille n x m par une matrice m x p donne une matrice n x p

Correction

numpy httpswwwcourspythoncomtableaux-numpyhtml

ajouter des 1 agrave une matrice Tableaux de 1 - numpyones()

gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])

La fonction numpyshape() (forme en anglais) renvoie la taille du tableau

gtgtgt a = nparray([2568])

gtgtgt npshape(a)

(4)

gtgtgt b = nparray([[1 2 3] [4 5 6]]) gtgtgt

npshape(b)

(2 3) Que fait numpyarray() cela creacuteeacutee des tableaux gtgtgt a = nparray([[1 2 3] [4 5 6]]) gtgtgta array([[1 2 3] [4 5 6]])

Correction

matplotlib httpwwwpython-simplecompython-matplotlibpyplotphp

On va srsquoexercer agrave faire des scheacutemas avec pyplot

Importation du module from matplotlib import pyplot

Pour tracer un graphe x-y avec les points relieacutes (pour un nuage de points utiliser plutocirct scatter)

from matplotlib import pyplot pour importer le module

pour tracer un graphe avec des valeurs de x et des valeurs de y en reliant les points dans lordre de la liste

pyplotplot([1 2 3 6] [1 4 9 36])

pyplotshow() montre le graphe courant

on peut indiquer le symbole et la couleur

pyplotplot(x y bo) bleu et avec des ronds

on peut aussi indiquer tous les paramegravetres avec des tags seacutepareacutes

pyplotplot(x y color = green linestyle = dashed linewidth = 2 marker = o markerfacecolor = blue markersize = 5) symboles ronds en bleu avec une taille de 5 et traits pointilleacutes en vert

on peut tracer plusieurs courbes sur le mecircme graphe

pyplotplot(x y r+ y y bo)

Pour tracer un graphe dune liste de valeurs en fonction du numeacutero dordre

pyplotplot([1 2 4 4 2 1] color = red linestyle = dashed linewidth = 2 markerfacecolor = blue markersize = 5)

pyplotylim(0 5)

pyplottitle(Un exemple)

meshgrid httpswwwcourspythoncomvisualisation-couleurhtml

Utilisation de meshgrid()

Pour visualiser une fonction z = f(x y) il faut drsquoabord geacuteneacuterer des tableaux X et Y qui contiennent les valeurs des abscisses et ordonneacutees pour chacun des points gracircce agrave la fonction meshgrid() Ensuite calculer la valeur de z pour chacun de ces points meshgrid() permet de geacuteneacuterer un maillage


gtgtgt x = nparray([3 4 7])

gtgtgt y = nparray([-1 0])

gtgtgt X Y = npmeshgrid(x y)

gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])

Utilisation de pcolor()

pcolor() permet une visualisation gracircce agrave des couleurs

Syntaxe laquo standard raquo

import numpy as np


x = nplinspace(-3 3 51)

y = nplinspace(-2 2 41)

X Y = npmeshgrid(x y)

Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)

calcul du tableau des valeurs de Z

pltpcolor(X Y Z)

pltshow()

Saisir sur votre python

meshgrid httpwwwpython-simplecompython-matplotlibscatterplotphp

marker = o le type de symbole ici un rond Les principaux symboles sont les suivants

o rond

s carreacute (square)

+ croix en forme de +

x croix en forme de x

eacutetoile

D losange (diamond)

d losange allongeacute

H hexagone (h est aussi un hexagone mais tourneacute)

p pentagone

point

gt triangle vers la droite (lt pour vers la gauche)

v triangle vers le bas (^ pour vers la haut)

| trait vertical (_ pour trait horizontal)

1 croix agrave 3 branches vers le bas (2 vers le haut 3 vers la gauche 4 vers la droite)

Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]

pyplotscatter(x y1 s = 130 c = yellow marker = edgecolors = green)

pyplotscatter(x y2 s = 50 c = red marker = + linewidth = 3)

pyplotscatter(x y3 s = 50 c = cyan marker = o edgecolors = none)

pyplottitle(scatter plot)


ravel httpswwwtutorialspointcomnumpynumpy_ndarray_ravelhtm

Cette fonction retourne un tableau array en une dimension

import numpy as np

a = nparange(8)reshape(24)

print The original array is

print a

print n

print After applying ravel function

print aravel()

print n

print Applying ravel function in F-style ordering

print aravel(order = F)

Votre reacutesultat devrait ressembler agrave cela

The original array is

[[0 1 2 3]

[4 5 6 7]]

After applying ravel function

[0 1 2 3 4 5 6 7]

Applying ravel function in F-style ordering [0 4 1 5 2 6 3 7]


Numpyc_ httpsstackoverflowcomquestions39136730confused-about-numpy-c-document-and-sample-code

Cette fonction concategravene plusieurs array

gtgtgt numpyc_[nparray([[123]]) 0 0 nparray([[456]])] array([[1 2 3 0 0 4 5 6]])


Preacutediction

Lalgorithme de preacutediction est repreacutesenteacute par une classe

Vous devez commencer par choisir lalgorithme agrave utiliser que nous

appelerons preacutedicteurclassifieurestimator Les algorithmes sont des

classes Python Les donneacutees sont toujours des tableaux

NumpyScipyPandasPython

Vous preacutecisez ses eacuteventuels paramegravetres appeleacutes hyperparamegravetres en

instanciant la classe

Vous lalimentez avec la fonction fit dans le cas dun apprentissage

superviseacute

Vous lancez la preacutediction sur un ensemble de valeurs via la fonction

predict parfois appeleacutee transform dans le cas de lapprentissage non

superviseacute

Exercice Reprenez les exercices preacuteceacutedents et trouver les fit et predict ou transform

Deacutecouverte par la pratique

- Classer une fleur selon des critegraveres observables

Nous allons utiliser pour ce tutoriel la base de donneacutees dIris de

la librairie scikit-learn

Mais quel est donc cet Iris

Cet exemple est tregraves souvent repris sur Internet Nous ne

deacuterogerons pas agrave la regravegle Nous reacutealiserons cependant un cas

dutilisation plus complet que la plupart des exemples que vous

pourrez trouver

Cette base contient des Iris quun botaniste Ronald Fisher a

classeacutes en 1936 agrave laide dune clef didentification des plantes

(type de peacutetales seacutepale type des feuilles forme des feuilles )

Puis pour chaque fleur classeacutee il a mesureacute les longueurs et largeurs des seacutepales et peacutetales

Lideacutee qui nous vient alors consiste agrave demander agrave lordinateur de deacuteterminer automatiquement lespegravece dune

nouvelle plante en fonction de la mesure des dimensions de ses seacutepales et peacutetales que nous aurions reacutealiseacutee

sur le terrain Pour cela nous lui demanderons de construire sa deacutecision agrave partir de la connaissance extraite

des mesures reacutealiseacutees par M Fisher Autrement dit nous allons donner agrave lordinateur un jeu de donneacutees deacutejagrave

classeacutees et lui demander de classer de nouvelles donneacutees agrave partir de celui-ci

Cest un cas dapprentissage superviseacute (mais nous le transformerons aussi en non superviseacute)

Une fois alimenteacutes avec les observations connues nos preacutedicteurs vont chercher agrave identifier des groupes

parmi les plantes deacutejagrave connues et deacutetermineront quel est le groupe duquel se rapproche le plus notre

observation

Botanistes en herbe agrave vos claviers

Note pour les naturalistes amateurs

Si vous aimez les clefs de deacutetermination une des plus connues est celle de M Gaston Bonnier Ses livres

sont aujourdhui dans le domaine public

Classer une fleur selon des critegraveres observables Le but de lrsquoexercice est que vous saisissiez au clavier chacune des eacutetapes afin de

comprendre au mieux ce que lrsquoon fait

Chargement de la base

from sklearn import datasets

iris = datasetsload_iris()

La variable iris est dun type inhabituel deacutecouvrons-le

Deacutecouverte du contenu de la base

print(type(iris))

Ce nest pas un DataFrame mais une sorte de dictionnaire Rien de bien complexe

pour un Pythoniste

ltclass sklearndatasetsbaseBunchgt

Et que peut-on faire avec

print(dir(iris))

[DESCR data feature_names target target_names]

print(irisfeature_names) Les noms des paramegravetres de nos donneacuteesenregistrements

Lattribut feature_names contient le nom des diffeacuterents paramegravetres de nos donneacutees il

sagit des longueurs et largeurs de peacutetales et seacutepales

[sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)] Un aperccedilu

des 5 premiers enregistrements

print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])

Classer une fleur selon des critegraveres observables

Question donnez les longueurs et largeusr des seacutepales peacutetales des 5 premiers

iris de la base

httpscanopeac-besanconfrfloredidactitielfleurfleurhtm



print(irisfeature_names) donne ces reacutesultats

[sepal length (cm) sepal width (cm) petal length (cm)

petal width (cm)]

print (irisdata[5]) donne cela

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])

donc pour lrsquoiris 0 la longueur du seacutepale est 51 cm la

largeur du sepale 35 cm

La longuer du petale 14 cm et la largeur du petale 02 cm

pour lrsquoiris 1 la longueur du seacutepale est 49 cm la largeur du

sepale 3 cm











Correction


Si comme moi vous trouvez que sur les images les sepales ont lrsquoair petit en tout cas plus

petits que les peacutetales alors que la base donne lrsquoinverse voici un nouveau sheacutema plus clair

Correction

httpkidisciencecafe-

sciencesorgarticlesp

redire-les-longueurs-

de-petale-des-fleurs-

diris

liste des espegraveces connues

La liste des espegraveces connues nos labels de classification est contenue dans

lattribut target_names

print(iristarget_names)

array([setosa versicolor virginica] dtype=ltU10)

Creacuteation dune variable target pour un accegraves plus facile agrave cet attribut

target = iristarget

Les labels associeacutes agrave chaque enregistrement

print(target)

target[0] est le label de iris[data][0]

Les targets sont un tableau indiquant le numeacutero de lespegravece de chaque

enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]

print(classe s nb exemplaires s (i len(target[ target == i]) ) )

classe 0 nb exemplaires 50




Exercice donnez les espegraveces drsquoiris (et reconnaitre les images) et dire combien de

chaque espegravece a-t-on dans la base



correction


La liste des espegraveces connues sont dans dans lattribut target_names



target = iristarget


for i in [012]






correction

leacutechantillon de fleurs

Exercice pouvez-vous nous dire ce que contient lrsquoeacutechantillon de

donneacutees iris



En reacutesumeacute leacutechantillon de fleurs propose plusieurs informations

Les noms des donneacutees disponibles feature_names

Les mesures reacutealiseacutees sur leacutechantillon de fleurs connues et deacutejagrave classeacutees

data

Il sagit de nos informations des paramegravetres de nos vecteurs pour chaque

fleur

Le nom de chaque espegravece target_names

Le classement de chaque enregistrement data dans son espegravece target

Il sagit de la classe de chaque fleurvecteur

correction

Eacutechantillon de fleurs

print(irisDESCR)

Iris Plants Database ==================== Notes ----- Data Set Characteristics Number of Instances 150

(50 in each of three classes) Number of Attributes 4 numeric predictive attributes and the class Attribute

Information - sepal length in cm - sepal width in cm - petal length in cm - petal width in cm - class - Iris-Setosa

- Iris-Versicolour - Iris-Virginica Summary Statistics ============== ==== ==== ======= =====

==================== Min Max Mean SD Class Correlation ============== ==== ==== ======= =====

==================== sepal length 43 79 584 083 07826 sepal width 20 44 305 043 -04194 petal

length 10 69 376 176 09490 (high) petal width 01 25 120 076 09565 (high) ============== ====

==== ======= ===== ==================== Missing Attribute Values None Class Distribution 333 for

each of 3 classes Creator RA Fisher Donor Michael Marshall (MARSHALLPLUioarcnasagov) Date

July 1988 This is a copy of UCI ML iris datasets httparchiveicsuciedumldatasetsIris The famous Iris

database first used by Sir RA Fisher This is perhaps the best known database to be found in the pattern

recognition literature Fishers paper is a classic in the field and is referenced frequently to this day (See Duda

amp Hart for example) The data set contains 3 classes of 50 instances each where each class refers to a type of

iris plant One class is linearly separable from the other 2 the latter are NOT linearly separable from each other

References ---------- - FisherRA The use of multiple measurements in taxonomic problems Annual Eugenics

7 Part II 179-188 (1936) also in Contributions to Mathematical Statistics (John Wiley NY 1950) -

DudaRO amp HartPE (1973) Pattern Classification and Scene Analysis (Q327D83) John Wiley amp Sons ISBN

0-471-22361-1 See page 218 - Dasarathy BV (1980) Nosing Around the Neighborhood A New System

Structure and Classification Rule for Recognition in Partially Exposed Environments IEEE Transactions on

Pattern Analysis and Machine Intelligence Vol PAMI-2 No 1 67-71 - Gates GW (1972) The Reduced

Nearest Neighbor Rule IEEE Transactions on Information Theory May 1972 431-433 - See also 1988 MLC

Proceedings 54-64 Cheeseman et als AUTOCLASS II conceptual clustering system finds 3 classes in the

data - Many many more

correction

Eacutechantillon de fleurs correction

Observation des donneacutees

matplotlib inline


import matplotlib as mpl

import numpy as np

fig = pltfigure(figsize=(8 4))

figsubplots_adjust(hspace=04 wspace=04)

ax1 = pltsubplot(121)

clist = [violet yellow blue]

colors = [clist[c] for c in iristarget]

ax1scatter(data[ 0] data[ 1] c=colors)

pltxlabel(Longueur du sepal (cm))

pltylabel(Largueur du sepal (cm))


ax2scatter(data[ 2] data[ 3] color=colors)

pltxlabel(Longueur du petal (cm))

pltylabel(Largueur du petal (cm))

Leacutegende

for ind s in enumerate(iristarget_names)

on dessine de faux points car la leacutegende naffiche que les points ayant un label

pltscatter([] [] label=s color=clist[ind])

pltlegend(scatterpoints=1 frameon=False labelspacing=1 bbox_to_anchor=(18

5) loc=center right title=Espegraveces)

pltplot()

Le but ici est simplement de regarder les donneacutees sur un scheacutema httpsmatplotlib

orgapi_as_gen

matplotlibpyplots

ubplothtml


Voici ce que lrsquoon obtient (pas important si vous nrsquoavez pas fait tourner le code

pour obtenir ces images il est seulement important dans la meacutethode drsquoessayer

de laquo dessiner raquo nos donneacutees avant de vouloir les classifier ou de faire tourner un

algo dessus)

Exercice pourriez-vous deacutejagrave trouver un critegravere une meacutethode de classification


Observer avec Seaborn

Cest assez vite eacutecrit et deacutejagrave fort parlant la seacuteparation des groupes entre

les longueurs et largeurs de peacutetales semble tregraves nette et deacuteterminante

Nous pourrions aussi le faire entre les longueurs de peacutetales et largeurs de

seacutepales et inversement mecircme si cela semble moins naturel

La librairie Seaborn propose une matrice precircte agrave lemploi via le graphique

Scatterplot Matrix pour reacutealiser ce type de graphique

import seaborn as sns

import pandas as pd

snsset()

df = pdDataFrame(data columns=iris[feature_names] )

df[target] = target

df[label] = dfapply(lambda x iris[target_names][int(xtarget)] axis=1)

dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats


Il ne reste plus quagrave dessiner le graphique avec Seaborn

snspairplot(df hue=label vars=iris[feature_names] size=2)

Exercice Quelle

classification

proposeriez-vous laquo de

tecircte raquo


Observer avec Seaborn Pour moi plusieurs

scheacutemas semblent

bien seacuteparer les

espegraveces

Voici ma proposition

drsquoalgo

Si longueur petalelt25

cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage

On va essayer de traiter ceci avec des algorithmes Nous pourrions ici utiliser

plusieurs algorithmes

Nous proposons de commencer par la classification Naive Bayes qui suppose que

chaque classe est construite agrave partir dune distribution Gaussiegravenne aligneacutee

Elle nimpose pas de deacutefinir dhyperparamegravetres et est tregraves rapide

Il faut utiliser GaussianNB qui est dans sklearnnaive_bayes

Puis Il faut creacuteer une instance du classificateur GaussianNB

Il faut faire fitter nos donneacutees data et target pour lrsquoapprentissage

Donc avec fit(data target)

Si on ne sait plus ce que lrsquoon peut faire avec notre classificateur imprimons son

directory avec print(dir(clf))


Apprentissage

from sklearnnaive_bayes import GaussianNB

Creacuteation du classifieur

clf = GaussianNB()

Apprentissage

clffit(data target)

GaussianNB(priors=None)

print(dir(clf))

[ _abc_cache _abc_negative_cache _abc_negative_cache_version

_abc_registry _estimator_type _get_param_names _joint_log_likelihood

_partial_fit _update_mean_variance fit get_params partial_fit predict

predict_log_proba predict_proba priors score set_params ]

clfget_params()

priors None

correction

Apprentissage

Exercice Exeacutecutons la preacutediction sur les donneacutees dapprentissage elles-

mecircmes avec clfpredict(data)

Et imprimer le reacutesultat qursquoobservez-vous Qursquoen pensez-vous


Apprentissage

Exeacutecutons la preacutediction sur les donneacutees dapprentissage elles-mecircmes

result = clfpredict(data)

result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])

mes remarques a priori on a fait tourner lrsquoalgo ndashtrouveacute par nos donneacutees

drsquoentreacutee ndash sur nos donneacutees drsquoentreacutee on aurait pu impaginer qursquoil redonne

exactement les valeurs drsquoeacutetiquettes vraies or ce nrsquoest pas le cas

correction

Qualiteacute de la preacutediction

Exercice Observons la qualiteacute de la preacutediction

Lagrave ou la preacutediction est juste la diffeacuterence de result - target doit ecirctre eacutegale agrave 0 Si la

preacutediction est parfaite nous aurons des zeacuteros dans tout le tableau Ce qui est agrave peine

le cas

Montrer les erreurs de preacutediction et calculer le pourcentage de reacuteussite agrave trouver la

bonne eacutetiquette de notre algorithme

Qursquoen deacuteduisez-vous

Pensez-vous que lrsquoalgorithme a lsquosurapprisrsquo





le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])

Calculons le pourcentage derreur

errors = sum(result = target) 6 erreurs sur 150 mesures

print(Nb erreurs errors)

print( Pourcentage de preacutediction juste (150-errors)100150) 96 de reacuteussite Nb

erreurs 6

Pourcentage de preacutediction juste 960

On aurait pu penser que les tableaux seraient parfaitement identiques mais

lalgorithme utiliseacute estime vraiment le label final en fonction des regravegles de probabiliteacute

quil a eacutetablies Ces regravegles ne sont pas rigoureusement identiques agrave la reacutealiteacute

Cela prouve aussi que lalgorithme essaye de trouver un classement intelligent et ne

se contente pas de comparer les valeurs dorigines aux valeurs entrantes

Ici nous ne sommes pas dans un cas de surapprentissage

correction

qualiteacute de la preacutediction Exercice

Ici nous avons regardeacute que notre algo preacutevoit le bon classement dans

96 des cas Pensez-vous que crsquoest un bon algorithme

que proposeriez-vous pour mieux calculer si votre algorithme est bon ou

pas

Regarder dans sklearndans sklearnmetrics regarder lrsquo accuracy_score

accuracy_score(result target)

Regarder aussi la matrice de confusiondans sklearnmetrics regarder

confusion_matrix

confusion_matrix(target result)

De quoi srsquoagit-il

httpsfrwikipediaorgwikiMatrice_de_confusion

Ou si vous avez le temps

httpsopenclassroomscomfrcourses4297211-evaluez-et-ameliorez-les-

performances-dun-modele-de-machine-learning


qualiteacute de la preacutediction Notre solution pour mesurer la qualiteacute de la preacutediction est tregraves rudimentaire

Scikit-Learn propose des solutions plus abouties

from sklearnmetrics import accuracy_score

accuracy_score(result target) 96 de reacuteussite

095999999999999996

Scikit-Learn permet aussi de calculer la matrice de confusion

from sklearnmetrics import confusion_matrix

conf = confusion_matrix(target result)

conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])

La matrice de confusion mesure

Les true positives ceux preacutevus en telle classe et qui el sont reacuteellement

Les false positive ils ont eacuteteacute preacutevus dans une classe mais en fait sont drsquoune

autre

Les false negatives on ne les avait pas preacutevu dans cette classe alors qursquoen

fait ils y sont en vrai

Les true negatives on ne les avait pas preacutevu ici et on a bien fait car ils nrsquoy

sont pas en vrai

correction

qualiteacute de la preacutediction

correction

Qualiteacute de la preacutediction Et Seaborn permet de la repreacutesenter avec le Heatmap

snsheatmap(conf square=True annot=True cbar=False

xticklabels=list(iristarget_names) yticklabels=list(iristarget_names))

pltxlabel(valeurs preacutedites)

pltylabel(valeurs reacuteelles)

Lon observe ici que

Lespegravece Setosa a eacuteteacute parfaitement identifieacutee

3 Virginica ont eacuteteacute confondues avec des Versicolor et inversemment

Ce nest pas tregraves surprenant les graphiques montrent une nette seacuteparation des

Setosa avec les 2 autres groupes qui sont nettement moins deacutetacheacutes

Correction compleacutement avec seaborn

Seacuteparation du jeu de tests et dapprentissage

Maintenant une prise de recul srsquoimpose

Nous avons entraineacute notre modegravele sur une base de donneacutees

On trouve un algorithme

Ensuite on regarde sur ces mecircmes donneacutees si lsquolrsquoalgorithme est performant

Nrsquoy a-t-il pas quelque chose qui vous gecircne

Imaginons que nos fleurs soient des versicolor agrave 95

Trouvez moi un algorithme bon agrave 95

Reacuteponse lrsquoaglo toutes les fleurs sont des versicolor sera bon nrsquoest-ce pas

Aussi on peut tregraves bien faire un algo juste agrave 100 avec nos donneacutees drsquoentreacutee si je

reprends lrsquoexemple preacuteceacutedent je vois que les fleurs numeacuteros52 70 77 106 119

133 sont mal eacutetiquetteacutees je peux tregraves bien ajouter dans mon algo

Et si numeacutero= 527077 alors eacutetiquette 2

Et si numeacutero= 106119 133 alors eacutetiquette 3

Que pensez-vous drsquoun tel algo

Exercice Que proposeriez-vous pour remeacutedier agrave cela



La reacuteponse est dans le fait de seacuteparer le jeu de donneacutees de deacutepart

Nous ne disposons que dun seul jeu de donneacutees connues

Geacuteneacuteralement lon teste lalgorithme sur de nouvelles donneacutees sinon les reacutesultats sont

forceacutement toujours tregraves bons

Nous pourrions choisir un enregistrement sur 2 comme ci-dessous

data_test target_test = data[2] target[2]

data_train target_train = data[12] target[12]

target_test target_train len(target_test) len(target_train)

(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)

Mais ce nest pas une tregraves bonne meacutethode

Dans cet exemple nous seacutelectionnons un enregistrement sur 2 Nous nous en sortons

bien car toutes les fleurs sont regroupeacutees par ordre de famille dans le tableau mais si

les setosa avaient eacuteteacute stockeacutees 1 sur 2 elles auraient soit toutes eacuteteacute utiliseacutees pour

lapprentissage et aucune naurait figureacute dans le jeu de tests ou inversement

correction

Model selection

Dans les faits on va plutocirct seacuteparer notre jeu de donneacutees en un jeu de donneacutee

drsquoentrainement aux alentours de 75 des donneacutees drsquoentreacutee et garder le reste en

jeu de test

Le module model_selection de Scikit-Learn propose des fonctions pour seacuteparer le

jeu de donneacutees du jeu de tests qui sont attentives agrave ce type de petits problegravemes

Il faut importer

train_test_split

Et donner la taille des donneacutees de tests

data_test = train_test_split(data target random_state=0 train_size=05)

httpsscikit-

learnorgstablemodulesgeneratedsklearnmodel_selectiontrain_test_splithtml

Exercice deacutecomposer notre jeu de donneacutees en jeu drsquoentrainement et jeu de test

avec 50 des donneacutees en jeu de test

Imprimez les 5 premiers eacuteleacutements

correction


Model selection

from sklearncross_validation import train_test_split Version 0171 from

sklearnmodel_selection import train_test_split version 0181

split the data with 50 in each set


data_train data_test target_train target_test = data_test

La fonction train_test_split permet de deacutecomposer le jeu de donneacutees en 2

groupes les donneacutees pour lapprentissage et les donneacutees pour les tests

Le paramegravetre train_size indique la taille du jeu dapprentissage qui sera utiliseacute

50 des enregistrements

data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction

Exercice maintenant reacute-entrainer le modegravele avec les nouvelles donneacutees

drsquoentrainement (seulement) et calculer le score et la matrice de confusion


classification Il ne reste plus quagrave relancer la classification

clf = GaussianNB()

clffit(data_train target_train)

result = clfpredict(data_test)

Puis de calculer de nouveau la qualiteacute de la preacutediction

Score

accuracy_score(result target_test)

Cela reste toujours tregraves bon

094666666666666666

Affichons la matrice de confusion Matrice de confusion

conf = confusion_matrix(target_test result)

conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction

les territoires de la classification Notre preacutedicteur sest construit une image de nos donneacutees

Visualisons-lagrave pour toutes les combinaisons de longueurs et largeurs de

seacutepales connues

Lideacutee est la suivante

Nous construisons un maillage de toutes les combinaisons possibles des

longueurs et largeurs des seacutepales comprises entre leurs valeurs minmax

Pour chaque couple de point (longueur largeur) compris entre les

minmax observeacutes nous demandons de preacutedire lespegravece de la fleur

Nous affichons sur la carte les preacutedictions reacutealiseacutees (une couleur pour

chaque point)

On ne conserve que les longueurslargeurs des seacutepales

data = irisdata[ 2]

target = iristarget

data[5]

Aperccedilu des donneacutees

array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])

les territoires de la classification choisissons Gaussian NB comme classificateur

clf = GaussianNB()

clffit(data target)

et un indice de population de notre tableau de 015 cm tous les points seront

eacuteloigneacutes les uns des autres de 015 cm

h = 15

Nous recherchons les valeurs minmax de longueurslargeurs des seacutepales en

ajoutant 1 pour laisser juste un peu de marge

x_min x_max = data[ 0]min() - 1 data[ 0]max() + 1

y_min y_max = data[ 1]min() - 1 data[ 1]max() + 1

et nous construisons un ensemble de points fictifs x et y seacutepareacutes de 015

x = nparange(x_min x_max h)

y = nparange(y_min y_max h)

Le tableau x contient la liste des longueurs des seacutepales qui seront utiliseacutees pour les

tests de classification comprises entre les minmax observeacutes et seacutepareacutes de 015 cm

x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])

les territoires de la classification Explications

Le tableau xx contient les diffeacuterentes longueurs reacutepeacuteteacutees autant de fois que nous

avons de mesures pour les largeurs

xx Vecteur des valeurs de X reacutepeacuteteacute autant de fois que lon a de valeurs

diffeacuterentes pour Y

array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])

Inversement le tableau yy contient chaque largeur reacutepeacuteteacutee autant de fois quil y a

de mesures diffeacuterentes des longueurs

yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])

les territoires de la classification La fonction ravel applatit un tableau agrave n dimensions en 1 tableau dune dimension

a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])

La fonction zip geacutenegravere quant-agrave-elle une liste de n-uplets constitueacutee des eacuteleacutements du mecircme rang de

chaque liste reccedilue en paramegravetre

list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]

Nous pouvons donc maintenant visualiser le contenu du jeu de donneacutees geacuteneacutereacute

data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]

Ces couples de points ne sont autres que des mesures de fleurs imaginaires comprises entre les

valeurs minmax connues

Le but eacutetant de deacuteterminer leur espegravece pour voir lextension des territoires de chacune delle telle que

classeacutee par lordinateur

les territoires de la classification Nous pouvons maintenant afficher les espegraveces telles que lalgorithme les

eacutevaluerait si nous les mesurerions dans la nature

Z = clfpredict(data_samples)

Z = Zreshape(xxshape)

pltfigure(1)

pltpcolormesh(xx yy Z) Affiche les deacuteductions en couleurs pour les

couples xy Plot also the training points pltscatter(data[ 0] data[ 1]

c=target)

colors = [violet yellow red]

C = [colors[x] for x in Z]

pltscatter(xxravel() yyravel() c=C)

pltxlim(xxmin() - 1 xxmax() + 1)

pltylim(yymin() - 1 yymax() + 1)



Cette image nest autre que votre clef de

deacutetermination Imprimez-lagrave et partez

identifier les fleurs sur le terrain mesurez

les longueurslargeurs de seacutepales

recherchez-les sur le graphique la couleur

du point vous donne lespegravece

les territoires de la classification

Affichons le limites avec pcolormesh

pltfigure(1)

pltpcolormesh(xx yy Zreshape(xxshape)) Affiche les deacuteductions en

couleurs pour les couples xy Plot also the training points


C = [colors[x] for x in target]

pltscatter(data[ 0] data[ 1] c=C)

pltxlim(xxmin() xxmax())

pltylim(yymin() yymax())



KNN Essayons le mecircme traitement en remplaccedilant GaussianNB par

KN

La classe agrave utiliser est

from sklearn import neighbors

clf = neighborsKNeighborsClassifier()

Si vous travaillez dans un notebook Jupyter (fortement

recommandeacute) utilisez le deacutecorateur interact pour faire varier

lhyperparamegravetre N du nombre voisins

from ipywidgets import interact

interact(n=(020))

def n_change(n=5)

clf = neighborsKNeighborsClassifier(n_neighbors=n)

clffit(data target)


pltfigure(1)

pltpcolormesh(xx yy Zreshape(xxshape)) Affiche les deacuteductions en couleurs pour les

couples xy Plot also the training points








KNN Calcul de la preacutecision de la preacutediction en

fonction de N

data_test target_test = irisdata[2]

iristarget[2]

data_train target_train = irisdata[12]

iristarget[12]

result = []

n_values = range(120)

for n in n_values

clf=neighborsKNeighborsClassifier

(n_neighbors=n)


Z = clfpredict(data_test)

score = accuracy_score(Z

target_test)

resultappend(score)

pltplot(list(n_values) result)

Le graphique geacuteneacutereacute montre que la preacutediction semble la meilleure pour N=8

Si vous souhaitez deacutecouvrir comment optimiser au mieux vos hyperparamegravetres la

fonction grid search vous simplifie eacutenormeacutement la recherche des hyperparamegravetres

optimaux

KNN httppython-prepagithubioateliersdata_mininghtml

Lorsqursquoarrive une observation inconnue nous allons chercher dans la base de donneacutee drsquoentrainement les

lsquoplus proches voisinsrsquo qui lui ressemblent plus et nous faisons un vote entre eux pour deacutecider de la classe de

lrsquoobservation inconnue

Comme nous avons un problegraveme de classification il nous faut un ldquoclassifierrdquo

gtgtgt from sklearn import neighbors

gtgtgt clf = neighborsKNeighborsClassifier()

clf sait apprendre agrave faire des deacutecisions agrave partir de donneacutees

gtgtgt clffit(data target)

et preacutedire sur des donneacutees

gtgtgt clfpredict(data[10])

array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque

Comment faire que un preacutedire aux plus proches voisins nrsquoait aucune erreur sur les donneacutees drsquoentraicircnement

Pourquoi est-ce illusoire

72122 Donneacutees de test

Pour tester la preacutediction sur des donneacutees non vues il nous faut en mettre de coteacute

gtgtgt data_train = data[2]

gtgtgt data_test = data[12]

gtgtgt target_train = target[2]

gtgtgt target_test = target[12]

gtgtgt clffit(data_train target_train)

Maintenant testons la preacutediction sur les donneacutees de ldquotestrdquo

gtgtgt npsum(clfpredict(data_test) - target_test)

1

Une seule erreur

Apprentissage non superviseacute Si nous supprimons linformation target nous tombons dans le cas dalgorithmes de

clustering nous pouvons toujours demander agrave ce que notre algorithme seacutepare nos

donneacutees en 3 groupes sans connaissance de leurs veacuteritables eacutetiquettes

Saura-t-il retrouver les groupes initiaux

Reacuteduction de dimension

Dans le cas des algorithmes non superviseacutes il est tregraves freacutequent de disposer de tregraves

grandes quantiteacutes de paramegravetres Ne sachant pas encore qui est responsable de

quoi on a tendance agrave tout livrer agrave la machine

Cela pose 2 problegravemes

La visualisation des donneacutees au delagrave de 3 paramegravetres notre cerveau est bien mal

outilleacute pour se repreacutesenter les donneacutees

La complexiteacute des calculs plus le nombre de paramegravetres est grand plus nous

aurons des calculs complexes et longs

Pour contourner ces problegravemes il est courant de reacuteduire la dimension du vecteur de

donneacutees agrave quelque chose de plus simple La difficulteacute est alors de reacuteduire le

nombre de paramegravetres tout en conservant lessentiel de linformation notamment

les variations susceptibles de permettre le regroupement des donneacutees

Plusieurs techniques de reacuteduction sont disponibles avec Scikit-Learn

Nous utiliserons pour cet exemple lanalyse en composante principale dite PCA

Le module manifold propose aussi dautres types dalgorithmes

PCA PCA est une technique lineacuteaire de reacuteduction de dimension qui a

lavantage decirctre tregraves rapide Elle sutilise simplement

Vous deacutefinissez le nombre de paramegravetres

Vous alimentez lalgorithme avec les donneacutees agrave reacuteduire

Vous lancez la preacutediction ici appeleacutee reacuteductiontransformation

from sklearndecomposition import PCA

Deacutefinition de lhyperparamegravetre du nombre de composantes voulues

model = PCA(n_components=2)

Alimentation du modegravele

modelfit(irisdata) Transformation avec ses propres donneacutees

reduc = modeltransform(irisdata )

Nous venons de reacuteduire notre vecteur de 4 paramegravetres en 1 vecteur de 2

paramegravetres dont les variations sont censeacutees ecirctre similaires

Autrement dit nous devrions ecirctre capable de classer nos fleurs avec ces

vecteurs reacuteduits en ayant une qualiteacute proche de celle utilisant les vecteurs

originaux

PCA

irisdata[5]

Consultation des donneacutees originales

array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])

Et de leur version reacuteduite

reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()

Ajoutons les nouveaux paramegravetres dans le dataframe dorigine

df[PCA1] = reduc[ 0]


dfhead()

PCA

Puis affichons les nouveaux couples de points (PCA1 PCA2) avec la

couleur de lespegravece associeacutee

colors = [violet yellow blue]

pltscatter(df[PCA1] df[PCA2] c=[ colors[c] for c in df[target] ])

pltxlabel(PCA1)

pltylabel(PCA2)

Nous obtenons 3 groupes plutocirct bien dissocieacutes

Maintenant ce nouveau classement peut-il

permettre un bon regroupement des 3

espegraveces le graphique semble le confirmer

veacuterifions cela avec le clustering

Clustering Il ne reste plus quagrave exeacutecuter le regroupement Plusieurs algorithmes

existent

k-Means qui se rapproche des plus proches voisins dans sa logique

recherche les donneacutees proches des centres des clusters Il est tregraves simple

mais nest vraiment efficace que sur des donneacutees organiseacutees en cercles

ici nous avons plutocirct des droites ou des ellipses

GMM Gaussian Mixture Models est plus complexe mais sadapate tregraves

bien agrave diffeacuterentes formes de clusters (groupes)

Scikit Learn en propose beaucoup dautres comme Spectral clustering

Mean Shift Hierarchical clustering

Nous utiliserons GMM pour cet exemple

from sklearnmixture import GaussianMixture

Creacuteation du modegravele avec 3 groupes de donneacutees

model = GaussianMixture (n_components=3 covariance_type=full)

Apprentissage il ny en a pas vraiment

modelfit(df[[PCA1 PCA2]])

Preacutediction

groups = modelpredict(df[[PCA1 PCA2]])

Clustering La preacutediction eacutetant faicircte pour chaque groupe geacuteneacutereacute nous affichons la

couleur reacuteelle des espegraveces si le clustering a eacuteteacute efficace il ny aura

quune seule couleur par groupe

df[group] = groups

snslmplot(PCA1 PCA2 data=df hue=label col=group

fit_reg=False)

Le groupe setosa est tregraves bien identifieacute il y a toujours une impreacutecision

entre les classes virginica et versicolor mais le reacutesultat reste remarquable

sur ce petit eacutechantillon

IRIS agrave vous Peacutedagogie

Lrsquoideacutee est de reprendre lrsquoensemble de ce que lrsquoon vient de voir et de tout refairehelliptout seul


bull De faire tourner les algorithmes suivants


bull Mais aussi

bull SVM

bull KNN

bull PCA


bull De comparer les reacutesultats de ces diffeacuterents algorithmes


-Fait tourner de nombreuses fonctionnaliteacutes de sklearn

-Montreacute nos donneacutees et reacutesultats en scheacutema

-fait tourneacute sur nos python gaussian NB mais aussi KNN et SVM PCA gaussian mixture

-compareacute les reacutesultats drsquoun mecircme set de donneacutees sur diffeacuterents algorithmes

-deacutecouvert ce que lrsquoon appelle classification reacuteduction de dimensionnaliteacute clustering hellip

Exercice IRIS avec diffeacuterents algos

Crsquoest agrave vous lancez-vous avec la base des iris et commenccedilons par lrsquoalgorithme KNN

key nearest neighbours = les n voisins les plus proches qui est un autre algorithme (sur

lequel on reviendra en deacutetail)

Tout drsquoabord

Importer depuis sklearn les datasets

Iris

et donnez la taille des donneacutees



IRIS donneacutees httppython-prepagithubioateliersdata_mininghtml

gtgtgt from sklearn import datasets

gtgtgt iris = datasetsload_iris()

gtgtgt data = irisdata

gtgtgt datashape

(150 4)

correction


IRIS donneacutees

Ensuite donnez les informations que lrsquoon a sur les iris en terme de seacutepales petaleshellip


IRIS donneacutees donnez les informations que lrsquoon a sur les iris en terme de seacutepales petaleshellip


gtgtgt irisfeature_names

[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target

Quelles sont les target de votre base iris

Et quelles sont les noms des especes


IRIS target Quelles sont les target de votre base iris



gtgtgt target = iristarget

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])

gtgtgt iristarget_names

array([setosa versicolor virginica] dtype=|S10)

correction

IRIS visualisation

Ensuite dessinnez sur un sheacutema ce que lrsquoon veut voir en important la

meacutethode pyplot de matplotlib matplotlibpyplot

Et sur un sheacutema de 4 sur 3 avec la methode figure et figsize

Tracez le nuage de point avec matplotlib pyplot scatter (plus drsquoexplications

sur httpwwwpython-simplecompython-matplotlibscatterplotphp ) en

prenant comme donneacutees drsquoabcisses les donneacutees drsquoentreacutee les longueur de

seacutepales

Et en ordonneacutee les largeur de sepales

Avec en couleur diffeacuterentes les diffeacuterentes espegraveces pour les points traceacutes

Nommer les axes avec xlabel et ylabel de matplotlibpyplot


IRIS visualisation


pltfigure(figsize=(4 3))

pltscatter(data[ 0] data[ 1] c=target)



plttitle(lsquovoici nos donneacutees IRISrsquo)

correction

IRIS visualisation


from matplotlib import pyplot as plt



data = irisdata

target = iristarget

Une nouvelle figure





Mise en page de la figure

plttight_layout()

pltshow()

correction

IRIS seacutepales Nous allons maintenant entrainer notre modegravele avec le classificateurs KNN

Tout drsquoabord on ne va prendre que les deux

premiegraveres informations dans notre set de

donneacutees que lrsquoon nommera iris longueur et

largeur des sepales

on nomme target les target des iris

IRIS seacutepales Deacutecision de ne prendre que les seacutepales


data = irisdata[ 2]

target = iristarget

correction

IRIS meshgrid Creacuteation de la grille

Nous allons maintenant dessiner une carte avec des couleurs pour visualiser les

diffeacuterents algorithmes

Pour dessiner cette carte on va dessiner plein de points eacuteloigneacutes de h= 002

chacun

On va determiner x_min le minimum des donneacutees de longueurs des seacutepales et lui

ocircter -1 (pour garder une frontiegravere)

Et x_max le maximum des donneacutees de longueurs des seacutepales et lui ajouter +1

(pour garder une frontiegravere)

De mecircme pour les largeurs de seacutepales

y_min le minimum des donneacutees de largeurs des seacutepales et lui ocircter -1 (pour garder

une frontiegravere)

Et y_max le maximum des donneacutees de largeurs des seacutepales et lui ajouter +1 (pour

garder une frontiegravere)

On va maintenant creacuteer une grille (meshgrid) xx yy entre ces valeurs minimum et

maximum des x et y (on pourra utiliser la meacutethode arange de numpy)

IRIS meshgrid Nous allons maintenant entrainer notre modegravele avec le classificateurs KNN

h = 02 pas de la grille

deacutefinition des points limites [x_min x_max][y_min y_max]



construction de la grille avec meshgrid et arange

xx yy = npmeshgrid(nparange(x_min x_max h)

nparange(y_min y_max h))

correction

IRIS KNN fit Nous allons maintenant entrainer notre modegravele avec le classificateurs KNN

Maintenant deacutefinissez un classificateur clf KNN neighborsKNeighborsClassifier

Et le faire fitter aux donneacutees drsquoentreacutee data et de target


on creacutee un instance de Neighbours Classifier

et on le fait fitter aux data


clffit(data target)

correction

IRIS KNN predict Nous allons maintenant preacutedire tous les points de la grille

Maintenant il faut preacutedire gracircce agrave ce classificateur clf

la classification de chacun des points de la grille

On va utiliser la methode ravel sur les xx et yy et

np_c pour les transformer chacun en points

Et numpyc_ pour concateacutener lrsquoensemble des points

en un set de donneacutees data agrave preacutedire

IRIS KNN predict Nous allons maintenant faire des preacutedictions sur tous nos points

Z = clfpredict(npc_[xxravel() yyravel()])

correction

IRIS KNN Visualisation Nous allons maintenant dessiner tout ceci

Il faut reshaper Z pour avoir le bon format qui doit ecirctre le mecircme que celui de xx

Et ensuite dessiner une figure de taille 43 (par figure et figsize)

Et ensuite mettre les points en couleur gracircce agrave pcolor leurs abcisses sont xx leurs

ordonneacutees yy et leurs couleurs provient du classificateur Z

Y ajouter les points drsquoentrainement avec en abcisses les longueurs de seacutepales en

ordonneacutee les largeurs de seacutepales et en couleur leur target diffeacuterentes

On peut prendre en limite sur les abcisses xlim les minimum et maximum des xx

On peut prendre en limite sur les ordonneacutees ylim les minimum et maximum des yy



pltfigure(1 figsize=(4 3))

pltclf()

pltpcolormesh(xx yy Z)

Plot also the training points




pltshow()

correction

IRIS Autres classificateurs Nous allons maintenant comparer les diffeacuterents algorithmes de classification

Refaire tourner tout ceci avec un classificateur naive bayes et un classificateur SVM

Nrsquooubliez pas drsquoimporter els bonnes bibliothegraveques

from sklearnsvm import LinearSVC

from sklearnmulticlass import OneVsOneClassifier

pour le svm

Et from sklearnnaive_bayes import GaussianNB

Pour le naive bayes

IRIS Autres classificateurs Nous allons maintenant utiliser drsquoautres algorithmes

Il vous suffit de prendre ces autres algorithmes




clf =OneVsOneClassifier(LinearSVC(random_state=0))


clf =GaussianNB()

correction

IRIS Autres classificateurs import numpy as np




data = irisdata

datashape

print(irisfeature_names )

target = iristarget

print( iristarget_names )





pltshow()

from sklearnnaive_bayes import

GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))

print (clfget_params())


print (clfpredict(data))

from sklearnmetrics import

accuracy_score

print(accuracy_score(result target))

correction

avec knn


clf2 =

neighborsKNeighborsClassifier()

Apprentissage

clf2fit(data target)

print(dir(clf2))

print (clf2get_params())

result2 = clf2predict(data)

print (clf2predict(data))

print(accuracy_score(result2

target))

avec svm


from sklearnmulticlass import

OneVsOneClassifier

clf3 =

OneVsOneClassifier(LinearSVC(ran

dom_state=0))





target))

on va dessiner cela

We use only the 2 first features

data = irisdata[ 2]

target = iristarget

h = 02

step size in the mesh

we create an instance of Neighbours

Classifier and fit the data


clf

=OneVsOneClassifier(LinearSVC(random_stat

e=0))

clf =GaussianNB()

clffit(data target)

Plot the decision boundary For that we will

asign a color to each

point in the mesh [x_min m_max]x[y_min

y_max]

x_min x_max = data[ 0]min() - 1 data[

0]max() + 1

y_min y_max = data[ 1]min() - 1 data[

1]max() + 1

xx yy = npmeshgrid(nparange(x_min x_max

h) nparange(y_min y_max h))


Put the result into a color plot



pltclf()

pltpcolor(xx yy Z)





pltshow()

IRIS Autres classificateurs correction

IRIS Autres classificateurs

Retrouvez quel sont les diffeacuterents classificateurs ici

IRIS reacuteduction de dimensionaliteacute Nous allons maintenant appliquer un algorithme de reacuteduction de dimensionaliteacute

Reprendre vos donneacutees iris de deacutepart et appliquer lrsquoalgorithme PCA pour ne garder

que deux dimensions puis lrsquoappliquer agrave nos donneacutees et le dessiner sur un sheacutema

On va donc importer le module depuis sklearndecomposition qui srsquoappelle PCA

Dire que lrsquoon a deux dimensions avec n_components de PCA

IRIS reacuteduction de dimensionaliteacute Nous allons maintenant utiliser un algorithme de reacuteduction de dimensionaliteacute


clf = PCA(n_components=2)

correction


On va appliquer ce modegravele PCA agrave nos donneacutees IRIS

Le faire fitter avec fit

Et donner les nouvelles dimensions avec reduc

httpsscikit-learnorgstablemodulesgeneratedsklearndecompositionPCAhtml



clffit(irisdata) fit aux donneacutees

reduc = clftransform(irisdata )

correction


Nous allons visualiser cette classification sur un sheacutema agrave deux dimensions avec

matplotlib pyplot

En utilisaant figure scatter et show



pltscatter(reduc[ 0] reduc[ 1] c=target)

plttitle(avec pca)

pltshow()

correction


correction

IRIS clustering Nous allons maintenant appliquer un algorithme de clustering

Nous allons reprendre nos donneacutees et leur appliquer lrsquoalgorithme de clustering

gaussian mixture

httpsscikit-

learnorgstablemodulesgeneratedsklearnmixtureGaussianMixturehtml


Avec

n_components=3

et une covariance_type=full

IRIS clustering Nous allons maintenant utiliser un algorithme de clustering


Creacuteation du modegravele avec 3 groupes de

donneacutees

clf = GaussianMixture (n_components=3

covariance_type=full)

correction


Reprendre les scheacutemas preacuteceacutedents avec les donneacutees data

Mais aussi avec les donneacutees reduites (issues de PCA)


clffit(reduc target)

Plot the decision boundary For that we will asign a color to each

point in the mesh [x_min m_max]x[y_min y_max]

x_min x_max = reduc[ 0]min() - 1 reduc[ 0]max() + 1

y_min y_max = reduc[ 1]min() - 1 reduc[ 1]max() + 1

xx yy = npmeshgrid(nparange(x_min x_max h) nparange(y_min y_max h))





pltclf()

pltpcolor(xx yy Z)





plttitle(avec le clustering)

pltshow()

correction


correction

Avec les data initiales

Avec les data reacuteduites

IRIS decision tree Un petit dernier algo pour la fin

On va tenter les arbres de deacutecision decision tree en anglais

Je vous donne directement le code agrave injecter et agrave vous de le faire tourner

from sklearntree import DecisionTreeClassifier

params = random_state 0 max_depth 4

clf = DecisionTreeClassifier(params)

IRIS decision tree Nous allons maintenant utiliser les arbres de deacutecision decision trees

import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)





plttitle(random forest)

pltshow()

correction

IRIS decision tree Nous allons maintenant utiliser un algorithme drsquoarbre de deacutecision

correction

IRIS big picture Retrouver sur le scheacutema ci-dessous ce que lrsquoon a fait et pourquoi

Pour aller plus loin Il est important de disposer de ressources pour sessayer au machine learning

Le site Kaggle propose de nombreuses ressources (jeux de donneacutees et exemples) sur le

machine learning

Il propose aussi des compeacutetions ou les membres peuvent comparer leurs algorithmes

Beaucoup de sites proposent des jeux de donneacutees

Open data du gouvernement franccedilais

Enigmaio

Une recherche Internet sur Open data vous donnera beaucoup de ressources

Conclusion

Nous voilagrave initieacutes au Machine Learning avec Scikit-Learn La librairie propose de

nombreux exemples et jeux de donneacutees Elle est extrecircmement riche et simple

Les difficulteacutes de cette discipline consistent agrave

comprendre les notions matheacutematiques derriegravere chaque algorithme pour avoir une

ideacutee de leurs limites

choisir les hyperparamegravetres

bien dimensionner ses jeux de donneacutees dapprentissage

Ensuite quelque soit votre algorithme cest tregraves simple

On instancie la classe et ses hyper-paramegravetres

On fournit les donneacutees dapprentissage agrave la meacutethode fit (si superviseacute)

On demande la deacutetermination des donneacutees avec la meacutethode predict

DIABETE Peacutedagogie

Lrsquoideacutee est de prendre un cas reacuteel drsquoanalyse de diabete et drsquo appliquer une regression lineacuteaire en

separant jeu de test et jeu drsquoentrainement


bull De se deacutebrouiller au maximum toute seule en appliquant ce qui a eacuteteacute vu sur un cas simple


bull Reacutegression lineaire

bull Drsquoappliquer la meacutethode

bull Seacuteparation du jeu de test et du jeu drsquoentrainement

bull Drsquoeacutevaluer notre algorithme


-Fait tourner sur un cas reacuteel un algorithme de regression lineacuteaire de sklearn en python


-Appliqueacute la meacutethode de seacuteparation de jeu de test et jeu drsquoentrainement

- Eacutevalueacute notre algorithme

- Travailleacute sur un cas reacuteel et appris sur al maladie du diabegravete (si vous ecirctes inteacuteresseacutes voir

Eric-Marsaudon-Diabete-defi-medical-du-21eme-siecle )

Diabete Exercice

Le but de cet exercice est drsquoappliquer la meacutethode de reacutegression lineacuteaire aux cas de

diabegravetes en reprenant totalement la meacutethode avec jeu de tests et jeu drsquoentrainement

et calcul de performance

Il nous faut prendre les donneacutees de diabetes dans sklearn


diabetes = datasetsload_diabetes()

httpsscikit-learnorgstableauto_exampleslinear_modelplot_olshtml


Regression lineacuteaire diabegravetes


import numpy as np

from sklearn import datasets linear_model

from sklearnmetrics import mean_squared_error r2_score

Load the diabetes dataset


Use only one feature

diabetes_X = diabetesdata[ npnewaxis 2]

print (dir(diabetes))

print (diabetesfeature_names)

print (diabetesDESCR)

print (diabetestarget)


correction


Split the data into trainingtesting sets

diabetes_X_train = diabetes_X[-20]

diabetes_X_test = diabetes_X[-20]

Split the targets into trainingtesting sets

diabetes_y_train = diabetestarget[-20]

diabetes_y_test = diabetestarget[-20]

Create linear regression object

regr = linear_modelLinearRegression()

Train the model using the training sets

regrfit(diabetes_X_train diabetes_y_train)

Make predictions using the testing set

diabetes_y_pred = regrpredict(diabetes_X_test)


correction


The coefficients

print(Coefficients n regrcoef_)

The mean squared error

print(Mean squared error 2f

mean_squared_error(diabetes_y_test diabetes_y_pred))

Explained variance score 1 is perfect prediction

print(Variance score 2f r2_score(diabetes_y_test diabetes_y_pred))

Plot outputs

pltscatter(diabetes_X_test diabetes_y_test color=black)

pltplot(diabetes_X_test diabetes_y_pred color=blue linewidth=3)

pltxticks(())

pltyticks(())

pltshow()


correction

Regression lineacuteaire diabegravetes httpsscikit-learnorgstableauto_exampleslinear_modelplot_olshtml

correction


correction

EXERCICE ISSUS DU LIVRE Prateek Joshi

Artificial intelligence with Python

Artificial Intelligence with Python Peacutedagogie

Lrsquoideacutee est de ces exercices est de lsquofaire le tourrsquo de ce qui existe en machine leanring en terme

drsquoalgorithmesainsi que de meacutethode de travail Les exercices sont tous issus du livre de Prateek

Joshi Artificial intelligence with Python bookpdf et couvrent lrsquoensemble des chapitres 1 agrave 5

Le but de ces exercice est

bull Drsquoavoir au moins vu une fois les algorithmes les plus reacutepandus en terme de machine learning

bull Regressions logistique linaires polynomiales maive bayes svm decision trees et random

forest (arbres de deacutecisions et forecircts aleacuteatoires)KNN gridsearchCV adaboost ainsi que des

algorithmes de clustering Kmeans meanshift silhouette score GMM gaussian Mixture enfin

des algorithmes de recommandation avec le filtrage collaboratif

bull De pouvoir srsquoentrainer soi-mecircme en python

bull Mais aussi de beacuteneacuteficier drsquoexemples qui fonctionnent (les py sont donneacutes en annexe)

bull De mieux comprendre les meacutethodes drsquoanalyses de donneacutees preprocessing encodage et

deacutecodage validation croiseacutee scoring confusion matrix variance pertes calssification report

courbe de dimensionaliteacute hellip

A la fin de ces exercices on aura

- Brosseacute lrsquoensemble des meacutethodes de machine learning

- Acquis des connaissances de base des datascientits sur le travail et lrsquoanayse des donneacutees

exercices

Tous ces exercices neacutecessitent drsquoutiliser les librairies suivantes de Python

NumPy httpdocsscipyorgdocnumpy-1101userinstallhtml

SciPy httpwwwscipyorginstallhtml

scikit-learn httpscikit-learnorgstableinstallhtml

matplotlib httpmatplotliborg142usersinstallinghtml

EXERCICE 1 PREPROCESSING

Exercice1 preprocessing travailler les donneacutees

(normalisation etc) Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

Le but de cet exercice est de travailler sur les

donneacutees en les reformattant avant de les utiliser

dans des algorithmesOn va utiliser les meacutethodes

de de sklearn qui sont dans preprocessing

httpsscikit-

learnorgstablemodulesgeneratedsklearnpreproc

essinghtml

Exercice1 binarisation [73 -99 -45]])

On va utiliser la meacutethode de binarisation de sklearn qui est dans preporcessing

httpsscikit-learnorgstablemodulesgeneratedsklearnpreprocessingbinarizehtml preprocessingBinarizer() Et la transformation transform(X[ y copy]) qui va binariser chaque eacuteleacutement de X

Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

Le but de lrsquoexercice est de binariser de lrsquoinformation lrsquoinformation sera transformeacutee en booleacuteen

par exemple pour du traitement drsquoimage en transformation des pixels en pixel noir et pixel blanc seulement

Voici les donneacutees agrave binariser

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Et voici ce que lrsquoon veut obtenir

Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]

Exercice1 binarisation Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

correction

import numpy as np

from sklearn import preprocessing

input_data = nparray([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =

preprocessingBinarizer()transform(input_data)

print(nBinarized datan data_binarized)

Exercice1 calcul de moyenne et de lrsquoeacutecart-type

Calculer la moyenne et lrsquoeacutecart type

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Et voici ce que lrsquoon veut obtenir la moyenne et lrsquoeacutecart type pour chaque colonne

Moyenne Mean = [ 3775 -115 -13 ]

Lrsquoeacutecart-type est donneacute par la laquo standard deviation raquo

Std deviation = [ 312039661 636651396 40620192 ]

On va utiliser les meacutethodes mean et std de sklearn qui sont dans preprocessing

httpsscikit-learnorgstablemodulespreprocessinghtml

mean

Std

Pour la moyenne mean on indiquera quel axe prendre axis = 0 ou 1

Exercice1 moyenne et ecart-type Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Print mean and standard deviation

print(nBEFORE)

print(Mean = input_datamean(axis=0))

print(Std deviation = input_datastd(axis=0))

Exercice1 mean removal centrage des donneacutees

On va vouloir maintenant transformer nos donneacutees pour obtenir une moyenne agrave 000 et un eacutecart type agrave 1

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 0 0 0]

Ecart-type standard deviation

Std deviation = [ 1 1 1 ]

On va utiliser la meacutethode scale de sklearn qui est dans preprocessing

httpsscikit-learnorgstablemodulesgeneratedsklearnpreprocessingscalehtml

Exercice1 centrage des donneacutees Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

on centre les donneacutees

data_scaled = preprocessingscale(input_data)

on reacuteimprime moyenne et eacutecart-types

print(Mean = data_scaledmean(axis=0))

print(Std deviation = data_scaledstd(axis=0))

Exercice1 mise agrave lrsquoeacutechelle

On va vouloir maintenant transformer nos donneacutees pour obtenir une eacutecart maximal de 1

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]

[ 1 0 017021277]] On va utiliser les meacutethodes MinMaxScaler et fit_transform de sklearn qui est dans

preprocessing httpsscikit-

learnorgstablemodulesgeneratedsklearnpreprocessingMinMaxScalerhtml

Exercice1 mise agrave lrsquoeacutechelle Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

mise agrave lrsquoeacutechelle data_scaler_minmax =

preprocessingMinMaxScaler(feature_range=(0 1))

data_scaled_minmax =

data_scaler_minmaxfit_transform(input_data)

print(nMin max scaled datan data_scaled_minmax)

Exercice 1 Normalisation L1

On va vouloir maintenant normaliser nos donneacutees

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]

On va utiliser la meacutethode normalize de sklearn avec la norm lsquol1rsquo qui est dans


learnorgstablemodulesgeneratedsklearnpreprocessingnormalizehtml

Exercice1 normalisation L1 Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p32

correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1

datadata_normalized_l1 =

preprocessingnormalize(input_data norm=l1)

print(nL1 normalized datan

data_normalized_l1)

Exercice1 Normalisation L2

On va vouloir maintenant normaliser nos donneacutees en

([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]

On va utiliser la meacutethode de normalize de sklearn avec la norm lsquol2rsquo qui est dans




correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2

data_normalized_l2 =



data_normalized_l2)

Annexe diffeacuterences L1 et L2

httpwwwchiokaindifferences-between-the-l1-norm-and-the-l2-norm-least-absolute-

deviations-and-least-squares

La ligne verte correspond agrave une normalisation L2 et est le chemin le plus

court unique alors que les lignes rouges jaunes ou bleues (normalisaiton

L1) sont toutes de la mecircme longueur (=12) pour aller el plus vite drsquoen bas agrave

gauche vers haut agrave droite On peut geacuteneacuteraliser cela agrave n dimensions L1 a

plusieurs solutions

Exercice1 solution import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized = preprocessingBinarizer(threshold=21)transform(input_data)



print(nBEFORE)



Remove mean

data_scaled = preprocessingscale(input_data)print(nAFTER)



Min max scaling

data_scaler_minmax = preprocessingMinMaxScaler(feature_range=(0 1))

data_scaled_minmax = data_scaler_minmaxfit_transform(input_data)


Normalize

datadata_normalized_l1 = preprocessingnormalize(input_data norm=l1)

data_normalized_l2 = preprocessingnormalize(input_data norm=l2)

print(nL1 normalized datan data_normalized_l1)


EXERCICE 2 ENCODER LES DONNEES

Exercice2 encoder des donneacutees Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p36

Voici des donneacutees

[red black red green black yellow white]

Voici ce que lrsquoon veut obtenir

Tester aussi avec [green red black] comme donneacutees drsquoentreacutee qursquoobient-on

On va utiliser la meacutethode LabelEncoder fit et transform de sklearn qui est dans


learnorgstablemodulesgeneratedsklearnpreprocessingLabelEncoderhtml

Exercice2 encodage Data preprocessing Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p36

correction

import numpy as np


creacuteation de nos donneacutees

input_labels = [red black red green black yellow white]

creacuteation de lrsquoencoder et laquo fittage raquo des donneacutees

encoder = preprocessingLabelEncoder()

encoderfit(input_labels)

Print the mapping

print(nLabel mapping)

for i item in enumerate(encoderclasses_)

print(item --gt i)

testons avec un nouveau jeu de donneacutees

test_labels = [green red black]

encoded_values = encodertransform(test_labels)

print(nLabels = test_labels)

print(Encoded values = list(encoded_values))

Exercice2 deacutecoder des donneacutees Data labelling Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p36


[3 0 4 1]


On va utiliser la meacutethode LabelEncoder et inverse_transform de sklearn qui est dans



Exercice2 solution Data labelling Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p36

import numpy as np


Sample input labels


Create label encoder and fit the labels



Print the mapping



print(item --gt i)

Encode a set of labels using the encoder





Decode a set of values using the encoder

encoded_values = [3 0 4 1]

decoded_list = encoderinverse_transform(encoded_values)

print(nEncoded values = encoded_values)

print(Decoded labels = list(decoded_list))

correction

EXERCICE 3 REGRESSION LOGISTIQUE

Exercice3 regression logistique Data logistic regressionPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p37

Voici des donneacutees ([[31 72] [4 67]

[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])

Et les labels leur correspondant ([0 0

0 1 1 1 2 2 2 3 3 3])

On veut classifier ces donneacutees en

utilisant la regression logistique

On va utiliser la meacutethode LogisticRegression et fit (pour entrainer le classificateur) de

LinearModel de sklearn

httpsscikit-

learnorgstablemodulesgeneratedsklearnlinear_modelLogisticRegressionhtml

et liblinear comme solver LIBLINEAR ndash A Library for Large Linear Classification

httpwwwcsientuedutw~cjlinliblinear (LIBLINEAR implements linear SVMs and logistic regression models

trained using a coordinate descent algorithm)

Et 1- 100 ou 900 comme donneacutee pour C C est un reacuteel par deacutefaut 1 plus il est petit plus la regularisation est

lsquofortersquo



On va deacutefinir un module que lrsquoon eacutecrit pour toutes nos visualisations future afin de

pouvoir eacutecrire ensuite (voir slide suivant)

from utilities import visualize_classifier

machine learning

bullREGRESSION LOGISTIQUE

regression logistique httpsopenclassroomscomfrcourses4444646-entrainez-un-modele-predictif-lineaire4507831-predisez-lineairement-la-

probabilite-de-l-appartenance-d-un-point-a-une-classe

reacutesoudre Devient donc

Et maximiser le maximum de vraisemblance revient agrave



Et en remplaccedilant par sa valeur ceci revient agrave maximiser

Qui est une fonction concave donc on pourra lui appliquer la meacutethode du gradient

pour la reacutesoudre (la suite pour ceux qui veulent ici

httpswwwdiensfrappstatnotescours2-regressionpdf )



La reacutegression logistique est largement reacutepandue dans de nombreux domaines

On peut citer de faccedilon non exhaustive

En meacutedecine elle permet par exemple de trouver les facteurs qui caracteacuterisent

un groupe de sujets malades par rapport agrave des sujets sains

Dans le domaine des assurances elle permet de cibler une fraction de la

clientegravele qui sera sensible agrave une police drsquoassurance sur tel ou tel risque

particulier

Dans le domaine bancaire pour deacutetecter les groupes agrave risque lors de la

souscription drsquoun creacutedit

En eacuteconomeacutetrie pour expliquer une variable discregravete Par exemple les

intentions de vote aux eacutelections

Par exemple Vincent Loonis utilise un modegravele de reacutegression logistique pour

eacutetudier les deacuteterminants de la reacuteeacutelection des deacuteputeacutes franccedilais depuis les

deacutebuts de la IIIe Reacutepublique4

httpsfrwikipediaorgwikiRC3A9gression_logistique

Exercice3 regression logistique Data regression logistique Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p37

Avec C=900

Exercice3 utilities Data regression logistique Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p37

import numpy as np


def visualize_classifier(classifier X y)

Define the minimum and maximum values for X and Y

that will be used in the mesh grid

min_x max_x = X[ 0]min() - 10 X[ 0]max() + 10

min_y max_y = X[ 1]min() - 10 X[ 1]max() + 10

Define the step size to use in plotting the mesh grid

mesh_step_size = 001

Define the mesh grid of X and Y values

x_vals y_vals = npmeshgrid(nparange(min_x max_x mesh_step_size) nparange(min_y max_y

mesh_step_size))

Run the classifier on the mesh grid

output = classifierpredict(npc_[x_valsravel() y_valsravel()])

Reshape the output array

output = outputreshape(x_valsshape)

Create a plot

pltfigure()

Choose a color scheme for the plot

pltpcolormesh(x_vals y_vals output cmap=pltcmgray)

Overlay the training points on the plot

pltscatter(X[ 0] X[ 1] c=y s=75 edgecolors=black linewidth=1 cmap=pltcmPaired)

Specify the boundaries of the plot

pltxlim(x_valsmin() x_valsmax())

pltylim(y_valsmin() y_valsmax())

Specify the ticks on the X and Y axes

pltxticks((nparange(int(X[ 0]min() - 1) int(X[ 0]max() + 1) 10)))

pltyticks((nparange(int(X[ 1]min() - 1) int(X[ 1]max() + 1) 10)))

pltshow()

Exercice3 solution Data regression logistiquePrateek Joshi Artificial intelligence with Python bookpdf Chapter 2

p37

import numpy as np




on deacutefinit les donneacutees drsquoentreacutee

X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])

on creacutee le classifier en utilisant la reacutegression logistique

classifier = linear_modelLogisticRegression(solver=liblinear C=1)


on entraine le classificateur

classifierfit(X y)

on le visualise

visualize_classifier(classifier X y)

EXERCICE 4 NAIVES BAYES

Exercice4 Naive Bayes Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

Creacuteer un nouveau fichier et importer les packages suivants

numpy que lrsquoon appelera np

matplotlibpyplot que lrsquoon nomera plt

On veut utiliser la classification Naive Bayes avec une reacutepartition gaussienne

Depuis sklearnNaiumlve_bayes importer GaussianNB

Nous calculerons la cross validation (voir explications page suivante)

depuis sklearnmodel_selection importer cross_val_score

et pour visualiser


Nous prendrons comme donneacutees data_multivar_nbtxt

Qursquoest-ce que ce fichier Que contient-il

Nous allons ensuite prendre ces donneacutees dans une lsquodatarsquo avec un deacutelimiteur qui est un virgule

data = nploadtxt(input_file delimiter=)

Regarder ces donneacutees on voit que la derniegravere colonne est 01 2 ou 3 ce sont les labels

Creacuteer les donneacutees X et la derniegravere colonne sont les labels y

X y = data[ -1] data[ -1]

Creacuteer une instance du classificateur Naiumlve Bayes entrainez-le (fit) et regarder le reacutesultat gracircce agrave from utilities import visualize_classifier


import numpy as np



from sklearn import model_selection


prenons les donneacutees en entreacutee

input_file = data_multivar_nbtxtlsquo

et chargeons les en data evac un delimiteur qui est une virgule



creacuteons une instance de clssificateur Gaussian NB

classifier = GaussianNB()

entrainons le classifier

classifierfit(X y)

et visualisons le


Exercice4 Naive Bayes exercice Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

Exercice4 Naive Bayes Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2

p41

Nous allons maintenant nous inteacuteresser agrave la

performance de lrsquoagorithme

Tout drsquoabord nous allons preacutedire les donneacutees y

selon les entreacutees X et notre classificateur gracircce agrave

predict

Ensuite nous voulons savoir si notre algorithme est

performant

On va donc calculer le nombre de y preacutedit aux

vraies valeurs de y par rapport au total de

preacutedictions

Exercice4 Naive Bayes correction Data naive bayes Prateek Joshi Artificial intelligence with Python

bookpdf Chapter 2 p41

preacutedire les valeurs de y selon le classificateur

y_pred = classifierpredict(X)

calculer la preacutecision (accuracy) les valeurs preacutedites de

y sont les bonnes pr aux donneacutees de deacutepart de y

accuracy = 1000 (y == y_pred)sum() Xshape[0]

print(Accuracy of Naive Bayes classifier =

round(accuracy 2) )

visualiser la classification gracircce agrave la fonciton

visulize_classifier


machine learning

bullCROSS VALIDATION

validation croiseacutee httpsfrwikipediaorgwikiValidation_croisC3A9e

Supposons posseacuteder un modegravele statistique avec un ou plusieurs paramegravetres inconnus et un ensemble de donneacutees dapprentissage sur lequel on peut entraicircner le modegravele Le processus dapprentissage optimise les paramegravetres du modegravele afin que celui-ci corresponde aux donneacutees le mieux possible Si on prend ensuite un eacutechantillon de validation indeacutependant issu de la mecircme population dentraicircnement il saveacuterera en geacuteneacuteral que le modegravele ne reacuteagit pas aussi bien agrave la validation que durant lentraicircnement on parle parfois de surapprentissage La validation croiseacutee est un moyen de preacutedire lefficaciteacute dun modegravele sur un ensemble de validation hypotheacutetique lorsquun ensemble de validation indeacutependant et explicite nest pas disponible

bullTechniques de validation croiseacutee

bullIl existe au moins trois variantes

bulllaquo testset validation raquo ou laquo holdout method raquo on divise leacutechantillon de taille n displaystyle n en deux sous-eacutechantillons le premier dit dapprentissage (communeacutement supeacuterieur agrave 60 de leacutechantillon) et le second dit de test Le modegravele est bacircti sur leacutechantillon dapprentissage et valideacute sur leacutechantillon de test Lerreur est estimeacutee en calculant un test une mesure ou un score de performance du modegravele sur leacutechantillon de test par exemple lerreur quadratique moyenne

bulllaquo k-fold cross-validation raquo on divise leacutechantillon original en k displaystyle k eacutechantillons puis on seacutelectionne un des k displaystyle k eacutechantillons comme ensemble de validation et les k minus 1 displaystyle k-1 autres eacutechantillons constitueront lensemble dapprentissage On calcule comme dans la premiegravere meacutethode le score de performance puis on reacutepegravete lopeacuteration en seacutelectionnant un autre eacutechantillon de validation parmi les k minus 1 displaystyle k-1 eacutechantillons qui nont pas encore eacuteteacute utiliseacutes pour la validation du modegravele Lopeacuteration se reacutepegravete ainsi k displaystyle k fois pour quen fin de compte chaque sous-eacutechantillon ait eacuteteacute utiliseacute exactement une fois comme ensemble de validation La moyenne des k displaystyle k erreurs quadratiques moyennes est enfin calculeacutee pour estimer lerreur de preacutediction

bulllaquo leave-one-out cross-validation raquo (LOOCV) cas particulier de la deuxiegraveme meacutethode ougrave k = n displaystyle k=n cest-agrave-dire que lon apprend sur n minus 1 displaystyle n-1 observations puis on valide le modegravele sur la eacuteniegraveme observation et lon reacutepegravete cette opeacuteration n displaystyle n fois2

validation croiseacutee

Exercice4 Naive Bayes cross validation Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

nous allons seacuteparer les donneacutees en donneacutees de test et donneacutees drsquoentrainement les donneacutees

drsquoentrainement repreacutesentent 80 des donneacutees de deacutepart on utilise crossval-score httpsscikit-

learnorgstablemodulescross_validationhtml

from sklearnmodel_selection import train_test_split

X_train X_test y_train y_test = train_test_split(X y test_size=02 random_state=3)

On va reacuteappliquer notre classificateur avec le nouveau jeu de donneacutees (drsquoentrainement)

classifier_new = GaussianNB()

classifier_newfit(X_train y_train)

y_test_pred = classifier_newpredict(X_test)

calculons la preacutecision

accuracy = 1000 (y_test == y_test_pred)sum() X_testshape[0]

print(Accuracy of the new classifier = round(accuracy 2) )

regardons ce classificateur

visualize_classifier(classifier_new X_test y_test)


Le but maintenant est de seacuteparer les donneacutees en deux nous allons seacuteparer les donneacutees en

donneacutees de test et donneacutees drsquoentrainement les donneacutees drsquoentrainement repreacutesentent 80 des

donneacutees de deacutepart on utilise crossval-score httpsscikit-


depuis sklearnmodel_selection on va importer train_test_split

On va donc avoir nos jeux drsquoentreacutee en 4 parties pour ce modegravele

les donneacutees X drsquoentrainement

les donneacutees X de test

les donneacutees y drsquoentrainement

les donneacutees y de test

X_train X_test y_train y_test

Qui seront donneacutees par tran_test_split appliqueacute sur

X y avec une taille de 20 pour le jeu de test

On va reacuteappliquer notre classificateur avec le nouveau jeu de donneacutees (drsquoentrainement) X_train et

y_train puis predire les reacutesultats y coorespondant aux donneacutees X_test

Exercice4 Naive Bayes cross validation Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter

2 p41

Cross validation

on seacutepare les donneacutees en test et entrainement

X_train X_test y_train y_test = model_selectiontrain_test_split(X y

test_size=02)


test_size=02)




on calcule lrsquoaccuracy



on visualise



Exercice4 Naive Bayes scoring Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

nous allons calculer lrsquoaccuracy la precision le recall et le F1

Lrsquoaccuracy est le nombre de bonnes preacutedictions par rapport au nombre de preacutedictions totales

On prendra un nombre de fold de cross validation cv = num_folds = 3

Et on utilisera model_selectioncross_val_score appliqueacutee au classifier agrave X agrave y et avec un

scoring=accuracy puis lsquoprecicion_weightedrsquo puis lsquorecall_weightedrsquo puis lsquof1_weightedrsquo

Precision

La preacutecision regarde les eacuteleacutements drsquoune classe A en vrai parmis tous les deacutetecteacutes de cette classe A Quand il y a bcp de cas deacutetecteacutes dans cette classe A qui ne le sont pas cette preacutecision est une bonne mesure par exemple les spams si un non-spam est rangeacute dans les spams on ne le lira pas crsquoest embetant car cela peutecirctre un mail important

Recall

Recall calcule les vrais drsquoune classe A et deacutetecteacutes comme tels sur lrsquoensemble de la classe A en vrai

Quand le cout des faux neacutegatifs (donc de ceux qui sont preacutedits drsquoune autre classe B mais en fait sont de la classe A) est eacuteleveacute cet indicateur est le bon par exemple dans le cas de deacutetection de maladies ou de transactions frauduleuses

F1 Score

Le score F1 est neacutecessaire quand on cherche un eacutequilibre entre preacutecision et recall

Par rapport agrave lrsquoaccuracy cet indicateur permet de se focaliser sur les deacutetections qui ont mis dans la mauvaise case et qui ont geacuteneacuteralement un cout eacuteleveacute



num_folds = 3

accuracy_values = cross_val_score(classifierX y scoring=accuracy cv=num_folds)

print(Accuracy + str(round(100accuracy_valuesmean() 2)) + )

precision_values = cross_val_score(classifierX y scoring=precision_weighted cv=num_folds)

print(Precision + str(round(100precision_valuesmean() 2)) + )

recall_values = cross_val_score(classifier X y scoring=recall_weighted cv=num_folds)

print(Recall + str(round(100recall_valuesmean() 2)) + )

f1_values = cross_val_score(classifier X y scoring=f1_weighted cv=num_folds)

print(F1 + str(round(100f1_valuesmean() 2)) + )

machine learning

bullSCORING

Annexe scoring httpstowardsdatasciencecomaccuracy-precision-recall-or-f1-331fb37c5cb9


Regardons la matrice de confusion

Quelle est lrsquoaccuracy avec ce modegravele de preacutediction

Le nombre de preacutedictions bonnes 998 (preacutedites neacutegatives et vraiment neacutegatives) + le nombre de preacutediction bonnes 1 (preacutedites positives et vraiment positives) soit 9991000 = 999 (1000 est le nombre de cas totaux)

Imaginons maintenant que les positifs soient qq porteurs de virus tregraves dangeureux et deacutepisteacute positif du coup le faux neacutegatif qq deacutepisteacute (preacutedit) neacutegatif alors qursquoil est positif est un cas dangereux

On va donc essayer drsquoavoir drsquoautres calculs pour dire si notre podegravele est bon

Precision et Recall

Precision and Recall



Precision

True Positive + False Positive = Total Predicted Positive

La preacutecision regarde les positifs en vrai parmis tous les deacutetecteacutes positifs Quand il y abcp de cas deacutetecteacutes positifs qui ne le sont pas cette preacutecision est une bonne mesure par exemple les spams si un non-spam est rangeacute dans les spams on ne le lira pas crsquoest embetant car cela peutecirctre un mail important


Recall

Recall calcule les vrais positifs et deacutetecteacutes comme tels sur lrsquoensemble des positifs en vrais

Quand le cout des faux neacutegatifs (donc de ceux qui sont preacutedits neacutegatifs mais en fait sont positifs) est eacuteleveacute cet indicateur est le bon par exemple dans le cas de deacutetection de maladies ou de transactions frauduleuses


F1 Score

Wikipedia



Exercice4 Naive Bayes correction Data naive bayes Prateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

import numpy as np



from sklearnmodel_selection import cross_val_score



input_file = data_multivar_nbtxtprint(input_file)

Load data from input file



print(XestX[5])

print(y esty[5])

print(y)

Create Naive Bayes classifier classifier = GaussianNB()

Train the classifier

classifierfit(X y)

Predict the values for training data


Compute accuracy


print(Accuracy of Naive Bayes classifier = round(accuracy 2) )

Visualize the performance of the classifier


Exercice4 Naive Bayes correction Data naive bayesPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p41

Cross validation Split data into training and test data






compute accuracy of the classifier





Scoring functions

num_folds = 3









EXERCICE 5 CONFUSION MATRIX

Exercice5 Confusion matrix Data confusion matrixPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p46

voici des donneacutees faire agrave la main la matrice de confusion et calculer la precision le recall et le

score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np



from sklearnmetrics import classification_report

Define sample labels

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]

Create confusion matrix

confusion_mat = confusion_matrix(true_labels pred_labels)

Visualize confusion matrix

pltimshow(confusion_mat interpolation=nearest cmap=pltcmgray)

plttitle(Confusion matrix)

pltcolorbar()ticks = nparange(5)

pltxticks(ticks ticks)

pltyticks(ticks ticks)

pltylabel(True labels)

pltxlabel(Predicted labels)

pltshow()

Classification report

targets = [Class-0 Class-1 Class-2 Class-3 Class-4]

print(n classification_report(true_labels pred_labels target_names=targets))

EXERCICE 6 SVM

Exercice6 SVM - income Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p49

Le but de cet exercice est de deacuteterminer un salaire agrave partir de donneacutees (chaque donneacutee a 14

variables) Nous allons utiliser un nouvel algorithme SVM support vector Machine

Les donneacutees sont dans le fichier income_datatxt

Il faut drsquoabord convertir les donneacutees car il y a des meacutelanges de numeacuterique et de texte

On va importer les bibliothegraveques suivantes

numpy que lrsquoon nomera np


Et depuis sklearn on importera preprocessing

Et depuis sklearnsvm on importera LinearSVC on verra plus loin ce qursquoest svm ici une

classification lineacuteaire LinearSVC

Et depuis sklearnmulticlass on importera OneVsOneClassifier qui est une faccedilon de choisir le

meilleur calssificateur en faisant du

Et depuis sklearnmodel_selection on importera train_test_split

Et depuis sklearnmodel_selection on importera cross_val_score

Puis on importera le fichier de donneacutees

input_file qui sera income_datatxtlsquo

Pour chaque donneacutees 25000 points au maximum on doit tout reprocesser et seacuteparer en

deux classes class1 et class2 qui sont les classes correspondant agrave mois de 50kUSD annuel

de salaire et agrave plus

Exercice6 SVM- income Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p49


import numpy as np







on importe le fichier de donneacutees des salaires

input_file = income_datatxtlsquo

Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0

max_datapoints = 25000


Regarder les donneacutees de salaire

Cela ressemble agrave

39 State-gov 77516 Bachelors 13 Never-married Adm-clerical Not-in-family White Male

2174 0 40 United-States lt=50K

Qursquoest-ce que vous voyez comme donneacutee

Nous allons creacuteer deux classes combien de personnes avec un salaire en dessous de 50kUSD

Combien au-dessus

on va lire le fichier (avec with open(input_file r) as f et freadlines() ) et populer peu agrave peu X

avec deux classes de salaires au-dessus ou en-dessous de 50K (USD) cette donneacutee est dans

la ligne[-1]

Il faut transformer tout ceci en array python X et y qui seront les labels + ou moins de 50kUSD

par an de salaire


on va lire le fichier et positionner dans deux classes de salaires au-dessus ou en-dessous de 50K

(USD)

with open(input_file r) as f

for line in freadlines()

if count_class1 gt= max_datapoints and count_class2 gt= max_datapoints

break

if in line

continue

data = line[-1]split( )

if data[-1] == lt=50K and count_class1 lt max_datapoints

Xappend(data)

count_class1 += 1

if data[-1] == gt50K and count_class2 lt max_datapoints

Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)


Il nous faut convertir les donneacutees chaines de caractegraveres en numeacuterique on va

creacuteer un

label_encoders qui sera vide [] et un X_encoded qui sera un tableau vide de la

taille de X npempty(Xshape)

Si la donneacutee est un chiffre pas de soucis sinon on va les encoder avec

preprocessingLabelEncoder() et fit_transform

Maintenant on peut choisir le classifier ce sera le SVM linearSVC httpsscikit-

learnorgstablemodulesgeneratedsklearnsvmLinearSVChtml

classifier = OneVsOneClassifier(LinearSVC(random_state=0))

Et entrainer le classificateur sur nos donneacutees X avec les labels y

classifierfit(X y)


Et convertir les donneacutees chaines de caractegraveres en numeacuterique

label_encoders = []

X_encoded = npempty(Xshape)

for i item in enumerate(X[0])

if itemisdigit()

X_encoded[ i] = X[ i]

else


X_encoded[ i] = encoderfit_transform(X[ i])

label_encodersappend(encoder)

X = X_encoded[ -1]astype(int)

y = X_encoded[ -1]astype(int)

print(X encodeacute estX)

print(y encodeacute esty)





classifierfit(X y)


On va maintenant effectuer une cross validation avec les donneacutees

drsquoentrainement qui font 80 des donneacutees et 20 pour les donneacutees de tests

X_train X_test y_train y_test seront determineacutes avec train_test_split

Sur les donneacutees drsquoentreacutee X les etiquettes y et une taille test_size de 20

Puis entrainer notre classificateur avec linear SVC


Ou directement LinearSVC

Puis on fera fitter le classificateur sur les donneacutees X_train et y_train

Et on lancera une prediction y_test_pred gracircce agrave predict sur les donneacutees de

test X_test

et on va calculer le score F1

Ensuite avec cross_val_score le classificateur sur X y avec le scoring

scoring=f1_weighted et le nombre de crossvalidation cv=3

Exercice6 SVM- income Data SVMPrateek Joshi Artificial intelligence with Python


On va maintenant effectuer une cross valifdation avec

les donneacutees drsquoentrainement qui font 80 des donneacutees

et 20 pour les donneacutees de tests

X_train X_test y_train y_test = train_test_split(X y

test_size=02 random_state=5)

classifier =

OneVsOneClassifier(LinearSVC(random_state=0))

classifierfit(X_train y_train)

y_test_pred = classifierpredict(X_test)


f1 = cross_val_score(classifier X y

scoring=f1_weighted cv=3)

print(F1 score + str(round(100f1mean() 2)) + )


maintenant calculons quel sera le salaire drsquoune personne donneacutee voici la donneacutee agrave entrer

Crsquoest un homme blanc de 37 ans vivant aux US qui nrsquoa jamais eacuteteacute marieacute et dont le meacutetier est

agent de propreteacute qui a termineacute le lyceacutee mais nrsquoa pas eacuteteacute au-delagrave

input_data = [37 Private 215646 HS-grad 9 Never-married Handlers-cleaners Not-in-

family White Male 0 0 40 United-States]

attention il faudra encoder ce point de donneacutees avec label_encoder et transform

input_data_encoded = [-1] len(input_data)

count = 0

for i item in enumerate(input_data)

if itemisdigit()

input_data_encoded[i] = int(input_data[i])

else

input_data_encoded[i] = int(label_encoder[count]transform(input_data[i]))

count += 1

input_data_encoded = nparray(input_data_encoded)

Et faire marcher le classificateur avec predict

predicted_class = classifierpredict(input_data_encoded)

print(label_encoder[-1]inverse_transform(predicted_class)[0])


quel sera le salaire drsquoune personne donneacutee voici la donneacutee agrave entrer

input_data = [37 Private 215646 HS-grad 9 Never-married Handlers-

cleaners Not-in-family White Male 0 0 40 United-States]

on va encoder ce point de donneacutees


count = 0


if itemisdigit()


else


count += 1


Et faire marcher le classificateur




machine learning

bullSVM

Annexe SVM httpcedriccnamfrvertigoCoursml2tpSVMLineaireshtml

Les machines agrave vecteurs de support (SVM Support Vector Machines) sont une classe de meacutethodes drsquoapprentissage statistique baseacutees sur le principe de la maximisation de la marge (seacuteparation des classes) Il existe plusieurs formulations (lineacuteaires versions agrave noyaux) qui peuvent srsquoappliquer sur des donneacutees seacuteparables (lineacuteairement) mais aussi sur des donneacutees non seacuteparables

Les avantages des SVM Tregraves efficaces en dimension eacuteleveacutee

Ils sont aussi efficaces dans le cas ougrave la dimension de lrsquoespace est plus grande que le nombre drsquoeacutechantillons drsquoapprentissage

Pour la deacutecision nrsquoutilisent pas tous les eacutechantillons drsquoapprentissage mais seulement une partie (les vecteurs de support) En conseacutequence ces algorithmes demandent moins de meacutemoire

Deacutesavantages Si le nombre drsquoattributs est beaucoup plus grand que le nombre drsquoeacutechantillons les performances sont moins bonnes

Comme il srsquoagit de meacutethodes de discrimination entre les classes elles ne fournissent pas drsquoestimations de probabiliteacutes

La ligne au milieu est la ligne de

seacuteparation les points sur les lignes en

pointilleacutes sont les support vectors

vecteurs de support on va travailler en

optimisant sur ces points vecteurs de

support

Annexe SVM

httpsopenclassroomscomfrcourses4444646-entrainez-un-modele-predictif-lineaire4507841-

maximisez-la-marge-de-separation-entre-vos-classes

Annexe SVM

EXERCICE 7 SVM IRIS

Exercice7 svm avec iris httpcedriccnamfrvertigoCoursml2tpSVMLineaireshtml

Le but de cet exercice est de reprendre la base des iris et de lui appliquer le

classificateur SVM

On importera numpy en tant que np

On va importer matplotlibpyplot en tant que plt

Et depuis sklearn on va importer svm et aussi les datasets (les iris)

datasetsload_iris()

On va comparer deux algorithmes linear SVC et SVC avec un noyau lineaire

On chargera notre base de X avec les deux premiers attributs et y les targets

Pour afficher la surface de deacutecision on va discreacutetiser lespace avec un pas h de 2mm

on va creacuteer la surface de deacutecision discretiseacutee

Puis donner agrave Z la prediction de chacun des points

on affichera aussi les points dapprentissage

pltscatter(X[ 0] X[ 1] c=y cmap=pltcmcoolwarm)

pltxlabel(Sepal length)

pltylabel(Sepal width)



pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()

httpcedriccnamfrvertigoCoursml2coursSVMLineai

reshtml


import numpy as np


from sklearn import svm datasets

Chargement des donneacutees


Garder juste les deux premiers attributs

X = irisdata[ 2]

y = iristarget

Pour afficher la surface de deacutecision on va discreacutetiser lespace avec un pas h

h = 02

C = 10 paramegravetre de reacutegularisation

svc = svmSVC(kernel=linear C=C)fit(X y)

lin_svc = svmLinearSVC(C=C)fit(X y)

Creacuteer la surface de deacutecision discretiseacutee

x_min x_max = X[ 0]min() - 1 X[ 0]max() + 1

y_min y_max = X[ 1]min() - 1 X[ 1]max() + 1



titles = [SVC with linear kernel LinearSVC (linear kernel)]

for i clf in enumerate((svc lin_svc))

pltsubplot(1 2 i + 1)

pltsubplots_adjust(wspace=04 hspace=04)


Utiliser une palette de couleurs


pltcontourf(xx yy Z cmap=pltcmcoolwarm alpha=08)

Afficher aussi les points dapprentissage






pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()

httpcedriccnamfrvertigoCoursml2cour

sSVMLineaireshtml



sSVMLineaireshtml

EXERCICE 8 REGRESSION LINEAIRE

Exercice8 regression lineacuteaire

Le but de lrsquoexercice est de faire une regression lineacuteaire on va importer les modules suivants

import pickle

import numpy as np


import sklearnmetrics as sm


on va chercher le fichier de donneacutees

input_file = data_singlevar_regrtxtlsquo

on va lire les donneacutees le premier champ est la donneacutee X et le dernier champ est le champ de labels y



on va prendre 80 des donneacutees pour les tests

num_training = int(08 len(X))

num_test = len(X) - num_training

on va dire quelles sont les donneacutees drsquoentrainement

X_train y_train = X[num_training] y[num_training]

et le reste des donneacutees est pour tester notre modegravele

X_test y_test = X[num_training] y[num_training]

on prend comme modegravele le modegravele de regression lineaire


et on fait fitter les donneacutees drsquoentrainement sur le modegravele de regression

regressorfit(X_train y_train)

on va voir si notre modegravele marche sur les donneacutees de test

y_test_pred = regressorpredict(X_test)

Data regressionPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p54


Plot outputs on va regarder sur un sheacutema les donneacutees

pltscatter(X_test y_test color=green)

pltplot(X_test y_test_pred color=black linewidth=4)

pltxticks(())

pltyticks(())

pltshow()

on va calculer les meacutetriques pour estimer si notre modegravele est bon

print(Linear regressor performance)

print(Mean absolute error = round(smmean_absolute_error(y_test y_test_pred) 2))

print(Mean squared error = round(smmean_squared_error(y_test y_test_pred) 2))

print(Median absolute error = round(smmedian_absolute_error(y_test y_test_pred) 2))

print(Explain variance score = round(smexplained_variance_score(y_test y_test_pred) 2))

print(R2 score = round(smr2_score(y_test y_test_pred) 2))

on va sauver notre modele en utilisant pickle

output_model_file = modelpkllsquo

on sauve le modegravele

with open(output_model_file wb) as f

pickledump(regressor f)

on le charge

with open(output_model_file rb) as f

regressor_model = pickleload(f)

on fait tourner notre modegravele sur les donneacutees test

y_test_pred_new = regressor_modelpredict(X_test)

print(nNew mean absolute error = round(smmean_absolute_error(y_test y_test_pred_new) 2))


Exercice8 regression lineacuteaire import pickle

import numpy as np




Input file containing data


Read data



Train and test split



Training

dataX_train y_train = X[num_training] y[num_training]

Test data


Create linear regressor object




Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()

Compute performance metrics







Model persistence


Save the model



Load the model



Perform prediction on test data




EXERCICE 9 REGRESSION POLYNOMIALE

Exercice9 regression polynomiale Le but de cet exercice est de faire de la regression lineacuteaire sur un set de donneacutee agrave

plus de une dimension

On va importer les bibliothegraveques habituelles plus polynomial features httpsscikit-

learnorgstablemodulesgeneratedsklearnpreprocessingPolynomialFeatureshtml

httpswwwyoutubecomwatchv=MnEa_xHm1j8

import numpy as np



from sklearnpreprocessing import PolynomialFeatures


Exercice9 regression polynomiale on prend le ficher mutlivariables

input_file = data_multivar_regrtxtlsquo

on charge le fichier de donneacutees et les X sont les donneacutees et le y est le label



on divise les donneacutees en donneacutees drsquoentrainement et donneacutees de test



les donneacutees drsquoentrainement sont


les donneacutees de test sont


on choisit le modegravele de regression lineacuteaire

modellinear_regressor = linear_modelLinearRegression()

on fait fitter (on entraine) le modele aux donneacutees drsquoentrainement

linear_regressorfit(X_train y_train)

on preacutedit les donneacutees de sorties

y_test_pred = linear_regressorpredict(X_test)

))


Exercice9 regression polynomiale

on mesure la performance

print(Linear Regressor performance)




print(Explained variance score = round(smexplained_variance_score(y_test y_test_pred) 2))


on fait avec une regression polynomiale pour comparer

polynomial = PolynomialFeatures(degree=10)

X_train_transformed = polynomialfit_transform(X_train)

on essaie avec un point de donneacutees particulier

En fait ce point est tregraves proche du point de la ligne 11 de notre fichier de donneacutees

Qui est [766 629 566] Donc une bonne preacutediction doit donner qqchose proche de 4135

On va creacuteer une regression lineacuteaire et aussi une regression polynomiale pour regarder la

diffeacuterence

datapoint = [[775 635 556]]

poly_datapoint = polynomialfit_transform(datapoint)

poly_linear_model = linear_modelLinearRegression()

poly_linear_modelfit(X_train_transformed y_train)

on compare les reacutesultats avec les deux faccedilons de preacutedire

print(nLinear regressionn linear_regressorpredict(datapoint))

print(nPolynomial regressionn poly_linear_modelpredict(poly_datapoint))


Exercice9 regression lineacuteaire n dim import numpy as np






Load the data from the input file



Split data into training and testing



Training data


Test data


Create the linear regressor




Predict the output


Measure performance







Polynomial regression



datapoint = [[775 635 556]]







EXERCICE 10 SVM - HOUSES PRICES

Exercice10 prix des maisons avec SVM

Le but de cet exercice est de trouver le prix drsquoune maison en utilisant SVM

On commence par importer les bibliothegraveques et SVR

httpsscikit-learnorgstablemodulesgeneratedsklearnsvmSVRhtml

httpswwwyoutubecomwatchv=KTeVOb8gaD4

import numpy as np


from sklearnsvm import SVR

from sklearnmetrics import mean_squared_error explained_variance_score

from sklearnutils import shuffle

on reacutecupegravere les fichiers de donneacutees sur Boston

data = datasetsload_boston()

on meacutelange les donneacutees

X y = shuffle(datadata datatarget random_state=7)

on seacutepare els donneacutees en donneacutees drsquoentrainement et donneacutees de test




on creacuteeacutee le modegravele avec SVR

sv_regressor = SVR(kernel=linear C=10 epsilon=01)

on fait fitter le modegravele sur les donneacutees drsquoentrainement

sv_regressorfit(X_train y_train)

Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p60

Exercice10 prix des maisons avec SVM Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 2 p60

on eacutevalue la performance

y_test_pred = sv_regressorpredict(X_test)

mse = mean_squared_error(y_test y_test_pred)

evs = explained_variance_score(y_test y_test_pred)

print(n Performance )

print(Mean squared error = round(mse 2))

print(Explained variance score = round(evs 2))

on veut trouver le prix drsquoune certaine maison

test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]

print(nPredicted price sv_regressorpredict([test_data])[0])

machine learning

bullVARIANCE

Annexe variance


httpsdevelopersgooglecommachine-learningcrash-coursedescending-into-mlcheck-your-

understandinghl=fr

httpsscikit-learnorgstablemodulesgeneratedsklearnmetricsexplained_variance_scorehtml

from sklearnmetrics import explained_variance_score

y_true = [3 -05 2 7]

y_pred = [25 00 2 8]

explained_variance_score(y_true y_pred)

y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]

explained_variance_score(y_true y_pred multioutput=uniform_average)

httpssupportminitabcomfr-frminitab18help-and-how-tostatisticsbasic-statisticssupporting-topicsdata-

conceptswhat-is-the-variance (La variance mesure le degreacute de dispersion des donneacutees autour de leur

moyenne Elle est eacutegale agrave leacutecart type au carreacute)


Distributions de la longueur des clous

La longueur des clous fabriqueacutes par la machine A

(en bleu continu) preacutesente une variance plus eacuteleveacutee

que celle des clous fabriqueacutes par la machine B

(rouge tirets) Par conseacutequent un clou fabriqueacute par

la machine A a plus de chances de se trouver en

dehors des limites de speacutecification quun clou

fabriqueacute par la machine B

machine learning

bullPERTES

Annexe pertes

Quelles sont les pertes (erreurs)

httpsdevelopersgooglecommachine-learningcrash-coursedescending-into-mlvideo-lecturehl=fr

Annexe pertes

Pour un modegravele lapprentissage signifie deacuteterminer les bonnes valeurs pour toutes les pondeacuterations et le biais agrave

partir dexemples eacutetiqueteacutes Dans lapprentissage superviseacute un algorithme de Machine Learning creacutee un modegravele

en examinant de nombreux exemples puis en tentant de trouver un modegravele qui minimise la perte Ce processus

est appeleacute minimisation du risque empirique

La perte correspond agrave la peacutenaliteacute pour une mauvaise preacutediction Autrement dit la perte est un nombre qui

indique la meacutediocriteacute de la preacutevision du modegravele pour un exemple donneacute Si la preacutediction du modegravele est parfaite la

perte est nulle Sinon la perte est supeacuterieure agrave zeacutero Le but de lentraicircnement dun modegravele est de trouver un

ensemble de pondeacuterations et de biais pour lesquels la perte en moyenne sur tous les exemples est faible Par

exemple la figure 3 preacutesente agrave gauche un modegravele dont la perte est eacuteleveacutee et agrave droite un modegravele dont la perte

est faible Agrave noter concernant cette figure

Les flegraveches rouges repreacutesentent les pertes

La ligne bleue repreacutesente les preacutedictions

httpsdevelopersgooglecommachine-learningcrash-coursedescending-into-mltraining-and-losshl=fr

Notez que les flegraveches

rouges dans le

graphique de gauche

sont plus longues que

celles de lautre

graphique Il est clair

que la ligne bleue dans

le modegravele de droite

correspond agrave un modegravele

preacutedictif plus performant

que celui repreacutesenteacute

dans le graphique de

gauche

Vous vous demandez

peut-ecirctre sil est possible

de creacuteer une fonction

matheacutematique (de perte)

capable dagreacuteger les

pertes de maniegravere

significative

Annexe pertes httpsdevelopersgooglecommachine-learningcrash-coursedescending-into-mltraining-and-losshl=fr

Lerreur quadratique moyenne (MSE) correspond agrave la perte quadratique moyenne pour chaque exemple Pour calculer

lerreur MSE il faut additionner toutes les pertes quadratiques de chaque exemple puis diviser cette somme par le nombre

dexemples

ougrave

bull(x y) est un exemple dans lequel

bullx est lensemble des caracteacuteristiques (par exemple tempeacuterature acircge et reacuteussite de laccouplement) que le modegravele

utilise pour reacutealiser des preacutedictions

bully est leacutetiquette de lexemple (par exemple stridulationsminute)

bullprediction(x) est une fonction des pondeacuterations et biais en combinaison avec lensemble des caracteacuteristiques x

bull D est un ensemble de donneacutees contenant de nombreux exemples eacutetiqueteacutes qui sont des paires (xy)

bull N est le nombre dexemples dans

bull

Bien que lerreur MSE soit couramment utiliseacutee dans le Machine Learning ce nest ni la seule fonction de perte pratique ni la

meilleure fonction de perte pour toutes les circonstances

Perte quadratique une fonction de perte populaire

Les modegraveles de reacutegression lineacuteaire que nous examinerons ici utilisent une fonction de perte appeleacutee perte quadratique (ou perte L2)

Pour un seul exemple la perte quadratique est


Annexe pertes httpsdevelopersgooglecommachine-learningcrash-coursereducing-lossvideo-lecturehl=fr

Comment reacuteduire la perte



httpsdevelopersgooglecommachine-learningcrash-

coursefittergraphhl=fr exercice de descente de gradient (cours google)

httpswwwyoutubecomwatchv=JGgT7L7wKQM explication du learning

rate (en franccedilais)

Exercice10 prix des maisons avec SVM import numpy as np





Load housing data


Shuffle the data


Split the data into training and testing datasets




Create Support Vector Regression model


Train Support Vector Regressor


Evaluate performance of Support Vector Regressor







Test the regressor on test datapoint

test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]



EXERCICE 11 ARBRES DE DECISION

Exercice11 arbres de deacutecision Le but de cet exercice est classifier des donneacutees gracircce agrave

un arbre de deacutecision decision tree

httpsscikit-learnorgstablemodulestreehtml

httpwwwgrappauniv-

lille3frpolysapprentissagesortie004html

On va commencer par importer les bibliothegraveques import numpy as np






puis prendre les donneacutees du fichier data_decision_treestxt

input_file = data_decision_treestxtlsquo


la derniegravere colonne est le label


on va separer les donneacutees en deux classes selon les labels 0 ou 1

class_0 = nparray(X[y==0])


Visualiser les donneacutees drsquoentreacutee input data

pltfigure()

pltscatter(class_0[ 0] class_0[ 1] s=75 facecolors=black

edgecolors=black linewidth=1 marker=x)

pltscatter(class_1[ 0] class_1[ 1] s=75 facecolors=white

edgecolors=black linewidth=1 marker=o)

plttitle(Input data)


Exercice11 arbres de deacutecision on seacutepare les donneacutees en donneacutees drsquoentrainement et donneacutees de tests 25 sont des donneacutees de

tests 75 des donneacutees drsquoentrainement


on applique les arbres de deacutecision comme classificateurs random_state se refere agrave ce qui est utiliseacute

par le geacuteneacuterateur de nombre au hasard (random number generator) pour lrsquointitialisation de lrsquoalgorithme et

max_depth est la profondeur maximum de lrsquoarbre agrave construire


classifier = DecisionTreeClassifier(params)


visualize_classifier(classifier X_train y_train Training dataset)


visualize_classifier(classifier X_test y_test Test dataset)


Exercice11 arbres de deacutecision on eacutevalue la performance

class_names = [Class-0 Class-1]

print(n + 40)

print(nClassifier performance on training datasetn)

print(classification_report(y_train classifierpredict(X_train) target_names=class_names))

print(40 + n)print(40)print(nClassifier performance on test datasetn)

print(classification_report(y_test y_test_pred target_names=class_names))

print(40 + n)

pltshow()


machine learning

bullDECISION TREES

annexesarbres de deacutecision Le but de cet exercice est classifier des donneacutees gracircce agrave un arbre de deacutecision decision tree


httpwwwgrappauniv-lille3frpolysapprentissagesortie004html


9 Classification par arbre de deacutecision

bull un Arbre de deacutecision comporte Š nœuds internes test sur un attribut

Š branches reacutesultat drsquoun test valeur de lrsquoattribut

Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui


bull Geacuteneacuteration de lrsquoarbre se fait en 2 eacutetapes

Š 1Construction

ƒ au deacutepart tous les exemples du jeu drsquoapprentissage sont agrave la racine ƒ partitionne reacutecursivement les exemple en seacutelectionnant des attributs Š 2Eacutelagage

ƒ identification et suppression des branches correspondant agrave des exceptions ou du bruit bull Utilisation de lrsquoarbre

Š teste les valeurs des attributs avec lrsquoarbre de deacutecision

11 Exemple suceptible drsquoacheter un ordinateur

age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no

excellent 31hellip40 high

gt40 medium

no fair lt=30 no fair

3040 gt40

gt40

low

yes

fair gt40 low yes excellent

31hellip40 low yes excellent

student yes credit rating

lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes

excellent 31hellip40

medium

no

excellent 31hellip40 high yes fair

gt40 medium no excellent

no yes no yes

Exercice Eacutecrire un arbre de deacutecision correspondant agrave ce tableau



age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes

Voici un exemplaire en avez-vous drsquoautres

Correction

12 Algorithme pour lrsquoinduction drsquoarbre de deacutecision

bull Algorithme glouton Š approche descendante reacutecursive diviser pour reacutegner

Š au deacutepart tous les objets sont agrave la racine

Š attributs cateacutegoriels (les valeurs continues sont discreacutetiseacutees agrave lrsquoavance) Š les exemples sont partitionneacutes reacutecursivement par la seacutelection drsquoattribut Š les attributs sont seacutelectionneacutes sur la base drsquoune heuristique ou drsquoune mesure statistique

bull Conditions drsquoarrecirct Š tous les exemples pour un nœud appartiennent agrave la mecircme classe

Š plus drsquoattribut pour partitionner dans ce cas la classe attribueacutees correspond agrave celle la plus repreacutesenteacutee Š plus drsquoexemple agrave classer

httpsopenclassroomscomcoursesles-algorithmes-gloutons

httpsscaroninfodocintro-arbres-decision


cette preacutesentation est-elle inteacuteressante

13 Mesure pour la seacutelection drsquoattribut Exemple gain drsquoinformation

bull Seacutelectionne lrsquoattribut qui a le gain le plus eacuteleveacute bull Soient 2 classes P et N Š Soit un jeu drsquoapprentissage S qui contient p objets de classe P et n

objets de classe N Š La quantiteacute drsquoinformation neacutecessaire pour deacutecider si un objet de S appartient agrave P ou N est deacutefinie comme

I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n

bull Les valeurs de A partitionnent S en S1 hellip Sv Š si Si contient pi exemples de P et ni exemple de N lrsquoentropie ou

lrsquoinformation attendue neacutecessaire pour classer les objets dans tous les sous-arbres Si est ν

p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n

bull Le gain drsquoinformation de lrsquoattribut A est Gain( A) = I ( p n) minus E(A)

14 Exemple achegravete un ordinateur

Œ Classe P achegravete un ordinateur = oui Œ Classe N achegravete un ordinateur = non

age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971

Œ Calcul de lrsquoentropie E( age )=

5

14

5

I(23)+

4

14

I(40)

Œ Gain drsquoinformation

Œ De mecircme

+ I(32)= 069 14

Gain(age) = I ( p n) minus E(age)

Gain(income) = 0029

Gain(student) = 0151

Gain(credit_ rating)= 0048

15 Eacuteviter de trop modeacuteliser le jeu drsquoapprentissage (overfitting)

bull Lrsquoarbre geacuteneacutereacute risque de trop refleacuteter le jeu drsquoapprentissage Š trop de branches certaines peuvent repreacutesenter des anomalies

Š preacutecision faible pour des donneacutees nouvelles bull

2 approches Š preacute-eacutelagage arrecircter la construction de lrsquoarbre tocirct = ne pas partitionner un nœud si la mesure de qualiteacute deacutepasse un seuil ƒ difficulteacute de fixer le seuil

Š post-eacutelagage supprimer des branches drsquoun arbre totalement construit = obtenir une seacutequence drsquoarbres progressivement eacutelagueacutes ƒ utiliser un jeu de donneacutees diffeacuterents pour deacutecider du meilleur arbre

eacutelagueacute

16 Ameacuteliorations de lrsquoalgorithme

bull Attributs deacutefinis sur des valeurs continues

Š deacutefinir dynamiquement les valeurs pour

partitionner les donneacutees

bull Toleacuterance aux donneacutees manquantes Š attribuer la valeur la plus freacutequente

Š attribuer une probabiliteacute pour chaque valeur possible

17 Classification Bayeacutesienne

bull Apprentissage probabiliste calcule explicitement les probabiliteacutes des hypothegraveses une des approches les plus pragmatiques pour certains types

drsquoapprentissage

bull Increacutemental chaque exemple met agrave jour la probabiliteacute qursquoune hypothegravese

est correcte Des connaissances a priori peuvent ecirctre combineacutees avec des

donneacutees drsquoobservation

bull Preacutediction probabiliste preacutedit plusieurs hypothegraveses pondeacutereacutees par leur probabiliteacute

machine learning

bullCLASSIFICATION REPORT

annexesclassification report httpsscikit-learnorgstablemodulesgeneratedsklearnmetricsclassification_reporthtml


y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]

target_names = [class 0 class 1 class 2]

print(classification_report(y_true y_pred target_names=target_names))


Exercice11 arbres de deacutecision import numpy as np






Load input data




Separate input data into two classes based on labels



Visualize input datapltfigure()

pltscatter(class_0[ 0] class_0[ 1] s=75 facecolors=black edgecolors=black linewidth=1 marker=x)

pltscatter(class_1[ 0] class_1[ 1] s=75 facecolors=white edgecolors=black linewidth=1 marker=o)


Split data into training and testing datasets


Decision Trees classifier







Evaluate classifier performance


print(n + 40)





print(40 + n)

pltshow()


EXERCICE 11 FORETS DrsquoARBRES ALEATOIRES

Exercice12 random forest Le but de cet exercice est drsquoutiliser les random forest


Avec type rf

Avec type erf

Exercice12 random forest import argparse

import numpy as np



from sklearnensemble import RandomForestClassifier ExtraTreesClassifier




Argument parser

def build_arg_parser()

parser = argparseArgumentParser(description=Classify data using Ensemble Learning techniques)

parseradd_argument(--classifier-type dest=classifier_type required=False default=rf

modif RE choices=[rf erf] help=Type of classifier to use can be either rf or erf)

return parser

if __name__==__main__

Parse the input arguments

args = build_arg_parser()parse_args()

classifier_type = argsclassifier_type

Load input data

input_file = data_random_foreststxt



print(X) print(y)

Separate input data into three classes based on labels




Visualize input data

pltfigure()

pltscatter(class_0[ 0] class_0[ 1] s=75 facecolors=whiteedgecolors=black linewidth=1 marker=s)


pltscatter(class_2[ 0] class_2[ 1] s=75 facecolors=white edgecolors=black linewidth=1 marker= )



X_train X_test y_train y_test = model_selectiontrain_test_split( X y test_size=025 random_state=5)

Ensemble Learning classifier

params = n_estimators 100 max_depth 4 random_state 0

if classifier_type == rf

classifier = RandomForestClassifier(params)

else

classifier = ExtraTreesClassifier(params)






class_names = [Class-0 Class-1 Class-2]

print(n + 40)



print(40 + n)

print(40)

print(nClassifier performance on test datasetn)


print(40 + n)

Compute confidence

test_datapoints = nparray([[5 5] [3 6] [6 4] [7 2] [4 4] [5 2]])

print(nConfidence measure)

for datapoint in test_datapoints

probabilities = classifierpredict_proba([datapoint])[0]

predicted_class = Class- + str(npargmax(probabilities))

print(nDatapoint datapoint)

print(Predicted class predicted_class)

Visualize the datapoints

visualize_classifier(classifier test_datapoints [0]len(test_datapoints) Test datapoints)

pltshow()


Exercice12 random forest On commence par importer des librairies

httpsdocspythonorg3libraryargparsehtml permet de geacuterer les ligens de commandes

httpwwwifremerfrvacummcoursesargparsehtml

import argparse

import numpy as np







on deacutefinit la fonction Argument parser pour prendre en entreacutee le classificateur python on va prendre RF random forest ou ERF

extreme random forest




modif RE (ici on prend au deacutepart rf et on regardera avec erf ensuite) choices=[rf erf] help=Type of classifier

to use can be either rf or erf)

return parser

on deacutefinit la fonction main


qui va parser les arguments



on prend comme fichier drsquoinput le fichier data_random_foreststxt



les donneacutees drsquoentreacutee sont X et le dernier champ y sont les labels


print(X)

print(y)


Exercice12 random forest on va seacuteparer les donneacutees en trois classes selon les labels




visualisons les donneacutees drsquoentreacutee

pltfigure()


pltscatter(class_1[ 0] class_1[ 1] s=75 facecolors=whiteedgecolors=black linewidth=1 marker=o)

pltscatter(class_2[ 0] class_2[ 1] s=75 facecolors=whiteedgecolors=black linewidth=1 marker= )



Exercice12 random forest seacuteparons les donneacutees entre donneacutees drsquoentrainement et donneacutees de test qui repreacutesentent 25


deacutefinissons les parametres agrave utiliser pour construire le classificateur

Le paramegravetre lsquon_estimatorsrsquo represente le nombre drsquoarbres qui seront construits ici 100

Le paramegravetre lsquomax_depthrsquo est la profondeur de chaque arbre cela se reacutefegravere au nombre de niveau dans chaque arbre

Le paramegravetre lsquorandom_statersquo est la valeur drsquoinitialisation

Extra tree classifier est expliqueacute ici httpsscikit-learnorgstablemodulesgeneratedsklearnensembleExtraTreesClassifierhtml

Sinon random forest forets aleacuteatoires est bien expliqueacute lagrave httppersomines-

paristechfrfabienmoutardeES_MachineLearningSlidescoursFM_AD-RFpdf

La diffeacuterence entre random forest et extreme random forest est ici httpsstatsstackexchangecomquestions175523difference-

between-random-forest-and-extremely-randomized-trees

En gros en extreme random forest on recherche drsquoautres arbres de faccedilon optimiseacutee (et non aleacuteatoire)




else


on fait fitter le classificateur aux donneacutees drsquoentrainement


On peut visualiser le classificateur sur les donneacutees drsquoentrainement




Exercice12 random forest

On peut visualiser le classificateur sur les donneacutees de test



Exercice12 random forest eacutevaluons la performance du modegravele


print(n + 40)


print(classification_report(y_train classifierpredict(X_train)

target_names=class_names))

print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)


Exercice12 random forest eacutevaluons la confiance du modegravele pour cet ensemble de points quelle sera la classe

preacutedite crsquoest celle avec la probabiliteacute la plus grande









Exercice12 random forest Visualisons les points de donneacutees

visualize_classifier(classifier test_datapoints [0]len(test_datapoints) Test

datapoints)

pltshow()


Exercice12 random forest Si on reprend le code avec ERF on obtiendra les donneacutees training suivantes


Exercice12 random forest Si on reprend le code avec ERF on obtiendra les donneacutees test suivantes


Exercice12 random forest Si on reprend le code avec ERF on obtiendra les donneacutees suivantes


EXERCICE 14 IMBALANCE

Exercice14 imbalance-random forest import sys

import numpy as np


from sklearnensemble import ExtraTreesClassifier




Load input data

input_file = data_imbalancetxtlsquo







pltfigure()






Extremely Random Forests

classifierparams = n_estimators 100 max_depth 4 random_state 0

if len(sysargv) gt 1

if sysargv[1] == balance

params = n_estimators 100 max_depth 4 random_state 0 class_weight balanced

else

raise TypeError(Invalid input argument should be balance)








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()


Le but de cet exercice est de trouver une solution quand les ensembles de deacuteparts ne sont pas eacutequitablement reacutepartis

Exercice14 imbalance-random forest

On importe les librairies habituelles

import sys

import numpy as np






on prend les donneacutees du fichier data_imbalancetxt pour notre analyse Chargeons les donneacutees Chaque donneacutee est seacutepareacutee par

u virgule les deux premiegraveres valeurs sont els doneacutenes drsquoinput et la derniegravere colonne les labels cibles Nous avons deux classes

dans ce jeu de donneacutees




separons les deux classes selon les deux labels y



visualisons les donneacutees drsquoinput

pltfigure()






Exercice14 imbalance-random forest Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p82


seacuteparons les donneacutees en donneacutees drsquoentrainement et de test qui feront 25 du total des donneacutees input


on va utiliser Extremely Random Forests les forets aleacuteatoires extremes en construisant une centaine

drsquoarbres de profondeur maximum 4 ajoutant un paramegravetre comme quoi il faut laquo eacutequilibrer raquo (balance) les

donneacutees sinon pourra faire lrsquoexercice sans le paramegravetre class_weight balancedlsquo et voir ce que cela donne



on fait fitter le modegravele



on preacutedit les y


on visualise les reacutesultats




print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced


Avec le balanced une erreur apparait car il en preacutedit rien en classe 0 du coup


Avec le balanced

EXERCICE 15 GRIDSEARCH CV

Exercice15 gridsearchCV Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p90

Le but de cet exercice est drsquoutiliser une fonction gridsearch cv qui permet de choisir les bons paramegravetres agrave notre place En effet lorsqursquoon

utilise les classificateurs on ne sait aps toujours quels paramegravetres mettre Et veacuterifier agrave la main plein de combinaisons est tregraves time

consuming Gridsearchcv fait cela on lui donne des valeurs agrave tester

Commenccedilons par importer les bibliothegraveques

import numpy as np


import sklearnensemble

import sklearnmetrics

import sklearnmodel_selection


on importe la donneacutee data_random_foreststxt avec le deacutelimiteur par une virgule

input_file = data_random_foreststxtlsquo



on seacuteparate les donneacutees en 3 classes selon les labels y qui sont agrave 0 1 ou 2




on seacutepare la donneacutee en donneacutees drsquoentrainement et donneacutees de test avec 25 pour les

donneacutees tests

X_train X_test y_train y_test = sklearnmodel_selectiontrain_test_split(X y test_size=025

random_state=5)


Le but de cet exercice est drsquoutiliser une fonction gridsearch cv qui permet de choisir les bons paramegravetres agrave notre place

on deacutefinit les paramegravetres du grid qui repreacutesentent les diffeacuterentes possibiliteacutes agrave tester nombre

drsquoarbres dans la forecirct la profondeur de chaque arbre et les meacutetriques que lrsquoon veut tester

precision ou recall (rappel)

parameter_grid = [ n_estimators [100] max_depth [2 4 7 12 16] max_depth [4]

n_estimators [25 50 100 250]

]metrics = [precision_weighted recall_weighted]

pour chaque meacutetrique preacutecision ou recall on calcule

for metric in metrics

print(n Searching optimal parameters for metric)

classifier =

sklearnmodel_selectionGridSearchCV(sklearnensembleExtraTreesClassifier(random_state=0)

parameter_grid cv=5 scoring=metric)

on fait fitter le classificateur


print(nGrid scores for the parameter grid)

for params avg_score in zip(classifiercv_results_[params]

classifiercv_results_[mean_test_score])

print(params --gt round(avg_score 3))

print(nBest parameters classifierbest_params_)

y_pred = classifierpredict(X_test)

print(nPerformance reportn)

print(sklearnmetricsclassification_report(y_test y_pred))



import numpy as np






Load input data









X_train X_test y_train y_test = sklearnmodel_selectiontrain_test_split(X y test_size=025 random_state=5)

Define the parameter grid

parameter_grid = [ n_estimators [100] max_depth [2 4 7 12 16] max_depth [4] n_estimators [25 50 100 250]




classifier = sklearnmodel_selectionGridSearchCV(sklearnensembleExtraTreesClassifier(random_state=0)




for params avg_score in zip(classifiercv_results_[params] classifiercv_results_[mean_test_score])








Si on cherche agrave optimiser la preacutecision



Si on cherche agrave optimiser le recall

EXERCICE 16 ADABOOST

Exercice16 features importants Adaboost Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p92

Le but de cet exercice est drsquoutiliser Adaboost qui permet de classifer les features importants dans notre base de donneacutees

Dans le but de reacuteduire la dimension de nos donneacutees regarder les features qui sont les plus importants est une bonne meacutethode

nous allons utiliser la regression Adaboost pour trouver lrsquoimportance de chacun des features Adaboost est le diminutif de

Adaptative Boosting qui est un algorithme souvent utiliseacute avec drsquoautres algos de machine learning pour ameacuteliorer leur

performance Dans Adaboost les points de donneacutees drsquoentrainement sont tireacutees drsquoune distribution pour entrainer le classificateur

Cette distribution est mise agrave jour agrave chaque iteacuteration pour que le classificateur se concentre sur les points les plus difficiles agrave

classifier ceux qui ne sont pas classifieacutes dans la bonne classe A chaque pas on change donc la distrubution on y remet les

points les plus difficiles agrave classifier Chaque classificateur est cascadeacute ainsi

httpswwwyoutubecomwatchv=GM3CDQfQ4sw

importons les librairies habituelles import numpy as np


from sklearntree import DecisionTreeRegressor

from sklearnensemble import AdaBoostRegressor





On charge les donneacutees des maisons de Boston

housing_data = datasetsload_boston()

on meacutelange les donneacutees pour ne pas ecirctre biaiseacute dans nos choix

X y = shuffle(housing_datadata housing_datatarget random_state=7)

on meacutelange les donneacutees en donneacutees drsquoentrainement et donneacutees de tests

X_train X_test y_train y_test = model_selectiontrain_test_split(X y test_size=02 random_state=7)

on applique lrsquoAdaBoost Regressor

modelregressor = AdaBoostRegressor(DecisionTreeRegressor(max_depth=4)n_estimators=400 random_state=7)

on fait fitter le regressor aux donneacutees



on eacutevalue la performance drsquoAdaBoost

regressory_pred = regressorpredict(X_test)

mse = mean_squared_error(y_test y_pred)

evs = explained_variance_score(y_test y_pred )

print(nADABOOST REGRESSOR)



on extrait les features importants

feature_importances = regressorfeature_importances_feature_names = housing_datafeature_names

on normalise les valeurs drsquoimportance

feature_importances = 1000 (feature_importances max(feature_importances))

on trie les valeurs et on les retourne

index_sorted = npflipud(npargsort(feature_importances))

on arrange les X

tickspos = nparange(index_sortedshape[0]) + 05

on dessine le reacutesultat

pltfigure()

pltbar(pos feature_importances[index_sorted] align=center)

pltxticks(pos feature_names[index_sorted])pltylabel(Relative Importance)

plttitle(Feature importance using AdaBoost regressor)

pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor



Evaluate performance of AdaBoost







Extract feature importances


Normalize the importance values feature_importances = 1000 (feature_importances max(feature_importances))

Sort the values and flip them


Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans

Exercice17 Clustering K-Means algorithm Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 4 p98

Le Clustering est lrsquoune des techniques les plus populaires de machine learning non superviseacute (on

ne sait pas ce qursquoon va trouver on nrsquoa pas de classes ou de valeurs attendues contrairement agrave la

classification ou agrave la regression)

Cette technique est utiliseacutee pour analyser la donneacutee et trouver des clusters (des paquets) agrave

lrsquointeacuterieur de la donneacutee

Dans le but de deacutefinir ces regroupements on va devoir utiliser une certaine lsquomesure de similariteacutersquo

on peut par exemple prendre la distance Euclidienne comme distance

Cette mesure de similariteacute va mesurer combien est lsquocompactrsquo le paquet (ou cluster)

Le clustering est le fait de deacutefinir des sous-groupes dans lesquels les eacuteleacutements sont similaires les

uns aux autres

Notre but est drsquoidentifier les proprieacuteteacutes intrinsegraveques des points de donneacutees qui font qursquoelles vont

appartenir au mecircme sous-groupe Il nrsquoy a pas de mesure de similariteacute qui marche pour tous les

cas

K-Means est un algorithme bien connu de clustering Pour lrsquoutiliser il savoir combien de clusters

on veut obtenir On segmente la donneacutee en ce nombre K de sous-groupes On commence par

classifier dans ce nombre K de paquets et ensuite on itegravere agrave chaque fois pour faire changer le

lsquocentrersquo (centroide) du paquets jusqursquoagrave optimisation (que les paquets ne bougent plus)

httpswwwyoutubecomwatchv=zHbxbb2ye3Eampitct=CAgQpDAYCCITCN7itYHaodYCFZjHnAodWQgNljIHc

mVsYXRlZEit4oasydaBwwk3Dampgl=USamphl=enampclient=mv-googleampapp=desktop

Une petite deacutemo ici avec des cartes


Creacuteons un nouveau fichier Python et importer les packages suivants

import numpy as np


from sklearncluster import KMeans

from sklearn import metrics

On va chercher la donneacutee data_clusteringtxt donrsquot le deacutelimiteur est une virgule

X = nploadtxt(data_clusteringtxt delimiter=)

Nous devons deacutefinir el nombre de clusters (paquets) avant drsquoappliquer lrsquoalgorithmeK-means

ici 5

num_clusters = 5

Nous allons visualiser les donneacutees drsquoentreacutee pour voir agrave quoi cela ressemble sur un scheacutema

pltfigure()

pltscatter(X[0] X[1] marker=o facecolors=noneedgecolors=black s=80)




pltxlim(x_min x_max)

pltylim(y_min y_max)

pltxticks(())

pltyticks(())



On peut voir que cela fait effectivement 5 paquets plus ou moins dans la donneacutee

Noua allons creacuteer lrsquoobjet KMeans avec des apramegravetre sinitiaux qui sont (ou plutocirct seront)les

centres des paquets on peut les choisir totalement au hasard mais on peut aussi utiliser

kmeans++ pour les choisir de maniegravere plus intelligente et donc faire converger lrsquoalgo plus

rapidement (pour cela dans kmeans++ on choisit un premier centre et le second eacuteloigneacute du

premier et un troisiegraveme eacuteloigneacute des deux autres etchellip)

Le paramegravetre n_clusters est le nombre de clusters

Le paramegravetre n_init est le nombre de fois ougrave lrsquoago va tourner avant de deacuteterminer le meilleur

clustering (va converger)

Creacuteons lrsquoobjet KMeans

kmeans = KMeans(init=k-means++ n_clusters=num_clusters n_init=10)

Entrainons le modegravele KMeans

kmeansfit(X)

Pour voir les frontiegraveres on va faire une grille de points serreacutes de 001 et voir dans quelle cluster

ils sont mis

on deacutefinit le pas Step size

step_size = 001

On deacutefinit une grille de points qui englobe nos donneacutees de deacutepart



x_vals y_vals = npmeshgrid(nparange(x_min x_max step_size)nparange(y_min y_max

step_size))


nous allons appliquer la preacutediction agrave tous ces points de la grille

output = kmeanspredict(npc_[x_valsravel() y_valsravel()])

nous allons positionner les valeurs drsquooutput et colorer chacune des reacutegions ou cluster


pltfigure()

pltclf()

pltimshow(output interpolation=nearestextent=(x_valsmin() x_valsmax()y_valsmin()

y_valsmax())cmap=pltcmPairedaspect=autoorigin=lower)

on ajoute nos points de deacutepart dans ces reacutegions coloreacutees


on va mettre les centre des clusters aussi sur le scheacutema

cluster_centers = kmeanscluster_centers_

pltscatter(cluster_centers[0] cluster_centers[1]marker=o s=210 linewidths=4 color=black

zorder=12 facecolors=black)



plttitle(Boundaries of clusters)



pltxticks(())

pltyticks(())

pltshow()



Le but de cet exercice est drsquoutiliser Kmeans

import numpy as np


from sklearncluster import Kmeans


Load input dataX = nploadtxt(data_clusteringtxt delimiter=)

num_clusters = 5

Plot input datapltfigure()

pltscatter(X[0] X[1] marker=o facecolors=nonelsquoedgecolors=black s=80)



plttitle(Input data)pltxlim(x_min x_max)


pltxticks(())pltyticks(())

Create KMeans object


Train the KMeans clustering model

kmeansfit(X)

Step size of the mesh

step_size = 001

Define the grid of points to plot the boundaries

x_min x_max = X[ 0]min() - 1 X[ 0]max() + 1y_min y_max = X[ 1]min() - 1 X[ 1]max() + 1

x_vals y_vals = npmeshgrid(nparange(x_min x_max step_size) nparange(y_min y_max step_size))

Predict output labels for all the points on the grid


Plot different regions and color them


pltfigure()

pltclf()

pltimshow(output interpolation=nearest extent=(x_valsmin() x_valsmax()y_valsmin() y_valsmax()) cmap=pltcmPaired aspect=auto origin=lower)

Overlay input points

pltscatter(X[0] X[1] marker=o facecolors=none edgecolors=black s=80)

Plot the centers of clusters


pltscatter(cluster_centers[0] cluster_centers[1] marker=o s=210 linewidths=4 color=black zorder=12 facecolors=black)x_min x_max = X[ 0]min() - 1 X[

0]max() + 1y_min y_max = X[ 1]min() - 1 X[ 1]max() + 1




pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS

Clustering K-Means algorithm httpsmediumcomfrianbizcomment-C3A7a-marche-le-machine-learning-5a5a3ec299ea

Pour regarder comment marche lrsquoalgo

Au deacutepart (a) on a nos

donneacutees

(b) on positionne deux

points (au hasard) et on

seacutepare les points de

donneacutees (c) selon leur

distance aux points

preacuteceacutedents

(d) On recommence avec

deux nouveaux points qui

sont les moyennes de

chaque nouveau cluster

(e) Idem in recommence

(f) jusqursquoagrave ce que lrsquoalgo ne

donne pas de nouvel

endroit pour els nouvelles

moyennes (il a convergeacute)


Pour vous amuser un site marchand a creacuteer des paquets de clients gracircce a Kmean

et voici sa trouvaille en regardant les surnoms des personnes

httpswwwyoutubecomwatchv=_w4OOhlv7Hk



EXERCICE 18 mean shift

Exercice18 mean shift Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 4 p104

import numpy as np


from sklearncluster import MeanShift estimate_bandwidthfrom itertools import cycle

on charge les donneacutees data_clusteringtxt


one stime la bande passante de X

bandwidth_X = estimate_bandwidth(X quantile=01 n_samples=len(X))

on va clusteriser les donneacutees gracircce agrave MeanShift

meanshift_model = MeanShift(bandwidth=bandwidth_X bin_seeding=True)

meanshift_modelfit(X)

et extraire les centres des clusters

cluster_centers = meanshift_modelcluster_centers_print(nCenters of clustersn cluster_centers)

Estimons le nombre de clusters

labels = meanshift_modellabels_

num_clusters = len(npunique(labels))

print(nNumber of clusters in input data = num_clusters)

Positionnons les points et les centres des clusters sur un sheacutema

pltfigure()markers = oxvslsquo

for i marker in zip(range(num_clusters) markers)

positionnons les points

pltscatter(X[labels==i 0] X[labels==i 1] marker=marker color=black)

et les centres des clusters

cluster_center = cluster_centers[i]

pltplot(cluster_center[0] cluster_center[1] marker=o markerfacecolor=black markeredgecolor=black

markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift

mean shift Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 4 p104

Mean Shift est un algorithme puissant non superviseacute On dit qursquoil est non parmaeacutetrique car il ne fait pas

drsquohypothegraveses sur ce qursquoil va trouver

Crsquoest diffeacuterent des techniques parameacutetriques ougrave on considegravere que les donneacutees suivent une distribution avec une

certaine probabiliteacute

Mean shift est utiliseacutee reacuteguliegraveremetn pour de lrsquoanalyse de donneacutees en temps reacuteel du tracage drsquoobjet

Dans mean shift on considegravere lrsquoespace des donneacutees comme une fonction de probabiliteacute de densiteacute

On commence avec le jeu de donneacutees drsquoentreacutee comme si crsquoeacutetait un extrait drsquoune fonction de probabiliteacute de

densiteacute

Les clusters vont donc correspondre aux maximum locaux de cette distribution

Srsquoil y a K clusters il y aura K pics dans la distribution de ces donneacutees et Kmeans identifiera ces pics (ce sera

lrsquoendroit ougrave se trouveront les centroiumldes)

Pour chaque point du set de donneacutees drsquoentreacutee il deacutefinit une lsquofenecirctrersquo autour de lui et deacutefinit le centre de densiteacute

de cette nouvelle fenecirctre et se met agrave jour en se positionnant en plein dans le centroiumlde de cette fenecirctre AU fur et

agrave mesure on se rapproche du pic de chaque cluster

Et ainsi chaque point de donneacutee se deacuteplacera vers le centre du cluster qui lui appartient en allant toujours vers

un endroit ougrave la densiteacute est la plus eleveacutee

Donc on ne fait que changer les les centroiumldes de place les centroiumldes sont aussi appeleacutes moyennes (means) et

on les change drsquoougrave le nom mean shift

On fait ceci jusqursquoagrave ce que lrsquoalgorithme converge crsquoest agrave dire juqursquoagrave ce que les centroiumldes ne bougent plus

On va utiliser le mecircme set de donneacutees que celui preacuteceacutedemment data_clusteringtxt file

mean shift httpwwwenseignementpolytechniquefrinformatiqueINF556TD2kd_treeindexhtml

Clustering On traite lensemble des points comme provenant dune fonction de densiteacute de probabiliteacute (quon ne connait pas

explicitement bien sur) les reacutegions de lespace ougrave la densiteacute est forte correspondent aux maximaux locaux (modes) de la

distribution sous-jacente Lalgorithme de clusterting appeleacute Mean-Shift consiste agrave effectuer des estimations locales du

gradient de la densiteacute aux points de donneacutees puis agrave bouger ces points le long du gradient estimeacute de maniegravere iteacuterative

jusquagrave ce quil y ait convergence les points stationnaires de ce procedeacute correspondent aux maximaux locaux de la

distribution Et finalement les points quon associe agrave un meme point stationnaire seront classifieacutes comme faisant partie du

meme cluster

Si ce nrsquoest pas tregraves clair voici lrsquoexplication pour les polytechniciens

Au deacutepart tous les points rouges (qui vont bouger vers lagrave ougrave il y a le plus de densiteacute sont exactement sur les

points de donneacutees initiaux les bleus)hellip mini suspense on pense que les rouges vont des mettre en 4

paquets mais en fait non en 3 Par rapport a Kmeans pas besoin de connaitre agrave lrsquoavance le nombre de

paquets


Creacuteons un nouveau fichier Python et importons les packages suivants

import numpy as np


from sklearncluster import MeanShift estimate_bandwidth

from itertools import cycle

chargeons la donneacutee drsquoentreacutee qui a pour deacutelimiteur un virgule


Estimons la bande passante de la donneacutee drsquoentreacuteehellipeh oui quand on parle de densiteacutehellipla notion

de bande passante nrsquoest pas loin la densiteacute du noyau est importante si la bande passante est

eacutetroite cela fera bcp de clusters alors que si elle est tregraves large plusieurs clusters vont se

meacutelanger en un A higher value for

quantile will increase the estimated bandwidth resulting in a lesser number of clusters

Estimons la bande passante de X


Nous allons entrainer lrsquoalgo Meanshift en utilisant la bande passante estimeacutee

clusterisons nos donneacutees gracircce agrave MeanShift



Extrayons les centres des clusters

Extractions des centres des clusters

cluster_centers = meanshift_modelcluster_centers_

print(nCenters of clustersn cluster_centers)


Estimons le nomber of clusters




Visualisons les poitns de donneacutees et les centres des clusters

pltfigure()

markers = oxvs


Postionnons les points qui appartiennent au cluster actuel

pltscatter(X[labels==i 0] X[labels==i 1] marker=marker

color=black)

Positionnons le centre des clusters actuels


pltplot(cluster_center[0] cluster_center[1] marker=o

markerfacecolor=black markeredgecolor=black

markersize=15)

plttitle(Clusters)

pltshow()



EXERCICE 19 silhouette scores

Exercice19 silhouette scores Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 4 p106

import numpy as np




chargeons les donneacutees data_qualitytxt

X = nploadtxt(data_qualitytxt delimiter=)

dessinons ces donneacutees

pltfigure()

pltscatter(X[0] X[1] color=black s=80 marker=o facecolors=none)





pltxticks(())

pltyticks(())

Initialisons les variables

scores = []values = nparange(2 10)

Iterons dans lrsquointervalle deacutefini

for num_clusters in values

entrainons le modele de clusering KMeans


kmeansfit(X)

score = metricssilhouette_score(X kmeanslabels_ metric=euclidean sample_size=len(X))

print(nNumber of clusters = num_clusters)

print(Silhouette score = score)

scoresappend(score)

desinons la silhouette

scorespltfigure()

pltbar(values scores width=07 color=black align=center)

plttitle(Silhouette score vs number of clusters)

Extrayons les meilleur score et le nombre optimal de clusters

num_clusters = npargmax(scores) + values[0]

print(nOptimal number of clusters = num_clusters)

pltshow()


Si la donneacutee est naturellement organiseacutee en un nombre disctinct de clusers alors cela

est facile de lrsquoexaminer visuellement et de deacuteterminer des infeacuterences Mais ceci est

rarement le cas dans le vrai monde Geacuteneacuteralement les donneacutees sont nombreuses et

deacutesordonneacutees Il faut donc une faccedilon de quantifier la qualiteacute du clustering

Silhouette est une meacutethode permettant de veacuterifier la coheacuterence des clusters de nos

donneacutees Cela donne une ideacutee pour eacutevaluer la pertinence de lrsquoappartenance drsquoun point agrave

un cluster compareacute aux autres clusters

Le score de silhouette fonctionne comme tout autre meacutetrique de similariteacute

Pour chaque point le silhouette score calcule

silhouette score = (p ndash q) max(p q)

Ici p est la distance moyenne aux points du cluster les plus pres auquel le poitn

nrsquoappartient pas

Et q est la moyenne de la distance intra-cluster de tous les poitns dans son propre

cluster

La valeur du silhouette score est entre -1 et 1

Un score de 1 indique que le poitn ressemble bcp aux autres points du cluster alors

que -1 indique qursquoil nrsquoest aps simimlaire aux autres poitns du cluster

SI jamais on trouve trop de poitns avec des scores neacutegatifs alors il se peut que lrsquoon ait

trop ou trop peu de clusters Il faut faire tourner lrsquoalgorithme agrave nouveau pour avoir le

nombre optimal


Regardons comment estimer la performance du clustering en utilisant les solhouette scores

Creacuteons un nouveau fichier python avec les packages correspondants

import numpy as np




Nous utiliserons la donneacutee dans data_qualitytxt Chaque ligne contient deux chiffres seacutepareacutes par une virgule

chargeons la donneacutee


Initialisons les variables Les tableaux de values sont une liste de variables sur lesquelles on veut iteacuterer pour

trouver le nombre optimal de clusters


scores = []

values = nparange(2 10)

Iterons pour chacune des valeurs et construisons un modele K-Means agrave chaque iteacuteration

Iterons sur les donneacutees values


entrainons le modele de clustering KMeans


kmeansfit(X)


Estimons le silhouette score pour ce modegravele de clustering avec la distance Euclidienne

score = metricssilhouette_score(X kmeanslabels_metric=euclidean sample_size=len(X))

Affichons le silhouette score pour la valeur courante



scoresappend(score)

Visualisons le silhouette scores pour diffeacuterentes valeurs

dessinons les silhouette scores

pltfigure()



Extrayons les meilleurs scores et leurs valeurs correspondantes pour le nombre de clusters

Extrayons le meilleur score et leur nombre optimal de clusters




Visualisons les donneacutees drsquoentreacutee

visualisons les donneacutees

pltfigure()

pltscatter(X[0] X[1] color=black s=80 marker=ofacecolors=none)






pltxticks(())

pltyticks(())

pltshow()




EXERCICE 20 GMM gaussian mixture

Exercice20 GMM Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 4 p106

import numpy as np


from matplotlib import patches

import sklearndatasets

import sklearnmixture


Load the iris dataset

iris = sklearndatasetsload_iris()

Split dataset into training and testing (8020 split)

skf = sklearnmodel_selectionStratifiedKFold(n_splits=5)

indices = skfsplit(irisdata iristarget)

Take the first fold

train_index test_index = next(iter(indices))

Extract training data and labels

X_train = irisdata[train_index]

y_train = iristarget[train_index]

Extract testing data and labels

X_test = irisdata[test_index]

y_test = iristarget[test_index]

Extract the number of classes

num_classes = len(npunique(y_train))

Build GMMclassifier = sklearnmixtureBayesianGaussianMixture(n_components=num_classes covariance_type=full)

Initialize the GMM means

classifiermeans_ = nparray([X_train[y_train == i]mean(axis=0) for i in range(num_classes)])

Train the GMM classifier

classifierfit(X_train)

Draw boundaries

pltfigure()colors = bgrlsquo

for i color in enumerate(colors)

Extract eigenvalues and eigenvectors

eigenvalues eigenvectors = nplinalgeigh(classifiercovariances_[i][2 2])

Normalize the first eigenvector

norm_vec = eigenvectors[0] nplinalgnorm(eigenvectors[0])

Extract the angle of tilt

angle = nparctan2(norm_vec[1] norm_vec[0])

angle = 180 angle nppi

Scaling factor to magnify the ellipses

(random value chosen to suit our needs)

scaling_factor = 8

eigenvalues = scaling_factor

Draw the ellipse

ellipse = patchesEllipse(classifiermeans_[i 2]

eigenvalues[0] eigenvalues[1] 180 + anglecolor=color)

axis_handle = pltsubplot(1 1 1)

ellipseset_clip_box(axis_handlebbox)

ellipseset_alpha(06)

axis_handleadd_artist(ellipse)

Plot the data

colors = bgrlsquo


cur_data = irisdata[iristarget == i]

pltscatter(cur_data[0] cur_data[1] marker=o facecolors=none edgecolors=black s=40label=iristarget_names[i])

test_data = X_test[y_test == i]

pltscatter(test_data[0] test_data[1] marker=s facecolors=black edgecolors=black s=40 label=iristarget_names[i])

Compute predictions for training and testing data

y_train_pred = classifierpredict(X_train)

accuracy_training = npmean(y_train_predravel() == y_trainravel()) 100

print(Accuracy on training data = accuracy_training)


accuracy_testing = npmean(y_test_predravel() == y_testravel()) 100

print(Accuracy on testing data = accuracy_testing)

plttitle(GMM classifier)

pltxticks(())

pltyticks(())

pltshow()


Que sont les Gaussian Mixture Models

Avant drsquoaborder les Gaussian Mixture Models (GMMs) essayons de comprendre ce

que sont les modegraveles Mixture

Un modegravele Mixture est un genre de modegravele de probabiliteacute de densiteacute ougrave nous

consideacuterons que les donneacutees sont gouverneacutees par des distributionsSi ces

distributions sont gaussiennes alors on obtient un Gaussian Mixture Model

Ces distributions sont combineacutees de faccedilons agrave fournir une fonction de densiteacute multi-

modale qui devient un modegravele mixture

Regardons un exemple pour comprendre comment le modegravele mixture fonctionne

Nous allons modeacuteliser les habitudes drsquoachats des SudAmericains

Une faccedilon de le faire serait de metre tout el continent et de faire fitter lrsquoensemble dans

un seul modegravele Mais nous savons que les habitudes de shopping varient drsquoun pays agrave

lrsquoautre Nous devons comprendre les habitudes drsquoachat de chacun des pays

httpsfrwikipediaorgwikiModC3A8le_de_mC3A9lange_gaussien


Si lrsquoon veut avoir un bon modegravele il faudra tenir compte de chacune des variations du continent

On va utiliser le meacutelange Gaussien en modelisant chaque pays et en combinant lrsquoensemble

Ainsi nous ne manquerons pas les nuances de chacun des pays

Les modegraveles de meacutelanges gaussiens sont semi-parameacutetriques ils deacutependent de fonctions

preacutedetermineacutees

SI lrsquoon deacutefinit la fonction de combinaison le modegravele devient parameacutetrique

Ainsi un GMM est un modegraveel parameacutetrique deacutefinit par la somme pondeacutereacutee des fonctions de

Gauss qui el composent

Les GMM sont utiliseacutes dans de nobreux cas la modeacutelisation de marcheacute les veacuteirifacations

biomeacutetriqueshellip

httpsbrilliantorgwikigaussian-mixture-model


Construisons un classificateur baseacute sur un Gaussian Mixture Model Creacuteons un

nouveau fichier Python et importons

import the following packages

import numpy as np




from sklearnmixture import GMM

from sklearncross_validation import StratifiedKFold

Reprenons la base des iris

Chargeons lrsquoiris dataset


Deacutecoupons les donneacutees entre un jeu de test et drsquoentrainement 8020 Le paramegravetre

n_folds indique le nombre de sous-ensembles que lrsquoon obtiendra nous utiliserons 5

donc el dataset estd eacutecoupeacute en 5 parties Nous utiliserons 4 parties pour le training et

un pour le jeu de test

deacutecoupons nos donneacutees (8020 split)

indices = StratifiedKFold(iristarget n_folds=5)


Extrayons les donneacutees drsquoentrainement

prenons la premiegravere partie


Extrayons les donneacutees drsquoentrainement et leur labels



Extrayons les donneacutees de test et leurs labels



Extrayons le nombre de classes des donneacutees


Construisons un GMM avec les paramegravetres comme cela

n_components speacutecifie le nombre de composants dans la distribution ce sera le nombre de

classes de nos donneacutees Nous devons indiquer le type de covariance ici full covariance

Le paramegravetre init_params deacutecrit les paramegravetres agrave modifier pendant lrsquoentrainement ici nous

utiliserons wc qui signifie weights and covariance (poids et covariance) qui seront modifieacutees

pendant lrsquoentrainement

Le paramegravetre n_iter repreacutesente le nombre drsquoiteacuterations drsquoExpectation-Maximization qui seront faites

construisons notre GMM

classifier = GMM(n_components=num_classes covariance_type=fullinit_params=wc n_iter=20)


Initialisons les moyennes du classificateur GMM

classifiermeans_ = nparray([X_train[y_train == i]mean(axis=0)

for i in range(num_classes)])

Train the Gaussian mixture model classifier using the training data



Visualisons les frontiegraveres du classificateur Nosu extraierons les valeurs propres et vecteurs

propres aussi appeleacutes eigenvalues et les eigenvectors

Pour estimer comment dessiner les frontiegraveres elliptiques autour des clusters

httpswwwmathhmceducalculustutorialseigenstuff Ou

httpsfrwikipediaorgwikiValeur_propre_vecteur_propre_et_espace_propre pour plus drsquoinfos

sur les vecteurs et valeurs propres

continuons

dessinons les frontiegraveres

pltfigure()

colors = bgr


Extrayons les eigenvalues et eigenvectors

eigenvalues eigenvectors = nplinalgeigh(classifier_get_covars()[i][2 2])

Normalisons le premier vecteur propre



Les ellipses doivent ecirctre tourneacutees pour montrer la distribution

estimons lrsquoangle



Agrandissons les ellipses pour els visualiser Les vecteurs ppropres deacuteteminent la

taille des ellipses

facteur drsquoagrandissement des ellipses

(valeur au hasard pour nos besoins ici)

scaling_factor = 8


dessinons les ellipses


eigenvalues[0] eigenvalues[1] 180 + angle

color=color)






Mettons tout ceci sur le scheacutema de deacutepart

dessinons les donneacutees

colors = bgr



pltscatter(cur_data[0] cur_data[1] marker=o

facecolors=none edgecolors=black s=40

label=iristarget_names[i])

Mettons ceci sur le mecircme scheacutema


pltscatter(test_data[0] test_data[1] marker=s

facecolors=black edgecolors=black s=40


Calculons les preacutedictions des donneacutees de training et de test








pltxticks(())

pltyticks(())

pltshow()


EXERCICE 21 Market classification

Exercice21 market classification Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p120

import csv

import numpy as np




input_file = salescsvlsquo

file_reader = csvreader(open(input_file r) delimiter=)

X = []

for count row in enumerate(file_reader)

if not count

names = row[1]

continue

Xappend([float(x) for x in row[1]])

Convert to numpy arrayX = nparray(X)

Estimating the bandwidth of input data

bandwidth = estimate_bandwidth(X quantile=08 n_samples=len(X))

Compute clustering with MeanShift

meanshift_model = MeanShift(bandwidth=bandwidth bin_seeding=True)


labels = meanshift_modellabels_cluster_centers = meanshift_modelcluster_centers_num_clusters = len(npunique(labels))


print(nCenters of clusters)

print(tjoin([name[3] for name in names]))

for cluster_center in cluster_centers

print(tjoin([str(int(x)) for x in cluster_center]))

Extract two features for visualization

cluster_centers_2d = cluster_centers[ 13]

Plot the cluster centers

pltfigure()

pltscatter(cluster_centers_2d[0] cluster_centers_2d[1] s=120 edgecolors=black facecolors=none)offset = 025

pltxlim(cluster_centers_2d[0]min() - offset cluster_centers_2d[0]ptp() cluster_centers_2d[0]max() + offsetcluster_centers_2d[0]ptp())

pltylim(cluster_centers_2d[1]min() - offset cluster_centers_2d[1]ptp() cluster_centers_2d[1]max() + offset cluster_centers_2d[1]ptp())

plttitle(Centers of 2D clusters)

pltshow()


Segmentation marcheacute en utilisant des patterns de shopping

Rergardons comment on pourrait utiliser des techniques drsquoapprentissage non superviseacute

pour augmenter les segmetns de marcheacute en se basant sur les habitudes drsquoachat

Dans le fichier salescsv vous avez les ventes de top

TshirtTank top (deacutebardeur) Halter topTurtleneckTube topSweater

de magasins drsquohabits Nous voulons identifier les scheacutemas et segment de marcheacute

selon les ventes de ces magasins


Creacuteons un nouveau fichier Python et importons les packages

import csv

import numpy as np



importons la donneacutee salescsv agrave convertir en NumPy array

input_file = salescsv


X = []


if not count

names = row[1]

continue


Convertissons en numpy array

X = nparray(X)


Estimons la bande passante des donneacutees drsquorsquoentreacutee


Entrainons un modegravele mean shift baseacute sur la bande passante estimeacutee

calculons le clustering avec MeanShift



Extrayons les labels et les centres de chaque cluster



Print the number of clusters and the cluster centers






Nous avons des donneacutees en 6 dimensions pour les visualiser nous nrsquoen prendrons

que deux avec la 2de et 3eme dimensions

Extrayons les deux features de visualisation



Dessinons les centres des clusters

pltfigure()

pltscatter(cluster_centers_2d[0] cluster_centers_2d[1]

s=120 edgecolors=black facecolors=none)

offset = 025

pltxlim(cluster_centers_2d[0]min() - offset

cluster_centers_2d[0]ptp()

cluster_centers_2d[0]max() + offset

cluster_centers_2d[0]ptp())

pltylim(cluster_centers_2d[1]min() - offset







EXERCICE 22 training pipeline

Exercice22 training pipeline Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p120

from sklearndatasets import samples_generator

from sklearnfeature_selection import SelectKBest f_regression

from sklearnpipeline import Pipeline


Generate data

X y = samples_generatormake_classification(n_samples=150 n_features=25 n_classes=3 n_informative=6

n_redundant=0 random_state=7)

Select top K features

k_best_selector = SelectKBest(f_regression k=9)

Initialize Extremely Random Forests classifier

classifier = ExtraTreesClassifier(n_estimators=60 max_depth=4)

Construct the pipeline

processor_pipeline = Pipeline([(selector k_best_selector) (erf classifier)])

Set the parameters

processor_pipelineset_params(selector__k=7 erf__n_estimators=30)

Training the pipeline processor_pipelinefit(X y)

Predict outputs for the input data

output = processor_pipelinepredict(X)

print(nPredicted outputn output)

Print scores print(nScore processor_pipelinescore(X y))

Print the features chosen by the pipeline selector

status = processor_pipelinenamed_steps[selector]get_support()

Extract and print indices of selected features

selected = [i for i x in enumerate(status) if x]

print(nIndices of selected features join([str(x) for x in selected]))


Creeacuter un training pipeline

Les systegravemes de Machine-learning sont geacuteneacuteralement faits en utilisant diffeacuterents

modules Ces modules sont combineacutes pour atteindre leur but

La librairie de scikit-learn a des fonctions qui eprmettent de construire ces pipelines en

concateacutenant divers modules

Nous devons speacutecifier les modules avec divers paramegravetres Cela construira un pipeline

utilisant ces modules qui processent les donneacutees et entrainent le systegraveme

Le modegravele peut inclure divers modules comme feature selection preprocessing

random forests clustering etc

Dans ce chapitre on construira un pipeline pour selectionner les top K features depuis

des donneacutees drsquoentreacutee et de les classifier en utilisant un classificateur Extremely

Random Forest


Creacuteons un fichier Python et importons les packages





Geacuteneacuterons des donneacutees pour lrsquoentrainement et le test

Nous creacuteerons 150 points de donneacutees chacune avec 25

dimensions de features Chaque poitna 6 points de feautres non

redondants


Generons la donneacutee

X y = samples_generatormake_classification(n_samples=150

n_features=25 n_classes=3 n_informative=6


Le premier bloc du pipeline est le selecteur de feature Ce block

selectionnes les K meilleurs features

Regardons les valeurs pour K jusqursquoagrave 9



Le bloc suivant du pipeline est un classificateur Extremely

Random Forests avec 60 estimateurs et une profondeur

maximales de 4

Initialisons le classificateur Extremely Random Forests



Construisons le pipeline en joignat les blocs construits numeacuterotons-les

Construisons le pipeline

processor_pipeline = Pipeline([(selector k_best_selector) (erfclassifier)])

On peut modifier les paramegravetres des blocs individuels

Modifions agrave la valeur de K agrave 7 et et le nombre drsquoestiamteurs agrave 30 du second

bloc

mettons les parametres


Entrainons le pipeline en utilisant la donneacutee geacuteneacutereacutee

processor_pipelinefit(X y)

Predisons les output pour chaque valeur drsquoinput values et imprimons-les




Calculons le score en utilisant les donneacutees drsquoentrainement

scores

print(nScore processor_pipelinescore(X y))

Extrayons les features choisis par le bloc selector

Nous avons dit que nous voulions 7 fetaures parmi les 25

imprimons les features choisis par le pipeline selector


Extrayons les indices des features selectionneacutes




EXERCICE 23 extracting nearest neighbors

Exercice23 extracting neirest neighbours Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p128

Les systegravemes de recommandation utilisent les plus proches voisins pour trouver de bonnes recommandations

Les plus proches voisins est un algorithme qui va trouver les points les plus proches sur un set de donneacutees

Creacuteons un Python et importons les packages

import numpy as np


from sklearnneighbors import NearestNeighbors

Definissons un example en deux dimensions

donneacutees drsquoentreacutee

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


Definissons le nombre de voisins que lrsquoon veut extraire

Nombre de plus proches voisins

k = 5

Definissons un poitn test qui sera utiliseacute pour extraire les plus proches voisins

Test datapoint

test_datapoint = [43 27]

Dessinons les donneacutees drsquoinput

pltfigure()


pltscatter(X[0] X[1] marker=o s=75 color=black)

Creacuteons et entrainons un modegravele K Nearest Neighbors utilisant ces points drsquoentreacutee pour extraire les plus proches voisins

construisons le modegravele K Nearest Neighbors

knn_model = NearestNeighbors(n_neighbors=k algorithm=ball_tree)fit(X)

distances indices = knn_modelkneighbors(test_datapoint)


Montrons les plus proches voisins extraits par le modegravele

imprimons les k plus proches voisins

print(nK Nearest Neighbors)

for rank index in enumerate(indices[0][k] start=1)

print(str(rank) + ==gt X[index])

Visualisons les plsu proches voisins

pltfigure()

plttitle(Nearest neighbors)

pltscatter(X[ 0] X[ 1] marker=o s=75 color=k)

pltscatter(X[indices][0][][ 0] X[indices][0][][ 1]

marker=o s=250 color=k facecolors=none)

pltscatter(test_datapoint[0] test_datapoint[1]

marker=x s=75 color=k)

pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])

Number of nearest neighbors

k = 5

Test datapoint


Plot input data

pltfigure()



Build K Nearest Neighbors model



Print the k nearest neighbors




Visualize the nearest neighbors along with the test datapoint

pltfigure()



pltscatter(X[indices][0][][ 0] X[indices][0][][ 1]marker=o s=250 color=k facecolors=none)

pltscatter(test_datapoint[0] test_datapoint[1]marker=x s=75 color=k)

pltshow()




EXERCICE 24 fabriquer un nearest neighbors

Exercice24 Knearest neighbours Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p132

Un classificateur K-Nearest Neighbors est un models qui utilise les plus proches voisins pour classifier un point donneacute

Lrsquoalgorithme donne les K plus proches voisins pour identifier la cateacutegorie en regardant la majoriteacute des votes

La valeur de K deacutepend du problegraveme agrave traiter


import numpy as np


import matplotlibcm as cm

from sklearn import neighbors datasets

Chargeons les doneacutenes drsquoentreacutee datatxt Chaque ligne a des donneacutees seacutepareacutees par une virgule et 4 classes

chargeons les donneacutees drsquoentreacutee

input_file = datatxt


X y = data[ -1] data[ -1]astype(npint)



pltfigure()


marker_shapes = v^os

mapper = [marker_shapes[i] for i in y]

for i in range(Xshape[0])

pltscatter(X[i 0] X[i 1] marker=mapper[i]s=75 edgecolors=black facecolors=none)

Definissons le nombre de voisins les plus proches agrave utiliser

Nombre de nearest neighbors

num_neighbors = 12

Definissons la taille de pas de al grille pour visualiser les frontiegraveres du classifcateur

taille du pas

step_size = 001

Creacuteons le modegravele K Nearest Neighbors

classifier = neighborsKNeighborsClassifier(num_neighborsweights=distance)


Entrainons le modegravele en utilsant les donneacutees drsquoentrainement

entrainons le modegravele K Nearest Neighbours

classifierfit(X y)

Creacuteons la grille pour repreacutesenter les frontiegraveres meshgrid



x_values y_values = npmeshgrid(nparange(x_min x_max step_size)

nparange(y_min y_max step_size))

Evaluons le classificateur sur chacun des points de la grille

output = classifierpredict(npc_[x_valuesravel() y_valuesravel()])


Creacuteons des couleurs pour visulaiser

Visualisons les preacutedictions

output = outputreshape(x_valuesshape)

pltfigure()

pltpcolormesh(x_values y_values output cmap=cmPaired)

ajoutons les points drsquoentrainement



Positionnons les limites X et Y et le titre

pltxlim(x_valuesmin() x_valuesmax())

pltylim(y_valuesmin() y_valuesmax())

plttitle(K Nearest Neighbors classifier model boundaries)


Definissons un poitnde test pour regarder le classificateur

Creacuteons un scheacutema avec les donneacutees drsquoentrainement et le poitn de test

Test input datapoint


pltfigure()

plttitle(Test datapoint)


pltscatter(X[i 0] X[i 1] marker=mapper[i]


pltscatter(test_datapoint[0] test_datapoint[1] marker=x

linewidth=6 s=200 facecolors=black)


Extrayons les plus proches voisins du poitn de test selon le modegravele

Extrayons les K nearest neighbors

_ indices = classifierkneighbors([test_datapoint])

indices = indicesastype(npint)[0]

dessinons les nearest neighbors

pltfigure()

plttitle(K Nearest Neighbors)

for i in indices

pltscatter(X[i 0] X[i 1] marker=mapper[y[i]]linewidth=3 s=100 facecolors=black)


Ajoutons les points de test



Aux donneacutees drsquoentreacutee




Dessinons les predictions

print(Predicted output classifierpredict([test_datapoint])[0])

pltshow()





EXERCICE 25 scores de similariteacute

Exercice25 scores de similariteacute Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p139

Dans le but de construire un systegraveme de recommandation il faut pouvoir comparer les diffeacuterents objets de nos donneacutees

Dans notre set de deacuteonnes on va avoir des personnes et leurs preacutefeacuterences de films de cineacutema

Comment comparer deux personnes entre elles Nous utiliserons le score de similariteacute cela nous donnera une ideacutee de combien lsquosimilairesrsquo ces deux objets

Nous utilisons geacuteneacuteralement deux score la distance Euclidienne que lrsquoon convertira pour ecirctre entre 0 et 1 (ne large distance euclidienne donnera un score proche de 0)

Le score de Pearson mesure la correlation entre deux objets utilisant la covariance entre deux objets et leur deacuteviations standard cela va de -1 agrave +1 +1 quand les objets sont tregraves similaires et -1 quand ils sont tregraves eacuteloigneacutes0 indique pas de correacutelation



import argparse

import json

import numpy as np

Construisons un argument parser pour les input


parser = argparseArgumentParser(description=Compute similarity score)

parseradd_argument(--user1 dest=user1 required=False default=David Smith modif REeneacute help=First user)

parseradd_argument(--user2 dest=user2 required=False default=Bill Duffy modif RE help=Second user)

parseradd_argument(--score-type dest=score_type required=Falsedefault=Euclidean modif RE choices=[Euclidean Pearson] help=Similarity metric to be used)

return parser

Definissons une fonction qui calcule le score entre deux utilisateurs

def euclidean_score(dataset user1 user2)

if user1 not in dataset

raise TypeError(Cannot find + user1 + in the dataset)




Definissons une variable pour tracker les films noteacutes par les deux utilisateurs

common_movies =

Extrayons les films noteacutes par les deux utilisateurs

for item in dataset[user1]

if item in dataset[user2]

common_movies[item] = 1

Si aucun film en commun on ne peut pas calculer de score de similariteacute le score est 0

if len(common_movies) == 0

return 0

Calculons les diffeacuterences au carreacute entre els notes et calculons la distance Euclidienne

squared_diff = []



squared_diffappend(npsquare(dataset[user1][item] -dataset[user2][item]))

return 1 (1 + npsqrt(npsum(squared_diff)))


Definissons une fonction pour calculer le score de Pearson entre les utilisateurs

def pearson_score(dataset user1 user2)





Definissons une variable pour tracer les films noteacutes par les deux utilisateurs

common_movies =





Srsquoil nrsquoy a aps de film commun noteacute alors on ne pourra pas calculer de score de similariteacute

num_ratings = len(common_movies)

et le score sera 0

if num_ratings == 0

return 0


Calculons la somme des notes de tous les films noteacutes par les deux utilisateurs

user1_sum = npsum([dataset[user1][item] for item in common_movies])


Calculons la somme des carreacutee des notes des films noteacutes par les deux utilisateurs user1_squared_sum = npsum([npsquare(dataset[user1][item]) for item in

common_movies])

user2_squared_sum = npsum([npsquare(dataset[user2][item]) for item in common_movies])

Calculons la somme des produits des notes des films noteacutes par les deux utilisateurs

sum_of_products = npsum([dataset[user1][item] dataset[user2][item] for item in common_movies])


Calculons les divers paramegravetres requis pour le score de Pearson

Sxy = sum_of_products - (user1_sum user2_sum num_ratings)

Sxx = user1_squared_sum - npsquare(user1_sum) num_ratings

Syy = user2_squared_sum - npsquare(user2_sum) num_ratings

Srsquoil nrsquoy a pas de deviation alors le score est 0

if Sxx Syy == 0

return 0

Donner le score de Pearson

return Sxy npsqrt(Sxx Syy)


Definissons les fonctions main et parsons les arguments en entreacutee



user1 = argsuser1

user2 = argsuser2

score_type = argsscore_type

Chargeons les notes dans un fichier ratingsjson dans un dictionnaire

ratings_file = ratingsjson

with open(ratings_file r) as f

data = jsonloads(fread())

Calculons le score de similariteacute baseacute sur les donneacutees drsquoinput

if score_type == Euclidean

print(nEuclidean score)

print(euclidean_score(data user1 user2))

else

print(nPearson score)

print(pearson_score(data user1 user2))

EXERCICE 26 filtrage collaboratif

Exercice26 filtrage collaboratif Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p143

Le filtrage collaboratif permet d identifier des patterns dans le set de donneacutees afin de faire des deacutecisions concernant un nouvel objet Dans le contexte de moteur de recommandation on va chercher des utilisaterus similaires du dataset

En collectant les preacutefeacuterences de diffeacuterents utilisateurs on fait collaborer cette information pour filtrer les utilisateurs

On suppose cii que si deux personnes ont des notes similaires sur certains films alors leurs choix sur des films inconnus seront aussi similaires

Ceci est utiliseacute avec de grandes bases de donneacutees dans des domaines tels que al finnace le shopping online les eacutetudes clientshellip



import argparse

import json

import numpy as np

from compute_scores import pearson_score

Definissons une fonction pour parser les arguments drsquoentreacutee


parser = argparseArgumentParser(description=Find users who are similar to the input user)

parseradd_argument(--user dest=user required=False default=Clarissa Jackson modif RE

help=Input user)

return parser

Definissons une fonction pour deacuteterminer les utilisateurs qui sont simillaires agrave un utilisateur donneacute

def find_similar_users(dataset user num_users)

if user not in dataset

raise TypeError(Cannot find + user + in the dataset)


Nous avons deacutejagrave importeacute la fonction du score de Pearson calculons le score de Pearson

Calculons le score de Pearson entre lrsquoutilisateur et tous les utilisateurs du jeu de donneacutees

scores = nparray([[x pearson_score(dataset userx)] for x in dataset if x = user])

Classons les scores en ordre deacutecroissant

scores_sorted = npargsort(scores[ 1])[-1]

Extrayons les scores des top users

top_users = scores_sorted[num_users]

return scores[top_users]


Definissons la fonction main function et parsons les arguments drsquoentreacutee



user = argsuser

Chargeons la donneacutee depuis les notes de film dans le fichier file ratingsjson




Trouvons les top 3 utilisateurs qui sont similaires agrave lrsquouser speacutecifieacute dans les donneacutees drsquoinput

print(nUsers similar to + user + n)

similar_users = find_similar_users(data user 3)

print(UsertttSimilarity score)

print(-41)

for item in similar_users

print(item[0] tt round(float(item[1]) 2))


EXERCICE 27 recommandation de films

Exercice27 recommandation de films Data SVMPrateek Joshi Artificial intelligence with Python bookpdf Chapter 3 p146

Maintenant que lrsquoon a tous les blocs en place nous pouvons faire un systegraveme de recommandation de films

On reprend le fichier ratingsjson ougrave se trouvent des personnes et leur notes de films

Creacuteons un nouveau fichier Python avec les packages

import argparse

import json

import numpy as np


from collaborative_filtering import find_similar_users



parser = argparseArgumentParser(description=Find the movie recommendations for the given user)

parseradd_argument(--user dest=userrequired=False default=Julie Hammel modif RE

help=Input user)

return parser


Definissons une fonction pour faire al recommandation de film pour un utilisateur donneacute

donner la reco pour un utilisateur donneacute

def get_recommendations(dataset input_user)

if input_user not in dataset

raise TypeError(Cannot find + input_user + in the dataset)

Definissons les variables pour noter les the scores

overall_scores =

similarity_scores =

Calculons le score de similariteacute entre lrsquoutilisateur entreacute et les autres de la base de donneacutees

for user in [x for x in dataset if x = input_user]

similarity_score = pearson_score(dataset input_user user)

Si le score de similariteacute est moisn de 0 on continue avec le prochain utilisteur

if similarity_score lt= 0

continue

Extrayons une liste de films qui ont eacuteteacute noteacutes par lrsquoutilisateur courant mais pas lrsquoutilsateur drsquoentreacutee

filtered_list = [x for x in dataset[user] if x not in dataset[input_user] or dataset[input_user][x] == 0]


Pour chaque film de la liste de filtrage gardons une trace des notes pondeacutereacutees baseacutees sur la similariteacute Gardons aussi une trace des scores de similariteacute

for item in filtered_list

overall_scoresupdate(item dataset[user][item] similarity_score)

similarity_scoresupdate(item similarity_score)

Si il nrsquoy a pas de film alors on ne peut pas recommander

if len(overall_scores) == 0

return [No recommendations possible]

Normalisons les scores baseacutes sur les scores pondeacutereacutes

movie_scores = nparray([[scoresimilarity_scores[item] item] for item score in overall_scoresitems()])


Classons les scores et extrayons les recommandations de films

par ordre deacutecroissant

movie_scores = movie_scores[npargsort(movie_scores[ 0])[-1]]

Extrayons les recommandations de films

movie_recommendations = [movie for _ movie in movie_scores]

return movie_recommendations

Definissons la fonction main function et parsons les arguments



user = argsuser

Chargeons les notes de films depuis ratingsjson





print(nMovie recommendations for + user + )

movies = get_recommendations(data user)

for i movie in enumerate(movies)

print(str(i+1) + + movie)


httpswwwyoutubecomwatchv=JGgT7

L7wKQM

machine learning

bullDEEP LEARNING

Annexe deep learning httpswwwyoutubecomwatchv=og5m7f1senoamplist=PLpEPgC7cUJ4b1ARx8PyIQa_sdZRL2GXw5

Deep learning apprentissage profond la machine apprend elle-mecircme

comment apprendre

On peut modeacuteliser cela par des regravegles si cette

case est remplie par un rond alors je joue ici

Ici 1919 cases du coup plus

complexe et selon la

strateacutegie de lrsquoadversaire on

va essayer de jouer

autrement

Deep learning reacutesoudre des tacircches faciles agrave faire pour les gens mais difficiles agrave

deacutecrire formellement

Qursquoest-ce que crsquoest

Un chat

Pourquoi crsquoest un chat

Pas de formule matheacutematique toute becircte pour

dire que crsquoest un chat



comment apprendre

On va donner des millions drsquoimages de chat et de chiens en disant crsquoest un

chat un chien


Udacity scikit-learn openclassroomhellipand co

httpsopenclassroomscomfrcourses4011851-initiez-vous-

au-machine-learning

httpsopenclassroomscomfrcourses4379436-explorez-

vos-donnees-avec-des-algorithmes-non-supervises

httpwwwxavierduprefrappensae_teaching_cshelpsphinx

notebooks_gs2a_ml_basehtml

httpsjakevdpgithubioPythonDataScienceHandbook

httpsfutureoflifeorgbackgroundbenefits-risks-of-artificial-

intelligence

httpwwwxavierduprefrappactuariat_pythonhelpsphinxno

tebooksseance4_projection_population_correctionhtml

httpsmakina-corpuscomblogmetier2017initiation-au-

machine-learning-avec-python-pratique

Avant propos ce cours regroupe des

informations et exercices venant des

sites udacity openclassroom ens

makina corpus sklearn et du livre de

Prateek Joshi et surtout celui de

ChloeAgathe Azencott

Toutes vos reacutefeacuterences nous seront

inteacuteressantes remontez-les nous




cas la voici










lrsquoinfo


suivant

Slide de correction




EXERCICE GOOGLE CAR


httpsscikit-






seul























drsquoautre


Google car




dans cet exercice


Google car


([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])



([1 1 1 2 2 2])



Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car









Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car









Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car



capteurs )





correction



thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps


frein


correction



frein








quelque part

Google car










[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car


une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car




[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici



correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car







deacutecision)







Google car




gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])




gtgtgt clffit(X Y)



[1]







gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])


(comme Y=f(X)=










gtgtgt clffit(X Y)





[1]



correction











machine learning

bullLOI NORMALE








bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5





bull Pour n = 1








16

1 2 3 4 5 6

Correction n=1










1 2 3 4 5 6 7 8 9 10 11 12

correction










1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction




correction








de Galton








httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction




Exercice qui

reconnaissez-vous

sur ces photos


















correction

machine learning


















Bayes

correction













correction














(ils ne sont que 2)



correction























correction










correction







ndash

correction

Quizz1










choix

EXERCICE LOYERS
















drsquoentreacutee













pltxticks(())

pltyticks(())

pltshow()





print(data)



print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()






regressorfit(X y)





def predict(x)






pb avec taille de X



def predict(x)







pltxticks(())

pltyticks(())


pltshow()



import numpy as np

import pandas as pd












print(theta)



pltxlabel(Surface)

pltylabel(Loyer)




c=000000)

pltshow()


regr =





Exercice






Et pour 50m2

Et pour 200m2


Pourquoi


pas











30100+2943 = 32943 (eurosmois)








correction





Voici












Commentez





import numpy as np


X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)


a = regscore(X y)


b=regcoef_


c =regintercept_




correction



correction



Y = X[0] + 200X[1] + 300



machine learning






Dans wikipedia











lineacuteaire
















etiquettes
















beta





de Bayes )
















































produit matriciel



devient








CQFD





machine learning


calculer

- la moyenne des x

- la moyenne des y


au carreacute)

- la variance de y



covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)



moyennes




datavisualisation



ednumpystdhtml

datavisualisation


un scheacutema


datavisualisation

correction




import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs




correction





totalement hands-on


pratique

et




et de scikit learn








bull Mais aussi

bull SVM

bull KNN

bull PCA













de la discipline


transfert

Les algorithmes

















exemples












disposition


Les donneacutees







cas


chaicircnes




Exercice












bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])






Correction



gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])



gtgtgt npshape(a)

(4)


npshape(b)


Correction







pyplotplot([1 2 3 6] [1 4 9 36])










pyplotylim(0 5)









gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])




import numpy as np





Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)


pltpcolor(X Y Z)

pltshow()




o rond




eacutetoile

D losange (diamond)



p pentagone

point





Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]








import numpy as np



print a

print n


print aravel()

print n





[[0 1 2 3]

[4 5 6 7]]


[0 1 2 3 4 5 6 7]







Preacutediction









superviseacute



superviseacute










pourrez trouver













observation












print(type(iris))


pour un Pythoniste



print(dir(iris))







print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])



iris de la base






petal width (cm)]


array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])





sepale 3 cm











Correction




Correction





diris







target = iristarget


print(target)



enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]










correction





target = iristarget


for i in [012]






correction



donneacutees iris






data


fleur




correction


print(irisDESCR)
























correction



matplotlib inline



import numpy as np













Leacutegende






pltplot()


orgapi_as_gen

matplotlibpyplots

ubplothtml





algo dessus)











import pandas as pd

snsset()


df[target] = target


dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats




Exercice Quelle

classification


tecircte raquo





espegraveces


drsquoalgo


cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage













Apprentissage



clf = GaussianNB()

Apprentissage

clffit(data target)


print(dir(clf))





clfget_params()

priors None

correction

Apprentissage





Apprentissage



result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])




correction





le cas









le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])





erreurs 6








correction





pas




confusion_matrix












095999999999999996




conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])




autre




sont pas en vrai

correction


correction






Lon observe ici que
































(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)






correction

Model selection



jeu de test



Il faut importer

train_test_split



httpsscikit-





correction


Model selection










data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction





clf = GaussianNB()




Score



094666666666666666



conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction










chaque point)


data = irisdata[ 2]

target = iristarget

data[5]


array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])


clf = GaussianNB()

clffit(data target)



h = 15










x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])






array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])



yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])


a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])



list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]


data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]









pltfigure(1)



c=target)
















pltfigure(1)











KN








interact(n=(020))

def n_change(n=5)


clffit(data target)


pltfigure(1)











fonction de N


iristarget[2]


iristarget[12]

result = []


for n in n_values


(n_neighbors=n)




target_test)

resultappend(score)





optimaux












array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque












1

Une seule erreur




































originaux

PCA

irisdata[5]


array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])


reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()




dfhead()

PCA





pltxlabel(PCA1)

pltylabel(PCA2)







existent















Preacutediction





df[group] = groups


fit_reg=False)









bull Mais aussi

bull SVM

bull KNN

bull PCA













Tout drsquoabord


Iris








gtgtgt datashape

(150 4)

correction


IRIS donneacutees






[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target








array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])



correction

IRIS visualisation







seacutepales





IRIS visualisation







correction

IRIS visualisation





data = irisdata

target = iristarget

Une nouvelle figure






plttight_layout()

pltshow()

correction





largeur des sepales




data = irisdata[ 2]

target = iristarget

correction





chacun







une frontiegravere)













correction








clffit(data target)

correction










correction













pltclf()






pltshow()

correction






pour le svm


Pour le naive bayes








clf =GaussianNB()

correction





data = irisdata

datashape


target = iristarget






pltshow()


GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))





accuracy_score


correction

avec knn


clf2 =


Apprentissage


print(dir(clf2))





target))

avec svm



OneVsOneClassifier

clf3 =


dom_state=0))





target))

on va dessiner cela


data = irisdata[ 2]

target = iristarget

h = 02





clf


e=0))

clf =GaussianNB()

clffit(data target)




y_max]


0]max() + 1


1]max() + 1







pltclf()

pltpcolor(xx yy Z)





pltshow()












correction










correction



matplotlib pyplot





plttitle(avec pca)

pltshow()

correction


correction



gaussian mixture

httpsscikit-



Avec

n_components=3





donneacutees



correction















pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction










import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction




machine learning




Enigmaio


Conclusion





























Diabete Exercice











import numpy as np












correction















correction


The coefficients







Plot outputs



pltxticks(())

pltyticks(())

pltshow()


correction


correction


correction





















exercices













httpsscikit-


essinghtml








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]


correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 3775 -115 -13 ]


Std deviation = [ 312039661 636651396 40620192 ]



mean

Std



correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])


print(nBEFORE)





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])








correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1




data_normalized_l1)



([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2




data_normalized_l2)








plusieurs solutions




[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data




print(nBEFORE)



Remove mean




Min max scaling




Normalize















correction

import numpy as np







Print the mapping



print(item --gt i)








[3 0 4 1]






import numpy as np


Sample input labels





Print the mapping



print(item --gt i)











correction




[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])


0 1 1 1 2 2 2 3 3 3])





httpsscikit-






lsquofortersquo






machine learning




















particulier










Avec C=900


import numpy as np











mesh_step_size))





Create a plot

pltfigure()











pltshow()


p37

import numpy as np





X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])





classifierfit(X y)

on le visualise











et pour visualiser











import numpy as np













classifierfit(X y)

et visualisons le




p41





predict


performant



preacutedictions









round(accuracy 2) )


visulize_classifier


machine learning










































2 p41

Cross validation



test_size=02)


test_size=02)







on visualise









Precision


Recall



F1 Score





num_folds = 3









machine learning

bullSCORING








Precision et Recall




Precision




Recall




F1 Score

Wikipedia




import numpy as np










print(XestX[5])

print(y esty[5])

print(y)



classifierfit(X y)



Compute accuracy

















Scoring functions

num_folds = 3












score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np





true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]











pltshow()




EXERCICE 6 SVM























import numpy as np









Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0









Combien au-dessus



la ligne[-1]


par an de salaire



(USD)




break

if in line

continue



Xappend(data)

count_class1 += 1


Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)



creacuteer un









classifierfit(X y)



label_encoders = []



if itemisdigit()


else












classifierfit(X y)











test X_test











classifier =
















count = 0


if itemisdigit()


else


count += 1











count = 0


if itemisdigit()


else


count += 1






machine learning

bullSVM













support

Annexe SVM



Annexe SVM

EXERCICE 7 SVM IRIS



classificateur SVM




datasetsload_iris()












pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


reshtml


import numpy as np






X = irisdata[ 2]

y = iristarget


h = 02























pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


sSVMLineaireshtml



sSVMLineaireshtml




import pickle

import numpy as np



























pltxticks(())

pltyticks(())

pltshow()













on le charge








import numpy as np






Read data






Training


Test data






Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()








Model persistence


Save the model



Load the model













import numpy as np























))

















diffeacuterence

datapoint = [[775 635 556]]




















Training data


Test data






Predict the output


Measure performance










datapoint = [[775 635 556]]













import numpy as np



























test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]


machine learning

bullVARIANCE

Annexe variance



understandinghl=fr



y_true = [3 -05 2 7]

y_pred = [25 00 2 8]


y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]














machine learning

bullPERTES

Annexe pertes



Annexe pertes















rouges dans le

graphique de gauche


celles de lautre








gauche

Vous vous demandez






significative




dexemples

ougrave








bull




















Load housing data


Shuffle the data


















test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]







httpwwwgrappauniv-

















pltfigure()






















print(n + 40)





print(40 + n)

pltshow()


machine learning

bullDECISION TREES








Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui



Š 1Construction





age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes




age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes


Correction














I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n



p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n




age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971


5

14

5

I(23)+

4

14

I(40)


Œ De mecircme

+ I(32)= 069 14


Gain(income) = 0029








eacutelagueacute









drsquoapprentissage





machine learning




y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]










Load input data






















print(n + 40)





print(40 + n)

pltshow()





Avec type rf

Avec type erf


import numpy as np







Argument parser





return parser





Load input data




print(X) print(y)






pltfigure()











else








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

Compute confidence










pltshow()





import argparse

import numpy as np














return parser











print(X)

print(y)







pltfigure()





















else














print(n + 40)




print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)














datapoints)

pltshow()










import numpy as np






Load input data








pltfigure()











else









print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()





import sys

import numpy as np
















pltfigure()
























print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced




Avec le balanced







import numpy as np















donneacutees tests


random_state=5)







n_estimators [25 50 100 250]





classifier =















import numpy as np






Load input data










































































on arrange les X



pltfigure()




pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor















Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans











uns aux autres



cas










import numpy as np







ici 5

num_clusters = 5


pltfigure()







pltxticks(())

pltyticks(())















kmeansfit(X)


ils sont mis


step_size = 001





step_size))






pltfigure()

pltclf()














pltxticks(())

pltyticks(())

pltshow()




import numpy as np





num_clusters = 5











kmeansfit(X)


step_size = 001








pltfigure()

pltclf()











pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS




donneacutees





distance aux points








donne pas de nouvel











import numpy as np
























markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift









densiteacute




















meme cluster





paquets



import numpy as np



























pltfigure()

markers = oxvs




color=black)





markersize=15)

plttitle(Clusters)

pltshow()





import numpy as np







pltfigure()






pltxticks(())

pltyticks(())







kmeansfit(X)




scoresappend(score)


scorespltfigure()






pltshow()















cluster






nombre optimal




import numpy as np










scores = []







kmeansfit(X)







scoresappend(score)



pltfigure()










pltfigure()







pltxticks(())

pltyticks(())

pltshow()






import numpy as np











Take the first fold















Draw boundaries












scaling_factor = 8


Draw the ellipse







Plot the data

colors = bgrlsquo














pltxticks(())

pltyticks(())

pltshow()
































import numpy as np

















































continuons


pltfigure()

colors = bgr












taille des ellipses



scaling_factor = 8





color=color)








colors = bgr



















pltxticks(())

pltyticks(())

pltshow()




import csv

import numpy as np






X = []


if not count

names = row[1]

continue

















pltfigure()





pltshow()











import csv

import numpy as np






X = []


if not count

names = row[1]

continue



X = nparray(X)























pltfigure()



offset = 025


















Generate data









Set the parameters
























Random Forest










redondants













maximales de 4









bloc










scores















import numpy as np





X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])




k = 5


Test datapoint



pltfigure()














pltfigure()







pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


k = 5

Test datapoint


Plot input data

pltfigure()











pltfigure()





pltshow()










import numpy as np











pltfigure()








num_neighbors = 12


taille du pas

step_size = 001






classifierfit(X y)












pltfigure()














pltfigure()













pltfigure()


for i in indices












pltshow()














import argparse

import json

import numpy as np







return parser









common_movies =







return 0


squared_diff = []













common_movies =







et le score sera 0

if num_ratings == 0

return 0






common_movies])










if Sxx Syy == 0

return 0







user1 = argsuser1

user2 = argsuser2










else











import argparse

import json

import numpy as np






help=Input user)

return parser


















user = argsuser









print(-41)









import argparse

import json

import numpy as np







help=Input user)

return parser








overall_scores =

similarity_scores =






continue























user = argsuser












L7wKQM

machine learning

bullDEEP LEARNING



comment apprendre






va essayer de jouer

autrement




Un chat






comment apprendre


chat un chien





cas la voici










lrsquoinfo


suivant

Slide de correction




EXERCICE GOOGLE CAR


httpsscikit-






seul























drsquoautre


Google car




dans cet exercice


Google car


([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])



([1 1 1 2 2 2])



Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car









Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car









Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car



capteurs )





correction



thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps


frein


correction



frein








quelque part

Google car










[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car


une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car




[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici



correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car







deacutecision)







Google car




gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])




gtgtgt clffit(X Y)



[1]







gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])


(comme Y=f(X)=










gtgtgt clffit(X Y)





[1]



correction











machine learning

bullLOI NORMALE








bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5





bull Pour n = 1








16

1 2 3 4 5 6

Correction n=1










1 2 3 4 5 6 7 8 9 10 11 12

correction










1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction




correction








de Galton








httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction




Exercice qui

reconnaissez-vous

sur ces photos


















correction

machine learning


















Bayes

correction













correction














(ils ne sont que 2)



correction























correction










correction







ndash

correction

Quizz1










choix

EXERCICE LOYERS
















drsquoentreacutee













pltxticks(())

pltyticks(())

pltshow()





print(data)



print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()






regressorfit(X y)





def predict(x)






pb avec taille de X



def predict(x)







pltxticks(())

pltyticks(())


pltshow()



import numpy as np

import pandas as pd












print(theta)



pltxlabel(Surface)

pltylabel(Loyer)




c=000000)

pltshow()


regr =





Exercice






Et pour 50m2

Et pour 200m2


Pourquoi


pas











30100+2943 = 32943 (eurosmois)








correction





Voici












Commentez





import numpy as np


X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)


a = regscore(X y)


b=regcoef_


c =regintercept_




correction



correction



Y = X[0] + 200X[1] + 300



machine learning






Dans wikipedia











lineacuteaire
















etiquettes
















beta





de Bayes )
















































produit matriciel



devient








CQFD





machine learning


calculer

- la moyenne des x

- la moyenne des y


au carreacute)

- la variance de y



covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)



moyennes




datavisualisation



ednumpystdhtml

datavisualisation


un scheacutema


datavisualisation

correction




import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs




correction





totalement hands-on


pratique

et




et de scikit learn








bull Mais aussi

bull SVM

bull KNN

bull PCA













de la discipline


transfert

Les algorithmes

















exemples












disposition


Les donneacutees







cas


chaicircnes




Exercice












bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])






Correction



gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])



gtgtgt npshape(a)

(4)


npshape(b)


Correction







pyplotplot([1 2 3 6] [1 4 9 36])










pyplotylim(0 5)









gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])




import numpy as np





Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)


pltpcolor(X Y Z)

pltshow()




o rond




eacutetoile

D losange (diamond)



p pentagone

point





Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]








import numpy as np



print a

print n


print aravel()

print n





[[0 1 2 3]

[4 5 6 7]]


[0 1 2 3 4 5 6 7]







Preacutediction









superviseacute



superviseacute










pourrez trouver













observation












print(type(iris))


pour un Pythoniste



print(dir(iris))







print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])



iris de la base






petal width (cm)]


array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])





sepale 3 cm











Correction




Correction





diris







target = iristarget


print(target)



enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]










correction





target = iristarget


for i in [012]






correction



donneacutees iris






data


fleur




correction


print(irisDESCR)
























correction



matplotlib inline



import numpy as np













Leacutegende






pltplot()


orgapi_as_gen

matplotlibpyplots

ubplothtml





algo dessus)











import pandas as pd

snsset()


df[target] = target


dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats




Exercice Quelle

classification


tecircte raquo





espegraveces


drsquoalgo


cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage













Apprentissage



clf = GaussianNB()

Apprentissage

clffit(data target)


print(dir(clf))





clfget_params()

priors None

correction

Apprentissage





Apprentissage



result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])




correction





le cas









le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])





erreurs 6








correction





pas




confusion_matrix












095999999999999996




conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])




autre




sont pas en vrai

correction


correction






Lon observe ici que
































(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)






correction

Model selection



jeu de test



Il faut importer

train_test_split



httpsscikit-





correction


Model selection










data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction





clf = GaussianNB()




Score



094666666666666666



conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction










chaque point)


data = irisdata[ 2]

target = iristarget

data[5]


array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])


clf = GaussianNB()

clffit(data target)



h = 15










x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])






array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])



yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])


a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])



list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]


data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]









pltfigure(1)



c=target)
















pltfigure(1)











KN








interact(n=(020))

def n_change(n=5)


clffit(data target)


pltfigure(1)











fonction de N


iristarget[2]


iristarget[12]

result = []


for n in n_values


(n_neighbors=n)




target_test)

resultappend(score)





optimaux












array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque












1

Une seule erreur




































originaux

PCA

irisdata[5]


array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])


reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()




dfhead()

PCA





pltxlabel(PCA1)

pltylabel(PCA2)







existent















Preacutediction





df[group] = groups


fit_reg=False)









bull Mais aussi

bull SVM

bull KNN

bull PCA













Tout drsquoabord


Iris








gtgtgt datashape

(150 4)

correction


IRIS donneacutees






[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target








array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])



correction

IRIS visualisation







seacutepales





IRIS visualisation







correction

IRIS visualisation





data = irisdata

target = iristarget

Une nouvelle figure






plttight_layout()

pltshow()

correction





largeur des sepales




data = irisdata[ 2]

target = iristarget

correction





chacun







une frontiegravere)













correction








clffit(data target)

correction










correction













pltclf()






pltshow()

correction






pour le svm


Pour le naive bayes








clf =GaussianNB()

correction





data = irisdata

datashape


target = iristarget






pltshow()


GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))





accuracy_score


correction

avec knn


clf2 =


Apprentissage


print(dir(clf2))





target))

avec svm



OneVsOneClassifier

clf3 =


dom_state=0))





target))

on va dessiner cela


data = irisdata[ 2]

target = iristarget

h = 02





clf


e=0))

clf =GaussianNB()

clffit(data target)




y_max]


0]max() + 1


1]max() + 1







pltclf()

pltpcolor(xx yy Z)





pltshow()












correction










correction



matplotlib pyplot





plttitle(avec pca)

pltshow()

correction


correction



gaussian mixture

httpsscikit-



Avec

n_components=3





donneacutees



correction















pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction










import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction




machine learning




Enigmaio


Conclusion





























Diabete Exercice











import numpy as np












correction















correction


The coefficients







Plot outputs



pltxticks(())

pltyticks(())

pltshow()


correction


correction


correction





















exercices













httpsscikit-


essinghtml








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]


correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 3775 -115 -13 ]


Std deviation = [ 312039661 636651396 40620192 ]



mean

Std



correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])


print(nBEFORE)





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])








correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1




data_normalized_l1)



([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2




data_normalized_l2)








plusieurs solutions




[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data




print(nBEFORE)



Remove mean




Min max scaling




Normalize















correction

import numpy as np







Print the mapping



print(item --gt i)








[3 0 4 1]






import numpy as np


Sample input labels





Print the mapping



print(item --gt i)











correction




[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])


0 1 1 1 2 2 2 3 3 3])





httpsscikit-






lsquofortersquo






machine learning




















particulier










Avec C=900


import numpy as np











mesh_step_size))





Create a plot

pltfigure()











pltshow()


p37

import numpy as np





X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])





classifierfit(X y)

on le visualise











et pour visualiser











import numpy as np













classifierfit(X y)

et visualisons le




p41





predict


performant



preacutedictions









round(accuracy 2) )


visulize_classifier


machine learning










































2 p41

Cross validation



test_size=02)


test_size=02)







on visualise









Precision


Recall



F1 Score





num_folds = 3









machine learning

bullSCORING








Precision et Recall




Precision




Recall




F1 Score

Wikipedia




import numpy as np










print(XestX[5])

print(y esty[5])

print(y)



classifierfit(X y)



Compute accuracy

















Scoring functions

num_folds = 3












score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np





true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]











pltshow()




EXERCICE 6 SVM























import numpy as np









Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0









Combien au-dessus



la ligne[-1]


par an de salaire



(USD)




break

if in line

continue



Xappend(data)

count_class1 += 1


Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)



creacuteer un









classifierfit(X y)



label_encoders = []



if itemisdigit()


else












classifierfit(X y)











test X_test











classifier =
















count = 0


if itemisdigit()


else


count += 1











count = 0


if itemisdigit()


else


count += 1






machine learning

bullSVM













support

Annexe SVM



Annexe SVM

EXERCICE 7 SVM IRIS



classificateur SVM




datasetsload_iris()












pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


reshtml


import numpy as np






X = irisdata[ 2]

y = iristarget


h = 02























pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


sSVMLineaireshtml



sSVMLineaireshtml




import pickle

import numpy as np



























pltxticks(())

pltyticks(())

pltshow()













on le charge








import numpy as np






Read data






Training


Test data






Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()








Model persistence


Save the model



Load the model













import numpy as np























))

















diffeacuterence

datapoint = [[775 635 556]]




















Training data


Test data






Predict the output


Measure performance










datapoint = [[775 635 556]]













import numpy as np



























test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]


machine learning

bullVARIANCE

Annexe variance



understandinghl=fr



y_true = [3 -05 2 7]

y_pred = [25 00 2 8]


y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]














machine learning

bullPERTES

Annexe pertes



Annexe pertes















rouges dans le

graphique de gauche


celles de lautre








gauche

Vous vous demandez






significative




dexemples

ougrave








bull




















Load housing data


Shuffle the data


















test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]







httpwwwgrappauniv-

















pltfigure()






















print(n + 40)





print(40 + n)

pltshow()


machine learning

bullDECISION TREES








Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui



Š 1Construction





age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes




age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes


Correction














I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n



p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n




age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971


5

14

5

I(23)+

4

14

I(40)


Œ De mecircme

+ I(32)= 069 14


Gain(income) = 0029








eacutelagueacute









drsquoapprentissage





machine learning




y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]










Load input data






















print(n + 40)





print(40 + n)

pltshow()





Avec type rf

Avec type erf


import numpy as np







Argument parser





return parser





Load input data




print(X) print(y)






pltfigure()











else








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

Compute confidence










pltshow()





import argparse

import numpy as np














return parser











print(X)

print(y)







pltfigure()





















else














print(n + 40)




print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)














datapoints)

pltshow()










import numpy as np






Load input data








pltfigure()











else









print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()





import sys

import numpy as np
















pltfigure()
























print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced




Avec le balanced







import numpy as np















donneacutees tests


random_state=5)







n_estimators [25 50 100 250]





classifier =















import numpy as np






Load input data










































































on arrange les X



pltfigure()




pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor















Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans











uns aux autres



cas










import numpy as np







ici 5

num_clusters = 5


pltfigure()







pltxticks(())

pltyticks(())















kmeansfit(X)


ils sont mis


step_size = 001





step_size))






pltfigure()

pltclf()














pltxticks(())

pltyticks(())

pltshow()




import numpy as np





num_clusters = 5











kmeansfit(X)


step_size = 001








pltfigure()

pltclf()











pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS




donneacutees





distance aux points








donne pas de nouvel











import numpy as np
























markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift









densiteacute




















meme cluster





paquets



import numpy as np



























pltfigure()

markers = oxvs




color=black)





markersize=15)

plttitle(Clusters)

pltshow()





import numpy as np







pltfigure()






pltxticks(())

pltyticks(())







kmeansfit(X)




scoresappend(score)


scorespltfigure()






pltshow()















cluster






nombre optimal




import numpy as np










scores = []







kmeansfit(X)







scoresappend(score)



pltfigure()










pltfigure()







pltxticks(())

pltyticks(())

pltshow()






import numpy as np











Take the first fold















Draw boundaries












scaling_factor = 8


Draw the ellipse







Plot the data

colors = bgrlsquo














pltxticks(())

pltyticks(())

pltshow()
































import numpy as np

















































continuons


pltfigure()

colors = bgr












taille des ellipses



scaling_factor = 8





color=color)








colors = bgr



















pltxticks(())

pltyticks(())

pltshow()




import csv

import numpy as np






X = []


if not count

names = row[1]

continue

















pltfigure()





pltshow()











import csv

import numpy as np






X = []


if not count

names = row[1]

continue



X = nparray(X)























pltfigure()



offset = 025


















Generate data









Set the parameters
























Random Forest










redondants













maximales de 4









bloc










scores















import numpy as np





X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])




k = 5


Test datapoint



pltfigure()














pltfigure()







pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


k = 5

Test datapoint


Plot input data

pltfigure()











pltfigure()





pltshow()










import numpy as np











pltfigure()








num_neighbors = 12


taille du pas

step_size = 001






classifierfit(X y)












pltfigure()














pltfigure()













pltfigure()


for i in indices












pltshow()














import argparse

import json

import numpy as np







return parser









common_movies =







return 0


squared_diff = []













common_movies =







et le score sera 0

if num_ratings == 0

return 0






common_movies])










if Sxx Syy == 0

return 0







user1 = argsuser1

user2 = argsuser2










else











import argparse

import json

import numpy as np






help=Input user)

return parser


















user = argsuser









print(-41)









import argparse

import json

import numpy as np







help=Input user)

return parser








overall_scores =

similarity_scores =






continue























user = argsuser












L7wKQM

machine learning

bullDEEP LEARNING



comment apprendre






va essayer de jouer

autrement




Un chat






comment apprendre


chat un chien










lrsquoinfo


suivant

Slide de correction




EXERCICE GOOGLE CAR


httpsscikit-






seul























drsquoautre


Google car




dans cet exercice


Google car


([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])



([1 1 1 2 2 2])



Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car









Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car









Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car



capteurs )





correction



thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps


frein


correction



frein








quelque part

Google car










[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car


une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car




[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici



correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car







deacutecision)







Google car




gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])




gtgtgt clffit(X Y)



[1]







gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])


(comme Y=f(X)=










gtgtgt clffit(X Y)





[1]



correction











machine learning

bullLOI NORMALE








bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5





bull Pour n = 1








16

1 2 3 4 5 6

Correction n=1










1 2 3 4 5 6 7 8 9 10 11 12

correction










1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction




correction








de Galton








httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction




Exercice qui

reconnaissez-vous

sur ces photos


















correction

machine learning


















Bayes

correction













correction














(ils ne sont que 2)



correction























correction










correction







ndash

correction

Quizz1










choix

EXERCICE LOYERS
















drsquoentreacutee













pltxticks(())

pltyticks(())

pltshow()





print(data)



print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()






regressorfit(X y)





def predict(x)






pb avec taille de X



def predict(x)







pltxticks(())

pltyticks(())


pltshow()



import numpy as np

import pandas as pd












print(theta)



pltxlabel(Surface)

pltylabel(Loyer)




c=000000)

pltshow()


regr =





Exercice






Et pour 50m2

Et pour 200m2


Pourquoi


pas











30100+2943 = 32943 (eurosmois)








correction





Voici












Commentez





import numpy as np


X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)


a = regscore(X y)


b=regcoef_


c =regintercept_




correction



correction



Y = X[0] + 200X[1] + 300



machine learning






Dans wikipedia











lineacuteaire
















etiquettes
















beta





de Bayes )
















































produit matriciel



devient








CQFD





machine learning


calculer

- la moyenne des x

- la moyenne des y


au carreacute)

- la variance de y



covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)



moyennes




datavisualisation



ednumpystdhtml

datavisualisation


un scheacutema


datavisualisation

correction




import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs




correction





totalement hands-on


pratique

et




et de scikit learn








bull Mais aussi

bull SVM

bull KNN

bull PCA













de la discipline


transfert

Les algorithmes

















exemples












disposition


Les donneacutees







cas


chaicircnes




Exercice












bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])






Correction



gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])



gtgtgt npshape(a)

(4)


npshape(b)


Correction







pyplotplot([1 2 3 6] [1 4 9 36])










pyplotylim(0 5)









gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])




import numpy as np





Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)


pltpcolor(X Y Z)

pltshow()




o rond




eacutetoile

D losange (diamond)



p pentagone

point





Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]








import numpy as np



print a

print n


print aravel()

print n





[[0 1 2 3]

[4 5 6 7]]


[0 1 2 3 4 5 6 7]







Preacutediction









superviseacute



superviseacute










pourrez trouver













observation












print(type(iris))


pour un Pythoniste



print(dir(iris))







print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])



iris de la base






petal width (cm)]


array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])





sepale 3 cm











Correction




Correction





diris







target = iristarget


print(target)



enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]










correction





target = iristarget


for i in [012]






correction



donneacutees iris






data


fleur




correction


print(irisDESCR)
























correction



matplotlib inline



import numpy as np













Leacutegende






pltplot()


orgapi_as_gen

matplotlibpyplots

ubplothtml





algo dessus)











import pandas as pd

snsset()


df[target] = target


dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats




Exercice Quelle

classification


tecircte raquo





espegraveces


drsquoalgo


cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage













Apprentissage



clf = GaussianNB()

Apprentissage

clffit(data target)


print(dir(clf))





clfget_params()

priors None

correction

Apprentissage





Apprentissage



result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])




correction





le cas









le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])





erreurs 6








correction





pas




confusion_matrix












095999999999999996




conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])




autre




sont pas en vrai

correction


correction






Lon observe ici que
































(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)






correction

Model selection



jeu de test



Il faut importer

train_test_split



httpsscikit-





correction


Model selection










data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction





clf = GaussianNB()




Score



094666666666666666



conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction










chaque point)


data = irisdata[ 2]

target = iristarget

data[5]


array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])


clf = GaussianNB()

clffit(data target)



h = 15










x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])






array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])



yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])


a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])



list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]


data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]









pltfigure(1)



c=target)
















pltfigure(1)











KN








interact(n=(020))

def n_change(n=5)


clffit(data target)


pltfigure(1)











fonction de N


iristarget[2]


iristarget[12]

result = []


for n in n_values


(n_neighbors=n)




target_test)

resultappend(score)





optimaux












array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque












1

Une seule erreur




































originaux

PCA

irisdata[5]


array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])


reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()




dfhead()

PCA





pltxlabel(PCA1)

pltylabel(PCA2)







existent















Preacutediction





df[group] = groups


fit_reg=False)









bull Mais aussi

bull SVM

bull KNN

bull PCA













Tout drsquoabord


Iris








gtgtgt datashape

(150 4)

correction


IRIS donneacutees






[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target








array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])



correction

IRIS visualisation







seacutepales





IRIS visualisation







correction

IRIS visualisation





data = irisdata

target = iristarget

Une nouvelle figure






plttight_layout()

pltshow()

correction





largeur des sepales




data = irisdata[ 2]

target = iristarget

correction





chacun







une frontiegravere)













correction








clffit(data target)

correction










correction













pltclf()






pltshow()

correction






pour le svm


Pour le naive bayes








clf =GaussianNB()

correction





data = irisdata

datashape


target = iristarget






pltshow()


GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))





accuracy_score


correction

avec knn


clf2 =


Apprentissage


print(dir(clf2))





target))

avec svm



OneVsOneClassifier

clf3 =


dom_state=0))





target))

on va dessiner cela


data = irisdata[ 2]

target = iristarget

h = 02





clf


e=0))

clf =GaussianNB()

clffit(data target)




y_max]


0]max() + 1


1]max() + 1







pltclf()

pltpcolor(xx yy Z)





pltshow()












correction










correction



matplotlib pyplot





plttitle(avec pca)

pltshow()

correction


correction



gaussian mixture

httpsscikit-



Avec

n_components=3





donneacutees



correction















pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction










import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction




machine learning




Enigmaio


Conclusion





























Diabete Exercice











import numpy as np












correction















correction


The coefficients







Plot outputs



pltxticks(())

pltyticks(())

pltshow()


correction


correction


correction





















exercices













httpsscikit-


essinghtml








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]


correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 3775 -115 -13 ]


Std deviation = [ 312039661 636651396 40620192 ]



mean

Std



correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])


print(nBEFORE)





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])








correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1




data_normalized_l1)



([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2




data_normalized_l2)








plusieurs solutions




[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data




print(nBEFORE)



Remove mean




Min max scaling




Normalize















correction

import numpy as np







Print the mapping



print(item --gt i)








[3 0 4 1]






import numpy as np


Sample input labels





Print the mapping



print(item --gt i)











correction




[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])


0 1 1 1 2 2 2 3 3 3])





httpsscikit-






lsquofortersquo






machine learning




















particulier










Avec C=900


import numpy as np











mesh_step_size))





Create a plot

pltfigure()











pltshow()


p37

import numpy as np





X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])





classifierfit(X y)

on le visualise











et pour visualiser











import numpy as np













classifierfit(X y)

et visualisons le




p41





predict


performant



preacutedictions









round(accuracy 2) )


visulize_classifier


machine learning










































2 p41

Cross validation



test_size=02)


test_size=02)







on visualise









Precision


Recall



F1 Score





num_folds = 3









machine learning

bullSCORING








Precision et Recall




Precision




Recall




F1 Score

Wikipedia




import numpy as np










print(XestX[5])

print(y esty[5])

print(y)



classifierfit(X y)



Compute accuracy

















Scoring functions

num_folds = 3












score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np





true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]











pltshow()




EXERCICE 6 SVM























import numpy as np









Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0









Combien au-dessus



la ligne[-1]


par an de salaire



(USD)




break

if in line

continue



Xappend(data)

count_class1 += 1


Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)



creacuteer un









classifierfit(X y)



label_encoders = []



if itemisdigit()


else












classifierfit(X y)











test X_test











classifier =
















count = 0


if itemisdigit()


else


count += 1











count = 0


if itemisdigit()


else


count += 1






machine learning

bullSVM













support

Annexe SVM



Annexe SVM

EXERCICE 7 SVM IRIS



classificateur SVM




datasetsload_iris()












pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


reshtml


import numpy as np






X = irisdata[ 2]

y = iristarget


h = 02























pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


sSVMLineaireshtml



sSVMLineaireshtml




import pickle

import numpy as np



























pltxticks(())

pltyticks(())

pltshow()













on le charge








import numpy as np






Read data






Training


Test data






Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()








Model persistence


Save the model



Load the model













import numpy as np























))

















diffeacuterence

datapoint = [[775 635 556]]




















Training data


Test data






Predict the output


Measure performance










datapoint = [[775 635 556]]













import numpy as np



























test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]


machine learning

bullVARIANCE

Annexe variance



understandinghl=fr



y_true = [3 -05 2 7]

y_pred = [25 00 2 8]


y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]














machine learning

bullPERTES

Annexe pertes



Annexe pertes















rouges dans le

graphique de gauche


celles de lautre








gauche

Vous vous demandez






significative




dexemples

ougrave








bull




















Load housing data


Shuffle the data


















test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]







httpwwwgrappauniv-

















pltfigure()






















print(n + 40)





print(40 + n)

pltshow()


machine learning

bullDECISION TREES








Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui



Š 1Construction





age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes




age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes


Correction














I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n



p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n




age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971


5

14

5

I(23)+

4

14

I(40)


Œ De mecircme

+ I(32)= 069 14


Gain(income) = 0029








eacutelagueacute









drsquoapprentissage





machine learning




y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]










Load input data






















print(n + 40)





print(40 + n)

pltshow()





Avec type rf

Avec type erf


import numpy as np







Argument parser





return parser





Load input data




print(X) print(y)






pltfigure()











else








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

Compute confidence










pltshow()





import argparse

import numpy as np














return parser











print(X)

print(y)







pltfigure()





















else














print(n + 40)




print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)














datapoints)

pltshow()










import numpy as np






Load input data








pltfigure()











else









print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()





import sys

import numpy as np
















pltfigure()
























print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced




Avec le balanced







import numpy as np















donneacutees tests


random_state=5)







n_estimators [25 50 100 250]





classifier =















import numpy as np






Load input data










































































on arrange les X



pltfigure()




pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor















Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans











uns aux autres



cas










import numpy as np







ici 5

num_clusters = 5


pltfigure()







pltxticks(())

pltyticks(())















kmeansfit(X)


ils sont mis


step_size = 001





step_size))






pltfigure()

pltclf()














pltxticks(())

pltyticks(())

pltshow()




import numpy as np





num_clusters = 5











kmeansfit(X)


step_size = 001








pltfigure()

pltclf()











pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS




donneacutees





distance aux points








donne pas de nouvel











import numpy as np
























markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift









densiteacute




















meme cluster





paquets



import numpy as np



























pltfigure()

markers = oxvs




color=black)





markersize=15)

plttitle(Clusters)

pltshow()





import numpy as np







pltfigure()






pltxticks(())

pltyticks(())







kmeansfit(X)




scoresappend(score)


scorespltfigure()






pltshow()















cluster






nombre optimal




import numpy as np










scores = []







kmeansfit(X)







scoresappend(score)



pltfigure()










pltfigure()







pltxticks(())

pltyticks(())

pltshow()






import numpy as np











Take the first fold















Draw boundaries












scaling_factor = 8


Draw the ellipse







Plot the data

colors = bgrlsquo














pltxticks(())

pltyticks(())

pltshow()
































import numpy as np

















































continuons


pltfigure()

colors = bgr












taille des ellipses



scaling_factor = 8





color=color)








colors = bgr



















pltxticks(())

pltyticks(())

pltshow()




import csv

import numpy as np






X = []


if not count

names = row[1]

continue

















pltfigure()





pltshow()











import csv

import numpy as np






X = []


if not count

names = row[1]

continue



X = nparray(X)























pltfigure()



offset = 025


















Generate data









Set the parameters
























Random Forest










redondants













maximales de 4









bloc










scores















import numpy as np





X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])




k = 5


Test datapoint



pltfigure()














pltfigure()







pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


k = 5

Test datapoint


Plot input data

pltfigure()











pltfigure()





pltshow()










import numpy as np











pltfigure()








num_neighbors = 12


taille du pas

step_size = 001






classifierfit(X y)












pltfigure()














pltfigure()













pltfigure()


for i in indices












pltshow()














import argparse

import json

import numpy as np







return parser









common_movies =







return 0


squared_diff = []













common_movies =







et le score sera 0

if num_ratings == 0

return 0






common_movies])










if Sxx Syy == 0

return 0







user1 = argsuser1

user2 = argsuser2










else











import argparse

import json

import numpy as np






help=Input user)

return parser


















user = argsuser









print(-41)









import argparse

import json

import numpy as np







help=Input user)

return parser








overall_scores =

similarity_scores =






continue























user = argsuser












L7wKQM

machine learning

bullDEEP LEARNING



comment apprendre






va essayer de jouer

autrement




Un chat






comment apprendre


chat un chien


EXERCICE GOOGLE CAR


httpsscikit-






seul























drsquoautre


Google car




dans cet exercice


Google car


([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])



([1 1 1 2 2 2])



Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car









Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car









Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car



capteurs )





correction



thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps


frein


correction



frein








quelque part

Google car










[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car


une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car




[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici



correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car







deacutecision)







Google car




gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])




gtgtgt clffit(X Y)



[1]







gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])


(comme Y=f(X)=










gtgtgt clffit(X Y)





[1]



correction











machine learning

bullLOI NORMALE








bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5





bull Pour n = 1








16

1 2 3 4 5 6

Correction n=1










1 2 3 4 5 6 7 8 9 10 11 12

correction










1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction




correction








de Galton








httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction




Exercice qui

reconnaissez-vous

sur ces photos


















correction

machine learning


















Bayes

correction













correction














(ils ne sont que 2)



correction























correction










correction







ndash

correction

Quizz1










choix

EXERCICE LOYERS
















drsquoentreacutee













pltxticks(())

pltyticks(())

pltshow()





print(data)



print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()






regressorfit(X y)





def predict(x)






pb avec taille de X



def predict(x)







pltxticks(())

pltyticks(())


pltshow()



import numpy as np

import pandas as pd












print(theta)



pltxlabel(Surface)

pltylabel(Loyer)




c=000000)

pltshow()


regr =





Exercice






Et pour 50m2

Et pour 200m2


Pourquoi


pas











30100+2943 = 32943 (eurosmois)








correction





Voici












Commentez





import numpy as np


X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)


a = regscore(X y)


b=regcoef_


c =regintercept_




correction



correction



Y = X[0] + 200X[1] + 300



machine learning






Dans wikipedia











lineacuteaire
















etiquettes
















beta





de Bayes )
















































produit matriciel



devient








CQFD





machine learning


calculer

- la moyenne des x

- la moyenne des y


au carreacute)

- la variance de y



covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)



moyennes




datavisualisation



ednumpystdhtml

datavisualisation


un scheacutema


datavisualisation

correction




import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs




correction





totalement hands-on


pratique

et




et de scikit learn








bull Mais aussi

bull SVM

bull KNN

bull PCA













de la discipline


transfert

Les algorithmes

















exemples












disposition


Les donneacutees







cas


chaicircnes




Exercice












bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])






Correction



gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])



gtgtgt npshape(a)

(4)


npshape(b)


Correction







pyplotplot([1 2 3 6] [1 4 9 36])










pyplotylim(0 5)









gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])




import numpy as np





Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)


pltpcolor(X Y Z)

pltshow()




o rond




eacutetoile

D losange (diamond)



p pentagone

point





Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]








import numpy as np



print a

print n


print aravel()

print n





[[0 1 2 3]

[4 5 6 7]]


[0 1 2 3 4 5 6 7]







Preacutediction









superviseacute



superviseacute










pourrez trouver













observation












print(type(iris))


pour un Pythoniste



print(dir(iris))







print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])



iris de la base






petal width (cm)]


array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])





sepale 3 cm











Correction




Correction





diris







target = iristarget


print(target)



enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]










correction





target = iristarget


for i in [012]






correction



donneacutees iris






data


fleur




correction


print(irisDESCR)
























correction



matplotlib inline



import numpy as np













Leacutegende






pltplot()


orgapi_as_gen

matplotlibpyplots

ubplothtml





algo dessus)











import pandas as pd

snsset()


df[target] = target


dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats




Exercice Quelle

classification


tecircte raquo





espegraveces


drsquoalgo


cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage













Apprentissage



clf = GaussianNB()

Apprentissage

clffit(data target)


print(dir(clf))





clfget_params()

priors None

correction

Apprentissage





Apprentissage



result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])




correction





le cas









le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])





erreurs 6








correction





pas




confusion_matrix












095999999999999996




conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])




autre




sont pas en vrai

correction


correction






Lon observe ici que
































(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)






correction

Model selection



jeu de test



Il faut importer

train_test_split



httpsscikit-





correction


Model selection










data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction





clf = GaussianNB()




Score



094666666666666666



conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction










chaque point)


data = irisdata[ 2]

target = iristarget

data[5]


array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])


clf = GaussianNB()

clffit(data target)



h = 15










x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])






array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])



yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])


a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])



list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]


data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]









pltfigure(1)



c=target)
















pltfigure(1)











KN








interact(n=(020))

def n_change(n=5)


clffit(data target)


pltfigure(1)











fonction de N


iristarget[2]


iristarget[12]

result = []


for n in n_values


(n_neighbors=n)




target_test)

resultappend(score)





optimaux












array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque












1

Une seule erreur




































originaux

PCA

irisdata[5]


array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])


reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()




dfhead()

PCA





pltxlabel(PCA1)

pltylabel(PCA2)







existent















Preacutediction





df[group] = groups


fit_reg=False)









bull Mais aussi

bull SVM

bull KNN

bull PCA













Tout drsquoabord


Iris








gtgtgt datashape

(150 4)

correction


IRIS donneacutees






[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target








array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])



correction

IRIS visualisation







seacutepales





IRIS visualisation







correction

IRIS visualisation





data = irisdata

target = iristarget

Une nouvelle figure






plttight_layout()

pltshow()

correction





largeur des sepales




data = irisdata[ 2]

target = iristarget

correction





chacun







une frontiegravere)













correction








clffit(data target)

correction










correction













pltclf()






pltshow()

correction






pour le svm


Pour le naive bayes








clf =GaussianNB()

correction





data = irisdata

datashape


target = iristarget






pltshow()


GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))





accuracy_score


correction

avec knn


clf2 =


Apprentissage


print(dir(clf2))





target))

avec svm



OneVsOneClassifier

clf3 =


dom_state=0))





target))

on va dessiner cela


data = irisdata[ 2]

target = iristarget

h = 02





clf


e=0))

clf =GaussianNB()

clffit(data target)




y_max]


0]max() + 1


1]max() + 1







pltclf()

pltpcolor(xx yy Z)





pltshow()












correction










correction



matplotlib pyplot





plttitle(avec pca)

pltshow()

correction


correction



gaussian mixture

httpsscikit-



Avec

n_components=3





donneacutees



correction















pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction










import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction




machine learning




Enigmaio


Conclusion





























Diabete Exercice











import numpy as np












correction















correction


The coefficients







Plot outputs



pltxticks(())

pltyticks(())

pltshow()


correction


correction


correction





















exercices













httpsscikit-


essinghtml








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]


correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 3775 -115 -13 ]


Std deviation = [ 312039661 636651396 40620192 ]



mean

Std



correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])


print(nBEFORE)





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])








correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1




data_normalized_l1)



([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2




data_normalized_l2)








plusieurs solutions




[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data




print(nBEFORE)



Remove mean




Min max scaling




Normalize















correction

import numpy as np







Print the mapping



print(item --gt i)








[3 0 4 1]






import numpy as np


Sample input labels





Print the mapping



print(item --gt i)











correction




[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])


0 1 1 1 2 2 2 3 3 3])





httpsscikit-






lsquofortersquo






machine learning




















particulier










Avec C=900


import numpy as np











mesh_step_size))





Create a plot

pltfigure()











pltshow()


p37

import numpy as np





X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])





classifierfit(X y)

on le visualise











et pour visualiser











import numpy as np













classifierfit(X y)

et visualisons le




p41





predict


performant



preacutedictions









round(accuracy 2) )


visulize_classifier


machine learning










































2 p41

Cross validation



test_size=02)


test_size=02)







on visualise









Precision


Recall



F1 Score





num_folds = 3









machine learning

bullSCORING








Precision et Recall




Precision




Recall




F1 Score

Wikipedia




import numpy as np










print(XestX[5])

print(y esty[5])

print(y)



classifierfit(X y)



Compute accuracy

















Scoring functions

num_folds = 3












score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np





true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]











pltshow()




EXERCICE 6 SVM























import numpy as np









Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0









Combien au-dessus



la ligne[-1]


par an de salaire



(USD)




break

if in line

continue



Xappend(data)

count_class1 += 1


Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)



creacuteer un









classifierfit(X y)



label_encoders = []



if itemisdigit()


else












classifierfit(X y)











test X_test











classifier =
















count = 0


if itemisdigit()


else


count += 1











count = 0


if itemisdigit()


else


count += 1






machine learning

bullSVM













support

Annexe SVM



Annexe SVM

EXERCICE 7 SVM IRIS



classificateur SVM




datasetsload_iris()












pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


reshtml


import numpy as np






X = irisdata[ 2]

y = iristarget


h = 02























pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


sSVMLineaireshtml



sSVMLineaireshtml




import pickle

import numpy as np



























pltxticks(())

pltyticks(())

pltshow()













on le charge








import numpy as np






Read data






Training


Test data






Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()








Model persistence


Save the model



Load the model













import numpy as np























))

















diffeacuterence

datapoint = [[775 635 556]]




















Training data


Test data






Predict the output


Measure performance










datapoint = [[775 635 556]]













import numpy as np



























test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]


machine learning

bullVARIANCE

Annexe variance



understandinghl=fr



y_true = [3 -05 2 7]

y_pred = [25 00 2 8]


y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]














machine learning

bullPERTES

Annexe pertes



Annexe pertes















rouges dans le

graphique de gauche


celles de lautre








gauche

Vous vous demandez






significative




dexemples

ougrave








bull




















Load housing data


Shuffle the data


















test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]







httpwwwgrappauniv-

















pltfigure()






















print(n + 40)





print(40 + n)

pltshow()


machine learning

bullDECISION TREES








Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui



Š 1Construction





age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes




age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes


Correction














I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n



p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n




age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971


5

14

5

I(23)+

4

14

I(40)


Œ De mecircme

+ I(32)= 069 14


Gain(income) = 0029








eacutelagueacute









drsquoapprentissage





machine learning




y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]










Load input data






















print(n + 40)





print(40 + n)

pltshow()





Avec type rf

Avec type erf


import numpy as np







Argument parser





return parser





Load input data




print(X) print(y)






pltfigure()











else








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

Compute confidence










pltshow()





import argparse

import numpy as np














return parser











print(X)

print(y)







pltfigure()





















else














print(n + 40)




print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)














datapoints)

pltshow()










import numpy as np






Load input data








pltfigure()











else









print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()





import sys

import numpy as np
















pltfigure()
























print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced




Avec le balanced







import numpy as np















donneacutees tests


random_state=5)







n_estimators [25 50 100 250]





classifier =















import numpy as np






Load input data










































































on arrange les X



pltfigure()




pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor















Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans











uns aux autres



cas










import numpy as np







ici 5

num_clusters = 5


pltfigure()







pltxticks(())

pltyticks(())















kmeansfit(X)


ils sont mis


step_size = 001





step_size))






pltfigure()

pltclf()














pltxticks(())

pltyticks(())

pltshow()




import numpy as np





num_clusters = 5











kmeansfit(X)


step_size = 001








pltfigure()

pltclf()











pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS




donneacutees





distance aux points








donne pas de nouvel











import numpy as np
























markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift









densiteacute




















meme cluster





paquets



import numpy as np



























pltfigure()

markers = oxvs




color=black)





markersize=15)

plttitle(Clusters)

pltshow()





import numpy as np







pltfigure()






pltxticks(())

pltyticks(())







kmeansfit(X)




scoresappend(score)


scorespltfigure()






pltshow()















cluster






nombre optimal




import numpy as np










scores = []







kmeansfit(X)







scoresappend(score)



pltfigure()










pltfigure()







pltxticks(())

pltyticks(())

pltshow()






import numpy as np











Take the first fold















Draw boundaries












scaling_factor = 8


Draw the ellipse







Plot the data

colors = bgrlsquo














pltxticks(())

pltyticks(())

pltshow()
































import numpy as np

















































continuons


pltfigure()

colors = bgr












taille des ellipses



scaling_factor = 8





color=color)








colors = bgr



















pltxticks(())

pltyticks(())

pltshow()




import csv

import numpy as np






X = []


if not count

names = row[1]

continue

















pltfigure()





pltshow()











import csv

import numpy as np






X = []


if not count

names = row[1]

continue



X = nparray(X)























pltfigure()



offset = 025


















Generate data









Set the parameters
























Random Forest










redondants













maximales de 4









bloc










scores















import numpy as np





X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])




k = 5


Test datapoint



pltfigure()














pltfigure()







pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


k = 5

Test datapoint


Plot input data

pltfigure()











pltfigure()





pltshow()










import numpy as np











pltfigure()








num_neighbors = 12


taille du pas

step_size = 001






classifierfit(X y)












pltfigure()














pltfigure()













pltfigure()


for i in indices












pltshow()














import argparse

import json

import numpy as np







return parser









common_movies =







return 0


squared_diff = []













common_movies =







et le score sera 0

if num_ratings == 0

return 0






common_movies])










if Sxx Syy == 0

return 0







user1 = argsuser1

user2 = argsuser2










else











import argparse

import json

import numpy as np






help=Input user)

return parser


















user = argsuser









print(-41)









import argparse

import json

import numpy as np







help=Input user)

return parser








overall_scores =

similarity_scores =






continue























user = argsuser












L7wKQM

machine learning

bullDEEP LEARNING



comment apprendre






va essayer de jouer

autrement




Un chat






comment apprendre


chat un chien



httpsscikit-






seul























drsquoautre


Google car




dans cet exercice


Google car


([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])



([1 1 1 2 2 2])



Google car

correction


[-1 -1] [-2 -1]

[-3 -2]

[1 1] [2 1]

[4 2]

Google car









Google car

correction


Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car









Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE

Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2

BOSSES IMPORTANTES

ROUTE TRES PENTUE






Google car



capteurs )





correction



thermomegravetre

Capteur infra-rouge

microphone

cameacutera

gps


frein


correction



frein








quelque part

Google car










[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2






Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car


une limite


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car




[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction

Google car



[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici



correction


[-1 -1]

1

[-2 -1]

1

[-3 -2]

1

[1 1]

2

[2 1]

[4 2]

2

2 Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici

Et ici


correction

Google car







deacutecision)







Google car




gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])




gtgtgt clffit(X Y)



[1]







gtgtgt X = nparray([[-1 -1] [-2 -1] [-3 -2] [1 1] [2 1] [4 2]])


(comme Y=f(X)=










gtgtgt clffit(X Y)





[1]



correction











machine learning

bullLOI NORMALE








bull Puis n=2

bull Puis n = 3

bull Puis n=4

bull Puis n=5





bull Pour n = 1








16

1 2 3 4 5 6

Correction n=1










1 2 3 4 5 6 7 8 9 10 11 12

correction










1 2 3 4 5 6 7 8 9 10 11 1213 14 1516 17 18

correction




correction








de Galton








httpswwwyoutubeco

mwatchv=cpCo6mtdA

nE

httpswwwyoutubeco

mwatchv=ADiZ28E-

9Lo

correction




Exercice qui

reconnaissez-vous

sur ces photos


















correction

machine learning


















Bayes

correction













correction














(ils ne sont que 2)



correction























correction










correction







ndash

correction

Quizz1










choix

EXERCICE LOYERS
















drsquoentreacutee













pltxticks(())

pltyticks(())

pltshow()





print(data)



print(X estX)

print(y esty)


pltxticks(())

pltyticks(())

pltshow()






regressorfit(X y)





def predict(x)






pb avec taille de X



def predict(x)







pltxticks(())

pltyticks(())


pltshow()



import numpy as np

import pandas as pd












print(theta)



pltxlabel(Surface)

pltylabel(Loyer)




c=000000)

pltshow()


regr =





Exercice






Et pour 50m2

Et pour 200m2


Pourquoi


pas











30100+2943 = 32943 (eurosmois)








correction





Voici












Commentez





import numpy as np


X = nparray([[100 1] [100 2] [200 2] [200 3]])

print(X)

y= (600 800 900 1100)

print(y)


a = regscore(X y)


b=regcoef_


c =regintercept_




correction



correction



Y = X[0] + 200X[1] + 300



machine learning






Dans wikipedia











lineacuteaire
















etiquettes
















beta





de Bayes )
















































produit matriciel



devient








CQFD





machine learning


calculer

- la moyenne des x

- la moyenne des y


au carreacute)

- la variance de y



covariance

eacutecarts-

types

datavisualisation

a = cov(xy)V(x)



moyennes




datavisualisation



ednumpystdhtml

datavisualisation


un scheacutema


datavisualisation

correction




import numpy as np

x = nparray([10 8 13 9 11 14 6 4 12 7 5])

y1 = nparray([804 695 758 881 833 996 724 426 1084 482 568])

y2 = nparray([914 814 874 877 926 810 613 310 913 726 474])

y3 = nparray([746 677 1274 711 781 884 608 539 815 642 573])

x4 = nparray([8 8 8 8 8 8 8 19 8 8 8])

y4 = nparray([658 576 771 884 847 704 525 1250 556 791 689])

print(nppolyfit([10 8 13 9 11 14 6 4 12 7 5][804 695 758 881 833 996

724 426 1084 482 568]1))

verify the stats

pairs = (x y1) (x y2) (x y3) (x4 y4)

for x y in pairs




correction





totalement hands-on


pratique

et




et de scikit learn








bull Mais aussi

bull SVM

bull KNN

bull PCA













de la discipline


transfert

Les algorithmes

















exemples












disposition


Les donneacutees







cas


chaicircnes




Exercice












bullTransposeacute

bullgtgtgt aT

array([[1 4] [2 5] [3 6]])






Correction



gtgtgt npones(3)

array([ 1 1 1])

gtgtgt npones((23))

array([[ 1 1 1] [ 1 1 1]])



gtgtgt npshape(a)

(4)


npshape(b)


Correction







pyplotplot([1 2 3 6] [1 4 9 36])










pyplotylim(0 5)









gtgtgt X array([[3 4 7] [3 4 7]])

gtgtgt Y array([[-1 -1 -1] [ 0 0 0]])




import numpy as np





Z = (1 - X2 + X5 + Y3) npexp(-X2 - Y2)


pltpcolor(X Y Z)

pltshow()




o rond




eacutetoile

D losange (diamond)



p pentagone

point





Exemple

x = [1 2 3 4 5]

y1 = [1 2 3 4 5]

y2 = [1 4 9 16 25]

y3 = [25 16 9 4 1]








import numpy as np



print a

print n


print aravel()

print n





[[0 1 2 3]

[4 5 6 7]]


[0 1 2 3 4 5 6 7]







Preacutediction









superviseacute



superviseacute










pourrez trouver













observation












print(type(iris))


pour un Pythoniste



print(dir(iris))







print (irisdata[5])

array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13 02] [ 46 31 15 02] [ 5

36 14 02]])



iris de la base






petal width (cm)]


array([[ 51 35 14 02] [ 49 3 14 02] [ 47 32 13

02] [ 46 31 15 02] [ 5 36 14 02]])





sepale 3 cm











Correction




Correction





diris







target = iristarget


print(target)



enregistrement

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

for i in [012]










correction





target = iristarget


for i in [012]






correction



donneacutees iris






data


fleur




correction


print(irisDESCR)
























correction



matplotlib inline



import numpy as np













Leacutegende






pltplot()


orgapi_as_gen

matplotlibpyplots

ubplothtml





algo dessus)











import pandas as pd

snsset()


df[target] = target


dfhead()

correction

Idem si le code

ne tourne pas

pas grave

regarder les

reacutesultats




Exercice Quelle

classification


tecircte raquo





espegraveces


drsquoalgo


cm alors sebosa

Si longueur petale

entre 25 et 5 cm

versicolor

Sinon virginica

correction

Apprentissage













Apprentissage



clf = GaussianNB()

Apprentissage

clffit(data target)


print(dir(clf))





clfget_params()

priors None

correction

Apprentissage





Apprentissage



result

array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2

2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2])




correction





le cas









le cas

result - target

array([ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0

-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])





erreurs 6








correction





pas




confusion_matrix












095999999999999996




conf

array([[50 0 0]

[ 0 47 3]

[ 0 3 47]])




autre




sont pas en vrai

correction


correction






Lon observe ici que
































(array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2]) array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2])

75

75)






correction

Model selection



jeu de test



Il faut importer

train_test_split



httpsscikit-





correction


Model selection










data_test[5]

array([[ 58 28 51 24]

[ 6 22 4 1 ]

[ 55 42 14 02]

[ 73 29 63 18]

[ 5 34 15 02]])

correction





clf = GaussianNB()




Score



094666666666666666



conf

array([[21 0 0]

[ 0 30 0]

[ 0 4 20]])

correction










chaque point)


data = irisdata[ 2]

target = iristarget

data[5]


array([[ 51 35]

[ 49 3 ]

[ 47 32]

[ 46 31]

[ 5 36]])


clf = GaussianNB()

clffit(data target)



h = 15










x

array([ 33 345 36 375 39 405 42 435 45

465 48 495 51 525 54 555 57 585

6 615 63 645 66 675 69 705 72

735 75 765 78 795 81 825 84 855

87 885])






array([[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]

[ 33 345 36 855 87 885]])



yy

array([[ 1 1 1 1 1 1 ]

[ 115 115 115 115 115 115]

[ 13 13 13 13 13 13 ]

[ 505 505 505 505 505 505]

[ 52 52 52 52 52 52 ]

[ 535 535 535 535 535 535]])


a = [ [10 20]

[ 1 2] ]

nparray(a)ravel()

array([10 20 1 2])



list(zip([102030] [123]))

[(10 1) (20 2) (30 3)]


data_samples[10]

[(32999999999999998 10)

(34499999999999997 10)

(35999999999999996 10)

(37499999999999996 10)

(38999999999999995 10)

(40499999999999989 10)

(41999999999999993 10)

(43499999999999996 10)

(44999999999999991 10)

(46499999999999986 10)]









pltfigure(1)



c=target)
















pltfigure(1)











KN








interact(n=(020))

def n_change(n=5)


clffit(data target)


pltfigure(1)











fonction de N


iristarget[2]


iristarget[12]

result = []


for n in n_values


(n_neighbors=n)




target_test)

resultappend(score)





optimaux












array([0 0 0 0 0 1 1 2 1 1 2 2 2 2 2])

gtgtgt target[10]

array([0 0 0 0 0 1 1 1 1 1 2 2 2 2 2])

Remarque












1

Une seule erreur




































originaux

PCA

irisdata[5]


array([[ 51 35 14 02]

[ 49 3 14 02]

[ 47 32 13 02]

[ 46 31 15 02]

[ 5 36 14 02]])


reduc[5]

array([[-268420713 032660731]

[-271539062 -016955685]

[-288981954 -013734561]

[-27464372 -031112432]

[-272859298 033392456]])

dfhead()




dfhead()

PCA





pltxlabel(PCA1)

pltylabel(PCA2)







existent















Preacutediction





df[group] = groups


fit_reg=False)









bull Mais aussi

bull SVM

bull KNN

bull PCA













Tout drsquoabord


Iris








gtgtgt datashape

(150 4)

correction


IRIS donneacutees






[sepal length (cm)

sepal width (cm)

petal length (cm)

petal width (cm)]

correction


IRIS target








array([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2])



correction

IRIS visualisation







seacutepales





IRIS visualisation







correction

IRIS visualisation





data = irisdata

target = iristarget

Une nouvelle figure






plttight_layout()

pltshow()

correction





largeur des sepales




data = irisdata[ 2]

target = iristarget

correction





chacun







une frontiegravere)













correction








clffit(data target)

correction










correction













pltclf()






pltshow()

correction






pour le svm


Pour le naive bayes








clf =GaussianNB()

correction





data = irisdata

datashape


target = iristarget






pltshow()


GaussianNB


clf = GaussianNB()

Apprentissage

clffit(data target)

print(dir(clf))





accuracy_score


correction

avec knn


clf2 =


Apprentissage


print(dir(clf2))





target))

avec svm



OneVsOneClassifier

clf3 =


dom_state=0))





target))

on va dessiner cela


data = irisdata[ 2]

target = iristarget

h = 02





clf


e=0))

clf =GaussianNB()

clffit(data target)




y_max]


0]max() + 1


1]max() + 1







pltclf()

pltpcolor(xx yy Z)





pltshow()












correction










correction



matplotlib pyplot





plttitle(avec pca)

pltshow()

correction


correction



gaussian mixture

httpsscikit-



Avec

n_components=3





donneacutees



correction















pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction










import numpy as np




data = irisdata

data = irisdata[ 2]

target = iristarget




clffit(data target)








pltclf()

pltpcolor(xx yy Z)






pltshow()

correction


correction




machine learning




Enigmaio


Conclusion





























Diabete Exercice











import numpy as np












correction















correction


The coefficients







Plot outputs



pltxticks(())

pltyticks(())

pltshow()


correction


correction


correction





















exercices













httpsscikit-


essinghtml








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Binarized data

[[ 1 0 1]

[ 0 1 0]

[ 1 0 0]

[ 1 0 0]]


correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data

data_binarized =





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Moyenne Mean = [ 3775 -115 -13 ]


Std deviation = [ 312039661 636651396 40620192 ]



mean

Std



correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])


print(nBEFORE)





([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])








correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


Min max scaled data

[[ 074117647 039548023 1 ]

[ 0 1 0 ]

[ 06 05819209 087234043]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])








([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L1 normalized data

[[ 045132743 -025663717 02920354 ]

[-00794702 051655629 -040397351]

[ 0609375 00625 0328125 ]

[ 033640553 -04562212 -020737327]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L1




data_normalized_l1)



([[51 -29 33]

[-12 78 -61]

[39 04 21]

[73 -99 -45]])


L2 normalized data

[[ 075765788 -043082507 049024922]

[-012030718 078199664 -061156148]

[ 087690281 008993875 047217844]

[ 055734935 -075585734 -034357152]]





correction

import numpy as np



[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Normalisation L2




data_normalized_l2)








plusieurs solutions




[-12 78 -61]

[39 04 21]

[73 -99 -45]])

Binarize data




print(nBEFORE)



Remove mean




Min max scaling




Normalize















correction

import numpy as np







Print the mapping



print(item --gt i)








[3 0 4 1]






import numpy as np


Sample input labels





Print the mapping



print(item --gt i)











correction




[29 8] [51 45] [6 5] [56 5]

[33 04] [39 09] [28 1] [05 34] [1

4] [06 49]])


0 1 1 1 2 2 2 3 3 3])





httpsscikit-






lsquofortersquo






machine learning




















particulier










Avec C=900


import numpy as np











mesh_step_size))





Create a plot

pltfigure()











pltshow()


p37

import numpy as np





X = nparray([[31 72] [4 67] [29 8] [51 45] [6 5] [56 5] [33 04] [39 09]

[28 1] [05 34] [1 4] [06 49]])

y = nparray([0 0 0 1 1 1 2 2 2 3 3 3])





classifierfit(X y)

on le visualise











et pour visualiser











import numpy as np













classifierfit(X y)

et visualisons le




p41





predict


performant



preacutedictions









round(accuracy 2) )


visulize_classifier


machine learning










































2 p41

Cross validation



test_size=02)


test_size=02)







on visualise









Precision


Recall



F1 Score





num_folds = 3









machine learning

bullSCORING








Precision et Recall




Precision




Recall




F1 Score

Wikipedia




import numpy as np










print(XestX[5])

print(y esty[5])

print(y)



classifierfit(X y)



Compute accuracy

















Scoring functions

num_folds = 3












score F1

true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]


import numpy as np





true_labels = [2 0 0 2 4 4 1 0 3 3 3]

pred_labels = [2 1 0 2 4 3 1 0 1 3 3]











pltshow()




EXERCICE 6 SVM























import numpy as np









Read the data

X = []

y = []

count_class1 = 0

count_class2 = 0









Combien au-dessus



la ligne[-1]


par an de salaire



(USD)




break

if in line

continue



Xappend(data)

count_class1 += 1


Xappend(data)

count_class2 += 1

Convert to numpy

arrayX = nparray(X)

print(X estX)



creacuteer un









classifierfit(X y)



label_encoders = []



if itemisdigit()


else












classifierfit(X y)











test X_test











classifier =
















count = 0


if itemisdigit()


else


count += 1











count = 0


if itemisdigit()


else


count += 1






machine learning

bullSVM













support

Annexe SVM



Annexe SVM

EXERCICE 7 SVM IRIS



classificateur SVM




datasetsload_iris()












pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


reshtml


import numpy as np






X = irisdata[ 2]

y = iristarget


h = 02























pltxticks(())

pltyticks(())

plttitle(titles[i])

pltshow()


sSVMLineaireshtml



sSVMLineaireshtml




import pickle

import numpy as np



























pltxticks(())

pltyticks(())

pltshow()













on le charge








import numpy as np






Read data






Training


Test data






Predict the output


Plot outputs



pltxticks(())

pltyticks(())

pltshow()








Model persistence


Save the model



Load the model













import numpy as np























))

















diffeacuterence

datapoint = [[775 635 556]]




















Training data


Test data






Predict the output


Measure performance










datapoint = [[775 635 556]]













import numpy as np



























test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]


machine learning

bullVARIANCE

Annexe variance



understandinghl=fr



y_true = [3 -05 2 7]

y_pred = [25 00 2 8]


y_true = [[05 1] [-1 1] [7 -6]]

y_pred = [[0 2] [-1 2] [8 -5]]














machine learning

bullPERTES

Annexe pertes



Annexe pertes















rouges dans le

graphique de gauche


celles de lautre








gauche

Vous vous demandez






significative




dexemples

ougrave








bull




















Load housing data


Shuffle the data


















test_data = [37 0 184 1 087 595 91 25052 26 666 202 35134 1527]







httpwwwgrappauniv-

















pltfigure()






















print(n + 40)





print(40 + n)

pltshow()


machine learning

bullDECISION TREES








Š feuilles classe

Ciel

deacutegageacute

Humiditeacute

forte

non

couvert

oui

normale

oui

pluvieux

Vent

faible

fort

non oui



Š 1Construction





age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes




age income student

age

credit rating

lt=30

high

no

fair lt=30

high

no


gt40 medium


3040 gt40

gt40

low

yes




lt=30

medium

no

fair lt=30

low

yes

fair gt40

medium

yes

fair

no

yes

excellent

fair

lt=30

medium

yes


medium

no



no yes no yes


Correction














I(pn)=minus

p

log

p

2

minus

n

log

n

2

p+n

p+n p+n

p+

n



p+n

i E(A)=sum

i I(p n )

i

i

i=1

p+n




age

pi ni

I(pi ni)

lt=30

2

3

0971 Œ I(pn) = I(95) = 0940

30hellip40 4 0 0

gt40

3

2

0971


5

14

5

I(23)+

4

14

I(40)


Œ De mecircme

+ I(32)= 069 14


Gain(income) = 0029








eacutelagueacute









drsquoapprentissage





machine learning




y_true = [0 1 2 2 2]

y_pred = [0 0 2 2 1]










Load input data






















print(n + 40)





print(40 + n)

pltshow()





Avec type rf

Avec type erf


import numpy as np







Argument parser





return parser





Load input data




print(X) print(y)






pltfigure()











else








print(n + 40)



print(40 + n)

print(40)



print(40 + n)

Compute confidence










pltshow()





import argparse

import numpy as np














return parser











print(X)

print(y)







pltfigure()





















else














print(n + 40)




print(40 + n)

print(40)



print(40 + n)



print(40 + n)

print(40)



print(40 + n)














datapoints)

pltshow()










import numpy as np






Load input data








pltfigure()











else









print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()





import sys

import numpy as np
















pltfigure()
























print(n + 40)



print(40 + n)

print(40)



print(40 + n)

pltshow()




sans le balanced


Avec le balanced


Sans le balanced


Avec le balanced




Avec le balanced







import numpy as np















donneacutees tests


random_state=5)







n_estimators [25 50 100 250]





classifier =















import numpy as np






Load input data










































































on arrange les X



pltfigure()




pltshow()




import numpy as np








Load housing data


Shuffle the data




AdaBoost Regressor















Arrange the X


Plot the bar graph

pltfigure()




pltshow()

EXERCICE 17 Kmeans











uns aux autres



cas










import numpy as np







ici 5

num_clusters = 5


pltfigure()







pltxticks(())

pltyticks(())















kmeansfit(X)


ils sont mis


step_size = 001





step_size))






pltfigure()

pltclf()














pltxticks(())

pltyticks(())

pltshow()




import numpy as np





num_clusters = 5











kmeansfit(X)


step_size = 001








pltfigure()

pltclf()











pltxticks(())

pltyticks(())

pltshow()

machine learning

bullK-MEANS




donneacutees





distance aux points








donne pas de nouvel











import numpy as np
























markersize=15)

plttitle(Clusters)

pltshow()

machine learning

bullMean shift









densiteacute




















meme cluster





paquets



import numpy as np



























pltfigure()

markers = oxvs




color=black)





markersize=15)

plttitle(Clusters)

pltshow()





import numpy as np







pltfigure()






pltxticks(())

pltyticks(())







kmeansfit(X)




scoresappend(score)


scorespltfigure()






pltshow()















cluster






nombre optimal




import numpy as np










scores = []







kmeansfit(X)







scoresappend(score)



pltfigure()










pltfigure()







pltxticks(())

pltyticks(())

pltshow()






import numpy as np











Take the first fold















Draw boundaries












scaling_factor = 8


Draw the ellipse







Plot the data

colors = bgrlsquo














pltxticks(())

pltyticks(())

pltshow()
































import numpy as np

















































continuons


pltfigure()

colors = bgr












taille des ellipses



scaling_factor = 8





color=color)








colors = bgr



















pltxticks(())

pltyticks(())

pltshow()




import csv

import numpy as np






X = []


if not count

names = row[1]

continue

















pltfigure()





pltshow()











import csv

import numpy as np






X = []


if not count

names = row[1]

continue



X = nparray(X)























pltfigure()



offset = 025


















Generate data









Set the parameters
























Random Forest










redondants













maximales de 4









bloc










scores















import numpy as np





X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])




k = 5


Test datapoint



pltfigure()














pltfigure()







pltshow()


import numpy as np



Input data

X = nparray([[21 13] [13 32] [29 25] [27 54] [38 09]

[73 21] [42 65] [38 37] [25 41] [34 19]

[57 35] [61 43] [51 22] [62 11]])


k = 5

Test datapoint


Plot input data

pltfigure()











pltfigure()





pltshow()










import numpy as np











pltfigure()








num_neighbors = 12


taille du pas

step_size = 001






classifierfit(X y)












pltfigure()














pltfigure()













pltfigure()


for i in indices












pltshow()














import argparse

import json

import numpy as np







return parser









common_movies =







return 0


squared_diff = []













common_movies =







et le score sera 0

if num_ratings == 0

return 0






common_movies])










if Sxx Syy == 0

return 0







user1 = argsuser1

user2 = argsuser2










else











import argparse

import json

import numpy as np






help=Input user)

return parser


















user = argsuser









print(-41)









import argparse

import json

import numpy as np







help=Input user)

return parser








overall_scores =

similarity_scores =






continue























user = argsuser












L7wKQM

machine learning

bullDEEP LEARNING



comment apprendre






va essayer de jouer

autrement




Un chat






comment apprendre


chat un chien


machine learning : exercices en python

Documents