安裝

sudo pip install numpy

sudo apt-get install libblas-dev liblapack-dev libatlas-base-dev gfortran
sudo pip install scipy

sudo pip install sklearn

sklearn.datasets

這個包提供一些函數(shù)用于讀取樣本數(shù)據(jù)（數(shù)據(jù)存在 .csv 或 .csv.gz 文件），比如
??
酒數(shù)據(jù)集（用于分類）
??13 個特征包括各種成分的含量、酒的顏色等
??3 個分類簡單的標(biāo)記為 class_0、class_1、class_2
??參數(shù) return_X_y 表示是不是以 (data, target) 的格式返回

def load_wine(return_X_y=False):
    """Load and return the wine dataset (classification).

    .. versionadded:: 0.18

    The wine dataset is a classic and very easy multi-class classification
    dataset.

    =================   ==============
    Classes                          3
    Samples per class        [59,71,48]
    Samples total                  178
    Dimensionality                  13
    Features            real, positive
    =================   ==============

鳶尾花數(shù)據(jù)集（用于分類）
??4 個特征包括花萼長度、花萼寬度、花瓣長度、花瓣寬度
??3 個分類為 Iris Setosa (山鳶尾)、Iris Versicolour (雜色鳶尾)、Iris Virginica (維吉尼亞鳶尾)

def load_iris(return_X_y=False):
    """Load and return the iris dataset (classification).

    The iris dataset is a classic and very easy multi-class classification
    dataset.

    =================   ==============
    Classes                          3
    Samples per class               50
    Samples total                  150
    Dimensionality                   4
    Features            real, positive
    =================   ==============

數(shù)字圖片數(shù)據(jù)集（用于分類）
??圖片大小 8*8, 分別是 0~9 的數(shù)字

def load_digits(n_class=10, return_X_y=False):
    """Load and return the digits dataset (classification).

    Each datapoint is a 8x8 image of a digit.

    =================   ==============
    Classes                         10
    Samples per class             ~180
    Samples total                 1797
    Dimensionality                  64
    Features             integers 0-16
    =================   ==============

糖尿病數(shù)據(jù)集（用于回歸）
??特征包括性別、年齡、血壓等等
??預(yù)測 1 年后病情的變化

def load_diabetes(return_X_y=False):
    """Load and return the diabetes dataset (regression).

    ==============      ==================
    Samples total       442
    Dimensionality      10
    Features            real, -.2 < x < .2
    Targets             integer 25 - 346
    ==============      ==================

體能數(shù)據(jù)集（多變量回歸）
??特征包括引體向上、仰臥起坐、彈跳
??目標(biāo)是體重、腰、脈搏

def load_linnerud(return_X_y=False):
    """Load and return the linnerud dataset (multivariate regression).

    ==============    ============================
    Samples total     20
    Dimensionality    3 (for both data and target)
    Features          integer
    Targets           integer
    ==============    ============================

波士頓房價數(shù)據(jù)集（用于回歸）
??特征包括犯罪率、大小、樓齡、距市區(qū)距離、有多少房間、房產(chǎn)稅等等
??目標(biāo)是預(yù)測房價

def load_boston(return_X_y=False):
    """Load and return the boston house-prices dataset (regression).

    ==============     ==============
    Samples total                 506
    Dimensionality                 13
    Features           real, positive
    Targets             real 5. - 50.
    ==============     ==============

簡單例子

## 讀取樣本數(shù)據(jù)
from sklearn import datasets
digits = datasets.load_digits()

## 創(chuàng)建 SVM
## C 是懲罰因子, C 越大表示越不能接受離群點(diǎn)(被錯分的點(diǎn))
## gamma 越大, 支持向量越少, gamma 越小, 支持向量越多
from sklearn import svm
clf = svm.SVC(gamma=0.001, C=100.)

## 訓(xùn)練
## 基本上每個模型都有 fit 函數(shù)用于訓(xùn)練
clf.fit(digits.data[:-1], digits.target[:-1])

## 預(yù)測
## 基本上每個模型都有 predict 函數(shù)用于預(yù)測
clf.predict(digits.data[-1:])

