原來ReLU這么好用！一文帶你深度了解ReLU激活函數！

在神經網絡中，激活函數負責將來自節點的加權輸入轉換為該輸入的節點或輸出的激活。ReLU 是一個分段線性函數，如果輸入為正，它將直接輸出，否則，它將輸出為零。它已經成為許多類型神經網絡的默認激活函數，因為使用它的模型更容易訓練，并且通常能夠獲得更好的性能。在本文中，我們來詳細介紹一下ReLU，主要分成以下幾個部分：

創新互聯建站始終堅持【策劃先行，效果至上】的經營理念，通過多達10年累計超上千家客戶的網站建設總結了一套系統有效的全網營銷推廣解決方案，現已廣泛運用于各行各業的客戶，其中包括：OPP膠袋等企業，備受客戶夸獎。

1、Sigmoid 和 Tanh 激活函數的局限性

2、ReLU（Rectified Linear Activation Function）

3、如何實現ReLU

4、ReLU的優點

5、使用ReLU的技巧

一個神經網絡由層節點組成，并學習將輸入的樣本映射到輸出。對于給定的節點，將輸入乘以節點中的權重，并將其相加。此值稱為節點的summed activation。然后，經過求和的激活通過一個激活函數轉換并定義特定的輸出或節點的“activation”。

最簡單的激活函數被稱為線性激活，其中根本沒有應用任何轉換。 一個僅由線性激活函數組成的網絡很容易訓練，但不能學習復雜的映射函數。線性激活函數仍然用于預測一個數量的網絡的輸出層(例如回歸問題)。

非線性激活函數是更好的，因為它們允許節點在數據中學習更復雜的結構 。兩個廣泛使用的非線性激活函數是 sigmoid 函數和 雙曲正切 激活函數。

Sigmoid 激活函數 ，也被稱為 Logistic函數神經網絡，傳統上是一個非常受歡迎的神經網絡激活函數。函數的輸入被轉換成介于0.0和1.0之間的值。大于1.0的輸入被轉換為值1.0，同樣，小于0.0的值被折斷為0.0。所有可能的輸入函數的形狀都是從0到0.5到1.0的 s 形。在很長一段時間里，直到20世紀90年代早期，這是神經網絡的默認激活方式。

雙曲正切函數 ，簡稱 tanh，是一個形狀類似的非線性激活函數，輸出值介于-1.0和1.0之間。在20世紀90年代后期和21世紀初期，由于使用 tanh 函數的模型更容易訓練，而且往往具有更好的預測性能，因此 tanh 函數比 Sigmoid激活函數更受青睞。

Sigmoid和 tanh 函數的一個普遍問題是它們值域飽和了 。這意味著，大值突然變為1.0，小值突然變為 -1或0。此外，函數只對其輸入中間點周圍的變化非常敏感。

無論作為輸入的節點所提供的求和激活是否包含有用信息，函數的靈敏度和飽和度都是有限的。一旦達到飽和狀態，學習算法就需要不斷調整權值以提高模型的性能。

最后，隨著硬件能力的提高，通過 gpu 的非常深的神經網絡使用Sigmoid 和 tanh 激活函數不容易訓練。在大型網絡深層使用這些非線性激活函數不能接收有用的梯度信息。錯誤通過網絡傳播回來，并用于更新權重。每增加一層，錯誤數量就會大大減少。這就是所謂的 消失梯度 問題，它能有效地阻止深層(多層)網絡的學習。

雖然非線性激活函數的使用允許神經網絡學習復雜的映射函數，但它們有效地阻止了學習算法與深度網絡的工作。在2000年代后期和2010年代初期，通過使用諸如波爾茲曼機器和分層訓練或無監督的預訓練等替代網絡類型，這才找到了解決辦法。

為了訓練深層神經網絡， 需要一個激活函數神經網絡，它看起來和行為都像一個線性函數，但實際上是一個非線性函數，允許學習數據中的復雜關系 。該函數還必須提供更靈敏的激活和輸入，避免飽和。

因此，ReLU出現了， 采用 ReLU 可以是深度學習革命中為數不多的里程碑之一 。ReLU激活函數是一個簡單的計算，如果輸入大于0，直接返回作為輸入提供的值；如果輸入是0或更小，返回值0。

我們可以用一個簡單的 if-statement 來描述這個問題，如下所示:

對于大于零的值，這個函數是線性的，這意味著當使用反向傳播訓練神經網絡時，它具有很多線性激活函數的理想特性。然而，它是一個非線性函數，因為負值總是作為零輸出。由于矯正函數在輸入域的一半是線性的，另一半是非線性的，所以它被稱為 分段線性函數（piecewise linear function ） 。

我們可以很容易地在 Python 中實現ReLU激活函數。

