RBM代码注释c++

这代码各种看不懂，各种给跪，当工具用吧。。

主函数：

main.cpp

#include "rbmpredictdata.h"
#include "rbmdata.h"
#include "rbm.h"
#include "rbmparallel.h"
#include <fstream>
#include <string>
#include <cstdlib>
#include <deque>

int main(int argc, char* argv[]) {
    parseArgs(argc, argv);   //第1步、这一步取得三个值 Hidden层数、trainfilename、testfilename
    srand(seed);
    printConfig();                  //第2步、打印初始化的数据

    RbmPredictData predictData;     //构造出对象
    safeLoad(predictData, testFilename);    //第3步、预测数据化成矩阵形式
    cout << "Done loading test data" << flush;

    RbmData data;
    safeLoad(data, trainFilename);            //步骤和第3步完全一样，这是训练集
    cout << "\rDone loading data.     " << endl;

    Rbm* r = NULL; 
    if (parallel) 
        r = new RbmParallel(nThreads, data, nHidden);   
    else
        r = new Rbm(data, nHidden);          //第4步、构造rbm，初始化各种W，hb，vb。查看rbm.cpp
    r->momentum = initialMomentum;
    r->hBiasLearnRate = hLearn;
    r->vBiasLearnRate = vLearn;
    r->WlearnRate = wLearn;
    r->weightDecay = wCost;

    for (int i = 1; i <= nEpochs; i++) {
        int increment = extractIncrements(i);    //浮云
        if (increment) {
            r->T += increment;
            cout << "\tT = " << r->T << endl;
        }
        if (i == finalMomentumStart)
            r->momentum = finalMomentum;

        r->performEpoch(data);        //第5步、最关键的步骤，查看rbm.cpp

        if (!epochsToSaveAt.empty() && epochsToSaveAt.front() == i) {
            epochsToSaveAt.pop_front();
            stringstream t;
            t << savePrefix << i;
            double d = r->predict(data, predictData, t.str());
            cout << i << ": saving to " << t.str() << "(" << d << ")" << endl;
        } else if (predictAlways) {
            double d = r->predict(data, predictData);            //第6步、预测，查看rbm.cpp
            cout << i << ": " << d << endl;
        } else {
            cout << i << ": omitting prediction" << endl;
        }
    }

    return 0;
}

//第1步、取参数
void parseArgs(int argc, char* argv[]) {
    int current = 1;
    // TODO: make more user friendly in terms of error handling.
    //       and coding style leaves something to be desired...
    while (current < argc) {
        if (strcmp("-h", argv[current]) == 0) {
            printf(helpString, argv[0]);
            exit(0);
        } else if (strcmp("-d", argv[current]) == 0) {
            cout << "Defaults: " << endl;
            printConfig();
            exit(0);
        } else if (strcmp("-v", argv[current]) == 0) {
            vLearn = atof(argv[current + 1]);
            current += 1;
        } else if (strcmp("-H", argv[current]) == 0) {
            hLearn = atof(argv[current + 1]);
            current += 1;
        } else if (strcmp("-w", argv[current]) == 0) {
            wLearn = atof(argv[current + 1]);
            current += 1;
        } else if (strcmp("-n", argv[current]) == 0) {
            nHidden = atoi(argv[current + 1]);
            current += 1;
        } else if (strcmp("-i", argv[current]) == 0) {
            initialMomentum = atof(argv[current + 1]);
            current += 1;
        } else if (strcmp("-m", argv[current]) == 0) {
            finalMomentum = atof(argv[current + 1]);
            finalMomentumStart = atoi(argv[current + 2]);
            current += 2;
        } else if (strcmp("-e", argv[current]) == 0) {
            nEpochs = atoi(argv[current + 1]);
            current += 1;
        } else if (strcmp("-c", argv[current]) == 0) {
            wCost = atof(argv[current + 1]);
            current += 1;
        } else if (strcmp("-t", argv[current]) == 0) {
            do {
                current += 1;
                tIncrements.push_back(atoi(argv[current]));
            } while (current + 1 < argc && 
                    '0' <= argv[current + 1][0] && argv[current + 1][0] <= '9');
        } else if (strcmp("-s", argv[current]) == 0) {
            current += 1;
            seed = atoi(argv[current]);
        } else if (strcmp("--save", argv[current]) == 0) {
            current += 1;
            savePrefix = argv[current];
            do {
                current += 1;
                epochsToSaveAt.push_back(atoi(argv[current]));
            } while (current + 1 < argc && 
                    '0' <= argv[current + 1][0] && argv[current + 1][0] <= '9');
        } else if (strcmp("--never", argv[current]) == 0) {
            predictAlways = false;
        } else if (argc - current == 2) {
            trainFilename = argv[current];
        } else if (argc - current == 1) {
            testFilename = argv[current];
        } else {
            cerr << "ERROR: Unknown option: " << argv[current] << endl
                 << "Exiting now." << endl;
            exit(1);
        }
        current += 1;
    }
}