## 持久化
import pickle
fw = open('dataFile.txt','wb')
pickle.dump(clf, fw)
fw.close()

fr = open('dataFile.txt','rb')
clf2 = pickle.load(fr)
fr.close()

clf2.predict(digits.data[-5:])

## 持久化
from sklearn.externals import joblib
joblib.dump(clf, 'filename.pkl')
clf3 = joblib.load('filename.pkl')
clf3.predict(digits.data[-5:])

## 改變參數(shù)然后重新訓(xùn)練
clf.set_params(kernel='linear').fit(digits.data[:-1], digits.target[:-1])
clf.predict(digits.data[-5:])
clf.set_params(kernel='rbf').fit(digits.data[:-1], digits.target[:-1])
clf.predict(digits.data[-5:])

## 將 SVM 改為多個分類 (通過多次 2 分類實(shí)現(xiàn))
from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier

X = [[1, 2], [2, 4], [4, 5], [3, 2], [3, 1]]
y = [0, 0, 1, 1, 2]

classif = OneVsRestClassifier(estimator=SVC(random_state=0))
classif.fit(X, y).predict(X)

## 把標(biāo)簽轉(zhuǎn)化為二進(jìn)制 (就是 one-hot representation)
from sklearn.preprocessing import LabelBinarizer
y = LabelBinarizer().fit_transform(y)
classif.fit(X, y).predict(X)

分類算法

線性判別分析 (LDA)

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda = LinearDiscriminantAnalysis(solver="svd", store_covariance=True)

二次判別分析 (QDA)

from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
qda = QuadraticDiscriminantAnalysis(store_covariances=True)

KNN 算法

from sklearn import neighbors
clf = neighbors.KNeighborsClassifier(n_neighbors=5, weights='uniform')

樸素貝葉斯算法 (Naive Bayes)

from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()

決策樹算法 (decision tree)

from sklearn import tree
clf = tree.DecisionTreeClassifier()

邏輯回歸 (Logistic regression)

from sklearn.linear_model import LogisticRegression
clf_l1_LR = LogisticRegression(C=1.0, penalty='l1', tol=0.01)
clf_l2_LR = LogisticRegression(C=1.0, penalty='l2', tol=0.01)

支持向量機(jī) (SVM)

from sklearn import svm
clf = svm.SVC(C=1.0, kernel='rbf', gamma='auto', tol=1e-3, max_iter=-1)

集成算法 (Ensemble methods)

# Bagging
from sklearn.ensemble import BaggingClassifier
from sklearn.neighbors import KNeighborsClassifier
bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)

# 隨機(jī)森林 (Random Forest)
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(n_estimators=10)

# AdaBoost
from sklearn.ensemble import AdaBoostClassifier
clf = AdaBoostClassifier(n_estimators=100)

# GBDT (Gradient Boosting Dicision Tree)
from sklearn.ensemble import GradientBoostingClassifier
clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)

神經(jīng)網(wǎng)絡(luò) (nn)

from sklearn.neural_network import MLPClassifier
clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(3, 5, 2), random_state=1)

預(yù)測訓(xùn)練

'''
GBDT 和決策樹全對
隨機(jī)森林只錯一個
其他的貌似沒差多少
可能不同參數(shù), 不同數(shù)據(jù), 結(jié)果也會不同
'''
iris = datasets.load_iris()
X, y = iris.data, iris.target
clf.fit(X,y)
clf.predict(X) - y

回歸算法

最小二乘回歸 (OLS)

from sklearn import linear_model
reg = linear_model.LinearRegression()

嶺回歸 (Ridge Regression)

from sklearn import linear_model
reg = linear_model.Ridge (alpha = .5)

核嶺回歸 (Kernel ridge regression)

from sklearn.kernel_ridge import KernelRidge
reg = KernelRidge(kernel='rbf', alpha=0.1, gamma=10)

支持向量機(jī)回歸 (SVR)

from sklearn import svm
reg = svm.SVR()

套索回歸 (Lasso)

from sklearn import linear_model
reg = linear_model.Lasso(alpha = 0.1)

彈性網(wǎng)絡(luò)回歸 (Elastic Net)

from sklearn.linear_model import ElasticNet
reg = ElasticNet(random_state=0)

