編程是怎麼實現神經網路

㈠ 神經網路的編程基礎——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%%
自己對著改一下。