如果要n个隐藏层呢

如果要 n 个隐藏层，我们可以对神经网络模型进行修改，使其具有 n 个隐藏层。以下是一个包含 n 个隐藏层的神经网络模型的代码示例：

import numpy as np

# 导入训练集和训练集对应的标签并将其初始化
X_train, T_train = idx2numpy.convert_from_file('emnist/emnist-letters-train-images-idx3-ubyte'), idx2numpy.convert_from_file('emnist/emnist-letters-train-labels-idx1-ubyte')
X_train, T_train = X_train.copy(), T_train.copy()
X_train = X_train.reshape((X_train.shape[0], -1))
T_train = T_train - 1
T_train = np.eye(26)[T_train]

# 导入测试集和测试集对应的标签标签并将其初始化
X_test, T_test = idx2numpy.convert_from_file('emnist/emnist-letters-test-images-idx3-ubyte'), idx2numpy.convert_from_file('emnist/emnist-letters-test-labels-idx1-ubyte')
X_test, T_test = X_test.copy(), T_test.copy()
X_test = X_test.reshape((X_test.shape[0], -1))
T_test = T_test - 1
T_test = np.eye(26)[T_test]

# 定义神经网络模型
class NeuralNetwork:
    def __init__(self, num_inputs, num_hidden, num_outputs, num_layers):
        # 初始化权重
        self.weights = []
        self.weights.append(np.random.randn(num_inputs, num_hidden))
        
        for i in range(num_layers - 1):
            self.weights.append(np.random.randn(num_hidden, num_hidden))
        
        self.weights.append(np.random.randn(num_hidden, num_outputs))

    def sigmoid(self, x):
        # sigmoid激活函数
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        # sigmoid函数的导数
        return x * (1 - x)

    def forward(self, X):
        # 前向传播
        self.hidden = []
        self.hidden.append(self.sigmoid(np.dot(X, self.weights[0])))
        
        for i in range(len(self.weights) - 2):
            self.hidden.append(self.sigmoid(np.dot(self.hidden[i], self.weights[i + 1])))
        
        self.output = self.sigmoid(np.dot(self.hidden[-1], self.weights[-1]))
        return self.output

    def backward(self, X, y, output):
        # 反向传播
        self.output_error = y - output
        self.output_delta = self.output_error * self.sigmoid_derivative(output)

        self.hidden_error = []
        self.hidden_delta = []
        self.hidden_error.append(self.output_delta.dot(self.weights[-1].T))
        self.hidden_delta.append(self.hidden_error[-1] * self.sigmoid_derivative(self.hidden[-1]))

        for i in range(len(self.weights) - 3, -1, -1):
            self.hidden_error.append(self.hidden_delta[-1].dot(self.weights[i + 1].T))
            self.hidden_delta.append(self.hidden_error[-1] * self.sigmoid_derivative(self.hidden[i]))

        self.hidden_delta.reverse()
        self.hidden.append(X)
        for i in range(len(self.weights)):
            self.weights[i] += self.hidden[i].T.dot(self.hidden_delta[i])

    def train(self, X, y):
        # 训练模型
        output = self.forward(X)
        self.backward(X, y, output)

    def predict(self, X):
        # 预测
        return np.argmax(self.forward(X), axis=1)

# 初始化神经网络
nn = NeuralNetwork(784, 50, 26, 3) # 3个隐藏层

# 训练神经网络
for i in range(1000):
    nn.train(X_train, T_train)

# 在测试集上进行预测
predictions = nn.predict(X_test)

# 计算准确率
accuracy = np.mean(predictions == np.argmax(T_test, axis=1))
print("Accuracy:", accuracy)

与之前的代码相比，主要的改变在于初始化权重和前向传播、反向传播的过程。在初始化权重时，我们需要为每一层都生成一个权重矩阵，然后将它们存储在一个列表中。在前向传播的过程中，我们需要对每一层都进行运算，并将中间结果存储在一个列表中以供后续使用。在反向传播的过程中，我们需要从输出层开始，逐层计算误差和梯度，并更新权重矩阵。