API avancée TensorFlow - Keras
Keras est une API de réseau de neurones de haut niveau écrite en Python qui peut s'exécuter sur TensorFlow, CNTK ou Theano comme backends. Keras est conçu pour être convivial, modulaire et facilement extensible.
Principales caractéristiques de Keras
- Simple et facile à utiliser: offre une interface intuitive et cohérente, adaptée au prototypage rapide
- Modulaire: les couches de réseau de neurones, les fonctions de perte, les optimiseurs, etc. sont tous des modules enfichables
- Facilement extensible: permet d'ajouter facilement de nouveaux modules pour exprimer de nouvelles idées de recherche
- Prise en charge multi-backend: peut s'exécuter de manière transparente sur TensorFlow, CNTK ou Theano
Concepts de base de Keras
1. Modèle
La structure de données centrale de Keras est le modèle, qui est une façon d'organiser les couches de réseau de neurones. Keras propose deux principaux types de modèles :
- Modèle séquentiel: empilement linéaire de couches
- API fonctionnelle: un graphe orienté acyclique pour construire des modèles complexes
2. Couche
Les couches sont les blocs de construction de base de Keras. Chaque couche reçoit des données d'entrée, effectue un certain calcul et produit le résultat. Keras fournit de nombreuses couches prédéfinies :
- Couches de base : Dense, Activation, Dropout, etc.
- Couches convolutives : Conv2D, MaxPooling2D, etc.
- Couches récurrentes : LSTM, GRU, etc.
- Autres : Embedding, BatchNormalization, etc.
3. Fonction d'activation
La fonction d'activation détermine la sortie d'un neurone. Les plus couramment utilisées incluent :
- ReLU (unité linéaire rectifiée)
- Sigmoïde
- Tanh
- Softmax (classification multi-classes)
Flux de travail de base avec Keras
1. Définir le modèle
Exemple
from tensorflow.keras.layers import Dense
model = Sequential([
Dense(64, activation='relu', input_shape=(784,)),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
2. Compiler le modèle
Exemple
loss='categorical_crossentropy',
metrics=['accuracy'])
3. Entraîner le modèle
Exemple
époques=5,
batch_size=32)
4. Évaluer le modèle
Exemple
5. Faire des prédictions
Exemple
Explication détaillée des couches Keras courantes
1. Couche Dense entièrement connectée
Exemple
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros')
units: entier positif, dimension de l'espace de sortieactivation: fonction d'activationuse_bias: s'il faut utiliser un vecteur de biaiskernel_initializer: initialiseur pour la matrice de poidsbias_initializer: initialiseur pour le vecteur de biais
2. Conv2D : couche de convolution 2D
Exemple
kernel_size,
strides=(1, 1),
padding='valid',
activation=None)
filters: nombre de noyaux de convolutionkernel_size: taille du noyau de convolutionstrides: pas de convolutionpadding: mode de remplissage ('valid' ou 'same')
3. LSTM : couche de mémoire à long et court terme
Exemple
activation='tanh',
recurrent_activation='hard_sigmoid',
return_sequences=False)
units: entier positif, dimension de l'espace de sortieactivation: fonction d'activationrecurrent_activation: fonction d'activation pour l'étape récurrentereturn_sequences: s'il faut renvoyer la séquence complète
Sauvegarde et chargement du modèle Keras
1. Enregistrer le modèle complet
Exemple
2. Enregistrer uniquement l'architecture
Exemple
yaml_string = model.to_yaml() # Enregistrer au format YAML
3. Enregistrer uniquement les poids
Exemple
4. Charger le modèle
Exemple
model = load_model('my_model.h5') # Charger le modèle complet
Fonctions de rappel Keras
Les fonctions de rappel sont des fonctions appelées à des moments précis pendant l'entraînement, utilisées pour :
- Sauvegarde de points de contrôle du modèle
- Arrêt précoce
- Ajustement du taux d'apprentissage
- Journalisation, etc.
Fonctions de rappel courantes
Exemple
callbacks = [
ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True),
EarlyStopping(monitor='val_loss', patience=3)
]
model.fit(x_train, y_train,
époques=10,
callbacks=callbacks,
validation_data=(x_val, y_val))
Exemple pratique Keras : reconnaissance de chiffres manuscrits MNIST
Exemple
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.utils import to_categorical
# Charger les données
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Prétraiter les données
x_train = x_train.reshape(60000, 28, 28, 1).astype('float32') / 255
x_test = x_test.reshape(10000, 28, 28, 1).astype('float32') / 255
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
# Construire le modèle
model = Sequential([
Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.25),
Flatten(),
Dense(128, activation='relu'),
Dropout(0.5),
Dense(10, activation='softmax')
])
# Compiler le modèle
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# Entraîner le modèle
model.fit(x_train, y_train,
batch_size=128,
époques=12,
verbose=1,
validation_data=(x_test, y_test))
# Évaluer le modèle
score = model.evaluate(x_test, y_test, verbose=0)
print('Perte de test :', score[0])
print('Précision du test :', score[1])
Astuces avancées Keras
1. Couches personnalisées
Exemple
from tensorflow.keras.layers import Layer
class MyLayer(Layer):
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyLayer, self).__init__(**kwargs)
def build(self, input_shape):
self.kernel = self.add_weight(name='kernel',
shape=(input_shape[1], self.output_dim),
initializer='uniform',
trainable=True)
super(MyLayer, self).build(input_shape)
def call(self, x):
return K.dot(x, self.kernel)
def compute_output_shape(self, input_shape):
return (input_shape[0], self.output_dim)
2. Fonction de perte personnalisée
Exemple
def custom_loss(y_true, y_pred):
return K.mean(K.square(y_pred - y_true), axis=-1)
model.compile(optimizer='adam', loss=custom_loss)
3. Planification du taux d'apprentissage
Exemple
def scheduler(epoch, lr):
if epoch < 10:
return lr
else:
return lr * K.exp(-0.1)
callback = LearningRateScheduler(scheduler)
model.fit(x_train, y_train, epochs=15, callbacks=[callback])
Problèmes et solutions courants de Keras
1. Problème de surapprentissage
- Ajouter des couches Dropout
- Utiliser la régularisation L1/L2
- Ajouter plus de données d'entraînement
- Utiliser l'augmentation de données
2. Vitesse d’entraînement lente
- Augmenter la taille du lot
- Utiliser un modèle plus simple
- Essayer différents optimiseurs
- Utiliser l’accélération GPU
3. Disparition/explosion des gradients
- Utiliser BatchNormalization
- Utiliser une initialisation de poids appropriée
- Utiliser des fonctions d’activation non saturantes telles que ReLU
- Utiliser l’écrêtage des gradients
Résumé
En tant qu’API de haut niveau de TensorFlow, Keras fournit une interface simple et intuitive pour construire et entraîner des modèles d’apprentissage profond. Après avoir lu cet article, vous devriez maîtriser :
- Concepts fondamentaux de Keras et flux de travail de base
- Comment utiliser les couches courantes
- Sauvegarde et chargement du modèle
- Utilisation des fonctions de rappel
- Exemples d'application dans des projets réels
- Astuces avancées et solutions aux problèmes courants
La force de Keras réside dans sa flexibilité et sa facilité d'utilisation, ce qui rend le développement de modèles d'apprentissage profond plus efficace. Au fur et à mesure que vous gagnerez en pratique, vous pourrez construire des modèles de réseaux de neurones plus complexes pour résoudre divers problèmes du monde réel.
Autres extensions