Java 中的 XOR 神经网络答案

【问题标题】：XOR Neural Network in JavaJava 中的 XOR 神经网络
【发布时间】：2012-03-28 14:20:12
【问题描述】：

我正在尝试为 Java 中的 XOR 函数实现和训练一个带有反向传播的五神经元神经网络。我的代码（请原谅它的丑陋）：

public class XORBackProp {

private static final int MAX_EPOCHS = 500;

//weights
private static double w13, w23, w14, w24, w35, w45;
private static double theta3, theta4, theta5;
//neuron outputs
private static double gamma3, gamma4, gamma5;
//neuron error gradients
private static double delta3, delta4, delta5;
//weight corrections
private static double dw13, dw14, dw23, dw24, dw35, dw45, dt3, dt4, dt5;
//learning rate
private static double alpha = 0.1;
private static double error;
private static double sumSqrError;
private static int epochs = 0;
private static boolean loop = true;

private static double sigmoid(double exponent)
{
    return (1.0/(1 + Math.pow(Math.E, (-1) * exponent)));
}

private static void activateNeuron(int x1, int x2, int gd5)
{
    gamma3 = sigmoid(x1*w13 + x2*w23 - theta3);
    gamma4 = sigmoid(x1*w14 + x2*w24 - theta4);
    gamma5 = sigmoid(gamma3*w35 + gamma4*w45 - theta5);

    error = gd5 - gamma5;

    weightTraining(x1, x2);
}

private static void weightTraining(int x1, int x2)
{
    delta5 = gamma5 * (1 - gamma5) * error;
    dw35 = alpha * gamma3 * delta5;
    dw45 = alpha * gamma4 * delta5;
    dt5 = alpha * (-1) * delta5;

    delta3 = gamma3 * (1 - gamma3) * delta5 * w35;
    delta4 = gamma4 * (1 - gamma4) * delta5 * w45;

    dw13 = alpha * x1 * delta3;
    dw23 = alpha * x2 * delta3;
    dt3 = alpha * (-1) * delta3;
    dw14 = alpha * x1 * delta4;
    dw24 = alpha * x2 * delta4;
    dt4 = alpha * (-1) * delta4;

    w13 = w13 + dw13;
    w14 = w14 + dw14;
    w23 = w23 + dw23;
    w24 = w24 + dw24;
    w35 = w35 + dw35;
    w45 = w45 + dw45;
    theta3 = theta3 + dt3;
    theta4 = theta4 + dt4;
    theta5 = theta5 + dt5;
}

public static void main(String[] args)
{

    w13 = 0.5;
    w14 = 0.9;
    w23 = 0.4;
    w24 = 1.0;
    w35 = -1.2;
    w45 = 1.1;
    theta3 = 0.8;
    theta4 = -0.1;
    theta5 = 0.3;

    System.out.println("XOR Neural Network");

    while(loop)
    {
        activateNeuron(1,1,0);
        sumSqrError = error * error;
        activateNeuron(0,1,1);
        sumSqrError += error * error;
        activateNeuron(1,0,1);
        sumSqrError += error * error;
        activateNeuron(0,0,0);
        sumSqrError += error * error;

        epochs++;

        if(epochs >= MAX_EPOCHS)
        {
            System.out.println("Learning will take more than " + MAX_EPOCHS + " epochs, so program has terminated.");
            System.exit(0);
        }

        System.out.println(epochs + " " + sumSqrError);

        if (sumSqrError < 0.001)
        {
            loop = false;
        }
    }
}
}

如果有帮助，这里是diagram of the network。

所有权重和学习率的初始值直接取自我教科书中的一个示例。目标是训练网络，直到误差平方和小于 0.001。教科书还给出了第一次迭代（1,1,0）后所有权重的值，我测试了我的代码，其结果与教科书的结果完美匹配。但根据本书，这应该只需要 224 个 epoch 就可以收敛。但是当我运行它时，它总是达到 MAX_EPOCHS，除非它设置为几千。我做错了什么？

【问题讨论】：

在您的图表中，w14 箭头被错误标记为 w24。
我将学习率更改为 19.801（这通常太高了），并在 300 个 epoch 内达到了所需的误差。我认为他们采取了另一个学习率。但是你的代码也可能有错误。

标签： java neural-network xor

【解决方案1】：

尝试在实例的激活阶段对 gamma3、gamma4、gamma5 进行四舍五入：

if (gamma3 > 0.7) gamma3 = 1;
if (gamma3 < 0.3) gamma3 = 0;

并上升一点点学习变量（alpha）

alpha = 0.2;

学习在 466 个 epoch 中结束。

当然，如果你进行更大的舍入和更高的 alpha 设置，你可以获得比 224 更好的结果。

【讨论】：

【解决方案2】：

    //Add this in the constants declaration section.
    private static double alpha = 3.8, g34 = 0.13, g5 = 0.21;

    // Add this in activate neuron
    gamma3 = sigmoid(x1 * w13 + x2 * w23 - theta3);
    gamma4 = sigmoid(x1 * w14 + x2 * w24 - theta4);        
    if (gamma3 > 1 - g34 ) {gamma3 = 1;}
    if (gamma3 < g34) {gamma3 = 0;}
    if (gamma4 > 1- g34) {gamma4 = 1;}
    if (gamma4 < g34) {gamma4 = 0;}   
    gamma5 = sigmoid(gamma3 * w35 + gamma4 * w45 - theta5);
    if (gamma5 > 1 - g5) {gamma5 = 1;}
    if (gamma5 < g5) {gamma5 = 0;}

ANN 应该在 66 次迭代中学习，但处于分歧的边缘。

【讨论】：

【解决方案3】：

这个网络的重点是展示如何处理分组不是基于“top = yes, bottom = no”的情况，而是有一条中心线（通过点 (0,1)和 (1,0) 在这种情况下），如果值接近线，则答案为“是”，而如果距离很远，则答案为“否”。你不能只用一层来集群这样的系统。不过两层就够了。

【讨论】：