參考資料
<PYTHON_MACHINE_LEARNING> chapter2
Training Ma
chine Learning Algorithms for Classifcation
引言
在上一節,我們學習了梯度下降算法,現在我們來了解一下梯度下降算法的一個類型——隨機梯度下降,每一次更新只考慮一個樣本的數據誤差,所以速度很快,能進行在線的參數更新... ...
原理
基本原理與批量梯度下降算法相同,不同的是更新權值的方法
這是上一章節的權值更新方法
在隨機梯度下降中,我們一次考慮一個樣本的誤差,再逐個加和,一旦到達最小,就可以停下來,所以可以大大加快模擬的速度,同時每一次迭代開始的時候,我們都打亂一遍訓練集,為了減小樣本之間造成的參數更新抵消問題
Python實現
我們在上一節AdalineGD類的基礎上稍加改動就得到了AdalineSGD類
主要的改動有:
- 增加了一個洗牌(shuffle)方法,用于在每一次迭代開始的時候打亂訓練集
- 增加了一個權值更新(._update_weights)方法, 用于更新每一個樣本的誤差
ok
上代碼吧, 有什么問題都在注釋里說明了
__author__ = 'Administrator'
#! /usr/bin/python <br> # -*- coding:utf8 -*-
import numpy as np
from numpy.random import seed
class AdalineSGD(object):
"""
ADAlineSGD Linear Neuron classifier.
Parameters(參數)
------------
eta : float
Learning rate (between 0.0 and 1.0) 學習效率
n_iter : int
Passes over the training dataset(數據集).
Attributes(屬性)
-----------
w_ : 1d-array
Weights after fitting.
errors_ : list
Number of misclassifications in every epoch(時間起點).
shuffle: bool (default :True) 洗牌
每次訓練開始的時候將訓練集重新打亂
如果為真,阻止循環
用隨機數來 打亂數據集 并且初始化權值
"""
def __init__(self, eta=0.01, n_iter=10,shuffle = True,
random_state = None):
self.eta = eta
self.n_iter = n_iter
self.w_initialiezed = False
self.shuffle = shuffle
if random_state:
seed(random_state)
def _shuffle(self, X, y):
"""shuffle training data"""
r = np.random.permutation(len(y))
#random.permutation(array/number)
#接受array的時候返回的是 array 的打亂的排列 ,
# 接受 數字的時候 返回一個 range(number) 的打亂的排列
# 所謂‘排列’可以理解成一個有數組序號組成的數組
#X[r] 就是 X 按照 r 的排列重排的數組(只重排第一個索引(重排行)),
# 同時 X[r] 返回一個copy 的對象
#X 本身并沒有改變
#random.shuffle(array)不返回對象,重排array,改變array本身
return X[r], y[r]
def _initialize_weights(self, m):
"""Initialize weights to zeros"""
self.w_ = np.zeros(1+m)
#初始化之后把屬性 w_initialiezd 設為 True
self.w_initialiezed = True
def fit(self, X, y):
'''
Fit training data.
Parameters
----------
X : {array-like}, shape = [n_samples, n_features] X的形式是列表的列表
Training vectors, where n_samples is the number of samples
and n_features is the number of features.
y : array-like, shape = [n_samples]
Target values.
Returns
-------
self : object
'''
self._initialize_weights(X.shape[1])
#將 權值屬性self.w_初始化 (100,1)的0數組
#X.shape = (100,2)
self.cost_ =[]
#self.cost_損失函數 cost_function
for i in range(self.n_iter):
#開始默認 shuffle為真
if self.shuffle:
X, y = self._shuffle(X,y)
cost = []
for xi,target in zip(X,y):
cost.append(self._update_weights(xi,target))
avg_cost = sum(cost)/len(y)
#avg_cost = np.array(cost).mean()
#也可用這種方法求平均數
self.cost_.append(avg_cost)
return self
def partial_fit(self, X, y):
"""Fit training data without reinitializing the weights"""
if not self.w_initialiezed:
self._initialize_weights(X.shape[1])
if y.ravel().shape[0] > 1:
for xi, target in zip(X, y):
self._update_weights(xi,target)
else:
self._update_weights(X, y)
return self
def _update_weights(self, xi, target):
"""Apply Adaline learning rule to update the weights"""
output = self.net_input(xi)
error = (target - output)
#每次error都是一個float
#xi對應一個樣本 (2,1)
#wi 的 update = eta* xi[i]*error
self.w_[1:] += self.eta * xi.dot(error)
self.w_[0] += self.eta * error
cost = 0.5 * error ** 2
return cost
def net_input(self, X):
"""Calculate net input"""
#np.dot(A,B)表示矩陣乘法 ,X(100,2) self.w_[1:](2,1)
#注意 這里每一組 向量x = [x1,x2] 不是 [x1,,,,,,x100]!!!
#所以得到的 net_input 是(100,1)的矩陣 表示100個樣本的net_input
return (np.dot(X, self.w_[1:])+self.w_[0])
def activation(self,X):
"""Compute linear activation"""
return self.net_input(X)
def predict(self, X):
"""return class label after unit step"""
return np.where(self.net_input(X) >= 0.0, 1, -1)
一樣用鳶尾花 Iris 的數據集來驗證一下
__author__ = 'Administrator'
#!/usr/bin/python <br> # -*- coding: utf8 -*-
from GDR import AdalineSGD
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from PDC import plot_decision_regions
filename = 'Iris.csv'
df = pd.read_csv(filename,header=None)
y = df.iloc[0:100, 4].values # .values將dataframe中的值存進一個list中
y = np.where(y=='Iris-setosa',-1,1) #如果是 Iris-setosa y=-1否則就是1 (二元分類)
X = df.iloc[0:100,[0,2]].values
X_std = np.copy(X)
X_std[:,0] = (X[:,0]-X[:,0].mean())/ X[:,0].std() #.std() 標準差
X_std[:,1] = (X[:,1]-X[:,1].mean())/ X[:,1].std() #.std() 標準差
ada = AdalineSGD(n_iter=15, eta=0.01,random_state=1)
ada.fit(X_std, y)
plot_decision_regions(X_std, y, classifier=ada)
plt.title('Adaline - Stochastic Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.legend(loc='upper left')
plt.savefig('Adaline- Stochastic Gradient Descent.png')
plt.show()
plt.plot(range(1,len(ada.cost_)+1), ada.cost_, marker='o')
plt.xlabel('Epoches')
plt.ylabel('Average Cost')
plt.savefig('Average Cost - Epoches.png')
plt.show()
比較一下達到最優的速率
SGD
BGD
很明顯 SGD 的收斂速率要快一點
OK!