bp網路模型c程序

⑴ BP神經網路的預測（回歸）過程C語言程序

神經網路本質也是一種數據回歸模型。我們舉個簡單的例子
y=ax^2+bx+c，
有三個系數要回歸，如果只給你1～2組數據，你覺得能回歸好嗎？
考慮到樣本本身有誤差，為了防止過擬合（或過學習），一般要求神經網路的訓練樣本數是連接權系數（包括閾值）的2～3倍。你用了太多的連接權系數（包括閾值），即使效果不錯，風險仍然很高。

⑵ BP神經網路

神經網路能很好地解決不同的機器學習問題。神經網路模型是許多邏輯單元按照不同層級組織起來的網路，每一層的輸出變數都是下一層的輸入變數。

上圖顯示了人工神經網路是一個分層模型，邏輯上可以分為三層：

輸入層 ：輸入層接收特徵向量 x

輸出層 ：輸出層產出最終的預測 h

隱含層 ：隱含層介於輸入層與輸出層之間，之所以稱之為隱含層，是因為當中產生的值並不像輸入層使用的樣本矩陣 X或者輸出層用到的標簽矩陣 y 那樣直接可見。

下面引入一些標記法來幫助描述模型：

!$ a^{(j)}_{i} $ 代表第j層的第i個激活單元。 !$ heta^{(j)} $ 代表從第 j 層映射到第 j+1 層時的權重的矩陣，例如 !$ heta^{(1)} $ 代表從第一層映射到第二層的權重的矩陣。其尺寸為：以第 j+1層的激活單元數量為行數，以第 j 層的激活單元數加一為列數的矩陣。例如：上圖所示的神經網路中 !$ heta^{(1)} $ 的尺寸為 3*4。

對於上圖所示的模型，激活單元和輸出分別表達為：

!$ a^{(2)}_{1} = g( heta^{(1)}_{10}x_0 + heta^{(1)}_{11}x_1 + heta^{(1)}_{12}x_2 + heta^{(1)}_{13}x_3 ) $

!$a^{(2)}_{2} = g( heta^{(1)}_{20}x_0 + heta^{(1)}_{21}x_1 + heta^{(1)}_{22}x_2 + heta^{(1)}_{23}x_3 ) $

!$a^{(2)}_{3} = g( heta^{(1)}_{30}x_0 + heta^{(1)}_{31}x_1 + heta^{(1)}_{32}x_2 + heta^{(1)}_{33}x_3 ) $

!$h_{ heta}{(x)} = g( heta^{(2)}_{10}a^{2}_{0} + heta^{(2)}_{11}a^{2}_{1} + heta^{(2)}_{12}a^{2}_{2} + heta^{(2)}_{13}a^{2}_{3} ) $

下面用向量化的方法以上面的神經網路為例，試著計算第二層的值：

對於多類分類問題來說:

我們可將神經網路的分類定義為兩種情況:二類分類和多類分類。

二類分類： !$ S_{L} = 0,y = 0,y = 1$

多類分類： !$ S_{L} = k, y_{i} = 1表示分到第i類；(k>2)$

在神經網路中，我們可以有很多輸出變數，我們的 !$h_{ heta}{(x)} $ 是一個維度為K的向量，並且我們訓練集中的因變數也是同樣維度的一個向量，因此我們的代價函數會比邏輯回歸更加復雜一些，為： !$ h_{ heta}{(x)} in R^{K}(h_{ heta}{(x)})_{i} = i^{th} output$

我們希望通過代價函數來觀察演算法預測的結果與真實情況的誤差有多大，唯一不同的是，對於每一行特徵，我們都會給出K個預測，基本上我們可以利用循環，對每一行特徵都預測K個不同結果，然後在利用循環在K個預測中選擇可能性最高的一個，將其與y中的實際數據進行比較。

正則化的那一項只是排除了每一層 !$ heta_0$ 後，每一層的 矩陣的和。最里層的循環j循環所有的行（由 +1 層的激活單元數決定），循環i則循環所有的列，由該層（ !$ s_l$ 層）的激活單元數所決定。即： !$h_{ heta}{(x)}$ 與真實值之間的距離為每個樣本-每個類輸出的加和，對參數進行 regularization 的 bias 項處理所有參數的平方和。