我們希望任何正值都能不變地返回，而0.0或負值的輸入值將作為0.0返回。

下面是一些修正的線性激活函數的輸入和輸出的例子：

輸出如下：

我們可以通過繪制一系列的輸入和計算出的輸出，得到函數的輸入和輸出之間的關系。下面的示例生成一系列從 -10到10的整數，并計算每個輸入的校正線性激活，然后繪制結果。

運行這個例子會創建一個圖，顯示所有負值和零輸入都突變為0.0，而正輸出則返回原樣：

ReLU函數的導數是斜率。負值的斜率為0.0，正值的斜率為1.0。

傳統上，神經網絡領域已經不能是任何不完全可微的激活函數，而ReLU是一個分段函數。從技術上講，當輸入為0.0時，我們不能計算ReLU的導數，但是，我們可以假設它為0。

tanh 和 sigmoid 激活函數需要使用指數計算， 而ReLU只需要max()，因此他 計算上更簡單，計算成本也更低 。

ReLU的一個重要好處是，它能夠輸出一個真正的零值 。這與 tanh 和 sigmoid 激活函數不同，后者學習近似于零輸出，例如一個非常接近于零的值，但不是真正的零值。這意味著負輸入可以輸出真零值，允許神經網絡中的隱層激活包含一個或多個真零值。這就是所謂的稀疏表示，是一個理想的性質，在表示學習，因為它可以加速學習和簡化模型。

ReLU看起來更像一個線性函數，一般來說，當神經網絡的行為是線性或接近線性時，它更容易優化 。

這個特性的關鍵在于，使用這個激活函數進行訓練的網絡幾乎完全避免了梯度消失的問題，因為梯度仍然與節點激活成正比。

ReLU的出現使得利用硬件的提升和使用反向傳播成功訓練具有非線性激活函數的深層多層網絡成為可能 。

很長一段時間，默認的激活方式是Sigmoid激活函數。后來，Tanh成了激活函數。 對于現代的深度學習神經網絡，默認的激活函數是ReLU激活函數 。

ReLU 可以用于大多數類型的神經網絡， 它通常作為多層感知機神經網絡和卷積神經網絡的激活函數 ，并且也得到了許多論文的證實。傳統上，LSTMs 使用 tanh 激活函數來激活cell狀態，使用 Sigmoid激活函數作為node輸出。 而ReLU通常不適合RNN類型網絡的使用。

偏置是節點上具有固定值的輸入，這種偏置會影響激活函數的偏移，傳統的做法是將偏置輸入值設置為1.0。當在網絡中使用 ReLU 時， 可以將偏差設置為一個小值，例如0.1 。

在訓練神經網絡之前，網絡的權值必須初始化為小的隨機值。當在網絡中使用 ReLU 并將權重初始化為以零為中心的小型隨機值時，默認情況下，網絡中一半的單元將輸出零值。有許多啟發式方法來初始化神經網絡的權值，但是沒有最佳權值初始化方案。 何愷明的文章指出Xavier 初始化和其他方案不適合于 ReLU ，對 Xavier 初始化進行一個小的修改，使其適合于 ReLU，提出He Weight Initialization，這個方法更適用于ReLU 。

在使用神經網絡之前對輸入數據進行縮放是一個很好的做法。這可能涉及標準化變量，使其具有零均值和單位方差，或者將每個值歸一化為0到1。如果不對許多問題進行數據縮放，神經網絡的權重可能會增大，從而使網絡不穩定并增加泛化誤差。 無論是否在網絡中使用 ReLU，這種縮放輸入的良好實踐都適用。

ReLU 的輸出在正域上是無界的。這意味著在某些情況下，輸出可以繼續增長。因此，使用某種形式的權重正則化可能是一個比較好的方法，比如 l1或 l2向量范數。 這對于提高模型的稀疏表示(例如使用 l 1正則化)和降低泛化誤差都是一個很好的方法 。

.

怎么用python寫tensorflow

開始使用

TensorFlow并不是一個純粹的神經網絡框架, 而是使用數據流圖進行數值分析的框架.

TensorFlow使用有向圖(graph)表示一個計算任務.圖的節點稱為ops(operations)表示對數據的處理,圖的邊flow 描述數據的流向.

該框架計算過程就是處理tensor組成的流. 這也是TensorFlow名稱的來源.

TensorFlow使用tensor表示數據. tensor意為張量即高維數組,在python中使用numpy.ndarray表示.

TensorFlow使用Session執行圖, 使用Variable維護狀態.tf.constant是只能輸出的ops, 常用作數據源.

下面我們構建一個只有兩個constant做輸入, 然后進行矩陣乘的簡單圖:

