Numpy 实现全连接神经网络

NumPy是一个用于科学计算的Python库，它提供了高性能的多维数组对象和用于处理这些数组的工具。要实现全连接神经网络，可以使用NumPy来进行矩阵运算和数值计算。

以下是使用NumPy实现全连接神经网络的一般步骤：

1. 导入NumPy库：

   import numpy as np

2. 定义神经网络的结构：
- 确定输入层的大小（特征数量）和输出层的大小（类别数量）。
- 决定隐藏层的数量和每个隐藏层的神经元数量。

3. 初始化权重和偏置：
- 使用随机数初始化权重矩阵和偏置向量。

4. 定义激活函数：
- 选择适当的激活函数，如Sigmoid、ReLU等。

5. 实现前向传播：
- 根据权重、偏置和激活函数计算每一层的输出。

6. 实现损失函数：
- 选择适当的损失函数，如交叉熵损失函数。

7. 实现反向传播：
- 根据损失函数计算每一层的梯度。
- 使用梯度下降法更新权重和偏置。

8. 训练模型：
- 使用训练数据进行多次迭代，不断更新权重和偏置。

9. 预测：
- 使用训练好的模型对新的数据进行预测。

相关问题

利用numpy搭建全连接神经网络，使用numpy 实现需要自己手动求导。（要求：程序代码写详细注释）

在Python中，我们可以利用NumPy库来构建简单的全连接神经网络，并手动实现梯度计算。首先，我们需要导入必要的库并创建一些函数来初始化权重、前向传播和反向传播。以下是详细的代码示例：

import numpy as np

# 初始化随机权重函数
def init_weights(input_nodes, hidden_nodes, output_nodes):
    """
    初始化全连接层的权重矩阵，采用均匀分布随机值
    """
    w1 = np.random.rand(hidden_nodes, input_nodes) * 0.01  # 隐藏层到输入层
    b1 = np.zeros((hidden_nodes, 1))  # 隐藏层偏置
    w2 = np.random.rand(output_nodes, hidden_nodes) * 0.01  # 输出层到隐藏层
    b2 = np.zeros((output_nodes, 1))  # 输出层偏置
    return w1, b1, w2, b2

# 前向传播函数，计算激活值
def forward_pass(x, weights, biases):
    z1 = np.dot(weights[0], x) + biases[0]  # 隐藏层输入
    a1 = np.tanh(z1)  # 使用tanh作为激活函数
    z2 = np.dot(weights[1], a1) + biases[1]  # 输出层输入
    yhat = sigmoid(z2)  # 使用sigmoid作为输出层激活函数
    return yhat

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

# 手动求梯度的反向传播函数
def backward_pass(y, yhat, weights, biases, x):
    m = x.shape[1]  # 总样本数

    # 求损失函数的导数
    dz2 = yhat - y
    dw2 = np.dot(dz2, a1.T) / m  # dL/dw2
    db2 = np.sum(dz2, axis=1, keepdims=True) / m  # dL/db2

    # 激活函数导数
    da1 = dz2 * sigmoid_derivative(z2)

    # 求dL/dw1和dL/db1
    dz1 = np.dot(weights[1].T, da1)
    dw1 = np.dot(da1, x.T) / m  # dL/dw1
    db1 = np.sum(dz1, axis=1, keepdims=True) / m  # dL/db1

    # 另一个激活函数的导数
    sigmoid_derivative = lambda z: sigmoid(z) * (1 - sigmoid(z))

    return dw1, db1, dw2, db2

# 训练过程
def train_neural_network(x, y, epochs, learning_rate, hidden_nodes):
    weights = init_weights(x.shape[1], hidden_nodes, 1)  # 初始化权重
    for e in range(epochs):
        yhat = forward_pass(x, *weights)  # 前向传播
        dw1, db1, dw2, db2 = backward_pass(y, yhat, *weights, x)  # 反向传播
        weights[0] -= learning_rate * dw1  # 更新权重
        weights[1] -= learning_rate * dw2
        biases[0] -= learning_rate * db1
        biases[1] -= learning_rate * db2

    return weights

# 示例数据
x_train = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_train = np.array([[0], [1], [1], [0]])

# 训练并输出结果
weights = train_neural_network(x_train, y_train, epochs=5000, learning_rate=0.5, hidden_nodes=4)
print("Weights after training:")
print(weights)

用numpy搭建三层全连接神经网络

好的,我很乐意为您介绍如何使用numpy搭建三层全连接神经网络。以下是具体步骤:

1. 导入必要的库:

import numpy as np

2. 定义激活函数及其导数:

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

3. 初始化网络参数:

input_layer_size = 3  # 输入层神经元数量
hidden_layer_size = 5  # 隐藏层神经元数量
output_layer_size = 1  # 输出层神经元数量

np.random.seed(42)
W1 = np.random.randn(input_layer_size, hidden_layer_size)
b1 = np.zeros((1, hidden_layer_size))
W2 = np.random.randn(hidden_layer_size, output_layer_size)
b2 = np.zeros((1, output_layer_size))

4. 定义前向传播:

def forward_propagation(X):
    Z1 = np.dot(X, W1) + b1
    A1 = sigmoid(Z1)
    Z2 = np.dot(A1, W2) + b2
    A2 = sigmoid(Z2)
    cache = (Z1, A1, Z2, A2)
    return A2, cache

5. 定义损失函数:

def compute_loss(Y_hat, Y):
    m = Y.shape[0]
    logprobs = np.multiply(np.log(Y_hat), Y) + np.multiply((1 - Y), np.log(1 - Y_hat))
    loss = -np.sum(logprobs) / m
    return loss

6. 定义反向传播:

def backward_propagation(X, Y, cache):
    m = X.shape[0]
    Z1, A1, Z2, A2 = cache
    dZ2 = A2 - Y
    dW2 = np.dot(A1.T, dZ2) / m
    db2 = np.sum(dZ2, axis=0, keepdims=True) / m
    dA1 = np.dot(dZ2, W2.T)
    dZ1 = dA1 * sigmoid_derivative(Z1)
    dW1 = np.dot(X.T, dZ1) / m
    db1 = np.sum(dZ1, axis=0, keepdims=True) / m
    grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2}
    return grads

7. 定义更新参数函数:

def update_parameters(grads, learning_rate):
    W1 -= learning_rate * grads["dW1"]
    b1 -= learning_rate * grads["db1"]
    W2 -= learning_rate * grads["dW2"]
    b2 -= learning_rate * grads["db2"]

8. 训练模型:

def train(X, Y, iterations=10000, learning_rate=0.01):
    for i in range(iterations):
        Y_hat, cache = forward_propagation(X)
        loss = compute_loss(Y_hat, Y)
        grads = backward_propagation(X, Y, cache)
        update_parameters(grads, learning_rate)
        
        if i % 1000 == 0:
            print(f"Iteration {i}, Loss: {loss:.4f}")

9. 使用模型进行预测:

def predict(X):
    Y_hat, _ = forward_propagation(X)
    return Y_hat > 0.5

通过以上步骤,我们就使用numpy搭建了一个简单的三层全连接神经网络。这个网络包含一个输入层,一个隐藏层和一个输出层。