由於神經網路允許多個隱含層，即各層的神經元都會產出預測，因此，就不能直接利用傳統回歸問題的梯度下降法來最小化 !$J( heta)$ ，而需要逐層考慮預測誤差，並且逐層優化。為此，在多層神經網路中，使用反向傳播演算法（Backpropagation Algorithm）來優化預測，首先定義各層的預測誤差為向量 !$ δ^{(l)} $

訓練過程：

當我們對一個較為復雜的模型（例如神經網路）使用梯度下降演算法時，可能會存在一些不容易察覺的錯誤，意味著，雖然代價看上去在不斷減小，但最終的結果可能並不是最優解。

為了避免這樣的問題，我們採取一種叫做梯度的數值檢驗（ Numerical Gradient Checking ）方法。這種方法的思想是通過估計梯度值來檢驗我們計算的導數值是否真的是我們要求的。

對梯度的估計採用的方法是在代價函數上沿著切線的方向選擇離兩個非常近的點然後計算兩個點的平均值用以估計梯度。即對於某個特定的 ，我們計算出在 !$ heta - epsilon$ 處和 !$ heta + epsilon$ 的代價值（是一個非常小的值，通常選取 0.001），然後求兩個代價的平均，用以估計在 !$ heta$ 處的代價值。

當 !$ heta$ 是一個向量時，我們則需要對偏導數進行檢驗。因為代價函數的偏導數檢驗只針對一個參數的改變進行檢驗，下面是一個只針對 !$ heta_1$ 進行檢驗的示例：

如果上式成立，則證明網路中BP演算法有效，此時關閉梯度校驗演算法（因為梯度的近似計算效率很慢），繼續網路的訓練過程。

⑶ 建立BP神經網路地面沉降預測模型

基坑降水引起地面沉降的BP神經網路預測模型建模過程如下：

（1）樣本選擇

因基坑降水引起的地面沉降量和距離基坑的距離關系密切，因此建模選用「基坑降水引起沉降工程數據（第二類）」（見表4.1）中的相關數據作為樣本進行學習訓練和檢驗。

（2）BP神經網路結構設計

對於BP網路，對於任何在閉區間內的一個連續函數都可以用單隱層的BP網路逼近，因而一個三層BP網路就可以完成任意的n維到m維的映射。根據網路結構簡單化的原則，確定採用三層BP網路結構，即輸入層為沉降點距基坑的距離L（m）、等效壓縮模量E（MPa）、水位降深H（m）和支護剛度n四個參數，輸出層為地面累積沉降量（mm），隱層層數為1層。隱層的神經元數目選擇是一個十分復雜的問題，往往需要根據設計者的經驗和多次實驗來確定，因而不存在一個理想的解析式來表示。隱單元的數目與問題的要求，與輸入、輸出單元的數目有直接的關系。隱單元數目太多會導致學習時間過長，誤差不一定最佳，也會導致容錯性差、不能識別以前沒有看到的樣本，因此一定存在一個最佳的隱單元數。研究通過一次編程比較了隱層神經元個數分別為5、10、15、20、25、30、40時訓練速度及檢驗精度。

圖4.2 BP神經網路程序框圖

（3）網路訓練及檢驗

BP網路採用梯度下降法來降低網路的訓練誤差，考慮到基坑降水地面沉降范圍內沉降量變化幅度較小的特點，訓練時以訓練目標取0.001為控制條件，考慮到網路的結構比較復雜，神經元個數比較多，需要適當增加訓練次數和學習速率，因此初始訓練次數設為10000次，學習速率取0.1，中間層的神經元傳遞函數採用S型正切函數tansig，傳輸函數採用logsig，訓練函數採用trainlm，選用38組數據中的33組作為訓練樣本，5組作為檢驗樣本。

（4）網路實現及檢驗效果

使用MATLAB6.0編程建立基於BP神經網路的基坑降水地面沉降預測模型（程序代碼見附件1），其訓練誤差及檢驗效果如下：

圖4.3 訓練誤差曲線

圖4.4 預測誤差曲線

由圖4.3、圖4.4可見：樣本數據收斂，訓練誤差較小，中間層神經單元個數為10時預測精度較好，誤差小於20%，誤差滿足工程需求。

⑷ BP神經網路方法

