机器学习：sk-learn

标签：explain   标记   ==   weight   ids   中学   gen   提取   ext   

安装

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

这个包提供一些函数用于读取样本数据（数据存在 .csv 或 .csv.gz 文件），比如
??
酒数据集（用于分类）
??13 个特征包括各种成分的含量、酒的颜色等
??3 个分类简单的标记为 class_0、class_1、class_2
??参数 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
	=================   ==============

鸢尾花数据集（用于分类）
??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
	=================   ==============

数字图片数据集（用于分类）
??图片大小 8*8, 分别是 0~9 的数字

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
	=================   ==============

糖尿病数据集（用于回归）
??特征包括性别、年龄、血压等等
??预测 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
	==============      ==================

体能数据集（多变量回归）
??特征包括引体向上、仰卧起坐、弹跳
??目标是体重、腰、脉搏

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
	==============    ============================

波士顿房价数据集（用于回归）
??特征包括犯罪率、大小、楼龄、距市区距离、有多少房间、房产税等等
??目标是预测房价

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.
	==============     ==============

简单例子

## 读取样本数据
from sklearn import datasets
digits = datasets.load_digits()

## 创建 SVM
## C 是惩罚因子, C 越大表示越不能接受离群点(被错分的点)
## gamma 越大, 支持向量越少, gamma 越小, 支持向量越多
from sklearn import svm
clf = svm.SVC(gamma=0.001, C=100.)

## 训练
## 基本上每个模型都有 fit 函数用于训练
clf.fit(digits.data[:-1], digits.target[:-1])

## 预测
## 基本上每个模型都有 predict 函数用于预测
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:])

## 改变参数然后重新训练
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 分类实现)
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)

## 把标签转化为二进制 (就是 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)

支持向量机 (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)

# 随机森林 (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)

神经网络 (nn)

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

预测训练

‘‘‘
GBDT 和决策树全对
随机森林只错一个
其他的貌似没差多少
可能不同参数, 不同数据, 结果也会不同
‘‘‘
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)

支持向量机回归 (SVR)

from sklearn import svm
reg = svm.SVR()

套索回归 (Lasso)

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

弹性网络回归 (Elastic Net)

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

贝叶斯回归 (Bayesian Regression)

from sklearn import linear_model
reg = linear_model.BayesianRidge()

稳健回归 (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)

典型相关分析 (CCA)

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

训练预测

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 个点的下标以及距离 (由于其中一个是自己所以最小的一直是 0)

Kmeans 算法
??最大优点是快，缺点是需要人为选取聚类数量以及初始点，算法的性能也完全依赖于上述选择

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 算法的变种
??采用小批量的数据子集减小计算时间，这里的小批量是指每次训练算法时所随机抽取的数据子集
??采用这些随机产生的子集进行训练算法，大大减小了计算时间
??与其他算法相比，减少了收敛时间，产生的结果一般只略差于标准算法

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

MeanShift 算法
??取一个中心点，计算距离该中心点一定范围内的所有点的均值
??移动中心点到该均值点，重复这个过程，直到收敛 （不用指定聚类个数?）

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) -- 支持多种距离
??一开始把所有点都当成一个 cluster
??然后每次找到距离最短的两个 cluster 合并成一个大的 cluster
??重复这个过程直到只剩一个 cluster
??
??层次聚类最大的优点，是一次性地得到整个聚类的过程
??只要得出聚类树，想分多少个 cluster 都可以直接根据树结构来得到结果
??改变 cluster 数目不需要再次计算数据点的归属
??
??层次聚类的缺点是计算量比较大，每次都要计算多个 cluster 内所有数据点的两两距离
??另外由于使用的是贪心算法，得到的只是局域最优，不一定是全局最优

from sklearn.cluster import AgglomerativeClustering
model = AgglomerativeClustering(n_clusters=3, linkage="ward")
model.fit(X)
model.labels_			## 直接输出结果, 没有 predict 函数

谱聚类 (spectral clustering)
??谱聚类过程主要有两步
??第一步是构图，将采样点数据构造成一张网图，点与点之间的边带有权值即为距离
??第二步是切图，将第一步构造出来的图切分成不同的图既聚类
??不同的子图间所有点的权值和尽可能大, 图内部所有点的权值和尽可能小
??
??优点
????对数据结构没有太多的假设要求，如 kmeans 则要求数据为凸集。
????可以通过构造稀疏 similarity graph，使得对于更大的数据集表现出明显优于其他算法的计算速度
????由于是对图切割处理，不会存在像 kmesns 聚类时将离散的小簇聚合在一起的情况
????无需像 GMM 一样对数据的概率分布做假设

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 基于密度的聚类) 算法
??取一个未处理的点
??如果是核心点（距离 eps 的范围内至少有 min_samples 个点）
??则找出所有该点密度可达的点（距离 eps 内的点，及距这些点 eps 内的点，不断扩张) 形成一个簇
??如果取出的点是非核心点，忽略，寻找下一个点
??重复这个过程直到所有点被处理
??
??优点：
????聚类速度快且能够有效处理噪声点和发现任意形状的空间聚类
????与 K-MEANS 比较起来，不需要输入要划分的聚类个数
????可以在需要时输入过滤噪声的参数
??缺点：
????当数据量增大时，要求较大的内存支持，I/O 消耗也很大
????当空间聚类的密度不均匀、聚类间距差相差很大时，聚类质量较差
????因为这种情况下参数 MinPts 和 Eps 选取困难
????算法聚类效果依赖与距离公式选取，实际应用中常用欧式距离，对于高维数据，存在 "维数灾难"

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

Affinity Propagation (近邻传播聚类)
??AP 算法的基本思想是将全部样本看作网络的节点，然后通过网络中各条边的消息传递计算出各样本的聚类中心，聚类过程中，共有两种消息在各节点间传递，分别是吸引度 (responsibility) 和归属度 (availability)，AP 算法通过迭代过程不断更新每一个点的吸引度和归属度值，直到产生 m 个高质量的 Exemplar (类似于质心)，同时将其余的数据点分配到相应的聚类中
??
??优点：
????无需指定聚类参数
????明确的质心，样本中的所有数据点都可能成为质心，
????而不是由多个数据点求平均而得到的聚类中心如 K-Means
????对距离矩阵的对称性没要求
????初始值不敏感
????若以误差平方和来衡量算法间的优劣, AP 聚类比其他方法的误差平方和都要低
??缺点：
????算法复杂度较高，为 O(NNlogN)，而 K-Means 只是 O(N*K) 的复杂度
????因此当 N 比较大时(N>3000)，AP 聚类算法往往需要算很久
????AP 聚类需要手动指定 Preference 和 Damping factor，这其实是原有的聚类数量控制的变体

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 利用层次方法的平衡迭代规约和聚类)
??适合数据量大，类别多的情况
??最大的特点是能利用有限的内存资源完成对大数据集的高质量的聚类
??同时通过单遍扫描数据集能最小化 I/O 代价
??采用多阶段聚类技术: 数据集的单边扫描产生基本的聚类
??一或多遍的额外扫描可以进一步改进聚类质量
??增量的聚类方法: 对每个数据的聚类决策都是基于当前已经处理过的数据，而不是基于全局的数据
??如果簇不是球形的，BIRCH 不能很好的工作，因为它用了半径或直径的概念来控制聚类的边界

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 算法的非线性扩展, 与 PCA 相比存在两点创新
??1. 为了更好地处理非线性数据, 引入非线性映射函数, 将原空间中的数据映射到高维空间
??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 (方差阈值)
??去掉那些方差没有达到阈值的特征
??默认情况下, 删除零方差的特征, 例如那些只有一个值的样本
??假设有一个数据集, 我们想去掉超过 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 通过结构化策略进行特征选择

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

随机梯度方法

有些算法会提供一个带随机梯度方法的接口比如

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

交叉验证

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

参数调优

学习器模型中一般有两类参数：一类参数可以从数据中学习估计得到, 还有一类参数无法从数据中估计, 只能靠人的经验进行指定, 后一类参数就叫超参数, 比如支持向量机里的 C, Kernel, gama, 朴素贝叶斯里的 alpha 等, 在学习其模型的设计中, 我们要搜索超参数空间为学习器模型找到最合理的超参数
??
sklearn 提供了两种通用的参数优化方法
??
网格搜索交叉验证 (GridSearchCV):
??以穷举的方式遍历所有可能的参数组合

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)

随机采样交叉验证 (RandomizedSearchCV):
??依据某种分布对参数空间采样, 随机的得到一些候选参数组合方案

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)

准确率, 召回率, 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)

损失函数

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 (对数损失) 或者 Cross-entropy Loss (交叉熵损失)

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))

数据预处理

标准化

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)  		## 结果和 (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)

标签二值化 (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()

标签编码 (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)

异常值处理
??如果数据中含有异常值, 那么使用均值和方差缩放数据的效果并不好, 这种情况下可以使用

preprocessing.robust_scale
preprocessing.RobustScaler

多项式转换

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()

机器学习：sk-learn

标签：explain   标记   ==   weight   ids   中学   gen   提取   ext   

原文地址：https://www.cnblogs.com/moonlight-lin/p/12578529.html