Shark源码分析（三）：数据预处理之正则化

在机器学习算法中，获取训练数据后首先要做的不是将输入投入训练方法中进行学习，而是应该对数据进行预处理。预处理过程输出数据的质量能够对之后算法的结果起着至关重要的作用。预处理过程含有非常多的操作，在我目前阅读代码的过程中只碰到了正则化这一过程。那我们就先来讨论正则化，如果之后再碰到了其他的方法再补充。

Shark将对输入数据进行正则化的模型也看作是一个线性模型。Shark给出了两种正则化的方法，分别是NormalizeComponentsUnitInterval, NormalizeComponentsUnitVariance。对于这两种不同的正则化方法有两个不同的trainer（联系上一篇博客的内容）进行训练。

第一种方法是将每一维度的特征都缩小到[0,1]范围内，这对于特征值是有界的情况来说是有效的。而第二种方法是将每一维度的方差都调整到1。对于『将均值变为0』这一操作来说是可选的。如果不包含这一操作，那么这一方法对于高维度的稀疏特征向量来说是有效的。



Normalizer类

该类定义在<include/shark/Models/Normalizer.h>文件中。

其与普通线性模型的不同之处在于：

输入与输出的维度必须是相同的
对于每一维度需要单独进行计算
template <class DataType = RealVector>
class Normalizer : public AbstractModel<DataType, DataType>
{
protected:
    RealVector m_A; //权值向量                
    RealVector m_b; //偏置向量                          bool m_hasOffset; //表示是否需要偏置向量                     
public:
    typedef AbstractModel<DataType, DataType> base_type;
    typedef Normalizer<DataType> self_type;

    typedef typename base_type::BatchInputType BatchInputType;
    typedef typename base_type::BatchOutputType BatchOutputType;

    Normalizer()
    { }

    Normalizer(const self_type& model)
    : m_A(model.m_A)
    , m_b(model.m_b)
    , m_hasOffset(model.m_hasOffset)
    { }

    Normalizer(std::size_t dimension, bool hasOffset = false)
    : m_A(dimension, dimension)
    , m_b(dimension)
    , m_hasOffset(hasOffset)
    { }

    Normalizer(RealVector diagonal)
    : m_A(diagonal)
    , m_hasOffset(false)
    { }

    Normalizer(RealVector diagonal, RealVector vector)
    : m_A(diagonal)
    , m_b(vector)
    , m_hasOffset(true)
    { }

    std::string name() const
    { return "Normalizer"; }

    friend void swap(const Normalizer& model1, const Normalizer& model2)
    {
        std::swap(model1.m_A, model2.m_A);
        std::swap(model1.m_b, model2.m_b);
        std::swap(model1.m_hasOffset, model2.m_hasOffset);
    }

    const self_type operator = (const self_type& model)
    {
        m_A = model.m_A;
        m_b = model.m_b;
        m_hasOffset = model.m_hasOffset;
    }

    boost::shared_ptr<State> createState() const
    {
        return boost::shared_ptr<State>(new EmptyState());
    }

    //判断模型是否有被正确地初始化
    bool isValid() const
    {
        return (m_A.size() != 0);
    }

    bool hasOffset() const
    {
        return m_hasOffset;
    }

