西瓜书课后习题——第五章

5.1

需要注意的是，神经网络中必须要有非线性的激活函数，无论是在隐层，还是输出层，或者全部都是。如果用$f(x)=omega ^{T}x$做激活函数，无论多少层神经网络都退化成了线性回归。

5.2

两者都是希望将连续值映射到{0,1}上，但由于阶跃函数不光滑，不连续的性质，所以才选择了sigmoid作为映射函数。不同之处在于激活函数不一定要使用sigmoid，只要是非线性的可导函数都可以使用。

5.3

 

5.4

如果学习率太低，每次下降的很慢，使得迭代次数非常多。 如果学习率太高，在后面迭代时会出现震荡现在，在最小值附近来回波动。

5.5

import pandas as pd
import numpy as np
dataset = pd.read_csv('/home/zwt/PycharmProjects/test/Machine_Learning/课后题/data_5.5.csv', delimiter=",")
attributeMap={}
attributeMap['浅白']=0
attributeMap['青绿']=0.5
attributeMap['乌黑']=1
attributeMap['蜷缩']=0
attributeMap['稍蜷']=0.5
attributeMap['硬挺']=1
attributeMap['沉闷']=0
attributeMap['浊响']=0.5
attributeMap['清脆']=1
attributeMap['模糊']=0
attributeMap['稍糊']=0.5
attributeMap['清晰']=1
attributeMap['凹陷']=0
attributeMap['稍凹']=0.5
attributeMap['平坦']=1
attributeMap['硬滑']=0
attributeMap['软粘']=1
attributeMap['否']=0
attributeMap['是']=1
del dataset['编号']
dataset=np.array(dataset)
m,n=np.shape(dataset)
for i in range(m):
    for j in range(n):
        if dataset[i,j] in attributeMap:
            dataset[i,j]=attributeMap[dataset[i,j]]
        dataset[i,j]=round(dataset[i,j],3)
trueY=dataset[:,n-1]
X=dataset[:,:n-1]
m,n=np.shape(X)
import random
d = n    #输入向量的维度
l = 1    #输出向量的维度
q = d+1  #隐层神经元个数（没有标准值，自己确定，可以编写迭代选择）
theta = [random.random() for i in range(l)]  #l个输出层神经元的阈值
gamma = [random.random() for i in range(q)]  #q个隐层神经元的阈值
v = [[random.random() for i in range(q)] for j in range(d)]  #输入层到隐层的连接权重，v=d*q
w = [[random.random() for i in range(l)] for j in range(q)]  #隐层到输出层的连接权重，w=q*l
eta = 0.2      #学习率
maxIter=5000   #最大迭代次数
import math
def sigmoid(iX,dimension):#iX is a matrix with a dimension
    if dimension==1:
        for i in range(len(iX)):
            iX[i] = 1 / (1 + math.exp(-iX[i]))
    else:
        for i in range(len(iX)):
            iX[i] = sigmoid(iX[i],dimension-1)
    return iX

#BP
while(maxIter>0):
    maxIter -= 1
    sumE = 0
    for i in range(m):
        alpha = np.dot(X[i],v)              #shape=1*q p102 从输入层到隐层的计算结果（用来计算激活函数的输入）
        b = sigmoid(alpha-gamma,1)          #shape=1*q 5.3 激活函数1的输出
        beta = np.dot(b,w)                  #shape=(1*q)*(q*l)=1*l p102 从隐层到输出层的计算结果（用来计算激活函数的输入）
        predictY = sigmoid(beta-theta,1)    #shape=1*l 5.3 激活函数2的输出
        E = sum((predictY-trueY[i]),2)/2    #5.4
        sumE += E                           #5.16
        g = predictY*(1-predictY)*(trueY[i]-predictY)       #shape=1*l , p103--5.10
        e = b*(1-b)*((np.dot(w,g.T)).T)                     #shape=1*q , p104--5.15
        w += eta*np.dot(b.reshape((q,1)),g.reshape((1,l)))  #5.11
        theta -= eta*g                                      #5.12
        v += eta*np.dot(X[i].reshape((d,1)),e.reshape((1,q)))   #5.13
        gamma -= eta*e                                          #5.14
        #dot是矩阵乘,T是转置

#ABP
#标准BP就是对于每一个输入的X个体，都更新一下网络，而累积BP就是把整个X集合都跑一遍，把各种要变化的值累加起来，再更新，累积BP类似于随机梯度下降法，每跑一遍整个集合，更新一次。区别很小
# trueY = trueY.reshape((m,l))
# while(maxIter>0):
#     maxIter -= 1
#     sumE = 0
#     alpha = np.dot(X, v)#p101 line 2 from bottom, shape=m*q
#     b = sigmoid(alpha - gamma,2)  # b=f(alpha-gamma), shape=m*q
#     beta = np.dot(b, w)  # shape=(m*q)*(q*l)=m*l
#     predictY = sigmoid(beta - theta,2)  # shape=m*l ,p102--5.3
#     E = sum(sum((predictY - trueY) * (predictY - trueY))) / 2  # 5.4
#     g = predictY * (1 - predictY) * (trueY - predictY)  # shape=m*l p103--5.10
#     e = b * (1 - b) * ((np.dot(w, g.T)).T)  # shape=m*q , p104--5.15
#     w += eta * np.dot(b.T, g)  # 5.11 shape (q*l)=(q*m) * (m*l)
#     theta -= eta * g  # 5.12
#     v += eta * np.dot(X.T, e)  # 5.13 (d,q)=(d,m)*(m,q)
#     gamma -= eta * e  # 5.14

def predict(iX):
    alpha = np.dot(iX, v)  # p101 line 2 from bottom, shape=m*q
    b=sigmoid(alpha-gamma,2)#b=f(alpha-gamma), shape=m*q
    beta = np.dot(b, w)  # shape=(m*q)*(q*l)=m*l
    predictY=sigmoid(beta - theta,2)  # shape=m*l ,p102--5.3
    return predictY

predict(X)

py = predict(X)
for i in range(len(py)):
    if py[i][0] < 0.5:
        py[i][0] = 0
    else:
        py[i][0] = 1

5.6

5.7

5.8

5.9

5.10