C++でMNISTの手書き数字認識をニューラルネットワークで行う

授業課題で実装を行ったので、備忘録として
ディープラーニングのフレームワークを一切使わず、C++で行列演算からバックプロパゲーションまでを自前実装し、MNIST手書き数字を分類する

repo: https://github.com/romophic/MNIST_cpp

1. 原理

構築したニューラルネットワークの中でデータがどのように処理されるかを説明する。

1.1 入力から出力までの流れ

ニューラルネットワークは、複数の層が重なってできている。データは入力層から隠れ層、そして出力層へと一方向に流れていく。これを順伝搬と言う。

ある層から次の層へデータが伝わるとき、それぞれの信号は重みによって強さが変えられる。入力データを $\bm{x}$ 、次の層へ伝わる信号を $\bm{u}$ 、重みをまとめた行列を $\bm{W}$ とすると、この関係は以下のように単純な行列の積で表せる。

\bm{u} = \bm{W} \bm{x}

この式は、前の層の全ニューロンからの信号が、それぞれ重みを掛けられて次の層のニューロンに集まってくることを意味している。集まってきた信号 $\bm{u}$ は、そのまま次の層へ送られるのではなく、活性化関数と呼ばれるフィルターを通る。これがニューロンの発火（信号を次に伝えるか）を決める役割を果たす。本実験では2種類の関数を使用した。

隠れ層ではReLU関数を用いた。これは入力が負の値なら0を出力し、正の値ならそのまま出力するという働きをする。

f(x) = \max(0, x)

これにより、不要な情報をカットし、重要な特徴だけを次の層へ伝えることができる。計算が非常に単純であるため、学習が速く進むという利点がある。

最後の出力層ではSigmoid関数を用いた。これはどんな値が来ても $0$ から $1$ の間の数値に変換する。

f(x) = \frac{1}{1 + e^{-x}}

出力が $0$ から $1$ の間に収まるため、その数字である確率として解釈することができる。

1.2 学習の仕組み（誤差逆伝播）

最初は重み $\bm{W}$ がランダムな値になっているため、正しい答えが出ない。そこで、ネットワークが出した答えと、教師データとの誤差を計算する。この誤差を小さくするように、出力層から入力層に向かって逆方向に重みを少しずつ修正していく。これを繰り返すことで、ニューラルネットワークは徐々に正しい判断ができるようになっていく。

2. 手法

実装にはC++23およびコンパイラとしてClang version 21.1.7を使用した。行列計算にはEigenライブラリを使用した。本実験で構築したモデルの詳細は以下の通りである。

入力層: 784ノード（ $28 \times 28$ ピクセルの画像データに対応）
隠れ層: 128ノード（活性化関数: ReLU）
出力層: 10ノード（活性化関数: Sigmoid、数字の0〜9に対応）

学習をスムーズに開始するため、重みの初期値は慎重に決める必要がある。隠れ層の重み初期化にはHe初期化を、出力層の重み初期化にはXavier初期化という手法を用いた。これはデータのバラつき具合を保つように乱数を設定する方法で、これを用いることで学習が途中で止まってしまうことを防いでいる。

2.1 学習アルゴリズム

学習部分のソースコードを段階に分けて説明する。以下は、ニューラルネットワークを扱う class NeuralNetwork の実装の概要である。

リスト1: NeuralNetworkクラスの実装（概要）

1
class NeuralNetwork {
2
 private:
3
  Eigen::MatrixXd w_ih;            // 入力層 → 隠れ層の重み
4
  Eigen::MatrixXd w_ho;            // 隠れ層 → 出力層の重み
5
  Eigen::VectorXd hidden_outputs;  // 隠れ層の出力
6

7
 public:
8
  // 初期化
9
  NeuralNetwork();
10
  // 順伝播を行う
11
  Eigen::VectorXd query(const Eigen::VectorXd& _inputs);
12
  // 学習
13
  void train(const Eigen::VectorXd& _inputs, const Eigen::VectorXd& _targets) {}
14
};

変数として入力層・隠れ層・出力層の重み行列を持つ。続いて、以下に初期化を行う NeuralNetwork の内容を記す。

リスト2: 初期化の実装

1
NeuralNetwork() {
2
  // 隠れ層
3
  double weight_scale_ih = sqrt(2.0 / INPUT_NODES); // He初期化係数
4
  w_ih = Eigen::MatrixXd::Random(HIDDEN_NODES, INPUT_NODES) * weight_scale_ih; // He初期化
5
  // 出力層
6
  double weight_scale_ho = sqrt(1.0 / HIDDEN_NODES);  // Xavier初期化係数
7
  w_ho = Eigen::MatrixXd::Random(OUTPUT_NODES, HIDDEN_NODES) * weight_scale_ho;  // Xavier初期化
8
}

以下に順伝搬を行う関数 query の内容を示す。

リスト3: 順伝播の実装