    //返回权值向量
    RealVector const& diagonal() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::matrix] model is not initialized");
        return m_A;
    }

    //返回偏置向量
    RealVector const& offset() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::vector] model is not initialized");
        return m_b;
    }

    std::size_t inputSize() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::inputSize] model is not initialized");
        return m_A.size();
    }

    std::size_t outputSize() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::outputSize] model is not initialized");
        return m_A.size();
    }

    //将权值向量与偏置向量合在一起进行输出
    RealVector parameterVector() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::parameterVector] model is not initialized");
        std::size_t dim = m_A.size();
        if (hasOffset())
        {
            RealVector param(2 * dim);
            init(param)<<m_A,m_b;
            return param;
        }
        else
        {
            RealVector param(dim);
            init(param)<<m_A;
            return param;
        }
    }

    //可以更改权值向量与偏置向量的值
    void setParameterVector(RealVector const& newParameters)
    {
        SHARK_CHECK(isValid(), "[Normalizer::setParameterVector] model is not initialized");
        std::size_t dim = m_A.size();
        if (hasOffset())
        {
            SIZE_CHECK(newParameters.size() == 2 * dim);
            init(newParameters)>>m_A,m_b;
        }
        else
        {
            SIZE_CHECK(newParameters.size() == dim);
            init(newParameters)>>m_A;
        }
    }

    std::size_t numberOfParameters() const
    {
        SHARK_CHECK(isValid(), "[Normalizer::numberOfParameters] model is not initialized");
        return (m_hasOffset) ? m_A.size() + m_b.size() : m_A.size();
    }

    //在训练完成之后，将权值向量与偏置向量保存到模型中
    void setStructure(RealVector const& diagonal)
    {
        m_A = diagonal;
        m_hasOffset = false;
    }

    void setStructure(std::size_t dimension, bool hasOffset = false)
    {
        m_A.resize(dimension);
        m_hasOffset = hasOffset;
        if (hasOffset) m_b.resize(dimension);
    }

    void setStructure(RealVector const& diagonal, RealVector const& offset)
    {
        SHARK_CHECK(diagonal.size() == offset.size(), "[Normalizer::setStructure] dimension conflict");
        m_A = diagonal;
        m_b = offset;
        m_hasOffset = true;
    }

    using base_type::eval;

    //对输入利用权值向量以及偏置向量进行正则化
    void eval(BatchInputType const& input, BatchOutputType& output) const
    {
        SHARK_CHECK(isValid(), "[Normalizer::eval] model is not initialized");
        output.resize(input.size1(), input.size2());
        noalias(output) = input * repeat(m_A,input.size1());
        if (hasOffset())
        {
            noalias(output) += repeat(m_b,input.size1());
        }
    }

    void eval(BatchInputType const& input, BatchOutputType& output, State& state) const
    {
        eval(input, output);
    }

    void read(InArchive& archive)
    {
        archive & m_A;
        archive & m_b;
        archive & m_hasOffset;
    }

    void write(OutArchive& archive) const
    {
        archive & m_A;
        archive & m_b;
        archive & m_hasOffset;
    }
};

注意到这个类也是继承自AbstractModel。

正则化模型的使用方式是，利用输入的训练数据训练正则化模型的参数。如果之后有测试数据输入进来，可以使用同样的模型对测试数据进行正则化，而不需要再重新训练模型。



NormalizeComponentsUnitVariance类

该类定义在<include/shark/Algorithms/Trainers/NormalizeComponentsUnitVariance.h>文件中。

在这个方法中，零均值化默认是被关闭的。因为对输入是一个稀疏矩阵的情况来说，零均值话是会破坏它的稀疏性。如果当输入数据不是稀疏的话，可以开启这一项。

其正则化方法是x′=x−μσ=1σ⋅x−μσ



template <class DataType = RealVector>
class NormalizeComponentsUnitVariance : public AbstractUnsupervisedTrainer< Normalizer<DataType> >
{
public:
    typedef AbstractUnsupervisedTrainer< Normalizer<DataType> > base_type;

    NormalizeComponentsUnitVariance(bool zeroMean)
    : m_zeroMean(zeroMean){ }

    std::string name() const
    { return "NormalizeComponentsUnitVariance"; }

    void train(Normalizer<DataType>& model, UnlabeledData<DataType> const& input)
    {
        SHARK_CHECK(input.numberOfElements() >= 2, "[NormalizeComponentsUnitVariance::train] input needs to consist of at least two points");
        std::size_t dc = dataDimension(input);

        RealVector mean;
        RealVector variance;
        meanvar(input, mean, variance); //计算数据的均值，方差

        RealVector diagonal(dc);
        RealVector vector(dc);

        for (std::size_t d=0; d != dc; d++){
            double stddev = std::sqrt(variance(d));
            if (stddev == 0.0)
            {
                diagonal(d) = 0.0;
                vector(d) = 0.0;
            }
            else
            {
                diagonal(d) = 1.0 / stddev;
                vector(d) = -mean(d) / stddev;
            }
        }

        if (m_zeroMean) 
            model.setStructure(diagonal, vector);
        else 
            model.setStructure(diagonal);
    }

protected:
    bool m_zeroMean;
};

