2. 程式人生 > >Bp神經網路+C++實現

Bp神經網路+C++實現

阿新 • • 發佈：2019-01-02

0 前言

　　神經網路在我印象中一直比較神祕，正好最近學習了神經網路，特別是對Bp神經網路有了比較深入的瞭解，因此，總結以下心得，希望對後來者有所幫助。
　　神經網路在機器學習中應用比較廣泛，比如函式逼近，模式識別，分類，資料壓縮，資料探勘等領域。神經網路本身是一個比較龐大的概念，從網路結構類別來劃分，大概有：多層前饋神經網路、徑向基函式網路（RBF）、自適應諧振理論網路（ART）、自組織對映網路（SOM）、級聯相關網路、Elman網路、Boltzmann機、受限Boltzmann機等等。
　下面一張圖是最近比較流行的網路結構：
這裡寫圖片描述
　 今天我們要介紹的是Bp神經網路，準確的說是採用Bp演算法進行訓練的多層前饋神經網路，Bp演算法應用比較廣泛。

1基本概念：

1.1神經元模型

 機器學習中所談論的神經網路源於生物上的神經網路，實際上指的是“神經網路“與”機器學習“的交叉部分，一個最簡單的M-P神經元模型如下圖所示：

這裡寫圖片描述
該神經元收到來自其他n個輸入神經元傳遞過來的輸入訊號（加權和的形式），然後將其與神經元的閾值進行比較，通過啟用函式進行處理，產生神經元的輸出。

1.2 常用啟用函式

啟用函式的作用是對其他所有神經元傳過來的所有訊號加權和進行處理，產生神經元輸出。

　 下圖是常用的啟用函式，最簡單的是：階躍函式，它簡單，最理想，但是性質最差（不連續/不光滑），因此在實際中，最常用的是Sigmoid函式。
常用啟用函式

1.3前饋神經網路

   多層前饋神經網路的準確定義：每一層神經元與下一層神經元全互連，神經元之間不存在同層連線，不存在跨層連線，如下圖所示就是一個經典的前饋神經網路，

三層前饋神經網路深度學習模型
（隨便插一句，當神經網路中隱層數越來越多，達到8-9層時，就變成了一個深度
學習模型，我曾在一篇論文中看到網路結構有達128層的，關於下面這塊，下面還會再敘述）。

2.標準Bp演算法

2.0 關於梯度

   首先我們應該清楚，一個多元函式的梯度方向是該函式值增大最陡的方向。具體化到1元函式中時，梯度方向首先是沿著曲線的切線的，然後取切線向上增長的方向為梯度方向，2元或者多元函式中，梯度向量為函式值f對每個變數的導數，該向量的方向就是梯度的方向，當然向量的大小也就是梯度的大小。
   梯度下降法(steepest descend method)用來求解表示式最大或者最小值的，屬於無約束優化問題。梯度下降法的基本思想還是挺簡單的，現假設我們要求函式f的最小值，首先得選取一個初始點後，然後下一個點的產生時是沿著梯度直線方向，這裡是沿著梯度的反方向(因為求的是最小值，如果是求最大值的話則沿梯度的正方向即可)，如下圖所示：

這裡寫圖片描述

2.1神經網路學習過程

　神經網路在外界輸入樣本的刺激下不斷改變網路的連線權值,以使網路的輸出不斷地接近期望的輸出，講幾個要點：
（1）學習過程可以簡述為：這裡寫圖片描述
（2）學習的本質： 對各連線權值以及所有功能神經元的閾值動態調整
注：可以將權值與閾值的學習統一為權值的學習，即將閾值看成一個”啞節點“，如下圖所示：
這裡寫圖片描述
（3） 權值調整規則：即在學習過程中網路中各神經元的連線權變化所依據的一定的調整規則 ，（Bp 演算法中權值調整採用的是梯度下降策略，下面會詳細介紹）
Bp網路的學習流程如下圖所示：
這裡寫圖片描述
（百度相簿裡搜的，能說明問題就行）