1
// 順伝播を行う
2
Eigen::VectorXd query(const Eigen::VectorXd& _inputs) {
3
  // 隠れ層
4
  Eigen::VectorXd hidden_inputs = w_ih * _inputs;   // 重み行列と入力行列を掛けた結果を出力とする
5
  hidden_outputs = hidden_inputs.unaryExpr(&relu);  // 出力にReluを適応する
6

7
  // 出力層
8
  Eigen::VectorXd final_inputs =
9
      w_ho * hidden_outputs;  // 重み行列と隠れ層の出力行列を掛けた結果を出力とする
10
  Eigen::VectorXd final_outputs = final_inputs.unaryExpr(&sigmoid);  // 出力にSigmoidを適応する
11
  return final_outputs;
12
}

最後に、学習を行う部分である train の実装を説明する。

リスト4: 学習（誤差逆伝播）の実装

1
// 学習
2
void train(const Eigen::VectorXd& _inputs, const Eigen::VectorXd& _targets) {
3
  Eigen::VectorXd final_outputs = query(_inputs);  // 順伝搬
4

5
  Eigen::VectorXd output_errors = _targets - final_outputs;          // 誤差計算
6
  Eigen::VectorXd hidden_errors = w_ho.transpose() * output_errors;  // 隠れ層の誤差計算
7

8
  // 出力層の勾配
9
  Eigen::VectorXd output_gradients =
10
      output_errors.cwiseProduct(final_outputs.unaryExpr(&sigmoid_d));
11
  w_ho += LEARNING_RATE * (output_gradients * hidden_outputs.transpose());  // 出力層の重み更新
12

13
  // 隠れ層の勾配
14
  Eigen::VectorXd hidden_gradients =
15
      hidden_errors.cwiseProduct(hidden_outputs.unaryExpr(&relu_d));
16
  w_ih += LEARNING_RATE * (hidden_gradients * _inputs.transpose());  // 隠れ層の重み更新
17
}

2.2 MNISTデータセットの読み込み

MNISTデータセットは、以下の4つのファイルから構成されている。これらはビッグエンディアン形式で記録されているため、4バイトずつ読み込み、バイト順を反転させて数値を再構成する処理が必要となる。

train-images-idx3-ubyte: 学習用画像データ
train-labels-idx1-ubyte: 学習用ラベルデータ
t10k-images-idx3-ubyte: テスト用画像データ
t10k-labels-idx1-ubyte: テスト用ラベルデータ

画像データ本体はヘッダの後に続いており、各ピクセルが0から255の値で格納されている。読み込み時に全ピクセル値を255で割り、正規化して入力データとした。

2.3 ソースコード

以下に実験で使用したソースコード全文を記す。

リスト5: main.cpp（全文）

1
#include <algorithm>
2
#include <cmath>
3
#include <cstdlib>
4
#include <fstream>
5
#include <iostream>
6
#include <vector>
7

8
#include "Eigen/Core"
9
#include "Eigen/Dense"
10

11
using namespace std;
12

13
constexpr int INPUT_NODES = 784;        // 入力層のノード数
14
constexpr int HIDDEN_NODES = 128;       // 隠れ層のノード数
15
constexpr int OUTPUT_NODES = 10;        // 出力層のノード数
16
constexpr double LEARNING_RATE = 0.01;  // 学習率
17
constexpr int EPOCHS = 10;              // エポック数
18

19
double sigmoid(double _x) { return 1.0 / (1.0 + exp(-_x)); }  // sigmoid関数
20
double sigmoid_d(double _x) { return _x * (1.0 - _x); }       // sigmoidの微分
21

22
double relu(double _x) { return max(0.0, _x); }            // relu関数
23
double relu_d(double _y) { return _y > 0.0 ? 1.0 : 0.0; }  // reluの微分
24

25
class NeuralNetwork {
26
 private:
27
  Eigen::MatrixXd w_ih;            // 入力層 -> 隠れ層の重み
28
  Eigen::MatrixXd w_ho;            // 隠れ層 -> 出力層の重み
29
  Eigen::VectorXd hidden_outputs;  // 隠れ層の出力
30

31
 public:
32
  // 初期化
33
  NeuralNetwork() {
34
    // 隠れ層
35
    double weight_scale_ih = sqrt(2.0 / INPUT_NODES);                             // He初期化係数
36
    w_ih = Eigen::MatrixXd::Random(HIDDEN_NODES, INPUT_NODES) * weight_scale_ih;  // He初期化
37

38
    // 出力層
39
    double weight_scale_ho = sqrt(1.0 / HIDDEN_NODES);  // Xavier初期化係数
40
    w_ho = Eigen::MatrixXd::Random(OUTPUT_NODES, HIDDEN_NODES) * weight_scale_ho;  // Xavier初期化
41
  }
42

43
  // 順伝播を行う
44
  Eigen::VectorXd query(const Eigen::VectorXd& _inputs) {
45
    // 隠れ層
46
    Eigen::VectorXd hidden_inputs = w_ih * _inputs;   // 重み行列と入力行列を掛けた結果を出力とする
47
    hidden_outputs = hidden_inputs.unaryExpr(&relu);  // 出力にReluを適応する
48

49
    // 出力層
50
    Eigen::VectorXd final_inputs =
51
        w_ho * hidden_outputs;  // 重み行列と隠れ層の出力行列を掛けた結果を出力とする
52
    Eigen::VectorXd final_outputs = final_inputs.unaryExpr(&sigmoid);  // 出力にSigmoidを適応する
53
    return final_outputs;
54
  }
55

56
  // 学習
57
  void train(const Eigen::VectorXd& _inputs, const Eigen::VectorXd& _targets) {
58
    Eigen::VectorXd final_outputs = query(_inputs);  // 順伝搬
59

60
    Eigen::VectorXd output_errors = _targets - final_outputs;          // 誤差計算
61
    Eigen::VectorXd hidden_errors = w_ho.transpose() * output_errors;  // 隠れ層の誤差計算
62

63
    // 出力層の勾配
64
    Eigen::VectorXd output_gradients =
65
        output_errors.cwiseProduct(final_outputs.unaryExpr(&sigmoid_d));
66
    w_ho += LEARNING_RATE * (output_gradients * hidden_outputs.transpose());  // 出力層の重み更新
67

68
    // 隠れ層の勾配
69
    Eigen::VectorXd hidden_gradients =
70
        hidden_errors.cwiseProduct(hidden_outputs.unaryExpr(&relu_d));
71
    w_ih += LEARNING_RATE * (hidden_gradients * _inputs.transpose());  // 隠れ層の重み更新
72
  }
73
};
74

