编程是怎么实现神经网络

㈠ 神经网络的编程基础——NG

本章内容主要针对神经网络训练数据的过程前向传播和后向传播的详细介绍。比如逻辑回归的前向传播：

用来预测y值和求代价函数的极小值。
同时后向传播该如何更新参数w，b。
损失函数：

其实都是一个概念，只不过损失函数针对一个样本提出来的定义，代价函数是针对多个样本提出来的概念，但说到底代价函数只不过是损失函数的累加的平均值而已。

后面也涉及到梯度下降法步骤，更新参数w，b的值。
以下内容从定义输入特征向量x，输出值y，y取0或1，以及定义一个独立样本(x,y)，以及m个样本组成的训练集。分别从一个样本开始，介绍了逻辑回归的损失函数和更新w，b参数，里面涉及求导，链式法则等知识，之后介绍了m个样本，逻辑回归的代价函数和如何整体更新参数w，b。因为for循环太慢，所以引入了向量化求解更新方式，也就是我们大学学习的矩阵。

这里存在一个讨论问题，为啥逻辑回归的损失函数是这样定的，大家可以思考下。

说明一下下面那张图，右边不是涂没了，而是dz的转置，即(dz1,dz2,...dzm)的转置。

其实看了for循环和向量化，发现，向量化真的快，以后要养成少些for循环的习惯，多用向量化求解，直观简明，符合矩阵的思想。

㈡ 如何用PyTorch实现递归神经网络

从 Siri 到谷歌翻译，深度神经网络已经在机器理解自然语言方面取得了巨大突破。这些模型大多数将语言视为单调的单词或字符序列，并使用一种称为循环神经网络（recurrent neural network/RNN）的模型来处理该序列。但是许多语言学家认为语言最好被理解为具有树形结构的层次化词组，一种被称为递归神经网络（recursive neural network）的深度学习模型考虑到了这种结构，这方面已经有大量的研究。虽然这些模型非常难以实现且效率很低，但是一个全新的深度学习框架 PyTorch 能使它们和其它复杂的自然语言处理模型变得更加容易。

虽然递归神经网络很好地显示了 PyTorch 的灵活性，但它也广泛支持其它的各种深度学习框架，特别的是，它能够对计算机视觉（computer vision）计算提供强大的支撑。PyTorch 是 Facebook AI Research 和其它几个实验室的开发人员的成果，该框架结合了 Torch7 高效灵活的 GPU 加速后端库与直观的 Python 前端，它的特点是快速成形、代码可读和支持最广泛的深度学习模型。

开始 SPINN

链接中的文章（https://github.com/jekbradbury/examples/tree/spinn/snli）详细介绍了一个递归神经网络的 PyTorch 实现，它具有一个循环跟踪器（recurrent tracker）和 TreeLSTM 节点，也称为 SPINN——SPINN 是深度学习模型用于自然语言处理的一个例子，它很难通过许多流行的框架构建。这里的模型实现部分运用了批处理（batch），所以它可以利用 GPU 加速，使得运行速度明显快于不使用批处理的版本。

SPINN 的意思是堆栈增强的解析器-解释器神经网络（Stack-augmented Parser-Interpreter Neural Network），由 Bowman 等人于 2016 年作为解决自然语言推理任务的一种方法引入，该论文中使用了斯坦福大学的 SNLI 数据集。

该任务是将语句对分为三类：假设语句 1 是一幅看不见的图像的准确标题，那么语句 2（a）肯定（b）可能还是（c）绝对不是一个准确的标题？（这些类分别被称为蕴含（entailment）、中立（neutral）和矛盾（contradiction））。例如，假设一句话是「两只狗正跑过一片场地」，蕴含可能会使这个语句对变成「户外的动物」，中立可能会使这个语句对变成「一些小狗正在跑并试图抓住一根棍子」，矛盾能会使这个语句对变成「宠物正坐在沙发上」。

