数据处理的统计学习（scikit-learn教程）

为了提升问题的状况（考虑到高维灾难），只选择信息含量较大的（对结果y造成的影响较大的）的特征，不选择信息含量较小的特征会很有趣，如把特征2的系数调到0.岭回归将会减少信息含量较小的系数的值，而不是把它们设置为0.另一种抑制措施——Lasso（最小绝对收缩和选择算子）可以使得一些参数为0.这些方法被称作稀疏方法。系数操作可以看作是奥卡姆的剃刀：模型越简单越好。

regr = linear_model.Lasso()
scores = [regr.set_params(alpha=alpha
 ? ? ? ? ? ?).fit(diabetes_X_train,diabetes_y_train
 ? ? ? ? ? ?).score(diabetes_X_test,diabetes_y_test) ? ? ? 
for alpha in alphas]
best_alpha = alphas[scores.index(max(scores))]
regr.alpha = best_alpha
regr.fit(diabetes_X_train,diabetes_y_train)print(regr.coef_)

针对相同问题的不同算法：
不同的算法可以被用来解决相同的数学问题。例如scikit-learn中的Lasso对象使用coordinate decent方法解决lasso回归问题，在大数据集上是很有效的。然而，scikit-learn也使用LARS算法提供了LassoLars对象，对于处理权重向量非常稀疏的数据非常有效（数据的观测实例非常少）。

• 分类：
  对于分类问题，比如iris标定任务，线性回归不是正确的方法。因为它会给数据得出大量远离决策边界的权重。一个线性方法是你和一个sigmoid函数或者logistic函数：

logistic = linear_model.LogisticRegression(C=1e5)
logistic.fit(iris_X_train,iris_y_train)

这就是有名的logistic回归。

• 多分类：
  如果你有多个类别需要预测，一个可行的方法是 “一对多”分类，接着根据投票决定最终的决策。

通过Logistic回归进行收缩和稀疏：

在LogisticRegression对象中C参数控制着正则化的数量：C越大，正则化数目越少。penalty= "12" 提供收缩（非稀疏化系数），penalty="11"提供稀疏化。

练习：
尝试使用近邻算法和线性模型对数字数据集进行分类。留出最后的10%作为测试集用来测试预测的精确度。

from sklearn import datasets,neighbors,linear_model
digits = datasets.load_digits()
X_digits = digits.data
y_digits = digits.target

【完整代码】

from sklearn import datasets,linear_model
digits = datasets.load_digits()
X_digits = digits.data
y_digits = digits.target
n_samples = len(X_digits)
X_train = X_digits[:.9 * n_samples]
y_train = y_digits[:.9 * n_samples]
X_test = X_digits[.9 * n_samples:]
y_test = y_digits[.9 * n_samples:]
knn = neighbors.KNeighborsClassifier()
logistic = linear_model.LogisticRegression()print('KNN score: %f' % knn.fit(X_train,y_train).score(X_test,y_test))print('LogisticRegression score: %f'
 ? ? ?% logistic.fit(X_train,y_test))

（3）支持向量机（SVMs）

线性SVNs：
支持向量机属于判别模型家族：它们尝试寻找样例的一个组合，构建一个两类之间的最大边缘平面。通过C参数进行正则化：一个较小的C意味着边缘是通过分割线周围的所有观测样例进行计算得到的（更规整化，正则化）；一个较大的C意味着边缘是通过邻近分割线的观测样例计算得到的（更少的规整化，正则化）：

• 非正则化SVN:

• 正则化 SVM(默认)：

样例：Plot different SVM分类器 iris数据集

SVMs能够被用于回归——SVR（支持向量回归）—用于分类——SVC(支持向量分类)
from sklearn import svm
svc = svm.SVC(kernel='linear')
svc.fit(iris_X_train,iris_y_train)
【警告】：规格化数据
对于大多数的估测模型，包括SVMs，处理好单位标准偏差对于获得一个好的预测是很重要的。

使用核函数：
在特征空间中类别不经常是线性可分的。解决方案是构建一个非线性但能用多项式代替的决策函数。这要通过核技巧实现：使用核可以被看作通过设置核在观测样例上创建决策力量。

• 线性核：

• 多项式核：

• 径向基函数核（RBF,Radial Basis Function）：

svc = svm.SVC(kernel='rbf')

交互式样例：
参照SVM GUI，下载svm_gui.py;通过鼠标左右键设置两类数据点，拟合模型并改变参数和数据。

练习：

尝试使用SVMs根据iris数据集前两个特征将其分成两类。留出每一类的10%作为测试样例。
【警告】数据集中的数据是按照分类顺序排列的，不要留出最后的10%作为测试样例，要不然你只能测试一种类别。（获取训练集和测试集是注意要进行混淆）
提示：你可以在一个网格上使用decision_function方法获得直观的呈现。

