首页 > 代码库 > 人大任务参考

人大任务参考

机器学习基本概念

机器学习、统计模型和数据挖掘有什么异同?

机器学习和统计模型区别不是很大,机器学习和统计模型中的回归都一样,底层算法都是差不多的,只是侧重点不一样,在统计学的角度,回归主要解决的问题侧重点在于模型的解释能力,关注的是 x 和 y 之间的关系,关注的更多是系数,从机器学习的角度看,关注的重点是预测的准确性。

机器学习和数据挖掘也没什么不一样,两者的算法基本上是一样的,只是在一些流程步骤上,数据挖掘会有一些特征工程的工作,以及对具体应用问题的解释。

有监督学习和无监督学习有什么区别?

有监督学习就是指有 y 作为数据的一部分,被称为目标变量,或被解释变量。无监督学习是指一堆数据,没有特定的 y,要从一堆 x 里找到模式或者规律出来。

有监督学习可以分为两个子类:分类和回归。分类问题中要预测的 y 偏离散,比如性别、血型;回归问题 y 都是连续的,实数域中的,比如收入、天气。

分类问题和聚类问题有什么区别?

分类问题是预测一个未知类别的对象属于哪个类别,而聚类是根据选定的指标,对一群对象进行划分,它不属于预测问题。

交叉验证是什么?

交叉验证是指用来建立模型的数据,和最后用来模型验证的数据,是不一样的。实践中拿到数据后,应该分为几个部分,最简单的分为两部分,一部分用于训练模型,另外一部分用于检验模型,这就是交叉验证。

何时用到特征工程?

特征工程是指要把原始数据做些整理,做些转换,主要目的是暴露出预测 y 的信息。

如何加载 sklearn 的内置数据集?

from sklearn import datasets
from sklearn import cross_validation
from sklearn import linear_model
from sklearn import metrics
from sklearn import tree
from sklearn import neighbors
from sklearn import svm
from sklearn import ensemble
from sklearn import cluster
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

skearn 有很多内置的数据集,上面已经加载了 sklearn 的 datasets,datasets 有一些可以用的数据,比如说加载 boston 数据集,加载后返回的就是个数据字典。

boston = datasets.load_boston()
print boston.keys()
[‘data‘, ‘feature_names‘, ‘DESCR‘, ‘target‘]

数据集的大小/格式/类型等信息如何得知?

print boston.DESCR
Boston House Prices dataset

Notes
------
Data Set Characteristics:  

    :Number of Instances: 506 

    :Number of Attributes: 13 numeric/categorical predictive
    
    :Median Value (attribute 14) is usually the target

    :Attribute Information (in order):
        - CRIM     per capita crime rate by town
        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.
        - INDUS    proportion of non-retail business acres per town
        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
        - NOX      nitric oxides concentration (parts per 10 million)
        - RM       average number of rooms per dwelling
        - AGE      proportion of owner-occupied units built prior to 1940
        - DIS      weighted distances to five Boston employment centres
        - RAD      index of accessibility to radial highways
        - TAX      full-value property-tax rate per $10,000
        - PTRATIO  pupil-teacher ratio by town
        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
        - LSTAT    % lower status of the population
        - MEDV     Median value of owner-occupied homes in $1000‘s

    :Missing Attribute Values: None

    :Creator: Harrison, D. and Rubinfeld, D.L.

This is a copy of UCI ML housing dataset.
http://archive.ics.uci.edu/ml/datasets/Housing


This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.

The Boston house-price data of Harrison, D. and Rubinfeld, D.L. ‘Hedonic
prices and the demand for clean air‘, J. Environ. Economics & Management,
vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, ‘Regression diagnostics
...‘, Wiley, 1980.   N.B. Various transformations are used in the table on
pages 244-261 of the latter.

The Boston house-price data has been used in many machine learning papers that address regression
problems.   
     