注意到该方法是继承自AbstractUnsupervisedTrainer，也把它作为无监督学习方法。



NormalizeComponentsUnitInterval类

该类定义在<include/shark/Algorithms/Trainers/NormalizeComponentsUnitInterval.h>文件中。

该方法是将数据的范围都变换到[0,1]区间内，这样做的话势必会破坏数据的稀疏性，所以可能会偏向于选择NormalizeComponentsUnitVariance这一方法。

该方法的公式是x′=x−minmax−min



template <class DataType = RealVector>
class NormalizeComponentsUnitInterval : public AbstractUnsupervisedTrainer< Normalizer<DataType> >
{
public:
    typedef AbstractUnsupervisedTrainer< Normalizer<DataType> > base_type;

    NormalizeComponentsUnitInterval()
    { }

    std::string name() const
    { return "NormalizeComponentsUnitInterval"; }

    void train(Normalizer<DataType>& model, UnlabeledData<DataType> const& input)
    {
        std:: size_t ic = input.numberOfElements();
        SHARK_CHECK(ic >= 2, "[NormalizeComponentsUnitInterval::train] input needs to consist of at least two points");
        std::size_t dc = dataDimension(input);

       //取出每一维度的第一个数据
       //求出每一维度的最大值和最小值
        RealVector min = input.element(0);
        RealVector max = input.element(0);
        for(std::size_t i=1; i != ic; i++){
            for(std::size_t d = 0; d != dc; d++){
                double x = input.element(i)(d);
                min(d) = std::min(min(d), x);
                max(d) = std::max(max(d), x);
            }
        }

        RealVector diagonal(dc);
        RealVector offset(dc);

        for (std::size_t d=0; d != dc; d++)
        {
            if (min(d) == max(d)) //这一维数据的值相同
            {
                diagonal(d) = 0.0;
                offset(d) = -min(d) + 0.5;//偏移设置成0.5就好
            }
            else
            {
                double n = 1.0 / (max(d) - min(d));
                diagonal(d) = n;
                offset(d) = -min(d) * n;
            }
        }

        model.setStructure(diagonal, offset);
    }
};

正则化的数学和代码实现
参考【Python数据预处理】
正则化主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
             p-范数的计算公式： 
该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。
1.可以使用preprocessing.normalize()函数对指定数据进行转换：
X = [[ 1., -1., 2.],[ 2.,  0.,  0.],[ 0.,  1., -1.]]
X_normalized=preprocessing.normalize(X, norm='l2') #l2范数，不是12 
输出：[[ 0.40824829, -0.40824829,  0.81649658] [ 1., 0., 0.][ 0., 0.70710678, -0.70710678]]
2. 可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：
注意类似归一化代码，也存在fit_transform=fit+transform的写法
X_train=[[ 1., -1., 2.],[ 2.,  0.,  0.],[ 0.,  1., -1.]]
X_test=[[-1.,  1., 0.]]
normalizer=preprocessing.Normalizer().fit(X)
normalizer.transform(X_train)
normalizer.transform(X_test) 
与归一化的代码类似,也可以这么写
normalizer=preprocessing.Normalizer()
normalizer.fit_transform(X_train)
normalizer.transform(X_test)
正则化概念（Regularization，不是Normalization）
参考<机器学习中正则化项L1和L2的直观理解><一文搞懂深度学习正则化的L2范数>
机器学习中几乎都可以看到损失函数后面会添加一个额外项，常用的额外项一般有两种一般英文称作 
 和 
 ，中文称作
