Cours Intelligence Artificielle

🤖

Chapitre 1 : Introduction a l'Intelligence Artificielle

Concepts fondamentaux et historique de l'IA

🎯 Objectifs du chapitre

Definir l'Intelligence Artificielle et ses branches
Connaitre l'historique et les evolutions de l'IA
Distinguer IA faible et IA forte
Identifier les applications de l'IA en electronique

1.1 Definition de l'Intelligence Artificielle

📖

Intelligence Artificielle (IA) L'Intelligence Artificielle est un domaine de l'informatique qui vise a creer des systemes capables d'effectuer des taches necessitant normalement l'intelligence humaine : apprentissage, raisonnement, perception, comprehension du langage, prise de decision.

Branches de l'Intelligence Artificielle

                        INTELLIGENCE ARTIFICIELLE
                                  │
        ┌─────────────┬───────────┼───────────┬─────────────┐
        │             │           │           │             │
        ▼             ▼           ▼           ▼             ▼
   ┌─────────┐  ┌─────────┐ ┌─────────┐ ┌─────────┐  ┌─────────┐
   │ Machine │  │  Deep   │ │  NLP    │ │ Vision  │  │Robotique│
   │Learning │  │Learning │ │(Langage)│ │  par    │  │         │
   │         │  │         │ │         │ │Ordinat. │  │         │
   └─────────┘  └─────────┘ └─────────┘ └─────────┘  └─────────┘
        │             │
        │     ┌───────┴───────┐
        │     │               │
        ▼     ▼               ▼
   ┌─────────────┐    ┌─────────────┐
   │   Reseaux   │    │   Reseaux   │
   │  de Neurones│    │Convolutifs  │
   │   (ANN)     │    │   (CNN)     │
   └─────────────┘    └─────────────┘

1.2 Historique de l'IA

Annee	Evenement	Importance
1943	McCulloch & Pitts : Neurone artificiel	Premier modele mathematique de neurone
1950	Test de Turing	Critere d'intelligence machine
1956	Conference de Dartmouth	Naissance officielle du terme "IA"
1957	Perceptron (Rosenblatt)	Premier reseau de neurones
1986	Retropropagation	Entrainement efficace des reseaux
1997	Deep Blue bat Kasparov	IA bat champion d'echecs
2012	AlexNet (ImageNet)	Revolution du Deep Learning
2016	AlphaGo bat Lee Sedol	IA maitrise le jeu de Go
2022	ChatGPT (OpenAI)	IA conversationnelle grand public

1.3 IA Faible vs IA Forte

🎯

IA Faible (Narrow AI)

Concue pour une tache specifique. Ex: reconnaissance faciale, traduction, recommandation. C'est l'IA actuelle.

🧠

IA Forte (General AI)

Intelligence comparable a l'humain, capable de raisonner, apprendre et s'adapter a toute tache. N'existe pas encore.

1.4 Applications de l'IA en Electronique

🔧

Maintenance Predictive

Detection de pannes avant qu'elles surviennent

📊

Controle Qualite

Inspection automatique des circuits

🎤

Reconnaissance Vocale

Commandes vocales pour IoT

👁️

Vision par Ordinateur

Detection d'objets, de gestes

⚡

Optimisation Energie

Gestion intelligente de la consommation

🤖

Robotique

Navigation autonome, manipulation

🧠

Chapitre 2 : Types d'Apprentissage Automatique

Supervise, non supervise et par renforcement

🎯 Objectifs du chapitre

Distinguer les trois types d'apprentissage machine
Identifier les cas d'usage de chaque type
Comprendre les notions de features et labels
Connaitre les algorithmes principaux de chaque categorie

2.1 Machine Learning : Vue d'ensemble

📖

Machine Learning (Apprentissage Automatique) Sous-domaine de l'IA ou les algorithmes apprennent a partir des donnees sans etre explicitement programmes pour chaque cas. Le systeme s'ameliore avec l'experience.

    PROGRAMMATION TRADITIONNELLE          MACHINE LEARNING
    
    ┌──────────────┐                    ┌──────────────┐
    │    REGLES    │                    │   DONNEES    │
    │  (Humain)    │                    │  (Exemples)  │
    └──────┬───────┘                    └──────┬───────┘
           │                                   │
           ▼                                   ▼
    ┌──────────────┐                    ┌──────────────┐
    │  PROGRAMME   │                    │  ALGORITHME  │
    │              │                    │     ML       │
    └──────┬───────┘                    └──────┬───────┘
           │                                   │
    ┌──────┴───────┐                    ┌──────┴───────┐
    │   DONNEES    │                    │   MODELE     │
    │   (Input)    │                    │  (Appris)    │
    └──────┬───────┘                    └──────┬───────┘
           │                                   │
           ▼                                   ▼
    ┌──────────────┐                    ┌──────────────┐
    │   RESULTAT   │                    │   REGLES     │
    │              │                    │  (Prediction)│
    └──────────────┘                    └──────────────┘

2.2 Apprentissage Supervise

L'algorithme apprend a partir de donnees etiquetees (avec les reponses connues).

    APPRENTISSAGE SUPERVISE
    
    Donnees d'entrainement:
    ┌─────────────────────────────────────────────┐
    │  Features (X)           │    Label (Y)      │
    ├─────────────────────────┼───────────────────┤
    │  [taille, poids, age]   │    "Malade"       │
    │  [taille, poids, age]   │    "Sain"         │
    │  [taille, poids, age]   │    "Malade"       │
    │         ...             │       ...         │
    └─────────────────────────┴───────────────────┘
                    │
                    ▼
            ┌───────────────┐
            │   MODELE ML   │  ← Apprentissage
            │   (Training)  │
            └───────┬───────┘
                    │
                    ▼
    Nouvelles donnees:
    [taille, poids, age] → Modele → Prediction: "Sain"

Types de problemes supervises

Type	Sortie	Exemples	Algorithmes
Classification	Categorie discrete	Spam/Non-spam, Malade/Sain	KNN, SVM, Arbres de decision
Regression	Valeur continue	Prix maison, temperature	Regression lineaire, polynomiale

2.3 Apprentissage Non Supervise

L'algorithme decouvre des structures cachees dans les donnees sans etiquettes.

    APPRENTISSAGE NON SUPERVISE (Clustering)
    
    Donnees sans etiquettes:        Resultat (groupes decouverts):
    
         ●  ●                           ●  ●
       ●  ●  ●                        ●  ●  ●   → Cluster 1
                         ═══▶               
              ○  ○                         ○  ○
            ○  ○  ○                      ○  ○  ○ → Cluster 2
                    
                 △  △                       △  △
               △  △                       △  △   → Cluster 3

Applications

Clustering : Segmentation clients, regroupement documents
Reduction de dimensions : PCA, compression de donnees
Detection d'anomalies : Fraudes, intrusions reseau

2.4 Apprentissage par Renforcement

Un agent apprend en interagissant avec un environnement, recevant des recompenses ou penalites.

    APPRENTISSAGE PAR RENFORCEMENT
    
              ┌─────────────────────────────────┐
              │                                 │
              ▼                                 │
        ┌───────────┐      Action        ┌─────┴─────┐
        │   AGENT   │ ──────────────────▶│ENVIRONNE- │
        │ (Decideur)│                    │   MENT    │
        └───────────┘                    └───────────┘
              ▲                                 │
              │     Etat + Recompense           │
              └─────────────────────────────────┘
    
    Exemples:
    - Jeux (AlphaGo, echecs)
    - Robotique (navigation)
    - Vehicules autonomes

2.5 Resume des Types d'Apprentissage

Type	Donnees	Objectif	Exemple IoT
Supervise	Etiquetees	Predire une sortie	Detection de chute (accelerometre)
Non supervise	Non etiquetees	Decouvrir des patterns	Detection d'anomalies capteurs
Renforcement	Recompenses	Optimiser une strategie	Regulation thermostat intelligent

📊

Chapitre 3 : Preparation des Donnees

Collecte, nettoyage et transformation des donnees

🎯 Objectifs du chapitre

Comprendre l'importance de la qualite des donnees
Maitriser les techniques de pretraitement
Normaliser et standardiser les donnees
Diviser les donnees en ensembles d'entrainement et de test

3.1 Importance des Donnees

⚠️