iris = datasets.load_iris()
X = iris.data
y = iris.target
X = X[y != 0,:2]
y = y[y != 0]

完整代码：

"""================================SVM Exercise================================A tutorial exercise for using different SVM kernels.This exercise is used in the :ref:`using_kernels_tut` part of the:ref:`supervised_learning_tut` section of the :ref:`stat_learn_tut_index`."""print(__doc__)import numpy as npimport matplotlib.pyplot as pltfrom sklearn import datasets,svm
iris = datasets.load_iris()
X = iris.data
y = iris.target
X = X[y != 0,:2]
y = y[y != 0]
n_sample = len(X)
np.random.seed(0)
order = np.random.permutation(n_sample)
X = X[order]
y = y[order].astype(np.float)
X_train = X[:.9 * n_sample]
y_train = y[:.9 * n_sample]
X_test = X[.9 * n_sample:]
y_test = y[.9 * n_sample:]# fit the modelfor fig_num,kernel in enumerate(('linear','rbf','poly')):
 ? ?clf = svm.SVC(kernel=kernel,gamma=10)
 ? ?clf.fit(X_train,y_train)
 ? ?plt.figure(fig_num)
 ? ?plt.clf()
 ? ?plt.scatter(X[:,0],X[:,1],c=y,zorder=10,cmap=plt.cm.Paired) ? ?# Circle out the test data
 ? ?plt.scatter(X_test[:,X_test[:,s=80,facecolors='none',zorder=10)
 ? ?plt.axis('tight')
 ? ?x_min = X[:,0].min()
 ? ?x_max = X[:,0].max()
 ? ?y_min = X[:,1].min()
 ? ?y_max = X[:,1].max()
 ? ?XX,YY = np.mgrid[x_min:x_max:200j,y_min:y_max:200j]
 ? ?Z = clf.decision_function(np.c_[XX.ravel(),YY.ravel()]) ? ?# Put the result into a color plot
 ? ?Z = Z.reshape(XX.shape)
 ? ?plt.pcolormesh(XX,YY,Z > 0,cmap=plt.cm.Paired)
 ? ?plt.contour(XX,Z,colors=['k','k','k'],linestyles=['--','-','--'],? ? ? ? ? ? ? ?levels=[-.5,0,.5])
 ? ?plt.title(kernel)
plt.show()

三、模型选择：选择模型和他们的参数

（1）分数，和交叉验证分数

众所周知，每一个模型会得出一个score方法用于裁决模型在新的数据上拟合的质量。其值越大越好。

from sklearn import datasets,svm
digits = datasets.load_digits()
X_digits = digits.data
 y_digits = digits.target
svc = svm.SVC(C=1,kernel='linear')
svc.fit(X_digits[:-100],y_digits[:-100]).score(X_digits[-100:],y_digits[-100:])

为了获得一个更好的预测精确度度量，我们可以把我们使用的数据折叠交错地分成训练集和测试集：

import numpy as np
X_folds = np.array_split(X_digits,3)
y_folds = np.array_split(y_digits,3)
scores = list()for k in range(3): ? ?# We use 'list' to copy,in order to 'pop' later on
 ? ?X_train = list(X_folds)
 ? ?X_test ?= X_train.pop(k)
 ? ?X_train = np.concatenate(X_train)
 ? ?y_train = list(y_folds)
 ? ?y_test ?= y_train.pop(k)
 ? ?y_train = np.concatenate(y_train)
 ? ?scores.append(svc.fit(X_train,y_test))print(scores)

这被称为KFold交叉验证

（2）交叉验证生成器

上面将数据划分为训练集和测试集的代码写起来很是沉闷乏味。scikit-learn为此自带了交叉验证生成器以生成目录列表：

from sklearn import cross_validation
k_fold = cross_validation.KFold(n=6,n_folds=3)for train_indices,test_indices in k_fold: ? ? print('Train: %s | test: %s' % (train_indices,test_indices))

接着交叉验证就可以很容易实现了：

kfold = cross_validation.KFold(len(X_digits),n_folds=3)
[svc.fit(X_digits[train],y_digits[train]).score(X_digits[test],y_digits[test]) ? ? ? ? for train,test in kfold]

为了计算一个模型的score，scikit-learn自带了一个帮助函数：

cross_validation.cross_val_score(svc,X_digits,y_digits,cv=kfold,n_jobs=-1)

n_jobs=-1意味着将计算任务分派个计算机的所有CPU.

（编辑：西安站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!