貝葉斯回歸 (Bayesian Regression)

from sklearn import linear_model
reg = linear_model.BayesianRidge()

穩(wěn)健回歸 (Robustness regression)

from sklearn import linear_model
reg = linear_model.RANSACRegressor()

高斯過程回歸 (Gaussian Process Regression)

from sklearn import gaussian_process
reg = gaussian_process.GaussianProcessRegressor()

偏最小二乘回歸 (PLS)

from sklearn.cross_decomposition import PLSCanonical
reg = PLSCanonical(algorithm='nipals', copy=True, max_iter=500, n_components=2,scale=True, tol=1e-06)

典型相關(guān)分析 (CCA)

from sklearn.cross_decomposition import CCA
cca = CCA(n_components=2)

訓(xùn)練預(yù)測

data = datasets.load_boston()
X, y = data.data, data.target
reg.fit(X,y)
reg.predict(X) - y

聚類算法

KNN 算法（為什么 KNN 是聚類）

from sklearn.neighbors import NearestNeighbors
nbrs = NearestNeighbors(n_neighbors=3, algorithm='ball_tree')
nbrs.fit(X)
nbrs.kneighbors(X)      ## 返回距離最近的 n 個點(diǎn)的下標(biāo)以及距離 (由于其中一個是自己所以最小的一直是 0)

Kmeans 算法
??最大優(yōu)點(diǎn)是快，缺點(diǎn)是需要人為選取聚類數(shù)量及初始點(diǎn)，算法的性能也完全依賴于上述選擇

from sklearn.cluster import KMeans
kmeans = KMeans(init='k-means++', n_clusters=3, n_init=10)
kmeans.fit(X)
kmeans.predict(X)

Mini Batch K-Means 算法
??K-Means 算法的變種
??采用小批量的數(shù)據(jù)子集減小計算時間，小批量是指每次訓(xùn)練算法時所隨機(jī)抽取的數(shù)據(jù)子集
??采用這些隨機(jī)產(chǎn)生的子集進(jìn)行訓(xùn)練算法，大大減小了計算時間
??與其他算法相比，減少了收斂時間，產(chǎn)生的結(jié)果一般只略差于標(biāo)準(zhǔn)算法

from sklearn.cluster import MiniBatchKMeans
miniBatchKmeans = MiniBatchKMeans(n_clusters=3)
miniBatchKmeans.fit(X)
miniBatchKmeans.predict(X)

MeanShift 算法
??取一個中心點(diǎn)，計算距離該中心點(diǎn)一定范圍內(nèi)的所有點(diǎn)的均值
??移動中心點(diǎn)到該均值點(diǎn)，重復(fù)這個過程，直到收斂 （不用指定聚類個數(shù)?）

from sklearn.cluster import estimate_bandwidth
from sklearn.cluster import MeanShift
bandwidth = estimate_bandwidth(X, quantile=0.3)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)

層次聚類 (Hierarchical clustering) -- 支持多種距離
??一開始把所有點(diǎn)都當(dāng)成一個 cluster
??然后每次找到距離最短的兩個 cluster 合并成一個大的 cluster
??重復(fù)這個過程直到只剩一個 cluster
??
??層次聚類最大的優(yōu)點(diǎn)，是一次性地得到整個聚類的過程
??只要得出聚類樹，想分多少個 cluster 都可以直接根據(jù)樹結(jié)構(gòu)來得到結(jié)果
??改變 cluster 數(shù)目不需要再次計算數(shù)據(jù)點(diǎn)的歸屬
??
??層次聚類的缺點(diǎn)是計算量比較大，每次都要計算多個 cluster 內(nèi)所有數(shù)據(jù)點(diǎn)的兩兩距離
??另外由于使用的是貪心算法，得到的只是局域最優(yōu)，不一定是全局最優(yōu)

from sklearn.cluster import AgglomerativeClustering
model = AgglomerativeClustering(n_clusters=3, linkage="ward")
model.fit(X)
model.labels_           ## 直接輸出結(jié)果, 沒有 predict 函數(shù)