**References**

   - Belsley, Kuh & Welsch, ‘Regression diagnostics: Identifying Influential Data and Sources of Collinearity‘, Wiley, 1980. 244-261.
   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.
   - many more! (see http://archive.ics.uci.edu/ml/datasets/Housing)
boston.data # 自变量矩阵,面积、家具等特征
array([[  6.32000000e-03,   1.80000000e+01,   2.31000000e+00, ...,
          1.53000000e+01,   3.96900000e+02,   4.98000000e+00],
       [  2.73100000e-02,   0.00000000e+00,   7.07000000e+00, ...,
          1.78000000e+01,   3.96900000e+02,   9.14000000e+00],
       [  2.72900000e-02,   0.00000000e+00,   7.07000000e+00, ...,
          1.78000000e+01,   3.92830000e+02,   4.03000000e+00],
       ..., 
       [  6.07600000e-02,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.96900000e+02,   5.64000000e+00],
       [  1.09590000e-01,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.93450000e+02,   6.48000000e+00],
       [  4.74100000e-02,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.96900000e+02,   7.88000000e+00]])
boston.data.shape
(506, 13)
boston.target.shape # 目标变量,房价
(506,)

datasets 除了现有的数据,还可以造一些数据,通过人造数据,来研究不同算法的特点。

datasets.make_regression
<function sklearn.datasets.samples_generator.make_regression>

回归问题

回归问题中,y 是个连续的数值,不仅可以采取线性回归,还可以使用决策树等做回归,只要输出是连续值,都可以用回归模型。

sklearn 的回归和 statsmodel 中的回归有什么异同?

如果使用同样的模型,两者的回归的解都是一样的,只是 statsmodel 输出更多些,比较偏向对参数做更多的解释,而 sklearn 更注重预测准确性。

如何使用交叉验证?它和过拟合有什么关系?

来个完整的例子。

np.random.seed(123)
X_all, y_all = datasets.make_regression(n_samples=50, n_features=50, n_informative=10)  # 真正有用的变量只有 10 个,另外 40 个都是噪音
print X_all.shape, y_all.shape
(50, 50) (50,)

这个数据集比较棘手,样本数比较少,变量多,容易过拟合,而且有用的变量不多,有很多噪音在里面,在做回归时,很容易把噪音放到方程里,用传统的方法比较难于处理,这里用机器学习处理。

为了防止过拟合,要用交叉验证,把数据分为两部分,一部分用于训练,一部分用于验证。

X_train, X_test, y_train, y_test = cross_validation.train_test_split(X_all, y_all, train_size=0.5)
print X_train.shape, y_train.shape
print X_test.shape, y_test.shape
print type(X_train)
(25, 50) (25,)
(25, 50) (25,)
<type ‘numpy.ndarray‘>

如何以线性模型拟合数据集?

model = linear_model.LinearRegression() # 实例化
model.fit(X_train, y_train) # 做线性回归拟合数据
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)

残差(residual)是什么?如何评估模型是个好模型?

残差是真实的 y 和预测的 y 的差,残差越小,拟合越好。

def sse(resid):
    return sum(resid**2) # 残差平方和,是回归效果的一个指标

残差平方和是回归效果的一个指标,值越小,说明模型越好。

resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
print sse_train
5.87164948974e-25
resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_test)
sse_test
194948.84691187815
model.score(X_train, y_train) # 计算判定系数 R-squared
1.0
model.score(X_test, y_test)
0.26275088549060643

模型在测试集上的分数只有 0.26,效果并不好。

画出各个样本对应的残差,和各个变量的系数。

def plot_residuals_and_coeff(resid_train, resid_test, coeff):
    fig, axes = plt.subplots(1, 3, figsize=(12, 3))
    axes[0].bar(np.arange(len(resid_train)), resid_train) # 各个样本对应的残差
    axes[0].set_xlabel("sample number")
    axes[0].set_ylabel("residual")
    axes[0].set_title("training data")
    axes[1].bar(np.arange(len(resid_test)), resid_test) # 各个样本对应的残差
    axes[1].set_xlabel("sample number")
    axes[1].set_ylabel("residual")
    axes[1].set_title("testing data")
    axes[2].bar(np.arange(len(coeff)), coeff) # 各个变量的系数
    axes[2].set_xlabel("coefficient number")
    axes[2].set_ylabel("coefficient")
    fig.tight_layout()
    return fig, axes
fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_); # 训练集的残差,测试集的残差,各个系数的大小

技术分享