人工神經網路是近幾年來發展起來的新興學科，它是一種大規模並行分布處理的非線性系統，適用解決難以用數學模型描述的系統，逼近任何非線性的特性，具有很強的自適應、自學習、聯想記憶、高度容錯和並行處理能力，使得神經網路理論的應用已經滲透到了各個領域。近年來，人工神經網路在水質分析和評價中的應用越來越廣泛，並取得良好效果。在這些應用中，縱觀應用於模式識別的神經網路，BP網路是最有效、最活躍的方法之一。

BP網路是多層前向網路的權值學習採用誤差逆傳播學習的一種演算法（Error Back Propagation，簡稱BP）。在具體應用該網路時分為網路訓練及網路工作兩個階段。在網路訓練階段，根據給定的訓練模式，按照「模式的順傳播」→「誤差逆傳播」→「記憶訓練」→「學習收斂」4個過程進行網路權值的訓練。在網路的工作階段，根據訓練好的網路權值及給定的輸入向量，按照「模式順傳播」方式求得與輸入向量相對應的輸出向量的解答（閻平凡，2000）。

BP演算法是一種比較成熟的有指導的訓練方法，是一個單向傳播的多層前饋網路。它包含輸入層、隱含層、輸出層，如圖4-4所示。

圖4-4 地下水質量評價的BP神經網路模型

圖4-4給出了4層地下水水質評價的BP神經網路模型。同層節點之間不連接。輸入信號從輸入層節點，依次傳過各隱含層節點，然後傳到輸出層節點，如果在輸出層得不到期望輸出，則轉入反向傳播，將誤差信號沿原來通路返回，通過學習來修改各層神經元的權值，使誤差信號最小。每一層節點的輸出隻影響下一層節點的輸入。每個節點都對應著一個作用函數（f）和閾值（a），BP網路的基本處理單元量為非線性輸入-輸出的關系，輸入層節點閾值為0，且f（x）=x；而隱含層和輸出層的作用函數為非線性的Sigmoid型（它是連續可微的）函數，其表達式為

f（x）=1/（1+e^-x） （4-55）

設有L個學習樣本（X_k，O_k）（k=1，2，…，l），其中X_k為輸入，O_k為期望輸出，X_k經網路傳播後得到的實際輸出為Y_k，則Y_k與要求的期望輸出O_k之間的均方誤差為

區域地下水功能可持續性評價理論與方法研究

式中：M為輸出層單元數；Y_k，p為第k樣本對第p特性分量的實際輸出；O_k，p為第k樣本對第p特性分量的期望輸出。

樣本的總誤差為

區域地下水功能可持續性評價理論與方法研究

由梯度下降法修改網路的權值，使得E取得最小值，學習樣本對W_ij的修正為

區域地下水功能可持續性評價理論與方法研究

式中：η為學習速率，可取0到1間的數值。

所有學習樣本對權值W_ij的修正為

區域地下水功能可持續性評價理論與方法研究

通常為增加學習過程的穩定性，用下式對W_ij再進行修正：

區域地下水功能可持續性評價理論與方法研究

式中：β為充量常量；W_ij（t）為BP網路第t次迭代循環訓練後的連接權值；W_ij（t-1）為BP網路第t-1次迭代循環訓練後的連接權值。

在BP網路學習的過程中，先調整輸出層與隱含層之間的連接權值，然後調整中間隱含層間的連接權值，最後調整隱含層與輸入層之間的連接權值。實現BP網路訓練學習程序流程，如圖4-5所示（倪深海等，2000）。

圖4-5 BP神經網路模型程序框圖

若將水質評價中的評價標准作為樣本輸入，評價級別作為網路輸出，BP網路通過不斷學習，歸納出評價標准與評價級別間復雜的內在對應關系，即可進行水質綜合評價。

BP網路對地下水質量綜合評價，其評價方法不需要過多的數理統計知識，也不需要對水質量監測數據進行復雜的預處理，操作簡便易行，評價結果切合實際。由於人工神經網路方法具有高度民主的非線性函數映射功能，使得地下水水質評價結果較准確（袁曾任，1999）。

BP網路可以任意逼近任何連續函數，但是它主要存在如下缺點：①從數學上看，它可歸結為一非線性的梯度優化問題，因此不可避免地存在局部極小問題；②學習演算法的收斂速度慢，通常需要上千次或更多。