特别地，研究 SPINN 的初始目标是在确定语句的关系之前将每个句子编码（encoding）成固定长度的向量表示（也有其它方式，例如注意模型（attention model）中将每个句子的每个部分用一种柔焦（soft focus）的方法相互比较）。

数据集是用句法解析树（syntactic parse tree）方法由机器生成的，句法解析树将每个句子中的单词分组成具有独立意义的短语和子句，每个短语由两个词或子短语组成。许多语言学家认为，人类通过如上面所说的树的分层方式来组合词意并理解语言，所以用相同的方式尝试构建一个神经网络是值得的。下面的例子是数据集中的一个句子，其解析树由嵌套括号表示：

( ( The church ) ( ( has ( cracks ( in ( the ceiling ) ) ) ) . ) )

这个句子进行编码的一种方式是使用含有解析树的神经网络构建一个神经网络层 Rece，这个神经网络层能够组合词语对（用词嵌入（word embedding）表示，如 GloVe）、 和/或短语，然后递归地应用此层（函数），将最后一个 Rece 产生的结果作为句子的编码：

X = Rece(“the”, “ceiling”)
Y = Rece(“in”, X)
... etc.

但是，如果我希望网络以更类似人类的方式工作，从左到右阅读并保留句子的语境，同时仍然使用解析树组合短语？或者，如果我想训练一个网络来构建自己的解析树，让解析树根据它看到的单词读取句子？这是一个同样的但方式略有不同的解析树的写法：

The church ) has cracks in the ceiling ) ) ) ) . ) )

或者用第 3 种方式表示，如下：

WORDS: The church has cracks in the ceiling .
PARSES: S S R S S S S S R R R R S R R

我所做的只是删除开括号，然后用「S」标记「shift」，并用「R」替换闭括号用于「rece」。但是现在可以从左到右读取信息作为一组指令来操作一个堆栈（stack）和一个类似堆栈的缓冲区（buffer），能得到与上述递归方法完全相同的结果：

1. 将单词放入缓冲区。
2. 从缓冲区的前部弹出「The」，将其推送（push）到堆栈上层，紧接着是「church」。
3. 弹出前 2 个堆栈值，应用于 Rece，然后将结果推送回堆栈。
4. 从缓冲区弹出「has」，然后推送到堆栈，然后是「cracks」，然后是「in」，然后是「the」，然后是「ceiling」。
5. 重复四次：弹出 2 个堆栈值，应用于 Rece，然后推送结果。
6. 从缓冲区弹出「.」，然后推送到堆栈上层。
7. 重复两次：弹出 2 个堆栈值，应用于 Rece，然后推送结果。
8. 弹出剩余的堆栈值，并将其作为句子编码返回。

我还想保留句子的语境，以便在对句子的后半部分应用 Rece 层时考虑系统已经读取的句子部分的信息。所以我将用一个三参数函数替换双参数的 Rece 函数，该函数的输入值为一个左子句、一个右子句和当前句的上下文状态。该状态由神经网络的第二层（称为循环跟踪器（Tracker）的单元）创建。Tracker 在给定当前句子上下文状态、缓冲区中的顶部条目 b 和堆栈中前两个条目 s1\s2 时，在堆栈操作的每个步骤（即，读取每个单词或闭括号）后生成一个新状态：

context[t+1] = Tracker(context[t], b, s1, s2)

容易设想用你最喜欢的编程语言来编写代码做这些事情。对于要处理的每个句子，它将从缓冲区加载下一个单词，运行跟踪器，检查是否将单词推送入堆栈或执行 Rece 函数，执行该操作；然后重复，直到对整个句子完成处理。通过对单个句子的应用，该过程构成了一个大而复杂的深度神经网络，通过堆栈操作的方式一遍又一遍地应用它的两个可训练层。但是，如果你熟悉 TensorFlow 或 Theano 等传统的深度学习框架，就知道它们很难实现这样的动态过程。你值得花点时间回顾一下，探索为什么 PyTorch 能有所不同。

图论

