Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

写一个2-2-1全连接无偏置的神经网络代码,解决异或问题,且满足三个激活函数彼此不同

  1. User

    写一个2-2-1全连接无偏置的神经网络代码,解决异或问题,且满足三个激活函数彼此不同

  2. Assistant

    在这个示例中,我们将实现一个具有以下结构的全连接神经网络:

    • 输入层(2个神经元)
    • 隐藏层(2个神经元,使用ReLU激活)
    • 输出层(1个神经元,使用Sigmoid激活)

    注意:我们将使用numpy库来进行向量和矩阵运算。

    import numpy as np
    
    
    def relu(x):
        """ReLU激活函数"""
        return np.maximum(0, x)
    
    
    def d_relu(x):
        """ReLU激活函数的导数"""
        return (x > 0).astype(int)
    
    
    def sigmoid(x):
        """sigmoid激活函数"""
        return 1 / (1 + np.exp(-x))
    
    
    def d_sigmoid(x):
        """Sigmoid激活函数的导数"""
        return sigmoid(x) * (1 - sigmoid(x))
    
    
    # 数据集:异或问题
    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # Input data: XOR problem
    Y = np.array([[0], [1], [1], [0]])  # Output data: XOR problem
    
    # 网络结构参数
    input_size = 2
    hidden_size = 2
    output_size = 1
    
    # 初始化网络权重
    np.random.seed(42)  # 为了获得可重现的结果
    W1 = np.random.randn(input_size, hidden_size)
    W2 = np.random.randn(hidden_size, output_size)
    
    # 训练网络
    lr = 1  # 学习率
    epochs = 10000  # 训练迭代次数
    
    for epoch in range(epochs):
        # 前向传播
        H1 = np.dot(X, W1)  # 输入层到隐藏层
        H1_relu = relu(H1)  # 隐藏层ReLU激活
        H2 = np.dot(H1_relu, W2)  # 隐藏层到输出层
        Y_pred = sigmoid(H2)  # 输出层Sigmoid激活
    
        # 损失计算
        loss = 0.5 * np.sum((Y - Y_pred) ** 2)
    
        # 反向传播
        d_loss = Y_pred - Y
        d_H2 = d_loss * d_sigmoid(H2)
        d_W2 = np.dot(H1_relu.T, d_H2)
        d_H1 = np.dot(d_H2, W2.T) * d_relu(H1)
        d_W1 = np.dot(X.T, d_H1)
    
        # 权重更新
        W1 = W1 - lr * d_W1
        W2 = W2 - lr * d_W2
    
        # 每1000个epoch输出损失值
        if epoch % 1000 == 0:
            print(f"Epoch {epoch} loss: {loss:.4f}")
    
    # 测试网络
    H1 = np.dot(X, W1)
    H1_relu = relu(H1)
    H2 = np.dot(H1_relu, W2)
    Y_pred = sigmoid(H2)
    Y_pred_round = np.round(Y_pred)  # 四舍五入预测结果
    print("\nPredictions:")
    print(Y_pred_round)
    print("Accuracy: {:.2f}".format(np.mean(Y_pred_round == Y) * 100))
    

    这个代码实现了解决异或问题的2-2-1全连接神经网络,并且各层的激活函数不同(分别为ReLU和Sigmoid)。训练这个网络后,我们可以得到一个正确预测异或问题输出的神经网络。

  3. User

    以上代码有点问题,因为我们要求三个激活函数彼此都是不相同的,请再调整一下

  4. Assistant

    抱歉,我理解错了问题。让我们在输入层使用tanh激活函数 (双曲正切),隐藏层使用ReLU激活函数,输出层使用Sigmoid激活函数。

    import numpy as np
    
    
    def tanh(x):
        """tanh激活函数"""
        return np.tanh(x)
    
    
    def d_tanh(x):
        """tanh激活函数的导数"""
        return 1 - np.tanh(x) * np.tanh(x)
    
    
    def relu(x):
        """ReLU激活函数"""
        return np.maximum(0, x)
    
    
    def d_relu(x):
        """ReLU激活函数的导数"""
        return (x > 0).astype(int)
    
    
    def sigmoid(x):
        """sigmoid激活函数"""
        return 1 / (1 + np.exp(-x))
    
    
    def d_sigmoid(x):
        """Sigmoid激活函数的导数"""
        return sigmoid(x) * (1 - sigmoid(x))
    
    
    # 数据集:异或问题
    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # Input data: XOR problem
    Y = np.array([[0], [1], [1], [0]])  # Output data: XOR problem
    
    # 网络结构参数
    input_size = 2
    hidden_size = 2
    output_size = 1
    
    # 初始化网络权重
    np.random.seed(42)  # 为了获得可重现的结果
    W1 = np.random.randn(input_size, hidden_size)
    W2 = np.random.randn(hidden_size, output_size)
    
    # 训练网络
    lr = 1  # 学习率
    epochs = 10000  # 训练迭代次数
    
    for epoch in range(epochs):
        # 前向传播
        H0 = np.dot(X, W1)  # 输入层
        H0_tanh = tanh(H0)  # 输入层tanh激活
        H1 = np.dot(H0_tanh, W2)  # 隐藏层
        H1_relu = relu(H1)  # 隐藏层ReLU激活
        H2 = H1_relu  # 输出层
        Y_pred = sigmoid(H2)  # 输出层Sigmoid激活
    
        # 损失计算
        loss = 0.5 * np.sum((Y - Y_pred) ** 2)
    
        # 反向传播
        d_loss = Y_pred - Y
        d_H2 = d_loss * d_sigmoid(H2)
        d_H1_relu = d_H2
        d_H1 = d_H1_relu * d_relu(H1)
        d_W2 = np.dot(H0_tanh.T, d_H1)
        d_H0 = np.dot(d_H1, W2.T) * d_tanh(H0)
        d_W1 = np.dot(X.T, d_H0)
    
        # 权重更新
        W1 = W1 - lr * d_W1
        W2 = W2 - lr * d_W2
    
        # 每1000个epoch输出损失值
        if epoch % 1000 == 0:
            print(f"Epoch {epoch} loss: {loss:.4f}")
    
    # 测试网络
    H0 = np.dot(X, W1)
    H0_tanh = tanh(H0)
    H1 = np.dot(H0_tanh, W2)
    H1_relu = relu(H1)
    H2 = H1_relu
    Y_pred = sigmoid(H2)
    Y_pred_round = np.round(Y_pred)  # 四舍五入预测结果
    print("\nPredictions:")
    print(Y_pred_round)
    print("Accuracy: {:.2f}".format(np.mean(Y_pred_round == Y) * 100))
    

    现在,我们使用了3个互不相同的激活函数。输入层使用tanh激活函数, 隐藏层使用ReLU激活函数, 输出层使用Sigmoid激活函数。