2.2權值調整策略：

　　首先說明一句，神經網路學習屬於監督學習的範疇。每輸入一個樣本,進行正向傳播（輸入層→隱層→輸出層），得到輸出結果以後,計算誤差，達不到期望後，將誤差進行反向傳播（輸出層→隱層→輸入層），採用梯度下降策略對所有權值和閾值進行調整。
誤差計算
注：上面的Ek是根據第k個樣本資料算出的誤差，可以看出：標準Bp演算法每次迭代更新只針對單個樣例。
權值與閾值的調整公式如下：
梯度下降法
上述公式的詳細推導過程見下圖：
這裡寫圖片描述
這裡寫圖片描述

2.3 BP神經網路總結

（1）BP神經網路一般用於分類或者逼近問題。
如果用於分類，則啟用函式一般選用Sigmoid函式或者硬極限函式，如果用於函式逼近，則輸出層節點用線性函式。
（2） BP神經網路在訓練資料時可以採用增量學習或者批量學習。
—增量學習要求輸入模式要有足夠的隨機性，對輸入模式的噪聲比較敏感，即對於劇烈變化的輸入模式，訓練效果比較差，適合線上處理。
—批量學習不存在輸入模式次序問題，穩定性好，但是隻適合離線處理。
（3）如何確定隱層數以及每個隱含層節點個數
Pre隱含層節點個數不確定，那麼應該設定為多少才合適呢（隱含層節點個數的多少對神經網路的效能是有影響的）？
有一個經驗公式可以確定隱含層節點數目：這裡寫圖片描述 ，（其中h:隱含層節點數目，m:為輸入層節點數目，n:為輸出層節點數目，a:為之間的調節常數）。

2.4 標準BP神經網路的缺陷

（1）容易形成區域性極小值而得不到全域性最優值。
（採用梯度下降法），如果僅有一個區域性極小值=>全域性最小，多個區域性極小=>不一定全域性最小。這就要求對初始權值和閥值有要求，要使得初始權值和閥值隨機性足夠好，可以多次隨機來實現。
（2）訓練次數多使得學習效率低，收斂速度慢。
每次更新只針對單個樣本；不同樣例出現”抵消“現象。
（3）過擬合問題
通過不斷訓練，訓練誤差達到很低，但測試誤差可能會上升（泛化效能差）。
解決策略：
1，”早停”：
即將樣本劃分成訓練集和驗證集，訓練集用來算梯度，更新權值和閾值，驗證集用來估計誤差，當訓練集誤差降低而驗證集誤差升高時就停止訓練，返回具有最小驗證集誤差的權值和閾值。
2，”正則化方法“：正則化，即在誤差目標中增加一個用於描述網路複雜程度的部分，其中引數λ常用交叉驗證來確定。

2.5 BP演算法的改進

（1）累積BP演算法
目的：為了減小整個訓練集的全域性誤差，而不針對某一特定樣本
這裡寫圖片描述 （更新策略做相應調整）

（2）利用動量法改進BP演算法
（標準Bp學習過程易震盪，收斂速度慢）
增加動量項，引入動量項是為了加速演算法收斂，即如下公式：
這裡寫圖片描述
α為動量係數，通常0＜α＜0.9。

（3）自適應調節學習率η
調整的基本指導思想是：在學習收斂的情況下，增大η，以縮短學習時間；當η偏大致使不能收斂（即發生震盪）時，要及時減小η，直到收斂為止。

3 工程搭建與C++實現

　實驗平臺：vs2013
專案包含檔案：
工程
專案流程如下圖所示：
這裡寫圖片描述

（1）Bp.h

#ifndef _BP_H_  
#define _BP_H_  

#include <vector>  

//引數設定
#define LAYER    3        //三層神經網路  
#define NUM      10       //每層的最多節點數  