图 1：一个函数的图结构表示

深度神经网络本质上是有大量参数的复杂函数。深度学习的目的是通过计算以损失函数（loss）度量的偏导数（梯度）来优化这些参数。如果函数表示为计算图结构（图 1），则向后遍历该图可实现这些梯度的计算，而无需冗余工作。每个现代深度学习框架都是基于此反向传播（backpropagation）的概念，因此每个框架都需要一个表示计算图的方式。

在许多流行的框架中，包括 TensorFlow、Theano 和 Keras 以及 Torch7 的 nngraph 库，计算图是一个提前构建的静态对象。该图是用像数学表达式的代码定义的，但其变量实际上是尚未保存任何数值的占位符（placeholder）。图中的占位符变量被编译进函数，然后可以在训练集的批处理上重复运行该函数来产生输出和梯度值。

这种静态计算图（static computation graph）方法对于固定结构的卷积神经网络效果很好。但是在许多其它应用中，有用的做法是令神经网络的图结构根据数据而有所不同。在自然语言处理中，研究人员通常希望通过每个时间步骤中输入的单词来展开（确定）循环神经网络。上述 SPINN 模型中的堆栈操作很大程度上依赖于控制流程（如 for 和 if 语句）来定义特定句子的计算图结构。在更复杂的情况下，你可能需要构建结构依赖于模型自身的子网络输出的模型。

这些想法中的一些（虽然不是全部）可以被生搬硬套到静态图系统中，但几乎总是以降低透明度和增加代码的困惑度为代价。该框架必须在其计算图中添加特殊的节点，这些节点代表如循环和条件的编程原语（programming primitive），而用户必须学习和使用这些节点，而不仅仅是编程代码语言中的 for 和 if 语句。这是因为程序员使用的任何控制流程语句将仅运行一次，当构建图时程序员需要硬编码（hard coding）单个计算路径。

例如，通过词向量（从初始状态 h0 开始）运行循环神经网络单元（rnn_unit）需要 TensorFlow 中的特殊控制流节点 tf.while_loop。需要一个额外的特殊节点来获取运行时的词长度，因为在运行代码时它只是一个占位符。

# TensorFlow
# (this code runs once, ring model initialization)
# “words” is not a real list (it’s a placeholder variable) so
# I can’t use “len”
cond = lambda i, h: i < tf.shape(words)[0]
cell = lambda i, h: rnn_unit(words[i], h)
i = 0
_, h = tf.while_loop(cond, cell, (i, h0))

基于动态计算图（dynamic computation graph）的方法与之前的方法有根本性不同，它有几十年的学术研究历史，其中包括了哈佛的 Kayak、自动微分库（autograd）以及以研究为中心的框架 Chainer和 DyNet。在这样的框架（也称为运行时定义（define-by-run））中，计算图在运行时被建立和重建，使用相同的代码为前向通过（forward pass）执行计算，同时也为反向传播（backpropagation）建立所需的数据结构。这种方法能产生更直接的代码，因为控制流程的编写可以使用标准的 for 和 if。它还使调试更容易，因为运行时断点（run-time breakpoint）或堆栈跟踪（stack trace）将追踪到实际编写的代码，而不是执行引擎中的编译函数。可以在动态框架中使用简单的 Python 的 for 循环来实现有相同变量长度的循环神经网络。

# PyTorch (also works in Chainer)
# (this code runs on every forward pass of the model)
# “words” is a Python list with actual values in it
h = h0
for word in words:
h = rnn_unit(word, h)

PyTorch 是第一个 define-by-run 的深度学习框架，它与静态图框架（如 TensorFlow）的功能和性能相匹配，使其能很好地适合从标准卷积神经网络（convolutional network）到最疯狂的强化学习（reinforcement learning）等思想。所以让我们来看看 SPINN 的实现。

代码

