使用动态权重解决XOR问题

最新推荐文章于 2023-04-23 10:07:38 发布

寒冰屋

最新推荐文章于 2023-04-23 10:07:38 发布

阅读量392

点赞数

分类专栏： ASP.NET CORE 人工智能 CSharp.NET 文章标签： cnn 人工智能神经网络

原文链接：https://www.codeproject.com/Tips/5322172/Solving-XOR-Problem-using-Dynamic-Weights

版权

CSharp.NET 同时被 3 个专栏收录

1245 篇文章 60 订阅

订阅专栏

ASP.NET CORE

1136 篇文章 56 订阅

订阅专栏

人工智能

564 篇文章 57 订阅

订阅专栏

本文探讨了如何使用动态权重的组合方法解决经典ANN问题——XOR函数，通过实例展示了训练过程和其在搜索问题中的通用性。先验条件定义了决策输出，通过随机权重初始化和强化学习训练，最后通过sigmoid激活函数得出答案。

摘要由CSDN通过智能技术生成

介绍

XOR或“异或”问题是ANN研究中的经典问题。

在给定两个二进制输入的情况下，使用神经网络预测XOR逻辑门的输出是一个问题。

如果两个输入不相等，XOR函数应该返回一个真值，如果它们相等则返回一个假值。

有许多不同的方法可以解决XOR问题。其中一些基于声明性方法，一些基于命令式方法，如神经网络等。

在本文中，我们将尝试使用一种组合方法来解决XOR问题。

这种方法也可以用来解决不同的搜索问题。

背景

为了使用这种方法，我们需要一些先决条件。

首先，我们需要为特定输入定义所需的输出，所以让我们为此定义一个数据结构。

var thought = new Thought
{
    Decisions = new List<Decision>
        {
            new Decision
            {
                Answer = "True",
                Id =1,
                Symbols = new List<Symbol>{new Symbol { Word = "1"}, 
                                           new Symbol { Word = "1" } }
            },
            new Decision
            {
                Answer = "False",
                Id = 2,
                Symbols = new List<Symbol>{new Symbol { Word = "1"}, 
                                           new Symbol { Word = "0" } }  
            },
            new Decision
            {
                Answer = "True",
                Id = 3,
                Symbols = new List<Symbol>{new Symbol { Word = "0"}, 
                                           new Symbol { Word = "0" } }
            },
            new Decision
            {
                Answer = "False",
                Id = 4,
                Symbols = new List<Symbol>{new Symbol { Word = "0"}, 
                                           new Symbol { Word = "1" } }
            }
        }
};

在这里，我们定义了一个思想类。此类表示具有决策列表的逻辑容器。

每个决定代表一个取决于输入的答案，这个想法应该产生一个有效的决定。

使用代码

在我们可以使用我们的思想之前，我们需要训练它的决定。

当思想产生时，决策中的所有权重都是随机分布的。

1、使用随机正态分布随机化权重：

thought.Decisions.ForEach(x => x.ResetWeights());

2、现在我们需要训练我们的思想：

thought.Reinforce(new[] { "0", "0" }, 3);
thought.Reinforce(new[] { "1", "0" }, 2);
thought.Reinforce(new[] { "0", "1" }, 4);
thought.Reinforce(new[] { "1", "1" }, 1);

在训练过程中，我们提供输入和所需的决策ID作为输出。

训练本身用循环和预定义的迭代次数表示。

迭代次数被定义为Decisions.Count * 1300;其中1300是启发式定义的常数。

在循环内部，我们尝试计算输出分数的差异并将其传播到目标决策。

使用以下公式计算目标决策的更新增量：

var updateDelta = MathUtils.Derivative(answer.Score) * 
                  targetDecision.Delta * targetAnswer.Score;

如果我们决定构建一个两层神经网络，这非常相似。

计算出delta后，我们将其应用于方法内的决策符号：

public void UpdateWeights()  {
    Bias += Delta;
    foreach (var symbol in Symbols) {
        symbol.Weight += Delta;
    }
}

训练完成后，我们可以向训练有素的思想询问答案：

要从思想中得到答案，首先我们需要找到输入符号和决策符号之间的匹配。

然后是一些权重并将其传递给一些激活函数（在我们的例子中，这是一个sigmoid函数）。

public double Stimulate(string[] words)  {
        var matchedSymbols = Symbols.Where(s => words.Contains(s.Word));
        var score = matchedSymbols.Sum(x => x.Weight) + Bias;
        return MathUtils.Sigmoid(score);
    }