c - 神经网络只是有时有效-6ren

c - 神经网络只是有时有效

转载作者：行者123 更新时间：2023-12-04 15:24:45

所以我终于在 youtube channel “Coding Train”系列的帮助下第一次编写了一个神经网络(我一直想这样做)，“唯一”的区别是我编写了它用 C 而不是 JS。

我试着模拟了一个异或:结构是两个输入节点，两个隐藏节点，一个输出节点。训练后，我发现它不能正常工作。

已经看过这篇文章和其他几篇文章，但它们对我没有帮助:XOR Neural Network sometimes outputs 0.5

这是我的训练数据:

Training data:
IN | OUT
00 | 0
01 | 1
10 | 1
11 | 0

我对它进行了多次训练，每次训练超过 10000 次，学习率从 0.5 到 0.01 不等，并期望得到相应的结果。在下表中，我列出了最常见的输出，无论我选择什么学习范围，在不同的培训类(class)之后。

一次培训=多次培训

Actual output after training (OUTn is the nth training session):
IN | OUT1 | OUT2 | OUT3 | OUT4 | OUT5
00 | 0.01 | 0.01 | 0.01 | 0.66 | 0.01
01 | 0.99 | 0.99 | 0.50 | 0.66 | 0.66
10 | 0.99 | 0.50 | 0.99 | 0.66 | 0.66
11 | 0.01 | 0.50 | 0.50 | 0.66 | 0.66

大多数时候它会输出一些非常奇怪的东西。经过几个小时的错误搜索等，我仍然无法弄清楚错误在哪里。也许阅读本文的人会找到一个？

代码如下。

我通过一个结构定义了一个 GETRANDOM 和我的网络，这样我就可以轻松地传递、修改和返回它:

#define GETRANDOM   ( (double)rand() / RAND_MAX * 2.0 - 1.0 )   // random number between -1 and 1

// network structure
struct sNetwork {
    // node count
    int input_nodes;
    int hidden_nodes;
    int output_nodes;
    // values
    double* input_values;
    double* hidden_values;
    double* output_values;
    double* expected_values;
    // error
    double* hidden_error;
    double* output_error;
    // bias
    double* bias_h;
    double* bias_o;
    // weights
    double** weights_ih;
    double** weights_ho;
};
typedef struct sNetwork tNetwork;

为此我还写了一个设置函数:

tNetwork* setup_network(tNetwork* tNet)
{
    // general error check
    if(tNet == NULL)
    {
        return NULL;
    }
    if((*tNet).input_nodes == 0 || (*tNet).hidden_nodes == 0 || (*tNet).output_nodes == 0)
    {
        return NULL;
    }

    // based on the defined size, set up the weights

    // set up the input to hidden weights
    (*tNet).weights_ih = (double**)malloc((*tNet).input_nodes * sizeof(double*));
    for(int i = 0; i < (*tNet).input_nodes; i++)
    {
        (*tNet).weights_ih[i] = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            (*tNet).weights_ih[i][j] = GETRANDOM;
        }
    }

    // set up the hidden to output weights
    (*tNet).weights_ho = (double**)malloc((*tNet).hidden_nodes * sizeof(double*));
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).weights_ho[i] = (double*)malloc((*tNet).output_nodes * sizeof(double));
        for(int j = 0; j < (*tNet).output_nodes; j++)
        {
            (*tNet).weights_ho[i][j] = GETRANDOM;
        }
    }

    // set up the bias

    // set up hidden bias and value
    (*tNet).bias_h = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).bias_h[i] = GETRANDOM;
    }

    // set up the output bias and value

    (*tNet).bias_o = (double*)malloc((*tNet).output_nodes * sizeof(double));
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).bias_o[i] = GETRANDOM;
    }

    // set up the values
    (*tNet).hidden_values = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    (*tNet).output_values = (double*)malloc((*tNet).output_nodes * sizeof(double));
    (*tNet).input_values = (double*)malloc((*tNet).input_nodes * sizeof(double));
    (*tNet).expected_values = (double*)malloc((*tNet).output_nodes * sizeof(double));

    // set up the error stuff
    (*tNet).hidden_error = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    (*tNet).output_error = (double*)malloc((*tNet).output_nodes * sizeof(double));

    return tNet;
}

S 型函数:

double sigmoid(double x)
{
    return 1 / (1 + exp(-x));
}

double dsigmoid(double x)
{
    return x * (1 - (x));
}

然后我编写了前馈函数:

tNetwork* feed_forward(tNetwork* tNet)
{
    // calculate the hidden outputs
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).hidden_values[i] = (*tNet).bias_h[i];  // add bias to weighted sum

        for(int j = 0; j < (*tNet).input_nodes; j++)
        {
            (*tNet).hidden_values[i] += ( (*tNet).input_values[j] * (*tNet).weights_ih[j][i] ); // build the weighted sum
        }

        (*tNet).hidden_values[i] = sigmoid((*tNet).hidden_values[i]);
    }

    // calculate the output
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).output_values[i] = (*tNet).bias_o[i];  // add bias to weighted sum

        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            (*tNet).output_values[i] += ( (*tNet).hidden_values[j] * (*tNet).weights_ho[j][i] ); // build the weighted sum
        }
        (*tNet).output_values[i] = sigmoid((*tNet).output_values[i]);
    }

    return tNet;
}

之后的火车功能:

tNetwork* train(tNetwork* tNet, double learning_rate)
{
    // first of all feed the network
    tNet = feed_forward(tNet);

    // init the hidden errors
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).hidden_error[i] = 0;
    }

    // calculate the output error
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).output_error[i] = (*tNet).expected_values[i] - (*tNet).output_values[i];
    }

    // calculate the hidden error
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        for(int j = 0; j < (*tNet).output_nodes; j++)
        {
            (*tNet).hidden_error[i] += ( (*tNet).weights_ho[i][j] * (*tNet).output_error[j] );
        }
    }

    // adjust outputs
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        // adjust output bias
        double gradient = learning_rate * (*tNet).output_error[i] * dsigmoid((*tNet).output_values[i]);
        (*tNet).bias_o[i] += gradient;

        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            // adjust hidden->output weights
            (*tNet).weights_ho[j][i] += gradient * (*tNet).hidden_values[j];
        }
    }

    // adjust hiddens
    for(int j = 0; j < (*tNet).hidden_nodes; j++)
    {
        // adjust hidden bias
        double gradient = learning_rate * (*tNet).hidden_error[j] * dsigmoid((*tNet).hidden_values[j]);
        (*tNet).bias_h[j] += gradient;

        for(int k = 0; k < (*tNet).input_nodes; k++)
        {
            // adjust input->hidden weights
            (*tNet).weights_ih[k][j] += gradient * (*tNet).input_values[k];
        }
    }

    return tNet;
}

最后，在我的主要功能中我这样做了:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

int main(void)
{
    // initialize
    srand(time(NULL));

    // create neural network
    tNetwork* network = (tNetwork*)malloc(sizeof(tNetwork));

    // set up the properties of the network and initialize it
    network->input_nodes = 2;
    network->hidden_nodes = 2;
    network->output_nodes  = 1;
    network = setup_network(network);

    // train
    for(int i = 0; i < 50000; i++)
    {
        switch(rand() % 4)
        {
            case 0:
                // train #1
                network->input_values[0] = 0;
                network->input_values[1] = 0;
                network->expected_values[0] = 0;
                network = train(network, 0.1);
                break;
            case 1:
                // train #2
                network->input_values[0] = 1;
                network->input_values[1] = 0;
                network->expected_values[0] = 1;
                network = train(network, 0.1);
                break;
            case 2:
                // train #3
                network->input_values[0] = 0;
                network->input_values[1] = 1;
                network->expected_values[0] = 1;
                network = train(network, 0.1);
                break;
            case 3:
                // train #4
                network->input_values[0] = 1;
                network->input_values[1] = 1;
                network->expected_values[0] = 0;
                network = train(network, 0.1);
                break;
            default:
                break;
        }
    }

    // check the functionality

    network->input_values[0] = 0;
    network->input_values[1] = 0;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 0;
    network->input_values[1] = 1;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 1;
    network->input_values[1] = 0;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 1;
    network->input_values[1] = 1;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    return 0;
}

如果有人真的读到这里，我印象深刻，如果发现并解释了任何错误，我非常感谢，提前致谢!!

最佳答案