#define A        30.0  
#define B        10.0     //A和B是S型函式的引數  
#define ITERS    1000     //最大訓練次數  
#define ETA_W    0.0035   //權值調整率  
#define ETA_B    0.001    //閥值調整率  
#define ERROR    0.002    //單個樣本允許的誤差  
#define ACCU     0.005    //每次迭代允許的誤差  

//型別
#define Type double  
#define Vector std::vector  

struct Data
{
    Vector<Type> x;       //輸入屬性
    Vector<Type> y;       //輸出屬性
};

class BP{

public:

    void GetData(const Vector<Data>);
    void Train();
    Vector<Type> ForeCast(const Vector<Type>);
    void ForCastFromFile(BP * &);
    void ReadFile(const char * InutFileName,int m, int n);

    void ReadTestFile(const char * InputFileName, int m, int n);
    void WriteToFile(const char * OutPutFileName);

private:

    void InitNetWork();         //初始化網路  
    void GetNums();             //獲取輸入、輸出和隱含層節點數  
    void ForwardTransfer();     //正向傳播子過程  
    void ReverseTransfer(int);  //逆向傳播子過程  
    void CalcDelta(int);        //計算w和b的調整量  
    void UpdateNetWork();       //更新權值和閥值  
    Type GetError(int);         //計算單個樣本的誤差  
    Type GetAccu();             //計算所有樣本的精度  
    Type Sigmoid(const Type);   //計算Sigmoid的值  
    void split(char *buffer, Vector<Type> &vec);

private:
    int in_num;                 //輸入層節點數  
    int ou_num;                 //輸出層節點數  
    int hd_num;                 //隱含層節點數  

    Vector<Data> data;            //樣本資料
    Vector<Vector<Type>> testdata;//測試資料
    Vector<Vector<Type>> result;  //測試結果
    int        rowLen;            //樣本數量
    int        restrowLen;        //測試樣本數量

    Type w[LAYER][NUM][NUM];    //BP網路的權值  
    Type b[LAYER][NUM];         //BP網路節點的閥值  

    Type x[LAYER][NUM];         //每個神經元的值經S型函式轉化後的輸出值，輸入層就為原值  
    Type d[LAYER][NUM];         //記錄delta學習規則中delta的值,使用delta規則來調整聯接權重 Wij(t+1)=Wij(t)+α(Yj-Aj(t))Oi(t)
};

#endif  //_BP_H_

(2)Bp.cpp

#include <string.h>  
#include <stdio.h>  
#include <math.h>  
#include <assert.h>  
#include <cstdlib>
#include <fstream>
#include <iostream>
using namespace std;

#include "Bp.h"  

//獲取訓練所有樣本資料  
void BP::GetData(const Vector<Data> _data)
{
    data = _data;
}

void BP::split(char *buffer, Vector<Type> &vec)
{
    char *p = strtok(buffer, " ,");      //\t
    while (p != NULL)
    {
        vec.push_back(atof(p));
        p = strtok(NULL, " \n");
    }
}


void BP::ReadFile(const char * InutFileName, int m ,int n)
{
    FILE *pFile;
    //Test
    //pFile = fopen("D:\\testSet.txt", "r");

    pFile = fopen(InutFileName, "r");

    if (!pFile)
    {
        printf("open file %s failed...\n", InutFileName);
        exit(0);
    }

    //init dataSet  
    char *buffer = new char[100];
    Vector<Type> temp;

    while (fgets(buffer, 100, pFile))
    {
        Data t;
        temp.clear();
        split(buffer, temp);
        //data[x].push_back(temp);

        for (int i = 0; i < temp.size(); i++)
        {
            if (i < m)
                t.x.push_back(temp[i]);
            else
                t.y.push_back(temp[i]);
        }
        data.push_back(t);
    }
    //init rowLen   
    rowLen = data.size();
}

