Premier réseau de neurones avec Keras
Keras est une API de réseau de neurones de haut niveau écrite en Python qui peut s'exécuter au-dessus de TensorFlow, CNTK ou Theano. Son développement se concentre sur la prise en charge d'une expérimentation rapide, permettant une transition rapide de l'idée au résultat avec un minimum de code.
Principales fonctionnalités de Keras
- Convivial: Keras dispose d'une interface simple et cohérente
- Modulaire: Les différents composants d'un réseau de neurones (couches, optimiseurs, schémas d'initialisation, etc.) sont des modules composables
- Extensibilité facile: De nouveaux modules peuvent être facilement ajoutés pour exprimer de nouvelles idées de recherche
- Prise en charge multi-backend: Permet de basculer de manière transparente entre TensorFlow, Theano et CNTK comme backend de calcul
Installation de Keras
Avant de commencer, nous devons installer Keras et son moteur backend (ici, nous utilisons TensorFlow) :
pip install tensorflow keras
Remarque : Keras 2.4.0 et les versions ultérieures ont été intégrées à TensorFlow et peuvent être utilisées directement via
tensorflow.kerasUtiliser
Construction du premier réseau de neurones
Commençons par un simple réseau de neurones entièrement connecté pour résoudre le problème classique de reconnaissance de chiffres manuscrits MNIST.
1. Importer les bibliothèques nécessaires
Exemple
from tensorflow import keras
from tensorflow.keras import layers
2. Préparer les données
Le jeu de données MNIST contient 60,000 images d'entraînement et 10,000 images de test, chacune étant une image en niveaux de gris de 28x28 pixels d'un chiffre manuscrit.
Exemple
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Prétraiter les données
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255
# Convertir les étiquettes en encodage one-hot
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
3. Construire le modèle
Nous allons construire un réseau entièrement connecté simple contenant une couche d'entrée, une couche cachée et une couche de sortie.
Exemple
layers.Dense(512, activation="relu", input_shape=(784,)),
layers.Dense(10, activation="softmax")
])
Analyse de la structure du modèle
Exemple
A[Couche d'entrée 784 neurones] --> B[Couche cachée 512 neurones, activation ReLU]
B --> C[Couche de sortie 10 neurones, activation Softmax]
4. Compiler le modèle
Avant d'entraîner le modèle, nous devons configurer le processus d'apprentissage :
Exemple
optimizer="rmsprop",
loss="categorical_crossentropy",
metrics=["accuracy"]
)
Description des paramètres de compilation
| Paramètre | Description | Valeurs courantes |
|---|---|---|
| optimizer | Optimiseur, utilisé pour mettre à jour les poids | "rmsprop", "adam", "sgd" |
| loss | Fonction de perte, mesure la différence entre les prédictions du modèle et les valeurs réelles | "categorical_crossentropy" (classification), "mse" (régression) |
| metrics | Métrique d'évaluation, utilisée pour surveiller l'entraînement | ["accuracy"] |
5. Entraîner le modèle
Nous pouvons maintenant commencer l'entraînement du modèle :
Exemple
x_train, y_train,
batch_size=128,
époques=10,
validation_split=0.2
)
Description des paramètres d'entraînement
| Paramètre | Description | Valeurs suggérées |
|---|---|---|
| batch_size | Nombre d'échantillons utilisés par mise à jour du gradient | 32-256 |
| époques | Nombre d'époques d'entraînement | Ajuster en fonction de la complexité des données |
| validation_split | Proportion des données d'entraînement utilisée comme ensemble de validation | 0.1-0.3 |
6. Évaluer le modèle
Une fois l'entraînement terminé, nous pouvons évaluer les performances du modèle sur l'ensemble de test :
Exemple
print(f"Test accuracy: {test_acc:.4f}")
Exemple de code complet
Exemple
from tensorflow import keras
from tensorflow.keras import layers
# 1. Charger les données
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# 2. Prétraiter
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
# 3. Construire le modèle
model = keras.Sequential([
layers.Dense(512, activation="relu", input_shape=(784,)),
layers.Dense(10, activation="softmax")
])
# 4. Compiler le modèle
model.compile(
optimizer="rmsprop",
loss="categorical_crossentropy",
metrics=["accuracy"]
)
# 5. Entraîner le modèle
history = model.fit(
x_train, y_train,
batch_size=128,
époques=10,
validation_split=0.2
)
# 6. Évaluer le modèle
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")
Suggestions d'amélioration du modèle
1. Ajouter une couche Dropout: Prévenir le surapprentissage
Exemple
2. Utiliser un optimiseur plus avancé: Comme Adam
Exemple
3. Ajouter des couches cachées: Construire un réseau plus profond
Exemple
4. Utiliser des couches convolutionnelles: Plus efficaces pour les données d'image
Exemple
FAQ
Q1: Pourquoi la précision de mon modèle est-elle si faible ?
- Vérifiez si le prétraitement des données est correct
- Essayez d'ajuster le taux d'apprentissage
- Augmenter la capacité du réseau (plus de couches ou plus de neurones)
Q2 : Que dois-je faire si la perte ne diminue pas pendant l'entraînement ?
- Vérifier s'il y a des problèmes avec les données
- Essayer différents optimiseurs
- Ajuster le taux d'apprentissage (généralement le réduire)
Q3 : Comment sauvegarder et charger un modèle entraîné ?
Exemple
model.save("mnist_model.h5")
# Charger le modèle
loaded_model = keras.models.load_model("mnist_model.h5")