//第2步、打印参数
void printConfig() {
    cout << "Learning rates:" << endl
         << "  visible        " << vLearn << endl
         << "  hidden         " << hLearn << endl
         << "  weights        " << wLearn << endl
         << "  cost           " << wCost << endl;
    cout << "Hidden nodes:    " << nHidden << endl;
    if (initialMomentum != 0.0 && finalMomentum != 0.0) {
        cout << "Momentum:        " << endl
             << "  initial        " << initialMomentum << endl
             << "  final          " << finalMomentum << endl
             << "  start          " << finalMomentumStart << endl;
    }
    if (tIncrements.size() > 0) {
        cout << "T-increment on:  ";
        for (unsigned i = 0; i < tIncrements.size(); i++) {
            cout << tIncrements[i] << ' ';
        }
        cout << endl;
    }
    if (epochsToSaveAt.size() > 0) {
        cout << "Saving at epochs:";
        for (unsigned i = 0; i < epochsToSaveAt.size(); i++) {
            cout << epochsToSaveAt[i] << ' ';
        }
        cout << endl;
        cout << "Save prefix:     " << savePrefix << endl;
    }
    cout << "Datasets:      " << endl
         << "  train          " << trainFilename << endl
         << "  test           " << testFilename << endl;
    cout << "Epochs:          " << nEpochs << endl;
    cout << "Random seed:     " << seed << endl;
    cout << "Predict always:  " << (predictAlways? "yes" : "no") << endl;
    cout << endl;
}

//第3步、这会调用rbmpredictdata.cpp的safeLoad函数，步骤3.1。
void safeLoad(RbmData& p, const string& fname) {
    ifstream f(fname.c_str());
    if (!f) {
        cerr << "ERROR: " << fname << " could not be opened." << endl;
        cerr << "Exiting now." << endl;
        exit(1);
    }
    p.loadTsv(f);
    f.close();
}

char helpString[] =
    "Usage: %s [arguments] <trainfile> <testfile>\n"
    "\n"
    "Arguments:\n"
    "  -h                    Print Help (this message) and exit\n"
    "  -v <float>            Set visible bias learning rate to <float>\n"
    "  -H <float>            Set hidden bias learning rate to <float>\n"
    "  -w <float>            Set weight learning rate to <float>\n"
    "  -c <float>            Set weight-cost coefficient to <float>\n"
    "  -n <uint>             Use <uint> hidden nodes\n"
    "  -i <float>            Set initial momentum to <float>\n"
    "  -m <float> <uint>     Set final momentum to <float> at epoch <uint>\n"
    "  -e <uint>             Perform <uint> epochs\n"
    "  -t <uint> [<uint>...] Increase T by one at epoch <uint>, <uint> ...\n"
    "  -d                    Print the defaults and exit\n"
    "  -s <uint>             Set the random seed to <uint>\n"
    "  --save <string>       Save the predictions of the model after epoch\n"
    "         <uint> [...]        <uint> to file: <string>+<uint>.dat\n"
    "  --never               Do not predict, unless specified to save.\n"
    "\n"
    "Example usage:\n"
    "  ./rbm -t 5 5 7 train.dat test.dat\n"
    "     Set T to 3 at epoch 5, and to 4 at epoch 7.\n"
    "  ./rbm --never --save mypredfile 10 20 train.dat test.dat\n"
    "     Generates two files: mypredfile10.dat and mypredfile20.dat\n";

string trainFilename, testFilename, savePrefix;
float vLearn = 0.005, hLearn = 0.005, wLearn = 0.005, wCost = 0.005;
int nHidden = 100, nEpochs = 40;
float finalMomentum = 0.0, initialMomentum = 0.0;
int finalMomentumStart = 5;
deque<int> tIncrements;
deque<int> epochsToSaveAt;
int seed = 1;
bool predictAlways = true;
bool parallel = false;
int nThreads = 32;

int extractIncrements(int i) {
    int increment = 0;
    while (tIncrements.size() != 0 && tIncrements.front() == i) {
        increment += 1;
        tIncrements.pop_front();
    }
    return increment;
} 

大头来了

rbm.h

#ifndef RBM_H
#define RBM_H