譜聚類 (spectral clustering)
??譜聚類過程主要有兩步
??第一步是構(gòu)圖，將采樣點(diǎn)數(shù)據(jù)構(gòu)造成一張網(wǎng)圖，點(diǎn)與點(diǎn)之間的邊帶有權(quán)值即為距離
??第二步是切圖，將第一步構(gòu)造出來的圖切分成不同的圖既聚類
??不同的子圖間所有點(diǎn)的權(quán)值和盡可能大, 圖內(nèi)部所有點(diǎn)的權(quán)值和盡可能小
??
??優(yōu)點(diǎn)
????對數(shù)據(jù)結(jié)構(gòu)沒有太多的假設(shè)要求，如 kmeans 則要求數(shù)據(jù)為凸集。
????通過構(gòu)造稀疏 similarity graph，使得對更大的數(shù)據(jù)集表現(xiàn)出明顯優(yōu)于其他算法的速度
????由于是對圖切割處理，不會存在像 kmesns 聚類時將離散的小簇聚合在一起的情況
????無需像 GMM 一樣對數(shù)據(jù)的概率分布做假設(shè)

from sklearn.cluster import SpectralClustering
spectral = SpectralClustering(n_clusters=3, eigen_solver='arpack', affinity="nearest_neighbors")
spectral.fit(X)
spectral.labels_

DBSCAN (Density-based spatial clustering of applications with noise 基于密度的聚類) 算法
??取一個未處理的點(diǎn)
??如果是核心點(diǎn)（距離 eps 的范圍內(nèi)至少有 min_samples 個點(diǎn)）
??找出所有該點(diǎn)密度可達(dá)的點(diǎn)（距離 eps 內(nèi)的點(diǎn)，距這些點(diǎn) eps 內(nèi)的點(diǎn)，不斷擴(kuò)張) 形成簇
??如果取出的點(diǎn)是非核心點(diǎn)，忽略，尋找下一個點(diǎn)
??重復(fù)這個過程直到所有點(diǎn)被處理
??
??優(yōu)點(diǎn)：
????聚類速度快且能夠有效處理噪聲點(diǎn)和發(fā)現(xiàn)任意形狀的空間聚類
????與 K-MEANS 比較起來，不需要輸入要劃分的聚類個數(shù)
????可以在需要時輸入過濾噪聲的參數(shù)
??缺點(diǎn)：
????當(dāng)數(shù)據(jù)量增大時，要求較大的內(nèi)存支持，I/O 消耗也很大
????當(dāng)空間聚類的密度不均勻、聚類間距差相差很大時，聚類質(zhì)量較差
????因?yàn)檫@種情況下參數(shù) MinPts 和 Eps 選取困難
????聚類效果依賴距離公式選取，實(shí)際應(yīng)用中常用歐式距離，對于高維數(shù)據(jù)存在 "維數(shù)災(zāi)難"

from sklearn.cluster import DBSCAN
dbscan = DBSCAN(eps=.2, min_samples=3)
dbscan.fit(X)
dbscan.labels_

Affinity Propagation (近鄰傳播聚類)
??AP 算法的基本思想是將全部樣本看作網(wǎng)絡(luò)的節(jié)點(diǎn)，然后通過網(wǎng)絡(luò)中各條邊的消息傳遞計算出各樣本的聚類中心，聚類過程中，共有兩種消息在各節(jié)點(diǎn)間傳遞，分別是吸引度 (responsibility) 和歸屬度 (availability)，AP 算法通過迭代過程不斷更新每一個點(diǎn)的吸引度和歸屬度值，直到產(chǎn)生 m 個高質(zhì)量的 Exemplar (類似于質(zhì)心)，同時將其余的數(shù)據(jù)點(diǎn)分配到相應(yīng)的聚類中
??
??優(yōu)點(diǎn)：
????無需指定聚類參數(shù)
????明確的質(zhì)心，樣本中的所有數(shù)據(jù)點(diǎn)都可能成為質(zhì)心，
????而不是由多個數(shù)據(jù)點(diǎn)求平均而得到的聚類中心如 K-Means
????對距離矩陣的對稱性沒要求
????初始值不敏感
????若以誤差平方和來衡量算法間的優(yōu)劣, AP 聚類比其他方法的誤差平方和都要低
??缺點(diǎn)：
????算法復(fù)雜度較高，為 O(NNlogN)，而 K-Means 只是 O(N*K) 的復(fù)雜度
????因此當(dāng) N 比較大時(N>3000)，AP 聚類算法往往需要算很久
????AP 聚類需要手動指定 Preference 和 Damping factor，這是原有的聚類數(shù)量控制的變體

