Python神經網路模型預測人口

❶ BP神經網路——python簡單實現三層神經網路（Numpy）

我們將在Python中創建一個NeuralNetwork類，以訓練神經元以給出准確的預測。該課程還將具有其他幫助程序功能。

1. 應用Sigmoid函數
我們將使用 Sigmoid函數 （它繪制一條「 S」形曲線）作為神經網路的激活函數。

2. 訓練模型
這是我們將教神經網路做出准確預測的階段。每個輸入將具有權重（正或負）。
這意味著具有大量正權重或大量負權重的輸入將對結果輸出產生更大的影響。

我們最初是將每個權重分配給一個隨機數。

本文參考翻譯於此網站 —— 原文

❷ 如何建立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]

代碼及圖形如下。

❸ 從零開始用Python構建神經網路

從零開始用Python構建神經網路
動機：為了更加深入的理解深度學習，我們將使用 python 語言從頭搭建一個神經網路，而不是使用像 Tensorflow 那樣的封裝好的框架。我認為理解神經網路的內部工作原理，對數據科學家來說至關重要。
這篇文章的內容是我的所學，希望也能對你有所幫助。
神經網路是什麼?
介紹神經網路的文章大多數都會將它和大腦進行類比。如果你沒有深入研究過大腦與神經網路的類比，那麼將神經網路解釋為一種將給定輸入映射為期望輸出的數學關系會更容易理解。
神經網路包括以下組成部分
? 一個輸入層，x
? 任意數量的隱藏層
? 一個輸出層，?
? 每層之間有一組權值和偏置，W and b
? 為隱藏層選擇一種激活函數，σ。在教程中我們使用 Sigmoid 激活函數
下圖展示了 2 層神經網路的結構(注意：我們在計算網路層數時通常排除輸入層)

2 層神經網路的結構
用 Python 可以很容易的構建神經網路類

訓練神經網路
這個網路的輸出 ? 為：

你可能會注意到，在上面的等式中，輸出 ? 是 W 和 b 函數。
因此 W 和 b 的值影響預測的准確率. 所以根據輸入數據對 W 和 b 調優的過程就被成為訓練神經網路。
每步訓練迭代包含以下兩個部分:
? 計算預測結果 ?，這一步稱為前向傳播
? 更新 W 和 b,，這一步成為反向傳播
下面的順序圖展示了這個過程：

前向傳播
正如我們在上圖中看到的，前向傳播只是簡單的計算。對於一個基本的 2 層網路來說，它的輸出是這樣的：

我們在 NeuralNetwork 類中增加一個計算前向傳播的函數。為了簡單起見我們假設偏置 b 為0：

但是我們還需要一個方法來評估預測結果的好壞(即預測值和真實值的誤差)。這就要用到損失函數。
損失函數
常用的損失函數有很多種，根據模型的需求來選擇。在本教程中，我們使用誤差平方和作為損失函數。
誤差平方和是求每個預測值和真實值之間的誤差再求和，這個誤差是他們的差值求平方以便我們觀察誤差的絕對值。
訓練的目標是找到一組 W 和 b，使得損失函數最好小，也即預測值和真實值之間的距離最小。
反向傳播
我們已經度量出了預測的誤差(損失)，現在需要找到一種方法來傳播誤差，並以此更新權值和偏置。
為了知道如何適當的調整權值和偏置，我們需要知道損失函數對權值 W 和偏置 b 的導數。
回想微積分中的概念，函數的導數就是函數的斜率。

梯度下降法
如果我們已經求出了導數，我們就可以通過增加或減少導數值來更新權值 W 和偏置 b(參考上圖)。這種方式被稱為梯度下降法。
但是我們不能直接計算損失函數對權值和偏置的導數，因為在損失函數的等式中並沒有顯式的包含他們。因此，我們需要運用鏈式求導發在來幫助計算導數。

鏈式法則用於計算損失函數對 W 和 b 的導數。注意，為了簡單起見。我們只展示了假設網路只有 1 層的偏導數。
這雖然很簡陋，但是我們依然能得到想要的結果—損失函數對權值 W 的導數(斜率)，因此我們可以相應的調整權值。
現在我們將反向傳播演算法的函數添加到 Python 代碼中

為了更深入的理解微積分原理和反向傳播中的鏈式求導法則，我強烈推薦 3Blue1Brown 的如下教程：
Youtube：https://youtu.be/tIeHLnjs5U8
整合並完成一個實例
既然我們已經有了包括前向傳播和反向傳播的完整 Python 代碼，那麼就將其應用到一個例子上看看它是如何工作的吧。

神經網路可以通過學習得到函數的權重。而我們僅靠觀察是不太可能得到函數的權重的。
讓我們訓練神經網路進行 1500 次迭代，看看會發生什麼。 注意觀察下面每次迭代的損失函數，我們可以清楚地看到損失函數單調遞減到最小值。這與我們之前介紹的梯度下降法一致。

讓我們看看經過 1500 次迭代後的神經網路的最終預測結果：

經過 1500 次迭代訓練後的預測結果
我們成功了!我們應用前向和方向傳播演算法成功的訓練了神經網路並且預測結果收斂於真實值。
注意預測值和真實值之間存在細微的誤差是允許的。這樣可以防止模型過擬合並且使得神經網路對於未知數據有著更強的泛化能力。
下一步是什麼?
幸運的是我們的學習之旅還沒有結束，仍然有很多關於神經網路和深度學習的內容需要學習。例如：
? 除了 Sigmoid 以外，還可以用哪些激活函數
? 在訓練網路的時候應用學習率
? 在面對圖像分類任務的時候使用卷積神經網路
我很快會寫更多關於這個主題的內容，敬請期待!
最後的想法
我自己也從零開始寫了很多神經網路的代碼
雖然可以使用諸如 Tensorflow 和 Keras 這樣的深度學習框架方便的搭建深層網路而不需要完全理解其內部工作原理。但是我覺得對於有追求的數據科學家來說，理解內部原理是非常有益的。
這種練習對我自己來說已成成為重要的時間投入，希望也能對你有所幫助

❹ python神經網路編程有什麼用

預測器
神經網路和計算機一樣，對於輸入和輸出都做了一些處理，當我們不知道這些是什麼具體處理的時候，可以使用模型來估計，模型中最重要的就是其中的參數。
對於以前所學的知識都是求出特定的參數，而在這里是使用誤差值的大小去多次指導參數的調整，這就是迭代。
誤差值=真實值-計算值
分類器
預測器是轉換輸入和輸出之間的關系，分類器是將兩類事物劃分開，只是預測器的目的是找到輸出在直線上，分類器是找到輸出分為兩類各在直線的上下方。但其實都是找到一個合適的斜率（只考慮簡單情況下）
分類器中的誤差值E=期望的正確值-基於A的猜測值得到的計算值$ E=t-y \quad E=(ΔA)x $這就是使用誤差值E得到ΔA
ΔA=E/x
，再將ΔA作為調整分界線斜率A的量
但是這樣會存在一個問題，那就是最終改進的直線會與最後一個訓練樣本十分匹配，近視可以認識忽略了之前的訓練樣本，所以要採用一個新的方法：採用ΔA幾分之一的一個變化值，這樣既能解決上面的問題，又可以有節制地抑制錯誤和雜訊的影響，該方法如下
ΔA=L(E/x)
此處的L稱之為調節系數（學習率）
使用學習率可以解決以上問題，但是當數據本身不是由單一線性過程支配時，簡單的線性分類器還是不能實現分類，這個時候就要採用多個線性分類器來劃分（這就是神經網路的核心思想）
神經網路中追蹤信號
對於一個輸入，神經元不會立即反應，而是會抑制輸入，只有當輸入增強到了一定程度，才可以觸發輸出，並且神經元前後層之間是互相連接的。
神經元的輸入和輸出一般採用S函數（sigmoid function）
y=11+e−x
。因為神經元存在多個輸入，所以需要將輸入的總和作為S函數的輸出。要控制最後的輸出結果，最有效的方式就是調整節點之間的連接強度，這就要使用到矩陣點乘。
一般神經網路分為三層，第一層是輸入層，無需任何計算；第二層是隱藏層；最後是輸出層。
總體過程如下：（特別注意：權重矩陣是不一樣的）
1.輸入層接收信號，通過權重比例輸出到隱藏層，此處遵守公式
X=W•I
$$
\begin{pmatrix}
w_{1,1} & w_{2,1}\\
w_{1,2} & w_{2,2}
\end{pmatrix}
\begin{pmatrix}
input1\\
input2
\end{pmatrix}
$$其中W是權重矩陣，I是輸入矩陣，X是組合調節後的信號
2.隱藏層使用S函數（激活函數）對輸入進行處理，然後輸出到輸出層
3.按照同樣的公式，先經過權重的組合調節再適用S函數（激活函數）得到最後的輸出
反向傳播誤差
誤差=期望的輸出值-實際的計算值，所以根據誤差來調整權重。誤差一般使用不等分誤差，就是按照權重的比例分割誤差。
使用權重，將誤差從輸出向後傳播到網路中，被稱為反向傳播。

❺ 如何用神經網路進行時間序列預測

神經網路是可以用來預測時間序列。例如神經網路人口預測。已知1990至2009年的某地區人口數[11 28 30 42 44 56 49 60 50 63 56 74 76 65 92 105 124 117 132 128]。預測2010-2016年的某地區人口數。
具體實施過程：
%已知數據
t=1990:2009;
x=[11 28 30 42 44 56 49 60 50 63 56 74 76 65 92 105 124 117 132 128];
% 自回歸階數
lag=3;
%預測步數為fn
fn=length(t);
%輸出數據
[f_out,iinput]=BP(x,lag,fn); %BP（）神經網路預測函數
[x' iinput']
R2=corrcoef(x,iinput)

%預測年份或某一時間段
%t1=2015:2016;
t1=length(x)+1:length(x)+7;
%預測步數為fn
fn=length(t1);
[f_out,iinput]=BP(x,lag,fn);
P=vpa(f_out,5);
%預測數據
t1=2010:2016;
[t1' P']
% 畫出預測圖
figure(6),plot(t,x,'b*-'),hold on
plot(t(end):t1(end),[iinput(end),f_out],'rp-'),grid on
title('BP神經網路預測某地區人口數')
xlabel('年份'),ylabel('人口數');
legend('2009-2014年人口變化數','2014-2016年人口預測數');

❻ bp神經網路人口預測程序（matlab實現）

x=[54167
55196
56300
57482
58796
60266
61465
62828
64653
65994
67207
66207
65859
67295
69172
70499
72538
74542
76368
78534
80671
82992
85229
87177
89211
90859
92420
93717
94974
96259
97542
98705
100072
101654
103008
104357
105851
107507
109300
111026
112704
114333
115823
117171
118517
119850
121121
122389
123626
124761
125786
126743
127627
128453
129227
129988
130756
131448
132129
132802
134480
135030
135770
136460
137510]';
% 該腳本用來做NAR神經網路預測
% 作者：Macer程
lag=3; % 自回歸階數
iinput=x; % x為原始序列（行向量）
n=length(iinput);

%准備輸入和輸出數據
inputs=zeros(lag,n-lag);
for i=1:n-lag
inputs(:,i)=iinput(i:i+lag-1)';
end
targets=x(lag+1:end);

%創建網路
hiddenLayerSize = 10; %隱藏層神經元個數
net = fitnet(hiddenLayerSize);

% 避免過擬合，劃分訓練，測試和驗證數據的比例
net.divideParam.trainRatio = 70/100;
net.divideParam.valRatio = 15/100;
net.divideParam.testRatio = 15/100;

%訓練網路
[net,tr] = train(net,inputs,targets);
%% 根據圖表判斷擬合好壞
yn=net(inputs);
errors=targets-yn;
figure, ploterrcorr(errors) %繪制誤差的自相關情況（20lags）
figure, parcorr(errors) %繪制偏相關情況
%[h,pValue,stat,cValue]= lbqtest(errors) %Ljung－Box Q檢驗（20lags）
figure,plotresponse(con2seq(targets),con2seq(yn)) %看預測的趨勢與原趨勢
%figure, ploterrhist(errors) %誤差直方圖
%figure, plotperform(tr) %誤差下降線


%% 下面預測往後預測幾個時間段
fn=7; %預測步數為fn。

f_in=iinput(n-lag+1:end)';
f_out=zeros(1,fn); %預測輸出
% 多步預測時，用下面的循環將網路輸出重新輸入
for i=1:fn
f_out(i)=net(f_in);
f_in=[f_in(2:end);f_out(i)];
end
% 畫出預測圖
figure,plot(1949:2013,iinput,'b',2013:2020,[iinput(end),f_out],'r')

圖1自相關

圖3預測

上面的程序是可以通用的，只要你根據自己需要是可以修改用在其他地方的，基本思想就是用前lag年的人口數來預測下一年的人口，至於lag等於幾你是可以自己改的。還有在對結果好壞的判斷中，僅僅看誤差圖是不夠的，如果是一個好的預測，那麼自相關性圖中除了0階自相關外，其他的自相關系數系數都不應該超過上下置信區間。還有其他的統計量和圖表都都寫在」%「後面了，如果需要，去掉就可用。最後的預測值為f_out，我的預測值為

138701.065269972 139467.632609654 140207.209707364 141210.109373609 141981.285378849 142461.332139592 143056.073139776

❼ python 神經網路預測 持續性預測

學習人工智慧時，我給自己定了一個目標－－用Python寫一個簡單的神經網路。為了確保真得理解它，我要求自己不使用任何神經網路庫，從頭寫起。多虧了Andrew Trask寫得一篇精彩的博客，我做到了！下面貼出那九行代碼：在這篇文章中，我將解釋我是如何做得，以便你可以寫出你自己的。我將會提供一個長點的但是更完美的源代碼。

❽ 如何用 Python 構建神經網路擇時模型

import math
import random
random.seed(0)
def rand(a,b): #隨機函數
return (b-a)*random.random()+a
def make_matrix(m,n,fill=0.0):#創建一個指定大小的矩陣
mat = []
for i in range(m):
mat.append([fill]*n)
return mat
#定義sigmoid函數和它的導數
def sigmoid(x):
return 1.0/(1.0+math.exp(-x))
def sigmoid_derivate(x):
return x*(1-x) #sigmoid函數的導數
class BPNeuralNetwork:
def __init__(self):#初始化變數
self.input_n = 0
self.hidden_n = 0
self.output_n = 0
self.input_cells = []
self.hidden_cells = []
self.output_cells = []
self.input_weights = []
self.output_weights = []
self.input_correction = []
self.output_correction = []
#三個列表維護：輸入層，隱含層，輸出層神經元
def setup(self,ni,nh,no):
self.input_n = ni+1 #輸入層+偏置項
self.hidden_n = nh #隱含層
self.output_n = no #輸出層
#初始化神經元
self.input_cells = [1.0]*self.input_n
self.hidden_cells= [1.0]*self.hidden_n
self.output_cells= [1.0]*self.output_n
#初始化連接邊的邊權
self.input_weights = make_matrix(self.input_n,self.hidden_n) #鄰接矩陣存邊權：輸入層->隱藏層
self.output_weights = make_matrix(self.hidden_n,self.output_n) #鄰接矩陣存邊權：隱藏層->輸出層
#隨機初始化邊權：為了反向傳導做准備--->隨機初始化的目的是使對稱失效
for i in range(self.input_n):
for h in range(self.hidden_n):
self.input_weights[i][h] = rand(-0.2 , 0.2) #由輸入層第i個元素到隱藏層第j個元素的邊權為隨機值
for h in range(self.hidden_n):
for o in range(self.output_n):
self.output_weights[h][o] = rand(-2.0, 2.0) #由隱藏層第i個元素到輸出層第j個元素的邊權為隨機值
#保存校正矩陣，為了以後誤差做調整
self.input_correction = make_matrix(self.input_n , self.hidden_n)
self.output_correction = make_matrix(self.hidden_n,self.output_n)
#輸出預測值
def predict(self,inputs):
#對輸入層進行操作轉化樣本
for i in range(self.input_n-1):
self.input_cells[i] = inputs[i] #n個樣本從0~n-1
#計算隱藏層的輸出，每個節點最終的輸出值就是權值*節點值的加權和
for j in range(self.hidden_n):
total = 0.0
for i in range(self.input_n):
total+=self.input_cells[i]*self.input_weights[i][j]
# 此處為何是先i再j，以隱含層節點做大循環，輸入樣本為小循環，是為了每一個隱藏節點計算一個輸出值，傳輸到下一層
self.hidden_cells[j] = sigmoid(total) #此節點的輸出是前一層所有輸入點和到該點之間的權值加權和
for k in range(self.output_n):
total = 0.0
for j in range(self.hidden_n):
total+=self.hidden_cells[j]*self.output_weights[j][k]
self.output_cells[k] = sigmoid(total) #獲取輸出層每個元素的值
return self.output_cells[:] #最後輸出層的結果返回
#反向傳播演算法：調用預測函數，根據反向傳播獲取權重後前向預測，將結果與實際結果返回比較誤差
def back_propagate(self,case,label,learn,correct):
#對輸入樣本做預測
self.predict(case) #對實例進行預測
output_deltas = [0.0]*self.output_n #初始化矩陣
for o in range(self.output_n):
error = label[o] - self.output_cells[o] #正確結果和預測結果的誤差：0,1，-1
output_deltas[o]= sigmoid_derivate(self.output_cells[o])*error#誤差穩定在0~1內
#隱含層誤差
hidden_deltas = [0.0]*self.hidden_n
for h in range(self.hidden_n):
error = 0.0
for o in range(self.output_n):
error+=output_deltas[o]*self.output_weights[h][o]
hidden_deltas[h] = sigmoid_derivate(self.hidden_cells[h])*error
#反向傳播演算法求W
#更新隱藏層->輸出權重
for h in range(self.hidden_n):
for o in range(self.output_n):
change = output_deltas[o]*self.hidden_cells[h]
#調整權重：上一層每個節點的權重學習*變化+矯正率
self.output_weights[h][o] += learn*change + correct*self.output_correction[h][o]
#更新輸入->隱藏層的權重
for i in range(self.input_n):
for h in range(self.hidden_n):
change = hidden_deltas[h]*self.input_cells[i]
self.input_weights[i][h] += learn*change + correct*self.input_correction[i][h]
self.input_correction[i][h] = change
#獲取全局誤差
error = 0.0
for o in range(len(label)):
error = 0.5*(label[o]-self.output_cells[o])**2 #平方誤差函數
return error
def train(self,cases,labels,limit=10000,learn=0.05,correct=0.1):
for i in range(limit): #設置迭代次數
error = 0.0
for j in range(len(cases)):#對輸入層進行訪問
label = labels[j]
case = cases[j]
error+=self.back_propagate(case,label,learn,correct) #樣例，標簽，學習率，正確閾值
def test(self): #學習異或
cases = [
[0, 0],
[0, 1],
[1, 0],
[1, 1],
] #測試樣例
labels = [[0], [1], [1], [0]] #標簽
self.setup(2,5,1) #初始化神經網路：輸入層，隱藏層，輸出層元素個數
self.train(cases,labels,10000,0.05,0.1) #可以更改
for case in cases:
print(self.predict(case))
if __name__ == '__main__':
nn = BPNeuralNetwork()
nn.test()

