C++で「はじめての機械学習」6章

せかいらぼ

 

4 Pockets

C++で「はじめての機械学習」2章, 3章

はじめての機械学習という機械学習の基本をC言語のソース付きで学べる書籍を読んでいるのだけど、しーぷらぷらーの僕としてはむず痒さを感じることもあるので、C++で実装をしてみることにする。2章 最小二乗法/** 最小二乗法による計算式の決定 y = a0 + a1*x　の a0, a1を出力 **/#include <iostream>using namespace std;int main(){ double xi, yi; // 入力データ double sxi=0, syi=0, sxiyi=0, sxi2=0; // 各項の計算結果 double a0, a1; ...

せかいらぼ

C++で「はじめての機械学習」4章

４章は判断木の構成で、データの属するカテゴリと各属性に対する判別結果を入力データとして与え、どの判断を用いて分類すればよいかの選択を支援するプログラムと、後半ではそれを確率探索しています。後半はまあいいかと思ったので前半部だけ。/** 判断木の構成を支援するプログラム (判断木を構成するためには、与えられたデータセットを 適切に分類する属性を選択しなければならない。そこで ある属性を選んだ場合にどのように分類されるかを計算 する。） 入力は標準入力から与え、出力は標準出力に出力します 使い方： ...

せかいらぼ

C++で「はじめての機械学習」5章

5章は遺伝的アルゴリズムです。ルーレット選択、一点交叉、突然変異、のsimpleGAです。最初は、目的関数最適化をめざすヒューリスティック。/** * simpleGA： * 1 遺伝子プールの初期化 * 2 loop{ * 交叉(親の選択を含む) * 突然変異 * 結果の出力 * } * 使い方： * $./simpleGA (遺伝子の桁数) (遺伝子の数) (終了条件スイッチ) (終了条件) > (出力ファイル) * 終了条件スイッチ：(終了条件)を指定。0->ループ回数、1->最高適応度下限 **/#include <iostream>#include <string>#include <limits>#incl...

www.amazon.co.jp

Amazon.co.jp

与えられたデータセットと評価値に近づくように重みとしきい値を
バックプロパゲーションで調整する３層パーセプトロン

/**
 * バックプロパゲーションによるニューラルネットの学習
 * 使い方
 *  $./backPropagation (変数の数) (中間層のセル数) (誤差の上限値) < (学習データセットのファイル名)
 *誤差の推移や、学習結果となる結合係数などを出力します
 **/

#include <iostream>
#include <vector>
#include <cstdlib>
#include <float.h>
#include <ctime>
#include <cmath>
using namespace std;

inline void initRand()
{
    srand((unsigned int)time(NULL));
}

/**シグモイド関数**/
inline double sigmoid(double u)
{
    return 1.0 / (1.0+exp(-u));
}

/**-1.0 - 1.0の実数乱数の生成**/
inline double randDouble()
{
    return (2.0 / RAND_MAX * rand())-1.0;
}

/**中間層の重みと出力層の重みを初期化(ランダム)**/
void initWeight(const int &n, const int &numAlliance,
                double **weightAlliance,  double *weightReaction)
{
    initRand();
    for(int i=0; i<numAlliance; ++i){
        for(int j=0; j<n+1; ++j){
            weightAlliance[i][j] = randDouble();
        }
        weightReaction[i] = randDouble();
    }
    weightReaction[numAlliance] = randDouble();
}

/**学習データをdataに読み込む**/
void readData(vector< vector<double> > &data, const int &n)
{
    // [n]は評価値
    double *buffer = new double [n+1];
    while(true){
        for(int i=0; i<n+1; ++i) cin >> buffer[i];
        if(cin.eof()) break;

        vector<double> bufferVector;
        for(int i=0; i<n+1; ++i) bufferVector.push_back(buffer[i]);

        data.push_back(bufferVector);
    }
}

/**順方向の出力の計算**/
double forward(double **weightAlliance, const double *weightReaction,
                double *outAlliance, const vector<double> &dataField,
                const int &n, const int &numAlliance)
{
    double out = 0.0;
    // outAllianceの計算
    for(int i=0; i<numAlliance; ++i){
        double u = 0; // 重み付き和
        for(int j=0; j<n; ++j){
            u += dataField[j] * weightAlliance[i][j];
        }
        u -= weightAlliance[i][n]; // しきい値の処理
        outAlliance[i] = sigmoid(u);
    }
    // outの計算
    for(int i=0; i<numAlliance; ++i)
        out += outAlliance[i] * weightReaction[i];
    out -= weightReaction[numAlliance]; // しきい値の処理

    return sigmoid(out);
}