Garbage In, Garbage Out La qualite du modele depend directement de la qualite des donnees. Un mauvais jeu de donnees produira un mauvais modele, peu importe l'algorithme utilise.

Pipeline de donnees typique

    ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
    │ Collecte │───▶│ Nettoyage│───▶│ Transform│───▶│ Division │───▶│ Modele   │
    │ Donnees  │    │ Donnees  │    │ Features │    │Train/Test│    │ Training │
    └──────────┘    └──────────┘    └──────────┘    └──────────┘    └──────────┘

3.2 Nettoyage des Donnees

Problemes courants et solutions

Valeurs manquantes : Supprimer, imputer (moyenne, mediane, mode)
Doublons : Identifier et supprimer les lignes identiques
Outliers (valeurs aberrantes) : Detecter (IQR, Z-score), supprimer ou corriger
Incoherences : Standardiser les formats (dates, unites)

# Nettoyage avec Pandas en Python
import pandas as pd
import numpy as np

# Charger les donnees
df = pd.read_csv('capteurs.csv')

# Verifier les valeurs manquantes
print(df.isnull().sum())

# Remplir les valeurs manquantes par la moyenne
df['temperature'].fillna(df['temperature'].mean(), inplace=True)

# Supprimer les doublons
df.drop_duplicates(inplace=True)

# Detecter les outliers avec IQR
Q1 = df['temperature'].quantile(0.25)
Q3 = df['temperature'].quantile(0.75)
IQR = Q3 - Q1
df = df[(df['temperature'] >= Q1 - 1.5*IQR) & 
        (df['temperature'] <= Q3 + 1.5*IQR)]

3.3 Normalisation et Standardisation

Normalisation Min-Max

X' = (X - X_min) / (X_max - X_min)

Ramene les valeurs entre 0 et 1

Standardisation (Z-Score)

X' = (X - μ) / σ

Moyenne = 0, Ecart-type = 1

# Normalisation et Standardisation avec Scikit-Learn
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# Normalisation Min-Max (0-1)
scaler_minmax = MinMaxScaler()
X_normalized = scaler_minmax.fit_transform(X)

# Standardisation (Z-score)
scaler_std = StandardScaler()
X_standardized = scaler_std.fit_transform(X)

3.4 Division Train/Test

Les donnees sont divisees pour entrainer le modele et evaluer sa performance sur des donnees inconnues.

    DATASET COMPLET (100%)
    ┌────────────────────────────────────────────────────────┐
    │                                                        │
    │   TRAIN SET (70-80%)          │   TEST SET (20-30%)   │
    │   Apprentissage du modele     │   Evaluation finale   │
    │                               │                       │
    └───────────────────────────────┴───────────────────────┘
    
    Optionnel: Validation Set (pour tuning hyperparametres)
    Train: 60% | Validation: 20% | Test: 20%

# Division des donnees avec Scikit-Learn
from sklearn.model_selection import train_test_split

# X = features, y = labels
X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2,      # 20% pour le test
    random_state=42,    # Pour reproductibilite
    stratify=y          # Maintenir la proportion des classes
)

print(f"Train: {len(X_train)}, Test: {len(X_test)}")

📈

Chapitre 4 : Algorithmes de Regression

Prediction de valeurs continues

🎯 Objectifs du chapitre

Comprendre le principe de la regression
Implementer une regression lineaire simple et multiple
Evaluer les performances avec MSE, RMSE, R²
Appliquer la regression a des donnees de capteurs

4.1 Regression Lineaire Simple

Modelise la relation lineaire entre une variable d'entree X et une sortie Y.

Equation de la droite de regression

Y = aX + b

a = pente (coefficient), b = ordonnee a l'origine (intercept)

        Y │
          │                          ∗
          │                     ∗  ─────── Droite de regression
          │                ∗  /     Y = aX + b
          │           ∗   /
          │      ∗      /
          │    ∗     /
          │  ∗    /
          │∗   /
          │  /
          └────────────────────────────▶ X

# Regression lineaire simple avec Scikit-Learn
from sklearn.linear_model import LinearRegression
import numpy as np

# Donnees: temperature vs consommation energetique
X = np.array([[15], [18], [22], [25], [30], [35]])  # Temperature °C
y = np.array([120, 135, 150, 165, 190, 220])         # Consommation W

# Creer et entrainer le modele
model = LinearRegression()
model.fit(X, y)

# Coefficients
print(f"Pente (a): {model.coef_[0]:.2f}")
print(f"Intercept (b): {model.intercept_:.2f}")

# Prediction pour 28°C
prediction = model.predict([[28]])
print(f"Consommation a 28°C: {prediction[0]:.1f} W")

4.2 Regression Lineaire Multiple

Plusieurs variables d'entree pour predire une sortie :

Regression multiple

Y = a₁X₁ + a₂X₂ + ... + aₙXₙ + b

Plusieurs features contribuent a la prediction

# Regression multiple: predire consommation selon temp, humidite, heure
X = np.array([
    [20, 60, 8],   # [temperature, humidite%, heure]
    [25, 55, 12],
    [30, 70, 14],
    [22, 65, 18],
    [28, 50, 20]
])
y = np.array([150, 180, 220, 160, 200])  # Consommation W

model = LinearRegression()
model.fit(X, y)

# Coefficients pour chaque feature
print("Coefficients:", model.coef_)
# Ex: [5.2, 0.8, 2.1] → temp a plus d'impact que humidite

4.3 Metriques d'Evaluation

Metrique	Formule	Interpretation
MSE (Mean Squared Error)	Σ(y - ŷ)² / n	Erreur quadratique moyenne. Plus petit = meilleur
RMSE (Root MSE)	√MSE	Meme unite que Y. Interpretable
MAE (Mean Absolute Error)	Σ\|y - ŷ\| / n	Erreur absolue moyenne
R² (Coefficient determination)	1 - SS_res/SS_tot	0-1. Proche de 1 = bon modele

# Evaluation du modele
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE: {mse:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAE: {mae:.2f}")
print(f"R²: {r2:.3f}")

🏷️

Chapitre 5 : Algorithmes de Classification

Prediction de categories

🎯 Objectifs du chapitre

Comprendre la difference classification vs regression
Implementer K-Nearest Neighbors (KNN)
Implementer la regression logistique
Evaluer avec accuracy, precision, recall, F1-score

5.1 K-Nearest Neighbors (KNN)

Classe un point selon la majorite de ses K plus proches voisins.

    K-NEAREST NEIGHBORS (K=3)
    
                 Classe A (●)
                 Classe B (○)
                 
         ●  ●
       ●         ★ ← Point a classifier
         ●  ○      
              ○  ○
            ○
    
    Les 3 plus proches voisins de ★ :
    - 2 sont de classe ● (A)
    - 1 est de classe ○ (B)
    
    → ★ est classe comme A (majorite)

# Classification KNN
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Donnees: [temperature, humidite] → Etat (0=Normal, 1=Alerte)
X = np.array([[22, 45], [25, 50], [28, 55], [35, 80], 
              [38, 85], [40, 90], [20, 40], [42, 95]])
y = np.array([0, 0, 0, 1, 1, 1, 0, 1])

# Division train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

# Creer et entrainer KNN (K=3)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# Prediction
y_pred = knn.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")

# Classifier un nouveau point
new_point = [[36, 75]]
prediction = knn.predict(new_point)
print(f"Prediction: {'Alerte' if prediction[0] else 'Normal'}")

5.2 Regression Logistique

Malgre son nom, c'est un algorithme de classification binaire. Utilise la fonction sigmoide.

Fonction Sigmoide

σ(z) = 1 / (1 + e⁻ᶻ)

Transforme une valeur en probabilite entre 0 et 1

# Regression logistique
from sklearn.linear_model import LogisticRegression

# Creer et entrainer
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)

# Prediction
y_pred = log_reg.predict(X_test)

# Probabilites
proba = log_reg.predict_proba([[36, 75]])
print(f"Probabilite Normal: {proba[0][0]:.2%}")
print(f"Probabilite Alerte: {proba[0][1]:.2%}")

5.3 Metriques de Classification

Matrice de Confusion

                        PREDICTION
                    Positif   Negatif
                 ┌─────────┬─────────┐
        Positif  │   TP    │   FN    │   TP = True Positive (Vrais Positifs)
    REEL         │         │         │   FP = False Positive (Faux Positifs)
                 ├─────────┼─────────┤   TN = True Negative (Vrais Negatifs)
        Negatif  │   FP    │   TN    │   FN = False Negative (Faux Negatifs)
                 │         │         │
                 └─────────┴─────────┘