神經網路具有學習、聯想和容錯功能，是地下水水質評價工作方法的改進，如何在現行的神經網路中進一步吸取模糊和灰色理論的某些優點，建立更適合水質評價的神經網路模型，使該模型既具有方法的先進性又具有現實的可行性，將是我們今後研究和探討的問題。

⑸ c語言實現*/遺傳演算法改進BP神經網路原理和演算法實現怎麼弄

遺傳演算法有相當大的引用。遺傳演算法在游戲中應用的現狀在遺傳編碼時, 一般將瓦片的坐標作為基因進行實數編碼, 染色體的第一個基因為起點坐標, 最後一個基因為終點坐標, 中間的基因為路徑經過的每一個瓦片的坐標。在生成染色體時, 由起點出發, 隨機選擇當前結點的鄰居節點中的可通過節點, 將其坐標加入染色體, 依此循環, 直到找到目標點為止, 生成了一條染色體。重復上述操作, 直到達到指定的種群規模。遺傳演算法的優點：1、遺傳演算法是以決策變數的編碼作為運算對象，可以直接對集合、序列、矩陣、樹、圖等結構對象進行操作。這樣的方式一方面有助於模擬生物的基因、染色體和遺傳進化的過程，方便遺傳操作運算元的運用。另一方面也使得遺傳演算法具有廣泛的應用領域，如函數優化、生產調度、自動控制、圖像處理、機器學習、數據挖掘等領域。2、遺傳演算法直接以目標函數值作為搜索信息。它僅僅使用適應度函數值來度量個體的優良程度，不涉及目標函數值求導求微分的過程。因為在現實中很多目標函數是很難求導的，甚至是不存在導數的，所以這一點也使得遺傳演算法顯示出高度的優越性。3、遺傳演算法具有群體搜索的特性。它的搜索過程是從一個具有多個個體的初始群體P(0)開始的，一方面可以有效地避免搜索一些不必搜索的點。另一方面由於傳統的單點搜索方法在對多峰分布的搜索空間進行搜索時很容易陷入局部某個單峰的極值點，而遺傳演算法的群體搜索特性卻可以避免這樣的問題，因而可以體現出遺傳演算法的並行化和較好的全局搜索性。4、遺傳演算法基於概率規則，而不是確定性規則。這使得搜索更為靈活，參數對其搜索效果的影響也盡可能的小。5、遺傳演算法具有可擴展性，易於與其他技術混合使用。以上幾點便是遺傳演算法作為優化演算法所具備的優點。遺傳演算法的缺點：遺傳演算法在進行編碼時容易出現不規范不準確的問題。

⑹ 求BP神經網路演算法的C++源代碼

// AnnBP.cpp: implementation of the CAnnBP class.
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "AnnBP.h"
#include "math.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAnnBP::CAnnBP()
{
eta1=0.3;
momentum1=0.3;

}

CAnnBP::~CAnnBP()
{

}

double CAnnBP::drnd()
{
return ((double) rand() / (double) BIGRND);
}

/*** 返回-1.0到1.0之間的雙精度隨機數 ***/
double CAnnBP::dpn1()
{
return (double) (rand())/(32767/2)-1;
}

/*** 作用函數，目前是S型函數 ***/
double CAnnBP::squash(double x)
{
return (1.0 / (1.0 + exp(-x)));
}

/*** 申請1維雙精度實數數組 ***/
double* CAnnBP::alloc_1d_dbl(int n)
{
double *new1;

new1 = (double *) malloc ((unsigned) (n * sizeof (double)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");
return (NULL);
}
return (new1);
}

/*** 申請2維雙精度實數數組 ***/
double** CAnnBP::alloc_2d_dbl(int m, int n)
{
int i;
double **new1;

new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n");
return (NULL);
}

for (i = 0; i < m; i++) {
new1[i] = alloc_1d_dbl(n);
}

return (new1);
}

/*** 隨機初始化權值 ***/
void CAnnBP::bpnn_randomize_weights(double **w, int m, int n)
{
int i, j;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
w[i][j] = dpn1();
}
}

}

/*** 0初始化權值 ***/
void CAnnBP::bpnn_zero_weights(double **w, int m, int n)
{
int i, j;

for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
w[i][j] = 0.0;
}
}

}

/*** 設置隨機數種子 ***/
void CAnnBP::bpnn_initialize(int seed)
{
CString msg,s;
msg="Random number generator seed:";
s.Format("%d",seed);
AfxMessageBox(msg+s);
srand(seed);
}