from sklearn.cluster import AffinityPropagation
affinity_propagation = AffinityPropagation(damping=.9, preference=-200)
affinity_propagation.fit(X)
affinity_propagation.labels_

BIRCH (Balanced Iterative Reducing and Clustering using Hierarchies 利用層次方法的平衡迭代規(guī)約和聚類)
??適合數(shù)據(jù)量大，類別多的情況
??最大的特點(diǎn)是能利用有限的內(nèi)存資源完成對大數(shù)據(jù)集的高質(zhì)量的聚類
??同時通過單遍掃描數(shù)據(jù)集能最小化 I/O 代價
??采用多階段聚類技術(shù): 數(shù)據(jù)集的單邊掃描產(chǎn)生基本的聚類
??一或多遍的額外掃描可以進(jìn)一步改進(jìn)聚類質(zhì)量
??增量聚類方法: 對每個數(shù)據(jù)的聚類決策都是基于當(dāng)前已經(jīng)處理過的數(shù)據(jù)，而不是基于全局?jǐn)?shù)據(jù)
??如果簇不是球形的，BIRCH 不能很好的工作，因?yàn)樗昧税霃交蛑睆降母拍顏砜刂凭垲愡吔?/p>

from sklearn.cluster import Birch
birch = Birch(n_clusters=3)
birch.fit(X)
birch.predict(X)

降維算法

PCA (Principal Component Analysis, 主成分方法)

from sklearn.decomposition import PCA
pca = PCA(n_components=3)
pca.fit(X)
pca.explained_variance_ratio_   ## 各主成分的方差值占總方差值的比例, 這個比例越大, 則越是重要的主成分
pca.explained_variance_         ## 各主成分的方差值, 方差值越大, 則說明越是重要的主成分
pca.singular_values_            ## 奇異值
pca.fit_transform(X)

Kernal PCA (核函主成分)
??PCA 是線性的, Kernal PCA 是對 PCA 算法的非線性擴(kuò)展, 與 PCA 相比存在兩點(diǎn)創(chuàng)新
??1. 為了更好地處理非線性數(shù)據(jù), 引入非線性映射函數(shù), 將原空間中的數(shù)據(jù)映射到高維空間
??2. 引入一個定理：空間中的任一向量(哪怕是基向量), 都可以由該空間中的所有樣本線性表示

from sklearn.decomposition import KernelPCA
kpca = KernelPCA(kernel="rbf", n_components=3, fit_inverse_transform=True, gamma=10)
kpca.fit(X)
kpca.fit_transform(X)

Factor Analysis (因子分析)

from sklearn.decomposition import FactorAnalysis
fa = FactorAnalysis(n_components = 3)
fa.fit(X)
fa.components_      ## 有幾行非 0 值, 代表提取幾個特征, 如果有指定 n_components 的值則提取 n_components 個特征
fa.transform(X)

文本挖掘算法

主題生成模型 (LDA, Latent Dirichlet Allocation)

from sklearn.decomposition import NMF, LatentDirichletAllocation

潛在語義分析 (LSA, Latent Semantic Analysis)

from sklearn.decomposition import TruncatedSVD

特征選擇

VarianceThreshold (方差閾值)
??去掉那些方差沒有達(dá)到閾值的特征
??默認(rèn)情況下, 刪除零方差的特征, 例如那些只有一個值的樣本
??假設(shè)有一個數(shù)據(jù)集, 我們想去掉超過 80% 都是 0 或 1 的特征

from sklearn.feature_selection import VarianceThreshold
X = [[0, 0, 1], [0, 1, 0], [1, 0, 0], [0, 1, 1], [0, 1, 0], [0, 1, 1]]
sel = VarianceThreshold(threshold=(.8 * (1 - .8)))
sel.fit_transform(X)