❾ matlab BP神經網路人口預測，用32個數據每4個為一組，前三個為輸入，進行滾動預測

你最好用優化演算法優化一下，結果肯定會更好，我做過一些這方面的研究，我給你個簡答的遺傳演算法優化BP網路的列子，你可以套用一下，就出來了，同樣是預測：
神經網路遺傳演算法函數極值尋優

%% 清空環境變數
clc
clear

tic
%% 訓練數據預測數據提取及歸一化
%下載輸入輸出數據
load data1 input output

%從1到2000間隨機排序
k=rand(1,4000);
[m,n]=sort(k);

%找出訓練數據和預測數據
input_train=input(n(1:3900),:)';
output_train=output(n(1:3900),:)';
input_test=input(n(3901:4000),:)';
output_test=output(n(3901:4000),:)';

%選連樣本輸入輸出數據歸一化
[inputn,inputps]=mapminmax(input_train);
[outputn,outputps]=mapminmax(output_train);

%% BP網路訓練
% %初始化網路結構
net=newff(inputn,outputn,5);

net.trainParam.epochs=100;
net.trainParam.lr=0.1;
net.trainParam.goal=0.0000004;

%網路訓練
net=train(net,inputn,outputn);

%% BP網路預測
%預測數據歸一化
inputn_test=mapminmax('apply',input_test,inputps);

%網路預測輸出
an=sim(net,inputn_test);

%網路輸出反歸一化
BPoutput=mapminmax('reverse',an,outputps);

%% 結果分析

figure(1)
plot(BPoutput,':og')
hold on
plot(output_test,'-*');
legend('預測輸出','期望輸出','fontsize',12)
title('BP網路預測輸出','fontsize',12)
xlabel('樣本','fontsize',12)
ylabel('輸出','fontsize',12)

%預測誤差
error=BPoutput-output_test;

figure(2)
plot(error,'-*')
title('神經網路預測誤差')

figure(3)
plot((output_test-BPoutput)./BPoutput,'-*');
title('神經網路預測誤差百分比')

errorsum=sum(abs(error))

❿ 如何在Python中用LSTM網路進行時間序列預測

時間序列模型

時間序列預測分析就是利用過去一段時間內某事件時間的特徵來預測未來一段時間內該事件的特徵。這是一類相對比較復雜的預測建模問題，和回歸分析模型的預測不同，時間序列模型是依賴於事件發生的先後順序的，同樣大小的值改變順序後輸入模型產生的結果是不同的。
舉個栗子：根據過去兩年某股票的每天的股價數據推測之後一周的股價變化；根據過去2年某店鋪每周想消費人數預測下周來店消費的人數等等

RNN 和 LSTM 模型

時間序列模型最常用最強大的的工具就是遞歸神經網路（recurrent neural network, RNN）。相比與普通神經網路的各計算結果之間相互獨立的特點，RNN的每一次隱含層的計算結果都與當前輸入以及上一次的隱含層結果相關。通過這種方法，RNN的計算結果便具備了記憶之前幾次結果的特點。

典型的RNN網路結構如下：

4. 模型訓練和結果預測
將上述數據集按4:1的比例隨機拆分為訓練集和驗證集，這是為了防止過度擬合。訓練模型。然後將數據的X列作為參數導入模型便可得到預測值，與實際的Y值相比便可得到該模型的優劣。

實現代碼

這里的輸入數據來源是csv文件，如果輸入數據是來自資料庫的話可以參考這里

這里寫的只涉及LSTM網路的結構搭建，至於如何把數據處理規范化成網路所需的結構以及把模型預測結果與實際值比較統計的可視化，就需要根據實際情況做調整了。