FONCTIONS MATHEMATIQUES

pour ecrire f(x)=x2

f= lambda x: x**2

pour ecrire f(x,y)=x2+y

f= lambda x,y: x**2+y

on peut verifier deux choses a la fois

if (x>0) & (y>0):

if (x>0) | (y>0):

la foction range a trois parametre range(origine,fin,pas)

on ne peut pas modifier un tuple tandis qu'on peut modifier une liste

slicing a trois elements : list[origine:fin:pas) le debut et la fin de la liste peut etre ignore et on peut bien
utilise un pas negatif

METHODE

[Link]()

[Link](l'indexe la ou on veut l'inserer,l'element qu'on veut inserer)

[Link](une autre liste qu'on veut ajouter a la fin)

[Link]() pour trier par ordre alphabetique ou par ordre croissant

[Link](reverse=True) pour trier par ordre antialphabetique ou decroissant

[Link](element) pour compter le nombre de fois qu'une valeur apparait dns la liste

for index,valeur in enumerate(list):

print(index,valeur)

for a,b in zip(list_a,list_b):

print(a,b) Pour manipuler deux listes a la fois

[Link]()

[Link]()

dict["nouvelle cle"]= nouvelle valeur

[Link]("cle",valeur par defaut) si la cle existe ca affiche sa valeur sinon ca affiche la valeur par defaut

[Link](list,valeur par defaut) ca va creer un dictionnaire dansles cles sont les element de la liste et
les valeurs la valeur par defaut

variable=[Link]("cle") ca va supprimer la combinaison et enregistrer la valeur de la cle dans le

dictionnaire

for i in dict:

print(i) Pour trouver lescles

for i in [Link]()

print(i) Pour trouver les valeurs

for a,b in [Link]():

print(a,b) pour les deux

list comprehension

list_1=[]

list_2=[]

dict={ k:v for k,v in zip(list_1,list_2)} Dictionnaire comprehension

dict={ k:v for k,v in zip(list_1,list_2) if v>10} on eut ajouter des conditions

tuple_1=tuple((i**2 for in range(10))) Tuple comprehension

Built-in function

abs(int) pour trouver la valeur absolu

round(float) pour arrondir une decimale

all(list_1) retourne True si tous elements sont True ou des nombres nn nuls

any(list_1) retourne True si au moins un element est True ou non nul

dans les autres cas,ils retourne False

les fonctions list(),dict(),tuple() nous permettent de creer des listes ,des tuples et des dictionnaires

La fonction format() pour inserer une variable dans une sequence:

x=25

ville="Paris"
message=" la temperature {} a la ville {}".format(x,ville)

La fonction open:

with open([Link],'w') as f:

[Link]("Bonjour")

with open([Link],'r') as f:

[Link]()

le module math permet de faire des maths

le module statistics

le module random

print([Link](la sequence)

on met [Link](0 ou n'importe quelle nombre ) au debut pour obtenir le meme resultat a chaque
fois

print([Link]()) pour afficher un float entre 1 et 0

print([Link](5,10)) pour afficher un integer entre 5 et 10

print([Link](100)) pour afficher un integer entre 0 et 100

print([Link](range(100),10)) pour faire une liste de dix elements selectionnes au hasard dans la
liste

[Link](list) pour nelanger les elements de la listes au hasard

le module os

[Link]()pour trouver le repertoire de travail ou on est situe

le module glob

print([Link]("*") pour afficher tous les fichiers qu'on utilise

print([Link]("*.txt") ) pour imprimer sulement les fichier au format txt

ND ARRAY de numpy

[Link]

A= [Link]([1,2,3]) pour creer un array a 1 dimension contenant es valeurs suivantes

[Link]

[Link] pour verifier le nombre de dimension

[Link]() permet d'obtenir le nombre d'element

[Link]((a,b)) pour créer un tableau rempli de zeros Avec a lives et b colonnes

[Link]((a,b)) rempli de 1 dans ce cas

[Link]((a,b),int) rempli de l'integer indiqué

[Link](a,b) pour créer un tableau Avec des nombre au hasard de dimension a ligne b
colonnes

[Link](a) nous permet de créer une matrice identité Avec a ligne et a colonne

[Link](debut,fin,quantité) permet de créer un tableau à une dimension en specifiant le debut,la fin,

et la quantité d'element

[Link](debut,fin,pas)

quel qué soit le constructeur qu'on utilise on peut utiliser en parametre dtype=

par exemple:

[Link](a,b,dtype=np.float64)

[Link](A,B) permet de cller Deux arrays horizontalement

[Link](A,B) permet de cller Deux arrays verticalement

[Link]((A,B),axis=) si on met axis=0 on colle verticalement,si on met 1 on colle horizontalement

[Link]((a,b)) nous permet de changer Les dimensions d'un tableau mais on doit Garder Le même
nombre d'element

[Link]() supprimé les 1 Dan's Les dimensions pour ne rester qu'avec (a,)

[Link]() sert à appltir un tableau Sur une seule dimension

A[a,b] l'element a la a eme ligne et b eme colonne

a:b b est exclu

a:b:c c est le as

MASQUE BOOLEEN
A=[Link](0,10,[5,5]) cree un tableau de dimension 5*5 avec des chiffres entre 0 et 10

A<5 cree un tableau avec des True et False

A[A<5] donne une liste des elements inferieur a 5

A[A<5]=10 remplace les element inferieur a 5 par 10

on peut integrer plusieurs conditions

A[(A<5) &(A>2)]

A[(A<5) |(A>2)]

MATH ET STATS
[Link](axis=) renvoi une liste de somme selon les axes(colonnes ou lignes)

[Link]() somme cumule

[Link]() renvoi le produit comme dans toutes ses fonctions on peut toujours preciser l'axe

[Link]() le produit cumule

[Link]() trouver le minimum on peut precisr l'axe pour trouver une liste de minimum selon les axes

[Link](axis) nous permet de trouver la position du minimum en gros si on choisit comme axe la ligne
ca va nous donner l'indexe de la colonne et inversement

c'est la meme chose avex max

[Link]() pour trier

[Link]() nous donne l'ordre dans lequel on devrait mettre les indexes s'il fallait trier

FONCTION MATH

[Link](A)

EX: [Link](A) ou [Link](A)

Statistiques
[Link]() la moyenne(on peut toujours preciser l'axe)

[Link]() l'ecart type

[Link]()
[Link](A,return_counts=True) retourne une liste des element et une iste de combien de fois ils
apparaissent

[Link]() [Link]() [Link]() permettent de calculer tout en ignorant les valeurs manquantes

[Link](A).sum() permet de determiner le nombre de fois qu'il apparaisse

A[[Link](A)]=0 si on veut remplacer toutes les valeurs manquantes par une valeur

ALGEBRE LINEAIRE
A.T transposee de a

[Link](b) produit matricielle entre A et B

[Link](A) Pour calculer le determinant d'une matrice

[Link](A) Pour obetnir l'inverse de la matrice

BROADCASTING
Le broadcasting consiste a etendre les dimensions d'un tableau pour effectuer une peration

Soit A et B etant les deux tableaux:

On peut effectuer le broadcasting si les dimensions sont egales entre elles,ou l'une egale a 1

Le broadcasting peut etre tres dangereux:

Par exemple avec les dimensions incompletes (a,)

du coup voila pourquoi la methode reshape() est aussi importante

PYPLOT
import [Link] as plt

[Link](x,y,c=,lw=,ls=) (ou [Link] pour un nuage de points) x et y etant deux array de memes
dimensions (x sur les abscisses et y sur les ordonnees)

Les parametrs c(pour la couleur de la ligne,on peut mettre c='red' par exemple),lw(l'epaisseur de la ligne
par exemple lw=2),ls(par exemple si on veut des tirets ls="--")

[Link]() pour afficher

CYCLE DE VIE
Debut de la figure: [Link]()

Contenu:

[Link](x,y,label='quadratique') le parametre label EST seulement utile lorsqu'on met la legende

[Link](x,x**3,label='cubique')

[Link]('axe x')

[Link]('axe y')

[Link]()

Affichage: [Link]()

Sauvegarde: [Link]('[Link]')

NB: on peut avoir plusieurs graphic à l'interieur d'une figure en utilisant la fonction subplot:

[Link]

[Link](nombre de ligne(int) ,nombre de colonne(int),numéro du graphique sur lequel on veut

travailler(int))

après avoir sélectionné un graphique on donne son contenu puis on fait pareil pour les autres
graphiques

2) Méthode Orienté Objet

fig,ax = [Link]()

[Link](x,y)

[Link]()

en sachant que fig est un objet(la feuille de papier) et ax est un tableau ndarray qui contient nos objets

L'avantage est que la methode oriente objet a plus de fonctionnalite par exemple on peut creer deux
graphiques qui partagent la meme abscisse

fig,ax = [Link](2,1,sharex=True)

ax[0].plot(x,y)

ax[1].plot(x,sin(x))

[Link]()

GRAPHIQUES MPORTANTS:
--SCATTER PLOT

tres utile pour les problemes de classification

[Link](x[:,0],x[:,1],c=y,alpha=,s=) c pour la couleur alpha pour la transparite et s pour l'epaissur du

point,ce qui est sympa ce qu,on peut controler ces elements en fonction d'une des variables du
dataset(colonne)

--GRAPHIQUE 3D

from mpl_toolkits.mplot3d import Axes3d

ax= [Link](projection="3d")

[Link](x[:,0],x[:,1],x[:,2],c=y)

on peut aussi representer des surfaces et des fonctions mathematiques modelisees

ex:

f= lamda x,y: [Link](x)+[Link](x+y) notre fonction mathematique anonyme

X= [Link](0,5,100)

Y= [Link](0,5,100)

X,Y=[Link](X,Y)

Z=f(X,Y)

ax=[Link](projection='3d')

ax.plot_surface(X,Y,Z,cmap="plasma") le parametre cmap nous permet de modifier la couleur de la

surface

--HISTOGRAMME

Ils nous permettent de voir la distribution des donnees

[Link](x[:,0],bins=) le parametre bins determine le nombre de section que l'on desire avoir dans notre
histogramme

on peut mettre deux histogrammes dans un meme graphique comme on l'a fait avec les courbes et on
peut aussifare des histogrammes en 2d

plt.hist2d(x[:,1],x[:,2],cmap=) on doit faire passer deux variable

[Link]() une sorte de legende aui nous aide a comprendre la distribution

--CONTOUR PLOT

Utile pour visualiser un model 3d en vue du dessus

[Link](X,Y,Z,20,c=) dans ce cas vingt et le nombre de niveaux

ou

[Link](X,Y,Z,cmap=)

[Link]()

--Imageshow

nous permet d'afficher une image ou n'importe quelle autre tableaundarray

[Link]([Link](x.T)) dans ce cas il nous permet de visualisez la matrice de correlation

SCIPY
Il pEut nous aider a interpoler(relier des points):

from [Link] import interpld

f= interpld(x,y,kind='linear') le parametre kind nous aide a determiner le type d'interpolation dans ce cas
on utilise une interpolation linear mais il y en a d'autres(cubic,etc)

new_x=[Link](0,10,30) on cree d'autres tableau qui vont nous aider a placer des points dans les
vides

result=f(new_x)

[Link](x,y)

[Link](new_x,result,c='r') puis on affiche les deux nuage de points l'ancien et celui qui nous permet
d'interpoler

le module OPTIMIZE
--Optimize:

la fonction minimize nous permet de trouver le minimum de n'importe quel fonction mathematique,elle
peut etre utiliser avec les fonctions de deux,trois,quatre dimensions

def f(x):

return x**2+2x+3
x=[Link](-10,10,100)

[Link](x,f(x))

result=[Link](f,x0=5).x

puis on peut utiliser matplotlib pour afficher la foction et son minimum

EN 2d

Dans ce cas le point de depart x0 sera un point 2d ndarray de dimension (2,1)

x0=[Link]((2,1))
result=[Link](f,x0=x0).x

le module SIGNAL
Fonction detrend nous permet d'eliminer les tendances lineaires de la fOnction

from scipy import signal

new_y= [Link](y) ,y etant la fonction

Le module fftpack
La transformation de fourier : nous permet de decomposer un signal(compose de plusieurs frequences)
en frequence ,le reultat est appele spectre( reliant les frequences sur l'axe des x et les amplitudes sur les
y)

from scipy import fftpack

fourier=[Link](y) y etant le signal

power=[Link](fourier) on ne retient que les valeurs positives

frequences=[Link]([Link]) [Link] nous permet d'indiquez le nombre de frequences

[Link]([Link](frequence),power)

La transformation de fourrier peut nous aider a filtrer un signal en 3 etapes:

-transformaton de fourier pour obtenir un spectre a partir d'un signal

-utiliser le boolean indexing pour filtrer

-utiliser la transformation de fourier inverse pour revenir a un signal filtre

on vient deja de faire la premiere etape

fourier[power<400]=0 2e etape

[Link](fourier)

NDIMAGE
TRAITEMENT D'IMAGE:
DILATION: imprime les pixels

EROSION LES SUPRIMES

open_x=nd_image.binary_opening(X) cette fonction nous permet d'effectuer les deux afin de traiter une
image

[Link](open_x)

PANDAS
CHARGER UN DATASET

import pandas as pd

data=pd.read_csv("[Link]")

data=pd.read_excel("[Link]")

data=pd.read_json("[Link]") ,etc

[Link]

[Link]

[Link]()

pour supprimer des colonnes

data=[Link]([liste des noms des colonnes],axis=1)

[Link]() nous permet de voir les statistiques de bases

si il y a des valeurs manquantes :

on peut soit les remplacer par une valeur

[Link](data["colonne"].mean()) ici par exemple on remplace par la moyenne

ou soit on peut les supprimer

[Link](axis=0) ici on veut supprimer les lignes

data["colonne"].value_counts nous permet de voir les differentes categories devaleur dans la colonne et
combien de fois ils apparaissent

Pandas utilise [Link]

data["colonne"].value_counts.[Link]()

data["colonne"].hist(bins=)

data["colonne"].plot()

data["colonne"].[Link](x=,y=)

[Link].scatter_matrix(data["colonne"])

poour plus de performances on utilise seaborn

LA FONCTION GRPOUPBY

[Link](["colonne"].mean()

[Link](["colonne1","colonne2"].mean()

La fonction set_index() nous permet de placer une colonne en tant qu'index

data.set_index("nom de la colonne")

On peut assembler deux series lorsqu'elle partage un meme index

Pour l'indexing on peut utiliser iloc et loc

[Link][0,0]

[Link][0:2,0:3] avec iloc on selectionne selon la valeur de l'index

[Link][0,"age"]

[Link][0:2,["age","sex"]] avec loc on selectionne selon le nom de la colonne

0:2 avec iloc selectionne les deux premiere ligne 2 est exclus

0:2 avec loc selectionne les trois premiere ligne 2 est inclus
BOOLEAN INDEXING

[Link][data["colonne1"]>10,"colonne 2"]=6 en utilisant le boolean indexing avec la fonction loc on

peut remplacer une valeur dans une colonne 2 en foction d'une condition appliquee dans une colonne 1

TIME SERIES

data=pd.read_csv("[Link]",index_col="Date",parse_date=True) le parametre index_col nous permet

de placer la colonne de date en tant qu'index et parse_date fait comprendre a pandas que ce sont des
dates et l'index est maintenant du type DateTimeIndex

avec ca on peut effectuer de l'indexing et du slicing sans probleme

En general pandas comprend plusieurs format de date mais si il n'y arrive pas on peut effectuer la
conversion avec la fonction to_datetime

pd.to_datetime('2023/03/30')

"2023/03/30 12:30:21.34" pandas peu aller jusqu'au nano seconde

La fonction resample nous permet de regrouper les donnees selon une frequence(mois,semaine)

[Link]["2019","close"].resample("M").plot() on affiche un graphique selon le mois

[Link]["2019","close"].resample("2W").mean().plot() on affiche un graphique avec les moyenne

toutes les deux semaines

on peut utilser la fonction aggregate pour utiliser plusieurs fonctions par dessus la fonction resample

[Link]["2019","close"].resample("2W").agg(['mean','min','max']) si on affiche ca on aura un dataframe

avec une colonne d'index ou sont afficher les date de 2019 toutes les deux semaines et trois autres
colonnes (mean,max,min)

MOVING AVERAGE

Au lieu de faire la moyenne sur toutes les valeurs on fait la moyenne sur une fenetre de valeur on decalle
d'une valeur et refait la moyenne et ainsi de suite

on utilise la fonction rolling

[Link]["2019","close"].rolling(window=7,center=True).mean() le parametre window nous permet de

determiner la fenetre de valeur et le paramere center permet de recentrer les valeur

La moyenne mobile exponentielle les valeurs perdent peu a peu dupoids avec le temps grace aux factuer
de lissage alpha

.On utilise la foction ewm

[Link]["2019","close"].ewm(alpha=0,6).mean() alpha le facteur de lissage est compris entre 0 et 1 et
on peut mesurer l'efficacite avec differentes valeurs de alpha

ASSEMBLER DES DATASET

Dataframe3=[Link](Dataframe1,Dataframe2,on="colonne",how='inner',suffixes=("_1","_2"))

le parametre on nous permet d'indiquer sur quel colonne en assemble(ce doit etre une colonne qu'ils
ont en commun), le parametre how indique comment on assemble avec inner si une dataset est plus
grande que l'autre on ne va retenir que les valeur commune avec outer on retient tout mais il y a des
valeurs manquantes(how peut aussi avoir right ou left comme valeur) le parmetre suffix nous permet
d'inquer le suffix apres les colonne de la 1ere et 2eme dataframe

Dataframe3[["close_1","close_2"]] pour calculer la correlation entre deux colonnes des differentes

dataframe assemblees

MAP ET APPLY
map est utiliser pour les series pour appiquer une fonction a chaque element de la serie

data["age"].map(lambda x:x-1)

data["age"].map(lambda x:len(x))

data["age"].map(classeur) classeur etant une fonction que j'ai defini au prealable qui prend en agument
les elements de la serie et qui nous retrourne quelque chose

apply par contre peut etre utilise soit pour un series soit pour un dataframe entier,elle permet
d'appliquer une fonction sur tous les elements d'un dataframe en suivant un axe(axis=0 lignes,axis=1
colonnes)

applymap() sert a appliquer une fonction sur tous les elements d'un dataframe elle est similaire a map
mais pour les dataframe en entier

CATEGORIES --> NUMERIQUES

3 approches:

data["sex"].map("male":0,"female":1)

data["sex"].replace(["male","female"],[0,1])

data["sex"].astype('category').[Link] la troisieme methode est preferable vu que meme quelque soit

le nombre de categories on aura pas a beaucoup ecrire
SEABORN
Les fonctions seaborn ont presque tous la meme forme

[Link](x,y,data,hue,size,style)

x,y,data=les donnees a afficher

X LA COLONNE SUR L'AXE X

Y LA COLONNE SUR L'AXE Y

data LA DATAFRAME

hue,size,style=options de segmentations

hue permet de differencier les points(du graphique) en fonction d'un troisieme element qui sera une
varible categorielle(la difference se fera en couleur)

size nous permet de controller la taille de points on peut le remplir avec une colonne de varible
numerique ou uneliste/array de valeurs numeriques

style nous permet de changer la forme en y attribuant une variable categorielle,dans ce cas chaque
categorie aura une forme differente(cercle,triangle,etc)

Les foctions les fonctions les plus utiles:

1)pairplot()

2)caplot()

3)boxplot()

4)distplot()

5)jointplot()

