⑴ 轻松体验TensorFlow 第一个神经网络：基本分类（Part 1）
关于 Jupyter Notebook 的使用，可以参考如下链接，有详细的步骤和截图：
Jupyter Notebook神器-免费体验来自微软的Azure Notebook
基于Jupyter Notebook 快速体验Python和plot()绘图方法
基于Jupyter Notebook 快速体验matplotlib.pyplot模块中绘图方法
TensorFlow 基本分类（basic classification）演示的完整代码，可以访问：
上述命令运行时间较长，请耐心等待。
pip list 命令用来查看当前环境下的Python 包，grep 命令用来查找和筛选。中间的竖线表示 pipe（管道），将pip list 命令的输出作为 grep 命令的输入。
pip 前面的感叹号是cell 中运行 Linux 命令的方式，在命令行中运行则不需要加感叹号。
上述命令的输出，表示当前环境已经安装好了 TensorFlow 包。如果没有安装，可以通过如下命令安装：
安装TensorFlow命令，说明如下：
本地安装TensorFlow，截图如下。
TensorFlow 安装完成：
下面训练了一个神经网络模型，来对服装图像进行分类，例如运动鞋和衬衫。需要使用tf.keras，这是一个用于在TensorFlow 中构建和训练模型的高级API。
下面使用Fashion MNIST 数据集，其中包含了10个类别中共70,000张灰度图像。图像包含了低分辨率（28 x 28像素）的单个服装物品，图片链接如下所示:
Fashion-MNIST是一个替代MNIST手写数字集的图像数据集。 它是由Zalando（一家德国的 时尚 科技 公司）旗下的研究部门提供。其涵盖了来自10种类别的共7万个不同商品的正面图片。Fashion-MNIST的大小、格式和训练集/测试集划分与原始的MNIST完全一致。60000/10000的训练测试数据划分，28x28的灰度图片。可以直接用它来测试你的机器学习和深度学习算法性能，且不需要改动任何的代码。
MNIST是 Mixed National Institute of Standards and Technology database 的简写。
下面使用60,000张图像来训练网络和10,000张图像来评估网络模型学习图像分类任务的准确程度。
可以直接从TensorFlow 使用Fashion MNIST，只需导入并加载数据。
加载数据集并返回四个NumPy数组:
图像是28x28 NumPy数组，像素值介于0到255之间。labels是一个整数数组，数值介于0到9之间。
下面是图像类别和标签的对应关系：
每个图像都映射到一个标签。由于类别名称不包含在数据集中，因此把他们存储在这里以便在绘制图像时使用:
以下显示训练集中有60,000个图像，每个图像表示为28 x 28像素：
训练集中有 60000个标签，并且每个标签都是0-9 之间的整数。
测试集和训练集类似，有10000个图像和对应的10000个图像标签。
在训练网络之前必须对数据进行预处理。 如果检查训练集中的第一个图像，将看到像素值落在0到255的范围内：
代码说明：
plt.figure() 创建一个新的figure。
plt.colorbar() 方法用来显示当前image 的颜色方案。
在发送到神经网络模型之前，我们将这些值缩放到0到1的范围（归一化处理）。为此，我们将像素值值除以255。重要的是，对训练集和测试集要以相同的方式进行预处理:
显示训练集中的前25个图像，并在每个图像下方显示类别名。验证数据格式是否正确，我们是否已准备好构建和训练网络。
代码说明：
plt.xticks([])和plt.yticks([]) - 以空list 作为xticks() 方法的参数，查看数据集中图像隐藏坐标轴。
plt.xlabel() 方法可以在 x 轴的下方显示指定文本。
plt.subplot(5,5,1) 方法 - 表示5行5列共25个位置，最后一个参数1 表示Axes的位置，第一行的位置编号为：1-5，第二行的位置编号为：6-10，依此类推。
上述代码遍历了25 个位置（for i in range(25)），批量显示多张图。针对每一个位置，设置隐藏x和y轴，不显示网关线（grid），在对应的位置显示图像以及类别（label）。
需要注意的地方：Axes 位置的起始值是1，不是常见的0。
对TensorFlow 深度学习有兴趣的同学，可以访问如下链接。
⑵ 怎么用spss神经网络来分类数据
用spss神经网络分类数据方法如下：
神经网络算法能够通过大量的历史数据，逐步建立和完善输入变量到输出结果之间的发展路径，也就是神经网络，在这个神经网络中，每条神经的建立以及神经的粗细（权重）都是经过大量历史数据训练得到的，数据越多，神经网络就越接近真实。神经网络建立后，就能够通过不同的输入变量值，预测输出结果。例如，银行能够通过历史申请贷款的客户资料，建立一个神经网络模型，用于预测以后申请贷款客户的违约情况，做出是否贷款给该客户的决策。本篇文章将用一个具体银行案例数据，介绍如何使用SPSS建立神经网络模型，用于判断将来申请贷款者的还款能力。
选取历史数据建立模型，一般会将历史数据分成两大部分：训练集和验证集，很多分析者会直接按照数据顺序将前70%的数据作为训练集，后30%的数据作为验证集。如果数据之间可以证明是相互独立的，这样的做法没有问题，但是在数据收集的过程中，收集的数据往往不会是完全独立的（变量之间的相关关系可能没有被分析者发现）。因此，通常的做法是用随机数发生器来将历史数据随机分成两部分，这样就能够尽量避免相同属性的数据被归类到一个数据集当中，使得建立的模型效果能够更加优秀。
在具体介绍如何使用SPSS软件建立神经网络模型的案例之前，先介绍SPSS的另外一个功能：随机数发生器。SPSS的随机数发生器常数的随机数据不是真正的随机数，而是伪随机数。伪随机数是由算法计算得出的，因此是可以预测的。当随机种子（算法参数）相同时，对于同一个随机函数，得出的随机数集合是完全相同的。与伪随机数对应的是真随机数，它是真正的随机数，无法预测也没有周期性。目前大部分芯片厂商都集成了硬件随机数发生器，例如有一种热噪声随机数发生器，它的原理是利用由导体中电子的热震动引起的热噪声信号，作为随机数种子。
⑶ 用最简单的神经网络做数据分类，展示神经网络训练过程
本文用简单的神经网络做数据分类，展示神经网络训练过程，伏薯方便理解缺锋者
神经网络模型：Y = w1 x1 + w2 x2 + b
第一步 ：生成训练数据与标签
第二步 ：合并数据并将数据打乱，然后将数据转换为Paddle框架基知所需要的数据类型
第三步 ，基于Paddle，构建神经网络、定义损失函数和优化器：Y = w1 x1 + w2 x2 + b
第四步 ，构建训练过程
最后一步 ，绘制训练结果
⑷ 神经网络的数据量多少比较合适
一般来说要1万以上，越多越好，但要保证采集标准统一，且输出为相同的数据不能太多。
⑸ 200组数据可以训练神经网络吗
不行
神经网络的数据需要1000个以上，其中训练样本至少700以上，验证样本至少300以上。
⑹ 神经网络分类问题
神经网络是新技术领域中的一个时尚词汇。很多人听过这个词，但很少人真正明白它是什么。本文的目的是介绍所有关于神经网络的基本包括它的功能、一般结构、相关术语、类型及其应用。
“神经网络”这个词实际是来自于生物学，而我们所指的神经网络正确的名称应该是“人工神经网络（ANNs）”。在本文，我会同时使用这两个互换的术语。
一个真正的神经网络是由数个至数十亿个被称为神经元的细胞（组成我们大脑的微小细胞）所组成，它们以不同方式连接而型成网络。人工神经网络就是尝试模拟这种生物学上的体系结构及其操作。在这里有一个难题：我们对生物学上的神经网络知道的不多！因此，不同类型之间的神经网络体系结构有很大的不同，我们所知道的只是神经元基本的结构。
The neuron
--------------------------------------------------------------------------------
虽然已经确认在我们的大脑中有大约50至500种不同的神经元，但它们大部份都是基于基本神经元的特别细胞。基本神经元包含有synapses、soma、axon及dendrites。Synapses负责神经元之间的连接，它们不是直接物理上连接的，而是它们之间有一个很小的空隙允许电子讯号从一个神经元跳到另一个神经元。然后这些电子讯号会交给soma处理及以其内部电子讯号将处理结果传递给axon。而axon会将这些讯号分发给dendrites。最后，dendrites带着这些讯号再交给其它的synapses，再继续下一个循环。
如同生物学上的基本神经元，人工的神经网络也有基本的神经元。每个神经元有特定数量的输入，也会为每个神经元设定权重（weight）。权重是对所输入的资料的重要性的一个指标。然后，神经元会计算出权重合计值（net value），而权重合计值就是将所有输入乘以它们的权重的合计。每个神经元都有它们各自的临界值（threshold），而当权重合计值大于临界值时，神经元会输出1。相反，则输出0。最后，输出会被传送给与该神经元连接的其它神经元继续剩余的计算。
Learning
--------------------------------------------------------------------------------
正如上述所写，问题的核心是权重及临界值是该如何设定的呢？世界上有很多不同的训练方式，就如网络类型一样多。但有些比较出名的包括back-propagation, delta rule及Kohonen训练模式。
由于结构体系的不同，训练的规则也不相同，但大部份的规则可以被分为二大类别 - 监管的及非监管的。监管方式的训练规则需要“教师”告诉他们特定的输入应该作出怎样的输出。然后训练规则会调整所有需要的权重值（这是网络中是非常复杂的），而整个过程会重头开始直至数据可以被网络正确的分析出来。监管方式的训练模式包括有back-propagation及delta rule。非监管方式的规则无需教师，因为他们所产生的输出会被进一步评估。
Architecture
--------------------------------------------------------------------------------
在神经网络中，遵守明确的规则一词是最“模糊不清”的。因为有太多不同种类的网络，由简单的布尔网络（Perceptrons），至复杂的自我调整网络（Kohonen），至热动态性网络模型（Boltzmann machines）！而这些，都遵守一个网络体系结构的标准。
一个网络包括有多个神经元“层”，输入层、隐蔽层及输出层。输入层负责接收输入及分发到隐蔽层（因为用户看不见这些层，所以见做隐蔽层）。这些隐蔽层负责所需的计算及输出结果给输出层，而用户则可以看到最终结果。现在，为免混淆，不会在这里更深入的探讨体系结构这一话题。对于不同神经网络的更多详细资料可以看Generation5 essays
尽管我们讨论过神经元、训练及体系结构，但我们还不清楚神经网络实际做些什么。
The Function of ANNs
--------------------------------------------------------------------------------
神经网络被设计为与图案一起工作 - 它们可以被分为分类式或联想式。分类式网络可以接受一组数，然后将其分类。例如ONR程序接受一个数字的影象而输出这个数字。或者PPDA32程序接受一个坐标而将它分类成A类或B类（类别是由所提供的训练决定的）。更多实际用途可以看Applications in the Military中的军事雷达，该雷达可以分别出车辆或树。
联想模式接受一组数而输出另一组。例如HIR程序接受一个‘脏’图像而输出一个它所学过而最接近的一个图像。联想模式更可应用于复杂的应用程序，如签名、面部、指纹识别等。
The Ups and Downs of Neural Networks
--------------------------------------------------------------------------------
神经网络在这个领域中有很多优点，使得它越来越流行。它在类型分类/识别方面非常出色。神经网络可以处理例外及不正常的输入数据，这对于很多系统都很重要（例如雷达及声波定位系统）。很多神经网络都是模仿生物神经网络的，即是他们仿照大脑的运作方式工作。神经网络也得助于神经系统科学的发展，使它可以像人类一样准确地辨别物件而有电脑的速度！前途是光明的，但现在...
是的，神经网络也有些不好的地方。这通常都是因为缺乏足够强大的硬件。神经网络的力量源自于以并行方式处理资讯，即是同时处理多项数据。因此，要一个串行的机器模拟并行处理是非常耗时的。
神经网络的另一个问题是对某一个问题构建网络所定义的条件不足 - 有太多因素需要考虑：训练的算法、体系结构、每层的神经元个数、有多少层、数据的表现等，还有其它更多因素。因此，随着时间越来越重要，大部份公司不可能负担重复的开发神经网络去有效地解决问题。
Conclusion
--------------------------------------------------------------------------------
希望您可以通过本文对神经网络有基本的认识。Generation5现在有很多关于神经网络的资料可以查阅，包括文章及程序。我们有Hopfield、perceptrons（2个）网络的例子，及一些back-propagation个案研究。
Glossary
--------------------------------------------------------------------------------
NN 神经网络，Neural Network
ANNs 人工神经网络，Artificial Neural Networks
neurons 神经元
synapses 神经键
self-organizing networks 自我调整网络
networks modelling thermodynamic properties 热动态性网络模型
⑺ BP神经网络的训练集需要大样本吗一般样本个数为多少
BP神经网络的训练集需要大样本吗？一般样本个数为多少？
BP神经网络样本数有什么影响
学习神经网络这段时间，有一个疑问，BP神经网络中训练的次数指的网络的迭代次数，如果有a个样本,每个样本训练次数n，则网络一共迭代an次，在n>>a 情况下 ， 网络在不停的调整权值，减小误差，跟样本数似乎关系不大。而且，a大了的话训练时间必然会变长。
换一种说法，将你的数据集看成一个固定值， 那么样本集与测试集 也可以按照某种规格确定下来如7：3 所以如何看待 样本集的多少与训练结果呢？ 或者说怎么使你的网络更加稳定，更加符合你的所需 。
我尝试从之前的一个例子中看下区别
如何用70行Java代码实现深度神经网络算法
作者其实是实现了一个BP神经网络 ，不多说，看最后的例子
一个运用神经网络的例子
最后我们找个简单例子来看看神经网络神奇的效果。为了方便观察数据分布，我们选用一个二维坐标的数据，下面共有4个数据，方块代表数据的类型为1，三角代表数据的类型为0，可以看到属于方块类型的数据有（1，2）和（2，1），属于三角类型的数据有（1，1），（2，2），现在问题是需要在平面上将4个数据分成1和0两类，并以此来预测新的数据的类型。
图片描述
我们可以运用逻辑回归算法来解决上面的分类问题，但是逻辑回归得到一个线性的直线做为分界线，可以看到上面的红线无论怎么摆放，总是有一个样本被错误地划分到不同类型中，所以对于上面的数据，仅仅一条直线不能很正确地划分他们的分类，如果我们运用神经网络算法，可以得到下图的分类效果，相当于多条直线求并集来划分空间，这样准确性更高。
图片描述
简单粗暴，用作者的代码运行后 训练5000次 。根据训练结果来预测一条新数据的分类（3,1）
预测值 （3,1）的结果跟（1,2）（2,1）属于一类 属于正方形
这时如果我们去掉 2个样本，则样本输入变成如下
//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1}};
1
2
3
4
1
2
3
4
则（3,1）结果变成了三角形，
如果你选前两个点 你会发现直接一条中间线就可以区分 这时候的你的结果跟之前4个点时有区别 so 你得增加样本 直到这些样本按照你所想要的方式分类 ，所以样本的多少 重要性体现在，样本得能反映所有的特征值（也就是输入值） ，样本多少或者特征（本例子指点的位置特征）决定的你的网络的训练结果，！！！这是 我们反推出来的结果 。这里距离深度学习好像近了一步。
另外，这个70行代码的神经网络没有保存你训练的网络 ，所以你每次运行都是重新训练的网络。其实，在你训练过后 权值已经确定了下来，我们确定网络也就是根据权值，so只要把训练后的权值保存下来，将需要分类的数据按照这种权值带入网络，即可得到输出值，也就是一旦网络确定， 权值也就确定，一个输入对应一个固定的输出，不会再次改变！个人见解。
最后附上作者的源码，作者的文章见开头链接
下面的实现程序BpDeep.java可以直接拿去使用，
import java.util.Random;
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数
public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;l<layernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1<layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;j<layernum[l]+1;j++)
for(int i=0;i<layernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
}
}
}
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;l<layer.length;l++){
for(int j=0;j<layer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;i<layer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;j<layerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);
while(l-->0){
for(int j=0;j<layerErr[l].length;j++){
double z = 0.0;
for(int i=0;i<layerErr[l+1].length;i++){
z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
}
}
}
public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
下面是这个测试程序BpDeepTest.java的源码：
import java.util.Arrays;
public class BpDeepTest{
public static void main(String[] args){
//初始化神经网络的基本配置
//第一个参数是一个整型数组，表示神经网络的层数和每层节点数，比如{3,10,10,10,10,2}表示输入层是3个节点，输出层是2个节点，中间有4层隐含层，每层10个节点
//第二个参数是学习步长，第三个参数是动量系数
BpDeep bp = new BpDeep(new int[]{2,10,2}, 0.15, 0.8);
//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2},{1,1},{2,1}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1},{0,1},{1,0}};
//迭代训练5000次
for(int n=0;n<5000;n++)
for(int i=0;i<data.length;i++)
bp.train(data[i], target[i]);
//根据训练结果来检验样本数据
for(int j=0;j<data.length;j++){
double[] result = bp.computeOut(data[j]);
System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
}
//根据训练结果来预测一条新数据的分类
double[] x = new double[]{3,1};
double[] result = bp.computeOut(x);
System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
}
}
⑻ bp神经网络只有一类样本怎么分类
神经网络一列为一个样本，所以对于matlab 而言，要求输入和输出的列数必须一样的
经常有人问起的问题：
Error using ==> network/train
Targets are incorrectly sized for network.
Matrix must have 1 rows.
解决：要求P T 的列数一样 ，如果不一样 P=p’ t=t’ 转置一下
2.
归一
澄清一个对归一的错误理解1
样本矩阵为9行4列。9组样本，4个变量。现在归一化：
x=[68.7 66.6 5610 19.2;
89.9 90.8 4500 11.8;
120.8 120.6 6800 20.6;
169 40.4 6160 40.6;
180.8 69.8 7330 33.4;
190.3 130.2 7320 31.6;
109.8 151.1 5754 86.1;
33.2 61.4 8255 22.6;
111.7 126.6 7040 13.6;]
写法一：
for i=1:9
x1(i,:)=(x(i,:)-min(x(i,:)))/(max(x(i,:))-min(x(i,:)))
end
结果：
0.0089 0.0085 1.0000 0
0.0174 0.0176 1.0000 0
0.0148 0.0148 1.0000 0
0.0210 0 1.0000 0.0000
0.0202 0.0050 1.0000 0
0.0218 0.0135 1.00 00 0
0.0042 0.0115 1.0000 0
0.0013 0.0047 1.0000 0
0.0140 0.0161 1.0000 0
写法二：
x=x'
for i=1:4
x1(i,:)=(x(i,:)-min(x(i,:)))/(max(x(i,:))-min(x(i,:)))
end
结果：
Columns 1 through 8
0.2260 0.3609 0.5576 0.8644 0.9395 1.0000 0.4876 0
0.2367 0.4553 0.7245 0 0.2656 0.8112 1.0000 0.1897
0.2956 0 0.6125 0.4421 0.7537 0.7510 0.3340 1.0000
0.0996 0 0.1184 0.3876 0.2907 0.2665 1.0000 0.1454
Column 9
0.4997
0.7787
0.6764
0.0242
注意：写法2为正确的归一化
对归一的错误理解2
将数据集分为训练集和测试集，对训练集和测试集分别做归一处理
所以就会有人问 如果我的测试集只有一个数据 如何归一呀
最大最小值从那里找呀
正确的理解是：
训练集和测试集的归一标准是一样的
建议：
如果训练集和测试集是一起归一的 可以自己编程实现归一
如果是训练集和测试集是分开的，最好是使用matlab自带的premnmx、postmnmx、tramnmx 函数
如果是自己编程的话 ，请注意训练集和测试集的归一标准需要一样
premnmx、postmnmx、tramnmx 函数
的使用例子如下：
Example
Here is the code to normalize a given data set so
that the inputs and targets will fall in the
range [-1,1], using PREMNMX, and the code to train a network
with the normalized data.
p = [-10 -7.5 -5 -2.5 0 2.5 5 7.5 10];
t = [0 7.07 -10 -7.07 0 7.07 10 7.07 0];
[pn,minp,maxp,tn,mint,maxt] = premnmx(p,t);
net = newff(minmax(pn),[5 1],{'tansig' 'purelin'},'trainlm');
net = train(net,pn,tn);
If we then receive new inputs to apply to the trained
network, we will use TRAMNMX to transform them
first. Then the transformed inputs can be used
to simulate the previously trained network. The
network output must also be unnormalized using
POSTMNMX.
p2 = [4 -7];
[p2n] = tramnmx(p2,minp,maxp);
an = sim(net,pn);
[a] = postmnmx(an,mint,maxt);
这个是归一到-1 和 1 之间 那我要归一到0 1 之间怎么办
有人说可以使用加绝对值就归一到 0 1之间了
我觉得加绝对值可能会有些问题
比较好的方式是变换
P 在-1 1 之间
Pp=(p+1)/2 就可以归一到0 1之间
至于要归一到0.1- 0.9 之间 选取合适的变换就可以做到了
二、神经网络(BP)系列(2)(初学者系列)每次结果不一样解析
这个系列主要针对使用matlab 神经网络工具箱，对一些初学者容易理解错误的地方进行解析。
神经网络每次结果不同解析
神经网络每次结果不同是因为初始化的权值和阈值是随机的
因为每次的结果不一样，才有可能找到比较理想的结果啊
找到比较好的结果后，用命令save filename net;保存网络，
可使预测的结果不会变化，调用时用命令load filename net;
取p_test=[ ];
t_test=[ ];
t=sim(net,p_test);
err=t_test-t;
plot(p_test,err);
选择误差小的保存网络
save filename net
以后调用时
load filename net
p_test=[ ];
t_test=[ ];
t=sim(net,p_test);
err=t_test-t;
plot(p_test,err):
因为每次初始化网络时都是随机的，而且训练终止时的误差也不完全相同，结果训练后的权植和阀也不完全相同（大致是一样的），所以每次训练后的结果也略有不同
举个例子，这样初始化就能使网络的输出结果是一样的，另外也可以给网络特定的权值，一种方法是把预测结果后的效果比较好的权值做为初值
p=[0.8726 0.9441 0;0 0 0.7093;0.7378 0.7093 0.3795;0.6416 0.3795 0.7031;1 0.7031 0.4241;0.7774 0.4241 0.9559;0.9559 0.5012 0.7052;...
0.8209 0.7052 0.4983;0.6011 0.4983 1;]';
t=[0 0.7378 0.6416 1 0.7774 0.5012 0.8209 0.6011 0.9350];
rand('state',0);
net=newff(minmax(p),[6,1],{'tansig','logsig'},'trainlm');
net.trainParam.epochs=2000;
net.trainParam.goal=0.001;
net=train(net,p,t);
y=sim(net,p);
error=y-t;
res=norm(error);
p_test=[0.9350 1 0.6236;]';
t_test=[ 0.8027]
a=sim(net,p_test)
rand('state',0);
这个的作用是每次初始化一样
0是种子数,如果换成其他数,就可以产生不同的随机值
注: rand('state',0);的使用有点为结果相同而相同，至于这样的结果网络性能是否达到好的要求则没有考虑，建议还是不要用这种方法使每次结果相同
用保存网络的方法吧
消除初值影响可以考虑的另一个方法是简单集成神经网络
原理
由于选择不同的权值所得结果不同，使最终神经网络泛化能力体现出一定的随机性。利用这个特性也可以改善神经网络的泛化能力，神经网络集成便是利用这种思路的体现，即先训练一组只有初始权值不同的子网，然后通过各子网“表决（Voting）” 的形式（如加权和）得到学习系统的输出。
当神经网络集成用于分类器时，集成的输出通常由个体网络的输出投票产生。通常利用绝对多数投票法（某分类成为最终结果当且仅当输出结果为该分类的神经网络的数目最多）。理论分析和大量实验表明，后者优于前者。因此，在对分类器进行集成时，目前大多采用相对多数投票法。
当神经网络集成用于回归估计时，集成的输出通常由各网络的输出通过简单平均或加权平均产生。Perrone等人认为，采用加权平均可以得到比简单平均更好的泛化能力。
三、神经网络(BP)系列(3)(初学者请看)分类实例
分类实例
输入输出设计：
对某一问题分析，影响网络性能的输入主要有5个指标，输出则分为8类。8类的话可以用三位二进制表示。
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
神经网络的输入为5维的向量，输出为三维的向量。输入的数据具有不同的单位和量级，所以在输入在输入神经网络之前应该首先进行归一化处理，将样本数据归一到0 1之间。
样本总共有328组数据
将样本集分为训练集和测试集
随机抽取70取做为测试测试集
其余的作为训练集
网络设计
采用tansig(x)和logsig(x)函数作为传输函数，tansig(x)如下式：
tansig=2/(1+exp(-2x))-1
logsig(x) 如下式：
logsig(x) = 1 / (1 + exp(-n))
对于有限个输入到输出的映射，并不需要无限个隐层节点，这就涉及到如何选择隐层节点数的问题，而这一问题的复杂性，使得至今为止尚未找到一个很好的解析 式，隐层节点数往往根据前人设计所得的经验和自己进行试验来确定。设计网络时我采用的方法是通过神经网络训练来确定隐含层的个数，首先确定隐含层中节点数目的范围，设计一个隐含层神经元数目可变的BP网络，通过误差对比，确定最佳的隐含层神经元的个数。最后确定的隐含层的个数为12。所以网络结构为 5-12-3的三层结构。
load('CSHuju1.mat');
p=CC1(:,[1,3:6])';
T=[0 0 0;
1 1 1;
1 1 0;
1 0 1;
1 0 0;
0 1 1;
0 1 0;
0 0 1];
t=repmat(T,41,1)';
pp=p;
%%%%%%归一到 0 1 之间
for i=1:5
p(i,:)=(p(i,:)-min(p(i,:)))/(max(p(i,:))-min(p(i,:)));
end
AllSamNum=328;%总样本数
TrainSamNum=258;%训练样本数
TestSamNum=AllSamNum-TrainSamNum;%测试样本数
PerPos=randperm(AllSamNum);
TrainDataIn=p(:,1:TrainSamNum)
TrainDataOut=t(:,1:TrainSamNum)
TestDataIn=p(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
TestDataOut=t(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
MaxMin=[0 1; 0 1; 0 1; 0 1;0 1];
net=newff(MaxMin,[12,3],{'tansig','logsig'},'trainlm');
%训练参数设置
net.trainParam.epochs=1000;
%训练次数
net.trainParam.goal=0.0001;
%训练结束的目标
LP.lr=0.1;
%学习率
net.trainParam.show=20;
net=train(net,TrainDataIn,TrainDataOut);
out=sim(net,TestDataIn)
训练结果：
TRAINLM, Epoch 0/1000, MSE 0.296308/0.0001, Gradient 83.9307/1e-010
TRAINLM, Epoch 20/1000, MSE 0.0224641/0.0001, Gradient 6.7605/1e-010
TRAINLM, Epoch 40/1000, MSE 0.00563627/0.0001, Gradient 3.27027/1e-010
TRAINLM, Epoch 60/1000, MSE 0.00348587/0.0001, Gradient 1.49868/1e-010
TRAINLM, Epoch 80/1000, MSE 0.00247714/0.0001, Gradient 0.459233/1e-010
TRAINLM, Epoch 100/1000, MSE 0.0018843/0.0001, Gradient 0.289155/1e-010
TRAINLM, Epoch 120/1000, MSE 0.00148204/0.0001, Gradient 0.392871/1e-010
TRAINLM, Epoch 140/1000, MSE 0.00119585/0.0001, Gradient 0.340864/1e-010
TRAINLM, Epoch 160/1000, MSE 0.000980448/0.0001, Gradient 0.391987/1e-010
TRAINLM, Epoch 180/1000, MSE 0.000779059/0.0001, Gradient 0.389835/1e-010
TRAINLM, Epoch 200/1000, MSE 0.000606974/0.0001, Gradient 0.310202/1e-010
TRAINLM, Epoch 220/1000, MSE 0.000388926/0.0001, Gradient 0.331632/1e-010
TRAINLM, Epoch 240/1000, MSE 0.000143563/0.0001, Gradient 0.0403953/1e-010
TRAINLM, Epoch 248/1000, MSE 9.87756e-005/0.0001, Gradient 0.174263/1e-010
TRAINLM, Performance goal met.
训练好的权值、阈值的输出方法是：
输入到隐层权值：w1=net.iw{1,1}
隐层阈值：theta1=net.b{1}
隐层到输出层权值：w2=net.lw{2,1};
输出层阈值：theta2=net.b{2}
>>w1=net.iw{1,1}
w1 =
1.7663 -2.8022 -0.7142 -2.1099 -2.4011
3.6614 -2.5297 -4.4295 5.0508 8.1899
4.4007 7.6775 -6.0282 6.1567 1.8775
4.5009 -9.9915 5.9737 5.0234 3.3931
0.2703 -2.8850 0.4482 -2.9153 1.3648
2.3769 3.3151 0.8745 3.1900 1.2608
-2.2815 -6.6847 1.8738 2.4093 -2.9033
-5.3332 6.1506 -8.4386 -6.7979 3.1428
-0.0135 -10.8942 -9.6333 7.2311 12.0693
2.3130 5.2211 0.0155 2.9431 0.3135
-6.4017 -0.8987 0.1976 3.2527 0.1444
-3.6517 -1.6339 3.5505 2.4813 1.7880
>> theta1=net.b{1}
theta1 =
0.5955
-5.4876
-9.8986
-4.4731
3.6523
-4.0371
5.6187
5.7426
0.9147
-8.5523
-2.3632
-5.6106
>> w2=net.lw{2,1}
w2 =
Columns 1 through 8
-0.2751 -3.5658 -2.3689 -6.4192 -1.1209 1.5711 -1.7615 7.6202
-1.2874 -9.1588 -14.4533 7.5064 3.7074 0.9019 8.7033 -5.0031
3.3536 -0.8844 7.8887 0.9336 0.8410 -2.4905 1.0627 -9.3513
Columns 9 through 12
-2.5894 -1.9950 -3.0132 -4.7009
13.3490 -9.8521 -4.6680 -4.2037
-5.9251 2.9388 -1.6797 -2.1077
>> theta2=net.b{2}
theta2 =
-2.4762
0.5692
0.6694
输出：
out =
Columns 1 through 8
1.0000 1.0000 0.0020 0.0000 1.0000 1.0000 0.0000 0.0000
1.0000 0.0000 0.0041 1.0000 1.0000 1.0000 1.0000 1.0000
0.9991 0.0000 0.0036 0.0015 0.9992 0.9985 0.0055 0.0036
Columns 9 through 16
1.0000 0.0000 0.0019 1.0000 0.0000 0.0000 0.0000 0.9996
1.0000 1.0000 0.9901 1.0000 1.0000 1.0000 1.0000 0.0000
0.9977 0.9999 0.9996 0.9994 0.0046 0.0023 0.0014 1.0000
Columns 17 through 24
0.0020 0.9925 0.0020 0.0000 0.0020 1.0000 0.0002 1.0000
0.0041 0.0284 0.0041 0.0284 0.0041 1.0000 0.9983 1.0000
0.0036 0.9955 0.0036 1.0000 0.0036 0.9989 0.9999 0.9990
Columns 25 through 32
1.0000 0.9938 1.0000 0.0000 1.0000 0.9999 0.0000 1.0000
1.0000 0.0177 0.0000 0.0021 1.0000 0.0006 1.0000 1.0000
0.0000 0.9971 0.0000 1.0000 0.0000 0.0004 0.9999 0.0000
Columns 33 through 40
0.9954 1.0000 0.0000 0.0000 0.9951 0.0020 0.0000 0.9997
0.0065 1.0000 1.0000 0.0025 0.0178 0.0041 1.0000 0.0000
0.9986 0.9990 0.9999 1.0000 0.0101 0.0036 0.0013 1.0000
Columns 41 through 48
0.0000 1.0000 0.9983 0.0000 0.0020 1.0000 0.0000 0.9873
0.0020 1.0000 0.0000 0.0037 0.0041 1.0000 0.0328 0.0637
1.0000 0.0000 0.9999 1.0000 0.0036 0.9982 1.0000 0.9884
Columns 49 through 56
0.0000 0.0001 1.0000 1.0000 1.0000 0.0000 0.0004 1.0000
0.0164 0.9992 0.9982 1.0000 1.0000 1.0000 0.9965 0.9998
1.0000 0.9999 0.9948 0.9991 0.9989 0.0024 0.9998 0.9968
Columns 57 through 64
1.0000 1.0000 0.0000 0.0020 0.0020 0.0001 0.0001 0.0000
0.9763 1.0000 0.0134 0.0041 0.0041 0.9990 0.0395 0.0017
0.0202 0.9988 1.0000 0.0036 0.0036 0.9999 0.9999 1.0000
Columns 65 through 70
0.9993 0.0000 0.0000 0.9978 1.0000 1.0000
0.0000 0.0018 0.0110 0.0001 1.0000 0.9998
1.0000 1.0000 1.0000 0.9999 0.9987 0.0007
每次结果因为初始化不同会不一样，可以选取一个性能比较好的网络
保持起来
save myBpNet net
save myShu.mat TestDataIn TestDataOut
测试数据也保存起来
(TestDataIn TestDataOut 为测试数据的输入向量和目标向量)
以后调用时
load myshu.mat
load myBpNet net
out=sim(net,TestDataIn)
基本框架程序：（前面的样本数据自己根据实际情况设计）
load('CSHuju1.mat');
p=CC1(:,[1,3:6])';
T=[0 0 0;
1 1 1;
1 1 0;
1 0 1;
1 0 0;
0 1 1;
0 1 0;
0 0 1];
t=repmat(T,41,1)';
pp=p;
%%%%%%归一到 0 1 之间
for i=1:5
p(i,:)=(p(i,:)-min(p(i,:)))/(max(p(i,:))-min(p(i,:)));
end
AllSamNum=328;%总样本数
TrainSamNum=258;%训练样本数
TestSamNum=AllSamNum-TrainSamNum;%测试样本数
PerPos=randperm(AllSamNum);
TrainDataIn=p(:,1:TrainSamNum)
TrainDataOut=t(:,1:TrainSamNum)
TestDataIn=p(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
TestDataOut=t(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
MaxMin=[0 1; 0 1; 0 1; 0 1;0 1];
net=newff(MaxMin,[12,3],{'tansig','logsig'},'trainlm');
net.trainParam.epochs=1000;
%训练次数
net.trainParam.goal=0.0001;
%训练结束的目标
LP.lr=0.1;
%学习率
net.trainParam.show=20;
net=train(net,TrainDataIn,TrainDataOut);
out=sim(net,TestDataIn)
⑼ 人工神经网络分析需要样本量一般多大
1.样本量的确定是费用与精度的函数，取决于研究的精度和费用，特别是实践中费用考虑的更多！
2.抽样调查，特别是随机抽样，样本有代表性，往往比普查更有效率，甚至精度更高，这里我们主要计算和讨论抽样误差，非抽样误差是人为因素，考质量控制；
3.样本量的确定有赖于随机抽样，或者说主要是针对随机抽样，需要统计推断下的计算样本量，如果是非概率抽样，理论上没有计算和控制样本量的问题；
4.如果研究只要40-50个样本，感觉上应该是非概率抽样（依赖被访者选择方式）
5.即使是非概率抽样，我们很多时候也采用概率和统计分析及推断思想来进行数据分析和下结论！只是这种方法没有完善的理论支持，或者说有可能因为研究者的主观判断失误造成偏差；
6.无论是概率抽样还是非概率抽样，样本量越大当然效果越好，结论越稳定（理论上说）
7.40-50个样本在统计上属于小样本，t-检验，如果样本大于60或理想120以上，t分布就是正态分布了，所以40个样本在统计上是最小推断总体的样本，换句话说40-50个样本是介于小样本和正态分布大样本的临界样本量；如果不严格的话40个样本就可以比较总体之间的统计差异了；
8.所以，一般来讲，针对一个研究对象和人群，要进行比较最少40个样本，比如男女差异，应该各拥有40人（80人），或者说你们进行配额样本的时候要保证统计比较的类别至少有40个样本；
9.那么40个样本有代表性吗？ 当然越多越好，越有代表性
10.但如果调查对象非常一致，没有差异，只要问一个人就行了，所以要考虑研究对象的差异性，如果差异大，当然样本量要大，如果没有差异，同质性较高样本量就少；
11.总体的大小对样本量的选择没有影响，调查研究一般必须在研究前明确总体是谁，大总体没有影响（上万人），中等总体有点影响（5000人），小总体有很大影响（千百个人）；总体是你要推断的人群；
12.再者要考虑研究对象在总体中拥有的比例（比如要找艾滋病人），如果比例非常低的话，需要大样本才能找到；但往往商业研究就采用非概率抽样了，比如滚雪球抽样，专家判断抽样，配额抽样等；
13.另外，选择40个人，如果是经过我们主观判断的，有一种说法：叫条件概率，也就是我们越了解研究目的和对象，我们就越能够做出正确判断；比如P（A|B），也就是说我们越了解B事件发生的概率，那么A发生的概率就越确定；就像我们在Google中搜东西，你的关键词=B越准确，得到的结果A就越是你想要的东西；
14.当然，如果你的主观判断错了，就会犯更大的错误
15.还有就是希望得到的精度；如果得到的结果是70%加减10%误差我们可以接受，但如果是总体本身就不到8%，那8%加减10%，尾巴比头都大显然不行，当然到底如何确定精度，是研究前你们与客户要明确的，事先研究设计确定的，不能事后来说；
16.记住：有时候我们研究本身不需要那么高的精度
17.整个研究设计过程的质量控制可以更有效提升研究品质
18.研究测试的技术（接近自然科学仪器测量）可获得更好研究品质
19.根据精确的抽样，需要采用精确的统计分析，否则也达不到效果
20.任何研究都不会完美，都是权衡和保守的过程，总的来讲保守不犯错
21.如果研究有实验设计和研究设计，所以实验设计，包括所谓双盲实验、正交设计、拉丁方格等，确定样本分组是非常精细的，有助于研究品质；但设计缺陷会造成降低品质；
22.处置组和对照组的设计，主要应用在传播效果、广告效果研究上，需要有设计原则
23.实验设计也强调对其它影响因素的控制，也就是X对Y的影响，要控制住Z的干扰，更能提高研究品质
24.被访者的参与度（你的激励方式）也重要，一分钱一分货；我们是花钱买信息
25.任何理由都是可解释的，但这里主要是要用术语，越专业越说行话，别人更相信，所以解释样本量的科学性，有时候要用科学，也就是理论；
26.因为有理论，显得有水平，因为有水平就有话语权，就有执行力！所以权威部门的设计或出面，客户就相信了！
27.研究过程，不断修正，比如追加样本也是解决问题的办法
28.连续性研究，也会解决或减少对样本量的需求
29.广告效果研究经常采用rolling data的方式，因为广告效果有延迟效应，每周50个样本，4周一个分析，就是200样本，第五周分析前4周，第六周分析2-5周数据，进行比较和检验，这是常有方法；
⑽ BP神经网络数据400组少吗
少。
如果你的数据具有非常复杂的对应关系，比如现在你分类到博彩类，用神经网络理论上讲是可以预测的的，很多人发了论文，讲怎么用神经网络预测双色球什么的。实际上效果并不是非常理想。因为内在规律太复杂，有限的数据无法透彻的归纳出来到底数据怎么变化。这种情况下，纵使你又几千个数据也不行。比较保险的办法还是用逆向工程方法建立一个一个的子模型，然后整理成一个大模型再做预测。往往会比因为数据量不够引起的神经网络预测误差要小得多。