Implémentation de Réseau de Neurones

Aperçu de Base du Réseau Neuronal

Vous avez maintenant atteint un stade où vous êtes équipé des connaissances essentielles de TensorFlow pour créer des réseaux neuronaux par vous-même. Bien que la plupart des réseaux neuronaux du monde réel soient complexes et généralement construits à l'aide de bibliothèques de haut niveau comme Keras, nous allons en construire un basique en utilisant les outils fondamentaux de TensorFlow. Cette approche nous donne une expérience pratique de la manipulation de tenseurs de bas niveau, nous aidant à comprendre les processus sous-jacents.

Dans des cours précédents comme Introduction aux Réseaux Neuronaux, vous vous souvenez peut-être du temps et des efforts nécessaires pour construire même un simple réseau neuronal, traitant chaque neurone individuellement.

TensorFlow simplifie considérablement ce processus. En utilisant des tenseurs, nous pouvons encapsuler des calculs complexes, réduisant ainsi le besoin de codage complexe. Notre tâche principale est de mettre en place un pipeline séquentiel d'opérations sur les tenseurs.

Voici un bref rappel des étapes pour démarrer un processus d'entraînement de réseau de neurones :

Préparation des données et création du modèle

La phase initiale de l'entraînement d'un réseau de neurones implique la préparation des données, englobant à la fois les entrées et les sorties que le réseau apprendra. De plus, nous établirons les hyperparamètres du modèle - ce sont les paramètres qui restent constants tout au long du processus d'entraînement. Nous initialisons également les poids, généralement tirés d'une distribution normale, et les biais, qui sont souvent fixés à zéro.

Propagation avant

Dans la propagation avant, chaque couche du réseau suit généralement ces étapes :

Multipliez l'entrée de la couche par ses poids ;
Ajoutez un biais au résultat ;
Appliquez une fonction d'activation à cette somme.

Ensuite, nous pouvons calculer la perte.

Propagation Rétrograde

La prochaine étape est la propagation rétrograde, où nous ajustons les poids et les biais en fonction de leur influence sur la perte. Cette influence est représentée par le gradient, que le Gradient Tape de TensorFlow calcule automatiquement. Nous mettons à jour les poids et les biais en soustrayant le gradient, mis à l'échelle par le taux d'apprentissage.

Boucle d'entraînement

Pour entraîner efficacement le réseau de neurones, nous répétons les étapes d'entraînement plusieurs fois tout en suivant la performance du modèle. Idéalement, nous devrions voir la perte diminuer au fil des époques.

Tâche

Swipe to start coding

Créez un réseau de neurones conçu pour prédire les résultats de l'opération XOR. Le réseau doit se composer de 2 neurones d'entrée, d'une couche cachée avec 2 neurones, et d'un neurone de sortie.

Commencez par configurer les poids et biais initiaux. Les poids doivent être initialisés en utilisant une distribution normale, et les biais doivent tous être initialisés à zéro. Utilisez les hyperparamètres input_size, hidden_size, et output_size pour définir les formes appropriées pour ces tenseurs.
Utilisez un décorateur de fonction pour transformer la fonction train_step() en un graph TensorFlow.
Effectuez la propagation avant à travers les couches cachée et de sortie du réseau. Utilisez la fonction d'activation sigmoïde.
Déterminez les gradients pour comprendre comment chaque poids et biais impacte la perte. Assurez-vous que les gradients sont calculés dans le bon ordre, correspondant aux noms des variables de sortie.
Modifiez les poids et biais en fonction de leurs gradients respectifs. Incorporez le learning_rate dans ce processus d'ajustement pour contrôler l'ampleur de chaque mise à jour.

Solution

import numpy as np

import tensorflow as tf

# Set seed

tf.random.set_seed(1)

# Set up input and output data

X_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype='float32')

Y_data = np.array([[0], [1], [1], [0]], dtype='float32')

# Hyperparameters

input_size = 2

hidden_size = 2

output_size = 1

learning_rate = 0.5

# Weights and biases for the hidden layer

W1 = tf.Variable(tf.random.normal((input_size, hidden_size)))

b1 = tf.Variable(tf.zeros((hidden_size)))

# Weights and biases for the output layer

W2 = tf.Variable(tf.random.normal((hidden_size, output_size)))

b2 = tf.Variable(tf.zeros((output_size)))

# Function that describes a single training step

@tf.function

def train_step(X, Y):

with tf.GradientTape() as tape:

# Forward pass for hidden layer

z1 = tf.matmul(X, W1) + b1 # Calculate biased weighted sum

a1 = tf.sigmoid(z1) # Apply activation function

# Forward pass for output layer

z2 = tf.matmul(a1, W2) + b2 # Calculate biased weighted sum

Y_pred = tf.sigmoid(z2) # Apply activation function

Conclusion

Étant donné que la fonction XOR est une tâche relativement simple, nous n'avons pas besoin de techniques avancées comme l'ajustement des hyperparamètres, la division du jeu de données ou la construction de pipelines de données complexes à ce stade. Cet exercice n'est qu'une étape vers la construction de réseaux de neurones plus sophistiqués pour des applications réelles.

Maîtriser ces bases est crucial avant de plonger dans les techniques avancées de construction de réseaux de neurones dans les cours à venir, où nous utiliserons la bibliothèque Keras et explorerons des méthodes pour améliorer la qualité du modèle avec les riches fonctionnalités de TensorFlow.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 3

single

import numpy as np

import tensorflow as tf

# Set seed

tf.random.set_seed(1)

# Set up input and output data

X_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype='float32')

Y_data = np.array([[0], [1], [1], [0]], dtype='float32')

# Hyperparameters

input_size = 2

hidden_size = 2

output_size = 1

learning_rate = 0.5

# Weights and biases for the hidden layer

W1 = tf.Variable(tf.___((___, ___)))

b1 = tf.Variable(tf.___((___)))

# Weights and biases for the output layer

W2 = tf.Variable(tf.___((___, ___)))

b2 = tf.Variable(tf.___((___)))

# Function that describes a single training step

___

def train_step(X, Y):

with tf.___() as tape:

# Forward pass for hidden layer

z1 = tf.matmul(___) + ___ # Calculate biased weighted sum

a1 = tf.___(___) # Apply activation function

# Forward pass for output layer

z2 = tf.matmul(___) + ___ # Calculate biased weighted sum

Y_pred = tf.___(___) # Apply activation function

# Calculate loss (Mean Squared Error)

loss = tf.reduce_mean((Y_pred - Y) ** 2)

# Gradients

dW1, db1, dW2, db2 = tape.___(___, [___])

# Update weights and biases

W1.assign_sub(___)

b1.assign_sub(___)

W2.assign_sub(___)

b2.assign_sub(___)

return loss

# Number of epochs for the model to run through

epochs = 2500

# Training loop

for epoch in range(epochs):

# Single training step

loss = train_step(X_data, Y_data)

# Display loss every 500 epochs

if (epoch + 1) % 500 == 0:

print(f"Epoch {epoch+1}/{epochs}, Loss: {loss:.4f}")

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion