【自学记录】深度学习入门——基于Python的理论与实现（第4章 神经网络的学习）

4.2 损失函数

#损失函数
#均方误差
def mean_squared_error(y,t):
    return 0.5*np.sum((y-t)**2)
#交叉熵误差
def _cross_entropy_error(y,t):
    delta=1e-7
    return -np.sum(t*np.log(y+delta))

#交叉熵损失函数
def cross_entropy_error(y,t):
    if y.ndim==1:
        t=t.reshape(1,t.size)
        y=y.reshape(1,y.size)
    # 把one-hot-vector 转化为正确的【10000，】 索引
    if t.size==y.size:
        t=t.argmax(axis=1)
    batch_size=y.shape[0]#一批有多少，就是y有多少行
    return -np.sum(np.log(y[np.arange(batch_size),t]+1e-7))/batch_size
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.3数值微分

#数值法求导数、偏导数   
def f(x):
    return x**2
def f2(x):
    return x[0]**2+x[1]**2

#数值法求导数（单个）
def numerical_diff(f,x):
    h=1e-4
    return (f(x+h)-f(x-h))/(2*h)

#求f2在点（3,4）处x1的偏导的中间函数
def f22(x):
    return x**2+4**2 

x=np.array([3.0,4.0])

#数值法求y=x**2在x=3下的导数
y=numerical_diff(f,3)
print("x**2在3的导数为"+str(y))

#数值法求单个y2=x1**2+x2**2在（3,4）下x1的偏导 
# f22是f(x,4),先把x2带入 
y2=numerical_diff(f22,3)
print("x1**2+x2**2在（3,4）的x1偏导数为"+str(y2))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.4 梯度

############4.4梯度#################
#数值法求梯度 即（dx1,dx2）,一起计算x0、x1的偏导
def numerical_gradient(f,x):
    h=1e-4#0.0001
    grad=np.zeros_like(x)#生成和x相同的数组
    for idx in range(x.size):#如X[3,4],X不一定是一个数，可能是F（x1,x2）,x1,x2两点处的偏导都要求
        tmp_val=x[idx]
        # f(x+h)
        x[idx]=tmp_val+h#x[3+h,4]
        fxh1=f(x)#F(3+h,4)

        #f(x-h)
        x[idx]=tmp_val-h
        fxh2=f(x)

        grad[idx]=(fxh1-fxh2)/(2*h) #[F(3+h,4)-F(3-h,4)]/(2*h)
        x[idx]=tmp_val#恢复X为X【3,4】
    return grad    
#数值法求个y2=x1**2+x2**2在（3,4）的偏导数
y2=numerical_gradient(f2,x)
print("x1**2+x2**2在（3,4）的偏导数为"+str(y2))

#梯度下降
#lr 学习率  学习率过大，会发散成一个很大的值，学习率过小，基本没怎么更新就结束了
#step_num梯度法的重复次数
def gradient_descent(f,init_x,lr=0.01,step_num=100):
    x=init_x
    for i in range(step_num):
        grad=numerical_gradient(f,x)#求此点的数值梯度
        x-=lr*grad #X每一次都在更新
    return x    
#求F2的最小值
init_x=np.array([-3.0,4.0])
min_x=gradient_descent(f2,init_x,lr=0.1,step_num=100)
min_y=f2(min_x)
print("F2mim=F2"+str(min_x)+"="+str(min_y))#与实际最小值（0,0）很接近
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

求简单神经网络的梯度

import sys, os
sys.path.append(os.pardir)  # 为了导入父目录中的文件而进行的设定
import numpy as np
from study03_NeuralNetwork import softmax
from study04_NeuralNetworkStudy import cross_entropy_error,numerical_gradient

class simpleNet:
    def __init__(self):
        self.W=np.random.randn(2,3)#初始化
    
    def predict(self,x):
        return np.dot(x,self.W)
    def loss(self,x,t):
        z=self.predict(x)
        y=softmax(z)
        loss=cross_entropy_error(y,t)
        return loss


net=simpleNet()
#print(net.W)
x=np.array([0.6,0.9])

p=net.predict(x)
print("predict_p="+str(p))

t=np.array([0,0,1])#正确解的标签

loss=net.loss(x,t)
print("loss="+str(loss))

f = lambda w: net.loss(x, t) 
dW=numerical_gradient(f,net.W)
print("dW="+str(dW))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34