COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

FINANCE & DATA SCIENCE

Machine Learning avec Python

Partie 2 — Implementation et Preparation des Donnees

Entrainement | Evaluation | Prediction | Nettoyage | Encodage | PCA | Mise a l'echelle

Applications Finance : Credit Scoring, Detection de Fraude, Prediction de Cours

Table des matieres

Partie A — Entrainement et Evaluation des modeles

A1. [Link]() — Entrainement
A2. [Link]() — Evaluation avec R2
A3. train_test_split() — Decoupage des donnees
A4. [Link]() — Predictions
A5. Evaluation d'un modele de Classification
A6. Evaluation d'un modele de Regression
A7. Exemple complet avec Matplotlib
Partie B — Preparation et Nettoyage des Donnees
B1. Collecte et lecture des donnees (Pandas)
B2. Nettoyage : valeurs manquantes, doublons, erreurs
B3. Encodage des variables categorielles
B4. Reduction de dimension (PCA)
B5. Mise a l'echelle (Standardisation, Normalisation)
B6. Pipeline complet enchaine

PARTIE A
Entrainement, Evaluation et Prediction des Modeles

A1. [Link]() — Entrainement du modele

[Link](X_train, y_train) est la methode d'ENTRAINEMENT du modele. Elle prend les

donnees et calcule les coefficients (la droite de regression) qui minimisent l'erreur entre les

Page 1 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

predictions et les vraies valeurs. C'est ici que la machine APPREND.

Lorsqu'on appelle fit(), sklearn calcule automatiquement deux elements fondamentaux :

• model.coef_ : La pente de la droite de regression (combien Y augmente quand X
augmente de 1)
• model.intercept_ : L'ordonnee a l'origine (la valeur de Y quand X = 0)

Code Python — Prediction du cours boursier

from sklearn.linear_model import LinearRegression
import numpy as np

# X = variable d'entree : Benefice Par Action (BPA) en euros

X = [[1], [2], [3], [4], [5]]

# y = variable cible : cours de l'action en euros

y = [52, 55, 58, 61, 64]

model = LinearRegression() # creation du modele vide

[Link](X, y) # le modele APPREND ici

print(model.coef_) # pente de la droite -> [3.0]

print(model.intercept_) # ordonnee a l'origine -> 49.0

APPLICATION FINANCE — FIT()