/*** 創建BP網路 ***/
BPNN* CAnnBP::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);

}

/* 釋放BP網路所佔地內存空間 */
void CAnnBP::bpnn_free(BPNN *net)
{
int n1, n2, i;

n1 = net->input_n;
n2 = net->hidden_n;

free((char *) net->input_units);
free((char *) net->hidden_units);
free((char *) net->output_units);

free((char *) net->hidden_delta);
free((char *) net->output_delta);
free((char *) net->target);

for (i = 0; i <= n1; i++) {
free((char *) net->input_weights[i]);
free((char *) net->input_prev_weights[i]);
}
free((char *) net->input_weights);
free((char *) net->input_prev_weights);

for (i = 0; i <= n2; i++) {
free((char *) net->hidden_weights[i]);
free((char *) net->hidden_prev_weights[i]);
}
free((char *) net->hidden_weights);
free((char *) net->hidden_prev_weights);

free((char *) net);
}

/*** 創建一個BP網路，並初始化權值***/
BPNN* CAnnBP::bpnn_create(int n_in, int n_hidden, int n_out)
{
BPNN *newnet;

newnet = bpnn_internal_create(n_in, n_hidden, n_out);

#ifdef INITZERO
bpnn_zero_weights(newnet->input_weights, n_in, n_hidden);
#else
bpnn_randomize_weights(newnet->input_weights, n_in, n_hidden);
#endif
bpnn_randomize_weights(newnet->hidden_weights, n_hidden, n_out);
bpnn_zero_weights(newnet->input_prev_weights, n_in, n_hidden);
bpnn_zero_weights(newnet->hidden_prev_weights, n_hidden, n_out);

return (newnet);

}

void CAnnBP::bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2)
{
double sum;
int j, k;

/*** 設置閾值 ***/
l1[0] = 1.0;

/*** 對於第二層的每個神經元 ***/
for (j = 1; j <= n2; j++) {

/*** 計算輸入的加權總和 ***/
sum = 0.0;
for (k = 0; k <= n1; k++) {
sum += conn[k][j] * l1[k];
}
l2[j] = squash(sum);
}
}

/* 輸出誤差 */
void CAnnBP::bpnn_output_error(double *delta, double *target, double *output, int nj, double *err)
{
int j;
double o, t, errsum;

errsum = 0.0;
for (j = 1; j <= nj; j++) {
o = output[j];
t = target[j];
delta[j] = o * (1.0 - o) * (t - o);
errsum += ABS(delta[j]);
}
*err = errsum;

}

/* 隱含層誤差 */
void CAnnBP::bpnn_hidden_error(double *delta_h, int nh, double *delta_o, int no, double **who, double *hidden, double *err)
{
int j, k;
double h, sum, errsum;

errsum = 0.0;
for (j = 1; j <= nh; j++) {
h = hidden[j];
sum = 0.0;
for (k = 1; k <= no; k++) {
sum += delta_o[k] * who[j][k];
}
delta_h[j] = h * (1.0 - h) * sum;
errsum += ABS(delta_h[j]);
}
*err = errsum;
}

/* 調整權值 */
void CAnnBP::bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, 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 CAnnBP::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);

}

/* 訓練BP網路 */
void CAnnBP::bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh)
{
int in, hid, out;
double out_err, hid_err;

in = net->input_n;
hid = net->hidden_n;
out = net->output_n;

/*** 前向輸入激活 ***/
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);

/*** 計算隱含層和輸出層誤差 ***/
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;

/*** 調整輸入層和隱含層權值 ***/
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);
}