L1正则化和L2正则化，或者L1范数和L2范数。
L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。对于线性回归模型，使用L1正则化的模型建叫做Lasso回归，使用L2正则化的模型叫做Ridge回归（岭回归）。下图是Python中Lasso回归的损失函数，式中加号后面一项 
 即为L1正则化项。
下图是Python中Ridge回归的损失函数，式中加号后面一项 
 即为L2正则化项。
一般回归分析中回归 
 表示特征的系数（也常用 
 ），从上式可以看到正则化项是对系数做了处理（限制）。
L1正则化和L2正则化的说明如下：
L1正则化是指权值向量 
 中各个元素的
绝对值之和，通常表示为
L2正则化是指权值向量 
 中各个元素的
平方和然后再求平方根（可以看到Ridge回归的L2正则化项有平方符号），通常表示为 
一般都会在正则化项之前添加一个系数，Python中用α表示，一些文章也用λ表示。这个系数需要用户指定。那添加L1和L2正则化有什么用？下面是L1正则化和L2正则化的作用，这些表述可以在很多文章中找到。
L1正则化可以产生稀疏权值矩阵，即产生一个稀疏模型，可以用于特征选择
L2正则化可以防止模型过拟合（overfitting）；一定程度上，L1也可以防止过拟合
稀疏模型与特征选择
上面提到L1正则化有助于生成一个稀疏权值矩阵，进而可以用于特征选择。为什么要生成一个稀疏矩阵？
稀疏矩阵指的是很多元素为0，只有少数元素是非零值的矩阵，即得到的线性回归模型的大部分系数都是0. 通常机器学习中特征数量很多，例如文本处理时，如果将一个词组（term）作为一个特征，那么特征数量会达到上万个（bigram）。在预测或分类时，那么多特征显然难以选择，但是如果代入这些特征得到的模型是一个稀疏模型，表示只有少数特征对这个模型有贡献，绝大部分特征是没有贡献的，或者贡献微小（因为它们前面的系数是0或者是很小的值，即使去掉对模型也没有什么影响），此时我们就可以只关注系数是非零值的特征。这就是稀疏模型与特征选择的关系。
L1和L2正则化的直观理解
这部分内容将解释为什么L1正则化可以产生稀疏模型（L1是怎么让系数等于零的），以及为什么L2正则化可以防止过拟合。
L1正则化和特征选择
假设有如下带L1正则化的损失函数
其中 
 是原始的损失函数，加号后面的一项是L1正则化项，α是正则化系数。注意到L1正则化是权值的
绝对值之和， 
 是带有绝对值符号的函数，因此 
 是不完全可微的。机器学习的任务就是要通过一些方法（比如梯度下降）求出损失函数的最小值。当我们在原始损失函数 
 后添加L1正则化项时，相当于对
 做了一个约束。令
 ，则 
 ，此时我们的任务变成
在L约束下求出 
​取最小值的解。考虑二维的情况，即只有两个权值w1和w2，此时 
 对于梯度下降法，求解J0 的过程可以画出等值线，同时L1正则化的函数L也可以在w1w2的二维平面上画出来。如下图：
图中等值线是J0的等值线，黑色方形是L函数的图形。在图中，当J0 等值线与L图形首次相交的地方就是最优解。上图中J0与L在L的一个顶点处相交，这个顶点就是最优解。注意到这个顶点的值是 
 .可以直观想象，因为L函数有很多『突出的角』（二维情况下四个，多维情况下更多），J0与这些角接触的机率会远大于与L其它部位接触的机率，而在这些角上，会有很多权值等于0，这就是为什么L1正则化可以产生稀疏模型，进而可以用于特征选择。
