sklearn基础知识-准备阶段

6.标签特征二元化

处理分类变量还有另一种方法,不需要通过OneHotEncoder,我们可以用LabelBinarizer。

这是一个阈值与分类变量组合的方法。
In [1]:
from sklearn import datasets as d
iris = d.load_iris()
target = iris.target
How to do it...
导入LabelBinarizer()创建一个对象:
In [2]:
from sklearn.preprocessing import LabelBinarizer
label_binarizer = LabelBinarizer()
现在,将因变量的值转换成一个新的特征向量:

In [3]:
new_target = label_binarizer.fit_transform(target)
让我们看看new_target和label_binarizer对象的结果:

In [4]:
new_target.shape
Out[4]:
(150, 3)
In [5]:
new_target[:5]

In [6]:
new_target[-5:]

In [9]:
label_binarizer.classes_
Out[9]:
array([0, 1, 2])

iris的因变量基数为3,就是说有三种值,

当LabelBinarizer将 N×1N×1 向量转换成 N×CN×C 矩阵时, CC 就是 N×1N×1 向量的基数。

需要注意的是,当label_binarizer处理因变量之后,再转换基数以外的值都是[0,0,0]:

In [15]:
label_binarizer.transform([4])
Out[15]:
array([[0, 0, 0]])
There's more...
0和1并不一定都是表示因变量中的阳性和阴性实例。例如,如果我们需要用1000表示阳性值,用-1000表示阴性值,我们可以用label_binarizer处理:

In [22]:
label_binarizer = LabelBinarizer(neg_label=-1000, pos_label=1000)
label_binarizer.fit_transform(target)[:5]

7.处理缺失值
scikit-learn有一些常见的计算方法,它可以对现有数据进行变换填补NA值。
In [2]:
from sklearn import datasets
import numpy as np
iris = datasets.load_iris()
iris_X = iris.data
masking_array = np.random.binomial(1, .25, iris_X.shape).astype(bool)
iris_X[masking_array] = np.nan
In [3]:
masking_array[:5]

In [4]:
iris_X[:5]

In [5]:
from sklearn import preprocessing
impute = preprocessing.Imputer()
iris_X_prime = impute.fit_transform(iris_X)
iris_X_prime[:5]
默认是均值mean,一共是三种:

均值mean(默认方法)
中位数median
众数most_frequent
scikit-learn会用指定的方法计算数据集中的每个缺失值,然后把它们填充好。

例如,用median方法重新计算iris_X,重新初始化impute即可:

In [9]:
impute = preprocessing.Imputer(strategy='median')
iris_X_prime = impute.fit_transform(iris_X)
iris_X_prime[:5]

In [10]:
iris_X[np.isnan(iris_X)] = -1
iris_X[:5]

In [11]:
impute = preprocessing.Imputer(missing_values=-1)
iris_X_prime = impute.fit_transform(iris_X)
iris_X_prime[:5]
Out[11]:
array([[ 5.1       ,  3.05221239,  1.4       ,  0.2       ],
       [ 4.9       ,  3.05221239,  1.4       ,  0.2       ],
       [ 4.7       ,  3.2       ,  1.3       ,  0.2       ],
       [ 5.86306306,  3.1       ,  1.5       ,  1.21388889],
       [ 5.        ,  3.6       ,  3.82685185,  0.2       ]])
There's more...
pandas库也可以处理缺失值,而且更加灵活,但是重用性较弱:

In [12]:
import pandas as pd
iris_X[masking_array] = np.nan
iris_df = pd.DataFrame(iris_X, columns=iris.feature_names)
iris_df.fillna(iris_df.mean())['sepal length (cm)'].head(5)
Out[12]:
0    5.100000
1    4.900000
2    4.700000
3    5.863063
4    5.000000
Name: sepal length (cm), dtype: float64
其灵活性在于,fillna可以填充任意统计参数值:

In [13]:
iris_df.fillna(iris_df.max())['sepal length (cm)'].head(5)

8.用管线命令处理多个步骤
管线命令可以把多个步骤组合成一个对象执行。
这样可以更方便灵活地调节和控制整个模型的配置,而不只是一个一个步骤调节。
In [1]:
from sklearn import datasets
import numpy as np
mat = datasets.make_spd_matrix(10)
masking_array = np.random.binomial(1, .1, mat.shape).astype(bool)
mat[masking_array] = np.nan
mat[:4, :4]
不用管道命令:
In [2]:
from sklearn import preprocessing
impute = preprocessing.Imputer()
scaler = preprocessing.StandardScaler()
mat_imputed = impute.fit_transform(mat)
mat_imputed[:4, :4]

In [5]:
mat_imp_and_scaled = scaler.fit_transform(mat_imputed)
mat_imp_and_scaled[:4, :4]

