`
gallon00
  • 浏览: 31409 次
  • 性别: Icon_minigender_1
  • 来自: 运城
文章分类
社区版块
存档分类
最新评论

[抄]人工神经网络之反向传播算法

 
阅读更多
都说《机器学习》是学计算机的人必须要看的一本书,确实不是浪得虚名。看了一章人工神经网络(ANN)中关于反向传播算法的内容,相比单个感知器而言,采用多层网络的反向传播算法能表示出更多种类的非线性曲面,下面总结下它基本的处理框架。
ANN核心数据结构:


typedef struct 
{
    int input_n;                  /* number of input units */
    int hidden_n;                 /* number of hidden units */
    int output_n;                 /* number of output units */
    double *input_units;          /* the input units */
    double *hidden_units;         /* the hidden units */
    double *output_units;         /* the output units */
    double *hidden_delta;         /* storage for hidden unit error */
    double *output_delta;         /* storage for output unit error */
    double *target;               /* storage for target vector */
    double **input_weights;       /* weights from input to hidden layer */
    double **hidden_weights;      /* weights from hidden to output layer */
    /*** The next two are for momentum ***/
    double **input_prev_weights;  /* previous change on input to hidden wgt */
    double **hidden_prev_weights; /* previous change on hidden to output wgt */
} BPNN;
整个神经网络可以分成三层:输入层,隐藏层,输出层,通过加权线性变换,层与层之间的传递,最终得到输入层的实数值。
BPNN *bpnn_internal_create(int n_in, int n_hidden,int n_out;)
{//创建人工网络,参数分别指定输入层,隐藏层和输出层大小
    BPNN *newnet;
    newnet = (BPNN *) malloc (sizeof (BPNN));
    if (newnet == NULL)
    {
        printf("BPNN_CREATE: Couldn't allocate neural network/n");
        return (NULL);
    }
    newnet->input_n = n_in;//输入层
    newnet->hidden_n = n_hidden;//隐藏层
    newnet->output_n = n_out;//输出层
    newnet->input_units = alloc_1d_dbl(n_in + 1);
    newnet->hidden_units = alloc_1d_dbl(n_hidden + 1);
    newnet->output_units = alloc_1d_dbl(n_out + 1);
    newnet->hidden_delta = alloc_1d_dbl(n_hidden + 1);
    newnet->output_delta = alloc_1d_dbl(n_out + 1);
    newnet->target = alloc_1d_dbl(n_out + 1);//目标向量
    newnet->input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);//输入层到隐藏层的权值
    newnet->hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);//隐藏层到输出层的权值
    newnet->input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
    newnet->hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
    return (newnet);
}
下面代码段是ANN运行的核心部分:


if (train_n > 0)
{//提供了训练集
    printf("Creating new network '%s'/n", netname);
    iimg = trainlist->list[0];//指向训练集第一张图片
    imgsize = ROWS(iimg) * COLS(iimg);
    /* bthom ===========================
    make a net with:
    imgsize inputs, 4 hiden units, and 1 output unit
    */
    //输入层为图片大小,隐藏层为,输出层为
    net = bpnn_create(imgsize, 4, 1);
}

// 训练
/************** Train it *****************************/
for (epoch = 1; epoch <= epochs; epoch++) 
{
    printf("%d ", epoch);  fflush(stdout);
    sumerr = 0.0;
    for (i = 0; i < train_n; i++) 
    {
        /** Set up input units on net with image i **/
        //为图像i在网络上建立输入单元
        load_input_with_image(trainlist->list[i], net);
        /** Set up target vector for image i **/
        //为图像i建立目标向量
        load_target(trainlist->list[i], net);
        /** Run backprop, learning rate 0.3, momentum 0.3 **/
        //学习速率.3,冲量.3
        bpnn_train(net, 0.3, 0.3, &out_err, &hid_err);
        sumerr += (out_err + hid_err);
    }
    进行性能评估:
        for (i = 0; i < n; i++) 
        {
            /*** Load the image into the input layer. **/
            load_input_with_image(il->list[i], net);//加载图片到输入层中
            /*** Run the net on this input. **/
            bpnn_feedforward(net);//在当前输入上运行神经网络
            /*** Set up the target vector for this image. **/
            load_target(il->list[i], net);//为此图片建立目标向量
            /*** See if it got it right. ***/
            if (evaluate_performance(net, &val, 0)) 
            {//判断是否正确识别,
                correct++;
            }
            else if (list_errors) 
            {
                printf("%s - outputs ", NAME(il->list[i]));
                for (j = 1; j <= net->output_n; j++) 
                {
                    printf("%.3f ", net->output_units[j]);
                }
                putchar('/n');
            }
            err += val;
        }
        err = err / (double) n;
        if (!list_errors)
            /* bthom==================================
            this line prints part of the ouput line
            discussed in section 3.1.2 of homework
            */
            printf("%g %g ", ((double) correct / (double) n) * 100.0, err);

用到的性能评估函数:
evaluate_performance(BPNN *net, double *err)
{//性能评估
      double delta;
      delta = net->target[1] - net->output_units[1];
      *err = (0.5 * delta * delta);
      /*** If the target unit is on... ***/
      if (net->target[1] > 0.5) 
      {
           /*** If the output unit is on, then we correctly recognized me! ***/
           if (net->output_units[1] > 0.5) 
           {
                 return (1);
           }
           else
           {
                 return (0);
           }
           /*** Else, the target unit is off... ***/
      }
      else 
      {
           /*** If the output unit is on, then we mistakenly thought it was me ***/
           if (net->output_units[1] > 0.5) 
           {
                 return (0);
                 /*** else, we correctly realized that it wasn't me ***/
           }
           else 
           {
                 return (1);
           }
      }
}
辅助处理函数区:
load_input_with_image(IMAGE *img, BPNN *net)
{//输入图像
    double *units;
    int nr, nc, imgsize, i, j, k;

    nr = ROWS(img);// 行大小
    nc = COLS(img);//列大小
    imgsize = nr * nc;;
    if (imgsize != net->input_n) 
    {//确保输入单元数目设置为图片大小
        printf("LOAD_INPUT_WITH_IMAGE: This image has %d pixels,/n", imgsize);
        printf("   but your net has %d input units.  I give up./n", net->input_n);
        exit (-1);
    }
    //取图片的每个像素为输入单元
    units = net->input_units;
    k = 1;
    for (i = 0; i < nr; i++) 
    {
        for (j = 0; j < nc; j++)
        {
            units[k] = ((double) img_getpixel(img, i, j)) / 255.0;
            k++;
        }
    }
}

load_target(IMAGE *img, BPNN *net)
{//加载目标值
    int scale;
    char userid[40], head[40], expression[40], eyes[40], photo[40];
    userid[0] = head[0] = expression[0] = eyes[0] = photo[0] = '/0';
    /*** scan in the image features ***/
    sscanf(NAME(img), "%[^_]_%[^_]_%[^_]_%[^_]_%d.%[^_]",
    userid, head, expression, eyes, &scale, photo);
    if (!strcmp(userid, "glickman")) 
    {
        net->target[1] = TARGET_HIGH;  /* it's me, set target to HIGH */
    } 
    else 
    {
        net->target[1] = TARGET_LOW;   /* not me, set it to LOW */
    }
}

void bpnn_train(BPNN *net, double eta, momentum *eo, momentum *eh)
{//人工神经网络训练
    int in, hid, out;
    double out_err, hid_err;
    in = net->input_n;
    hid = net->hidden_n;
    out = net->output_n;
    /*** Feed forward input activations. ***/
    bpnn_layerforward(net->input_units, net->hidden_units,
    net->input_weights, in, hid);
    bpnn_layerforward(net->hidden_units, net->output_units,
    net->hidden_weights, hid, out);
    /*** Compute error on output and hidden units. ***/
    bpnn_output_error(net->output_delta, net->target, net->output_units,out, &out_err);
    bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out,net->hidden_weights, net->hidden_units, &hid_err);
    *eo = out_err;
    *eh = hid_err;
    /*** Adjust input and hidden weights. ***/
    bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid,net->hidden_weights, net->hidden_prev_weights, eta, momentum);
    bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in,net->input_weights, net->input_prev_weights, eta, momentum);
}

void bpnn_feedforward(BPNN *net)
{//前向反馈
    int in, hid, out;
    in = net->input_n;//输入层大小
    hid = net->hidden_n;//隐藏层大小
    out = net->output_n;//输出层大小
    /*** Feed forward input activations. ***/
    bpnn_layerforward(net->input_units, net->hidden_units,net->input_weights, in, hid);
    bpnn_layerforward(net->hidden_units, net->output_units,net->hidden_weights, hid, out);
}

void bpnn_adjust_weights(double *delta, double *ly,double **w, double **oldw, double eta, double momentum)
{//调整权值
    double new_dw;
    int k, j;
    ly[0] = 1.0;
    for (j = 1; j <= ndelta; j++) 
    {
        for (k = 0; k <= nly; k++) 
        {
            new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
            w[k][j] += new_dw;
            oldw[k][j] = new_dw;
        }
    }
}
void bpnn_layerforward(double *l1, double *l2, double **conn,int n1,int n2)
{//层次前向输入
    double sum;
    int j, k;
    /*** Set up thresholding unit ***/
    l1[0] = 1.0;
    //加权线性变换
    /*** For each unit in second layer ***/
    for (j = 1; j <= n2; j++) 
    {
        /*** Compute weighted sum of its inputs ***/
        sum = 0.0;
        for (k = 0; k <= n1; k++)
        {
            sum += conn[k][j] * l1[k];
        }
        l2[j] = squash(sum);
    }
}
分享到:
评论

相关推荐

    纯numpy实现的人工神经网络及反向传播算法.zip

    纯numpy实现的人工神经网络及反向传播算法 纯numpy实现的人工神经网络及反向传播算法 纯numpy实现的人工神经网络及反向传播算法 纯numpy实现的人工神经网络及反向传播算法 纯numpy实现的人工神经网络及反向传播算法 ...

    基于纯numpy实现的人工神经网络及反向传播算法源码+项目说明.zip

    【资源说明】 1、该资源包括项目的全部源码,下载可以直接使用! 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目,...基于纯numpy实现的人工神经网络及反向传播算法源码+项目说明.zip

    零基础入门深度学习(3) - 神经网络和反向传播算法

    深度学习的核心是利用人工神经网络模拟人脑的神经元网络结构,通过学习大量的数据,自动提取特征并进行有效的分类和预测。 神经网络是深度学习的基本组成部分,它是由大量简单计算单元(神经元)通过各种形式的连接...

    人工神经网络反向传播算法基础代码学习

    人工神经网络反向传播算法基础代码学习 阅读 Tom M. Mitchell 的《机器学习》后,根据自己的理解写的最基础的人工神经网络反向传播算法 人工神经网络反向传播算法基础代码学习 阅读 Tom M. Mitchell 的《机器学习...

    人工神经网络反向传播算法学习.zip

    在"人工神经网络反向传播算法学习.zip"中,我们可以期待深入理解这一关键的学习策略。 BP算法的工作原理基于梯度下降,通过计算损失函数关于权重的梯度来更新网络参数。首先,输入数据通过网络前向传播,直至得到...

    Python实现的人工神经网络算法示例【基于反向传播算法】

    ### Python 实现的人工神经网络算法(基于反向传播算法) #### 一、概述 本文主要探讨了如何利用Python编程语言实现人工神经网络,并重点介绍了其中的反向传播算法。反向传播算法是一种广泛应用于训练多层前馈神经...

    基于人工蜂群的BP神经网络 人工蜂群算法的反向传播神经网络.zip

    综上所述,"基于人工蜂群的BP神经网络 人工蜂群算法的反向传播神经网络"的研究是将自然界的智能行为模拟引入到机器学习领域,通过人工蜂群算法优化BP神经网络的训练过程,提升其性能和泛化能力。这一方法的实现和...

    神经网络-反向传播算法.zip

    深度学习,神经网络学习资源,机器学习源码及案例,经典人工智能算法。 深度学习,神经网络学习资源,机器学习源码及案例,经典人工智能算法。 深度学习,神经网络学习资源,机器学习源码及案例,经典人工智能算法...

    BP人工神经网络-反向传播法-matlab-数据+代码

    BP人工神经网络,全称为Backpropagation Neural Network,是一种基于梯度下降的监督学习算法,广泛应用于模式识别、预测分析和复杂系统建模等领域。它通过反向传播误差信号来调整网络权重,以最小化预测输出与实际...

    matlab开发-多层感知神经网络模型与反向传播算法

    多层感知器是一种前馈型人工神经网络,其结构包括输入层、隐藏层和输出层,其中隐藏层可以有多个。这种网络能够处理非线性关系,通过多层神经元的组合,形成复杂的决策边界。在MATLAB中,我们可以利用Simulink工具箱...

    backPropagationNN-master_神经网络_反向传播算法_

    在`backPropagationNN-master`项目中,开发者提供了一个神经网络反向传播算法的实现。这个实现可能包括了网络架构定义、损失函数计算、梯度反向传播的代码,以及可能的数据预处理和训练过程。通过这个项目,你可以...

    深入解析神经网络中的反向传播算法

    反向传播算法(Backpropagation)是训练人工神经网络的核心算法,尤其在深度学习领域中扮演着至关重要的角色。它利用了梯度下降的概念,通过计算损失函数关于网络参数的梯度来更新网络权重,以此最小化网络的预测...

    纯numpy实现的人工神经网络及反向传播算法

    神经网络算法可以用于解决车辆路径问题,以下是与此相关的一些理论概念: 1. **神经网络在车辆路径问题中的应用**: - 神经网络可以用于学习和优化车辆路径规划,通过训练数据集来预测最佳的路径选择。 - 神经...

Global site tag (gtag.js) - Google Analytics