單變量特征選擇
??SelectBest 只保留 k 個最高分的特征
??SelectPercentile 只保留用戶指定百分比的最高得分的特征
??GenericUnivariateSelect 通過結(jié)構(gòu)化策略進(jìn)行特征選擇

from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import SelectPercentile
from sklearn.feature_selection import GenericUnivariateSelect

X, y = iris.data, iris.target
SelectKBest(chi2, k=2).fit_transform(X, y)
SelectPercentile(percentile=90).fit_transform(X, y)
GenericUnivariateSelect(mode='percentile', param=90).fit_transform(X, y)

遞歸特征淘汰 (RFE)

from sklearn.feature_selection import RFE
from sklearn.feature_selection import RFECV

通過模型選擇

from sklearn.feature_selection import SelectFromModel

隨機(jī)梯度方法

有些算法會提供一個帶隨機(jī)梯度方法的接口比如

from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import SGDRegressor

交叉驗(yàn)證

from sklearn import tree
from sklearn.model_selection import cross_val_predict
from sklearn import metrics

clf = tree.DecisionTreeClassifier()
predicted = cross_val_predict(clf, X, y, cv=10)
metrics.accuracy_score(y, predicted)

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_validate
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import LeavePOut

參數(shù)調(diào)優(yōu)

學(xué)習(xí)器模型中一般有兩類參數(shù)：一類參數(shù)可以從數(shù)據(jù)中學(xué)習(xí)估計得到, 還有一類參數(shù)無法從數(shù)據(jù)中估計, 只能靠人的經(jīng)驗(yàn)進(jìn)行指定, 后一類參數(shù)就叫超參數(shù), 比如支持向量機(jī)里的 C, Kernel, gama, 樸素貝葉斯里的 alpha 等, 在學(xué)習(xí)其模型的設(shè)計中, 我們要搜索超參數(shù)空間為學(xué)習(xí)器模型找到最合理的超參數(shù)
??
sklearn 提供了兩種通用的參數(shù)優(yōu)化方法
??
網(wǎng)格搜索交叉驗(yàn)證 (GridSearchCV):
??以窮舉的方式遍歷所有可能的參數(shù)組合

from sklearn import svm
from sklearn.model_selection import GridSearchCV

parameters={'kernel':('rbf','linear'),'C':[1,5,10]}
parameters=[
   {'C':[1,10,100,1000],'kernel':['linear']},
   {'C':[1,10,100,1000],'gamma':[0.001,0.0001],'kernel':['rbf']}
]
svr=svm.SVC()
clf=GridSearchCV(svr, parameters)
clf.fit(X, y)
clf.predict(X)

隨機(jī)采樣交叉驗(yàn)證 (RandomizedSearchCV):
??依據(jù)某種分布對參數(shù)空間采樣, 隨機(jī)的得到一些候選參數(shù)組合方案

from scipy.stats import randint as sp_randint
from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier

clf=RandomForestClassifier(n_estimators=20)

param_dist={"max_depth":[3,None],
            "max_features":sp_randint(1,4),
            "min_samples_split":sp_randint(2,4),
            "min_samples_leaf":sp_randint(1,4),
            "bootstrap":[True,False],
            "criterion":['gini','entropy']
            }

random_search=RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=20)
random_search.fit(X,y)
random_search.predict(X)

準(zhǔn)確率, 召回率, AUC, ROC

import numpy as np
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
from sklearn.metrics import auc

y_true = [0, 1, 2, 2, 2]
y_pred = [0, 0, 2, 2, 1]
target_names = ['class 0', 'class 1', 'class 2']

accuracy_score(y_true, y_pred)
precision_score(y_true, y_pred, average='micro')
precision_score(y_true, y_pred, average='macro')
recall_score(y_true, y_pred, average='micro')
recall_score(y_true, y_pred, average='macro')
f1_score(y_true, y_pred, average='weighted')

confusion_matrix(y_true, y_pred)

print(classification_report(y_true, y_pred, target_names=target_names))

y_true_2 = np.array([0, 0, 1, 1])
y_scores = np.array([0.1, 0.4, 0.35, 0.8])
roc_auc_score(y_true_2, y_scores)