在开始构建网络之前，我需要设置一个数据加载器（data loader）。通过深度学习，模型可以通过数据样本的批处理进行操作，通过并行化（parallelism）加快训练，并在每一步都有一个更平滑的梯度变化。我想在这里可以做到这一点（稍后我将解释上述堆栈操作过程如何进行批处理）。以下 Python 代码使用内置于 PyTorch 的文本库的系统来加载数据，它可以通过连接相似长度的数据样本自动生成批处理。运行此代码之后，train_iter、dev_iter 和 test_itercontain 循环遍历训练集、验证集和测试集分块 SNLI 的批处理。

from torchtext import data, datasets
TEXT = datasets.snli.ParsedTextField(lower=True)
TRANSITIONS = datasets.snli.ShiftReceField()
LABELS = data.Field(sequential=False)train, dev, test = datasets.SNLI.splits(
TEXT, TRANSITIONS, LABELS, wv_type='glove.42B')TEXT.build_vocab(train, dev, test)
train_iter, dev_iter, test_iter = data.BucketIterator.splits(
(train, dev, test), batch_size=64)

你可以在 train.py中找到设置训练循环和准确性（accuracy）测量的其余代码。让我们继续。如上所述，SPINN 编码器包含参数化的 Rece 层和可选的循环跟踪器来跟踪句子上下文，以便在每次网络读取单词或应用 Rece 时更新隐藏状态；以下代码代表的是，创建一个 SPINN 只是意味着创建这两个子模块（我们将很快看到它们的代码），并将它们放在一个容器中以供稍后使用。

import torchfrom torch import nn
# subclass the Mole class from PyTorch’s neural network package
class SPINN(nn.Mole):
def __init__(self, config):
super(SPINN, self).__init__()
self.config = config self.rece = Rece(config.d_hidden, config.d_tracker)
if config.d_tracker is not None:
self.tracker = Tracker(config.d_hidden, config.d_tracker)

当创建模型时，SPINN.__init__ 被调用了一次；它分配和初始化参数，但不执行任何神经网络操作或构建任何类型的计算图。在每个新的批处理数据上运行的代码由 SPINN.forward 方法定义，它是用户实现的方法中用于定义模型向前过程的标准 PyTorch 名称。上面描述的是堆栈操作算法的一个有效实现，即在一般 Python 中，在一批缓冲区和堆栈上运行，每一个例子都对应一个缓冲区和堆栈。我使用转移矩阵（transition）包含的「shift」和「rece」操作集合进行迭代，运行 Tracker（如果存在），并遍历批处理中的每个样本来应用「shift」操作（如果请求），或将其添加到需要「rece」操作的样本列表中。然后在该列表中的所有样本上运行 Rece 层，并将结果推送回到它们各自的堆栈。

def forward(self, buffers, transitions):
# The input comes in as a single tensor of word embeddings;
# I need it to be a list of stacks, one for each example in
# the batch, that we can pop from independently. The words in
# each example have already been reversed, so that they can
# be read from left to right by popping from the end of each
# list; they have also been prefixed with a null value.
buffers = [list(torch.split(b.squeeze(1), 1, 0))
for b in torch.split(buffers, 1, 1)]
# we also need two null values at the bottom of each stack,
# so we can from the nulls in the input; these nulls
# are all needed so that the tracker can run even if the
# buffer or stack is empty
stacks = [[buf[0], buf[0]] for buf in buffers]
if hasattr(self, 'tracker'):
self.tracker.reset_state()
for trans_batch in transitions:
if hasattr(self, 'tracker'):
# I described the Tracker earlier as taking 4
# arguments (context_t, b, s1, s2), but here I
# provide the stack contents as a single argument
# while storing the context inside the Tracker
# object itself.
tracker_states, _ = self.tracker(buffers, stacks)
else:
tracker_states = itertools.repeat(None)
lefts, rights, trackings = [], [], []
batch = zip(trans_batch, buffers, stacks, tracker_states)
for transition, buf, stack, tracking in batch:
if transition == SHIFT:
stack.append(buf.pop())
elif transition == REDUCE:
rights.append(stack.pop())
lefts.append(stack.pop())
trackings.append(tracking)
if rights:
reced = iter(self.rece(lefts, rights, trackings))
for transition, stack in zip(trans_batch, stacks):
if transition == REDUCE:
stack.append(next(reced))
return [stack.pop() for stack in stacks]

在调用 self.tracker 或 self.rece 时分别运行 Tracker 或 Rece 子模块的向前方法，该方法需要在样本列表上应用前向操作。在主函数的向前方法中，在不同的样本上进行独立的操作是有意义的，即为批处理中每个样本提供分离的缓冲区和堆栈，因为所有受益于批处理执行的重度使用数学和需要 GPU 加速的操作都在 Tracker 和 Rece 中进行。为了更干净地编写这些函数，我将使用一些 helper（稍后将定义）将这些样本列表转化成批处理张量（tensor），反之亦然。

我希望 Rece 模块自动批处理其参数以加速计算，然后解批处理（unbatch）它们，以便可以单独推送和弹出。用于将每对左、右子短语表达组合成父短语（parent phrase）的实际组合函数是 TreeLSTM，它是普通循环神经网络单元 LSTM 的变型。该组合函数要求每个子短语的状态实际上由两个张量组成，一个隐藏状态 h 和一个存储单元（memory cell）状态 c，而函数是使用在子短语的隐藏状态操作的两个线性层（nn.Linear）和将线性层的结果与子短语的存储单元状态相结合的非线性组合函数 tree_lstm。在 SPINN 中，这种方式通过添加在 Tracker 的隐藏状态下运行的第 3 个线性层进行扩展。

图 2：TreeLSTM 组合函数增加了第 3 个输入（x，在这种情况下为 Tracker 状态）。在下面所示的 PyTorch 实现中，5 组的三种线性变换（由蓝色、黑色和红色箭头的三元组表示）组合为三个 nn.Linear 模块，而 tree_lstm 函数执行位于框内的所有计算。图来自 Chen et al. (2016)。

㈢ 如何用matlab编写BP神经网络程序

matlab编写BP神经网络很方便的，这个工作不用像编程序的C什么的那样还要编写算法。这个算法早已经在软件的库里提供了。你只要用一条语句就出来了。把参数，深度和节点固定的往里一代数就可以了。还有一点，注意最后结果的收敛性，神经网络发展一直是曲折前进的，为什么这样，现在不太给力，因为面临着一个收敛的问题，实现起来效果不好。这些程序网上有很多，你借一本基本的神经网络的书里面也有。望采纳。

㈣ 如何用代码编写一个神经网络异或运算器

配置环境、安装合适的库、下载数据集……有时候学习深度学习的前期工作很让人沮丧，如果只是为了试试现在人人都谈的深度学习，做这些麻烦事似乎很不值当。但好在我们也有一些更简单的方法可以体验深度学习。近日，编程学习平台 Scrimba 联合创始人 Per Harald Borgen 在 Medium 上发文介绍了一种仅用30行 JavaScript 代码就创建出了一个神经网络的教程，而且使用的工具也只有 Node.js、Synaptic.js 和浏览器而已。另外，作者还做了一个交互式 Scrimba 教程，也许能帮你理解其中的复杂概念。

Synaptic.js：http://synaptic.juancazala.com

Node.js：http://nodejs.org

Scrimba 教程：http://scrimba.com/casts/cast-1980

Synaptic.js 让你可以使用 Node.js 和浏览器做深度学习。在这篇文章中，我将介绍如何使用 Synaptic.js 创建和训练神经网络。

//创建网络const { Layer, Network }= window.synaptic;var inputLayer = new Layer(2);var hiddenLayer = new Layer(3);var outputLayer = new Layer(1);

inputLayer.project(hiddenLayer);

hiddenLayer.project(outputLayer);var myNetwork = new Network({

input: inputLayer,

hidden:[hiddenLayer],

output: outputLayer

});//训练网络——学习异或运算var learningRate =.3;for (var i =0; i <20000; i++)