/**出力層の重みの調整**/
void learnReaction(double *weightReaction, double *outAlliance,
                    const vector<double> &dataField, double outReaction,
                    const int &n, const int &numAlliance, const int &ALPHA)
{
    double diff; // 誤差
    diff = (dataField[n] - outReaction) * outReaction * (1 - outReaction);
    // 結合荷重の調整
    for(int i=0; i<numAlliance; ++i)
        weightReaction[i] += ALPHA * outAlliance[i] * diff;
    // しきい値の調整
    weightReaction[numAlliance] += ALPHA * (-1.0) * diff;
}

/**中間層の重みの調整**/
void learnAlliance(double **weightAlliance, double *weightReaction,
                    double *outAlliance, const vector<double> &dataField, double outReaction,
                    const int &n, const int &numAlliance, const int &ALPHA)
{
    double diff; // 重みが考慮された誤差
    // i番目の中間層セルについて
    for(int i=0; i<numAlliance; ++i){
        diff = outAlliance[i] * (1 - outAlliance[i]) * weightReaction[i] *
                (dataField[n] - outReaction) * outReaction * (1 - outReaction);
        // j番目の重みを調整
        for(int j=0; j<n; ++j)
            weightAlliance[i][j] += ALPHA * dataField[j] * diff;
        weightAlliance[i][n] += ALPHA * (-1.0) * diff; // しきい値の調整
    }
}

/**結合荷重の出力**/
void printWeight(double **weightAlliance, double *weightReaction,
                    const int &n,  const int &numAlliance)
{
    for(int i=0; i<numAlliance; ++i){
        for(int j=0; j<n+1; ++j)
            cout << weightAlliance[i][j] << " ";
    }
    cout << endl;
    for(int i=0; i<numAlliance+1; ++i)
        cout << weightReaction[i];
    cout << endl;
}

int main(int argc, char *argv[])
{
    // 定数
    const int                ALPHA = 10;           // 学習係数

    // 変数
    int                      n;                    // 変数の数=入力層の数
    int                      numAlliance;          // 中間層のセル数
    double                   errorLimit;           // 誤差の上限値
    vector< vector<double> > data;                 // 学習データセット
    double                   **weightAlliance = 0; // 中間層層の重み
    double                   *weightReaction = 0;  // 出力層の重み
    double                   *outAlliance = 0;     // 中間層の出力
    double                   outReaction = 0;      // 出力層の出力
    double                   error = DBL_MAX;      // データとの誤差
    int                      count = 0;            // 繰り返し回数のカウンタ

    // 引数のチェック
    if(argc != 4){
        cerr << "使い方 $./backPropagation "
             << "(変数の数) (中間層のセル数) (誤差の上限値) "
             << "< (入力ファイル)" << endl;
        return -1;
    }
    if((n=atoi(argv[1])) < 1){
        cerr << "変数の数の値が不適切です" << endl;
        return -1;
    }
    if((numAlliance=atoi(argv[2])) < 1){
        cerr << "中間層のセル数が不適切です" << endl;
        return -1;
    }
    if((errorLimit=atof(argv[3])) == 0.0){
        cerr << "収束しない可能性があります" << endl;
    }

    // get memory
    weightAlliance = new double * [numAlliance];
    weightReaction = new double [numAlliance+1]; // [numAlliance]はしきい値
    for(int i=0; i<numAlliance; ++i) weightAlliance[i] = new double [n+1];
    outAlliance = new double [numAlliance];

    initWeight(n, numAlliance, weightAlliance, weightReaction);
    readData(data, n);

    // 学習
    while(error > errorLimit){
        error = 0.0;
        for(int i=0; i<data.size(); ++i){
            // 順方向の計算
            outReaction = forward(weightAlliance, weightReaction, outAlliance,
                                    data[i], n, numAlliance);
            // 出力層の重みの調整
            learnReaction(weightReaction, outAlliance,
                            data[i], outReaction, n, numAlliance, ALPHA);
            // 中間層の重みの調整
            learnAlliance(weightAlliance, weightReaction, outAlliance,
                            data[i], outReaction, n, numAlliance, ALPHA);
            // 誤差の積算
            error += (outReaction - data[i][n]) *
                        (outReaction - data[i][n]);
        }
        ++count;
        // 誤差の出力
        cout << count << "t" << error << endl;
    } // 学習終了

    // 結果の出力
    // １．結合荷重の出力
    printWeight(weightAlliance, weightReaction, n, numAlliance);
    // ２．学習データに対する結果の出力
    for(int i=0; i<data.size(); ++i){
        cout << i << " ";
        for(int j=0; j<n+1; ++j)
            cout << data[i][j] << " ";
        outReaction = forward(weightAlliance, weightReaction, outAlliance,
                                data[i], n, numAlliance);
        cout << outReaction << endl;
    }

    // memory release
    for(int i=0; i<numAlliance; ++i) delete [] weightAlliance[i];
    delete [] weightAlliance;
    delete [] weightReaction;
    delete [] outAlliance;

    return 0;
}

5章はちょっと習作を思いついたのでまた今度になるかも