python: 深度學習-梯度

梯度的實現：

 

import numpy as np

def numerical_gradient(f,x):     
    #數值微分求梯度,f為函數，x為NumPy數組，該函數對數組x的各個元素求數值微分
    
    h=1e-4#0.0001
    grad=np.zeros_like(x)#生成和x形狀相同的數組
    
    for idx in range(x.size):
        tmp_val=x[idx]
        #f(x+h)的計算
        x[idx]=tmp_val+h
        fxh1=f(x)
        
        #f(x-h)的計算
        x[idx]=tmp_val-h
        fxh2=f(x)
        
        grad[idx]=(fxh1-fxh2)/(2*h)
        x[idx]=tmp_val #還原值
        
    return grad
    
def function_2(x):
    return x[0]**2+x[1]**2
    
print(numerical_gradient(function_2,np.array([3.0,4.0])))

 

梯度下降法的實現：

def gradient_descent(f,init_x,lr=0.01,step_num=100):  #f是函數
    x=init_x  #init_x是初始值
    
    for i in range(step_num):
        grad=numerical_gradient(f,x)
        x-=lr*grad
        
    return x

神經網絡的梯度

 

　　　　

下面，我們以一個簡單的神經網絡為例，來實現求梯度的代碼：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 為了導入父目錄中的文件而進行的設定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import 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)     #z=xW
        y = softmax(z)
        loss = cross_entropy_error(y, t)    #交叉熵誤差

        return loss

x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])

net = simpleNet()

f = lambda w: net.loss(x, t)   #f是損失函數
dW = numerical_gradient(f, net.W)       

print(dW)

 

學習算法的實現：

前提

神經網絡存在合適的權重和偏置，調整權重和偏置以便擬合訓練數據的過程稱為“學習”。神經網絡的學習分成下面 4 個步驟。

步驟 1（mini-batch）

從訓練數據中隨機選出一部分數據，這部分數據稱為 mini-batch。我們的目標是減小 mini-batch 的損失函數的值。

步驟 2（計算梯度）

為了減小 mini-batch 的損失函數的值，需要求出各個權重參數的梯度。梯度表示損失函數的值減小最多的方向。

步驟 3（更新參數）

將權重參數沿梯度方向進行微小更新。

步驟 4（重復）

重復步驟 1、步驟 2、步驟 3。

 

2層神經網絡的類：

 

import sys,os
sys.path.append(os.pardir)
from common.functions import *
from common.gradient import numerical_gradient

class TwoLayerNet:
    def __init__(self,input_size,hidden_size,output_size,weight_init_std=0.01):
        #初始化權重
        self.params={}
        self.params['W1']=weight_init_std*np.random.randn(input_size,hidden_size)
        self.params['b1']=np.zeros(hidden_size)
        self.params['W2']=weight_init_std*np.random.randn(hidden_size,output_size)
        self.params['b2']=np.zeros(output_size)
        
    def predict(self,x):
        W1,W2=self.params['W1'],self.params['W2']
        b1,b2=self.params['b1'],self.params['b2']
        
        a1=np.dot(x,W1)+b1
        z1=sigmoid(a1)
        a2=np.dot(z1,W2)+b2
        y=softmax(a2)
        
        return y
        
    def loss(self,x,t):
        y=self.predict(x)
        
        return cross_entropy_error(y,t)
        
    def accuracy(self,x,t):
        y=self.predict(x)
        y=np.argmax(y,axis=1)
        t=np.argmax(t,axis=1)
        
        accuracy=np.sum(y==t)/float(x.shape[0])
        return accuracy
        
    def numerical_gradient(self,x,t):
        loss_W=lambda W: self.loss(x,t)
        
        grads={}
        grads['W1']=numerical_gradient(loss_W,self.params['W1'])
        grads['b1']=numerical_gradient(loss_W,self.params['b1'])
        grads['W2']=numerical_gradient(loss_W,self.params['W2'])
        grads['b2']=numerical_gradient(loss_W,self.params['b2'])
        
        return grads

 mini-batch的實現：

import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

(x_train, t_train), (x_test, t_test) = \ load_mnist(normalize=True, one_hot_
label = True)

train_loss_list = []

# 超參數
iters_num = 10000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

for i in range(iters_num):
    # 獲取mini-batch
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    # 計算梯度
    grad = network.numerical_gradient(x_batch, t_batch)
    # grad = network.gradient(x_batch, t_batch) # 高速版!

    # 更新參數
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]

    # 記錄學習過程
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)