想做预测数据，希望通过算法来得到结果。有可能需要matlab或者python的机器学习（machine learning）等

1. 想做预测数据，希望通过算法来得到结果。有可能需要matlab或者python的机器学习（machine learning）等

你想通过训练来预测数据，一般可以通过BP人工神经网络来实现。


人工神经网络是由若干个神经元相互连接组成一个比较大的并行互联的网络，其结构为拓扑结构。
实现步骤：1、输入和输出数据；2、创建网络；3、划分训练，测试和验证数据的比例设定；4、训练网络；5、根据训练结果，预测未来数据
下图为用BP神经网络预测某地铁线路（14月至17月）客流量图

2. python 神经网络预测 持续性预测

学习人工智能时，我给自己定了一个目标－－用Python写一个简单的神经网络。为了确保真得理解它，我要求自己不使用任何神经网络库，从头写起。多亏了Andrew Trask写得一篇精彩的博客，我做到了！下面贴出那九行代码：在这篇文章中，我将解释我是如何做得，以便你可以写出你自己的。我将会提供一个长点的但是更完美的源代码。

3. 有没有用python实现的遗传算法优化BP神经网络的代码

下面是函数实现的代码部分： 
clc 
clear all 
close all 
%% 加载神经网络的训练样本 测试样本每列一个样本 输入P 输出T，T是标签 
%样本数据就是前面问题描述中列出的数据 
%epochs是计算时根据输出误差返回调整神经元权值和阀值的次数 
load data 
% 初始隐层神经元个数 
hiddennum=31; 
% 输入向量的最大值和最小值 
threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1]; 
inputnum=size(P,1); % 输入层神经元个数 
outputnum=size(T,1); % 输出层神经元个数 
w1num=inputnum*hiddennum; % 输入层到隐层的权值个数 
w2num=outputnum*hiddennum;% 隐层到输出层的权值个数 
N=w1num+hiddennum+w2num+outputnum; %待优化的变量的个数
%% 定义遗传算法参数 
NIND=40; %个体数目 
MAXGEN=50; %最大遗传代数 
PRECI=10; %变量的二进制位数 
GGAP=0.95; %代沟 
px=0.7; %交叉概率 
pm=0.01; %变异概率 
trace=zeros(N+1,MAXGEN); %寻优结果的初始值
FieldD=[repmat(PRECI,1,N);repmat([-0.5;0.5],1,N);repmat([1;0;1;1],1,N)]; %区域描述器 
Chrom=crtbp(NIND,PRECI*N); %初始种群 
%% 优化 
gen=0; %代计数器 
X=bs2rv(Chrom,FieldD); %计算初始种群的十进制转换 
ObjV=Objfun(X,P,T,hiddennum,P_test,T_test); %计算目标函数值 
while gen

4. python进行bp神经网络训练时有没有区分训练和测试样本

a=sim(net,x) 说实话我也菜鸟级别，你看一下最后这个函数能不能用： 其中“a”自己随便可以设的，其实就是个代表返回值 “net”换成你训练好的函数， “x”换成你的输入矩阵

5. 如何用python和scikit learn实现神经网络

1：神经网络算法简介
2：Backpropagation算法详细介绍
3：非线性转化方程举例
4：自己实现神经网络算法NeuralNetwork
5：基于NeuralNetwork的XOR实例
6：基于NeuralNetwork的手写数字识别实例
7：scikit-learn中BernoulliRBM使用实例
8：scikit-learn中的手写数字识别实例

一：神经网络算法简介
1：背景
以人脑神经网络为启发，历史上出现过很多版本，但最著名的是backpropagation
2：多层向前神经网络（Multilayer  Feed-Forward Neural Network）

多层向前神经网络组成部分
输入层（input layer），隐藏层（hiddenlayer），输出层（output layer）

每层由单元（units）组成
输入层（input layer）是由训练集的实例特征向量传入
经过连接结点的权重（weight）传入下一层，一层的输出是下一层的输入
隐藏层的个数是任意的，输出层和输入层只有一个
每个单元（unit）也可以被称作神经结点，根据生物学来源定义
上图称为2层的神经网络（输入层不算）
一层中加权的求和，然后根据非线性的方程转化输出
作为多层向前神经网络，理论上，如果有足够多的隐藏层（hidden layers）和足够大的训练集，可以模拟出任何方程

3：设计神经网络结构
3.1使用神经网络训练数据之前，必须确定神经网络层数，以及每层单元个数
3.2特征向量在被传入输入层时通常被先标准化（normalize）和0和1之间（为了加强学习过程）
3.3离散型变量可以被编码成每一个输入单元对应一个特征可能赋的值
比如：特征值A可能取三个值（a0,a1,a2），可以使用三个输入单元来代表A
如果A=a0,那么代表a0的单元值就取1，其他取0
如果A=a1,那么代表a1的单元值就取1，其他取0，以此类推
3.4神经网络即可以用来做分类（classification）问题，也可以解决回归（regression）问题
3.4.1对于分类问题，如果是2类，可以用一个输入单元表示（0和1分别代表2类）
如果多于两类，每一个类别用一个输出单元表示
所以输入层的单元数量通常等于类别的数量 
3.4.2没有明确的规则来设计最好有多少个隐藏层
3.4.2.1根据实验测试和误差，以及准确度来实验并改进
4：算法验证——交叉验证法（Cross- Validation）


解读： 有一组输入集A,B，可以分成三组，第一次以第一组为训练集，求出一个准确度，第二次以第二组作为训练集，求出一个准确度，求出准确度，第三次以第三组作为训练集，求出一个准确度，然后对三个准确度求平均值
二：Backpropagation算法详细介绍

1：通过迭代性来处理训练集中的实例

2：输入层输入数
经过权重计算得到第一层的数据，第一层的数据作为第二层的输入，再次经过权重计算得到结果，结果和真实值之间是存在误差的，然后根据误差，反向的更新每两个连接之间的权重
3：算法详细介绍
输入：D : 数据集，| 学习率（learning rate），一个多层前向神经网络
输出：一个训练好的神经网络（a trained neural network）
3.1初始化权重（weights）和偏向（bias）：随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有一个偏向
3.2对于每一个训练实例X，执行以下步骤：
3.2.1：由输入层向前传送,输入->输出对应的计算为：


计算得到一个数据，经过f 函数转化作为下一层的输入，f函数为：
3.2.2：根据误差（error）反向传送
对于输出层（误差计算）：  Tj：真实值，Qj表示预测值

对于隐藏层（误差计算）：  Errk 表示前一层的误差， Wjk表示前一层与当前点的连接权重

权重更新：  l：指学习比率（变化率），手工指定，优化方法是，随着数据的迭代逐渐减小

偏向更新：  l：同上
3.3：终止条件
3.3.1权重的更新低于某个阀值
3.3.2预测的错误率低于某个阀值
3.3.3达到预设一定的循环次数



4：结合实例讲解算法



0.9对用的是L，学习率

测试代码如下：
1.NeutralNetwork.py文件代码
#coding:utf-8import numpy as np#定义双曲函数和他们的导数def tanh(x):return np.tanh(x)def tanh_deriv(x):return 1.0 - np.tanh(x)**2def logistic(x):return 1/(1 + np.exp(-x))def logistic_derivative(x):return logistic(x)*(1-logistic(x))#定义NeuralNetwork 神经网络算法class NeuralNetwork:#初始化，layes表示的是一个list，eg[10,10,3]表示第一层10个神经元，第二层10个神经元，第三层3个神经元def __init__(self, layers, activation='tanh'):""":param layers: A list containing the number of units in each layer.Should be at least two values:param activation: The activation function to be used. Can be"logistic" or "tanh""""if activation == 'logistic':self.activation = logisticself.activation_deriv = logistic_derivativeelif activation == 'tanh':self.activation = tanhself.activation_deriv = tanh_derivself.weights = []#循环从1开始，相当于以第二层为基准，进行权重的初始化for i in range(1, len(layers) - 1):#对当前神经节点的前驱赋值self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)#对当前神经节点的后继赋值self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25)#训练函数   ，X矩阵，每行是一个实例 ，y是每个实例对应的结果，learning_rate 学习率，# epochs，表示抽样的方法对神经网络进行更新的最大次数def fit(self, X, y, learning_rate=0.2, epochs=10000):X = np.atleast_2d(X) #确定X至少是二维的数据temp = np.ones([X.shape[0], X.shape[1]+1]) #初始化矩阵temp[:, 0:-1] = X  # adding the bias unit to the input layerX = tempy = np.array(y) #把list转换成array的形式for k in range(epochs):#随机选取一行，对神经网络进行更新i = np.random.randint(X.shape[0])a = [X[i]]#完成所有正向的更新for l in range(len(self.weights)):a.append(self.activation(np.dot(a[l], self.weights[l])))#error = y[i] - a[-1]deltas = [error * self.activation_deriv(a[-1])]#开始反向计算误差，更新权重for l in range(len(a) - 2, 0, -1): # we need to begin at the second to last layerdeltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))deltas.reverse()for i in range(len(self.weights)):layer = np.atleast_2d(a[i])delta = np.atleast_2d(deltas[i])self.weights[i] += learning_rate * layer.T.dot(delta)#预测函数def predict(self, x):x = np.array(x)temp = np.ones(x.shape[0]+1)temp[0:-1] = xa = tempfor l in range(0, len(self.weights)):a = self.activation(np.dot(a, self.weights[l]))return a
2、测试代码
#coding:utf-8'''#基于NeuralNetwork的XOR（异或）示例import numpy as npfrom NeuralNetwork import NeuralNetworknn = NeuralNetwork([2,2,1], 'tanh')X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])y = np.array([0, 1, 1, 0])nn.fit(X, y)for i in [[0, 0], [0, 1], [1, 0], [1,1]]:print(i,nn.predict(i))''''''#基于NeuralNetwork的手写数字识别示例import numpy as npfrom sklearn.datasets import load_digitsfrom sklearn.metrics import confusion_matrix,classification_reportfrom sklearn.preprocessing import LabelBinarizerfrom sklearn.cross_validation import train_test_splitfrom NeuralNetwork import NeuralNetworkdigits = load_digits()X = digits.datay = digits.targetX -= X.min()X /= X.max()nn =NeuralNetwork([64,100,10],'logistic')X_train, X_test, y_train, y_test = train_test_split(X, y)labels_train = LabelBinarizer().fit_transform(y_train)labels_test = LabelBinarizer().fit_transform(y_test)print "start fitting"nn.fit(X_train,labels_train,epochs=3000)predictions = []for i in range(X_test.shape[0]):o = nn.predict(X_test[i])predictions.append(np.argmax(o))print confusion_matrix(y_test, predictions)print classification_report(y_test, predictions)'''#scikit-learn中的手写数字识别实例import numpy as npimport matplotlib.pyplot as pltfrom scipy.ndimage import convolvefrom sklearn import linear_model, datasets, metricsfrom sklearn.cross_validation import train_test_splitfrom sklearn.neural_network import BernoulliRBMfrom sklearn.pipeline import Pipeline################################################################################ Setting updef nudge_dataset(X, Y):direction_vectors = [[[0, 1, 0],[0, 0, 0],[0, 0, 0]],[[0, 0, 0],[1, 0, 0],[0, 0, 0]],[[0, 0, 0],[0, 0, 1],[0, 0, 0]],[[0, 0, 0],[0, 0, 0],[0, 1, 0]]]shift = lambda x, w: convolve(x.reshape((8, 8)), mode='constant',weights=w).ravel()X = np.concatenate([X] +[np.apply_along_axis(shift, 1, X, vector)for vector in direction_vectors])Y = np.concatenate([Y for _ in range(5)], axis=0)return X, Y# Load Datadigits = datasets.load_digits()X = np.asarray(digits.data, 'float32')X, Y = nudge_dataset(X, digits.target)X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001)  # 0-1 scalingX_train, X_test, Y_train, Y_test = train_test_split(X, Y,test_size=0.2,random_state=0)# Models we will uselogistic = linear_model.LogisticRegression()rbm = BernoulliRBM(random_state=0, verbose=True)classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])################################################################################ Training# Hyper-parameters. These were set by cross-validation,# using a GridSearchCV. Here we are not performing cross-validation to# save time.rbm.learning_rate = 0.06rbm.n_iter = 20# More components tend to give better prediction performance, but larger# fitting timerbm.n_components = 100logistic.C = 6000.0# Training RBM-Logistic Pipelineclassifier.fit(X_train, Y_train)# Training Logistic regressionlogistic_classifier = linear_model.LogisticRegression(C=100.0)logistic_classifier.fit(X_train, Y_train)################################################################################ Evaluationprint()print("Logistic regression using RBM features:\n%s\n" % (metrics.classification_report(Y_test,classifier.predict(X_test))))print("Logistic regression using raw pixel features:\n%s\n" % (metrics.classification_report(Y_test,logistic_classifier.predict(X_test))))################################################################################ Plottingplt.figure(figsize=(4.2, 4))for i, comp in enumerate(rbm.components_):plt.subplot(10, 10, i + 1)plt.imshow(comp.reshape((8, 8)), cmap=plt.cm.gray_r,interpolation='nearest')plt.xticks(())plt.yticks(())plt.suptitle('100 components extracted by RBM', fontsize=16)plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)plt.show()'''from sklearn.neural_network import BernoulliRBMX = [[0,0],[1,1]]y = [0,1]clf = BernoulliRBM().fit(X,y)print
测试结果如下：

6. python 神经网络库有哪些

学习人工智能时，我给自己定了一个目标－－用Python写一个简单的神经网络。为了确保真得理解它，我要求自己不使用任何神经网络库，从头写起。多亏了Andrew Trask写得一篇精彩的博客，我做到了！下面贴出那九行代码：


在这篇文章中，我将解释我是如何做得，以便你可以写出你自己的。我将会提供一个长点的但是更完美的源代码。
首先，神经网络是什么？人脑由几千亿由突触相互连接的细胞（神经元）组成。突触传入足够的兴奋就会引起神经元的兴奋。这个过程被称为“思考”。

我们可以在计算机上写一个神经网络来模拟这个过程。不需要在生物分子水平模拟人脑，只需模拟更高层级的规则。我们使用矩阵（二维数据表格）这一数学工具，并且为了简单明了，只模拟一个有3个输入和一个输出的神经元。

我们将训练神经元解决下面的问题。前四个例子被称作训练集。你发现规律了吗？‘？’是0还是1？

你可能发现了，输出总是等于输入中最左列的值。所以‘？’应该是1。
训练过程
但是如何使我们的神经元回答正确呢？赋予每个输入一个权重，可以是一个正的或负的数字。拥有较大正（或负）权重的输入将决定神经元的输出。首先设置每个权重的初始值为一个随机数字，然后开始训练过程：
取一个训练样本的输入，使用权重调整它们，通过一个特殊的公式计算神经元的输出。
计算误差，即神经元的输出与训练样本中的期待输出之间的差值。
根据误差略微地调整权重。
重复这个过程1万次。

最终权重将会变为符合训练集的一个最优解。如果使用神经元考虑这种规律的一个新情形，它将会给出一个很棒的预测。
这个过程就是back propagation。

计算神经元输出的公式
你可能会想，计算神经元输出的公式是什么？首先，计算神经元输入的加权和，即

接着使之规范化，结果在0，1之间。为此使用一个数学函数－－Sigmoid函数：


Sigmoid函数的图形是一条“S”状的曲线。

把第一个方程代入第二个，计算神经元输出的最终公式为：

你可能注意到了，为了简单，我们没有引入最低兴奋阈值。
调整权重的公式
我们在训练时不断调整权重。但是怎么调整呢？可以使用“Error Weighted Derivative”公式：

为什么使用这个公式？首先，我们想使调整和误差的大小成比例。其次，乘以输入（0或1），如果输入是0，权重就不会调整。最后，乘以Sigmoid曲线的斜率（图4）。为了理解最后一条，考虑这些：
我们使用Sigmoid曲线计算神经元的输出
如果输出是一个大的正（或负）数，这意味着神经元采用这种（或另一种）方式
从图四可以看出，在较大数值处，Sigmoid曲线斜率小
如果神经元认为当前权重是正确的，就不会对它进行很大调整。乘以Sigmoid曲线斜率便可以实现这一点
Sigmoid曲线的斜率可以通过求导得到：

把第二个等式代入第一个等式里，得到调整权重的最终公式：

当然有其他公式，它们可以使神经元学习得更快，但是这个公式的优点是非常简单。
构造Python代码
虽然我们没有使用神经网络库，但是将导入Python数学库numpy里的4个方法。分别是：
exp－－自然指数
array－－创建矩阵
dot－－进行矩阵乘法
random－－产生随机数
比如， 我们可以使用array()方法表示前面展示的训练集：

“.T”方法用于矩阵转置（行变列）。所以，计算机这样存储数字：

我觉得我们可以开始构建更优美的源代码了。给出这个源代码后，我会做一个总结。
我对每一行源代码都添加了注释来解释所有内容。注意在每次迭代时，我们同时处理所有训练集数据。所以变量都是矩阵（二维数据表格）。下面是一个用Python写地完整的示例代码。



结语
试着在命令行运行神经网络：

你应该看到这样的结果：

我们做到了！我们用Python构建了一个简单的神经网络！
首先神经网络对自己赋予随机权重，然后使用训练集训练自己。接着，它考虑一种新的情形[1, 0, 0]并且预测了0.99993704。正确答案是1。非常接近！
传统计算机程序通常不会学习。而神经网络却能自己学习，适应并对新情形做出反应，这是多么神奇，就像人类一样。

7. python，keras如何输出神经网络的权重

#the name of your model `model`model.save("my_mode.h5") #保存模型#保存模型的结构，而不包含其权重或配置信息json_string = model.to_json()#保存模型的权重model.save_weights('my_model_weights.h5')

