python感知機分類乳腺癌資料集

標籤：圖片   mod   利用   esc   order   最大值   show   區別   最簡   

 

一、感知機介紹

感知器（英語：Perceptron）是Frank Rosenblatt在1957年就職於康奈爾航空實驗室（Cornell Aeronautical Laboratory）時所發明的一種人工神經網路。它可以被視為一種最簡單形式的前饋神經網路，是一種二元線性分類器。Frank Rosenblatt給出了相應的感知機學習演算法，常用的有感知機學習、最小二乘法和梯度下降法。譬如，感知機利用梯度下降法對損失函數進行極小化，求出可將訓練資料進行線性劃分的分離超平面，從而求得感知機模型。感知機是生物神經細胞的簡單抽象。神經細胞結構大致可分為：樹突、突觸、細胞體及軸突。單個神經細胞可被視為一種只有兩種狀態的機器——激動時為‘是’，而未激動時為‘否’。神經細胞的狀態取決於從其它的神經細胞收到的輸入訊號量，及突觸的強度（抑制或加強）。當訊號量總和超過了某個閾值時，細胞體就會激動，產生電脈衝。電脈衝沿著軸突並通過突觸傳遞到其它神經元。為了類比神經細胞行為，與之對應的感知機基礎概念被提出，如權量（突觸）、偏置（閾值）及啟用函數（細胞體）。

      在人工神經網路領域中，感知機也被指為單層的人工神經網路，以區別於較複雜的多層感知機（Multilayer Perceptron）。作為一種線性分類器，（單層）感知機可說是最簡單的前向人工神經網路形式。儘管結構簡單，感知機能夠學習並解決相當複雜的問題。感知機主要的本質缺陷是它不能處理線性不可分問題。

二、感知機原理

感知機演算法的原理和線性迴歸演算法的步驟大致相同，只是預測函數H和權值更新規則不同，這裡將感知機演算法應用於二分類。

三、資料集介紹

乳腺癌資料集，其執行個體數量是569，執行個體中包括診斷類和屬性，協助預測的屬性是30，各屬性包括為radius 半徑（從中心到邊緣上點的距離的平均值），texture 紋理（灰階值的標準差）等等，類包括:WDBC-Malignant 惡性和WDBC-Benign 良性。用資料集的70%作為訓練集，資料集的30%作為測試集，訓練集和測試集中都包括特徵和診斷類。

四、感知機演算法的代碼實現與結果分析

代碼實現：

import pandas as pd#用pandas讀取資料
import matplotlib.pyplot as plt
import numpy as np
from sklearn import preprocessing

from matplotlib.colors import ListedColormap
from perceptron import Perceptron
from scipy.special import expit#這是sign（）函數
from sklearn.model_selection import train_test_split

def loadDataSet():
    # df=pd.read_csv("Breast_ Cancer_ Data.csv")
    # # print(df.head())
    # # print(df.tail())
    # label=df.ix[:,1]
    # data=df.ix[:,2:32]#資料類型沒有轉換，比如31.48，是str類型，需要將其轉換為float
    #
    # m=data.shape[0]
    # data=np.array(data,dtype=float)
    #
    # for i in range(m):
    #     if label[i]==‘B‘:
    #         label[i]=0
    #     else :
    #         label[i]=1
    # train_x, test_x, train_y, test_y = train_test_split(data, label, test_size=0.30, random_state=0)  # 劃分資料集和測試集

    df = pd.read_csv("Breast_ Cancer_ Data.csv")
    dataArray=np.array(df)
    testRatio=0.3
    dataSize=dataArray.shape[0]
    testNum=int(testRatio*dataSize)
    trainNum=dataSize-testNum

    train_x=np.array(dataArray[0:trainNum,2:],dtype=np.float)
    test_x=np.array(dataArray[trainNum:,2:],dtype=np.float)
    train_y=dataArray[0:trainNum,1]
    test_y = dataArray[trainNum:, 1]
    for i in range(trainNum):
        if train_y[i]==‘B‘:
            train_y[i]=1
        else:
            train_y[i]=0
    for i in range(testNum):
        if test_y[i] == ‘B‘:
            test_y[i] = 1
        else:
            test_y[i] = 0

    return train_x,test_x,train_y,test_y

# def sign(inner_product):
#     if inner_product >= 0:
#         return 1
#     else:
#         return 0

#學習模型，學的參數theta
def train_model(train_x,train_y,theta,learning_rate,iteration):
    m=train_x.shape[0]
    n=train_x.shape[1]

    J_theta=np.zeros((iteration,1))#列向量
    train_x=np.insert(train_x,0,values=1,axis=1)#相當於x0,加在第一列上
    for i in range(iteration):#迭代
        # temp=theta #暫存
        # J_theta[i]=sum(sum((train_y-expit(np.dot(train_x,theta)))**2)/2.0)#dot是內積,sum函數是將減掉後的列向量求和成一個數
        J_theta[i]=sum((train_y[:,np.newaxis]-expit(np.dot(train_x,theta)))**2)/2.0#dot是內積,sum函數是將減掉後的列向量求和成一個數

        for j in range(n):#j是第j個屬性，但是所有屬性對應的的theta都要更新，故要迴圈
            # temp[j]=temp[j]+learning_rate*np.dot((train_x[:,j].T)[np.newaxis],(train_y[:,np.newaxis]-expit(np.dot(train_x,theta))))#T是轉置
            # temp[j]=temp[j]+learning_rate*np.dot(train_x[:,j].T,(train_y-expit(np.dot(train_x,theta))))#T是轉置
            theta[j]=theta[j]+learning_rate*np.dot((train_x[:,j].T)[np.newaxis],(train_y[:,np.newaxis]-expit(np.dot(train_x,theta))))#T是轉置


        # theta=temp

    x_iteration=np.linspace(0,iteration,num=iteration)
    plt.plot(x_iteration,J_theta)
    plt.show()
    return theta