6)Heatplot()

Matplotlib ou seaborn

seaborn: data,exploration statistique,vision globale

matplotlib:foction,matrices,math,science,ingenierie,graphique specialise

APPRENTISSAGE SUPERVISE
--En fournissant des donnees a la machine on constitue un dataset
--On specifie le type de modele et les hyperparametres de ce model

--Grace a un parametre d'optimisation la machine trouve les parametres qui fournissent les meilleures
performances sur le dataset,C'est ce qu'on appele la phase d'entrainement

--pret a etre utilise

Il peut etre utilse pour des problemes de regression lorsqu'on dois predire une variable
continue(numerique)

ou de classification lorsqu'n doit predire une varibale discrete(categorielle)

Etapes:

model=LinearRegression(...) on selectionne un estimateur(type de model) et on precise ces

hyperparametres

on l'entraine avec les donnees X,y \

[Link](X,y)

on l'evalue

[Link](X,y)

Utilise le model

[Link](X)

exemple:

from [Link] import KneighborsClassifier

model= KneighborsClassifier()

y=titanic["survived"]

X=[Link]("survived",axis=1)

[Link](X,y)

[Link](X,y)

[Link](X)

def survie(model,pclass=3,sex=0,age=26):

x= [Link]([pclass,sex,age]).reshape(1,3) on doit mettre les features dans le meme ordre que dans
la dataset et on soit utiliser reshape pour la transtormer en 2D
 print([Link](x))