void BP::ReadTestFile(const char * InputFileName, int m, int n)
{
    FILE *pFile;

    pFile = fopen(InputFileName, "r");
    if (!pFile)
    {
        printf("open file %s failed...\n", InputFileName);
        exit(0);
    }

    //init dataSet  
    char *buffer = new char[100];
    Vector<Type> temp;

    while (fgets(buffer, 100, pFile))
    {
        Vector<Type> t;
        temp.clear();
        split(buffer, temp);
        for (int i = 0; i < temp.size(); i++)
        {
            t.push_back(temp[i]);
        }
        testdata.push_back(t);
    }

    restrowLen = testdata.size();
}

void BP::WriteToFile(const char * OutPutFileName)
{
    ofstream fout;
    fout.open(OutPutFileName);
    if (!fout)
    {
        cout << "file result.txt  open failed" << endl;
        exit(0);
    }

    Vector<Vector<Type>> ::iterator it = testdata.begin();
    Vector<Vector<Type>>::iterator itx = result.begin();
    while (it != testdata.end())  
    {    
        Vector<Type> ::iterator itt = (*it).begin();
        Vector<Type> ::iterator ittx = (*itx).begin();
        while (itt != (*it).end())
        {
             fout << (*itt) << ",";
             itt++;
        }
        fout << "\t";
        while (ittx != (*itx).end())
        {
            fout << (*ittx) << ",";
            ittx++;
        }
        it++;
        itx++;
        fout << "\n";
    }
}

//開始進行訓練  
void BP::Train()
{
    printf("Begin to train BP NetWork!\n");
    GetNums();
    InitNetWork();
    int num = data.size();

    for (int iter = 0; iter <= ITERS; iter++)
    {
        for (int cnt = 0; cnt < num; cnt++)
        {
            //第一層輸入節點賦值  
            for (int i = 0; i < in_num; i++)
                x[0][i] = data.at(cnt).x[i];

            while (1)
            {
                ForwardTransfer();
                if (GetError(cnt) < ERROR)    //如果誤差比較小，則針對單個樣本跳出迴圈  
                    break;
                ReverseTransfer(cnt);
            }
        }
        printf("This is the %d th trainning NetWork !\n", iter);

        Type accu = GetAccu();               //每一輪學習的均方誤差E
        printf("All Samples Accuracy is %lf\n", accu);
        if (accu < ACCU) break;
    }
    printf("The BP NetWork train End!\n");
}

//根據訓練好的網路來預測輸出值  
Vector<Type> BP::ForeCast(const Vector<Type> data)
{
    int n = data.size();
    assert(n == in_num);
    for (int i = 0; i < in_num; i++)
        x[0][i] = data[i];

    ForwardTransfer();
    Vector<Type> v;
    for (int i = 0; i < ou_num; i++)
        v.push_back(x[2][i]);
    return v;
}

void  BP::ForCastFromFile(BP * &pBp)
{   

    Vector<Vector<Type>> ::iterator it = testdata.begin();
    Vector<Type> ou;
    while (it != testdata.end())
    {
        ou = pBp->ForeCast(*it);
        result.push_back(ou);

        it++;
    }

}

//獲取網路節點數  
void BP::GetNums()
{
    in_num = data[0].x.size();                         //獲取輸入層節點數  
    ou_num = data[0].y.size();                         //獲取輸出層節點數  
    hd_num = (int)sqrt((in_num + ou_num) * 1.0) + 5;   //獲取隱含層節點數    
    if (hd_num > NUM) hd_num = NUM;                     //隱含層數目不能超過最大設定  
}

//初始化網路  
void BP::InitNetWork()
{
    memset(w, 0, sizeof(w));      //初始化權值和閥值為0，也可以初始化隨機值  
    memset(b, 0, sizeof(b));
}

