參考資料
<PYTHON_MACHINE_LEARNING> chapter3
Maximum margin classifcation with
support vector machines
引言
在上一章邏輯回歸算法中，我們已經注意到，邏輯回歸 LogisticalRegression與線性自適應 Adaline 的區別只在于它們對應的激勵函數不同，所以這一章，我們試著自己來構建一個簡單的邏輯回歸單元
step 1 結構分析
參考感知機單元，我們構建的這個邏輯回歸類 應該接受一組訓練集，包括一個 nk*的矩陣以及一個n維的列向量 y
這個類應該包括一個求 net_input 的方法來求出 z
一個更新權值并統計損失函數的方法
一個分類器
注意，這個分類器應該以0.5作為閾值
step 2 直接在Adaline的基礎上修改代碼
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 30 12:57:19 2017
@author: Administrator
"""
import numpy as np
class LogisticalRegression(object):
"""
LogisticalRegression lassifier.
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（時間起點）.
"""
def __init__(self, eta=0.01, n_iter=10, C=1.0):
self.eta = eta
self.n_iter = n_iter
self.C = C
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.w_ = np.zeros(1 + X.shape[1])
#X.shape = (100,2),zeros 生成的是列向量
#self.w_ 是一個(3,1)的矩陣
# print('X.shape[1]=',X.shape[1])
self.cost_ =[]
#self.cost_損失函數 cost_function
# zeros()創建了一個 長度為 1+X.shape[1] = 1+n_features 的 0數組
# self.w_ 權向量
self.errors_ = []
for i in range(self.n_iter):
output = self.activation(X)
'''
if i==1:
print(output)
print(y)
'''
# y(100，1) output(100,1),errors(100,1)
errors = (y - output)
self.w_[1:] += self.C*self.eta * X.T.dot(errors)
# X先取轉置(2,100)，再矩陣乘法乘以 errors(100,1) X.T.dot(errors) (2,1)
self.w_[0] += self.C*self.eta * errors.sum()
cost = (errors**2).sum()
self.cost_.append(cost)
'''
ln_output=np.log(output)
cost = y.dot(ln_output)+(1-y).dot(np.log(1-output))
self.cost_.append(cost)
print(self.cost_)
'''
# print(self.w_.shape)
# print(self.w_)
# print(X.shape)
return self
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 LR activation"""
return 1/(1+np.exp(-self.net_input(X)))
def predict(self, X):
"""return class label after unit step"""
print(self.cost_)
return np.where(self.activation(X)>= 0.5, 1, 0)
同樣用 Iris 數據集來測試一下下~
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 30 14:47:25 2017
@author: Administrator
"""
from LR import LogisticalRegression
from sklearn import datasets
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
from PDC import plot_decision_regions
import matplotlib.pyplot as plt
import numpy as np
Iris = datasets.load_iris()
x = Iris.data[0:100,2:4]
y = Iris.target[0:100]
X_train,X_test,y_train,y_test = train_test_split(
x,y,test_size=0.3,random_state=0)
sc=StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)
Lr=LogisticalRegression(n_iter=20,eta=0.01,C=10)
Lr.fit(X_train_std,y_train)
X_combined_std = np.vstack((X_train_std,X_test_std))
y_combined = np.hstack((y_train,y_test))
plot_decision_regions(X=X_combined_std,y=y_combined,
classifier=Lr,test_idx=range(70,100)
)
'''
plt.scatter(X_test_std[:,0],X_test_std[:,1],c='',edgecolor='0',alpha=1.0,
linewidths=1,marker='o',s=55,label='test')
'''
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')
plt.savefig('Iris.png')
plt.show()
結果如下
ok!