Metrique	Formule	Signification
Accuracy	(TP+TN) / Total	% de predictions correctes
Precision	TP / (TP+FP)	Parmi les positifs predits, % de vrais
Recall	TP / (TP+FN)	Parmi les vrais positifs, % detectes
F1-Score	2×(P×R)/(P+R)	Moyenne harmonique Precision/Recall

# Metriques de classification
from sklearn.metrics import confusion_matrix, classification_report

# Matrice de confusion
cm = confusion_matrix(y_test, y_pred)
print("Matrice de confusion:")
print(cm)

# Rapport complet
print(classification_report(y_test, y_pred))

🌳

Chapitre 6 : Arbres de Decision

Algorithmes interpretables pour classification et regression

🎯 Objectifs du chapitre

Comprendre le fonctionnement des arbres de decision
Implementer un arbre de decision
Visualiser et interpreter l'arbre
Decouvrir Random Forest (foret aleatoire)

6.1 Principe de l'Arbre de Decision

L'arbre de decision pose une serie de questions binaires pour arriver a une decision.

    ARBRE DE DECISION - Detection d'anomalie capteur
    
                      ┌─────────────────────┐
                      │  Temperature > 35°C │
                      └──────────┬──────────┘
                          Oui /       \ Non
                             ▼         ▼
                 ┌─────────────────┐  ┌─────────────────┐
                 │ Humidite > 80%  │  │    NORMAL ✓     │
                 └────────┬────────┘  └─────────────────┘
                    Oui /     \ Non
                       ▼       ▼
            ┌──────────────┐ ┌──────────────┐
            │  ALERTE ⚠️   │ │ Vibration>5  │
            └──────────────┘ └──────┬───────┘
                               Oui /   \ Non
                                  ▼     ▼
                       ┌──────────┐ ┌──────────┐
                       │ ALERTE ⚠️│ │ NORMAL ✓ │
                       └──────────┘ └──────────┘

6.2 Implementation avec Scikit-Learn

# Arbre de decision pour classification
from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# Donnees: [temperature, humidite, vibration] → Etat
X = np.array([
    [25, 50, 2], [30, 60, 3], [38, 85, 4],
    [40, 90, 6], [22, 45, 1], [42, 95, 8]
])
y = np.array([0, 0, 1, 1, 0, 1])  # 0=Normal, 1=Alerte

# Creer et entrainer l'arbre
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)

# Visualiser l'arbre
plt.figure(figsize=(12, 8))
plot_tree(tree, feature_names=['Temp', 'Hum', 'Vib'], 
          class_names=['Normal', 'Alerte'], filled=True)
plt.show()

# Prediction
new_data = [[36, 82, 5]]
print(f"Prediction: {tree.predict(new_data)}")

6.3 Random Forest (Foret Aleatoire)

Ensemble de plusieurs arbres de decision qui votent pour la decision finale. Plus robuste qu'un seul arbre.

# Random Forest
from sklearn.ensemble import RandomForestClassifier

# Creer le modele avec 100 arbres
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Evaluation
accuracy = rf.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2%}")

# Importance des features
print("Importance des features:")
for name, importance in zip(['Temp', 'Hum', 'Vib'], rf.feature_importances_):
    print(f"  {name}: {importance:.2%}")

🧬

Chapitre 7 : Reseaux de Neurones Artificiels

Fondements du Deep Learning

🎯 Objectifs du chapitre

Comprendre le neurone artificiel (perceptron)
Connaitre les fonctions d'activation
Comprendre l'architecture multicouche
Expliquer la retropropagation

7.1 Le Neurone Artificiel (Perceptron)

    NEURONE ARTIFICIEL
    
      Entrees         Poids        Somme      Activation     Sortie
    
        x₁ ────○──── w₁ ────┐
                            │
        x₂ ────○──── w₂ ────┼──▶ Σ ──▶ f(z) ──▶ y
                            │
        x₃ ────○──── w₃ ────┘
                            │
        1  ────○──── b  ────┘  (biais)
    
    z = w₁x₁ + w₂x₂ + w₃x₃ + b   (somme ponderee)
    y = f(z)                      (fonction d'activation)

Calcul du neurone

y = f(Σ wᵢxᵢ + b)

Somme ponderee des entrees + biais, passee par une activation

7.2 Fonctions d'Activation

Fonction	Formule	Sortie	Usage
Sigmoid	1 / (1 + e⁻ˣ)	[0, 1]	Classification binaire (sortie)
Tanh	(eˣ - e⁻ˣ) / (eˣ + e⁻ˣ)	[-1, 1]	Couches cachees
ReLU	max(0, x)	[0, +∞)	Couches cachees (le plus utilise)
Softmax	eˣⁱ / Σeˣʲ	[0, 1], somme=1	Classification multi-classes

    FONCTIONS D'ACTIVATION
    
    SIGMOID               ReLU                   SOFTMAX
    
     1 │    ╭───         │     ╱               Classe A: 0.7
       │   ╱             │    ╱                Classe B: 0.2
   0.5│──╱───            │   ╱                 Classe C: 0.1
       │ ╱               │  ╱                  ─────────────
     0 │╱                │─╱                   Somme = 1.0
       └──────           └──────
         -5  0  5          -2  0  2

7.3 Architecture Multicouche (MLP)

    RESEAU DE NEURONES MULTICOUCHE (Multi-Layer Perceptron)
    
     Couche         Couche(s)           Couche
     d'entree        cachee(s)          de sortie
    
       ○──────────────○
        ╲            ╱ ╲
       ○──╲────────○─────╲─────────○
        ╲  ╲      ╱ ╲     ╲
       ○───╲────○─────╲────╲───────○
            ╲  ╱       ╲    ╲
       ○─────○──────────╲────╲─────○
    
     3 entrees     4 neurones       3 sorties
     (features)    (representation  (classes)
                    apprise)
    
    Dense (Fully Connected): Chaque neurone connecte a tous les neurones de la couche precedente

7.4 Entrainement et Retropropagation

    CYCLE D'ENTRAÎNEMENT
    
    1. FORWARD PROPAGATION (Propagation avant)
       ───────────────────────────────────────▶
       Input → Hidden → Output → Prediction (ŷ)
    
    2. CALCUL DE L'ERREUR (Loss)
       Loss = f(y_vrai, ŷ)   ex: MSE, Cross-Entropy
    
    3. BACKPROPAGATION (Retropropagation)
       ◀───────────────────────────────────────
       Calcul des gradients: ∂Loss/∂w pour chaque poids
    
    4. MISE A JOUR DES POIDS (Gradient Descent)
       w_nouveau = w_ancien - η × ∂Loss/∂w
       (η = learning rate, taux d'apprentissage)
    
    5. REPETER pour chaque batch/epoch

💡

Epoch et Batch
- Epoch: Un passage complet sur toutes les donnees d'entrainement
- Batch: Sous-ensemble de donnees traitees ensemble avant mise a jour des poids

🔮

Chapitre 8 : Deep Learning

Reseaux de neurones profonds et architectures avancees

🎯 Objectifs du chapitre

Comprendre ce qu'est le Deep Learning
Decouvrir les reseaux convolutifs (CNN)
Connaitre les reseaux recurrents (RNN)
Identifier les applications en electronique

8.1 Deep Learning vs Machine Learning

📖

Deep Learning (Apprentissage Profond) Sous-domaine du ML utilisant des reseaux de neurones avec plusieurs couches cachees (profonds). Capable d'apprendre automatiquement des representations hierarchiques complexes a partir de donnees brutes.

Aspect	Machine Learning Classique	Deep Learning
Features	Extraction manuelle (humain)	Extraction automatique (reseau)
Donnees	Fonctionne avec peu de donnees	Necessite beaucoup de donnees
Materiel	CPU suffisant	GPU recommande
Interpretabilite	Souvent interpretable	Boite noire

8.2 Reseaux Convolutifs (CNN)

Specialises dans le traitement d'images. Apprennent des filtres (features) hierarchiques.

    CNN - CONVOLUTIONAL NEURAL NETWORK
    
    Image         Convolution      Pooling       Fully Connected    Sortie
    Entree        + Activation     (Reduction)   (Classification)
    
    ┌─────┐      ┌─────┐          ┌───┐         ┌───┐
    │█████│      │▓▓▓▓▓│          │▓▓▓│         │   │
    │█████│  →   │▓▓▓▓▓│   →      │▓▓▓│    →    │   │  →  "Chat"
    │█████│      │▓▓▓▓▓│          │▓▓▓│         │   │
    └─────┘      └─────┘          └───┘         └───┘
    28×28        24×24×32         12×12×32       128      10 classes
    
    Convolution: Detecte des patterns locaux (bords, textures)
    Pooling: Reduit la taille, garde l'information importante

Applications des CNN

Classification d'images (chat vs chien)
Detection d'objets (YOLO, SSD)
Reconnaissance faciale
Inspection visuelle de PCB
Lecture de compteurs analogiques

8.3 Reseaux Recurrents (RNN)

Specialises dans les sequences (texte, audio, series temporelles). Possedent une "memoire".

    RNN - RECURRENT NEURAL NETWORK
    
    Sequence temporelle: t₁ → t₂ → t₃ → t₄
    
         ┌───┐     ┌───┐     ┌───┐     ┌───┐
         │ h │────▶│ h │────▶│ h │────▶│ h │───▶ Sortie
         └─▲─┘     └─▲─┘     └─▲─┘     └─▲─┘
           │         │         │         │
          x₁        x₂        x₃        x₄
    
    h = etat cache (memoire des entrees precedentes)
    
    Variantes: LSTM (Long Short-Term Memory)
               GRU (Gated Recurrent Unit)

Applications des RNN/LSTM

Prediction de series temporelles (capteurs)
Reconnaissance vocale
Traduction automatique
Detection d'anomalies temporelles

Cours Intelligence Artificielle - Fondamentaux

Chapitre 1 : Introduction a l'Intelligence Artificielle

🎯 Objectifs du chapitre

1.1 Definition de l'Intelligence Artificielle

Branches de l'Intelligence Artificielle

1.2 Historique de l'IA

1.3 IA Faible vs IA Forte

IA Faible (Narrow AI)

IA Forte (General AI)

1.4 Applications de l'IA en Electronique

Maintenance Predictive

Controle Qualite

Reconnaissance Vocale

Vision par Ordinateur

Optimisation Energie

Robotique

Chapitre 2 : Types d'Apprentissage Automatique

🎯 Objectifs du chapitre

2.1 Machine Learning : Vue d'ensemble

2.2 Apprentissage Supervise

Types de problemes supervises

2.3 Apprentissage Non Supervise

Applications

2.4 Apprentissage par Renforcement

2.5 Resume des Types d'Apprentissage

Chapitre 3 : Preparation des Donnees

🎯 Objectifs du chapitre

3.1 Importance des Donnees

Pipeline de donnees typique

3.2 Nettoyage des Donnees

Problemes courants et solutions

3.3 Normalisation et Standardisation

3.4 Division Train/Test

Chapitre 4 : Algorithmes de Regression

🎯 Objectifs du chapitre

4.1 Regression Lineaire Simple

4.2 Regression Lineaire Multiple

4.3 Metriques d'Evaluation

Chapitre 5 : Algorithmes de Classification

🎯 Objectifs du chapitre

5.1 K-Nearest Neighbors (KNN)

5.2 Regression Logistique

5.3 Metriques de Classification

Matrice de Confusion

Chapitre 6 : Arbres de Decision

🎯 Objectifs du chapitre

6.1 Principe de l'Arbre de Decision

6.2 Implementation avec Scikit-Learn

6.3 Random Forest (Foret Aleatoire)

Chapitre 7 : Reseaux de Neurones Artificiels

🎯 Objectifs du chapitre

7.1 Le Neurone Artificiel (Perceptron)

7.2 Fonctions d'Activation

7.3 Architecture Multicouche (MLP)

7.4 Entrainement et Retropropagation

Chapitre 8 : Deep Learning

🎯 Objectifs du chapitre

8.1 Deep Learning vs Machine Learning

8.2 Reseaux Convolutifs (CNN)

Applications des CNN

8.3 Reseaux Recurrents (RNN)

Applications des RNN/LSTM

Formulaire de contact