//工作訊號正向傳遞子過程  
void BP::ForwardTransfer()
{
    //計算隱含層各個節點的輸出值  
    for (int j = 0; j < hd_num; j++)
    {
        Type t = 0;
        for (int i = 0; i < in_num; i++)
            t += w[1][i][j] * x[0][i];
        t += b[1][j];
        x[1][j] = Sigmoid(t);
    }

    //計算輸出層各節點的輸出值  
    for (int j = 0; j < ou_num; j++)
    {
        Type t = 0;
        for (int i = 0; i < hd_num; i++)
            t += w[2][i][j] * x[1][i];
        t += b[2][j];
        x[2][j] = Sigmoid(t);
    }
}

//計算單個樣本的誤差  
Type BP::GetError(int cnt)
{
    Type ans = 0;
    for (int i = 0; i < ou_num; i++)
        ans += 0.5 * (x[2][i] - data.at(cnt).y[i]) * (x[2][i] - data.at(cnt).y[i]);
    return ans;
}

//誤差訊號反向傳遞子過程  
void BP::ReverseTransfer(int cnt)
{
    CalcDelta(cnt);
    UpdateNetWork();
}

//計算所有樣本的精度  
Type BP::GetAccu()
{
    Type ans = 0;
    int num = data.size();
    for (int i = 0; i < num; i++)
    {
        int m = data.at(i).x.size();
        for (int j = 0; j < m; j++)
            x[0][j] = data.at(i).x[j];
        ForwardTransfer();
        int n = data.at(i).y.size(); //樣本輸出的維度
        for (int j = 0; j < n; j++)
            ans += 0.5 * (x[2][j] - data.at(i).y[j]) * (x[2][j] - data.at(i).y[j]);//對第i個樣本算均方誤差
    }
    return ans / num;
}

//計算調整量  
void BP::CalcDelta(int cnt)
{
    //計算輸出層的delta值  
    for (int i = 0; i < ou_num; i++)
        d[2][i] = (x[2][i] - data.at(cnt).y[i]) * x[2][i] * (A - x[2][i]) / (A * B);
    //計算隱含層的delta值  
    for (int i = 0; i < hd_num; i++)
    {
        Type t = 0;
        for (int j = 0; j < ou_num; j++)
            t += w[2][i][j] * d[2][j];
        d[1][i] = t * x[1][i] * (A - x[1][i]) / (A * B);
    }
}

//根據計算出的調整量對BP網路進行調整  
void BP::UpdateNetWork()
{
    //隱含層和輸出層之間權值和閥值調整  
    for (int i = 0; i < hd_num; i++)
    {
        for (int j = 0; j < ou_num; j++)
            w[2][i][j] -= ETA_W * d[2][j] * x[1][i];
    }
    for (int i = 0; i < ou_num; i++)
        b[2][i] -= ETA_B * d[2][i];

    //輸入層和隱含層之間權值和閥值調整  
    for (int i = 0; i < in_num; i++)
    {
        for (int j = 0; j < hd_num; j++)
            w[1][i][j] -= ETA_W * d[1][j] * x[0][i];
    }
    for (int i = 0; i < hd_num; i++)
        b[1][i] -= ETA_B * d[1][i];
}

//計算Sigmoid函式的值  
Type BP::Sigmoid(const Type x)
{
    return A / (1 + exp(-x / B));
}

(3)Test.cpp

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
using namespace std;

#include "Bp.h"  

int main()
{
    unsigned int Id, Od;    //樣本資料的輸入維數/輸出維數
    int select = 0;
    BP *bp = new BP();
    const char * inputDataName = "exercisedata.txt";//訓練資料檔名稱
    const char * testDataName = "testdata.txt";   //測試資料檔名稱
    const char * outputDataName = "result.txt";     //輸出檔名稱

    printf("please input sample input dimension and output dimension:\n");
    scanf("%d%d", &Id, &Od);
    bp->ReadFile(inputDataName,Id,Od);

    //exercise
    bp->Train();
    //Test
    printf("\n******************************************************\n");
    printf("*1.使用測試檔案中國的資料測試 2.從控制檯輸入資料測試  \n");
    printf("******************************************************\n");
    scanf("%d", &select);
    switch (select)
    {
    case 1:
        bp->ReadTestFile(testDataName,Id,Od);
        bp->ForCastFromFile(bp);
        bp->WriteToFile(outputDataName);
        printf("the result have been save in the file :result.txt.\n");
        break;
    case 2:
        printf("\n\nplease input the Test Data(3 dimension )：\n");
        while (1)
        {
            Vector<Type> in;
            for (int i = 0; i < Id; i++)
            {
                Type v;
                scanf_s("%lf", &v);
                in.push_back(v);
            }
            Vector<Type> ou;
            ou = bp->ForeCast(in);
            printf("%lf\n", ou[0]);
        }
        break;
    default:
        printf("Input error!");
        exit(0);
    }

    return 0;
}

