① 神经网络，训练样本过多，怎样先用一组数据训练后再用另一组数据训练（在上组数据训练结果的基础上）
继承权重啊。
但是这样的话新训练的权重对于旧的数据是无效的。
② 数据模型需要多少训练数据
数据模型需要多少训练数据
毫无疑问机器学习是大数据分析不可或缺的一部分，在使用机器学习技术的时候工程师除了要选择合适的算法之外还需要选择合适的样本数据。那么工程师到底应该选择哪些样本数据、选择多少样本数据才最合适呢?来自于Google的软件工程师Malay Haldar最近发表了一篇题为《数据模型需要多少训练数据》的文章对此进行了介绍。
训练数据的质量和数量通常是决定一个模型性能的最关键因素。一旦训练数据准备好，其他的事情就顺理成章了。但是到底应该准备多少训练数据呢?答案是这取决于要执行的任务，要满足的性能，所拥有的输入特征、训练数据中的噪音、提取特征中的噪音以及模型的复杂程度等因素。而找出这些变量之间相互关系的方法就是在不同数据量的训练数据上训练模型并绘制学习曲线。但是这仅仅适合于已经有一定数量的训练数据的情况，如果是最开始的时候，或者说只有很少一点训练数据的情况，那应该怎么办呢?
与死板地给出所谓精确的“正确”答案相比，更靠谱的方法是通过估算和具体的经验法则。例如本文将要介绍的实证方法：首先自动生成很多逻辑回归问题。然后对生成的每一个问题，研究训练数据的数量与训练模型的性能之间的关系。最后通过观察这两者在这一系列问题上的关系总结出一个简单的规则。
生成一系列逻辑回归问题并研究不同数据量的训练数据所造成的影响的代码可以从GitHub上获取。相关代码是基于Tensorflow实现的，运行这些代码不需要任何特殊的软件或者硬件，用户可以在自己的笔记本上运行整个实验。代码运行之后生成的图表如下：
其中，X轴是训练样本的数量与模型参数数量的比率。Y轴是训练模型的得分(f-score)。不同颜色的曲线表示不同参数数量的模型。例如，红色曲线代表模型有128个参数，曲线的轨迹表明了随着训练样本从128 x 1到 128 x 2并不断增长的过程中该模型的得分变化。
通过该图表，我们能够发现模型得分并不会随着参数规模的变化而变化。但是这是针对线性模型而言，对于一些隐藏的非线性模型并不适合。当然，更大的模型需要更多的训练数据，但是对于一个给定的训练模型数量与模型参数数量比率其性能是一样的。该图表还显示，当训练样本的数量与模型参数数量的比率达到10:1之后，模型得分基本稳定在0.85，该比率便可以作为良好性能模型的一种定义。根据该图表我们可以总结出10X规则，也就是说一个优秀的性能模型需要训练数据的数量10倍于该模型中参数的数量。
10X规则将估计训练数据数量的问题转换成了需要知道模型参数数量的问题。对于逻辑回归这样的线性模型，参数的数量与输入特征的数量相等，因为模型会为每一个特征分派一个相关的参数。但是这样做可能会有一些问题：
特征可能是稀疏的，因而可能会无法直接计算出特征的数量。
由于正则化和特征选择技术，很多特征可能会被抛弃，因而与原始的特征数相比，真正输入到模型中的特征数会非常少。
避免这些问题的一种方法是：必须认识到估算特征的数量时并不是必须使用标记的数据，通过未标记的样本数据也能够实现目标。例如，对于一个给定的大文本语料库，可以在标记数据进行训练之前通过生成单词频率的历史图表来理解特征空间，通过历史图表废弃长尾单词进而估计真正的特征数，然后应用10X规则来估算模型需要的训练数据的数据量。
需要注意的是，神经网络构成的问题集与逻辑回归这样的线性模型并不相同。为了估算神经网络所需要的参数数量，你需要：
如果输入是稀疏的，那么需要计算嵌套层使用的参数的数量。参照word2vec的Tensorflow教程示例。
计算神经网络中边的数量
由于神经网络中参数之间的关系并不是线性的，所以本文基于逻辑回归所做的实证研究并不适合神经网络。但是在这种情况下，可以将10X规则作为训练数据所需数据量的下限。
尽管有上面的问题，根据Malay Haldar的经验，10X规则对于大部分问题还是适用的，包括浅神经网络。如果有疑问，可以在Tensorflow的代码中插入自己的模型和假设，然后运行代码进行验证研究。
③ 神经网络模型需要多少条数据
输入指标是什么意思。输入维数吗？数据一是这些数据有意义是一类的，或者说是有内部规律。数量上多一点好一点。训练样本个预测样本2比1左右就好。学习过程要注意的是你的学习速率，这影响最优解的寻找。
④ 神经网络处理数据组有1000个维数需要多少输入节点
这需要看你的实际需求了，一般使用二次型就行，这样的话输入节点1000！个，维度这么大我想应该有很大数据是冗余的，可以先用PCA降低下维度1000维度（通道）有点夸张，还是说只是单维度下，有连续1000个输入作为一组样本
⑤ tensorflow 训练一个神经网络 需要多长时间
基本使用
使用 TensorFlow, 你必须明白 TensorFlow:
使用图 (graph) 来表示计算任务.
在被称之为 会话 (Session) 的上下文 (context) 中执行图.
使用 tensor 表示数据.
通过 变量 (Variable) 维护状态.
使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.
综述
TensorFlow 是一个编程系统, 使用图来表示计算任务. 图中的节点被称之为 op
(operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算,
产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组.
例如, 你可以将一小组图像集表示为一个四维浮点数数组,
这四个维度分别是 [batch, height, width, channels].
一个 TensorFlow 图描述了计算的过程. 为了进行计算, 图必须在 会话 里被启动.
会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法.
这些方法执行后, 将产生的 tensor 返回. 在 Python 语言中, 返回的 tensor 是
numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是
tensorflow::Tensor 实例.
计算图
TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤
被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.
例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.
TensorFlow 支持 C, C++, Python 编程语言. 目前, TensorFlow 的 Python 库更加易用,
它提供了大量的辅助函数来简化构建图的工作, 这些函数尚未被 C 和 C++ 库支持.
三种语言的会话库 (session libraries) 是一致的.
构建图
构建图的第一步, 是创建源 op (source op). 源 op 不需要任何输入, 例如 常量 (Constant). 源 op 的输出被传递给其它 op 做运算.
Python 库中, op 构造器的返回值代表被构造出的 op 的输出, 这些返回值可以传递给其它
op 构造器作为输入.
TensorFlow Python 库有一个默认图 (default graph), op 构造器可以为其增加节点. 这个默认图对
许多程序来说已经足够用了. 阅读 Graph 类 文档
来了解如何管理多个图.
import tensorflow as tf
# 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
# 加到默认图中.
#
# 构造器的返回值代表该常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])
# 创建另外一个常量 op, 产生一个 2x1 矩阵.
matrix2 = tf.constant([[2.],[2.]])
# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
# 返回值 'proct' 代表矩阵乘法的结果.
proct = tf.matmul(matrix1, matrix2)
默认图现在有三个节点, 两个 constant() op, 和一个matmul() op. 为了真正进行矩阵相乘运算, 并得到矩阵乘法的
结果, 你必须在会话里启动这个图.
在一个会话中启动图
构造阶段完成后, 才能启动图. 启动图的第一步是创建一个 Session 对象, 如果无任何创建参数,
会话构造器将启动默认图.
欲了解完整的会话 API, 请阅读Session 类.
# 启动默认图.
sess = tf.Session()
# 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'proct' 作为该方法的参数.
# 上面提到, 'proct' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
# 矩阵乘法 op 的输出.
#
# 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
#
# 函数调用 'run(proct)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
#
# 返回值 'result' 是一个 numpy `ndarray` 对象.
result = sess.run(proct)
print result
# ==> [[ 12.]]
# 任务完成, 关闭会话.
sess.close()
Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 "with" 代码块
来自动完成关闭动作.
with tf.Session() as sess:
result = sess.run([proct])
print result
在实现上, TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU
或 GPU). 一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测. 如果检测到 GPU, TensorFlow
会尽可能地利用找到的第一个 GPU 来执行操作.
如果机器上有超过一个可用的 GPU, 除第一个外的其它 GPU 默认是不参与计算的. 为了让 TensorFlow
使用这些 GPU, 你必须将 op 明确指派给它们执行. with...Device 语句用来指派特定的 CPU 或 GPU
执行操作:
with tf.Session() as sess:
with tf.device("/gpu:1"):
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
proct = tf.matmul(matrix1, matrix2)
...
设备用字符串进行标识. 目前支持的设备包括:
"/cpu:0": 机器的 CPU.
"/gpu:0": 机器的第一个 GPU, 如果有的话.
"/gpu:1": 机器的第二个 GPU, 以此类推.
阅读使用GPU章节, 了解 TensorFlow GPU 使用的更多信息.
交互式使用
文档中的 Python 示例使用一个会话 Session 来
启动图, 并调用 Session.run() 方法执行操作.
为了便于使用诸如 IPython 之类的 Python 交互环境, 可以使用
InteractiveSession 代替
Session 类, 使用 Tensor.eval()
和 Operation.run() 方法代替
Session.run(). 这样可以避免使用一个变量来持有会话.
# 进入一个交互式 TensorFlow 会话.
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])
# 使用初始化器 initializer op 的 run() 方法初始化 'x'
x.initializer.run()
# 增加一个减法 sub op, 从 'x' 减去 'a'. 运行减法 op, 输出结果
sub = tf.sub(x, a)
print sub.eval()
# ==> [-2. -1.]
Tensor
TensorFlow 程序使用 tensor 数据结构来代表所有的数据, 计算图中, 操作间传递的数据都是 tensor.
你可以把 TensorFlow tensor 看作是一个 n 维的数组或列表. 一个 tensor 包含一个静态类型 rank, 和
一个 shape. 想了解 TensorFlow 是如何处理这些概念的, 参见
Rank, Shape, 和 Type.
变量
Variables for more details.
变量维护图执行过程中的状态信息. 下面的例子演示了如何使用变量实现一个简单的计数器. 参见
变量 章节了解更多细节.
# 创建一个变量, 初始化为标量 0.
state = tf.Variable(0, name="counter")
# 创建一个 op, 其作用是使 state 增加 1
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)
# 启动图后, 变量必须先经过`初始化` (init) op 初始化,
# 首先必须增加一个`初始化` op 到图中.
init_op = tf.initialize_all_variables()
# 启动图, 运行 op
with tf.Session() as sess:
# 运行 'init' op
sess.run(init_op)
# 打印 'state' 的初始值
print sess.run(state)
# 运行 op, 更新 'state', 并打印 'state'
for _ in range(3):
sess.run(update)
print sess.run(state)
# 输出:
# 0
# 1
# 2
# 3
代码中 assign() 操作是图所描绘的表达式的一部分, 正如 add() 操作一样. 所以在调用 run()
执行表达式之前, 它并不会真正执行赋值操作.
通常会将一个统计模型中的参数表示为一组变量. 例如, 你可以将一个神经网络的权重作为某个变量存储在一个 tensor 中.
在训练过程中, 通过重复运行训练图, 更新这个 tensor.
Fetch
为了取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 传入一些 tensor,
这些 tensor 会帮助你取回结果. 在之前的例子里, 我们只取回了单个节点 state, 但是你也可以取回多个
tensor:
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)
with tf.Session() as sess:
result = sess.run([mul, intermed])
print result
# 输出:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
需要获取的多个 tensor 值，在 op 的一次运行中一起获得（而不是逐个去获取 tensor）。
Feed
上述示例在计算图中引入了 tensor, 以常量或变量的形式存储. TensorFlow 还提供了 feed 机制, 该机制
可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor.
feed 使用一个 tensor 值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数.
feed 只在调用它的方法内有效, 方法结束, feed 就会消失. 最常见的用例是将某些特殊的操作指定为 "feed" 操作,
标记的方法是使用 tf.placeholder() 为这些操作创建占位符.
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1, input2)
with tf.Session() as sess:
print sess.run([output], feed_dict={input1:[7.], input2:[2.]})
# 输出:
# [array([ 14.], dtype=float32)]
for a larger-scale example of feeds.
如果没有正确提供 feed, placeholder() 操作将会产生错误.
MNIST 全连通 feed 教程
(source code)
给出了一个更大规模的使用 feed 的例子.
⑥ rbf神经网络的训练样本要多大
因课题而异。
1、样本最关键在于正确性和准确性。你所选择的样本首先要能正确反映该系统过程的内在规律。我们从生产现场采得的样本数据中有不少可能是坏样本，例如由于测量仪器故障导致测量数据误差较大等，这样的样本会干扰你的神经网络训练。通常我们认为坏样本只是个别现象，所以我们希望通过尽可能大的样本规模来抵抗坏样本造成的负面影响。
2、其次是样本数据分布的均衡性。你所选择的样本最好能涉及到该系统过程可能发生的各种情况。例如某化工生产中某反应炉的温度主要分布在350度—400度，且出现在380度的情况较多，那么你的样本数据最好也是在350-400度各种情况都有，并且也是在380度左右的样本较多些，这样可以极大可能的照顾到系统在各个情况下的规律特征。通常我们对系统的内在规律不是很了解，所以我们希望通过尽可能大的样本规模来“地毯式”覆盖对象系统的方方面面。
3、再次就是样本数据的规模，也就是你要问的问题。在确保样本数据质量和分布均衡的情况下，样本数据的规模决定你神经网络训练结果的精度。样本数据量越大，精度越高。还用刚才的例子，假如反应炉的温度主要均匀分布在375-385度之间，那么你用100个均衡分布在375-385度的训练样本去训练，经过无限次或者说是足够多次迭代之后，理论上你的神经网络的精度就是0.1度。如果你觉得0.1度足够细腻了，那么样本规模为100也就可以接受了。由于样本规模直接影响计算机的运算时间，所以在精度符合要求的情况下，我们不需要过多的样本数据，否则我们要等待很久的训练时间。
补充说明一下，不论是径向基（rbf）神经网络还是经典的bp神经网络，都只是具体的训练方法，对于足够多次的迭代，训练结果的准确度是趋于一致的，方法只影响计算的收敛速度（运算时间），和样本规模没有直接关系。
⑦ 用MATLAB与BP神经网络法处理15组数据,共60个数据,需要多长时间
训练时长取决于训练算法、训练目标、样本数量和网络规模。你的样本只有15组，数量较少，一般几秒钟就能训练完成。
若从速度的角度出发，人脑神经元之间传递信息的速度要远低于计算机，前者为毫秒量级，而后者的频率往往可达几百兆赫。但是，由于人脑是一个大规模并行与串行组合处理系统，因而，在许多问题上可以作出快速判断、决策和处理，其速度则远高于串行结构的普通计算机。人工神经网络的基本结构模仿人脑，具有并行处理特征，可以大大提高工作速度。
⑧ matlab神经网络训练一般需要多少数据
只要你觉得这些数据能把握住你要解决的问题了，够这个问题的学习了，就够了。几十到上百万都是有可能的。一般数据多一些更有利于精度。
⑨ 网络训练
利用train（net，pn）函数训练网络，net为设计的网络，pn为样本数据，共23组。通过“net.trainParam.epochs＝300；net＝init（net）”设置网络训练次数，并绘图查看其权值聚类效果，最终选择网络训练次数为1000。训练结束后神经元的聚类效果如图9.14所示，训练后网络权值如表9.3所示。
⑩ 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));
}
}