现在我们用pipeline来演示:
In [6]:
from sklearn import pipeline
pipe = pipeline.Pipeline([('impute', impute), ('scaler', scaler)])
我们看看pipe的内容。和前面介绍一致,管线命令定义了处理步骤:
In [7]:
pipe
Out[7]:
Pipeline(steps=[('impute', Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)), 

('scaler', StandardScaler(copy=True, with_mean=True, with_std=True))])
然后在调用pipe的fit_transform方法,就可以把多个步骤组合成一个对象了:
In [10]:
new_mat = pipe.fit_transform(mat)
new_mat[:4, :4]

In [11]:
np.array_equal(new_mat, mat_imp_and_scaled)
Out[11]:
True
pipeline最重要的函数也不外乎下面三个:

fit
transform
fit_transform
具体来说,如果管线命令有N个对象,前N-1个对象必须实现fit和transform,

第N个对象至少实现fit。否则就会出现错误。
使用管线命令的理由主要有两点:

首先是方便。
其次,就是使用交叉验证。模型可以变得很复杂。如果管线命令中的一个步骤调整了参数,

那么它们必然需要重新测试;测试一个步骤参数的代码管理成本是很低的。但是,
如果测试5个步骤的全部参数会变都很复杂。管线命令可以缓解这些负担。
9.用主成分分析降维
主成分分析(Principal component analysis,PCA)是本书介绍的第一个高级技术。
而PCA将统计学和线性代数组合起来实现降维,堪称简单模型的杀手锏。

PCA是scikit-learn的一个分解模块。
In [1]:
from sklearn import datasets
iris = datasets.load_iris()
iris_X = iris.data

In [2]:
from sklearn import decomposition
然后,初始化一个PCA对象:
In [3]:
pca = decomposition.PCA()
pca
Out[3]:
PCA(copy=True, n_components=None, whiten=False)
PCA的参数很少。这样PCA对象就创建了,

下面用fit_transform处理iris_X数据:
In [6]:
iris_pca = pca.fit_transform(iris_X)
iris_pca[:5]

这样PCA就完成了,我们可以看看降维的效果:

In [8]:
pca.explained_variance_ratio_
Out[8]:
array([ 0.92461621,  0.05301557,  0.01718514,  0.00518309])
PCA用正交向量集表示原始数据集。
PCA将原始数据集映射到新的空间中,里面每个列向量都是彼此正交的。从数据分析的视角看,

PCA将数据集的协方差矩阵变换成若干能够“解释”一定比例变量的列向量。
例如,在iris数据集中,92.5%的变量可以由第一个主成份表示。

数据分析里面维度多会导致维度灾难,因此降维至关重要。通常算法处理高维训练集时会出现拟合过度(overfit)

的情况,于是难以把握测试集的一般性特征。如果数据集的真实结构可以用更少的维度表示,那么通常都值得一试。

为了演示这点,我们用PCA将iris数据集转换成二维数据。iris数据集用全部的维度通常可以很好的分类:

In [9]:
pca = decomposition.PCA(n_components=2)
iris_X_prime = pca.fit_transform(iris_X)
iris_X_prime.shape
Out[9]:
(150, 2)
我们的矩阵现在是 150×2150×2 ,不是 150×4150×4 了。二维变量更容易可视化:

PCA对象还可以一开始设置解释变量的比例。例如,如果我们想介绍98%的变量,PCA对象就可以这样创建:

In [15]:
pca = decomposition.PCA(n_components=.98)
iris_X_prime = pca.fit_transform(iris_X)
pca.explained_variance_ratio_.sum()
Out[15]:
0.99481691454981014
In [16]:
iris_X_prime.shape
Out[16]:
(150, 3)

10 用因子分析降维
因子分析(factor analysis)是另一种降维方法。与PCA不同的是,因子分析有假设而PCA没有假设。
因子分析的基本假设是有一些隐藏特征与数据集的特征相关。
这个主题将浓缩(boil down)样本数据集的显性特征,尝试像理解因变量一样地理解自变量之间的隐藏特征。
让我们再用iris数据集来比较PCA与因子分析,首先加载因子分析类:
In [3]:
from sklearn import datasets
iris = datasets.load_iris()
from sklearn.decomposition import FactorAnalysis

In [6]:
fa = FactorAnalysis(n_components=2)
iris_two_dim = fa.fit_transform(iris.data)
iris_two_dim[:5]

由于因子分析是一种概率性的转换方法,我们可以通过不同的角度来观察,

例如模型观测值的对数似然估计值,通过模型比较对数似然估计值会更好。

因子分析也有不足之处。由于你不是通过拟合模型直接预测结果,拟合模型只是一个中间步骤。