8. 如何用9行Python代码编写一个简易神经网络

　　学习人工智能时，我给自己定了一个目标－－用Python写一个简单的神经网络。为了确保真得理解它，我要求自己不使用任何神经网络库，从头写起。多亏了Andrew Trask写得一篇精彩的博客，我做到了！下面贴出那九行代码：

　　

　　在这篇文章中，我将解释我是如何做得，以便你可以写出你自己的。我将会提供一个长点的但是更完美的源代码。

　　首先，神经网络是什么？人脑由几千亿由突触相互连接的细胞（神经元）组成。突触传入足够的兴奋就会引起神经元的兴奋。这个过程被称为“思考”。

　　

　　我们可以在计算机上写一个神经网络来模拟这个过程。不需要在生物分子水平模拟人脑，只需模拟更高层级的规则。我们使用矩阵（二维数据表格）这一数学工具，并且为了简单明了，只模拟一个有3个输入和一个输出的神经元。

　　我们将训练神经元解决下面的问题。前四个例子被称作训练集。你发现规律了吗？‘？’是0还是1？

　　

　　你可能发现了，输出总是等于输入中最左列的值。所以‘？’应该是1。

　　训练过程

　　但是如何使我们的神经元回答正确呢？赋予每个输入一个权重，可以是一个正的或负的数字。拥有较大正（或负）权重的输入将决定神经元的输出。首先设置每个权重的初始值为一个随机数字，然后开始训练过程：

　　取一个训练样本的输入，使用权重调整它们，通过一个特殊的公式计算神经元的输出。

　　计算误差，即神经元的输出与训练样本中的期待输出之间的差值。

　　根据误差略微地调整权重。

　　重复这个过程1万次。

　　

　　最终权重将会变为符合训练集的一个最优解。如果使用神经元考虑这种规律的一个新情形，它将会给出一个很棒的预测。

　　这个过程就是back propagation。

　　计算神经元输出的公式

　　你可能会想，计算神经元输出的公式是什么？首先，计算神经元输入的加权和，即

　　

　　接着使之规范化，结果在0，1之间。为此使用一个数学函数－－Sigmoid函数：

　　

　　Sigmoid函数的图形是一条“S”状的曲线。

　　

　　把第一个方程代入第二个，计算神经元输出的最终公式为：

　　

　　你可能注意到了，为了简单，我们没有引入最低兴奋阈值。

　　调整权重的公式

　　我们在训练时不断调整权重。但是怎么调整呢？可以使用“Error Weighted Derivative”公式：

　　

　　为什么使用这个公式？首先，我们想使调整和误差的大小成比例。其次，乘以输入（0或1），如果输入是0，权重就不会调整。最后，乘以Sigmoid曲线的斜率（图4）。为了理解最后一条，考虑这些：

　　我们使用Sigmoid曲线计算神经元的输出

　　如果输出是一个大的正（或负）数，这意味着神经元采用这种（或另一种）方式

　　从图四可以看出，在较大数值处，Sigmoid曲线斜率小

　　如果神经元认为当前权重是正确的，就不会对它进行很大调整。乘以Sigmoid曲线斜率便可以实现这一点

　　Sigmoid曲线的斜率可以通过求导得到：

　　

　　把第二个等式代入第一个等式里，得到调整权重的最终公式：

　　

　　当然有其他公式，它们可以使神经元学习得更快，但是这个公式的优点是非常简单。

　　构造Python代码

　　虽然我们没有使用神经网络库，但是将导入Python数学库numpy里的4个方法。分别是：

　　exp－－自然指数

　　array－－创建矩阵

　　dot－－进行矩阵乘法

　　random－－产生随机数

　　比如， 我们可以使用array()方法表示前面展示的训练集：

　　

　　“.T”方法用于矩阵转置（行变列）。所以，计算机这样存储数字：

　　

　　我觉得我们可以开始构建更优美的源代码了。给出这个源代码后，我会做一个总结。

　　我对每一行源代码都添加了注释来解释所有内容。注意在每次迭代时，我们同时处理所有训练集数据。所以变量都是矩阵（二维数据表格）。下面是一个用Python写地完整的示例代码。




　　我们做到了！我们用Python构建了一个简单的神经网络！

　　首先神经网络对自己赋予随机权重，然后使用训练集训练自己。接着，它考虑一种新的情形[1, 0, 0]并且预测了0.99993704。正确答案是1。非常接近！

　　传统计算机程序通常不会学习。而神经网络却能自己学习，适应并对新情形做出反应，这是多么神奇，就像人类一样。