Comment utiliser le module keras pour l'apprentissage en profondeur dans Python 3.x

Comment utiliser le module Keras pour l'apprentissage en profondeur dans Python 3.x

Keras est une bibliothèque de réseaux neuronaux avancée pour créer et entraîner des modèles d'apprentissage en profondeur. Il est basé sur Python et prend en charge des backends tels que TensorFlow, Theano et MxNet. Keras fournit une API simple et facile à utiliser, nous permettant de créer rapidement différents types de modèles d'apprentissage en profondeur, tels que le Perceptron multicouche, le réseau neuronal convolutif et le réseau neuronal récurrent.

Cet article expliquera comment utiliser le module Keras pour l'apprentissage en profondeur dans l'environnement Python 3.x. Nous allons d'abord installer Keras et ses bibliothèques dépendantes, puis apprendre à créer et entraîner un modèle de réseau neuronal simple à l'aide d'un exemple de code simple.

1. Installer Keras

Avant de commencer, nous devons installer Keras dans notre environnement Python. Keras peut être installé à l'aide de pip via la commande suivante :

pip install keras

2. Créez un modèle de réseau neuronal simple

Ensuite, nous utiliserons Keras pour créer un modèle de réseau neuronal simple afin de mettre en œuvre la tâche de reconnaissance de chiffres manuscrits. Tout d'abord, nous devons importer les bibliothèques nécessaires :

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils

Ensuite, nous devons charger l'ensemble de données MNIST, qui contient 60 000 échantillons d'apprentissage et 10 000 échantillons de test. Chaque échantillon est une image en niveaux de gris 28x28, correspondant à un [0, 9 ]. entre les nombres. L'ensemble de données peut être chargé en utilisant le code suivant :

from keras.datasets import mnist

(X_train, Y_train), (X_test, Y_test) = mnist.load_data()

Ensuite, nous devons prétraiter les données. Étant donné que les données d'image originales sont une image en niveaux de gris de 28 x 28, nous devons les aplatir en un vecteur de 784 dimensions et normaliser les données d'entrée pour mettre à l'échelle la valeur du pixel dans la plage de [0, 255] à [0, 1 ] Dans la plage :

X_train = X_train.reshape(X_train.shape[0], 784).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 784).astype('float32') / 255

Afin de pouvoir entraîner le modèle, nous devons également encoder les étiquettes à chaud. Keras fournit la fonction np_utils.to_categorical() pour nous aider à réaliser cette étape :

Y_train = np_utils.to_categorical(Y_train, 10)
Y_test = np_utils.to_categorical(Y_test, 10)

Maintenant, nous pouvons construire un modèle simple de perceptron multicouche (Multilayer Perceptron). Ce modèle contient une couche d'entrée, deux couches cachées et une couche de sortie. Vous pouvez utiliser la fonction Sequential() pour créer un modèle de séquence et la fonction Dense() pour ajouter des couches :

model = Sequential()
model.add(Dense(units=512, input_dim=784, activation='relu'))
model.add(Dense(units=512, activation='relu'))
model.add(Dense(units=10, activation='softmax'))

Une fois le modèle construit, nous devons le compiler. Vous pouvez utiliser la fonction compile() pour configurer le processus de formation du modèle. Ici, nous pouvons spécifier la fonction de perte, l'optimiseur et les métriques d'évaluation :

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

3. Modèle d'entraînement et prédiction

Une fois le modèle compilé, nous pouvons utiliser la fonction fit() pour entraîner le modèle. Vous pouvez spécifier les données d'entraînement, le nombre de cycles d'entraînement et le nombre d'échantillons dans chaque lot :

model.fit(X_train, Y_train, epochs=10, batch_size=128)

Une fois la formation du modèle terminée, nous pouvons utiliser la fonction évaluer() pour évaluer les performances du modèle sur le test set :

loss, accuracy = model.evaluate(X_test, Y_test)
print('Test loss:', loss)
print('Test accuracy:', accuracy)

Enfin, nous pouvons utiliser la fonction prédict_classes() pour prédire les catégories de nouveaux échantillons :

predictions = model.predict_classes(X_test)

De cette façon, nous avons terminé le processus de construction et de formation d'un modèle de réseau neuronal simple.

Résumé :

Cet article présente comment utiliser le module Keras pour l'apprentissage en profondeur dans Python 3.x. Nous avons d'abord installé Keras et ses bibliothèques dépendantes, puis avons appris à créer et à entraîner un modèle de réseau neuronal simple à l'aide d'un exemple de code. Ceci n'est qu'une introduction au deep learning. Keras propose également plus de fonctions et de modèles pour répondre à différents besoins. J'espère que les lecteurs pourront avoir une compréhension préliminaire de Keras et de l'apprentissage profond grâce à l'introduction de cet article, et pouvoir l'utiliser dans des applications pratiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!