python实现RNN神经网络

以下是一个简单的Python代码示例，用于实现基本的循环神经网络(RNN)：

import numpy as np

# 定义sigmoid函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义RNN类
class RNN:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重矩阵
        self.Wxh = np.random.randn(hidden_size, input_size) * 0.01
        self.Whh = np.random.randn(hidden_size, hidden_size) * 0.01
        self.Why = np.random.randn(output_size, hidden_size) * 0.01
        # 初始化偏置向量
        self.bh = np.zeros((hidden_size, 1))
        self.by = np.zeros((output_size, 1))

    def forward(self, x):
        # 初始化隐藏状态和输出
        h = np.zeros((self.Whh.shape[0], 1))
        y = np.zeros((self.Why.shape[0], 1))
        # 循环计算
        for i in range(len(x)):
            # 更新隐藏状态
            h = sigmoid(np.dot(self.Wxh, x[i]) + np.dot(self.Whh, h) + self.bh)
            # 更新输出
            y = np.dot(self.Why, h) + self.by
        return y

# 测试
x = [np.array([[0], [1]]), np.array([[1], [0]]), np.array([[1], [1]]), np.array([[0], [0]])]
y = [np.array([[1]]), np.array([[1]]), np.array([[0]]), np.array([[0]])]
model = RNN(2, 16, 1)
for i in range(1000):
    for j in range(len(x)):
        y_pred = model.forward(x[j])
        loss = np.sum((y_pred - y[j])**2)
        # 反向传播
        dL_dy = 2 * (y_pred - y[j])
        dWhy = np.dot(dL_dy, model.h.T)
        dL_dh = np.dot(model.Why.T, dL_dy) + model.dh_next
        dh_raw = model.h * (1 - model.h)
        dh = dL_dh * dh_raw
        dbh = dh
        dWxh = np.dot(dh, x[j].T)
        dWhh = np.dot(dh, model.h.T)
        # 更新参数
        model.Wxh -= 0.1 * dWxh
        model.Whh -= 0.1 * dWhh
        model.Why -= 0.1 * dWhy
        model.bh -= 0.1 * dbh
        model.by -= 0.1 * dL_dy
        model.dh_next = np.dot(model.Whh.T, dh)
    if i % 100 == 0:
        print("Epoch: {}, Loss: {}".format(i, loss))

这个代码示例实现了一个简单的RNN，用于二进制加法。它有2个输入神经元，16个隐藏神经元和1个输出神经元。它使用sigmoid作为激活函数，并使用反向传播算法进行训练。在训练过程中，它将输入序列通过RNN，计算输出并计算损失。然后，它使用反向传播算法计算梯度，并使用梯度下降算法更新权重矩阵和偏置向量。在每个epoch结束时，它会打印出损失值。