{//0,0=>0

myNetwork.activate([0,0]);

myNetwork.propagate(learningRate,[0]);//0,1=>1

myNetwork.activate([0,1]);

myNetwork.propagate(learningRate,[1]);//1,0=>1

myNetwork.activate([1,0]);

myNetwork.propagate(learningRate,[1]);//1,1=>0

myNetwork.activate([1,1]);

myNetwork.propagate(learningRate,[0]);

}//测试网络console.log(myNetwork.activate([0,0]));//[0.0]console.log(myNetwork.activate([0,1]));//[0.]console.log(myNetwork.activate([1,0]));//[0.]console.log(myNetwork.activate([1,1]));//[0.0]

我们将创建一个最简单的神经网络：一个可以执行异或运算的网络。上面就是这个网络的全部代码，但在我们深入解读这些代码之前，首先我们先了解一下神经网络的基础知识。

神经元和突触

神经网络的基本构造模块是神经元。神经元就像是一个函数，有几个输入，然后可以得到一个输出。神经元的种类有很多。我们的网络将使用 sigmoid 神经元，它可以输入任何数字并将其压缩到0 到1 之间。下图就是一个 sigmoid 神经元。它的输入是5，输出是1。箭头被称为突触，可以将该神经元与网络中的其它层连接到一起。

现在训练这个网络：

// train the network - learn XORvar learningRate =.3;for (var i =0; i <20000; i++){ //0,0=>0

myNetwork.activate([0,0]);

myNetwork.propagate(learningRate,[0]);//0,1=>1

myNetwork.activate([0,1]);

myNetwork.propagate(learningRate,[1]);//1,0=>1

myNetwork.activate([1,0]);

myNetwork.propagate(learningRate,[1]);//1,1=>0

myNetwork.activate([1,1]);

myNetwork.propagate(learningRate,[0]);

}

这里我们运行该网络20000次。每一次我们都前向和反向传播4 次，为该网络输入4 组可能的输入：[0,0][0,1][1,0][1,1]。

首先我们执行 myNetwork.activate([0,0])，其中[0,0]是我们发送给该网络的数据点。这是前向传播，也称为激活这个网络。在每次前向传播之后，我们需要执行反向传播，这时候网络会更新自己的权重和偏置。

反向传播是通过这行代码完成的：myNetwork.propagate(learningRate,[0])，其中 learningRate 是一个常数，给出了网络每次应该调整的权重的量。第二个参数0 是给定输入[0,0]对应的正确输出。

然后，该网络将自己的预测与正确的标签进行比较，从而了解自己的正确程度有多少。

然后网络使用这个比较为基础来校正自己的权重和偏置值，这样让自己的下一次猜测更加正确一点。

这个过程如此反复20000次之后，我们可以使用所有四种可能的输入来检查网络的学习情况：

->[0.0]console.log(myNetwork.activate([0,1]));

->[0.]console.log(myNetwork.activate([1,0]));

->[0.]console.log(myNetwork.activate([1,1]));

->[0.0]

如果我们将这些值四舍五入到最近的整数，我们就得到了正确的异或运算结果。

这样就完成了。尽管这仅仅只碰到了神经网络的表皮，但也足以帮助你进一步探索 Synaptic 和继续学习了。http://github.com/cazala/synaptic/wiki 这里还包含了更多好教程。

㈤ 如何建立神经网络模型

人工神经网络有很多种，我只会最常用的BP神经网络。不同的网络有不同的结构和不同的学习算法专。
简单点说，人工属神经网络就是一个函数。只是这个函数有别于一般的函数。它比普通的函数多了一个学习的过程。
在学习的过程中，它根据正确结果不停地校正自己的网络结构，最后达到一个满意的精度。这时，它才开始真正的工作阶段。
学习人工神经网络最好先安装MathWords公司出的MatLab软件。利用该软件，你可以在一周之内就学会建立你自己的人工神经网络解题模型。
如果你想自己编程实现人工神经网络，那就需要找一本有关的书籍，专门看神经网络学习算法的那部分内容。因为“学习算法”是人工神经网络的核心。最常用的BP人工神经网络，使用的就是BP学习算法。