相關推薦

單隱層BP神經網路C++實現

    這幾天抽時間學習了一下很久之前就想學習的BP神經網路。通過閱讀西瓜書的神經網路部分的原理和參考了網上幾篇部落格，我自己用C++編寫、實現了一個單隱層BP神經網路。     簡單畫了個示意圖，好理解下面給出的公式：（注意：圖中省略了其他的節點之間的連

Bp神經網路+C++實現

0 前言 　　神經網路在我印象中一直比較神祕，正好最近學習了神經網路，特別是對Bp神經網路有了比較深入的瞭解，因此，總結以下心得，希望對後來者有所幫助。 　　神經網路在機器學習中應用比較廣泛，比如函式逼近，模式識別，分類，資料壓縮，資料探勘等領域。神經

BP神經網路 c++實現

#include <iostream> #include <cmath> #include "stdio.h" #include "stdlib.h" #include "time.h" using namespace std;

BP神經網路-- C語言實現 上

在上一篇文章中，介紹了BP神經網路的基本模型、模型中的一些術語並對模型進行了數學上的分析，對它的原理有了初步的認識。那麼如何用程式語言來具體的實現它，將是我們下一步需要討論的問題。本文選取的是C語言來實現一個簡單的單隱藏層的BP神經網路（預設大家瞭解了BP神經網路的基本

機器學習之BP神經網路演算法實現影象分類

BP 演算法是一個迭代演算法，它的基本思想為：(1) 先計算每一層的狀態和啟用值，直到最後一層（即訊號是前向傳播的）；(2) 計算每一層的誤差，誤差的計算過程是從最後一層向前推進的（這就是反向傳播演算法名字的由來）；(3) 更新引數（目標是誤差變小），迭代前面兩

MATLAB神經網路程式設計（七）——BP神經網路的實現

《MATLAB神經網路程式設計》 化學工業出版社 讀書筆記 第四章 前向型神經網路 4.3 BP傳播網路 本文是《MATLAB神經網路程式設計》書籍的閱讀筆記，其中涉及的原始碼、公式、原理都來自此書，若有不理解之處請參閱原書 本文講述BP網路常

Java實現BP神經網路，實現對空氣質量的分析和評級

使用java實現BP神經網路進行迴歸分析，並利用訓練好的神經網路實現空氣質量的評級。 本實驗的工程專案和訓練資料集可訪問以下網址下載： 實驗描述: 對指定資料集進行迴歸分析，選擇適當的迴歸演算法，編寫程式實現，提交程式和結果報告。 資料集： AirQualityU

BP神經網路的實現

一 BP神經網路的基本結構 在神經網路中，輸入層由資料集的某個向量x和一個偏置b構成，該向量需要乘以同緯度的權重向量w，累加得到下一層神經元的一個輸入標量，該標量乘以啟用函式得到下一層神經元的輸入。 該結構分為以下幾個部分。 二 BP神

BP神經網路java實現，按照演算法步驟也參考網上相關資源寫的，若君有高見，非常歡迎指教