/* 保存BP網路 */
void CAnnBP::bpnn_save(BPNN *net, char *filename)
{
CFile file;
char *mem;
int n1, n2, n3, i, j, memcnt;
double dvalue, **w;
n1 = net->input_n; n2 = net->hidden_n; n3 = net->output_n;
printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename);
try
{
file.Open(filename,CFile::modeWrite|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e->ReportError();
e->Delete();
}

file.Write(&n1,sizeof(int));
file.Write(&n2,sizeof(int));
file.Write(&n3,sizeof(int));

memcnt = 0;
w = net->input_weights;
mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
// mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));
for (i = 0; i <= n1; i++) {
for (j = 0; j <= n2; j++) {
dvalue = w[i][j];
//fast(&mem[memcnt], &dvalue, sizeof(double));
fast(&mem[memcnt], &dvalue, sizeof(double));
memcnt += sizeof(double);

}
}

file.Write(mem,sizeof(double)*(n1+1)*(n2+1));
free(mem);

memcnt = 0;
w = net->hidden_weights;
mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
// mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));
for (i = 0; i <= n2; i++) {
for (j = 0; j <= n3; j++) {
dvalue = w[i][j];
fast(&mem[memcnt], &dvalue, sizeof(double));
// fast(&mem[memcnt], &dvalue, sizeof(double));
memcnt += sizeof(double);
}
}

file.Write(mem, (n2+1) * (n3+1) * sizeof(double));
// free(mem);

file.Close();
return;
}

/* 從文件中讀取BP網路 */
BPNN* CAnnBP::bpnn_read(char *filename)
{
char *mem;
BPNN *new1;
int n1, n2, n3, i, j, memcnt;
CFile file;

try
{
file.Open(filename,CFile::modeRead|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e->ReportError();
e->Delete();
}

// printf("Reading '%s'\n", filename);// fflush(stdout);

file.Read(&n1, sizeof(int));
file.Read(&n2, sizeof(int));
file.Read(&n3, sizeof(int));

new1 = bpnn_internal_create(n1, n2, n3);

// printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3);
// printf("Reading input weights..."); // fflush(stdout);

memcnt = 0;
mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));

file.Read(mem, ((n1+1)*(n2+1))*sizeof(double));
for (i = 0; i <= n1; i++) {
for (j = 0; j <= n2; j++) {
//fast(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double));
fast(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double));
memcnt += sizeof(double);
}
}
free(mem);

// printf("Done\nReading hidden weights..."); //fflush(stdout);

memcnt = 0;
mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));

file.Read(mem, (n2+1) * (n3+1) * sizeof(double));
for (i = 0; i <= n2; i++) {

for (j = 0; j <= n3; j++) {
//fast(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
fast(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
memcnt += sizeof(double);

}
}
free(mem);
file.Close();

printf("Done\n"); //fflush(stdout);

bpnn_zero_weights(new1->input_prev_weights, n1, n2);
bpnn_zero_weights(new1->hidden_prev_weights, n2, n3);

return (new1);
}

void CAnnBP::CreateBP(int n_in, int n_hidden, int n_out)
{
net=bpnn_create(n_in,n_hidden,n_out);
}

void CAnnBP::FreeBP()
{
bpnn_free(net);

}

void CAnnBP::Train(double *input_unit,int input_num, double *target,int target_num, double *eo, double *eh)
{
for(int i=1;i<=input_num;i++)
{
net->input_units[i]=input_unit[i-1];
}

for(int j=1;j<=target_num;j++)
{
net->target[j]=target[j-1];
}
bpnn_train(net,eta1,momentum1,eo,eh);

}

void CAnnBP::Identify(double *input_unit,int input_num,double *target,int target_num)
{
for(int i=1;i<=input_num;i++)
{
net->input_units[i]=input_unit[i-1];
}
bpnn_feedforward(net);
for(int j=1;j<=target_num;j++)
{
target[j-1]=net->output_units[j];
}
}

void CAnnBP::Save(char *filename)
{
bpnn_save(net,filename);

}

void CAnnBP::Read(char *filename)
{
net=bpnn_read(filename);
}

void CAnnBP::SetBParm(double eta, double momentum)
{
eta1=eta;
momentum1=momentum;

}

void CAnnBP::Initialize(int seed)
{
bpnn_initialize(seed);

}

⑺ 數學建模題 葡萄酒的評價 用bp神經網路解，求怎樣用C或C++或Java代碼解

能傳一下表格么，謝謝啦

⑻ 如何建立bp神經網路預測 模型

建立BP神經網路預測 模型，可按下列步驟進行：

1、提供原始數據

2、訓練數內據預測數據提取及歸一化

3、BP網路容訓練

4、BP網路預測

5、結果分析

現用一個實際的例子，來預測2015年和2016年某地區的人口數。

已知2009年——2014年某地區人口數分別為3583、4150、5062、4628、5270、5340萬人

執行BP_main程序，得到

[ 2015, 5128.631704710423946380615234375]

[ 2016, 5100.5797325642779469490051269531]

代碼及圖形如下。