㈥ 神经网络编程入门

听到 神经网络 这个词，从直觉上我们会想到大脑，的确，我们可以将大脑看成一个大型的天然神经网络。然而，人工神经网络又是什么呢？人工是一个与天然相对的词，我们首先想到的就是人工大脑或者机器人，这就是所谓的人工。在这种情况下，受人脑的启发，我们创建出一个和人脑相似的结构，称之为人工智能。

结合人脑的特点和结构，可以说人工神经网络是一种自然启发的方法。每个神经元与许多其他神经元相接，这些神经元又会和其他大量神经元相连，形成一个高度互连的结构。神经元之间的连通性解释了学习能力，因为每个连接都可以根据刺激和期望目标进行配置。

人工神经元

人工神经元是最基本的人工神经元素，已证明生物神经元是信号处理器，神经元中的树突会根据接受信号的强弱和振幅。发送信号到轴突。可以这样认为，神经元在输入上有一个信号收集器，在输出上有一个激活单元，它可以触发一个新的信号，然后传递给其他神经元。

激活函数

激活函数是指一个神经元根据输入信号，执行计算并产生输出。从数学方面讲，激活函数用于为神经网络模型的处理加入非线性因素，从而提供人工神经网络的非线性行为，这对模拟生物神经元的非线性特征非常有用。激活函数通常是一个非线性函数，输出限制在某个区间范围内，但某些特定情况下，也可以是线性函数。

权重

尽管神经网络的结构能固定，但通过神经元之间的连接权重能够增强或减弱接收到的神经信号，所以可以通过修改权重影响神经元的输出。因此，神经元的激活不仅依赖输入信号，还依赖权重。如果输入来自其他神经元或者外部世界，权重可以看成神经网络在神经元之间建立的连接。

偏置

作为一个独立组件，偏置主要为激活函数增加一个额外信号，这对人工神经元非常有用。

层

为抽象化处理层次，如我们大脑处理问题的方式，神经元按层组织。输入层接受外部世界的直接刺激，输出层触发一些行为，对外部世界产生直接影响。输入层和输出层之间，有许多隐含层，某种意义上，这些隐含层对外部世界不可见。在人工神经网络中，同一层的所有神经元具有相同的输入和激活函数。

神经网络可以有不同的布局，主要取决于神经元或层之间是如何连接的，每一个神经网络体系结构都是为特定目标而设计。神经网络可以应用于许多问题，根据问题的性质，神经网络旨在高效解决问题。

单层网络

单层网络体系中，所有神经元都处于同一层，形成单个层。

多层网络

多层网络中，神经元分成多个层，每层对应神经元的一个平行布局，每层神经元都共享相同的输入数据。

前馈网络

神经网络中的信号流动可以是单向的，也可以是递归的。对于第一种结构，称之为前馈网络，输入信号被送入输入层，经过处理后向前传递到下一层。多层感知机和径向基函数都是前馈网络

反馈网络

当神经网络中有某种内部递归时，这意味着信号会反向传递到已经接受或已经处理过信号的神经元或层，这类网络类型为反馈网络。

㈦ 基于matlab或C#的神经网络编程

1.人工神经元( Artificial Neuron )模型

人工神经元是神经网络的基本元素，其原理可以用下图表示：

若神经元的净激活net为正，称该神经元处于激活状态或兴奋状态(fire)，若净激活net为负，则称神经元处于抑制状态。

图1中的这种“阈值加权和”的神经元模型称为M-P模型( McCulloch-Pitts Model )，也称为神经网络的一个处理单元( PE, Processing Element )。

㈧ matlab编程问题，建立BP神经网络