def predict(test_x,test_y,theta):#假設theta是已經學習好的參數傳遞進來
    errorCount=0
    m=test_x.shape[0]
    test_x=np.insert(test_x,0,values=1,axis=1)#相當於x0
    h_theta = expit(np.dot(test_x, theta))

    for i in range(m):
        if h_theta[i]>0.5:
            h_theta[i]=1
        else:
            h_theta[i]=0
        if h_theta[i]!=test_y[i]:#test_y[i]需要是0或者1才能比較，因為h_theta[i]就是0或者1
            errorCount+=1
    error_rate=float(errorCount)/m
    print("error_rate ",error_rate)

#特徵縮放中的標準化方法,注意：numpy中的矩陣運算要多運用
def Standardization(x):#x是data
    m=x.shape[0]
    n=x.shape[1]
    x_average=np.zeros((1,n))#x_average是1*n矩陣
    sigma = np.zeros((1, n))  # sigma是1*n矩陣
    x_result=np.zeros((m, n))  # x_result是m*n矩陣

    x_average=sum(x)/m
    # x_average = x.mean(axis=0)#用np的mean函數也可以求得每一列的平均值

    # for i in range(n):
    #     for j in range(m):
    #         x_average[0][i] +=(float(x[j][i]))
    #     x_average[0][i]/=m

    # sigma=(sum((x-x_average)**2)/m)**0.5#m*n的矩陣減去1*n的矩陣的話，會廣播，1*n的矩陣會複製成m*n的矩陣
    sigma = x.var(axis=0)  # 用np的var函數來求每一列的方差
    # for i in range(n):
    #     for j in range(m):
    #         sigma[0][i]+=((x[j][i]-x_average[0][i])**2.0)
    #     sigma[0][i]=(sigma[0][i]/m)**0.5

    x_result=(x-x_average)/sigma#對應的元素相除
    # for i in range(n):
    #     for j in range(m):
    #         x_result[j][i]=(x[j][i]-x_average[0][i])/sigma[0][i]

    return x_result

#特徵縮放中的調節比例方法
def Rescaling(x):
    m = x.shape[0]
    n = x.shape[1]
    x_min=np.zeros((1,n))#x_min是1*n矩陣
    x_max=np.zeros((1,n))#x_max是1*n矩陣
    x_result = np.zeros((m, n))  # x_result是m*n矩陣
    # for i in range(n):
    #     x_min[0][i]=x[0][i]
    #     x_max[0][i]=x[0][i]
    #     for j in range(1,m):
    #         if x_min[0][i]>x[j][i]:
    #             x_min[0][i]=x[j][i]
    #         if x_max[0][i]<x[j][i]:
    #             x_max[0][i]=x[j][i]
    # for i in range(n):
    #     for j in range(m):
    #         x_result[j][i]=(x[j][i]-x_min[0][i])/(x_max[0][i]-x_min[0][i])

    x_min=x.min(axis=0)#獲得每個列的最小值
    x_max=x.max(axis=0)#獲得每個列的最大值
    x_result = (x - x_min) / (x_max - x_min)

    return x_result


if __name__==‘__main__‘:
    train_x, test_x, train_y, test_y=loadDataSet()
    # scaler=preprocessing.MinMaxScaler()
    # train_x=scaler.fit_transform(train_x)
    # test_x=scaler.fit_transform(test_x)

    # train_x=Standardization(train_x)
    # test_x=Standardization(test_x)

    # train_x=Rescaling(train_x)
    # test_x=Rescaling(test_x)

    n=test_x.shape[1]+1
    theta=np.zeros((n,1))
    # theta=np.random.rand(n,1)#隨機構造1*n的矩陣
    theta_new=train_model(train_x,train_y,theta,learning_rate=0.001,iteration=1000)#用rescaling的時候錯誤率0.017

    predict(test_x, test_y, theta_new)


結果展示和分析：

感知機分類乳腺癌資料集的實驗

   實驗的迭代次數1000，學習率0.001，對特徵縮放的方法效果進行比較，如表3所示。

表3 分類錯誤率和特徵縮放的方法的關係

特徵縮放	Standardization	Rescaling
分類錯誤率	0.182	0.017

 

Standardization標準化方法的J隨著迭代次數的變化圖1所示：

 

圖1 標準化方法的

Rescaling調節比例方法的J隨著迭代次數的變化圖2所示：

圖2 調節比例方法的

圖1 說明迭代次數和學習率等參數未調節到使效果較好的值；圖2的效果比較好，損失函數逐漸降低並且趨於平緩；比較兩種方法，相對來說調節比例的方法優於標準化方法。

 

python感知機分類乳腺癌資料集