而正则化前面的系数α，可以控制L图形的大小。α越小，L的图形越大（上图中的黑色方框）；α越大，L的图形就越小，可以小到黑色方框只超出原点范围一点点，这是最优点的值
中的w可以取到很小的值。
类似，假设有如下带L2正则化的损失函数：
同样可以画出他们在二维平面上的图形，如下：
二维平面下L2正则化的函数图形是个圆，与方形相比，被磨去了棱角。因此J0 与L相交时使得w1或w2 等于零的机率小了许多，这就是为什么L2正则化不具有稀疏性的原因。
L2正则化和过拟合
拟合过程中通常都倾向于让权值尽可能小，最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单，能适应不同的数据集，也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程，若参数很大，那么只要数据偏移一点点，就会对结果造成很大的影响；但如果参数足够小，数据偏移得多一点也不会对结果造成什么影响，专业一点的说法是『抗扰动能力强』。
那为什么L2正则化可以获得值很小的参数？
以线性回归中的梯度下降法为例。假设要求的参数为θ， 
 是我们的假设函数。线性回归一般使用平方差损失函数。单个样本的平方差是 
 ，如果考虑所有样本，损失函数是对每个样本的平方差求和，假设有m个样本，线性回归的代价函数如下，为了后续处理方便，乘以一个常数 
 :
在梯度下降算法中，需要先对参数求导，得到梯度。梯度本身是上升最快的方向，为了让损失尽可能小，沿梯度的负方向更新参数即可。对于单个样本，先对某个参数θj求导：
其中λ就是正则化参数。从上式可以看到，与未添加L2正则化的迭代公式相比，每一次迭代，θj 都要先乘以一个小于1的因子，从而使得θj 不断减小，因此总得来看，θ是不断减小的。
最开始也提到L1正则化一定程度上也可以防止过拟合。之前做了解释，当L1的正则化系数很小时，得到的最优解会很小，可以达到和L2正则化类似的效果。
正则化参数的选择
L1正则化参数
通常越大的λ可以让代价函数在参数为0时取到最小值。下面是一个简单的例子，这个例子来自Quora上的问答。为了方便叙述，一些符号跟这篇帖子的符号保持一致。
假设有如下带L1正则化项的代价函数：
其中x是要估计的参数，相当于上文中提到的w以及θ. 注意到L1正则化在某些位置是不可导的，当λ足够大时可以使得F(x)在x=0时取到最小值。如下图：
分别取λ=0.5和λ=2，可以看到越大的λ越容易使F(x)在x=0时取到最小值。
L2正则化参数
从公式5可以看到，λ越大，θj 衰减得越快。另一个理解可以参考图2，λ越大，L2圆的半径越小，最后求得代价函数最值时各参数也会变得很小。
Reference
过拟合的解释：为什么正则化能够降低过拟合 · 神经网络与深度学习
正则化的解释：正则化 · 神经网络与深度学习
正则化的解释：http://blog.csdn.net/u012162613/article/details/44261657
正则化的数学解释（一些图来源于这里）：http://blog.csdn.net/zouxy09/article/details/24971995
深入理解L0，L1和L2正则化: https://blog.csdn.net/anshuai_aw1/article/details/89435414

标准化（Scale）和正则化（Normalization）是两种常用的数据预处理方法，其作用是让数据变得更加“规范”一些。在文本聚类等任务中使用的比较多。
针对某数据，如果不适用数据标准化、正则化，展示的情况如下图
1.数据标准化


公式为：(X-mean)/std  计算时对每个属性/每列分别进行。将数据按期属性（按列进行）减去其均值，并处以其方差。得到的结果是，对于每个属性/每列来说所有数据都聚集在0附近，方差为1。经过数据标准化的数据如下图：可以看到有些特征被凸显出来了。




2.数据正则化


正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。

Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。

             p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p

该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。




在sklearn中有三种正则化方法，l1范数、l2范数、max范数。

使用这三种范数生成的结果如下图所示：










在肉眼上很难看出有什么区别，不过还是能看出l2范数的结果相对更好，即能尽可能的削弱“强势”特征，将一些数值较小但是比较有特点的特征“凸显”出来。

使用方法参照sklearn官方文档就可以了，非常简单：

http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.scale.html#sklearn.preprocessing.scale


http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html#sklearn.preprocessing.normalize

