Créez des modèles d'apprentissage profond avec TensorFlow et Keras

TensorFlow et Keras sont actuellement l'un des frameworks d'apprentissage en profondeur les plus populaires. Ils fournissent non seulement des API de haut niveau pour faciliter la création et la formation de modèles d'apprentissage profond, mais fournissent également une variété de couches et de types de modèles pour faciliter la construction de divers types de modèles d'apprentissage profond. Par conséquent, ils sont largement utilisés pour former des modèles d’apprentissage profond à grande échelle.

Nous utiliserons TensorFlow et Keras pour créer un modèle d'apprentissage profond pour la classification d'images. Dans cet exemple, nous utiliserons l'ensemble de données CIFAR-10, qui contient 10 catégories différentes avec 6 000 images couleur 32x32 par catégorie.

Tout d'abord, nous devons importer les bibliothèques et les ensembles de données nécessaires. Nous utiliserons TensorFlow version 2.0 et l'API Keras pour créer le modèle. Voici le code pour importer la bibliothèque et l'ensemble de données : ```python importer tensorflow astf à partir de tensorflow importer des keras à partir de tensorflow.keras.datasets importer mnist #Importer un ensemble de données (x_train, y_train), (x_test, y_test) = mnist.load_data() ``` Ce qui précède est le code pour importer la bibliothèque et l'ensemble de données. Nous utilisons la bibliothèque « tensorflow » pour construire le modèle et utilisons l'ensemble de données « mnist » comme exemple d'ensemble de données.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.datasets import cifar10

# 加载CIFAR-10数据集
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# 将像素值缩放到0到1之间
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# 将标签从整数转换为one-hot编码
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

Ensuite, nous définirons un modèle de réseau neuronal convolutif. Nous utiliserons trois couches convolutives et trois couches de pooling pour extraire les fonctionnalités, puis deux couches entièrement connectées pour la classification. Voici la définition de notre modèle :

model = keras.Sequential(
    [
        # 第一个卷积层
        layers.Conv2D(32, (3, 3), activation="relu", input_shape=(32, 32, 3)),
        layers.MaxPooling2D((2, 2)),
        # 第二个卷积层
        layers.Conv2D(64, (3, 3), activation="relu"),
        layers.MaxPooling2D((2, 2)),
        # 第三个卷积层
        layers.Conv2D(128, (3, 3), activation="relu"),
        layers.MaxPooling2D((2, 2)),
        # 展平层
        layers.Flatten(),
        # 全连接层
       layers.Dense(128, activation="relu"),
        layers.Dense(10, activation="softmax"),
    ]
)

Dans ce modèle, nous utilisons la fonction d'activation ReLU, qui est une fonction non linéaire couramment utilisée qui peut aider le modèle à apprendre des relations non linéaires complexes. Nous avons également utilisé la fonction d'activation softmax pour la classification multi-classe.

Maintenant, nous pouvons compiler le modèle et commencer la formation. Nous utiliserons l'optimiseur Adam et la fonction de perte d'entropie croisée pour la formation du modèle. Voici le code : model.compile(optimizer='adam', loss='categorical_crossentropy') model.fit(X_train, y_train, epochs=10, batch_size=32)

# 编译模型
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

# 训练模型
history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

Une fois la formation terminée, nous pouvons utiliser l'ensemble de tests pour évaluer les performances du modèle. Voici notre code pour évaluer le modèle :

# 在测试集上评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)

print("Test loss:", test_loss)
print("Test accuracy:", test_acc)

Enfin, nous pouvons utiliser l'historique d'entraînement pour tracer la perte d'entraînement et de validation et la précision du modèle. Voici le code pour dessiner l'historique de la formation :

import matplotlib.pyplot as plt

# 绘制训练和验证损失
plt.plot(history.history["loss"], label="Training loss")
plt.plot(history.history["val_loss"], label="Validation loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()

plt.show()

# 绘制训练和验证准确率
plt.plot(history.history["accuracy"], label="Training accuracy")
plt.plot(history.history["val_accuracy"], label="Validation accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.legend()

plt.show()

Ce qui précède est le code complet d'un exemple de modèle d'apprentissage profond basé sur TensorFlow et Keras. Nous avons construit un modèle de réseau neuronal convolutif en utilisant l'ensemble de données CIFAR-10 pour les tâches de classification d'images.

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!