这本身并非坏事,但是训练实际模型时误差就会产生。
因子分析与前面介绍的PCA类似。但两者有一个不同之处。PCA是通过对数据进行线性变换获取一个能够解释
数据变量的主成分向量空间,这个空间中的每个主成分向量都是正交的。你可以把PCA看成是 NN 维数据集降维成
 MM 维,其中 M<NM<N 。

而因子分析的基本假设是,有 MM 个重要特征和它们的线性组合(加噪声),能够构成原始的 NN 维数据集。

也就是说,你不需要指定结果变量(就是最终生成 NN 维),而是要指定数据模型的因子数量( MM 个因子)
13.用字典学习分解法分类
用于分类的分解方法——字典学习(Dictionary Learning),将数据集转换成一个稀疏的形式。
DictionaryLearning方法的思想是把特征看作构成数据集的基础。首先我们导入iris数据集:

In [1]:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
In [2]:
from sklearn.datasets import load_iris
iris = load_iris()
iris_data = iris.data
iris_target = iris.target

首先,导入DictionaryLearning:
In [3]:
from sklearn.decomposition import DictionaryLearning
然后用三个成分表示iris数据集中花的类型:

In [4]:
dl = DictionaryLearning(3)
再用fit_transform转换其他数据,这样我们就可以对比训练前后的数据了:
In [5]:
transformed = dl.fit_transform(iris_data[::2])
transformed[:5]
意,每个成分的值分别平行 xx , yy 和 zz 三个轴,其他坐标都是0;这就是稀疏性。

In [6]:
from mpl_toolkits.mplot3d import Axes3D
colors = np.array(list('rgb'))
f = plt.figure()
ax = f.add_subplot(111, projection='3d')
ax.set_title("Training Set")
ax.scatter(transformed[:, 0], transformed[:, 1], transformed[:, 2], color=colors[iris.target[::2]]);

下面,让我们用fit而不用fit_transform来训练数据集:

In [7]:
transformed = dl.transform(iris_data[1::2])
In [8]:
colors = np.array(list('rgb'))
f = plt.figure()
ax = f.add_subplot(111, projection='3d')
ax.set_title("Training Set")
ax.scatter(transformed[:, 0], transformed[:, 1], transformed[:, 2], color=colors[iris.target[1::2]]);

17.用随机梯度下降处理回归
随机梯度下降法(Stochastic Gradient Descent,SGD),我们将用它解决回归问题,后面我们还用它处理分类问题。
SGD成为许多机器学习算法的核心的另一个原因是它很容易描述过程。我们对数据作一些变换,
然后用模型的损失函数(loss function)拟合数据。
In [5]:
from sklearn import datasets
X, y = datasets.make_regression(int(1e6))
print("{:,}".format(int(1e6)))
1,000,000
还在我们用的是NumPy数组,所以我们可以获得nbytes。
Python本身没有获取NumPy数组大小的方法。输

In [9]:
print("{:,}".format(X.nbytes))
800,000,000

In [10]:
X.nbytes / 1e6
Out[10]:
800.0
In [11]:
X.nbytes / (X.shape[0] * X.shape[1])
Out[11]:
8.0
现在,我们有了数据,就用SGDRegressor来拟合:
In [13]:
import numpy as np
from sklearn import linear_model
sgd = linear_model.SGDRegressor()
train = np.random.choice([True, False], size=len(y), p=[.75, .25])
sgd.fit(X[train], y[train])
Out[13]:
SGDRegressor(alpha=0.0001, average=False, epsilon=0.1, eta0=0.01,
       fit_intercept=True, l1_ratio=0.15, learning_rate='invscaling',
       loss='squared_loss', n_iter=5, penalty='l2', power_t=0.25,
       random_state=None, shuffle=True, verbose=0, warm_start=False)
损失函数是squared_loss,与线性回归里的残差平方和是一样的。

还需要注意shuffle会对数据产生随机搅动(shuffle),这在解决伪相关问题时很有用。
scikit-learn用fit_intercept方法可以自动加一列1。如果想从拟合结果中看到很多输出,
就把verbose设为1。用scikit-learn的API预测,我们可以统计残差的分布情况:

In [16]:
linear_preds = sgd.predict(X[~train])
In [17]:
%matplotlib inline
from matplotlib import pyplot as plt
f, ax = plt.subplots(figsize=(7, 5))
f.tight_layout()
ax.hist(linear_preds - y[~train],label='Residuals Linear', color='b', alpha=.5);
ax.set_title("Residuals")
ax.legend(loc='best');

标准的梯度下降法的思想是在每次迭代计算一个新的相关系数矩阵,然后用学习速率(learning rate)和

目标函数(objective function)的梯度调整它,直到相关系数矩阵收敛为止。如果用伪代码写就是这样:
上一篇:Javascript日期时间总结


下一篇:协议森林16 小美的桌号(DHCP协议)