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

  1. Simple et facile à utiliser: offre une interface intuitive et cohérente, adaptée au prototypage rapide
  2. Modulaire: les couches de réseau de neurones, les fonctions de perte, les optimiseurs, etc. sont tous des modules enfichables
  3. Facilement extensible: permet d'ajouter facilement de nouveaux modules pour exprimer de nouvelles idées de recherche
  4. 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.models import Sequential
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

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

3. Entraîner le modèle

Exemple

model.fit(x_train, y_train,
          époques=5,
          batch_size=32)

4. Évaluer le modèle

Exemple

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

5. Faire des prédictions

Exemple

classes = model.predict(x_test, batch_size=128)

Explication détaillée des couches Keras courantes

1. Couche Dense entièrement connectée

Exemple

Dense(units,
      activation=None,
      use_bias=True,
      kernel_initializer='glorot_uniform',
      bias_initializer='zeros')
  • units: entier positif, dimension de l'espace de sortie
  • activation: fonction d'activation
  • use_bias: s'il faut utiliser un vecteur de biais
  • kernel_initializer: initialiseur pour la matrice de poids
  • bias_initializer: initialiseur pour le vecteur de biais

2. Conv2D : couche de convolution 2D

Exemple

Conv2D(filters,
       kernel_size,
       strides=(1, 1),
       padding='valid',
       activation=None)
  • filters: nombre de noyaux de convolution
  • kernel_size: taille du noyau de convolution
  • strides: pas de convolution
  • padding: mode de remplissage ('valid' ou 'same')

3. LSTM : couche de mémoire à long et court terme

Exemple

LSTM(units,
     activation='tanh',
     recurrent_activation='hard_sigmoid',
     return_sequences=False)
  • units: entier positif, dimension de l'espace de sortie
  • activation: fonction d'activation
  • recurrent_activation: fonction d'activation pour l'étape récurrente
  • return_sequences: s'il faut renvoyer la séquence complète

Sauvegarde et chargement du modèle Keras

1. Enregistrer le modèle complet

Exemple

model.save('my_model.h5')  # Enregistrer l'architecture, les poids et la configuration d'entraînement

2. Enregistrer uniquement l'architecture

Exemple

json_string = model.to_json()  # Enregistrer au format JSON
yaml_string = model.to_yaml()  # Enregistrer au format YAML

3. Enregistrer uniquement les poids

Exemple

model.save_weights('my_model_weights.h5')

4. Charger le modèle

Exemple

from tensorflow.keras.models import load_model

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

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

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.datasets import mnist
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 import backend as K
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

from tensorflow.keras import backend as K

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

from tensorflow.keras.callbacks import LearningRateScheduler

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 :

  1. Concepts fondamentaux de Keras et flux de travail de base
  2. Comment utiliser les couches courantes
  3. Sauvegarde et chargement du modèle
  4. Utilisation des fonctions de rappel
  5. Exemples d'application dans des projets réels
  6. 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