75
int read_int(ifstream& file) {
76
  unsigned char bytes[4];
77
  file.read((char*)bytes, 4);
78
  return (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
79
}
80

81
void load_mnist(const string& _image_path, const string& _label_path,
82
                vector<Eigen::VectorXd>& _images, vector<int>& _labels) {
83
  ifstream img_file(_image_path, ios::binary);
84
  ifstream lbl_file(_label_path, ios::binary);
85

86
  if (not(img_file.is_open() and lbl_file.is_open())) exit(1);
87

88
  read_int(img_file);
89

90
  int num_items = read_int(img_file);
91
  int rows = read_int(img_file);
92
  int cols = read_int(img_file);
93

94
  cout << "num_items: " << num_items << endl;
95
  cout << "rows: " << rows << endl;
96
  cout << "cols: " << cols << endl;
97

98
  read_int(lbl_file);
99
  read_int(lbl_file);
100

101
  _images.reserve(num_items);
102
  _labels.resize(num_items);
103

104
  for (int i = 0; i < num_items; ++i) {
105
    unsigned char label;
106
    lbl_file.read((char*)&label, 1);
107
    _labels[i] = (int)label;
108
    Eigen::VectorXd img_vec(rows * cols);
109
    for (int j = 0; j < rows * cols; ++j) {
110
      unsigned char pixel;
111
      img_file.read((char*)&pixel, 1);
112
      img_vec[j] = pixel / 255.0;
113
    }
114
    _images.emplace_back(img_vec);
115
  }
116
}
117

118
int main() {
119
  vector<Eigen::VectorXd> train_images, test_images;
120
  vector<int> train_labels, test_labels;
121

122
  load_mnist("train-images.idx3-ubyte", "train-labels.idx1-ubyte", train_images, train_labels);
123
  load_mnist("t10k-images.idx3-ubyte", "t10k-labels.idx1-ubyte", test_images, test_labels);
124

125
  NeuralNetwork nn;
126

127
  for (int epoch = 1; epoch <= EPOCHS; ++epoch) {
128
    for (size_t i = 0; i < train_images.size(); ++i) {
129
      Eigen::VectorXd targets = Eigen::VectorXd::Constant(OUTPUT_NODES, 0.01);
130
      targets[train_labels[i]] = 0.99;
131
      nn.train(train_images[i], targets);
132
    }
133
    cout << "Epoch " << epoch << " done" << endl;
134
  }
135

136
  int correct_count = 0;
137
  for (size_t i = 0; i < test_images.size(); ++i) {
138
    Eigen::VectorXd outputs = nn.query(test_images[i]);
139
    int predicted_label;
140
    outputs.maxCoeff(&predicted_label);
141
    if (predicted_label == test_labels[i])
142
      correct_count++;
143
  }
144

145
  double accuracy = (double)correct_count / test_images.size() * 100.0;
146
  cout << "Accuracy: " << accuracy << "%" << endl;
147

148
  return 0;
149
}

コンパイルコマンド:

clang++ -std=c++23 -O3 -march=native main.cpp

3. 結果

学習用データ60,000枚を使って10エポックの学習を行い、テストデータ10,000枚で正解率を測定した。認識精度は約**97.53%**となり、高い精度を確認した。

4. 考察

活性化関数: 隠れ層のReLUにより勾配消失を回避し、効率的な学習を実現した。
学習率: 0.01という設定は、収束の安定性と速度において適切であった。

C++でMNISTの手書き数字認識をニューラルネットワークで行う

#1. 原理

#1.1 入力から出力までの流れ

#1.2 学習の仕組み（誤差逆伝播）

#2. 手法

#2.1 学習アルゴリズム

#2.2 MNISTデータセットの読み込み

#2.3 ソースコード

#3. 結果

#4. 考察

#5. 参考文献