#include "rbmdata.h"
#include "rbmpredictdata.h"
#include <Eigen/Dense>
#include <vector>
#include <thread>

using namespace Eigen;
using namespace std;

typedef Matrix<bool, 1, Dynamic> RowVectorXb;

class Rbm {
public:
    Rbm(const RbmData& data, int nHidden);

    virtual void performEpoch(const RbmData& data);

    virtual double predict(
            const RbmData& data, 
            const RbmPredictData& predictData, 
            const string& filename);

    virtual double predict(
            const RbmData& data,
            const RbmPredictData& predictData);

    virtual double predict(
            const RbmData& data,
            const RbmPredictData& predictData,
            ostream& predictStream);

    static float hBiasLearnRate;
    static float vBiasLearnRate;
    static float WlearnRate;
    static float weightDecay;
    static float momentum;
    static int T;
private:
    Rbm();

    void negActivation(const RowVectorXf& h0states);

    void gibbsSample();

    void normalizedNegActivation(const RowVectorXf& h0states);
    void softmax(const RowVectorXf& h0states);

    void initVisibleBias(const RbmData& data);

    void applyMomentum(const RbmData& data, int user);
    void selectWeights(const RbmData& data, int rangeStart, int rangeEnd);

public: // These are public so RbmParallel can use them
    MatrixXf W, Wsel, Wmomentum;
    RowVectorXf vBias, vBiasSel, vBiasMomentum, hBias, hBiasMomentum;

    void performEpoch(const RbmData& data, int userStart, int userEnd);

private:
    RowVectorXf h0probs, hTProbs;
    RowVectorXb h0states;

    RowVectorXf negData;

    MatrixXf posProds, negProds;

    int nHidden;
    int nClasses;
};

#endif

rbm.cpp

#include "rbm.h"
#include <iomanip>
#include <numeric>
#include <thread>
#include <cmath>
#include <fstream>

float Rbm::hBiasLearnRate = 0.001;
float Rbm::vBiasLearnRate = 0.008;
float Rbm::WlearnRate = 0.0006;
float Rbm::weightDecay = 0.0001;
float Rbm::momentum = 0.5;
int Rbm::T = 1;


//第4步、初始化w，hb，vb
//W = N(movie) * K(评分类数) * M(隐层节点数)
//vb = N(movie) * K(评分类数)
//hb = M(隐层节点数)
Rbm::Rbm(const RbmData& data, int nHidden) 
        : nHidden(nHidden), nClasses(data.nClasses)
{
    W.setRandom(data.nMovies * nClasses, nHidden);
    W.array() *= 0.01;
    vBias.setZero(data.nMovies * nClasses);
    initVisibleBias(data);                    //可见层的bias初始化。
    hBias.setZero(nHidden);
}


//4.1所建立的movies和ratings根据用户id进行匹配

void Rbm::initVisibleBias(const RbmData& data) {
    MatrixXi totals = MatrixXi::Zero(1, data.nMovies);
    int nUsers = data.range.size() - 1;
    for (int i = 0; i < nUsers; i++) {
        
//segment根据data.range(i), data.range(i + 1)也就是每行的userid数建立矩阵        
        const auto& movies = data.movies.segment(
                data.range(i), data.range(i + 1) - data.range(i));
        const auto& ratings = data.ratings.segment(
                data.range(i), data.range(i + 1) - data.range(i));
                
//表示userid=0有多少个 1有多少。。。且和每行的movies、ratings相等                
        int amountOfRatings = data.range(i + 1) - data.range(i);     
        for (int r = 0; r < amountOfRatings; r++) {
            vBias(movies(r)) += ratings(r);
            int exactMovie = movies(r) / nClasses;
            totals(exactMovie) += ratings(r);
        }
    }
    for (int m = 0; m < totals.size(); m++) {
        for (int c = 0; c < nClasses; c++) {
            if (vBias(m * nClasses + c) != 0) {
                vBias(m * nClasses + c) /= totals(m);
                vBias(m * nClasses + c) = 
                    log(vBias(m * nClasses + c));
            }
        }
    }
}


//第5步、坑爹的又调用下面的
void Rbm::performEpoch(const RbmData& data) {
    performEpoch(data, 0, data.range.size() - 1);
}

//第5.1步、开刀
void Rbm::performEpoch(const RbmData& data, int userStart, int userEnd) {
    vector<int> randomizedIds(userEnd - userStart, 0);       //定义了End-Start个0元素
    for (int i = userStart; i < userEnd; i++) 
        randomizedIds[i - userStart] = i;                                            //根据传进来的值知道这个相当是userid个数
    random_shuffle(randomizedIds.begin(), randomizedIds.end());    //打乱顺序

    for (unsigned i = 0; i < randomizedIds.size(); i++) {
        int rangeStart = data.range(randomizedIds[i]);
        int rangeEnd = data.range(randomizedIds[i] + 1); // end is exclusive
        int rangeLength = rangeEnd - rangeStart;                //用户id为i的那一行有几个电影评分了*5；
        
        selectWeights(data, rangeStart, rangeEnd);            //寻找和userid匹配的W
        const auto& visData = data.ratings.segment(rangeStart, rangeLength);   //这个userid矩阵化

        h0probs = 1 / (1 + (-visData*Wsel - hBias).array().exp());        //h0
        h0states = h0probs.array() > 
            (h0probs.Random(h0probs.size()).array() + 1) / 2;           //？
        negActivation(h0states.cast<float>());                                                    //？

        hTProbs = 1 / (1 + (-negData*Wsel - hBias).array().exp());      //h1
        for (int t = 1; t < T; t++)
            gibbsSample();                                                                                            //gibbs

        posProds.noalias() = visData.transpose() * h0probs;
        negProds.noalias() = negData.transpose() * hTProbs; 

        if (i > 0)
            applyMomentum(data, randomizedIds[i - 1]);                        //userid>0


//下面各种更新参数
        hBiasMomentum.noalias() = hBiasLearnRate * (h0probs - hTProbs);
        hBias.noalias() += hBiasMomentum;
        vBiasMomentum.noalias() = vBiasLearnRate * (visData - negData);
        for (int r = rangeStart; r < rangeEnd; r++)
            vBias(data.movies(r)) += vBiasMomentum(r - rangeStart);

        Wmomentum.noalias() = posProds - negProds;
        for (int r = 0; r < rangeLength; r++)
            W.row(data.movies(r + rangeStart)).noalias() += 
                WlearnRate * (Wmomentum.row(r) - weightDecay*Wsel.row(r));
    }
}

void Rbm::negActivation(const RowVectorXf& h0states) {
    softmax(h0states);
}

void Rbm::gibbsSample() {
    h0states = 
        hTProbs.array() > (hTProbs.Random(hTProbs.size()).array() + 1) / 2;
    negActivation(h0states.cast<float>());
    hTProbs = 1 / (1 + (-negData*Wsel - hBias).array().exp());
}

void Rbm::normalizedNegActivation(const RowVectorXf& h0states) {
    softmax(h0states);
}

void Rbm::softmax(const RowVectorXf& h0states) {
    negData = (h0states*Wsel.transpose() + vBiasSel);
    for (int m = 0; m < negData.size(); m += nClasses) {
        negData.segment(m, nClasses).array() -=
            negData.segment(m, nClasses).maxCoeff();           //userid=i那行减去其最大值
    }
    negData.array() = negData.array().exp();
    for (int m = 0; m < negData.size(); m += nClasses) {
        negData.segment(m, nClasses).array() /=
            negData.segment(m, nClasses).sum();                     //userid=i那行减去其最大值，不知何用意?
    }
}

void Rbm::selectWeights(const RbmData& data, int rangeStart, int rangeEnd) {
    int rangeLength = rangeEnd - rangeStart;
    Wsel.resize(rangeLength, nHidden);
    vBiasSel.resize(rangeLength);
    for (int r = rangeStart; r < rangeEnd; r++) {
        Wsel.row(r - rangeStart).noalias() = W.row(data.movies(r));
        vBiasSel(r - rangeStart) = vBias(data.movies(r));
    }
}

void Rbm::applyMomentum(const RbmData& data, int user) {
    if (momentum == 0.0) return;
    int rangeStart = data.range(user);
    int rangeEnd = data.range(user + 1); // end is exclusive
    int rangeLength = rangeEnd - rangeStart;

    hBias.noalias() += momentum * hBiasMomentum;
    for (int r = rangeStart; r < rangeEnd; r++)
        vBias(data.movies(r)) += momentum * vBiasMomentum(r - rangeStart);

    for (int r = 0; r < rangeLength; r++) {
        W.row(data.movies(r + rangeStart)).noalias() += 
            momentum * Wmomentum.row(r);
    }
}

double Rbm::predict(const RbmData& data, const RbmPredictData& predictData,
        const string& fname) {
    ofstream out(fname.c_str());
    double d = predict(data, predictData, out);
    out.close();
    return d;
}

//第6步、又特么调用下面的
double Rbm::predict(const RbmData& data, const RbmPredictData& predictData) {
    stringstream dontcare;        //输入流，传入参数和目标对象类型自动推导
    return predict(data, predictData, dontcare);
}

//第6.1步。主要思想如下
//由之前训练重构的数据和预测数据相减算rmse
double Rbm::predict(const RbmData& data, const RbmPredictData& predictData,
        ostream& predictStream) {
    double rmse = 0.0;
    int predictCount = 0;
    for (unsigned i = 0; i < predictData.userIds.size(); i++) {
        int userId = predictData.userIds[i];
        int rangeStart = data.range(userId);
        int rangeEnd = data.range(userId + 1); // end is exclusive
        selectWeights(data, rangeStart, rangeEnd);
        const auto& visData = 
            data.ratings.segment(rangeStart, rangeEnd - rangeStart);
        h0probs = 1 / (1 + (-visData*Wsel - hBias).array().exp());       //这里又不知道在干嘛。

        rangeStart = predictData.range(i);
        rangeEnd = predictData.range(i + 1);
        selectWeights(predictData, rangeStart, rangeEnd);
        normalizedNegActivation(h0probs);
        const auto& actualData = 
            predictData.ratings.segment(rangeStart, rangeEnd - rangeStart);    //预测集ratings矩阵化

        for (int r = 0; r < actualData.size(); r += nClasses) {
            float actual = 0;
            float predicted = 0;
            for (int c = 0; c < nClasses; c++) {
                actual += actualData(r + c) * (c + 1);          //把5维的0 1 转化成评分数1~k
                predicted += negData(r + c) * (c + 1);                
            }
            predictStream << predicted << endl;
            float t = actual - predicted;
            rmse += t * t;
        }
        predictCount += actualData.size() / nClasses;
    }
    return sqrt(rmse / predictCount);
}

rbmparallel.h

#ifndef RBM_PARALLEL_H
#define RBM_PARALLEL_H
#include "rbm.h"
#include "rbmdata.h"

class RbmParallel : public Rbm {
public:
    RbmParallel(int nThreads, const RbmData& data, int nHidden);

    void performEpoch(const RbmData& data);

private:
    RbmParallel();

    void startEpochs(const RbmData& data, int batchStart, int batchSize);
    void joinExecution();
    void updateWeights();
    void synchronizeWeights();

    static void performEpochInThread(
            Rbm& r, const RbmData& data, int userStart, int userEnd);

    int nThreads;
    int nUsers;
    vector<Rbm> subRbms;
    vector<thread> threads;
};

#endif

rbmparallel.cpp

#include "rbmparallel.h"

RbmParallel::RbmParallel(int nThreads, const RbmData& data, int nHidden) : 
    Rbm(data, nHidden), 
    nThreads(nThreads), 
    nUsers(data.range.size() - 1),
    subRbms(nThreads - 1, Rbm(data, nHidden))
{
    synchronizeWeights();
}

void RbmParallel::performEpoch(const RbmData& data) {
    int batchSize = nUsers;
    for (int batchStart = 0; batchStart < nUsers; batchStart += batchSize) {
        startEpochs(data, batchStart, batchSize);
        joinExecution();
        updateWeights();
    }
}

void RbmParallel::startEpochs(
        const RbmData& data, int batchStart, int batchSize) {
    threads.clear();
    int usersPerStep = batchSize / nThreads;
    int userStart = batchStart;
    for (int i = 0; i < nThreads - 1; i++) {
        threads.push_back(
                thread(&RbmParallel::performEpochInThread, 
                    ref(subRbms[i]), ref(data), 
                    userStart, userStart + usersPerStep));
        userStart += usersPerStep;
    }
    Rbm::performEpoch(data, userStart, nUsers);
}

void RbmParallel::performEpochInThread(
        Rbm& r, const RbmData& data, int userStart, int userEnd) {
    r.performEpoch(data, userStart, userEnd);
}

void RbmParallel::joinExecution() {
    for (auto it = threads.begin(); it != threads.end(); it++) {
        it->join();
    }
}

void RbmParallel::updateWeights() {
    float updateFactor = 1.0 / nThreads;
    W *= updateFactor;
    vBias *= updateFactor;
    hBias *= updateFactor;
    for (auto it = subRbms.begin(); it != subRbms.end(); it++) {
        W += it->W * updateFactor;
        vBias += it->vBias * updateFactor;
        hBias += it->hBias * updateFactor;
    }
    synchronizeWeights();
}

void RbmParallel::synchronizeWeights() {
    for (auto it = subRbms.begin(); it != subRbms.end(); it++) {
        it->W = W;
        it->hBias = hBias;
        it->vBias = vBias;
    }
}

基础太差，看了一个星期，还是看不懂，伤不起。