Apres [Link](), le modele a appris la relation entre les indicateurs financiers (BPA, taux
d'interet, CA) et le cours de l'action. Il peut desormais predire les cours futurs pour de
nouvelles valeurs de BPA jamais vues. En credit scoring, fit() apprend la frontiere entre bon
payeur et mauvais payeur a partir des dossiers historiques.

RESUME DE LA SECTION
• fit(X, y) = l'etape d'APPRENTISSAGE — la machine calcule les coefficients optimaux
• model.coef_ = la pente (impact de X sur Y)
• model.intercept_ = la valeur de depart (quand X=0)
• Sans fit(), le modele ne peut ni predire ni scorer

A2. [Link]() — Evaluation avec R2

[Link](X_test, y_test) retourne le coefficient de determination R2, un nombre entre 0 et

1 qui mesure a quel point le modele explique la variabilite des donnees. Plus R2 est proche
de 1, meilleur est le modele.

Code Python
r2 = [Link](X_test, y_test)
print(r2) # ex: 0.95 -> le modele explique 95% de la variance

Page 2 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

Grille d'interpretation du R2
Valeur R2 Interpretation En finance
0.95 — 1.00 Excellent Modele tres fiable, utilisable en
production
0.80 — 0.95 Bon Acceptable pour le credit scoring
0.60 — 0.80 Moyen A ameliorer avant deploiement
0.00 — 0.60 Faible Modele peu utile
Negatif Tres mauvais Pire que de predire la moyenne

CORRECTION : Overfitting (surapprentissage)

Si score() est appele sur les MEMES donnees que fit(), le score est artificiellement gonfle. Le
modele a memorise les reponses comme un etudiant qui connait les questions d'avance.
Toujours evaluer sur X_test (donnees jamais vues pendant l'entrainement).

RESUME DE LA SECTION
• score() = mesure la QUALITE du modele via R2 (entre 0 et 1)
• Toujours utiliser score(X_test, y_test) — jamais score(X_train, y_train)
• R2 > 0.80 = bon modele pour la finance
• R2 negatif = le modele est inutile

A3. train_test_split() — Decoupage des donnees

Avant d'entrainer un modele, on divise TOUJOURS les donnees en deux parties : les
donnees d'entrainement (X_train, y_train) sur lesquelles le modele apprend, et les donnees
de test (X_test, y_test) sur lesquelles on evalue honnêtement le modele.

Syntaxe complete
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(

X, # donnees d'entree
y, # variable cible
test_size=0.2, # 20% pour le test, 80% pour l'entrainement
random_state=0 # fixe le melange -> resultats reproductibles
)

Explication de chaque parametre

Parametre Explication
X, y Les donnees completes a decouper (entrees et sorties)

Page 3 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

test_size=0.2 20% des donnees reservees pour le test, 80% pour

l'entrainement
random_state=0 Fixe le melange aleatoire. Meme resultat a chaque
execution. Le chiffre 0 est une convention (42 aussi
populaire)
X_train / y_train Les 80% utilises par [Link]() pour apprendre
X_test / y_test Les 20% utilises par [Link]() pour evaluer
honnêtement

Analogie de l'examen
Analogie Examen Equivalent ML
Exercices de revision X_train — donnees d'entrainement
Examen final (nouvelles questions) X_test — donnees de test
Apprendre sur les exercices [Link](X_train, y_train)
Passer l'examen [Link](X_test, y_test)

RESUME DE LA SECTION
• Toujours decouper les donnees AVANT d'entrainer le modele
• test_size=0.2 = 20% test / 80% train (repartition standard)
• random_state fixe le melange aleatoire pour la reproductibilite
• Le modele ne doit JAMAIS voir X_test pendant l'entrainement

A4. [Link]() — Generer des predictions

Apres entrainement avec fit(), [Link](X_nouveau) permet de predire les valeurs Y

pour de nouvelles donnees X que le modele n'a jamais vues. C'est la methode la plus utilisee
en production.

Les 3 etapes fondamentales

[Link](X_train, y_train) # 1. Le modele APPREND
[Link](X_test, y_test) # 2. On EVALUE sa qualite
[Link](X_nouveau) # 3. On PREDIT de nouvelles valeurs

# Difference cle :
# score() -> compare predictions aux vraies valeurs (mesure qualite)
# predict() -> retourne directement les valeurs predites (usage reel)

Exemple complet — Prediction du cours boursier

import numpy as np
from sklearn.linear_model import LinearRegression

Page 4 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

from sklearn.model_selection import train_test_split

# Donnees historiques : BPA et cours de l'action

X = [[1.2],[1.5],[1.8],[2.0],[2.3],[2.5],[2.8],[3.0],[3.2],[3.5]]
y = [48, 52, 57, 61, 65, 68, 73, 76, 80, 85]

# Etape 1 : Decoupage
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=0)

# Etape 2 : Entrainement
model = LinearRegression()
[Link](X_train, y_train)
print('Modele entraine !')

# Etape 3 : Evaluation
score = [Link](X_test, y_test)
print(f'Score R2 : {score:.2f}') # -> 0.99

# Etape 4 : PREDICTIONS sur de nouveaux BPA

nouveaux_bpa = [[4.0], [4.5], [5.0]]
predictions = [Link](nouveaux_bpa)

print('--- Predictions du cours ---')

for bpa, cours in zip(nouveaux_bpa, predictions):
print(f'BPA = {bpa[0]}E -> Cours predit = {cours:.2f}E')

# Resultats :
# BPA = 4.0E -> Cours predit = 96.34E
# BPA = 4.5E -> Cours predit = 103.21E
# BPA = 5.0E -> Cours predit = 110.08E

Resume des 3 methodes

Methode Ce qu'elle fait Ce qu'elle retourne
fit(X_train, y_train) Entraine le modele Rien (modifie le modele)
score(X_test, y_test) Evalue la qualite R2 entre 0 et 1
predict(X_nouveau) Fait des predictions Les valeurs Y predites

RESUME DE LA SECTION
• predict() est la methode de PRODUCTION — elle delivre la vraie valeur du modele
• predict() retourne une liste de valeurs numeriques (regression) ou de categories
(classification)
• En finance : predire les cours futurs, scorer les demandes de credit, detecter les
fraudes

A5. Evaluation d'un modele de Classification

Page 5 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

Un modele de classification predit des CATEGORIES (ex: fraude=1 ou legitime=0). Le R2 ne

suffit plus : on utilise des metriques specifiques basees sur la matrice de confusion.

Les 4 situations possibles — Matrice de confusion

REALITE : Fraude (1) REALITE : Legitime (0)
PREDIT : Fraude (1) TP — True Positive FP — False Positive
Dit FRAUDE + vrai ✅ Dit FRAUDE + faux ✅

PREDIT : Legitime (0) FN — False Negative TN — True Negative

Dit LEGITIME + faux ✅ Dit LEGITIME + vrai ✅

Les 6 metriques de classification

Metrique Formule Signification
Accuracy (TP+TN) / Total % de bonnes predictions (toutes
categories)
Precision TP / (TP+FP) Parmi les fraudes detectees, combien
sont vraies ?
Recall (Sensibilite) TP / (TP+FN) Parmi les vraies fraudes, combien
detectees ?
Specificite TN / (TN+FP) Capacite a identifier les transactions
legit.
NPV (Neg. Pred. TN / (TN+FN) Fiabilite des predictions negatives
Value)
F1-Score 2 x (Prec x Equilibre entre Precision et Recall
Rec)/(Prec+Rec)

CORRECTION : Formule Specificite (corrigee)

Vos notes indiquent Specificite = TP/(TN+FP) — c'est INCORRECT. La formule exacte est :
Specificite = TN / (TN+FP). Elle mesure la capacite du modele a identifier correctement les
cas negatifs (transactions legitimes).

Code Python — Evaluation complete

from [Link] import (accuracy_score, precision_score,
recall_score, f1_score,
confusion_matrix, classification_report)

# Apres avoir predit avec [Link](X_test) :

y_pred = [Link](X_test)

print(f'Accuracy : {accuracy_score(y_test, y_pred):.2f}')

print(f'Precision : {precision_score(y_test, y_pred):.2f}')
print(f'Recall : {recall_score(y_test, y_pred):.2f}')
print(f'F1-Score : {f1_score(y_test, y_pred):.2f}')

Page 6 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

print('\n--- Matrice de confusion ---')

print(confusion_matrix(y_test, y_pred))

print('\n--- Rapport complet ---')

print(classification_report(y_test, y_pred,
target_names=['Legitime (0)', 'Fraude (1)']))

QUELLE METRIQUE PRIVILEGIER EN FINANCE ?

Detection de fraude -> privilegier le RECALL : mieux vaut une fausse alarme que laisser
passer une vraie fraude. Une fraude non detectee coute beaucoup plus cher qu'un controle
inutile. Credit scoring -> privilegier la PRECISION : mieux vaut refuser un bon client que
d'accorder un credit a risque. Cas general -> privilegier le F1-SCORE : il equilibre Precision
et Recall et est la metrique la plus utilisee en pratique.

RESUME DE LA SECTION
• La matrice de confusion montre les 4 types d'erreurs : TP, TN, FP, FN
• Accuracy = % global de bonnes predictions
• Recall = crucial pour la detection de fraude (ne rien manquer)
• Precision = crucial pour le credit (ne pas accorder un mauvais credit)
• F1-Score = metrique equilibree recommandee en general
• Specificite = TN/(TN+FP) — formule corrigee par rapport aux notes

A6. Evaluation d'un modele de Regression

Un modele de regression predit des VALEURS CONTINUES (ex: cours = 96.34 euros). On
ne peut pas utiliser Accuracy. On utilise R2, MAE, MSE et RMSE pour mesurer la precision
des predictions numeriques.

Les 4 metriques de regression

Metrique Formule Interpretation
R2 1 - (err. modele / err. 0 a 1. Le modele explique X% de la
moyenne) variance. Plus proche de 1 = mieux.
MAE Moy(|reel - predit|) Erreur moyenne en euros. Facile a
interpreter. Ex: 0.48 euros d'ecart moyen.
MSE Moy((reel - predit)2) Penalise les grosses erreurs (elevation au
carre). Unite : euros2.
RMSE Racine(MSE) Comme MSE mais dans l'unite d'origine
(euros). LA metrique la plus utilisee.

Code Python — Exemple sur 20 mois de donnees boursieres

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

Page 7 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

from [Link] import mean_absolute_error, mean_squared_error,

r2_score

# X = [BPA, taux_interet, chiffre_affaires]

X = [[1.2,2.5,500],[1.5,2.7,520],[1.8,2.6,545],[2.0,3.0,560],
[2.3,3.1,580],[2.5,2.9,600],[2.8,3.2,625],[3.0,3.0,640],
[3.2,3.3,660],[3.5,3.1,685],[3.8,3.4,700],[4.0,3.2,720],
[4.2,3.5,745],[4.5,3.3,760],[4.8,3.6,780],[5.0,3.4,800],
[5.2,3.7,825],[5.5,3.5,840],[5.8,3.8,865],[6.0,3.6,880]]

y = [48,52,57,61,65,68,73,76,80,85,89,93,98,102,107,110,115,119,124,128]

X_train,X_test,y_train,y_test =
train_test_split(X,y,test_size=0.2,random_state=0)
print(f'Donnees entrainement : {len(X_train)} mois')
print(f'Donnees test : {len(X_test)} mois')

model = LinearRegression()
[Link](X_train, y_train)
print('\nModele entraine !')

y_pred = [Link](X_test)

print('\n--- Comparaison reel vs predit ---')

for reel, predit in zip(y_test, y_pred):
ecart = abs(reel - predit)
print(f'Reel:{reel}E | Predit:{predit:.2f}E | Ecart:{ecart:.2f}E')

r2 = r2_score(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = [Link](mse)

print(f'\nR2 : {r2:.4f}') # -> 0.9987

print(f'MAE : {mae:.2f}E') # -> 0.48 euros
print(f'MSE : {mse:.2f}') # -> 0.31
print(f'RMSE : {rmse:.2f}E')# -> 0.55 euros

Interpretation des resultats

R2 = 0.9987 -> le modele explique 99.87% de la variance du cours ✅ MAE = 0.48 euros ->
en moyenne, le modele se trompe de seulement 0.48 euros ✅ RMSE = 0.55 euros -> erreur
typique de 0.55 euros sur le cours predit ✅ Dans ce cas, les trois metriques confirment un
excellent modele. En production, un RMSE de 0.55 euros sur un cours a 100 euros
represente une erreur de 0.55% — tres acceptable.

RESUME DE LA SECTION
• R2 = metrique de reference (0 a 1) — comparer plusieurs modeles
• MAE = erreur moyenne en euros — facile a communiquer aux non-techniciens
• RMSE = erreur typique en euros — penalise les grosses erreurs
• MSE = en euros2 — moins lisible mais utile pour l'optimisation
• Prédiction de cours -> R2 + RMSE | Risque de defaut -> MAE

Page 8 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

A7. Exemple complet avec Matplotlib

Matplotlib est la bibliotheque Python de reference pour creer des graphiques. pyplot est son
module principal, importe sous l'alias plt. On l'utilise pour visualiser les donnees et la droite
de regression.

Code complet corrige — Regression lineaire avec visualisation

CORRECTION : Corrections apportees au code original
Import -> import (minuscule obligatoire) matpotlib -> matplotlib (faute de frappe) Np, Plt, M, X,
Y -> np, plt, m, X, y (conventions Python en minuscule) [Link] -> [Link]
(la fonction correcte) Linear regression -> LinearRegression (CamelCase, pas d'espace)
print([Link]) sans print() -> le score ne s'affiche pas

import numpy as np # calculs numeriques

import [Link] as plt # graphiques

# Creation des donnees

[Link](0) # fixe le hasard (reproductibilite)
m = 100 # 100 points de donnees (samples)

X = [Link](0, 10, m).reshape(m, 1) # 100 valeurs de 0 a 10

# linspace cree des valeurs regulierement espacees
# reshape(m,1) transforme (100,) en (100,1) -> requis par sklearn

y = X + [Link](m, 1) # y = X + bruit aleatoire normal

# randn genere des nombres suivant une distribution normale (moy=0)
# Simule les variations reelles d'un cours boursier

# Visualisation initiale
[Link](X, y) # nuage de points
[Link]('Donnees brutes') # titre du graphique
[Link]('Temps (mois)') # axe X
[Link]('Cours (euros)') # axe Y
[Link]()

# Modele de regression
from sklearn.linear_model import LinearRegression
model = LinearRegression()
[Link](X, y) # entrainement
print([Link](X, y)) # affiche le R2

# Predictions et visualisation finale

predictions = [Link](X) # calcule y_predit pour chaque X

[Link](X, y, label='Donnees reelles')

[Link](X, predictions, c='r', label='Droite de regression')
[Link]('Regression lineaire - Cours boursier')
[Link]('Temps (mois)')

Page 9 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

[Link]('Cours (euros)')
[Link]() # affiche la legende
[Link]() # affiche le graphique final

Explication de chaque element

Element Python Explication
import numpy as np Importe la bibliotheque numpy sous le surnom np
(calculs numeriques)
import [Link] as plt Importe le module graphique pyplot sous le surnom plt
[Link](0) Fixe le generateur aleatoire -> memes resultats a
chaque execution
m = 100 Nombre de points de donnees a creer (100 samples)
[Link](0,10,m) Cree 100 valeurs regulierement espacees entre 0 et 10
.reshape(m,1) Transforme le tableau de (100,) en (100,1) — requis
par sklearn
[Link](m,1) Genere 100 nombres aleatoires selon loi normale —
simule le bruit de marche
[Link](X,y) Trace un nuage de points (chaque point = une
observation)
[Link](X,pred,c='r') Trace la droite de regression en rouge (c='r' = color
red)
[Link]() Affiche le graphique — INDISPENSABLE sinon rien ne
s'affiche

RESUME DE LA SECTION
• [Link] = bibliotheque de graphiques, alias plt
• [Link]() = nuage de points | [Link]() = ligne
• [Link](0) = fige l'aleatoire pour la reproductibilite
• [Link]() = valeurs equidistantes | [Link]() = bruit normal
• .reshape(m,1) = obligatoire pour sklearn (2 dimensions)

PARTIE B
Preparation et Nettoyage des Donnees

B1. Collecte et Lecture des Donnees avec Pandas

Pandas est la bibliotheque Python de reference pour manipuler les donnees sous forme de
tableaux (DataFrames). On importe les donnees avec pd.read_csv() puis on explore la

Page 10 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

structure avec des fonctions dediees.

Les sources de donnees en finance

Source Exemples financiers
Fichiers CSV / Excel Historiques boursiers, bilans comptables, portefeuilles
Bases de donnees SQL Transactions bancaires, dossiers de credit
APIs financieres Bloomberg, Yahoo Finance, Banque Centrale
Web scraping Prix en temps reel, communiques de presse
Formulaires / Enquetes Profil de risque client, sondages de marche

Code Python — Lecture et exploration

CORRECTION : Corrections dans vos notes
Import panda as pd -> import pandas as pd Df: pd.read_csv([Link]) -> df =
pd.read_csv('[Link]') Unsecols -> usecols (parametre correct) Print -> print (minuscule)
Nrows=1000 -> nrows=1000 (minuscule)

import pandas as pd
import numpy as np

# Lecture du fichier CSV

df = pd.read_csv('transactions_bancaires.csv')

# Parametres utiles lors de l'importation :

df = pd.read_csv('[Link]',
sep=',', # separateur (virgule par defaut)
header=0, # 1ere ligne = noms de colonnes
index_col='id', # definir une colonne comme index
usecols=['a','b'], # charger seulement certaines colonnes
nrows=1000 # lire seulement les 1000 premieres lignes
)

# === EXPLORATION ===

print('=== DIMENSIONS ===')
print(f'Lignes : {[Link][0]}') # nb de clients
print(f'Colonnes : {[Link][1]}') # nb de variables

print([Link]()) # afficher les 5 premieres lignes

print([Link]()) # types de variables et valeurs manquantes
print([Link]()) # statistiques descriptives
print([Link]) # type de chaque colonne
print([Link]().sum()) # nb de valeurs manquantes par colonne

Identifier les variables

# Variables numeriques (int64, float64)
num_vars = df.select_dtypes(include=['int64','float64']).columns

Page 11 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

print(f'Variables numeriques : {list(num_vars)}')

# -> ['age', 'salaire', 'montant', 'score']

# Variables categorielles (object)

cat_vars = df.select_dtypes(include=['object']).columns
print(f'Variables categorielles : {list(cat_vars)}')
# -> ['genre', 'ville', 'credit']

# Variable cible Y et variables explicatives X

print('Variable cible (Y) : credit')
print('Variables entree (X) : age, salaire, genre, ville, montant, score')

RESUME DE LA SECTION
• pandas = bibliotheque de manipulation de tableaux, alias pd
• pd.read_csv() = charger un fichier CSV comme DataFrame
• [Link]() = voir les 5 premieres lignes
• [Link]() = types et valeurs manquantes
• [Link]() = statistiques (moyenne, min, max, quartiles)
• [Link]().sum() = compter les valeurs manquantes par colonne

B2. Nettoyage des Donnees

Le nettoyage des donnees est l'etape la plus longue d'un projet ML (60 a 70% du temps). Un
modele entraine sur de mauvaises donnees donnera de mauvaises predictions — c'est le
principe Garbage In, Garbage Out.

B2.1 — Gestion des valeurs manquantes

Il existe 4 strategies principales pour traiter les valeurs manquantes, selon le contexte :

Strategie Code Python Usage typique en Finance

Suppression [Link]() Quand les lignes sont peu
nombreuses et peu utiles
Moyenne/Mediane fillna(df['col'].mean()) Revenus, ages, soldes bancaires
Zero fillna(0) Dividendes non verses, frais
absents
Valeur suivante fillna(method='ffill') Cours de bourse, taux d'interet
(ffill)
Mode (plus fillna(df['col'].mode()[0]) Type de carte, pays, categorie client
frequent)

# Option 1 : Suppression
df_sans_na = [Link]()
print(f'Apres dropna() : {df_sans_na.shape}')

Page 12 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

# Option 2 : Remplacement par la moyenne (variables numeriques)

df['age'] = df['age'].fillna(df['age'].mean())

# Option 3 : Remplacement par la mediane (si outliers presents)

df['salaire'] = df['salaire'].fillna(df['salaire'].median())

# Option 4 : Remplacement par la valeur suivante (series temporelles)

df['cours'] = df['cours'].fillna(method='ffill') # forward fill

# Option 5 : Remplacement par la valeur la plus frequente

df['genre'] = df['genre'].fillna(df['genre'].mode()[0])

B2.2 — Suppression des doublons

# Detecter les doublons
print(f'Nombre de doublons : {[Link]().sum()}')

# Supprimer les doublons

df = df.drop_duplicates()
print(f'Apres suppression : {[Link]}')
df.drop_duplicates(keep='first')
• keep='first' → garde la PREMIÈRE occurrence, supprime les suivantes
• keep='last' → garde la DERNIÈRE occurrence, supprime les précédentes
• keep=False → supprime TOUTES les occurrences (même la première)

B2.3 — Correction des valeurs aberrantes (Outliers)

# Detecter les valeurs aberrantes (ex: montant negatif)
print(f'Montant minimum : {df["montant"].min()}')
# -> -500 : impossible, un montant ne peut pas etre negatif

# Supprimer les lignes avec valeurs aberrantes

df = df[df['montant'] > 0]

# Ou remplacer par la mediane

mediane = df['montant'].median()
df['montant'] = df['montant'].apply(
lambda x: mediane if x < 0 else x)

# Verification finale
print(f'Valeurs manquantes : {[Link]().sum().sum()}')
print(f'Doublons restants : {[Link]().sum()}')
print(f'Montant minimum : {df["montant"].min()}')

RESUME DE LA SECTION
• Garbage In, Garbage Out : la qualite du modele depend de la qualite des donnees
• dropna() supprime les lignes avec NaN | fillna() remplace les NaN
• fillna(mean()) pour les variables numeriques sans outliers
• fillna(median()) quand des valeurs extremes biaisent la moyenne
• fillna(method='ffill') pour les series temporelles (cours boursiers)
• drop_duplicates() supprime les lignes identiques

Page 13 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

B3. Encodage des Variables Categorielles

Les algorithmes de ML ne comprennent que des chiffres. Les variables categorielles (texte)
comme 'genre', 'ville', 'credit' doivent etre converties en nombres. Il existe deux methodes
principales selon le type de variable.

Methode Quand l'utiliser

Label Encoding Variable CIBLE Y (credit: Oui=1, Non=0) ou variable
ORDINALE (avec un ordre : Faible < Moyen < Eleve)
One-Hot Encoding Variable NOMINALE sans ordre (genre, ville, type de
carte). Cree une colonne binaire (0/1) par categorie

Code Python — Label Encoding et One-Hot Encoding

from [Link] import LabelEncoder
import pandas as pd

# === LABEL ENCODING (variable cible Y) ===

le = LabelEncoder()
df['credit_encode'] = le.fit_transform(df['credit'])
# Non -> 0 | Oui -> 1
print(df[['credit', 'credit_encode']])

# === ONE-HOT ENCODING (variables categorielles X) ===

df_encode = pd.get_dummies(df, columns=['genre', 'ville'])
print(df_encode.head())

# Resultat :
# genre_F genre_H ville_Lyon ville_Paris ville_Rabat
# 0 1 0 1 0
# 1 0 1 0 0

# === REGLE A RETENIR ===

print('Variable cible (Y) -> Label Encoding')
print('Variable categorielle (X) -> One-Hot Encoding')

Comparaison Label Encoding One-Hot Encoding

Nombre de 1 colonne (remplace l'originale) Autant de colonnes que de
colonnes categories
Exemple genre H=0, F=1 (1 colonne) genre_H et genre_F (2 colonnes)
Usage Variable cible Y Variables explicatives X
nominales
Risque Introduce un ordre artificiel Augmente la dimension des
donnees

RESUME DE LA SECTION
• Les algorithmes ML ne comprennent que des chiffres — toujours encoder les

Page 14 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

variables texte
• Label Encoding : variable cible Y (credit Oui/Non -> 1/0)
• One-Hot Encoding : variables explicatives X categorielles (genre, ville)
• pd.get_dummies() = One-Hot Encoding avec pandas
• LabelEncoder() de sklearn = Label Encoding

B4. Reduction de Dimension avec PCA

La PCA (Principal Component Analysis) est une technique qui reduit le nombre de variables
en creant de nouvelles composantes qui capturent le maximum de variance. Elle est utile
quand on a trop de variables (curse of dimensionality).

Pourquoi utiliser la PCA ?

• Trop de variables -> le modele est lent et peut overfitter
• Certaines variables sont correlees -> information redondante
• PCA combine les variables correlees en composantes independantes
• Regle : garder les composantes qui expliquent 95% de la variance

Code Python — PCA etape par etape

from [Link] import PCA
from [Link] import StandardScaler
import numpy as np

# Donnees numeriques uniquement pour PCA

X_numerique = df[['age', 'salaire', 'montant', 'score']]
print(f'Nb variables avant PCA : {X_numerique.shape[1]}') # 4

# ETAPE 1 : Standardiser AVANT PCA (obligatoire !)

# PCA est sensible aux echelles -> toujours standardiser d'abord
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_numerique)

# ETAPE 2 : Appliquer PCA sans specifier n_components

pca = PCA() # toutes les composantes
[Link](X_scaled)

# ETAPE 3 : Voir la variance expliquee par composante

print('=== VARIANCE EXPLIQUEE ===')
variance = pca.explained_variance_ratio_
for i, v in enumerate(variance):
print(f'Composante {i+1} : {v*100:.2f}%')
# Composante 1 : 58.32%
# Composante 2 : 24.15%
# Composante 3 : 12.41%
# Composante 4 : 5.12%

Page 15 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

# ETAPE 4 : Variance cumulee -> choisir nb de composantes

variance_cumulee = [Link](variance)
print('=== VARIANCE CUMULEE ===')
for i, v in enumerate(variance_cumulee):
print(f'Avec {i+1} composante(s) : {v*100:.2f}%')
# Avec 1 : 58.32% | Avec 2 : 82.47% | Avec 3 : 94.88%

# ETAPE 5 : Appliquer PCA avec le bon nombre

pca_final = PCA(n_components=2) # 2 composantes suffisent (82%)
X_pca = pca_final.fit_transform(X_scaled)

print(f'Avant PCA : {X_numerique.shape[1]} variables')

print(f'Apres PCA : {X_pca.shape[1]} composantes')
print(f'Variance totale :
{sum(pca_final.explained_variance_ratio_)*100:.2f}%')

APPLICATION FINANCE — PCA

En finance, on peut avoir des centaines de ratios financiers (P/E, ROE, ROA, Debt/Equity...)
qui sont souvent correles entre eux. La PCA permet de reduire ces 100+ variables a 3 ou 4
composantes independantes qui capturent 95% de l'information, rendant le modele plus
rapide et plus robuste.

RESUME DE LA SECTION
• PCA = reduction de dimension en preservant le maximum d'information
• OBLIGATOIRE : standardiser avec StandardScaler() AVANT d'appliquer PCA
• Regle des 95% : garder les composantes qui cumulent 95% de variance
• PCA(n_components=2) = garder 2 composantes principales
• pca.explained_variance_ratio_ = % de variance par composante

B5. Mise a l'Echelle des Variables Numeriques

Les algorithmes ML sont sensibles aux echelles des variables. Si 'age' va de 25 a 52 et

'salaire' de 3000 a 9000, le modele va surestimer l'importance du salaire. La mise a l'echelle
resout ce probleme.

Methode Quand utiliser

Standardisation (StandardScaler) Regression lineaire, PCA, SVM, logistique. Donne
moyenne=0 et ecart-type=1
Normalisation (MinMaxScaler) Reseaux de neurones, KNN, distances. Ramene toutes
les valeurs entre 0 et 1

Code Python — Standardisation et Normalisation

from [Link] import StandardScaler, MinMaxScaler
import pandas as pd

Page 16 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

X = df[['age', 'salaire', 'montant', 'score']]

print('=== AVANT MISE A L ECHELLE ===')
print([Link]().round(2))
# age: min=25, max=52 | salaire: min=3000, max=9000

# === STANDARDISATION : z = (x - moyenne) / ecart_type ===

# Resultat : moyenne=0, ecart-type=1
scaler_std = StandardScaler()
X_standardise = scaler_std.fit_transform(X)
X_std_df = [Link](X_standardise, columns=[Link])

print('=== APRES STANDARDISATION ===')

print(X_std_df.describe().round(2))
# mean ≈ 0.00 pour toutes les colonnes
# std ≈ 1.00 pour toutes les colonnes

# === NORMALISATION : x_norm = (x - min) / (max - min) ===

# Resultat : toutes valeurs entre 0 et 1
scaler_mm = MinMaxScaler()
X_normalise = scaler_mm.fit_transform(X)
X_norm_df = [Link](X_normalise, columns=[Link])

print('=== APRES NORMALISATION ===')

print(X_norm_df.describe().round(2))
# min = 0.00 | max = 1.00 pour toutes les colonnes

# === COMPARAISON VALEUR AGE=25 ===

print(f'Original : 25')
print(f'Standardise : {X_std_df["age"].iloc[0]:.4f}') # -> -1.5032
print(f'Normalise : {X_norm_df["age"].iloc[0]:.4f}') # -> 0.0000

Critere Standardisation Normalisation

Formule z = (x - moy) / std x_norm = (x-min)/(max-min)
Plage de valeurs Pas de limite (-inf, +inf) Toujours entre 0 et 1
Moyenne et Ecart- Moy=0, Std=1 Variable
type
Sensible aux Non (peu) Oui (beaucoup)
outliers
Utilisation Regression, PCA, SVM Reseaux neurones, KNN

RESUME DE LA SECTION
• Toujours mettre a l'echelle les variables numeriques avant d'entrainer le modele
• StandardScaler : moy=0, std=1 -> utiliser pour regression, PCA, SVM
• MinMaxScaler : valeurs entre 0 et 1 -> utiliser pour reseaux de neurones, KNN
• Appliquer fit_transform() sur X_train puis transform() (seulement) sur X_test

Page 17 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

B6. Pipeline Complet — Les 5 Etapes Enchainees

En pratique, les 5 etapes de preparation des donnees s'enchainent dans un ordre precis. Ce
pipeline constitue la base de tout projet ML en finance.

# Etape Code Python

1 Comprendre print([Link]()) | print([Link]()) |
print([Link]().sum())

2 Nettoyer df['age']=df['age'].fillna(df['age'].mean()) |
df=df.drop_duplicates()

3 Encoder df['credit']=LabelEncoder().fit_transform(df['credit']) |
pd.get_dummies()

4 Reduire pca=PCA(n_components=2) | X_pca=pca.fit_transform(X_scaled)

(PCA)
5 Mettre a X_final=StandardScaler().fit_transform([Link]('credit',axis=1))
l'echelle

Code pipeline complet

import pandas as pd
import numpy as np
from [Link] import LabelEncoder, StandardScaler
from [Link] import PCA

df = pd.read_csv('clients_bancaires.csv')

# === 1. COMPRENDRE ===

print([Link]())
print([Link]())
print([Link]().sum())

# === 2. NETTOYER ===

df['age'] = df['age'].fillna(df['age'].mean())
df['cours'] = df['cours'].fillna(method='ffill') # series temp.
df = df.drop_duplicates()
df = df[df['montant'] > 0] # suppr. aberrants

# === 3. ENCODER ===

df['credit'] = LabelEncoder().fit_transform(df['credit'])
df = pd.get_dummies(df, columns=['genre', 'ville'])

# === 4. REDUIRE (PCA) ===

X_num = df[['age','salaire','montant','score']]
X_scaled = StandardScaler().fit_transform(X_num)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# === 5. METTRE A L'ECHELLE ===

X_final = StandardScaler().fit_transform(

Page 18 / 19
COURS DE MACHINE LEARNING | Finance & Data Science | Partie 2

[Link]('credit', axis=1))

print('Donnees pretes pour le modele !')

Fin de la Partie 2 — Machine Learning avec Python

Finance & Data Science | Partie 1 : Introduction au ML | Partie 2 : Implementation et Preparation des Donnees

Page 19 / 19