用sigmoid算法实现前馈神经网络的代码

当使用sigmoid算法实现前馈神经网络时，需要进行以下几个步骤：

1. 初始化参数：初始化权重和偏置值，可以使用随机数或者其他方法进行初始化。

2. 前向传播：通过计算每一层的加权输入和激活函数的输出，将输入数据从输入层传递到输出层。

3. 计算损失：根据预测值和真实值之间的差异，计算损失函数的值。

4. 反向传播：根据损失函数的值，计算每一层的梯度，并更新参数。

5. 重复步骤2-4，直到达到预定的迭代次数或者损失函数收敛。

下面是一个简单的用sigmoid算法实现前馈神经网络的代码示例：

import numpy as np

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

# 初始化参数
def initialize_parameters(layer_dims):
    parameters = {}
    L = len(layer_dims)
    
    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
        
    return parameters

# 前向传播
def forward_propagation(X, parameters):
    caches = []
    A = X
    L = len(parameters) // 2
    
    for l in range(1, L):
        Z = np.dot(parameters['W' + str(l)], A) + parameters['b' + str(l)]
        A = sigmoid(Z)
        caches.append((Z, A))
    
    ZL = np.dot(parameters['W' + str(L)], A) + parameters['b' + str(L)]
    AL = sigmoid(ZL)
    caches.append((ZL, AL))
    
    return AL, caches

# 计算损失
def compute_cost(AL, Y):
    m = Y.shape
    cost = -np.sum(Y * np.log(AL) + (1 - Y) * np.log(1 - AL)) / m
    cost = np.squeeze(cost)
    
    return cost

# 反向传播
def backward_propagation(AL, Y, caches):
    grads = {}
    L = len(caches)
    m = AL.shape
    Y = Y.reshape(AL.shape)
    
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    
    dZL = dAL * sigmoid(caches[L-1]) * (1 - sigmoid(caches[L-1]))
    grads['dW' + str(L)] = np.dot(dZL, caches[L-1].T) / m
    grads['db' + str(L)] = np.sum(dZL, axis=1, keepdims=True) / m
    
    for l in reversed(range(L-1)):
        dA = np.dot(parameters['W' + str(l+2)].T, dZ)
        dZ = dA * sigmoid(caches[l]) * (1 - sigmoid(caches[l]))
        grads['dW' + str(l+1)] = np.dot(dZ, caches[l].T) / m
        grads['db' + str(l+1)] = np.sum(dZ, axis=1, keepdims=True) / m
    
    return grads

# 更新参数
def update_parameters(parameters, grads, learning_rate):
    L = len(parameters) // 2
    
    for l in range(L):
        parameters['W' + str(l+1)] -= learning_rate * grads['dW' + str(l+1)]
        parameters['b' + str(l+1)] -= learning_rate * grads['db' + str(l+1)]
    
    return parameters

# 定义前馈神经网络模型
def model(X, Y, layer_dims, learning_rate, num_iterations):
    parameters = initialize_parameters(layer_dims)
    
    for i in range(num_iterations):
        AL, caches = forward_propagation(X, parameters)
        cost = compute_cost(AL, Y)
        grads = backward_propagation(AL, Y, caches)
        parameters = update_parameters(parameters, grads, learning_rate)
        
        if i % 100 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
    
    return parameters

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

# 定义神经网络结构
layer_dims = [2, 4, 1]

# 训练模型
parameters = model(X, Y, layer_dims, learning_rate=0.01, num_iterations=1000)

这段代码实现了一个简单的前馈神经网络，其中使用了sigmoid函数作为激活函数。你可以根据自己的需求进行修改和扩展。希望对你有帮助！