pr, tpr, thresholds = roc_curve(y_true, y_pred, pos_label=2)
auc(fpr, tpr)

損失函數(shù)

Zero-One Loss

from sklearn.metrics import zero_one_loss
y_pred = [1, 2, 3, 4]
y_true = [2, 2, 3, 4]
zero_one_loss(y_true, y_pred)
zero_one_loss(y_true, y_pred, normalize=False)

Hinge Loss

from sklearn import svm
from sklearn.metrics import hinge_loss
X = [[0], [1]]
y = [-1, 1]
est = svm.LinearSVC(random_state=0)
est.fit(X, y)
pred_decision = est.decision_function([[-2], [3], [0.5]])
hinge_loss([-1, 1, 1], pred_decision)

Log Loss (對數(shù)損失) 或者 Cross-entropy Loss (交叉熵?fù)p失)

from sklearn.metrics import log_loss
y_true=[0,0,1,1]
y_pred=[[0.9,0.1],[0.8,0.2],[0.3,0.7],[0.01,0.99]]
print(log_loss(y_true,y_pred))

Hamming Loss

from sklearn.metrics import hamming_loss
y_pred=[1,2,3,4]
y_true=[2,2,3,4]
print(hamming_loss(y_true,y_pred))

數(shù)據(jù)預(yù)處理

標(biāo)準(zhǔn)化

X = np.array([[ 1., -1.,  2.],
              [ 2.,  0.,  0.],
              [ 0.,  1., -1.]])
X_mean = X.mean(axis=0)
X_std = X.std(axis=0)
(X-X_mean)/X_std
preprocessing.scale(X)          ## 結(jié)果和 (X-X_mean)/X_std 一樣

將特征的取值縮小到一個范圍如 0 到 1

X = np.array([[ 1., -1.,  2.],
              [ 2.,  0.,  0.],
              [ 0.,  1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
min_max_scaler.fit_transform(X)

正則化 (Normalization)

X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]
preprocessing.normalize(X, norm='l2')

特征二值化 (Binarization)

X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]
binarizer = preprocessing.Binarizer().fit(X)
binarizer.transform(X)

標(biāo)簽二值化 (Label Binarization)

x = [0,1,2,3]
lb = preprocessing.LabelBinarizer()
lb.fit(x)
lb.transform(x)

one-hot 編碼

enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
enc.transform([[0, 1, 3]]).toarray()

標(biāo)簽編碼 (Label encoding)

le = preprocessing.LabelEncoder()
le.fit(["paris", "paris", "tokyo", "amsterdam"])
le.transform(["tokyo", "tokyo", "paris"])

缺失值處理

## 除了 mean 也可以用 median 或 most_frequent
imp = preprocessing.Imputer(missing_values='NaN', strategy='mean', axis=0)  
imp.fit([[1, 2], [np.nan, 3], [7, 6]])      ## fit 計算均值, transform 用均值填充
X = [[np.nan, 2], [6, np.nan], [7, 6]]
imp.transform(X)

異常值處理
??如果數(shù)據(jù)中含有異常值, 那么使用均值和方差縮放數(shù)據(jù)的效果并不好, 這種情況下可以使用

preprocessing.robust_scale
preprocessing.RobustScaler

多項(xiàng)式轉(zhuǎn)換

x = [[0,1,2,3]]
poly = preprocessing.PolynomialFeatures(degree=2)
poly.fit_transform(x)

pipeline

例子1

from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.decomposition import PCA

estimators = [('reduce_dim', PCA()), ('svm', SVC())]
clf = Pipeline(estimators)
clf
clf.set_params(svm__C=10)
clf

例子2

from sklearn import svm
from sklearn.datasets import samples_generator
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_regression
from sklearn.pipeline import Pipeline

X, y = samples_generator.make_classification(n_informative=5, n_redundant=0, random_state=42)

anova_filter = SelectKBest(f_regression, k=5)
clf = svm.SVC(kernel='linear')
anova_svm = Pipeline([('anova', anova_filter), ('svc', clf)])
anova_svm.set_params(anova__k=10, svc__C=.1).fit(X, y)

prediction = anova_svm.predict(X)
anova_svm.score(X, y)

anova_svm.named_steps['anova'].get_support()