DL学习笔记——概率和非线性建模，激活函数

0.python基础

https://www.codecademy.com/catalog

1.github

https://github.com/iamtrask/Grokking-Deep-Learning

2.AI

https://www.codecademy.com/catalog/subject/artificial-intelligence

———————————————————————————————————————————

9.1 激活函数

激活函数必须满足：

1.函数必须连续，且定义域是无穷的

2.好的激活函数是单调的，不会改变方向

3.好的激活函数是非线性的（扭曲或反转）

4.合适的激活函数（及其倒数），应该是易于计算的

9.2 标准隐藏层激活函数

基础激活函数：sigmoid

它能平滑的将输入无穷的空间平滑的变换到0到1之间。

对于隐藏层来说 tanh比sigmoid更合适。

tanh的取值范围是-1到1之间，不仅可以表示正相关，还可以表示负相关。

9.3 标准输出层激活函数

类型1：预测原始数据值（没有激活函数）

类型2：预测不相关的“是”或“否”的概率（sigmoid）

类型3：预测“哪一个”的概率（softmax）

9.4 核心问题：输入具有相似性

9.5 计算softmax

softmax计算每个输入值的指数形式，再除以该层 的和。

softmax的优点：神经网络对一个值的预测越高，它对其它值得预测就越低。它增加了信号的衰减锐度。

要调整它的执行力度，可以在指数运算时使用略高于或低于e的数座底数。数值越小衰减越小，数据越大，衰减越大。

9.6 将输出转换为斜率（导数）

大多数优秀的激活函数没有按照通常的习惯在曲线上的某一个点计算导数，而是尝试着采用另一种方法：用神经元层在正向传播时的输出来计算导数。这已经成为计算神经网络导数的标准实践，而且非常方便。

import numpy as np, sys
np.random.seed(1)

from keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

images, labels = (x_train[0:1000].reshape(1000,28*28) / 255, y_train[0:1000])

one_hot_labels = np.zeros((len(labels),10))
for i,l in enumerate(labels):
    one_hot_labels[i][l] = 1
labels = one_hot_labels

test_images = x_test.reshape(len(x_test),28*28) / 255
test_labels = np.zeros((len(y_test),10))
for i,l in enumerate(y_test):
    test_labels[i][l] = 1

def tanh(x):
    return np.tanh(x)

def tanh2deriv(output):
    return 1 - (output ** 2)

def softmax(x):
    temp = np.exp(x)
    return temp / np.sum(temp, axis=1, keepdims=True)

alpha, iterations, hidden_size = (2, 300, 100)
pixels_per_image, num_labels = (784, 10)
batch_size = 100 

weights_0_1 = 0.02*np.random.random((pixels_per_image,hidden_size))-0.01 #将tanh的值调整到-0.01和0.01之间。

weights_1_2 = 0.2*np.random.random((hidden_size,num_labels)) - 0.1  # 用np.random.random来创建一个数值随机分布在0和1之间的矩阵。通过将它乘以0.2再减去0.1，将输出调整在-0.1和0.1之间。这对relu来说效果很好。

for j in range(iterations):
    correct_cnt = 0
    for i in range(int(len(images) / batch_size)):
        batch_start, batch_end=((i * batch_size),((i+1)*batch_size))
        layer_0 = images[batch_start:batch_end]
        layer_1 = tanh(np.dot(layer_0,weights_0_1))
        dropout_mask = np.random.randint(2,size=layer_1.shape)
        layer_1 *= dropout_mask * 2
        layer_2 = softmax(np.dot(layer_1,weights_1_2))

        for k in range(batch_size):
            correct_cnt += int(np.argmax(layer_2[k:k+1]) == np.argmax(labels[batch_start+k:batch_start+k+1]))

        layer_2_delta = (labels[batch_start:batch_end]-layer_2) / (batch_size * layer_2.shape[0])
        layer_1_delta = layer_2_delta.dot(weights_1_2.T) * tanh2deriv(layer_1)
        layer_1_delta *= dropout_mask

        weights_1_2 += alpha * layer_1.T.dot(layer_2_delta)
        weights_0_1 += alpha * layer_0.T.dot(layer_1_delta)

    test_correct_cnt = 0

    for i in range(len(test_images)):

        layer_0 = test_images[i:i+1]
        layer_1 = tanh(np.dot(layer_0,weights_0_1))
        layer_2 = np.dot(layer_1,weights_1_2)

        test_correct_cnt += int(np.argmax(layer_2) == np.argmax(test_labels[i:i+1]))
    if(j % 10 == 0):
        sys.stdout.write("\n"+ \
         "I:" + str(j) + \
         " Test-Acc:"+str(test_correct_cnt/float(len(test_images)))+\
         " Train-Acc:" + str(correct_cnt/float(len(images))))