我认为您的代码非常好(我不擅长用 C 编程……我有 Java 背景)并且没有输出，因为需要进行一些手动调整。例如，我认为训练循环应该运行更长的时间，而不是在 4 个案例之间随机选择，而应该选择所有案例并对其进行训练(这是因为如果我们随机选择训练样本，一些案例可能会得到更多比其他导致网络学习不正确)。我调整了你的代码来解决这些问题(同时将学习率提高到 0.2)，我几乎总是能得到很好的分类。请尝试以下代码，

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define GETRANDOM   ( (double)rand() / RAND_MAX * 2.0 - 1.0 )   // random number between -1 and 1

// network structure
struct sNetwork {
    // node count
    int input_nodes;
    int hidden_nodes;
    int output_nodes;
    // values
    double* input_values;
    double* hidden_values;
    double* output_values;
    double* expected_values;
    // error
    double* hidden_error;
    double* output_error;
    // bias
    double* bias_h;
    double* bias_o;
    // weights
    double** weights_ih;
    double** weights_ho;
};
typedef struct sNetwork tNetwork;

tNetwork* setup_network(tNetwork* tNet)
{
    // general error check
    if(tNet == NULL)
    {
        return NULL;
    }
    if((*tNet).input_nodes == 0 || (*tNet).hidden_nodes == 0 || (*tNet).output_nodes == 0)
    {
        return NULL;
    }

    // based on the defined size, set up the weights

    // set up the input to hidden weights
    (*tNet).weights_ih = (double**)malloc((*tNet).input_nodes * sizeof(double*));
    for(int i = 0; i < (*tNet).input_nodes; i++)
    {
        (*tNet).weights_ih[i] = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            (*tNet).weights_ih[i][j] = GETRANDOM;
        }
    }

    // set up the hidden to output weights
    (*tNet).weights_ho = (double**)malloc((*tNet).hidden_nodes * sizeof(double*));
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).weights_ho[i] = (double*)malloc((*tNet).output_nodes * sizeof(double));
        for(int j = 0; j < (*tNet).output_nodes; j++)
        {
            (*tNet).weights_ho[i][j] = GETRANDOM;
        }
    }

    // set up the bias

    // set up hidden bias and value
    (*tNet).bias_h = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).bias_h[i] = GETRANDOM;
    }

    // set up the output bias and value

    (*tNet).bias_o = (double*)malloc((*tNet).output_nodes * sizeof(double));
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).bias_o[i] = GETRANDOM;
    }

    // set up the values
    (*tNet).hidden_values = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    (*tNet).output_values = (double*)malloc((*tNet).output_nodes * sizeof(double));
    (*tNet).input_values = (double*)malloc((*tNet).input_nodes * sizeof(double));
    (*tNet).expected_values = (double*)malloc((*tNet).output_nodes * sizeof(double));

    // set up the error stuff
    (*tNet).hidden_error = (double*)malloc((*tNet).hidden_nodes * sizeof(double));
    (*tNet).output_error = (double*)malloc((*tNet).output_nodes * sizeof(double));

    return tNet;
}

double sigmoid(double x)
{
    return 1 / (1 + exp(-x));
}

double dsigmoid(double x)
{
    return x * (1 - (x));
}

tNetwork* feed_forward(tNetwork* tNet)
{
    // calculate the hidden outputs
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).hidden_values[i] = (*tNet).bias_h[i];  // add bias to weighted sum

        for(int j = 0; j < (*tNet).input_nodes; j++)
        {
            (*tNet).hidden_values[i] += ( (*tNet).input_values[j] * (*tNet).weights_ih[j][i] ); // build the weighted sum
        }

        (*tNet).hidden_values[i] = sigmoid((*tNet).hidden_values[i]);
    }

    // calculate the output
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).output_values[i] = (*tNet).bias_o[i];  // add bias to weighted sum

        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            (*tNet).output_values[i] += ( (*tNet).hidden_values[j] * (*tNet).weights_ho[j][i] ); // build the weighted sum
        }
        (*tNet).output_values[i] = sigmoid((*tNet).output_values[i]);
    }

    return tNet;
}

