MNISTローダとMLPの学習コードをC++/Eigenで作成する(MNISTローダ作成編)

class MnistEigenDataset
{

    private:
        // ファイル入力用
        string _train_image_filepath = "./datasets/data/train-images.idx3-ubyte";
        string _train_label_filepath = "./datasets/data/train-labels.idx1-ubyte";
        string _test_image_filepath = "./datasets/data/t10k-images.idx3-ubyte";
        string _test_label_filepath = "./datasets/data/t10k-labels.idx1-ubyte";
        ifstream _train_image_ifs;
        ifstream _train_label_ifs;
        ifstream _test_image_ifs;
        ifstream _test_label_ifs;

        // ファイルシーク：初期位置記憶用
        ifstream::pos_type _train_image_pos;
        ifstream::pos_type _train_label_pos;
        ifstream::pos_type _test_image_pos;
        ifstream::pos_type _test_label_pos;

        // ファイルシーク用インデックス格納コンテナ
        vector<int> _train_indices;
        vector<int> _test_indices;

        // 内部変数
        int _batch_size;
        int _train_max_batch_num;
        int _test_max_batch_num;
        int _train_load_count = 0;
        int _test_load_count = 0;

        int _number_of_train_data = 0;
        int _number_of_test_data = 0;
        int _rows = 0;
        int _cols = 0;

    private:
        void _init_train_loader(void);
        void _init_test_loader(void);

    public:
        MnistEigenDataset(){}; // デフォルトコンストラクタ -> 簡単のため未実装
        MnistEigenDataset(const int batch_size, bool random_load=true);
        void next_train(MatrixXd &, MatrixXd &, bool one_hot_label=false, bool normalize=true);
        void next_test(MatrixXd &, MatrixXd &, bool one_hot_label=false, bool normalize=true);

};

<!-- wp:code -->
<pre class="wp-block-code"><code>// コンストラクタ
MnistEigenDataset::MnistEigenDataset(int batch_size, bool random_load)
{
    _batch_size = batch_size;

    // ファイル読み込み初期化処理
    _init_train_loader();
    _init_test_loader();

    _train_max_batch_num = (_number_of_train_data + _batch_size - 1) / _batch_size; // 切り上げ
    _test_max_batch_num = (_number_of_test_data + _batch_size - 1) / _batch_size;

    // ランダム読み出しの設定をしているときはインデックスをシャッフル
    if (random_load)
    {
        std::mt19937_64 get_rand_mt;
        std::shuffle(_train_indices.begin(), _train_indices.end(), get_rand_mt);
        std::shuffle(_test_indices.begin(), _test_indices.end(), get_rand_mt);
    }
}


void MnistEigenDataset::_init_train_loader(void)
{
    // 設定したファイルパスに基づいてファイルオープン
    _train_image_ifs.open(_train_image_filepath, std::ios::in | std::ios::binary);
    _train_label_ifs.open(_train_label_filepath, std::ios::in | std::ios::binary);
    int magic_number = 0;

    // 適切な位置までファイルポインタ移動
    _train_image_ifs.read((char *)&magic_number, sizeof(magic_number)); // sizeof(magic_number) = 4
    magic_number = LittleEndian2BigEndian(magic_number);
    _train_image_ifs.read((char *)&_number_of_train_data, sizeof(_number_of_train_data));
    _number_of_train_data = LittleEndian2BigEndian(_number_of_train_data);
    _train_image_ifs.read((char *)&_rows, sizeof(_rows));
    _rows = LittleEndian2BigEndian(_rows);
    _train_image_ifs.read((char *)&_cols, sizeof(_cols));
    _cols = LittleEndian2BigEndian(_cols);

    cout << "IMAGE magic number: " << magic_number << endl;

    // 適切な位置までファイルポインタ移動
    _train_label_ifs.read((char *)&magic_number, sizeof(magic_number));
    magic_number = LittleEndian2BigEndian(magic_number);
    _train_label_ifs.read((char *)&_number_of_train_data, sizeof(_number_of_train_data));
    _number_of_train_data = LittleEndian2BigEndian(_number_of_train_data);

    cout << "LABEL magic number: " << magic_number << endl;

    // ファイルポインタ：シーク位置の記憶
    _train_image_pos = _train_image_ifs.tellg();
    _train_label_pos = _train_label_ifs.tellg();

    // 読み出しのためのインデックス作成：単なる整数型でOK(int)
    for (int i = 0; i < _number_of_train_data; i++)
    {
        _train_indices.push_back(i);
    }
}

// _init_test_loader()についてはほぼ同様なので省略</code></pre>
<!-- /wp:code -->

void MnistEigenDataset::next_train(MatrixXd& train_X, MatrixXd& train_y, bool one_hot_label, bool normalize)
{
    // 読み出し用一時変数
    int pixels = _rows * _cols;
    vector<double> tmp_image(pixels); // 配列のサイズ初期化は必要(でないとセグフォとなる)
    vector<double> tmp_labels(_batch_size);

    if (one_hot_label){
        train_y = MatrixXd::Zero(_batch_size, 10); // one_hot_label有効化時の初期化
    }

    // インデックス取得：初期位置計算
    int start_idx = _batch_size * _train_load_count;
    int tmp_idx;
    // 訓練データ読み出し メイン処理部
    for (int i = 0; i < _batch_size; i++)
    {
        // 59999を超えたインデックスは0から再カウント
        tmp_idx = _train_indices[(start_idx + i) % _number_of_train_data]; 
        // ファイルシーク：画像データのインターバルは「28×28=784byte」あるので注意
        // 画像データ
        _train_image_ifs.seekg(_train_image_pos);                     // シークを初期位置に
        _train_image_ifs.seekg(tmp_idx * pixels, std::ios_base::cur); // 読み出し位置まで移動
        // ラベル
        _train_label_ifs.seekg(_train_label_pos);                     // シークを初期位置に
        _train_label_ifs.seekg(tmp_idx, std::ios_base::cur);          // 読み出し位置まで移動

        // 画像読み出し
        for (int j = 0; j < pixels; j++)
        {
            unsigned char tmp_value;
            _train_image_ifs.read((char *)&tmp_value, sizeof(tmp_value));
            tmp_image[j] = (double)(tmp_value);
        }
        // テンプレート実体化のため、コンパイル時に数値指定の必要あり(_rows, _colsが使えない)
        train_X.row(i) = Map<Matrix<double, 1, 28*28>>(&(tmp_image[0]));

        // ラベル読み出し
        unsigned char tmp_label;
        _train_label_ifs.read((char *)&tmp_label, sizeof(tmp_label));
        tmp_labels[i] = (double)(tmp_label);

        // one-hotか否かで場合分け
        if (one_hot_label){
            train_y(i, int(tmp_label)) = 1;
        } else {
            train_y.row(i) = Map<Matrix<double, 1, 1>>(&(tmp_labels[i]));
        }

    }

    if (normalize)
    {
        train_X /= 255;
    }

    _train_load_count++;
    // カウンタリセット → バッチ数とカウントが同じになったら0にする
    _train_load_count = _train_load_count % _train_max_batch_num;