可以看到第一幅图训练集中的残差不算大,范围在 -3 到 5 之间,测试集的残差就过大,范围在 -150 到 250 之间,可见模型过拟合了,在训练集上还行,测试集上就很糟糕。

真实变量里只有 10 个是有用的,而上面的变量系数图有很多都不是 0,有很多冗余。变量多,样本少,怎么解决呢?

变量比样本多时,如何处理?

一种方法是做个主成分分析,降维,对变量做个筛选,再放到模型里来,但这种方法比较麻烦。

还有种是正则化的方法。

正则化是什么?有哪两种方法?

正则化在统计学里有两种思路,一种叫岭回归,把系数放到 loss function 中,经典的 loss function 是残差平方和,这里把 50 个系数平方求和,放到 loss function 中,所以最终既要使残差平方和小,又要使权重小,可以压制一些过于冗余的权重。

model = linear_model.Ridge(alpha=5) # 参数 alpha 表示对于权重系数的决定因子
model.fit(X_train, y_train)
Ridge(alpha=5, copy_X=True, fit_intercept=True, max_iter=None,
   normalize=False, random_state=None, solver=‘auto‘, tol=0.001)
resid_train = y_train - model.predict(X_train)
sse_train = sum(resid_train**2)
print sse_train
2963.35374445
resid_test = y_test - model.predict(X_test)
sse_test = sum(resid_test**2)
print sse_test
187177.590437

残差平方和还比较高。

model.score(X_train, y_train), model.score(X_test, y_test)
(0.99197132152011414, 0.29213988699168503)

之前测试集的 R 方是 0.26,这里是 0.29,略有改善。

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)

技术分享

从图上看,training 的残差增加了,testing 的有所减少,系数大小没有太多改善,所以在这里使用岭回归有一点点效果,并不明显。

下面使用正则化的另一种方法,称为 Lasso,思路跟岭回归是一样的,都是把残差平方和以及系数放到 loss function 中,既要使残差平方和小,又要使系数小,但 Losso 公式有点不一样,Losso 是把权重的绝对值加起来,而岭回归是把权重的方法加起来,有这么一点不一样,就可以使得很多权重回为 0。看小效果。

model = linear_model.Lasso(alpha=1.0)
model.fit(X_train, y_train)
Lasso(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=1000,
   normalize=False, positive=False, precompute=False, random_state=None,
   selection=‘cyclic‘, tol=0.0001, warm_start=False)
resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
print sse_train
256.539066413
resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_test)
print sse_test
691.523154567
fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)

技术分享

testing 的残差有明显的减小,范围减小到 -10 到 15 之间。很多系数也变为 0,真正的起作用的只有少数几个。这是 lasso 的优点,它可以应付有很多噪音的情况,对于维度比较高噪音比较多的情况,lasso 可以在建模的同时做降维。

alphas = np.logspace(-4, 2, 100) # 尝试 100 个不同的 alpha
coeffs = np.zeros((len(alphas), X_train.shape[1]))
sse_train = np.zeros_like(alphas)
sse_test = np.zeros_like(alphas)

for n, alpha in enumerate(alphas):
    model = linear_model.Lasso(alpha=alpha)
    model.fit(X_train, y_train)
    coeffs[n, :] = model.coef_
    resid = y_train - model.predict(X_train)
    sse_train[n] = sum(resid**2)
    resid = y_test - model.predict(X_test)
    sse_test[n] = sum(resid**2)
fig, axes = plt.subplots(1, 2, figsize=(12, 4), sharex=True)

for n in range(coeffs.shape[1]):
    axes[0].plot(np.log10(alphas), coeffs[:, n], color=‘k‘, lw=0.5)

axes[1].semilogy(np.log10(alphas), sse_train, label="train")
axes[1].semilogy(np.log10(alphas), sse_test, label="test")
axes[1].legend(loc=0)

axes[0].set_xlabel(r"${\log_{10}}\alpha$", fontsize=18)
axes[0].set_ylabel(r"coefficients", fontsize=18)
axes[1].set_xlabel(r"${\log_{10}}\alpha$", fontsize=18)
axes[1].set_ylabel(r"sse", fontsize=18)
fig.tight_layout()