from tensorflow import Session, device, constant, matmul'''構建一個只有兩個constant做輸入, 然后進行矩陣乘的簡單圖:'''#如果不使用with session()語句, 需要手動執行session.close().

#with device設備指定了執行計算的設備:

# ? ?"/cpu:0": 機器的 CPU.

# ? ?"/gpu:0": 機器的第一個 GPU, 如果有的話.

# ? ?"/gpu:1": 機器的第二個 GPU, 以此類推.

with Session() as session: ?# 創建執行圖的上下文

with device('/cpu:0'): ?# 指定運算設備

mat1 = constant([[3, 3]]) ?# 創建源節點

mat2 = constant([[2], [2]])

product = matmul(mat1, mat2) # 指定節點的前置節點, 創建圖

result = session.run(product) # 執行計算 ? ? ? ?print(result)123456789101112131415161718

下面使用Variable做一個計數器:

from tensorflow import Session, constant, Variable, add, assign, initialize_all_variables

state = Variable(0, name='counter') # 創建計數器one = constant(1) # 創建數據源: 1val = add(state, one) # 創建新值節點update = assign(state, val) # 更新計數器setup = initialize_all_variables() # 初始化Variablewith Session() as session:

session.run(setup) # 執行初始化

print(session.run(state)) # 輸出初值

for i in range(3):

session.run(update) # 執行更新

print(session.run(state)) # 輸出計數器值12345678910111213

在使用變量前必須運行initialize_all_variables()返回的圖, 運行Variable節點將返回變量的值.

本示例中將構建圖的過程寫在了上下文之外, 而且沒有指定運行設備.

上面示例中session.run只接受一個op作為參數, 實際上run可以接受op列表作為輸入:

session.run([op1, op2])1

上述示例一直使用constant作為數據源, feed可以在運行時動態地輸入數據:

from tensorflow import Session, placeholder, mul, float32

input1 = placeholder(float32)

input2 = placeholder(float32)

output = mul(input1, input2)with Session() as session: ? ?print session.run(output, feed_dict={input1: [3], input2: [2]})1234567

實現一個簡單神經網絡

神經網絡是應用廣泛的機器學習模型, 關于神經網絡的原理可以參見這篇隨筆, 或者在tensorflow playground上體驗一下在線demo.

首先定義一個BPNeuralNetwork類:

class BPNeuralNetwork:

def __init__(self):

self.session = tf.Session()

self.input_layer = None

self.label_layer = None

self.loss = None

self.trainer = None

self.layers = [] ? ?def __del__(self):

self.session.close()1234567891011

編寫一個生成單層神經網絡函數,每層神經元用一個數據流圖表示.使用一個Variable矩陣表示與前置神經元的連接權重, 另一個Variable向量表示偏置值, 并為該層設置一個激勵函數.

def make_layer(inputs, in_size, out_size, activate=None):

weights = tf.Variable(tf.random_normal([in_size, out_size]))

basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)

result = tf.matmul(inputs, weights) + basis ? ?if activate is None: ? ? ? ?return result ? ?else: ? ? ? ?return activate(result)12345678

使用placeholder作為輸入層.

self.input_layer = tf.placeholder(tf.float32, [None, 2])1

placeholder的第二個參數為張量的形狀, [None, 1]表示行數不限, 列數為1的二維數組, 含義與numpy.array.shape相同.這里, self.input_layer被定義為接受二維輸入的輸入層.

同樣使用placeholder表示訓練數據的標簽:

self.label_layer = tf.placeholder(tf.float32, [None, 1])1

使用make_layer為神經網絡定義兩個隱含層, 并用最后一層作為輸出層:

self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reduction_indices=[1]))1

tf.train提供了一些優化器, 可以用來訓練神經網絡.以損失函數最小化為目標:

self.trainer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)1

使用Session運行神經網絡模型:

initer = tf.initialize_all_variables()# do trainingself.session.run(initer)

for i in range(limit):

self.session.run(self.trainer, feed_dict={self.input_layer: cases, self.label_layer: labels})12345

使用訓練好的模型進行預測:

self.session.run(self.layers[-1], feed_dict={self.input_layer: case})1

完整代碼:

import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):

weights = tf.Variable(tf.random_normal([in_size, out_size]))

basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)

result = tf.matmul(inputs, weights) + basis ? ?if activate is None: ? ? ? ?return result ? ?else: ? ? ? ?return activate(result)class BPNeuralNetwork:

def __init__(self):

self.session = tf.Session()

self.input_layer = None

self.label_layer = None

self.loss = None

self.optimizer = None

self.layers = [] ? ?def __del__(self):

self.session.close() ? ?def train(self, cases, labels, limit=100, learn_rate=0.05):

# 構建網絡

self.input_layer = tf.placeholder(tf.float32, [None, 2])