%采用动量梯度下降算法训练 BP 网络。
close all
clear
echo on
clc
% NEWFF——生成一个新的前向神经网络
% TRAIN——对 BP 神经网络进行训练
% SIM——对 BP 神经网络进行仿真
pause
% 敲任意键开始
clc
% 定义训练样本
% P 为输入矢量 pau
P=[-1,-2,3,1;-1,1,5,-3];
% T 为目标矢量
T=[-1, -1, 1, 1];
pause;
clc
% 创建一个新的前向神经网络
minmax(P)
net=newff(minmax(P),[3,1],{'tansig''purelin'},'traingdm');
% minmax(P)取值范围是P内的最小值到最大值 [3,1]是3个神经元 1维 tansig purelin traingdm各层神经网络的激励函数
% tansig purelin隐含层更改权值的函数 当前输入层权值和阈值
inputWeights=net.IW{1,1};
inputbias=net.b{1};
% 当前网络层权值和阈值
layerWeights=net.LW{2,1};
layerbias=net.b{2};
%表示对各层神经网络的权值与阈值传递到相应变量
pause
clc
% 设置训练参数
net.trainParam.show = 50; %训练显示间隔 50次显示一次
net.trainParam.lr = 0.05; %学习步长0.05学习率
net.trainParam.mc = 0.9; %动量项系数0.9
net.trainParam.epochs = 1000; %训练次数1000次
net.trainParam.goal = 1e-3; %训练精度目标为0.001
pause
clc
% 调用 traingdm 算法训练 BP 网络
[net,tr]=train(net,P,T);%调用网络指令
pause
clc
% 对 BP 网络进行仿真
A=sim(net,P)
% 计算仿真误差
E=T-A
MSE=mse(E)
pause
clc
echo off

㈨ 神经网络怎么进行Gui编程

神经网络算法，通过一次次地训练来调节神经节点的连接权重，能够有效地进行模式识别。
比如电脑可以快速分辨出
00000000
和
00000O00
之间内容不同。
但是却很难认为找茬游戏的两张图片是相似图片。
使用神经网络，可以瞬间识别出两张图片的相似程度（需要用其中一张长期训练）。
总而言之，神经网络算法给了程序模式识别的能力。

㈩ 用matlab编程实现用RBF神经网络预测客流

%% 清空环境变量
clc
clear
close all
%%
a=load('walk1.txt');%读取数据 % xlsread（‘ ‘）；读取execl文件
data=a(1:500,5);%样本数据和测试数据
order=5;%输入数据个数
snum=200;%训练样本数
step=3;%预测步数
input=data(1:snum);
output=data(1+order+step:snum+order+step);
delay=200;%训练样本与测试样本间时延
input1=data(1+delay:snum+delay);
output1=date(1+order+delay+step:snum+order+delay+step);
input_train=zeros(snum,order);input_test=zeros(snum,order);
for i=1:snum
input_train(i,:)=data(i:i+order-1);
input_test(i,:)=data(i+delay:i+delay+order-1);
end
%% RBF神经网络预测
%% 网络建立和训练
net=newrb(input_train',output',0.001,100,300,25);
% net=newrbe(input_train',output',100);
% net=newgrnn(input_train',output',10);
%% 网络验证
ty=sim(net,input_train');
errR=abs(output-ty');
ty1=sim(net,input_test');
errR1=abs(output1-ty1');

figure
plot(1:snum,output1,'r*-');
hold on;
plot(1:snum,ty1','kx-');
title('三步RBF');
xlabel('数据序号');
ylabel('数据值');
legend('实际值','预测值');

figure
subplot(2,1,1);
stem(1:snum,errR1,'r*');
title('三步RBF');
xlabel('数据序号');
ylabel('绝对误差值');
rbfmean = mean(errR1)
subplot(2,1,2);
stem(1:snum,
abs(errR1./output1),'r*');
title('三步RBF');
xlabel('数据序号');
ylabel('绝对误差率');
rbfpmean = mean(abs(errR1./output1))*100%%
自己对着改一下。