Skip to main content
 首页 » 编程设计

python之为什么我的 ReLU 激活给出了错误的输出

2024年11月24日6luoye11

ReLU 函数,在这种情况下,我使用了 leaky ReLU 给我错误的输出。但是使用 sigmoid 函数它给了我一个可接受的输出

这是我的代码:

import numpy as np 
 
def relu(x): 
    return np.maximum(0.01 * x, x) 
 
 
def relu_derivative(x): 
    x[x>0] = 1 
    x[x<0] = 0.01 
    return x 
 
training_inputs = np.array([[1, 0],  
                            [1, 1],  
                            [0, 0],  
                            [0, 1]]) 
training_outputs = np.array([[1, 0, 0, 1]]).T 
 
weights = 2 * np.random.random((2, 1)) - 1 
 
print('Weights before training: ') 
print(weights) 
 
for epochs in range(10000): 
    outputs = relu(np.dot(training_inputs, weights)) 
 
    error = training_outputs - outputs 
 
    adjustment = error * relu_derivative(outputs) 
 
    weights += np.dot(training_inputs.T, adjustment) 
 
print('Neuron Weights after training: ') 
print(weights) 
 
print('Outputs after training: ') 
print(outputs) 

时代 = 10000

使用 ReLU 函数 训练后的

输出 = [0.01],[0.01],[0.01],[0.01],[0.01]

使用 sigmoid 函数 训练后的

输出 = [0.99],[0.01],[0.006],[0.99],[0.98]

sigmoid 函数给出的输出比 ReLU 的好,我用高达 100000 的 epoch 进行了测试,ReLU 函数的结果仍然相同。我的功能或代码有问题吗?

请您参考如下方法:

首先是您的 relu_derivative 函数中的一个小错误。您不应修改 x 值,而应创建一个新数组:

def relu_derivative(x): 
    y = np.zeros_like(x) 
    y[x>0] = 1 
    y[x<0] = 0.01 
    return y 

但它没有回答您的问题,因为它仍然没有正确学习如何解决 XOR。我认为 1 个隐藏单元不足以解决 relu 的这个问题。

我用 PyTorch 重写了同样的实验,代码如下:

import torch 
 
 
class Model(torch.nn.Module): 
    def __init__(self, *args, **kwargs): 
        super().__init__() 
        self.hidden = torch.nn.Linear(2, kwargs['h']) 
        self.relu = torch.nn.LeakyReLU(0.1) 
        self.out = torch.nn.Linear(kwargs['h'], 1) 
 
        with torch.no_grad(): 
            self.hidden.bias.zero_() 
            self.out.bias.zero_() 
 
    def forward(self, x): 
        z = self.hidden(x) 
        z = self.relu(z) 
        z = self.out(z) 
        return z 
 
 
if __name__ == '__main__': 
    training_inputs = torch.Tensor([[1., 0.], 
                                    [1., 1.], 
                                    [0., 0.], 
                                    [0., 1.]]) 
    training_outputs = torch.Tensor([1., 0., 0., 1.]).reshape(4, 1) 
 
    model = Model(h=2) 
    learning_rate = 0.01 
 
    criterion = torch.nn.MSELoss() 
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) 
    print(*[i for i in model.parameters()], sep='\n') 
    for _ in range(1000): 
        pred = model(training_inputs) 
        loss = criterion(pred, training_outputs) 
 
        optimizer.zero_grad() 
        loss.backward() 
        optimizer.step() 
 
    print(pred, loss) 
    print(*[i for i in model.parameters()], sep='\n') 

确实只有 1 个隐藏单元,看起来你无法解决 XOR,但是有 2 个隐藏单元,有时(取决于初始化)它可以工作。