Exemple d'algorithme de réseau neuronal récurrent en Python

Ces dernières années, l'apprentissage profond est devenu un sujet brûlant dans le domaine de l'intelligence artificielle. Dans la pile technologique d'apprentissage profond, les réseaux de neurones récurrents (RNN en abrégé) sont un algorithme très important. Python est un langage de programmation très populaire dans le domaine de l'intelligence artificielle. La bibliothèque d'apprentissage en profondeur TensorFlow de Python fournit également une multitude d'implémentations d'algorithmes RNN. Cet article présentera l'algorithme de réseau neuronal récurrent en Python et donnera un exemple d'application pratique.

1. Introduction aux réseaux de neurones récurrents

Les réseaux de neurones récurrents (RNN) sont un réseau de neurones artificiels capable de traiter des données de séquence. Contrairement aux réseaux de neurones traditionnels, RNN peut utiliser des informations antérieures pour aider à comprendre les données d'entrée actuelles. Ce « mécanisme de mémoire » rend RNN très efficace lors du traitement de données séquentielles telles que la langue, les séries chronologiques et la vidéo.

Le cœur du réseau neuronal récurrent est sa structure cyclique. Dans une série chronologique, l'entrée à chaque instant affecte non seulement la sortie actuelle, mais affecte également la sortie au prochain instant. RNN implémente un mécanisme de mémoire en combinant la sortie du point temporel actuel avec la sortie du point temporel précédent. Au cours du processus de formation, RNN apprend automatiquement à enregistrer les informations historiques et à les utiliser pour guider les décisions en cours.

2. Implémentation de l'algorithme de réseau neuronal récurrent en Python

En Python, le framework d'apprentissage en profondeur le plus populaire pour la mise en œuvre de l'algorithme RNN est TensorFlow. TensorFlow fournit aux utilisateurs divers modèles d'algorithmes RNN, notamment le RNN de base, le LSTM (réseau de mémoire à long terme) et le GRU (unité récurrente fermée), etc.

Ensuite, regardons un exemple de réseau neuronal récurrent implémenté basé sur TensorFlow.

Nous utiliserons une tâche de génération de texte pour démontrer l'application des réseaux de neurones récurrents. Notre objectif est de générer un nouveau texte en utilisant un texte de formation connu.

Tout d'abord, nous devons préparer les données d'entraînement. Dans cet exemple, nous utiliserons Hamlet de Shakespeare comme texte de formation. Nous devons prétraiter le texte, convertir tous les caractères en jeu de caractères abrégés et les convertir en nombres.

Ensuite, nous devons construire un modèle de réseau neuronal récurrent. Nous utiliserons le modèle LSTM. Voici l'implémentation du code :

import tensorflow as tf

#定义超参数
num_epochs = 50
batch_size = 50
learning_rate = 0.01

#读取训练数据
data = open('shakespeare.txt', 'r').read()
chars = list(set(data))
data_size, vocab_size = len(data), len(chars)
char_to_ix = { ch:i for i,ch in enumerate(chars) }
ix_to_char = { i:ch for i,ch in enumerate(chars) }

#定义模型架构
inputs = tf.placeholder(tf.int32, shape=[None, None], name='inputs')
targets = tf.placeholder(tf.int32, shape=[None, None], name='targets')
keep_prob = tf.placeholder(tf.float32, shape=[], name='keep_prob')

#定义LSTM层
lstm_cell = tf.contrib.rnn.BasicLSTMCell(num_units=512)
dropout_cell = tf.contrib.rnn.DropoutWrapper(cell=lstm_cell, output_keep_prob=keep_prob)
outputs, final_state = tf.nn.dynamic_rnn(dropout_cell, inputs, dtype=tf.float32)

#定义输出层
logits = tf.contrib.layers.fully_connected(outputs, num_outputs=vocab_size, activation_fn=None)
predictions = tf.nn.softmax(logits)

#定义损失函数和优化器
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=targets))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)

Dans ce modèle, nous utilisons un réseau neuronal LSTM monocouche et définissons une couche d'abandon pour empêcher le modèle de surajuster. La couche de sortie adopte une couche entièrement connectée et utilise la fonction softmax pour normaliser le texte généré.

Avant de former le modèle, nous devons également implémenter certaines fonctions auxiliaires. Par exemple, une fonction permettant de générer une séquence aléatoire d'échantillons et une fonction permettant de reconvertir des nombres en caractères. Voici l'implémentation du code :

import random

#生成序列数据样本
def sample_data(data, batch_size, seq_length):
    num_batches = len(data) // (batch_size * seq_length)
    data = data[:num_batches * batch_size * seq_length]
    x_data = np.array(data)
    y_data = np.copy(x_data)
    y_data[:-1] = x_data[1:]
    y_data[-1] = x_data[0]
    x_batches = np.split(x_data.reshape(batch_size, -1), num_batches, axis=1)
    y_batches = np.split(y_data.reshape(batch_size, -1), num_batches, axis=1)
    return x_batches, y_batches

#将数字转换回字符
def to_char(num):
    return ix_to_char[num]

Avec ces fonctions auxiliaires, nous pouvons commencer à entraîner le modèle. Pendant le processus de formation, nous divisons les données de formation en petits blocs en fonction de batch_size et seq_length, et les envoyons au modèle par lots pour la formation. Voici l'implémentation du code :

import numpy as np

#启动会话
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    #开始训练模型
    for epoch in range(num_epochs):
        epoch_loss = 0
        x_batches, y_batches = sample_data(data, batch_size, seq_length)

        for x_batch, y_batch in zip(x_batches, y_batches):
            inputs_, targets_ = np.array(x_batch), np.array(y_batch)
            inputs_ = np.eye(vocab_size)[inputs_]
            targets_ = np.eye(vocab_size)[targets_]
            last_state, _ = sess.run([final_state, optimizer],
                                     feed_dict={inputs:inputs_, targets:targets_, keep_prob:0.5})
            epoch_loss += loss.eval(feed_dict={inputs:inputs_, targets:targets_, keep_prob:1.0})

        #在每个epoch结束时输出损失函数
        print('Epoch {:2d} loss {:3.4f}'.format(epoch+1, epoch_loss))

        #生成新的文本
        start_index = random.randint(0, len(data) - seq_length)
        sample_seq = data[start_index:start_index+seq_length]
        text = sample_seq
        for _ in range(500):
            x_input = np.array([char_to_ix[ch] for ch in text[-seq_length:]])
            x_input = np.eye(vocab_size)[x_input]
            prediction = sess.run(predictions, feed_dict={inputs:np.expand_dims(x_input, 0), keep_prob:1.0})
            prediction = np.argmax(prediction, axis=2)[0]
            text += to_char(prediction[-1])

        print(text)

3. Conclusion

Le réseau neuronal récurrent le rend plus précis et plus efficace dans le traitement des données de séquence en combinant l'entrée actuelle et les informations précédentes. En Python, nous pouvons utiliser l'algorithme RNN fourni dans la bibliothèque TensorFlow pour implémenter facilement l'algorithme de réseau neuronal récurrent. Cet article fournit un exemple d'implémentation Python basé sur LSTM, qui peut être appliqué aux tâches de génération de texte.

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!