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

正则表达式 前端之家
前端之家收集整理的这篇文章主要介绍了Shark源码分析（三）：数据预处理之正则化，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

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−μ@H_668_403@σ 

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);
    }
};
原文链接：https://www.f2er.com/regex/358605.html

猜你在找的正则表达式相关文章

常用正则表达式-手机号、身份证、邮箱
一、校验数字的表达式 1 数字：^[0-9]*$ 2 n位的数字：^d{n}$ 3 至少n位的数字：^d{n,}$ 4...
JS正则表达式详解
正则表达式非常有用，查找、匹配、处理字符串、替换和转换字符串，输入输出等。下面整理一...
组内正则培训记录
0. 注： 不同语言中的正则表达式实现都会有一些不同。下文中的代码示例除特别说明的外，都...
高级正则表达式技术（Python版）
 正则表达式是从信息中搜索特定的模式的一把瑞士军刀。它们是一个巨大的工具库，其中的...
史上最全最常用的正则表达式
一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,...
正则表达式工具
正则表达式初步
分享5个可视化的正则表达式编辑工具
　　正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编...
分享5个可视化的正则表达式编辑工具
正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器...
[知识积累]--正则表达式记忆表
在工作中常常遇到正则表达式问题，有时候又会忘记这则的语法。 下面就分享一份正则表达式记...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript