Contoh algoritma rangkaian saraf berulang dalam Python

Dalam beberapa tahun kebelakangan ini, pembelajaran mendalam telah menjadi topik hangat dalam bidang kecerdasan buatan. Dalam timbunan teknologi pembelajaran mendalam, Rangkaian Neural Berulang (RNN singkatannya) ialah algoritma yang sangat penting. Python ialah bahasa pengaturcaraan yang sangat popular dalam bidang kecerdasan buatan, perpustakaan pembelajaran mendalam Python TensorFlow juga menyediakan banyak pelaksanaan algoritma RNN. Artikel ini akan memperkenalkan algoritma rangkaian saraf berulang dalam Python dan memberikan contoh aplikasi praktikal.

1. Pengenalan kepada Rangkaian Neural Berulang

Rangkaian Neural Berulang (secara ringkasnya RNN) ialah rangkaian saraf tiruan yang boleh memproses data jujukan. Tidak seperti rangkaian neural tradisional, RNN boleh menggunakan maklumat sebelumnya untuk membantu memahami data input semasa. "Mekanisme ingatan" ini menjadikan RNN sangat berkesan apabila memproses data berjujukan seperti bahasa, siri masa dan video.

Inti bagi rangkaian saraf berulang ialah struktur kitarannya. Dalam siri masa, input pada setiap titik masa bukan sahaja mempengaruhi output semasa, tetapi juga mempengaruhi output pada titik masa seterusnya. RNN melaksanakan mekanisme ingatan dengan menggabungkan output titik masa semasa dengan output titik masa sebelumnya. Semasa proses latihan, RNN secara automatik belajar cara menyimpan maklumat sejarah dan menggunakannya untuk membimbing keputusan semasa.

2. Pelaksanaan Algoritma Rangkaian Neural Berulang dalam Python

Dalam Python, rangka kerja pembelajaran mendalam yang paling popular untuk melaksanakan algoritma RNN ialah TensorFlow. TensorFlow menyediakan pengguna dengan pelbagai model algoritma RNN, termasuk RNN ​​asas, LSTM (rangkaian memori jangka pendek panjang) dan GRU (unit berulang berpagar), dsb.

Seterusnya, mari lihat contoh rangkaian saraf berulang yang dilaksanakan berdasarkan TensorFlow.

Kami akan menggunakan tugas penjanaan teks untuk menunjukkan aplikasi rangkaian saraf berulang. Matlamat kami adalah untuk menjana teks baharu menggunakan teks latihan yang diketahui.

Pertama, kita perlu menyediakan data latihan. Dalam contoh ini, kami akan menggunakan Shakespeare's Hamlet sebagai teks latihan kami. Kita perlu mempraproses teks, menukar semua aksara kepada set aksara yang disingkatkan, dan menukarnya kepada nombor.

Seterusnya, kita perlu membina model rangkaian saraf berulang. Kami akan menggunakan model LSTM. Berikut ialah pelaksanaan kod:

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)

Dalam model ini, kami menggunakan rangkaian neural LSTM satu lapisan dan mentakrifkan lapisan tercicir untuk mengelakkan model daripada dipasang secara berlebihan. Lapisan keluaran menggunakan lapisan bersambung sepenuhnya dan menggunakan fungsi softmax untuk menormalkan teks yang dijana.

Sebelum melatih model, kita juga perlu melaksanakan beberapa fungsi tambahan. Sebagai contoh, fungsi untuk menjana urutan sampel rawak, dan fungsi untuk menukar nombor kembali kepada aksara. Berikut ialah pelaksanaan kod:

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]

Dengan fungsi tambahan ini, kita boleh mula melatih model. Semasa proses latihan, kami membahagikan data latihan kepada blok kecil mengikut saiz_kelompok dan panjang_seq, dan menghantarnya kepada model secara berkelompok untuk latihan. Berikut ialah pelaksanaan kod:

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. Kesimpulan

Dengan menggabungkan input semasa dan maklumat sebelumnya, rangkaian neural berulang boleh menjadi lebih tepat dan cekap dalam memproses data jujukan. Dalam Python, kita boleh menggunakan algoritma RNN yang disediakan dalam perpustakaan TensorFlow untuk melaksanakan algoritma rangkaian saraf berulang dengan mudah. Artikel ini menyediakan contoh pelaksanaan Python berdasarkan LSTM, yang boleh digunakan pada tugas penjanaan teks.

Atas ialah kandungan terperinci Contoh algoritma rangkaian saraf berulang dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!