技术分享

alpha 为 0 时,表示没有在 loss function 中放权重项,即没有惩罚,这时做回归,跟前面结果是一样的。

alpha 增大,很多噪音的因子就会降为 0,即对变量做筛选。

我们的目标是要使模型的预测效果最佳,自然要选择测试集上残差平方和最小的地方所对应的 alpha。

怎么求这个点,实际用时用 LassoCV 自动找出最好的 alpha。

model = linear_model.LassoCV() # 可以去尝试不同的参数值
model.fit(X_all, y_all)
LassoCV(alphas=None, copy_X=True, cv=None, eps=0.001, fit_intercept=True,
    max_iter=1000, n_alphas=100, n_jobs=1, normalize=False, positive=False,
    precompute=‘auto‘, random_state=None, selection=‘cyclic‘, tol=0.0001,
    verbose=False)
model.alpha_ # 自动找出最好的 alpha
0.06559238747534718
resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
print sse_train
1.76481994041
resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_test)
print sse_test
1.31238073253

效果非常不错。

model.score(X_train, y_train), model.score(X_test, y_test)
(0.9999952185351132, 0.99999503689532787)
fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)

技术分享

training 和 testing 的残差都比较小,无关变量的系数都被压到 0。效果非常好。

分类问题

分类问题和回归问题有什么区别?

分类的目标和回归不一样,虽然都是做预测,回归的 y 是连续的数值,分类预测的 y 是离散的数值,比如预测明天会不会下雨,就有会下雨和不会下雨两种情况,这是二元分类问题,编码时可编为 0 和 1 两种情况,还有是判断一个图形是什么阿拉伯数字,可能是 0,1,...,9,有 10 个可能的分类,是多元分类问题。

之前用的 statsmodels 的 logistic 回归就是分类模型,这里用 sklearn 中更多的分类模型。

sklearn 内有哪些分类模型?

  • 广义线性模型

    • 岭回归
    • Logistic 回归
    • 贝叶斯回归
  • 支持向量机

  • 最近邻

  • 朴素贝叶斯

  • 决策树

iris = datasets.load_iris() # 载入鸢尾花数据集
print iris.target_names
print iris.feature_names
[‘setosa‘ ‘versicolor‘ ‘virginica‘]
[‘sepal length (cm)‘, ‘sepal width (cm)‘, ‘petal length (cm)‘, ‘petal width (cm)‘]
print iris.data.shape
print iris.target.shape
(150, 4)
(150,)
X_train, X_test, y_train, y_test = cross_validation.train_test_split(iris.data, iris.target, train_size=0.7) # 70% 用于训练,30% 用于检验
classifier = linear_model.LogisticRegression()
classifier.fit(X_train, y_train)
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class=‘ovr‘, n_jobs=1,
          penalty=‘l2‘, random_state=None, solver=‘liblinear‘, tol=0.0001,
          verbose=0, warm_start=False)
y_test_pred = classifier.predict(X_test)

如何评估分类效果?confusion matrix 是什么?

用 metrics 模块来检查模型效果,其中的 classification_report 是分类报告,显示各种指标,来衡量模型的效果。

print(metrics.classification_report(y_test, y_test_pred)) # 真实的 y 和预测的 y
             precision    recall  f1-score   support

          0       1.00      1.00      1.00        15
          1       1.00      0.75      0.86        16
          2       0.78      1.00      0.88        14

avg / total       0.93      0.91      0.91        45

precision 是精准度,recall 是召回率,fs-score 是 F1 值。从这几个值可以看到模型很完美。

还可以用混淆矩阵 confusion matrix 来评估分类器。混淆矩阵的每一列代表了预测类别,每一列的总数表示预测为该类别的数据的数目;每一行代表了数据的真实归属类别,每一行的数据总数表示该类别的数据实例的数目。每一列中的数值表示真实数据被预测为该类的数。如果混淆矩阵的所有数据都在对角线上,就说明预测是完全正确的。

metrics.confusion_matrix(y_test, y_test_pred)
array([[15,  0,  0],
       [ 0, 12,  4],
       [ 0,  0, 14]])
