Comment créer un réseau neuronal à l'aide de TensorFlow

TensorFlow est un framework d'apprentissage automatique populaire utilisé pour former et déployer divers réseaux de neurones. Cet article explique comment utiliser TensorFlow pour créer un réseau neuronal simple et fournit un exemple de code pour vous aider à démarrer.

La première étape dans la construction d'un réseau de neurones consiste à définir la structure du réseau. Dans TensorFlow, nous pouvons utiliser le module tf.keras pour définir les couches d'un réseau de neurones. L'exemple de code suivant définit un réseau neuronal à réaction entièrement connecté avec deux couches cachées et une couche de sortie : ```python importer tensorflow astf modèle = tf.keras.models.Sequential([ tf.keras.layers.Dense(units=64, activation='relu', input_shape=(input_dim,)), tf.keras.layers.Dense(units=32, activation='relu'), tf.keras.layers.Dense(units=output_dim, activation='softmax') ]) ``` Dans le code ci-dessus, nous utilisons le modèle « Séquentiel » pour construire le réseau neuronal. La couche « Dense » représente une couche entièrement connectée, spécifiant le nombre de neurones (unités) et la fonction d'activation (activation) de chaque couche. La forme d'entrée de la première couche cachée est donnée par `input_shape

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

Dans cet exemple, nous utilisons le modèle séquentiel pour définir notre réseau neuronal. Il s'agit d'un modèle d'empilement simple dans lequel chaque couche s'appuie sur la couche précédente. Nous définissons trois couches, la première et la deuxième couches sont toutes deux des couches entièrement connectées avec 64 neurones et utilisent la fonction d'activation ReLU. La forme de la couche d'entrée est (784), car nous utiliserons l'ensemble de données de chiffres manuscrits MNIST, et chaque image de cet ensemble de données mesure 28 x 28 pixels, qui s'étend jusqu'à 784 pixels. La dernière couche est une couche entièrement connectée avec 10 neurones qui utilise une fonction d'activation softmax et est utilisée pour les tâches de classification telles que la classification des chiffres dans l'ensemble de données MNIST.

Nous devons compiler le modèle et spécifier l'optimiseur, la fonction de perte et les métriques d'évaluation. Voici l'exemple :

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

Dans cet exemple, nous utilisons l'optimiseur Adam pour entraîner notre modèle en utilisant l'entropie croisée comme fonction de perte pour un problème de classification multi-classes. Nous avons également spécifié la précision comme mesure d'évaluation pour suivre les performances du modèle pendant la formation et l'évaluation.

Maintenant que nous avons défini la structure et la configuration d'entraînement du modèle, nous pouvons lire les données et commencer à entraîner le modèle. Nous utiliserons l'ensemble de données de chiffres manuscrits MNIST comme exemple. Voici l'exemple de code :

from tensorflow.keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

train_images = train_images.reshape((60000, 784))
train_images = train_images.astype('float32') / 255

test_images = test_images.reshape((10000, 784))
test_images = test_images.astype('float32') / 255

train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)

model.fit(train_images, train_labels, epochs=5, batch_size=64)

Dans cet exemple, nous utilisons la fonction mnist.load_data() pour charger l'ensemble de données MNIST. Nous avons ensuite aplati les images d'entraînement et de test à 784 pixels et mis à l'échelle les valeurs des pixels pour qu'elles soient comprises entre 0 et 1. Nous encodons également les étiquettes à chaud afin de les convertir en tâche de classification. Enfin, nous utilisons la fonction d'ajustement pour entraîner notre modèle, en utilisant des images et des étiquettes d'entraînement, en spécifiant un entraînement pour 5 époques, en utilisant 64 échantillons pour chaque époque.

Une fois la formation terminée, nous pouvons utiliser la fonction d'évaluation pour évaluer les performances du modèle sur l'ensemble de test :

test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)

Dans cet exemple, nous appelons la fonction d'évaluation avec l'image et l'étiquette de test, et imprimons les résultats pour afficher les performances du modèle sur la précision de l'ensemble de test sur l'ensemble.

Ceci est un exemple simple de la façon de créer et de former un réseau neuronal à l'aide de TensorFlow. Bien entendu, dans les applications réelles, vous aurez peut-être besoin de structures de réseau et d’ensembles de données plus complexes. Cependant, cet exemple constitue un bon point de départ pour vous aider à comprendre l'utilisation de base de TensorFlow.

L'exemple de code complet est le suivant :

import tensorflow as tf
from tensorflow.keras.datasets import mnist

# Define the model architecture
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

# Load the data
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

train_images = train_images.reshape((60000, 784))
train_images = train_images.astype('float32') / 255

test_images = test_images.reshape((10000, 784))
test_images = test_images.astype('float32') / 255

train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)

# Train the model
model.fit(train_images, train_labels, epochs=5, batch_size=64)

# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)

Ce qui précède est l'exemple de code pour créer un réseau neuronal à l'aide de TensorFlow, qui définit un réseau neuronal à réaction entièrement connecté contenant deux couches cachées et une couche de sortie, à l'aide de MNIST. données numériques manuscrites L'ensemble est formé et testé à l'aide de l'optimiseur Adam et de la fonction de perte d'entropie croisée. Le résultat final est la précision de l’ensemble de test.

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!