for(int i=0;i<hidN;i++){for(int j=0;j<=inN;j++){wyh[i][j]=Math.random()-0.5;//初始化權值和閾值//System.out.println(wyh[i][j]);}}//System.out.println();wyo=ne

BP神經網路Python實現異或問題

# -*- coding: UTF-8 -*- import matplotlib as mpl import numpy as np import matplotlib.pyplot as plt #BP神經網路實現異或問題 X=np.array([[1,0,0]

[純C#實現]基於BP神經網路的中文手寫識別演算法

效果展示 這不是OCR,有些人可能會覺得這東西會和OCR一樣,直接進行整個字的識別就行,然而並不是. OCR是2維畫素矩陣的畫素資料.而手寫識別不一樣,手寫可以把使用者寫字的筆畫時間順序,抽象成一個維度.這樣識別的就是3維的資料了.識別起來簡單很多. 最近需要做一箇中文手寫識別演算法.搜尋了網上的

BP神經網路原理分析及c++程式碼實現（上）

    本部落格所述BP神經網路，是本人研究總結的結果，希望對您有所幫助，當然，如果有需要，大家可以互相交流。    設計一個BP神經網路類，來實現一個BP神經網路。要求輸入層節點數、隱層數、隱層節點數、輸出層節點數、傳遞函式、演算法等等可以由使用者自主設定。 神經網路

C++實現誤差反向傳播演算法（BP神經網路）

誤差反向傳播學習演算法 實現Iris資料分類 Denverg Secret Number 29,April 2018 實驗目的 用C++實現BP神經網路 實驗原理 人工神經網路模型 人們從40年代開始研究人腦神經元功能。1943年

BP神經網路原理分析及c++程式碼實現（下）

為了方便廣大使用者的使用，本人將BP神經網路寫成了一個BPNNS類，這樣使用者們可以很方便的將此類潛入到自己的工程當中，此類的具體的使用規則，下面會介紹。 /*********************************************************

C++實現的簡單BP神經網路

實現了一個簡單的BP神經網路演算法 使用EasyX圖形化顯示訓練過程和訓練結果 使用了25個數據集，一共訓練了1萬次。 該神經網路有兩個輸入，一個輸出端 下圖是訓練效果，data是訓練的輸入資料，temp代表所在層的輸出，target是訓練目標，右邊的大

C# + Matlab 實現計件工時基於三層BP神經網路的擬合--真實專案

  工序工時由該工序的工藝引數決定，有了工時後乘以固定因子就是計件工資。一般參考本地小時工資以及同類小時工資並考慮作業的風險等因素給出固定因子 採用的VS2010 , Matlab2015a 64,  開發端是win7 64 , 部署端是win2012 R2 Datacenter 64 M

BP神經網路基於Tensorflow的實現（程式碼註釋詳細）

BP(back propagation)神經網路是1986年由Rumelhart和McClelland為首的科學家提出的概念，是一種按照誤差逆向傳播演算法訓練的多層前饋神經網路，是目前應用最廣泛的神經網路。 在一般的BP神經網路中，單個樣本有m個輸入和n個輸出，在輸入層

神經網路學習（3）————BP神經網路以及python實現

一、BP神經網路結構模型                BP演算法的基本思想是，學習過程由訊號的正向傳播和誤差的反向傳播倆個過程組成，輸入從輸入層輸入，經隱層處理以後，傳向輸出層。如果輸出層的實際輸出和期望輸出不符合

Tensorflow實現BP神經網路

Tensorflow實現BP神經網路 摘要：深度學習中基本模型為BP深度神經網路，其包括輸入層、隱含層和輸出層。輸入層的神經元個數取決於資料集屬性特徵的個數，輸出層神經元個數取決於劃分類標的個數。BP神經網路通過梯度下降法不斷調整權重矩陣和偏向進行調參，實現神經網路的訓練。   本人

keras實現網路流量分類功能的BP神經網路

資料集選用KDD99 資料下載地址：http://kdd.ics.uci.edu/databases/kddcup99/kddcup99.html 需求：https://blog.csdn.net/com_stu_zhang/article/details/6987632