tNetwork* train(tNetwork* tNet, double learning_rate)
{
    // first of all feed the network
    tNet = feed_forward(tNet);

    // init the hidden errors
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        (*tNet).hidden_error[i] = 0;
    }

    // calculate the output error
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        (*tNet).output_error[i] = ((*tNet).expected_values[i] - (*tNet).output_values[i]);
    }

    // calculate the hidden error
    for(int i = 0; i < (*tNet).hidden_nodes; i++)
    {
        for(int j = 0; j < (*tNet).output_nodes; j++)
        {
            (*tNet).hidden_error[i] += ( (*tNet).weights_ho[i][j] * (*tNet).output_error[j] );
        }
    }

    // adjust outputs
    for(int i = 0; i < (*tNet).output_nodes; i++)
    {
        // adjust output bias
        double gradient = learning_rate * (*tNet).output_error[i] * dsigmoid((*tNet).output_values[i]);
        (*tNet).bias_o[i] += gradient;

        for(int j = 0; j < (*tNet).hidden_nodes; j++)
        {
            // adjust hidden->output weights
            (*tNet).weights_ho[j][i] += gradient * (*tNet).hidden_values[j];
        }
    }

    // adjust hiddens
    for(int j = 0; j < (*tNet).hidden_nodes; j++)
    {
        // adjust hidden bias
        double gradient = learning_rate * (*tNet).hidden_error[j] * dsigmoid((*tNet).hidden_values[j]);
        (*tNet).bias_h[j] += gradient;

        for(int k = 0; k < (*tNet).input_nodes; k++)
        {
            // adjust input->hidden weights
            (*tNet).weights_ih[k][j] += gradient * (*tNet).input_values[k];
        }
    }

    return tNet;
}

int main(void)
{
    // initialize
    srand(time(NULL));

    // create neural network
    tNetwork* network = (tNetwork*)malloc(sizeof(tNetwork));

    // set up the properties of the network and initialize it
    network->input_nodes = 2;
    network->hidden_nodes = 2;
    network->output_nodes  = 1;
    network = setup_network(network);

    // train
    for(int i = 0; i < 10000; i++)
    {
        double learnRate = 0.2;
        network->input_values[0] = 0;
        network->input_values[1] = 0;
        network->expected_values[0] = 0;
        network = train(network, learnRate);
        
        network->input_values[0] = 1;
        network->input_values[1] = 0;
        network->expected_values[0] = 1;
        network = train(network, learnRate);
        
        network->input_values[0] = 0;
        network->input_values[1] = 1;
        network->expected_values[0] = 1;
        network = train(network, learnRate);
        
        network->input_values[0] = 1;
        network->input_values[1] = 1;
        network->expected_values[0] = 0;
        network = train(network, learnRate);
    }

    // check the functionality

    network->input_values[0] = 0;
    network->input_values[1] = 0;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 0;
    network->input_values[1] = 1;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 1;
    network->input_values[1] = 0;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    network->input_values[0] = 1;
    network->input_values[1] = 1;
    network = feed_forward(network);
    printf("%f\n", network->output_values[0]);

    return 0;
}

第一次运行:

第二次运行:

第三次运行:(有时网络不学习，但我想这没关系，因为不能保证神经网络总能学到所有东西)

为了增加我们的网络更好地学习的机会，我们可以增加隐藏层的大小(例如，从 2 到 10)并运行循环训练 100000 次。那样的话分类效果会更好，

第一次运行:

第二次运行:

第三次运行:

关于c - 神经网络只是有时有效，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/62506755/

文章推荐： python - pandas-datareader 世界银行 API 损坏

文章推荐： cas - 用于测试客户端代码的公共(public) CAS 服务器

文章推荐： python - Matplotlib - 在边缘一致地显示或隐藏网格线

文章推荐： r - 如何更改图例符号(关键字形)以匹配绘图符号？