print(model.predict_proba(x)) cette methode estb presente dans certains model et nous permet de
calculer laprobabilite d'appartenir a une categorie oy l'autre en target

Le module model selction

train_test_split :on ne peut pas entrainer et tester nos donner avec les memes donnees d'ou on les
separe

from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0,2) le parametre test_size nous permet

d'indiquer le pourcentage de donees place dans le donnees de test,en genral on choisit 20%

from [Link] import KneighborsClassifier

model= KneighborsClassifier(n_neighbors=3)

y=titanic["survived"]

X=[Link]("survived",axis=1)

[Link](X_train,y_train)

[Link](X_test,y_test)

[Link](X)

CROSS VALIDATION:

Consiste a diviser nos donner en split et chaque fois on va tester avec le un split en ayant entraine avec le
reste. A la fin on fait la moyenne de des score obetenu en testant sur different split

from sklearn.model_selection import cross_val_score

cross_val_score(KneighborsClassifier(),X_train,y_train,cv=5,scoring='accuracy').mean()

donc comme parametre il ya le model,les donnees d'entrainement,le parametre cv permet d'indiquer le

nombre de plis,et le parametre scoring indique le metric utiliser pour evaluer le model si on l'indique pas
il y en aura un par defaut lie au model

pour choisir le meilleur hyperparametre n_neighbors on peut utiliser la foction validation score qui va
nous permettre de faire cette observation avec un graphique

from sklearn.model_selection import validation_curve

model=KneighborsClassifier()
k=[Link](1,50)

train_score, val_score = validation_curve(model,X_train,y_train,n_neighbors,k,cv=5)

[Link](k,val_score.mean(axis=1)) grace a cette technique on peut en meme temps afficher le

train_score et du coup facilement detecter l'overfitting

La fonction GridSearchCV nous permet d'indiquer la meilleure combinaison d'hyperparametre dans un

model

form sklearn.model_selection import GridSearchCV

param_grid={'n_neighbors':[Link](0,20),'metrics':['euclidean','manathan']} on cree un dictionnaire

qui asssocie lles hyperparametre a leur valeur possibles

grid= GridSearchCV(KneighborsClassifier(),param_grid,cv=5)

[Link](X_train,y_train)

print(grid.best_score_) pour afficher le meilleur score

print(grid.best_params_) pour afficher les meilleurs parametres

model=grid.best_estimator_ on le sauvegarde

[Link](X_test,y_test) et on le test avec d'autres donnees

si om veut tester avec beaucoup plus d'hyperparametre on prut utiliser RandomizedSearchCV qui va
chercher la meilleure configuration au hasard avec un nombre d'iteration qu'on devra preciser

grid= RandomizedSearchCV(KneighborsClassifier(),param_grid,cv=5,n_iter=40)

Différentes stratégies de cross validation:

1) K Fold: on mélange les train_set grâce au Shuffle par défaut et ensuite on le divise en Split,on utilise
un Split pour valider le model et le reste pour l'entraînement et ainsi de suite juqu'à avoir utiliser tous les
splits pour la validation

from [Link] import KneighborsClassifier

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import KFold

CV=KFold(5,random_state=0) ici le nombre de Split c'est 5

Score-=cross_v_score(KneighborsClassifier,X,y,cv=CV).mean()

L'un des cas particuliers de KFold ça s'appelle leave one out qui consiste à tester le model sur chacun des
exemples d'où le nombre de Split est égal au nombre de ligne

from sklearn.model_selection import KFold,LeaveOneOut

CV=LeaveOneOut()

Score-=cross_v_score(KneighborsClassifier,X,y,cv=CV) mais elle ne marchera pas avec les dataset trop

grande du au nombre élevé d'exemples

La stratégie KFold présente un inconvénient si on est dans des situations où il y a des classes
déséquilibré(une cartegorie se présente en très petit nombre,tandis qu'une autre domine) mais elle
reste très bonne surtout pour les problème de régression où il n'y a pas de classe

2) Shuffle split :

On mélange le train_set on définit une portion (20% par exemple) pour valider et le reste pour
entraîner,on remelange on utilise la même portion

Pour valider et le reste pour entraîner et ainsi de suite autant de fois qu'on le veut

from [Link] import KneighborsClassifier

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import ShuffleSplit

CV=ShuffleSplit (4,test_size=0.2) ici le nombre de on va recommencer 4 foid

Score-=cross_v_score(KneighborsClassifier,X,y,cv=CV).mean() .Cette stratégie présente le même

inconvénient quant aux classes déséquilibrées

3) Stratified Kfold: consiste a créer des Split dans les quels on retrouve une portion de toutes les classes:

from [Link] import KneighborsClassifier

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import StratifiedKFold

CV= StratifiedKFold (4) ici il y a 4 splits

Score-=cross_v_score(KneighborsClassifier,X,y,cv=CV).mean().

Pas d'inconvénients

4) GroupKFold:lorsqu'on a des données qui dépende d'un groupe,par exemple on peut assembler les
membres d'une famille,ou bien assembler les membres d'une même classe dans ce cas dans le
paramètre groups il faut faire passer la colonne catégorielle qui différencie mes groupes(famille,classe)
from [Link] import KneighborsClassifier

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import GroupKFold