Python数据预处理—归一化，标准化，正则化
关于数据预处理的几个概念
归一化 (Normalization)：
属性缩放到一个指定的最大和最小值（通常是1-0）之间，这可以通过preprocessing.MinMaxScaler类实现。
常用的最小最大规范化方法(x-min(x))/(max(x)-min(x))
除了上述介绍的方法之外，另一种常用的方法是将属性缩放到一个指定的最大和最小值（通常是1-0）之间，这可以通过preprocessing.MinMaxScaler类实现。
使用这种方法的目的包括：
1、对于方差非常小的属性可以增强其稳定性。
2、维持稀疏矩阵中为0的条目
>>> X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[ 0.5 , 0. , 1. ],
[ 1. , 0.5 , 0.33333333],
[ 0. , 1. , 0. ]])
 
>>> #将相同的缩放应用到测试集数据中
>>> X_test = np.array([[ -3., -1., 4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5 , 0. , 1.66666667]])
 
 
>>> #缩放因子等属性
>>> min_max_scaler.scale_
array([ 0.5 , 0.5 , 0.33...])
 
>>> min_max_scaler.min_
array([ 0. , 0.5 , 0.33...])
当然，在构造类对象的时候也可以直接指定最大最小值的范围：feature_range=(min, max)，此时应用的公式变为：
X_std=(X-X.min(axis=0))/(X.max(axis=0)-X.min(axis=0)) 
X_scaled=X_std/(max-min)+min
 
标准化(Standardization)：
将数据按比例缩放，使之落入一个小的特定区间内，标准化后的数据可正可负，一般绝对值不会太大。
计算时对每个属性/每列分别进行
将数据按期属性（按列进行）减去其均值，并处以其方差。得到的结果是，对于每个属性/每列来说所有数据都聚集在0附近，方差为1。
使用z-score方法规范化(x-mean(x))/std(x)
这个在matlab中有特定的方程
使用sklearn.preprocessing.scale()函数，可以直接将给定数据进行标准化：
>>> from sklearn import preprocessing
>>> import numpy as np
>>> X = np.array([[ 1., -1.,  2.],
...               [ 2.,  0.,  0.],
...               [ 0.,  1., -1.]])
>>> X_scaled = preprocessing.scale(X)
 
>>> X_scaled                                          
array([[ 0.  ..., -1.22...,  1.33...],
       [ 1.22...,  0.  ..., -0.26...],
       [-1.22...,  1.22..., -1.06...]])
 
>>>#处理后数据的均值和方差
>>> X_scaled.mean(axis=0)
array([ 0.,  0.,  0.])
 
>>> X_scaled.std(axis=0)
array([ 1.,  1.,  1.])
  
使用sklearn.preprocessing.StandardScaler类，使用该类的好处在于可以保存训练集中的参数（均值、方差）直接使用其对象转换测试集数据：
>>> scaler = preprocessing.StandardScaler().fit(X)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)
 
>>> scaler.mean_
array([ 1. ..., 0. ..., 0.33...])
 
>>> scaler.std_
array([ 0.81..., 0.81..., 1.24...])
 
>>> scaler.transform(X)
array([[ 0. ..., -1.22..., 1.33...],
[ 1.22..., 0. ..., -0.26...],
[-1.22..., 1.22..., -1.06...]])
 
 
>>>#可以直接使用训练集对测试集数据进行转换
>>> scaler.transform([[-1., 1., 0.]])
array([[-2.44..., 1.22..., -0.26...]])
 
 
正则化：
正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。
 
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
 
             p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p
该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。
 
1、可以使用preprocessing.normalize()函数对指定数据进行转换：
>>> X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')
 
>>> X_normalized
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
 
2、可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：
>>> normalizer = preprocessing.Normalizer().fit(X) # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')
 
>>>
>>> normalizer.transform(X)
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
 
>>> normalizer.transform([[-1., 1., 0.]])
array([[-0.70..., 0.70..., 0. ...]])
 
 
参考：
http://www.cnblogs.com/chaosimple/p/4153167.html
http://blog.sina.com.cn/s/blog_973bec650101rnap.html