self.label_layer = tf.placeholder(tf.float32, [None, 1])

self.layers.append(make_layer(self.input_layer, 2, 10, activate=tf.nn.relu))

self.layers.append(make_layer(self.layers[0], 10, 2, activate=None))

self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reduction_indices=[1]))

self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)

initer = tf.initialize_all_variables() ? ? ? ?# 做訓練

self.session.run(initer) ? ? ? ?for i in range(limit):

self.session.run(self.optimizer, feed_dict={self.input_layer: cases, self.label_layer: labels}) ? ?def predict(self, case):

return self.session.run(self.layers[-1], feed_dict={self.input_layer: case}) ? ?def test(self):

x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

y_data = np.array([[0, 1, 1, 0]]).transpose()

test_data = np.array([[0, 1]])

self.train(x_data, y_data)

print(self.predict(test_data))

nn = BPNeuralNetwork()

nn.test()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

上述模型雖然簡單但是使用不靈活, 作者采用同樣的思想實現了一個可以自定義輸入輸出維數以及多層隱含神經元的網絡, 可以參見dynamic_bpnn.py

import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):

weights = tf.Variable(tf.random_normal([in_size, out_size]))

basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)

result = tf.matmul(inputs, weights) + basis ? ?if activate is None: ? ? ? ?return result ? ?else: ? ? ? ?return activate(result)class BPNeuralNetwork:

def __init__(self):

self.session = tf.Session()

self.loss = None

self.optimizer = None

self.input_n = 0

self.hidden_n = 0

self.hidden_size = []

self.output_n = 0

self.input_layer = None

self.hidden_layers = []

self.output_layer = None

self.label_layer = None

def __del__(self):

self.session.close() ? ?def setup(self, ni, nh, no):

# 設置參數個數

self.input_n = ni

self.hidden_n = len(nh) ?#隱藏層的數量

self.hidden_size = nh ?#每個隱藏層中的單元格數

self.output_n = no ? ? ? ?#構建輸入層

self.input_layer = tf.placeholder(tf.float32, [None, self.input_n]) ? ? ? ?#構建標簽層

self.label_layer = tf.placeholder(tf.float32, [None, self.output_n]) ? ? ? ?#構建隱藏層

in_size = self.input_n

out_size = self.hidden_size[0]

inputs = self.input_layer

self.hidden_layers.append(make_layer(inputs, in_size, out_size, activate=tf.nn.relu)) ? ? ? ?for i in range(self.hidden_n-1):

in_size = out_size

out_size = self.hidden_size[i+1]

inputs = self.hidden_layers[-1]

self.hidden_layers.append(make_layer(inputs, in_size, out_size, activate=tf.nn.relu)) ? ? ? ?#構建輸出層

self.output_layer = make_layer(self.hidden_layers[-1], self.hidden_size[-1], self.output_n) ? ?def train(self, cases, labels, limit=100, learn_rate=0.05):

self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.output_layer)), reduction_indices=[1]))

self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)

initer = tf.initialize_all_variables() ? ? ? ?#做訓練

self.session.run(initer) ? ? ? ?for i in range(limit):

self.session.run(self.optimizer, feed_dict={self.input_layer: cases, self.label_layer: labels}) ? ?def predict(self, case):

return self.session.run(self.output_layer, feed_dict={self.input_layer: case}) ? ?def test(self):

x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

y_data = np.array([[0, 1, 1, 0]]).transpose()

test_data = np.array([[0, 1]])

self.setup(2, [10, 5], 1)

self.train(x_data, y_data)

print(self.predict(test_data))

nn = BPNeuralNetwork()

nn.test()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576

python2.7中的一個代碼在python3.5中運行不了，要如何改

zip(input_vec,?self.weights)假設這里出來的數據結構是?[(1,?4),?(2,?5),?(3,?6)]

那么lambda?(x,?w):?x?*?w?在2.7版本就直接接收?元祖(1,?4)這樣子的數據類型當做一個參數，

（x,w）=依次=(1,?4),?(2,?5),?(3,?6),

但是這個寫法在3.5的時候?，狗日的不認識map（lambda?(x,?w)。。。x[0]?*?x[1]

替代方式我沒去研究?在3.5的時候?我是直接把?x=(1,?4)。。用的時候x[0]?*?x[1]

(reduce(lambda?a,?b:?a?+?b,

map(lambda?x:?x[0]?*?x[1],??

zip(input_vec,?weights))

,?0.0))

網頁標題：python激勵函數 python激活函數
路徑分享：http://vcdvsql.cn/article26/doishcg.html

成都網站建設公司_創新互聯，為您提供品牌網站設計、關鍵詞優化、定制網站、Google、定制開發、小程序開發

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