CV= GroupKFold (4).get_n_splits(X,y,groups=) ici il y a 4 entraînement

Score-=cross_v_score(KneighborsClassifier,X,y,cv=CV).mean().

Metrics

from [Link] import*

mae=mean_absolute_error(y,y_pred)

mse=mean_squarred_error(y,y_pred)

Dans quel situation utiliser MAE ou MSE:

-On utilise le MSE lorsqu'on accorde une grande importance aux grandes erreurs

-Par contre,on utilise le MAE:si l'importance d'une erreur est linéaire avec son [Link] le dataset
contient des valeurs aberrantes(outliers,En data science, un outlier (ou valeur aberrante) est une donnée
qui diffère fortement des autres observations dans un ensemble de données. Il s'agit d'un point qui
semble "anormal" ou éloigné des tendances générales)

D'ailleurs la median_absolute_error est beaucoup moins sensible au valeurs aberrantes

D'où autant utiliser plusieurs metrics pour récolter le plus d'informations possibles.

R² est la metrics implémenter dans la mé[Link]() des model de régression.

Si on veut utiliser plusieurs metrics dans une cross validation il suffit de fournir une liste de metrics dans
le paramètre scoring de cross_val_score sous forme de string

CONFUSION MATRIX:
Cette fonction est un outil tres utile pour les problemes de classification qui nous permet de voir les
erreurs de classement

from [Link] import confusion_matrix

print(cofusion_matrix(y_test,[Link](X_test))

LEARNING CURVE:

Elle nous montre l'evolution de la performance du model en fonction de la quantite de donnees

from sklearn.model_selection import learning_curve

N,train_score,val_score=learning_curve(model,X_train,y_train,train_size=[Link](0.2,1.0,5),cv=5)

le parametre train_size permet de d'indiquer le premier pourcentage de donnees 20%,le dernier 100%
et le nombre de pourcentage total 5 et tout ca est stocke dans la variable N

puis avec du matplotlib on peut observer l'evolution des scores(train_score,val_score) en tracant de

courbe et en mettant N sur l'axe des y

[Link]()

[Link](2, 1, 1)

[Link]("TRAIN")

[Link](N,train_score.mean(axis=1))

[Link](2, 1, 2)

[Link]("VALIDATION")

[Link](N,val_score.mean(axis=1))

[Link]()

RESUME
1) Créer un Train set et un Test set. Entraîner puis évaluer

2) Avec GridSearch, trouver les meilleurs hyper-paramètres n_neighbors, metrics et weights

3) Est-ce-que collecter plus de données serait utile ?

DATA PREPROCESSING
Dans le module [Link] on a plusieurs objet de class transformers

et ces transformers on une methode .fit() qui permet de develooper une fonction de transformation aa
partir des donnees d'entrainement(X_train) et une methode transform() qui permet d,appliquer cette
fonction pour transformer le donnees d'entrainement et de [Link] methode fit_transforme(X_trian) fait
d'une pierre deux coups

En reume, on divise le data set en train_set et en test_set ,on utilise la methode fit_transform sur les
donnees du train_set puis on entraine notre estimateur avec le train_set [Link] on utilise la
methode transform sur les donnees du test_set,et on utilise l'estimateur pour faire de nouvelles
predictions.

NB:En combinant un transformer et un estimateur,on obtient une pipeline

TRANSFORMER D'ENCODAGE:

Il y en a 5 et nous permettent d'effectuer deux types d'encodage:

1)Encodage ordinal: remplacer chaque categorie par une valeur numerique, il y a deux transformer qui
nous aide a le realiser:

--LabelEncoder: A ete concu pour encoder une seule colonne ,en l'occurence la variable y

import numpy as np

y=[Link](['chat','chien','oiseau','chat'])

from [Link] import LabelEncoder

encoder=LabelEncoder()

y=encoder.fit_transform(y)

b=encoder.inverse_transform([Link]([0,0,2,2])) la fonction inverse_transform nous permet de

[Link] on veut encoder X c'est a dire plusieurs colonne on doit utiliser OrdinalEncoder() a la place de
LabelEncoder()

NB: C'est que ca etablit un ordre arithmetique entre les categorie c'est qui affecte la plupart des model a
l'exception des model d'arbre,pour y remedier on utilise le one-hot encodage

2) Encodage One-hot:

consiste a decomposer chaque categorie de facon binaire

chat --> 1 0 0

chien-->0 1 0

oiseau-->0 0 1

On peut utiliser trois transformer:

--LabelBinarizer()

--MultiLabelBinarizer()

--OneHotEncoder()

from [Link] import LabelBinarizer

y=[Link](['chat','chien','oiseau','chat'])

encoder=LabelBinarizer(sparse_output=True,handle_unknown)
y=ebcoder.fit_transform(y)

Si on a un large dataset avec plusieurs categories et qu'on utilise l'encodage one-hot ca risque de devenir
trop volumineux du coup le parametre sparse_output=True nous eprmet de compresser le resultat,mais
il n'est pas necessaire avec le transformer OneHotEncoder() car le resultat est compresse par defaut ,le
parametre handle_unknown peut avoir deux valeur 'error' pour retourner une erreur si on se retrouve
face a une categorie inconnu ou 'ignore' pour ignorer

NORMALISATION:

Consiste a mettre toutes les donnees quantitatives sur la meme echelle

Les trois techniques les plus connues sont:

1) la normalisation MinMax

consiste a transformer chaque variable de telle sorte qu'elle soit comprise entre 0 et 1

formule: XTRAINSCALED=(XTRAIN-XTRAINmin)/(XTRAINMAX - XTRAINMIN)

from [Link] import MinMaxScaler

X= [Link]([70],[80],[120])

scaler=MinMaxScaler()

X=scaler.fit_transform(X) On devra aussi normaliser au prealable les donnees de test

X_test=[Link]([90])

X_test=[Link](X_test) Dans ce cas voici ce qui se passe:

XTESTSCALED=(XTEST-XTRAINmin)/(XTRAINMAX - XTRAINMIN)

2) STANDARDISATION

Consiste a transformer nos variables de telle sorte que chaque variable ait une moyenne nulle et un
ecart-type=1

formule= (X-µX)/ø µX etant la moyenne et ø l'ecart type

from [Link] import StandardScaler

X= [Link]([70],[80],[120])

scaler=StandardScaler()

X=scaler.fit_transform(X)
X_test=[Link]([90])

X_test=[Link](X_test)

Les deux techniques ci-haut sont sensibles au valeurs aberrantes(outliers) et deviennent et rendent les
donnees difficiles a exploiter vu qu'elles sont vraiment ecrasees(reduites) en vue de respecter les
contraintes(entre 0 et 1, moyenne=o et ecart type=1) tout en maintenant la distance entre les donees.
Pour y remedier on peut normaliser grace a RobustScaler qui lui n'est pas sensible aux outliers

