Les outils essentiels pour créer et entraîner des réseaux de neurones
Python est devenu le langage de prédilection pour l'Intelligence Artificielle et le Machine Learning. Sa syntaxe claire, son écosystème riche et sa communauté active en font l'outil idéal pour développer des modèles d'IA.
NumPy, Pandas, TensorFlow, PyTorch, Scikit-learn...
Code lisible et expressif, idéal pour le prototypage rapide
Millions de développeurs, tutoriels, et support
Backends optimisés en C/C++, support GPU
NumPy (Numerical Python) est la bibliothèque fondamentale pour le calcul scientifique en Python. Elle fournit des tableaux multidimensionnels efficaces et des opérations mathématiques vectorisées.
import numpy as np
# Création de tableaux
array = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6]])
# Opérations vectorisées (très rapides !)
result = array * 2 # [2, 4, 6, 8, 10]
squared = array ** 2 # [1, 4, 9, 16, 25]
# Statistiques
mean = np.mean(array) # 3.0
std = np.std(array) # 1.414
# Algèbre linéaire
dot_product = np.dot(array, array) # 55
matrix_mult = np.matmul(matrix, matrix.T)
# Génération de données
random_data = np.random.randn(1000, 10) # 1000 samples, 10 features
zeros = np.zeros((3, 3))
ones = np.ones((2, 4))
# Reshaping (crucial pour les réseaux de neurones)
reshaped = array.reshape(5, 1)
flattened = matrix.flatten() # [1, 2, 3, 4, 5, 6]Pandas est la bibliothèque incontournable pour la manipulation et l'analyse de données structurées. Elle fournit des structures de données puissantes (DataFrame, Series) et des outils pour nettoyer, transformer et analyser les données.
import pandas as pd
import numpy as np
# Création d'un DataFrame
data = {
'nom': ['Alice', 'Bob', 'Charlie', 'David'],
'age': [25, 30, 35, 28],
'salaire': [50000, 60000, 75000, 55000]
}
df = pd.DataFrame(data)
# Lecture de fichiers
df = pd.read_csv('data.csv')
df = pd.read_excel('data.xlsx')
# Exploration rapide
print(df.head()) # 5 premières lignes
print(df.info()) # Types et valeurs manquantes
print(df.describe()) # Statistiques descriptives
# Sélection et filtrage
ages = df['age'] # Une colonne
filtered = df[df['age'] > 30] # Filtre
subset = df[['nom', 'age']] # Plusieurs colonnes
# Nettoyage de données
df.dropna() # Supprimer valeurs manquantes
df.fillna(0) # Remplir valeurs manquantes
df.drop_duplicates() # Supprimer duplicatas
# Transformation
df['age_squared'] = df['age'] ** 2
df['salaire_norm'] = (df['salaire'] - df['salaire'].mean()) / df['salaire'].std()
# Groupement et agrégation
grouped = df.groupby('age').mean()
pivot = df.pivot_table(values='salaire', index='age', aggfunc='mean')
# Conversion pour ML
X = df[['age', 'salaire']].values # Vers NumPy array
y = df['target'].valuesLes frameworks de Deep Learning fournissent des abstractions de haut niveau pour créer, entraîner et déployer des réseaux de neurones. Voici les trois principaux :
Framework complet développé par Google, orienté production et déploiement. Utilisé massivement dans l'industrie.
Framework favori de la recherche, dynamique et pythonique. Intuition et flexibilité.
API de haut niveau, simple et élégante. Intégrée à TensorFlow depuis la v2. Parfaite pour débuter.
| Critère | TensorFlow | PyTorch | Keras |
|---|---|---|---|
| Facilité d'apprentissage | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Flexibilité | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| Production | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Recherche | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| Communauté | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Documentation | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
Keras permet de créer des réseaux de neurones en quelques lignes de code. Voici des exemples concrets pour différentes tâches.
Classificateur binaire basique : 3 couches denses pour prédire une classe.
from tensorflow import keras
from tensorflow.keras import layers
# Créer le modèle
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=(10,)),
layers.Dropout(0.5),
layers.Dense(32, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
# Compiler
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy']
)
# Entraîner
history = model.fit(
X_train, y_train,
epochs=50,
batch_size=32,
validation_split=0.2
)
# Prédire
predictions = model.predict(X_test)Réseau convolutif pour classifier des chiffres manuscrits.
from tensorflow.keras import layers, models
# Créer CNN
model = models.Sequential([
# Bloc convolutif 1
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
# Bloc convolutif 2
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
# Bloc convolutif 3
layers.Conv2D(64, (3, 3), activation='relu'),
# Classification
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(10, activation='softmax') # 10 classes (0-9)
])
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
# Entraîner
model.fit(X_train, y_train, epochs=10, validation_data=(X_val, y_val))Réseau récurrent pour analyser des séquences temporelles.
from tensorflow.keras import layers, models
# Créer LSTM
model = models.Sequential([
layers.LSTM(128, return_sequences=True, input_shape=(100, 10)),
layers.Dropout(0.2),
layers.LSTM(64),
layers.Dropout(0.2),
layers.Dense(32, activation='relu'),
layers.Dense(1) # Prédiction continue
])
model.compile(
optimizer='adam',
loss='mse', # Mean Squared Error pour régression
metrics=['mae'] # Mean Absolute Error
)
model.fit(X_train, y_train, epochs=50, batch_size=64)Utiliser un modèle pré-entraîné pour une nouvelle tâche.
from tensorflow.keras.applications import VGG16
from tensorflow.keras import layers, models
# Charger VGG16 pré-entraîné (sans la couche de classification)
base_model = VGG16(
weights='imagenet',
include_top=False,
input_shape=(224, 224, 3)
)
# Geler les poids pré-entraînés
base_model.trainable = False
# Ajouter nos propres couches
model = models.Sequential([
base_model,
layers.GlobalAveragePooling2D(),
layers.Dense(256, activation='relu'),
layers.Dropout(0.5),
layers.Dense(5, activation='softmax') # 5 classes custom
])
model.compile(
optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy']
)
model.fit(X_train, y_train, epochs=10)Encoder-Decoder pour compresser et reconstruire des données.
from tensorflow.keras import layers, models
# Dimension de l'espace latent
encoding_dim = 32
# Encoder
encoder = models.Sequential([
layers.Dense(128, activation='relu', input_shape=(784,)),
layers.Dense(64, activation='relu'),
layers.Dense(encoding_dim, activation='relu')
])
# Decoder
decoder = models.Sequential([
layers.Dense(64, activation='relu', input_shape=(encoding_dim,)),
layers.Dense(128, activation='relu'),
layers.Dense(784, activation='sigmoid')
])
# Autoencoder complet
autoencoder = models.Sequential([encoder, decoder])
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
# Entraîner à reconstruire l'entrée
autoencoder.fit(X_train, X_train, epochs=50, batch_size=256)
# Utiliser l'encoder pour réduire la dimension
encoded_data = encoder.predict(X_test)Générateur et Discriminateur s'affrontent pour créer des données réalistes.
from tensorflow.keras import layers, models
# Générateur
generator = models.Sequential([
layers.Dense(256, activation='relu', input_shape=(100,)),
layers.BatchNormalization(),
layers.Dense(512, activation='relu'),
layers.BatchNormalization(),
layers.Dense(784, activation='tanh')
])
# Discriminateur
discriminator = models.Sequential([
layers.Dense(512, activation='relu', input_shape=(784,)),
layers.Dropout(0.3),
layers.Dense(256, activation='relu'),
layers.Dropout(0.3),
layers.Dense(1, activation='sigmoid')
])
discriminator.compile(optimizer='adam', loss='binary_crossentropy')
# GAN complet (générateur + discriminateur gelé)
discriminator.trainable = False
gan = models.Sequential([generator, discriminator])
gan.compile(optimizer='adam', loss='binary_crossentropy')
# Boucle d'entraînement alternée
for epoch in range(epochs):
# 1. Entraîner discriminateur
noise = np.random.normal(0, 1, (batch_size, 100))
fake_images = generator.predict(noise)
real_images = X_train[np.random.randint(0, X_train.shape[0], batch_size)]
d_loss_real = discriminator.train_on_batch(real_images, np.ones((batch_size, 1)))
d_loss_fake = discriminator.train_on_batch(fake_images, np.zeros((batch_size, 1)))
# 2. Entraîner générateur
noise = np.random.normal(0, 1, (batch_size, 100))
g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))Visualisation de Données
Créer des graphiques pour analyser les données et visualiser les résultats.
import matplotlib.pyplot as plt
import seaborn as sns
# Visualiser l'historique d'entraînement
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model Loss')
plt.legend(['train', 'validation'])
plt.show()
# Matrice de confusion
sns.heatmap(confusion_matrix, annot=True)Machine Learning Classique
Algorithmes ML traditionnels, preprocessing, métriques d'évaluation.
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
# Split données
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Normalisation
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)Traitement d'Images
Manipulation d'images, vidéo, détection de features pour vision par ordinateur.
import cv2
# Charger et redimensionner image
img = cv2.imread('image.jpg')
img_resized = cv2.resize(img, (224, 224))
# Convertir BGR → RGB
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# Augmentation
img_rotated = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)NLP & LLMs
Accès à des milliers de modèles pré-entraînés (BERT, GPT, T5...).
from transformers import pipeline
# Sentiment analysis en 2 lignes
classifier = pipeline('sentiment-analysis')
result = classifier("J'adore ce cours sur l'IA!")
# [{'label': 'POSITIVE', 'score': 0.9998}]
# Génération de texte
generator = pipeline('text-generation', model='gpt2')
text = generator("Python est", max_length=50)Computing Numérique Haute Performance
NumPy accéléré avec GPU/TPU, autodiff, compilation JIT.
import jax.numpy as jnp
from jax import grad, jit
# Fonction à optimiser
def loss(params, x, y):
return jnp.mean((params * x - y) ** 2)
# Gradient automatique
grad_fn = grad(loss)
# Compilation JIT pour vitesse
@jit
def fast_function(x):
return jnp.sum(x ** 2)Suivi d'Expériences
Traquer métriques, hyperparamètres, visualiser l'entraînement.
import wandb
# Initialiser
wandb.init(project="mon-projet")
# Logger métriques
wandb.log({
"loss": loss,
"accuracy": acc,
"epoch": epoch
})
# Pour TensorBoard avec Keras
tensorboard = keras.callbacks.TensorBoard(log_dir='./logs')
model.fit(X, y, callbacks=[tensorboard])import pandas as pd
import numpy as np
# Charger
df = pd.read_csv('dataset.csv')
# Explorer
print(df.head())
print(df.info())
print(df.describe())# Gérer valeurs manquantes
df = df.dropna()
# Encoder catégories
df = pd.get_dummies(df, columns=['category'])
# Séparer features/target
X = df.drop('target', axis=1).values
y = df['target'].valuesfrom sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)from tensorflow import keras
model = keras.Sequential([
keras.layers.Dense(64, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(32, activation='relu'),
keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])history = model.fit(
X_train, y_train,
epochs=50,
batch_size=32,
validation_split=0.2,
callbacks=[
keras.callbacks.EarlyStopping(patience=5),
keras.callbacks.ModelCheckpoint('best_model.h5')
]
)from sklearn.metrics import classification_report
# Prédictions
y_pred = (model.predict(X_test) > 0.5).astype(int)
# Métriques
print(classification_report(y_test, y_pred))
# Courbes
import matplotlib.pyplot as plt
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.show()# Sauvegarder
model.save('my_model.h5')
# Charger
loaded_model = keras.models.load_model('my_model.h5')
# Prédire sur nouvelles données
new_prediction = loaded_model.predict(new_data)Débutez avec Keras et des modèles simples. Augmentez la complexité progressivement uniquement si nécessaire.
Testez différentes architectures, hyperparamètres, fonctions d'activation. Utilisez W&B ou TensorBoard pour traquer vos expériences.
Toujours visualiser vos données, les courbes d'entraînement, et les prédictions. Les graphiques révèlent souvent des problèmes cachés.
Utilisez toujours un ensemble de validation pour détecter le surapprentissage. Early stopping est votre ami !
Ne réinventez pas la roue. Utilisez des modèles pré-entraînés quand c'est possible, surtout pour la vision et le NLP.
Documentez votre code, vos expériences, et vos résultats. Votre futur vous (et vos collègues) vous remercieront.
Python est l'écosystème le plus complet pour l'IA et le Machine Learning :
Avec Keras, vous pouvez créer des réseaux de neurones sophistiqués en quelques lignes de code. Commencez simple, expérimentez, et progressez graduellement vers des architectures plus complexes.
L'important n'est pas de tout maîtriser dès le début, mais de pratiquer régulièrement et de construire des projets concrets !