y_test.shape
(45,)
classifier = tree.DecisionTreeClassifier() # 决策树
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)
array([[12,  0,  0],
       [ 0, 13,  2],
       [ 0,  2, 16]])
classifier = neighbors.KNeighborsClassifier() # K 近邻
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)
array([[12,  0,  0],
       [ 0, 14,  1],
       [ 0,  2, 16]])
classifier = svm.SVC() # 支持向量机
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)
array([[12,  0,  0],
       [ 0, 15,  0],
       [ 0,  3, 15]])
classifier = ensemble.RandomForestClassifier()
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)
array([[12,  0,  0],
       [ 0, 14,  1],
       [ 0,  2, 16]])
train_size_vec = np.linspace(0.1, 0.9, 30) # 尝试不同的样本大小
classifiers = [tree.DecisionTreeClassifier,
               neighbors.KNeighborsClassifier,
               svm.SVC,
               ensemble.RandomForestClassifier
              ]
cm_diags = np.zeros((3, len(train_size_vec), len(classifiers)), dtype=float) # 用来放结果
for n, train_size in enumerate(train_size_vec):
    X_train, X_test, y_train, y_test =         cross_validation.train_test_split(iris.data, iris.target, train_size=train_size)

    for m, Classifier in enumerate(classifiers): 
        classifier = Classifier()
        classifier.fit(X_train, y_train)
        y_test_pred = classifier.predict(X_test)
        cm_diags[:, n, m] = metrics.confusion_matrix(y_test, y_test_pred).diagonal()
        cm_diags[:, n, m] /= np.bincount(y_test)
fig, axes = plt.subplots(1, len(classifiers), figsize=(12, 3))

for m, Classifier in enumerate(classifiers): 
    axes[m].plot(train_size_vec, cm_diags[2, :, m], label=iris.target_names[2])
    axes[m].plot(train_size_vec, cm_diags[1, :, m], label=iris.target_names[1])
    axes[m].plot(train_size_vec, cm_diags[0, :, m], label=iris.target_names[0])
    axes[m].set_title(type(Classifier()).__name__)
    axes[m].set_ylim(0, 1.1)
    axes[m].set_xlim(0.1, 0.9)
    axes[m].set_ylabel("classification accuracy")
    axes[m].set_xlabel("training size ratio")
    axes[m].legend(loc=4)

fig.tight_layout()

技术分享

样本大小对预测分类结果有影响吗?

从上图可看出,当样本太小时,有些模型会表现很差,比如决策树、K 最近邻 和SVC,KNN 和 SVM 是比较依赖数据规模的。当 train size 变大后,分类准确率就比较高了。

聚类问题

聚类是一种无监督学习方法。

聚类问题的应用场景是什么?

主要解决把一群对象划分为若干个组的问题。例如用户细分:选择若干指标把用户群聚为若干个组,组内特征类似,组件特征差异明显。

应用最广泛的聚类方法是什么?

K-means 聚类。

X, y = iris.data, iris.target
np.random.seed(123)
n_clusters = 3 # 可以尝试其它值
c = cluster.KMeans(n_clusters=n_clusters) # 实例化
c.fit(X) # 这里的 fit 没有 y
KMeans(copy_x=True, init=‘k-means++‘, max_iter=300, n_clusters=3, n_init=10,
    n_jobs=1, precompute_distances=‘auto‘, random_state=None, tol=0.0001,
    verbose=0)
y_pred = c.predict(X)
print y_pred[::8]
print y[::8]
[1 1 1 1 1 1 1 2 2 2 2 2 2 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2]

聚类结果是 1、2、0,真实结果是 0、1、2。为了跟真实值做比对,需要做个转换。

idx_0, idx_1, idx_2 = (np.where(y_pred == n) for n in range(3)) # 做转换
y_pred[idx_0], y_pred[idx_1], y_pred[idx_2] = 2, 0, 1
print y_pred[::8]
print y[::8]
[0 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2]
[0 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2]
print metrics.confusion_matrix(y, y_pred) # 当然在实际场景中是不可能有混淆矩阵的,因为根本就没有真实的 y
[[50  0  0]
 [ 0 48  2]
 [ 0 14 36]]

人大任务参考