3) RobustScaler:

formule:

XSCALED= (X- mediane)/ IQR IQR etant l'interquartile

from [Link] import RobustScaler

X= [Link]([70],[80],[120])

scaler=RobustScaler()

X=scaler.fit_transform(X)

X_test=[Link]([90])

X_test=[Link](X_test)

AUTRE TRANSFORMER UTILE DU MODULE PREPROCESSING:

--PolyFeatures: cree des variable polynomailes a partir des variables

ex: 2 variables x1 et x2 --> polynome 2

x1,x2 --> 1,x1,x2,x12,x1x2,x22

ces variables n'etant pas sur le meme echelle il faut les normaliser avant de les utiliser

--PowerTransformer: permet de faire une transformation non lineaire pour arranger la distribution de
donnees, et faciliter l'apprentissage

--Pour la discretisation,qui consiste a diviser une variable continue en categories, on a deux

transformer:1) Binarizer:

X=[Link](0,5,10).reshape((10,1))

X=Binarizer(threshold=3).fit_transform(X) Dans ce cas les valeurs en dessous de 3 auront la valeur de 0 et

celle au dessus auront la valeur de 1

2)KBinsDiscretizer:
Qui fait la meme chose en decoupant la variable en plus de deux categories

X=[Link](0,5,10).reshape((10,1))

X=KBinsDiscretizer(n_bins=6).fit_transform(X) n_bins c'est le nombre de categories qui seront stocke de

maniere binaire

--FunctionTransformer : est un transformer personnalisable dans lequel on peut entrer n'importe quel
fonctiom

X=[Link](0,5,10).reshape((10,1))

Mon_transformer= FunctionTransformer( func=[Link],inverse_func=[Link])

X=Mon_transformer.fit_transform(X)

TRANSFORMERS DU MODULE IMPUTE

1) SimpleImputer

from [Link] import SimpleImputer

imputer=SimpleImputer(missing_values=[Link],strategy='mean') missing_values permet de déterminer

le type de valeur qu'on veut remplacer la c'est les valeurs de type nan mais on pourrait très bien le faire
avec les valeurs négatives par exemple,la strategy peut être 'mean' on remplace par la moyenne,on peut
remplacer par la médiane ou 'most_frequent' on remplace par la valeur la plus fréquente

imputer.fit_transform(X)

2)KNNImputer:consiste à deviner la valeur manquante en se basant sur la ressemblance avec les voisins:

from [Link] import KNNImputer

imputer=KNNImputer(n_neighbors=1)

Imputer.fit_transform(X)

On peut utiliser GridSearchCV pour optimiser n_neighbors

3) MissingIndicator:sert à indiquer l'emplacement des valeurs manquantes :

from [Link] import

b=MissingIndicator().fit_transform(X)

print(b) ça va nous retourner un tableau numpy avec des True à l'emplacement des valeurs manquantes
et des False où il n'y en a pas
SKLEARN PIPELINE
On assemble le transformer et l'estimateur dans une pipeline

from [Link] import make_pipeline

model=make_pipeline(StandardScaler(),SGDClassifier()) on fait passer en parametre le transformer et

l'estimateur

[Link](X_train,y_train)

[Link](X_test)

PIPELINE GRIDSEARCHCV

from sklearn.model_selection import GridSearchCV

model=make_pipeline(PolynomialFeatures(),StandardScaler(),SGDClassifier(random_state=0)

params={'polynomialfeatures__degree': [2,3,4],'sgdclassifier__penalty':['l1','l2']}

vu que le model est dans un pipeline dans le dictionnaire d'hyperparametre on met son nom__ et le
parametre

grid= GridSearchCV(model,params,cv=4)

[Link](X_train,y_train)

model=grid.best_estimator_

Pipeline avancée:

1) make_column_transformer

from [Link] import make_column_transformer

numerical_features=[ ] on etablit une liste des colonnes contenant les colonnes des variables numérique

Catégorical_features=[ ] on fait la même chose avec les variables catégorielles

numerical_pipeline=make_pipeline(simple_imputer(), StandardScaler())

Categorical_pipeline=make_pipeline(simple_imputer(strategy='most_frequent),OneHotEncoder()

On crée des pipelines pour chacun de nos groupes de colonnes

preprocessor= make_column_transformer((numerical_pipeline,numerical_features),
(categorical_pipeline,categorical_features)) grâce à la fondation make_column_transformer on sélection
quel pipeline va traiter quel colonne avec des tuples
model=make_pipeline(preprocessor,SGDClassifier()) puis on crée une pipeline final

2)make_column_selector:

Pour sélectionner les variables au lieu de mettre de liste on peut faire par exemple

numerical_features=make_column_selector(dtype_include=[Link])

Catégorical_features=make_column_selector(dtype_exclude=[Link])

Puis on continue

3) make_union(): cette fonction de créer des pipelines parallèles dont les résultats sont concatenés à la
sortie du transformer:

from [Link] import make_union

pipeline=make_union(StandardScaler(),Binarizer())

pipeline.fit_transform(numerical_features)

on aura un tableau avec des colonnes standardisé(grâce à StandardScaler()) concatenés avec un tableau
encodé (grâce à Binarizer()) ce qui fait que la deuxième dimension du tableau va doubler.

FEATURE SELECTION
1)Le transformer VarianceThreshold qui elimine les variables dont dont la variance est inferieur a un
certain seuil.

Explication:

Pour effectuer des predictions, un estimateur a besoin d'informations qui varient avec en accord la target

from sklearn.feature_selection import VarianceThreshold

selector=VarianceThreshold(threshold=0.2) 0.2 etant le seuil

X=selector.fit_transform(X)

selector.get_support() nous retourne un tableau numpy 1D rempli de booleen qui nous indique quel
colonne a ete selectionnee

2)SelectKBest est en general plus efficace, il selectionne les K variables dont le score du test de
dependance avec y est le plus [Link] statistique nous avons plusieurs test de dependance:
from sklearn.feature_selection import SelectKBest,chi2

selector=SelectKBest(chi2,k=2) ici le test de dependance est chi2 et vu qu'on a mis k=2 ca va nous
retourner les deux colonnes de X avec les scores de test de dependance les plus eleves
X=selector.fit_transform(X,y) il faut faire passer a la fois X et y qui sont neccessaire au test de
dependance

3)SelectFromModel entraine un estimateur puis selectionne les variables es plus importantes pour cet
estimateurs

