weka に基づくロジスティック回帰 (ロジスティック回帰) の手動実装

1. ロジスティック回帰モデル

ロジスティック回帰モデルは実際には分類モデルであり、ここでの実装は Li Hang 著の「Statistical Machine Learning」と Zhou Zhihua 著の「Machine Learning」の 2 冊の教科書に基づいています。

入力が$\times$、$x\; は$多次元にすることができ、$x$でyyを予測する$y$，$y\in \{0,1\}$ . ロジスティックモデルは次のとおりです。

$$p(Y=1|x)=\frac{exp(w\cdot \times }{1+exp(w\cdot \times ）}\text{\hspace{1em}( 1 )}$$

ここでパラメータ$w$は学習したいものです。注: これには重み係数とバイアス (バイアス) b が含まれます。プログラムを作成する場合は、この表現の方が簡潔です。

第二に、最尤法パラメータ推定

パラメータ$w$は学習する必要があるもので、最尤法を使用してモデル パラメーターを推定します。

設定：

$$P(Y)=1|x)=\pi \left(x\right)、P(Y)=0|x)=1-\pi \left(x\right)\text{\hspace{1em}( 2 )}$$

尤度関数は次のとおりです。

$$\prod _{i=1}\left[p\right(x_{}\left){]}^{y_{}}\right[1-\pi \left(x_{}\right){]}^{1-y_{}}\text{\hspace{1em}( 3 )}$$

この指数形式は導出に役立たないため、次のように対数形式に変換する必要があります。

$$\begin{array}{rl}L\left(w\right)=& \sum _{i=1}\left[y_{}log\pi \right(x_{})+(1-y_{}\left)log\right(1-\pi (x_{}))]\\ =& \sum _{i=1}\left[y_{}log\right(\frac{\pi (x_{}}{1-\pi \left(x_{}\right)})+log(1-\pi (x_{}))]\\ & \sum _{i=1}\left[y_{}\right(w\cdot {バツ}_{})-log(1+exp(w\cdot {バツ}_{}))\end{array}\text{\hspace{1em}( 4 )}$$

L ( w )の場合$L\left(w\right)$の最大値を見つけて$w$の推定値

第三に、尤度関数を解くための勾配降下法

勾配降下法は最小値を見つけることであり、取得したいのは$L\left(w\right)$の最大値、したがって、$L\left(w\right)$の反対の数、つまり:

$$\underset{w}{\mathrm{引数}}-L\left(w\right)\text{\hspace{1em}( 5 )}$$

L ( w )の場合$L(w)$关于$w$の微分は

$$\begin{array}{rl}(-L(w){)}^{』}=& -\sum _{i=1}[(y_{}\cdot {バツ}_{})-\frac{exp(w\cdot {バツ}_{}}{1+exp(w\cdot \times ）}\cdot {バツ}_{}]\\ =& -\sum _{i=1}[(y_{}-\frac{exp(w\cdot {バツ}_{}}{1+exp(w\cdot \times ）})\cdot {バツ}_{}]\\ & \sum _{i=1}[(\frac{exp(w\cdot {バツ}_{}}{1+exp(w\cdot \times ）}-y_{})\cdot {バツ}_{}\end{array}\text{\hspace{1em}( 6 )}$$

次にパラメータを取得します$w$の更新式は次のとおりです。

$$\begin{array}{rl}{w}^{』}=& w-lr\cdot (-L(w{)}^{）}\_\\ & w-lr\cdot (\sum _{i=1}[(\frac{exp(w\cdot {バツ}_{}}{1+exp(w\cdot \times ）}-y_{})\cdot {バツ}_{}]\end{array}\text{\hspace{1em}( 7 )}$$

最適化手法の選択については、当初はスイカ本に掲載されているニュートン法を選択しましたが、ニュートン法の利点はより速い収束速度が得られることですが、欠点はヘッセ行列が特異行列が表示されます。解決できないケースが表示されます。

したがって、準ニュートン法を最適化に使用することができ、この問題を解決しながらも高速に収束することができます。

ただし、準ニュートン法には詳しくありません。また、勾配降下法は収束が遅いかもしれませんが、実装は比較的簡単であるため、ここでは尤度関数の最適化に勾配降下法を使用します。

4 番目、weka ベースのコード実装

package weka.classifiers.myf;

import weka.classifiers.Classifier;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.matrix.Matrix;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.NominalToBinary;
import weka.filters.unsupervised.attribute.Standardize;

import java.util.Arrays;

/**
 * @author YFMan
 * @Description 自定义的 Logistic 回归分类器
 * @Date 2023/6/13 11:02
 */
public class myLogistic extends Classifier {
    
    
    // 用于存储 线性回归 系数 的数组
    private double[] m_Coefficients;

    // 类别索引
    private int m_ClassIndex;

    // 牛顿法的迭代次数
    private int m_MaxIterations = 1000;

    // 属性数量
    private int m_numAttributes;

    // 系数数量
    private int m_numCoefficients;

    // 梯度下降步长
    private double m_lr = 1e-4;

    // 标准化数据的过滤器
    public static final int FILTER_STANDARDIZE = 1;

    // 用于标准化数据的过滤器
    protected Filter m_StandardizeFilter = null;

    // 用于将 normal 转为 binary 的过滤器
    protected Filter m_NormalToBinaryFilter = null;


    /*
     * @Author YFMan
     * @Description 采用牛顿法来训练 logistic 回归模型
     * @Date 2023/5/9 22:08
     * @Param [data] 训练数据
     * @return void
     **/
    public void buildClassifier(Instances data) throws Exception {
    
    
        // 设置类别索引
        m_ClassIndex = data.classIndex();

        // 设置属性数量
        m_numAttributes = data.numAttributes();

        // 系数数量 = 输入属性数量 + 1（截距参数b）
        m_numCoefficients = m_numAttributes;

        // 初始化 系数数组
        m_Coefficients = new double[m_numCoefficients];
        Arrays.fill(m_Coefficients, 0);

        // 将输入数据进行标准化
        m_StandardizeFilter = new Standardize();
        m_StandardizeFilter.setInputFormat(data);
        data = Filter.useFilter(data, m_StandardizeFilter);

        // 将类别属性转为二值属性
        m_NormalToBinaryFilter = new NominalToBinary();
        m_NormalToBinaryFilter.setInputFormat(data);
        data = Filter.useFilter(data, m_NormalToBinaryFilter);

        // 梯度下降法
        for(int curPerformIteration = 0; curPerformIteration < m_MaxIterations;curPerformIteration++){
    
    

            double[] deltaM_Coefficients = new double[m_numCoefficients];
            // 计算 l(w) 的一阶导数
            for(int i = 0;i<data.numInstances();i++){
    
    

                double yi = data.instance(i).value(m_ClassIndex);
                double wxi = 0;
                int column = 0;
                for(int j=0;j<m_numAttributes;j++){
    
    
                    if(j!=m_ClassIndex){
    
    
                        wxi += m_Coefficients[column] * data.instance(i).value(j);
                        column++;
                    }
                }
                // 加上截距参数 b
                wxi += m_Coefficients[column];
                double pi1 = Math.exp(wxi) / (1 + Math.exp(wxi));
                for(int k=0;k<m_numCoefficients - 1;k++){
    
    
                    deltaM_Coefficients[k] += m_lr * (pi1 - yi) * data.instance(i).value(k);
                }
                // 这里计算 bias b 对应的更新量
                deltaM_Coefficients[m_numCoefficients - 1] += m_lr * (pi1 - yi);
            }

            // 进行参数更新
            for(int k=0;k<m_numCoefficients;k++){
    
    
                m_Coefficients[k] -= deltaM_Coefficients[k];
            }

            // 如果参数更新量小于阈值，则停止迭代
            double delta = 0;
            for(int k=0;k<m_numCoefficients;k++){
    
    
                delta += deltaM_Coefficients[k] * deltaM_Coefficients[k];
            }
            if(delta < 1e-6){
    
    
                break;
            }

        }
    }


    /*
     * @Author YFMan
     * @Description // 分类实例
     * @Date 2023/6/16 11:17
     * @Param [instance]
     * @return double[]
     **/
    public double[] distributionForInstance(Instance instance) throws Exception {
    
    

        // 将输入数据进行标准化
        m_StandardizeFilter.input(instance);
        instance = m_StandardizeFilter.output();

        // 将输入属性二值化
        m_NormalToBinaryFilter.input(instance);
        instance = m_NormalToBinaryFilter.output();

        double[] result = new double[2];
        result[0] = 0;
        result[1] = 0;
        int column = 0;
        for(int i=0;i<m_numAttributes;i++){
    
    
            if(m_ClassIndex != i){
    
    
                result[0] += instance.value(i) * m_Coefficients[column];
                column++;
            }
        }
        result[0] += m_Coefficients[column];
        result[0] = 1 / (1 + Math.exp(result[0]));

        result[1] = 1 - result[0];

        return result;
    }

    /*
     * @Author YFMan
     * @Description 主函数 生成一个线性回归函数预测器
     * @Date 2023/5/9 22:35
     * @Param [argv]
     * @return void
     **/
    public static void main(String[] argv) {
    
    
        runClassifier(new myLogistic(), argv);
    }
}