javascript - .on ('click' ) 有效， .css ('display' ,'block' ) 有效，但不在一起
我遇到了一个奇怪的问题。我有这个: $(document).ready(function () {
Java URL java.net.ConnectException 错误(Ping 有效，其他 URL 有效)
我正在编写一个程序，它从列表中读取一些 ID，从中找出不同的 URL，然后将图像保存到我的 C: 驱动器中。如果我在浏览器中导航到图像 URL，它们就会起作用。此外，如果我尝试从不同的服务器获取图像
java - 奇怪的 httpPost 行为(可能与 json、auth、代理相关)GET 有效，POST 有效，但没有代理就不行(部分解决)
我编写了一个 REST WCF RIA Silverlight 4.0 兼容服务，我可以从 javascript + jQuery.1.4.2.js + JSON2.js(当然，还可以从 .NET 4
有效 32 位有符号整数的正则表达式
我很确定这个网站实际上还没有得到回答。一劳永逸地，与 32 位有符号整数范围内的数字字符串匹配的最小正则表达式是什么，范围是 -2147483648至 2147483647 . 我必须使用正则表达式进
r - (有效)合并随机键控子集
我有两个data.table；我想从那些与键匹配的元素中随机分配一个元素。我现在这样做的方式相当慢。让我们具体点；这是一些示例数据: dt1<-data.table(id=sample(letter
celery 有效，但与花无效
我已经安装了 celery 、RabitMQ 和花。我可以浏览到花港。我有以下简单的工作人员，我可以将其附加到 celery 并从 python 程序调用: # -*- coding: utf-8 -
ScalaCheck 有效/无效的测试边界
我正在使用 ScalaCheck 在 ScalaTest 中进行一些基于属性的测试。假设我想测试一个函数，f(x: Double): Double仅针对 x >= 0.0 定义的, 并返回 NaN对于
delphi - 有效 IMAGE_DOS_SIGNATURE
我想检查文件是否具有有效的 IMAGE_DOS_SIGNATURE (MZ) function isMZ(FileName : String) : boolean; var Signature: W
java - 为什么通过引用比较整数 (==) 有效？
在 Herbert Schildt 的“Java:完整引用，第 9 版”中，有一个让我有点困惑的例子。它的关键点我无法理解可以概括为以下代码: class Test { public stat
php - 为什么 for(;;) 有效？
我在工作中查看了一些代码，发现了一些我以前没有遇到过的东西: for (; ;) { // Some code here break; } 我们一直调用包含这个的函数，我最近才进去看看它是
java - 为什么通过引用比较整数 (==) 有效？
在 Herbert Schildt 的“Java:完整引用，第 9 版”中，有一个让我有点困惑的例子。它的关键点我无法理解可以概括为以下代码: class Test { public stat
python - 在矩阵的一维中进行洗牌(有效)？
我试图编写一个函数，获取 2D 点矩阵和概率 p 并以概率 p 更改或交换每个点坐标所以我问了一个question我试图使用二进制序列作为特定矩阵 swap_matrix=[[0,1],[1,0]]
c# - 为什么这个无效的文件路径//有效？
这个问题在这里已经有了答案: Using / or \\ for folder paths in C# (5 个答案) 关闭 7 年前。我在某个Class1中有这个功能: public v
postgresql - 删除重复记录(有效)
PostgreSQL 10.4 我有一张 table : Column | Type ------------------------- id | integer| title
sql - 有效/简单地计算同一数据集的不同范围
我正在 Postgresql 中编写一个函数，它将返回一些针对特定时区(输入)计算的指标。示例结果: 主要问题是这只是一个指标。我需要从其他表中获取其他 9 个指标。对于实现此目标的更简洁的方法有
python - 模拟从袋子中取出弹珠而不更换(有效)
我需要在 python 中模拟超几何分布(用于不替换采样元素的花哨词)。设置:有一个装满人口许多弹珠的袋子。弹珠有两种类型，红色和绿色(在以下实现中，弹珠表示为 True 和 False)。从袋子中
css - 有效/无效类未添加到预填充文本字段
我正在使用 MaterializeCSS 框架并动态填充文本输入。我遇到的一个问题是，在我关注该字段之前，valid 和 invalid css 类不会添加到我的字段中。即使我调用 M.update
CSS - 重叠 - 有效
是否有重叠 2 个 div 的有效方法。我有以下内容，但无法让它们重叠。 #top-border{width:100%; height:60px; background:url(image.jpg)
c++ - 为什么需要重新定义固定大小的静态数组/有效？
我希望你们中的一位能向我解释为什么编译器要求我在编译单元中重新定义一个静态固定长度数组，尽管我已经在头文件中这样做了。这是一个例子: 我的类.h: #ifndef MYCLASS_H #define
Python 分布式计算(有效)
我正在使用旧线程发布试图解决相同问题的新代码。什么是安全 pickle ？ this? socks .py from socket import socket from socket import A

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 神经网络只是有时有效