Note:Compatible avec les estimateurs qui developpent une fonction parametree(attribut .coef_
ou .feature_importance_) pas compatible avec K-Nearest Neighbour

from sklearn.feature_selection import SelectFromModel

from sklearn.linear_model import SGDClassifier

selector=SelectorFromModel(SGDClassifier(random_state=0),threshold="mean'') cava selectionner les

variables dont lescoefficient sont au dessus de la moyenne des coefficients X=selector.fit_transform(X,y)
il faut inclure a la fois X et y vu que l'estimateur en a besoin pour s'entrainer

3)RFE et RFECV permet de d'effectuer une selection de feature recursive c'est a dire entrainer
l'estimateur avec le dataset eliminer un certain nombre de variables moins importantes ,entrainer
l'estimateur avec les variables restantes ,resupprimer des colonnes et ainsi de suite

fromsklearn.feature_selection import RFECV

selector=RFECV(SGDClassifier(),step=1,minimum_to_select=2,cv=5) le parametre step nous permet

d'indiquer le nombre de feature a eliminer a chaque fois minimum_to_select indique le nombre
minimum de feature qu'on veut a la fin

selector.fit_transform(X,y)

selector.ranking_ nous permet de visualiser le classement des variable par importance

[Link].score_ nous permet de visualiser le score du model apres chaque entrainement

APPRENTISSAGE NON SUPERVISE

1) CLUSTERING
Consiste a donner seulement des donnees X a la machine et non y et ensuite la machine va les
classifier,les regrouper selon leur ressemblance

K-mean clustering est un algorythme iteratif qui se deroule en 2 etapes:

--affectation des points au centre(centroid) le plus proche

--deplacement du centre vers la moyenne du cluster

en fonction de la position initiale du centroid il est possible que la convergence se passe mal pour y
remedier on execute K-mean avec plusieurs positions initiales et on retient la position qui minimise la
somme des distances entre les point du cluster et sont centre(centroid).on cherche enfaite a minimiser
une fonction cout appeler inertiasemblable a la variance

from [Link] import KMeans

model=KMeans(n_cluster=3) ici il y a trois cluster

[Link](X)

[Link](X)

print(model.inertia_) nous imprime la foction cout inertia

print([Link]()) nous imprime la foction cout inertia de facon negative

Pour trouver lebon nombre de cluster on prut utiliser la "Elbow method" qui nous permet de determiner
une zone de coude qui nous donne le nombre de cluster optimal qui minimise le cout tout en restant un
nombre raisonnable

rom [Link] import KMeans

import [Link] as plt

inertia = []

K_range = range(1, 20)

for k in K_range:

model = KMeans(n_clusters=k, )

[Link](model.inertia_)

# Tracé de la courbe

[Link](K_range, inertia)

[Link]("Nombre de clusters")

[Link]("Coût du modèle (Inertia)")

[Link]("Méthode du coude (Elbow Method)")

[Link]()

Deux autres algorythmes de clustering utiles: DBSCAN, AgglomerativeClustering

DETECTIOND'ANOMALIE
IsolationForest

on effectue un nombre desplis aleatoires et on compte le nombre de splits qu'il faut pour isoler nos
[Link] nombre de splits --> anomalie

fom [Link] import IsolationForest

model=IsolationForest(contamination=0.01) par la on dit qu'on pense qu'il y a 1% d'anomalie

[Link](X)

[Link](X[:,0],X[:,1],c=[Link](X)) [Link](X) retourne un tableau numpy avec des 1 et -1

ou les -1 represente les anomalies

NB: La detection d'anomalie contient deux branches:

--Outlier detection: detecte les anomalies dans le train_set comme le fait IsolationForest

--Novelty detection:detecte les anomalies dans les donnees futures comme le fait LocalOutlierFactor

REDUCTION DE DIMENSION
Le principe est de **réduire la complexité superflue** d’un dataset en projetant ses données dans un
espace de plus petite dimension (un espace avec **moins de variables**).

- **Accélérer l’apprentissage** de la machine

- **Lutter contre le fléau de la dimension** (risque d’overfitting lié au surplus de dimensions)

On cherche a projeter nos donnees sur des axes appeles composantes principales,encherchant
aminimiser la distance entre les points et leurs projections decette maiere on reduit la dimension de
notre dataset tout en preservant au max la variance

from [Link] import PCA On importe le transformer PCA

model= PCA(n_components=10) On indique le nombre de coposantes sur lequel on souhaite projeter

grace au parametre n_components

model.fit_transform(X)

Comment choisir le parametre n_components:

pour la visualisation si on veut visualiser les donnees en 2D n_components=2, en 3D n_components=3

Pour compresser un dataset on doit chercher a le compresser au max tout en conservant le max de
variance(95 a 99%) pour garder la qualite

model= PCA(n_components=0.95) pour coserver 95% de la variance

model.fit_transform(X)

A savoir:

- Il faut **standardiser** les données avant d’utiliser PCA (**StandardScaler**).

- PCA est normalement conçu pour traiter les **variables continues**.

- PCA **n’est pas efficace** sur les datasets **non-linéaires**.

ENSEMBLE LEARNING
Consiste a ensembler plusieurs model pour constituer une prediction [Link] doivent chacun avoir une
performance > 50 % et avoir de la [Link] y atrois techniques:

BAGGING|:

Consiste a creer plusieurs copies du meme model et d'entrainer chaque copie sur une partie aleatoire du
dataset,on utlise une technique appele bootstrapping pour faire en sorte qu'ils aient quand meme des
predictions en [Link]:RandomForest qui est un ensemble de DecisionTree

BOOSTING:

Consiste a entrainer un model, a demander a un autre model entrainer de cooriger ses erreurs et ainsi
de suite

En bagging,chaque model est fort ,en situation d'overfitting et les assembler permet de reduire la
[Link] boosting chaque model est faible en situation d'undefitting et les assembler permet de
reduire le biais

STACKING:

Au lieu de rassembler les [Link] demande a un dernier model de d'apprendre a predire le

resutat final a partir des predictions des modeles precedents

Dans le module [Link] on trouve trois class:

1)VOTING ESTIMATOR:

VOTING CLASSIFIER: On ensemble plusieurs models

from sklearn.linear_model import SGDClassifier

from [Link] import DecisionTreeClassifier

from [Link] import KneighborsClassifier

from [Link] import VotingClassifier

model_1=SGDClassifier(random_state=0)

model_2=DecisionTreeClassifier(random_state=0)

model_3=KneighborsClassifier(random_state=0)

model_4=VotingClassifier([("SGD,model_1),("Tree,model_2),("KNN",model_3),voting='hard') le
parametre voting nous permet d'indiquer le type de vote:

pour la classe VotingRegressor utilise pour les problemes de regressions on fait juste la moyenne des
predictions mais pour la class VotingClassifier on a le choix entre le hard voting(vote suir les
predictions,on voit la majorite) et le soft voting(vote sur les pribabilites de chaque class,on voit les
predictions de chaque model et a combien de % il en est sur)

for model in (model_1,model_2,model_3):

[Link](X_train,y_train)

En general utiliser les voting estimator n'est pas tres efficace a cause de la faible diversite des predictions

2) BAGGING ESTIMATOR:

from [Link] import BaggingClassifier,RandomForestRegressor

model_1=BaggingClassifier(base_estimator=KNeighborsRegressor,n_estimators=100)ici il suffit de
specifier un estimateur de base et un nombre d'estimateur qui est par defaut egal a 100

model_1.fit(X_train,y_train)

model_2=RandomForestRegressor(n_estimator=100,max_depth=) on specifie un nombre d'estimateurs

et on peut aussi jouer avec le max_depth(peu conduire a l'overfittibg) mais bien regler un randomforest
donne generalement des meilleurs resultats

model_2.fit(X_train,Y_train)

3)BOOSTING ESTIMATOR:

from [Link] import AdaBoostingClassifier,GradientBoostingClassifier

model=AdaBoostingClassifier(n_estimators=100)

[Link](X_train,y_train)

[Link](X_test,y_test)
comme d'ab ils sont aussi disponible en tant que regressor et a part le nombre d'estimateurs on peut
bien specifier d'autres parametres et le mieux est d'utliser une gridsearch

4) STACKING ESTIMATOR

from [Link] import StackimgClassifier

model_4=StackingClassifier([("SGD,model_1),("Tree,model_2),
("KNN",model_3),final_estimator=KNeighborsClassifier()) le final_estimator effectue ses predictions par
dessus celle des autres models

model_4.fit(X_train,y_train)

model_4.score(X_test,y_test)

NB: Si nos models ont tendances a faire de l'overfitting on se tourne vers le bagging.S'Ils ne sont pas
assez performants on se tourne vers le [Link] stacking peut etre tres efficace si on a passe
beaucoup de temps a entraine chaque model et qu'ils ont chacun une tres bonne
performances,cependant il prend beaucoup de temps

DEMARCHE DE TRAVAIL
1. Définir un objectif mesurable :

- Objectif : Prédire si une personne est infectée en fonction des données cliniques disponibles.

- Métriques :

- Précision (Precision)

- Racall (Recall ou sensibilité)**

- score F1 enfaite on utilise ca a la place des metrics si ples quand les class sont desequilibres dans un
probleme de classification comme la plupart du temps

Concepts clés :

- Précision (Precision)

Formule :

Précision = TP / (TP + FP)*

- Permet de réduire au maximum le taux de faux positifs.(c'est-à-dire dans ce cas réduire le nombre de
personnes envoyer à l'hôpital alors qu'ils ne sont pas malades)

- Recall
 Formule :

Rappel = TP / (TP + FN)

- Permet de réduire au maximum le taux de faux négatifs.(réduire le nombre de malades non envoyés à
l'hôpital)

- Score F1 :

Une métrique combinant précision et rappel pour une évaluation équilibrée.

Exemple de métrique souhaitée :

- F1 ≥ 50%

- Recall ≥ 70%

2. Analyse exploratoire des données (EDA - Exploratory Data Analysis) :

Objectif :*Comprendre au maximum les données disponibles afin de définir une stratégie de
modélisation.

Checklist de base :

1. Analyse de la forme :

- Identification de la variable cible (target).

- Nombre de lignes et de colonnes dans le dataset.

- Types des variables.(EX: [Link] pour avoir le type de chaque variable et [Link] .value_counts
chaque type et combien de fois il apparait)

- Identification des valeurs manquantes: pour visualisez on peut utiliser [Link]([Link]())

2. Analyse du fond :

- Visualisation de la cible (target) via histogrammes ou boxplots.

- Compréhension des différentes variables grâce à des recherches.

- Analyse des relations entre les variables explicatives et la cible (target).

- Identification des points aberrants (outliers).

si on veut travailler sur un type de variable:

for col in df.select_dtypes('float')

for col in df.select_dtypes('object')

pour la distribution on peut utiliser la fonction [Link]

pour une relation entre deux variables categorielles on peut utiliser [Link]

si on veut voir la correlation entre les variables d'un groupe de variables

[Link](df[groupe].corr())

le taux de valeurs manquantes pour chaque variable: missing_rate= [Link]().sum()/[Link][0]

3. Prétraitement des données (Pre-processing) :

- Nettoyage des données (gestion des valeurs manquantes, encodage des variables catégoriques, etc.).

- Normalisation ou standardisation des données si nécessaire.

4. Modélisation :

- Choix et entraînement du modèle.

- Évaluation du modèle à l’aide des métriques définies (Précision, Rappel, Score F1).

Slide 1 : Pre-processing

Objectif: Transformer les données pour les mettre dans un format propice au Machine Learning.

Checklist de base (non-exhaustive) :

- Création du Train set / Test Set

- Élimination des NaN : `dropna()`, imputation, colonnes « vides »

- Encodage

- Suppression des outliers néfastes au modèle

- Feature Selection

- Feature Engineering

- Feature Scaling

Slide 2 : Modelling

Objectif : Développer un modèle de Machine Learning qui réponde à l’objectif final.

Checklist de base (non-exhaustive) :

- Définir une fonction d’évaluation

- Entraînement de différents modèles

- Optimisation avec GridSearchCV

- (Optionnel)Analyse des erreurs et retour au Preprocessing / EDA

- Learning Curve et prise de décision:

Dans le cas d'une classification binaire on peut definir un seuil(threshold) a partir duquel le model emet
une prediction ou l'autre

from [Link] import precision_recall_curve

precision, recall, threshold = precision_recall_curve(y_test,

grid.best_estimator_.decision_function(X_test))

[Link](threshold, precision[:-1], label='precision')

[Link](threshold, recall[:-1], label='recall')

[Link]()

on affiche un graphique avec le threshold sur l'abscisse et la precision et le recall sur les
ordonnees et en general il est mieux de decigner l'intersection de ces deux courbes comme seuil(en
general bien sur)

def model_final(model, X, threshold=0):

return model.decision_function(X) > threshold cette fonction est notre model final qui effectura des
predictions en fonctions de notre seuil personnalise

y_pred = model_final(grid.best_estimator_, X_test, threshold=1)

puis on peut l'evaluer

from [Link] import recall_score

f1_score(y_test, y_pred)

recall_score(y_test, y_pred)