基于sklearn的例子-准备阶段

1，得到数据Getting ready
scikit-learn的内置数据库在datasets模块里。用如下命令导入：
from sklearn import datasets
import numpy as np
在IPython里面运行datasets.*?就会看到datasets模块的指令列表。

datasets模块主要有两种数据类型。较小的测试数据集在sklearn包里面，可以通过datasets.load_*?查看。

默认在sklearn包里面的数据集可以通过datasets.load_*?查看。

另外一些数据集需要通过datasets.fetch_*?下载，

首先，加载boston数据集看看：
boston = datasets.load_boston()
print(boston.DESCR)
housing = datasets.fetch_california_housing()
print(housing.DESCR)
当这些数据集被加载时，它们并不是直接转换成Numpy数组。它们是Bunch类型。Bunch是Python常用的
数据结构。基本可以看成是一个词典，它的键被实例对象作为属性使用。

用data属性连接数据中包含自变量的Numpy数组，用target属性连接数据中的因变量。

X, y = boston.data, boston.target

数据集默认会被当前文件夹的scikit_learn_data/放在里面，可以通过两种方式进行配置：
设置SCIKIT_LEARN_DATA环境变量指定下载位置
fetch_*?方法的第一个参数是data_home，可以知道下载位置
通过datasets.get_data_home()很容易检查默认下载位置




2.把数据调整为标准正态分布

Z值表（z-scores）Z值表的作用就是把服从某种分布的特征转换成标准正态分布的Z值。
数据标准化调整是非常有用的。
例如，SVM（Support Vector Machine，支持向量机）在没有标准化调整过的数据中表现很差，

因为可能一个变量的范围是0-10000，而另一个变量的范围是0-1。

preprocessing模块提供了一些函数可以将特征调整为标准形：

from sklearn import preprocessing
import numpy as np
还用boston数据集运行下面的代码：

from sklearn import datasets
boston = datasets.load_boston()
X, y = boston.data, boston.target
X[:, :3].mean(axis=0) #前三个特征的均值
array([  3.59376071,  11.36363636,  11.13677866])
X[:, :3].std(axis=0) #前三个特征的标准差
array([  8.58828355,  23.29939569,   6.85357058])
这里看出很多信息。首先，第一个特征的均值是三个特征中最小的，

而其标准差却比第三个特征的标准差大。

第二个特征的均值和标准差都是最大的——说明它的值很分散，我们通过preprocessing对它们标准化：

X_2 = preprocessing.scale(X[:, :3])
X_2.mean(axis=0)
array([  6.34099712e-17,  -6.34319123e-16,  -2.68291099e-15])
X_2.std(axis=0)
array([ 1.,  1.,  1.])
In [10]:

my_scaler = preprocessing.StandardScaler()
my_scaler.fit(X[:, :3])
my_scaler.transform(X[:, :3]).mean(axis=0)
Out[10]:
array([  6.34099712e-17,  -6.34319123e-16,  -2.68291099e-15])
把特征的样本均值变成0，标准差变成1，这种标准化处理并不是唯一的方法。

preprocessing还有MinMaxScaler类，将样本数据根据最大值和最小值调整到一个区间内：

In [14]:
my_minmax_scaler = preprocessing.MinMaxScaler()
my_minmax_scaler.fit(X[:, :3])
my_minmax_scaler.transform(X[:, :3]).max(axis=0)
Out[14]:
array([ 1.,  1.,  1.])
通过MinMaxScaler类可以很容易将默认的区间0到1修改为需要的区间：

In [19]:
my_odd_scaler = preprocessing.MinMaxScaler(feature_range=(-3.14, 3.14))
my_odd_scaler.fit(X[:, :3])
my_odd_scaler.transform(X[:, :3]).max(axis=0)
Out[19]:
array([ 3.14,  3.14,  3.14])
还有一种方法是正态化（normalization）。它会将每个样本长度标准化为1。

这种方法和前面介绍的不同，它的特征值是标量。正态化代码如下：
In [27]:
normalized_X = preprocessing.normalize(X[:, :3])
乍看好像没什么用，但是在求欧式距离（相似度度量指标）时就很必要了。

例如三个样本分别是向量(1,1,0)，(3,3,0)，(1,-1,0)。

样本1与样本3的距离比样本1与样本2的距离短，尽管样本1与样本3是轴对称，

而样本1与样本2只是比例不同而已。

由于距离常用于相似度检测，因此建模之前如果不对数据进行正态化很可能会造成失误。

4.用阈值创建二元特征

当不需要呈标准化分布的数据时，我们可以不处理它们直接使用；

通常，尤其是处理连续数据时，可以通过建立二元特征来分割数据。
首先，加载boston数据集：
In [1]:
from sklearn import datasets
boston = datasets.load_boston()
import numpy as np
scikit-learn有两种方法二元特征：

preprocessing.binarize（一个函数）
preprocessing.Binarizer（一个类）
boston数据集的因变量是房子的价格中位数（单位：千美元）。

这个数据集适合测试回归和其他连续型预测算法，但是假如现在我们想预测一座房子的价格是否高于总体均值。

要解决这个问题，我们需要创建一个均值的阈值。如果一个值比均值大，则为1；否则，则为0：
In [6]:
from sklearn import preprocessing
new_target = preprocessing.binarize(boston.target, threshold=boston.target.mean())
new_target[0,:5]
Out[6]:
array([ 1.,  0.,  1.,  1.,  1.])
In [22]:
(boston.target[:5] > boston.target.mean()).astype(int)
Out[22]:
array([1, 0, 1, 1, 1])

要用管道命令就要用Binarizer类：
In [24]:
bin = preprocessing.Binarizer(boston.target.mean())
new_target = bin.fit_transform(boston.target)
new_target[0,:5]
Out[24]:
array([ 1.,  0.,  1.,  1.,  1.])
其实scikit-learn在底层创建一个检测层，

如果被监测的值比阈值大就返回Ture。然后把满足条件的值更新为1，不满足条件的更新为0。

稀疏矩阵
稀疏矩阵的0是不被存储的；这样可以节省很多空间。这就为binarizer造成了问题，

需要指定阈值参数threshold不小于0来解决，如果threshold小于0就会出现错误：
In [31]:
from scipy.sparse import coo
spar = coo.coo_matrix(np.random.binomial(1, .25, 100))
preprocessing.binarize(spar, threshold=-1)

fit方法
binarizer类里面有fit方法，但是它只是通用接口，并没有实际的拟合操作，仅返回对象。

分类变量
这里boston数据集不适合演示。虽然它适合演示二元特征，但是用来创建分类变量不太合适。

因此，这里用iris数据集演示。


目标是预测花萼的宽度；

那么花的种类就可能是一个有用的特征。
In [1]:
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target
现在X和y都获得了对应的值，我们把它们放到一起：
In [2]:
import numpy as np
d = np.column_stack((X, y))
下面我们把花类型y对应那一列转换成分类特征：
In [9]:
from sklearn import preprocessing
text_encoder = preprocessing.OneHotEncoder()
text_encoder.fit_transform(d[:, -1:]).toarray()[:5]
Out[9]:
array([[ 1.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 1.,  0.,  0.]])
How it works...
矩阵是这样定义的：每一行由0和1构成，对应的分类特征是1，其他都是0。

text_encoder是一个标准的scikit-learn模型，可以重复使用：
In [12]:
text_encoder.transform(np.ones((3, 1))).toarray()
Out[12]:
array([[ 0.,  1.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  1.,  0.]])