HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

Tensor Is the Might

Tensor Is the Might (zserge.com)

12 pointsby eatonphil3 コメント

要約

この記事は、ニューラルネットワークの基盤となる数学的抽象概念であるテンソルについて、その定義からC言語での実装までを解説しています。テンソルを多次元配列とメタデータとして捉え、インデックス計算の効率化やメモリ管理、さらにはGPU(Metal)での演算アクセラレーションまで、ゼロからテンソルライブラリを構築する過程を詳細に説明しています。

全文翻訳

Tensor is the might

あらゆる優れた抽象化は問題を解決する。この記事では、私がこれまで知っている素晴らしい数学的抽象化、すなわちテンソルについてすべてを解説する。

単純な2層のMLPからGPT-5に至るまで、ニューラルネットワークはすべて同じものに集約される。それは、演算グラフを流れる浮動小数点数である。この記事では、C言語で完全に加速されたテンソルライブラリをゼロから構築する。これは、Bellard氏のlibncに強く触発されているが、残念ながらまだオープンソース化されていない。

テンソルとは、数値のフラットな配列に、その数値を多次元オブジェクトとして解釈する方法を伝えるメタデータが付加されたものである。2次元配列は、1次元配列と行数/列数でより良く表現できると学んだが、これは本質的にテンソルが何であるかを示している。

[画像: Tensors]

しかし、2次元を超えると、一般的な形状のような他のメタデータが必要になるかもしれない。

float data[32 * 3 * 28 * 28]; // 32 images, 3 channels, 28x28 pixels
int shape[4] = {32, 3, 28, 28}; // shape of the tensor
int ndim = 4; // number of dimensions

形状があれば、4次元テンソルの位置 [n,c,h,w] にある要素が、テンソルを行優先のC言語順フォーマット(今日のほとんどのテンソルライブラリでデフォルトとなっていることが多い)で保持している場合、オフセット data[n*(3*28*28)+c*(28*28)+h*28+w] に存在することを把握できる。

しかし、毎回このように要素のインデックスを計算するのは非効率なので、形状がわかればストライドを事前に計算できる。ストライドは、指定された次元で1つの要素を進めるためにスキップする必要がある要素数を示す。形状関連のフィールドをすべてまとめてグループ化することもできる。

struct ut_shape {
  int ndim; // number of dimensions
  int nelem; // number of elements
  int shape[4]; // shape of the tensor
  int strides[4]; // strides for each dimension
};

struct ut_tensor {
  struct ut_shape shape; // shape of the tensor
  float *data; // pointer to the data
  ... // more fields to come later
};

形状を作成し、多次元インデックスからフラットインデックスを取得するためのヘルパーを追加できる。

ut_shape ut_shape_new(int ndims, int* dims) {
  ut_shape s = {.ndims = ndims, .nelems = 1};
  for (int i = 0; i < ndim; i++) {
    s.shape[i] = dims[i];
    s.nelem *= dims[i];
  }
  return s;
}

int ut_index(ut_shape s, const int* idx) {
  int flat = 0, stride = 1;
  for (int i = s.ndim - 1; i >= 0; i--) {
    flat += idx[i] * stride;
    stride *= s.shape[i];
  }
  return flat;
}

ut_shape s = ut_shape_new(3, (int[]){2, 3, 4});
assert(s.nelem == 24);
assert(s.ndim  == 3);
// element [1][2][3] should be at offset 1*12 + 2*4 + 3 = 23
assert(ut_index(s, (int[]){1, 2, 3}) == 23);

テンソルは通常動的に割り当てられるため、作成および破棄の方法を提供する必要がある。これはmalloc/freeのラッパーにすぎない。

場合によっては、別のテンソルと同じデータを共有するテンソルを作成したいことがある。例えば、テンソルの一部を「ビュー」として取得したり、データをコピーせずにテンソルを転置したり、形状を変更(フラット化)したりする場合である。この場合、データの所有権を追跡する必要がある。また、テンソルを「保持」しておくと、元のスコープを超えて存続させることができる。例えば、反復トレーニング中に、同じ割り当てを何度も避けるためである。そこで、テンソル構造体に参照カウントフィールドを追加する。

struct ut_tensor {
  struct ut_shape shape; // shape of the tensor
  float *data; // pointer to the data
  int refcount; // reference count for shared ownership, free when reaches 0
  struct ut_tensor *owner; // pointer to the owner tensor if this tensor is a view
};

アリーナアロケータやメモリプールを追加して頻繁なmalloc/free呼び出しを回避することで、メモリ管理をさらに最適化できるが、現時点で持っているものでも良い出発点となる。

しかし、操作なしではテンソルはほとんど役に立たない。

Elementwise

テンソルに対する最も基本的な操作は要素ごとの操作(elementwise)である。これは、すべての要素を単一のループで処理し、各要素(単項演算)または要素のペア(二項演算)に関数を適用する。これらは次のように実装できる。

static void ew_neg(float* out, const float* a, int n) {
  for (int i = 0; i < n; i++) out[i] = -a[i];
}

// ...more unary ops...

static void ew_relu(float* out, const float* a, int n) {
  for (int i = 0; i < n; i++) out[i] = fmaxf(0.f, a[i]);
}
static void ew_add(float* out, const float* a, const float* b, int n) {
  for (int i = 0; i < n; i++) out[i] = a[i] + b[i];
}

// ...more binary ops...

static ut_tensor* ew_unary(ut_tensor* a, void (*fn)(float*, const float*, int)) {
  ut_tensor* out = ut_alloc(a->shape.ndim, a->shape.shape);
  fn(out->data, a->data, a->shape.nelem);
  return out;
}
static ut_tensor* ew_binary(ut_tensor* a, ut_tensor* b,
                            void (*fn)(float*, const float*, const float*, int)) {
  ut_tensor* out = ut_alloc(a->shape.ndim, a->shape.shape);
  fn(out->data, a->data, b->data, a->shape.nelem);
  return out;
}

ut_tensor* ut_neg(ut_tensor* a) { return ew_unary(a, ew_neg); }
ut_tensor* ut_exp(ut_tensor* a) { return ew_unary(a, ew_exp); }
ut_tensor* ut_sigmoid(ut_tensor* a) { return ew_unary(a, ew_sigmoid); }
ut_tensor* ut_tanh(ut_tensor* a) { return ew_unary(a, ew_tanh); }
ut_tensor* ut_relu(ut_tensor* a) { return ew_unary(a, ew_relu); }
ut_tensor* ut_add(ut_tensor* a, ut_tensor* b) { return ew_binary(a, b, ew_add); }
ut_tensor* ut_sub(ut_tensor* a, ut_tensor* b) { return ew_binary(a, b, ew_sub); }
ut_tensor* ut_mul(ut_tensor* a, ut_tensor* b) { return ew_binary(a, b, ew_mul); }
ut_tensor* ut_div(ut_tensor* a, ut_tensor* b) { return ew_binary(a, b, ew_div); }
ut_tensor* ut_scale(ut_tensor* a, float s) {
  ut_tensor* out = ut_alloc(a->shape.ndim, a->shape.shape);
  for (int i = 0; i < a->shape.nelem; i++) out->data[i] = a->data[i] * s;
  return out;
}

二項演算を行う前に、2つのテンソルの形状が同じであることをassert()で確認できると良いだろう。あるいは、この時点で「ブロードキャスティング」をサポートしたいと判断するかもしれない。これは、小さい方のテンソルを大きい方のテンソルの形状に一致するように拡張することである。例えば、形状が[2, 3, 4]のテンソルと形状が[3, 4]のテンソルは、「最初の次元に沿って引き伸ばす」ことによって加算できる。これは多くのテンソルライブラリで一般的な機能だが、今回は省略することにした。私が目指しているほとんどのモデルは、基盤となるテンソルが完全に整列されている。そうでない場合は、テンソルの形状を明示的に整列させてデータを複製するか、後でブロードキャスティングのインデックス計算を追加することができる。

この時点で、行列乗算や畳み込みなどのより多くの演算を実装したくなるかもしれない。しかし、ここで問うべきは、すべての演算をCPUで実行したいのかということだ。

Golden Processing Unit (GPU)

現代のGPU価格を見ると、数値配列の計算において大きな価値があることは明らかである。したがって、ライブラリをCPUに限定するのではなく、一部の演算をGPUにオフロードすることを検討するかもしれない。

ここからが面白くなる。CPUとGPUの両方でメモリを管理し、データを効率的に転送し、GPUカーネルの書き方を学び、その他多くのことを行う必要があるからだ。さらに悪いことに、「GPUアクセラレータ」は一つではない。ベンダーは多数あり、それぞれ独自のAPIと癖がある。CUDA、OpenCL、WebGPU、Metal、Vulkanなどだ。

CPUのみのテンソルから最大限の性能を引き出そうと何度も試みたが、BLAS、LAPACK、OpenMPを使っても、GPUで加速されたフレームワークと同等の性能には到達できなかった。

管理しやすくするために、Metalから始めることにした。一方ではAppleデバイスに限定されるが、他方ではかなりモダンなAPIであり、「ユニファイドメモリ」を持つApple Siliconのおかげで物事がシンプルになる。

MetalはGPUカーネル(MSL)を定義するために独自の言語を使用しており、これはモダンなC++に似ている。カーネルは実行時にコンパイルされるため、Cコード内の文字列として定義できる。

static const char *shaderSource = 
    "#include <metal_stdlib>\n"
    "using namespace metal;\n"
    "\n"
    "kernel void relu(device const float *in  [[buffer(0)]],\n"
    "                  device float       *out [[buffer(1)]],\n"
    "                  uint id [[thread_position_in_grid]]) {\n"
    "    float val = in[id];\n"
    "    out[id] = fmax(val, 0.0f);\n"
    "}\n";

このカーネルをGPUで実行するには、デバイスを作成し、コマンドキュー(GPUは非同期である)を構築し、カーネルをコンパイルし、入出力用のバッファを作成し、最後にカーネルを実行するためにGPUにディスパッチする必要がある。GPUで加速された単純なReLU操作は次のようになるだろう。

// prepare device, queue, and compile kernel
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
id<MTLCommandQueue> queue = [device newCommandQueue];
NSError *err = nil;
id<MTLLibrary> library = [device newLibraryWithSource:[NSString stringWithUTF8String:shaderSource] options:nil error:&err];
id<MTLFunction> reluFn = [library newFunctionWithName:@"relu"];
id<MTLComputePipelineState> pipeline = [device newComputePipelineStateWithFunction:reluFn error:&err];

// prepare data, dispatch kernel
float input[8]  = {-2.0, -1.0, 0.0, 1.0, 2.0, -0.5, 3.0, -3.0};
float output[8] = {0};
id<MTLBuffer> bufIn = [device newBufferWithBytes:input length:sizeof(input) options:MTLResourceStorageModeShared];
id<MTLBuffer> bufOut = [device newBufferWithLength:sizeof(output) options:MTLResourceStorageModeShared];
id<MTLCommandBuffer> cmdBuf = [queue commandBuffer];
id<MTLComputeCommandEncoder> enc = [cmdBuf computeCommandEncoder];
[enc setComputePipelineState:pipeline];
[enc setBuffer:bufIn  offset:0 atIndex:0];
[enc setBuffer:bufOut offset:0 atIndex:1];
MTLSize gridSize = MTLSizeMake(8, 1, 1);
MTLSize tgSize  = MTLSizeMake(pipeline.maxTotalThreadsPerThreadgroup, 1, 1);
[enc dispatchThreads:gridSize threadsPerThreadgroup:tgSize];
[enc endEncoding];
[cmdBuf commit];
[cmdBuf waitUntilCompleted];
// copy results back
memcpy(output, bufOut.contents, sizeof(output));

このコードの最初の部分は、「Metalコンテキスト」構造体にラップできる。これは一度作成され、ライブラリ全体の存続期間中保持される。その後、バッファの割り当て、読み書き、カーネルのディスパッチを行うヘルパーを追加できる。公式のMetal APIはObjective-CまたはSwiftだが、低レベルのObjC ランタイム関数を使用してCから呼び出すことができ、ライブラリを純粋に保つことができる(コード全体でobjC_msgSendを使用)。

これで、テンソル上の各操作は2回実装する必要がある。単純なCPU実装とGPUカーネル実装である。テンソルの起源に応じて、どちらかの実装が呼び出される。これは、テンソルが「デバイス」フィールドを保持することも意味し、テンソルが割り当てられる際にデバイスを指定する必要があるということだ。CPUテンソルは通常のデータバッファのみを持つが、MetalテンソルはMetalバッファオブジェクトへのポインタも持つ。

GPUとCPUのバッファが乖離するタイミングを追跡する必要があることも重要になってくる。簡単な方法は、CPU/GPUバッファに「ダーティ」フラグを保持し、「同期」関数を提供して一方のバッファからもう一方へデータをコピーすることである。

一部の操作はGPUで実行できる、または実行すべきであるが、物事を単純化するために、CPUで作成してから処理を行い、GPUにデータを送信/コピーする場合もある。

全体として、以下の実装が必要になる。

static const char *_mtl_src = "..."; // MSL source code for all kernels
void *ut_mtl_init(); // create Metal context as a singleton
void ut_mtl_dispatch(void *ctx, char *kernel, void **bufs, int nbufs, void *bytes, int blen, int n); // dispatch kernel with buffers
void *ut_mtl_buf_alloc(void *ctx, void *data, int len); // allocate Metal buffer
void ut_mtl_buf_free(void *ctx, void *buf); // free Metal buffer
void ut_mtl_buf_read(void *ctx, void *buf, void *data, int len); // read Metal buffer to CPU
void ut_mtl_buf_write(void *ctx, void *buf, void *data, int len); // write CPU buffer to Metal

void ut_sync_cpu(ut_tensor *t); // sync CPU buffer from GPU
void ut_sync_gpu(ut_tensor *t); // sync GPU buffer from CPU
void ut_to_device(ut_tensor *t, ut_dev device); // move tensor to specified device (CPU/GPU)

要素ごとの操作とそのGPUカーネル等価物の実装が終わったら、すべてのニューラルネットワークのコアである行列乗算に進むことができる。

Matmul

その場で考えた統計によると、あらゆるニューラルネットワークのFLOPsの80%は行列乗算である。これらを正しく、かつ高速に実装することは、あらゆる深層学習フレームワークにとって極めて重要である。行列乗算の実装方法には多くの方法があり、最も効率的な方法は行列のサイズ、ハードウェア、メモリレイアウトに依存する。

[画像: Matrix multiplication]

まず、2つの2次元行列AとBの乗算の最も単純なケースを考える。ここでAは形状[M, K]、Bは形状[K, N]である。結果Cは形状[M, N]になる。単純な実装は次のようになるだろう。

void gemm(const float *A, const float *B, float *C,
          int m, int n, int k, bool ta, bool tb) {
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++) {
            float sum = 0.f;
            for (int l = 0; l < k; l++) {
                float a = ta ? A[l*m + i] : A[i*k + l];
                float b = tb ? B[j*k + l] : B[l*n + j];
                sum += a * b;
            }
            C[i*n + j] = sum;
        }
}

これは非常に遅いことは言うまでもない。3つのネストされたループがあり、キャッシュ最適化もない。Apple Siliconでは、Accelerateフレームワークのcblas_sgemmを直接置き換えることができる。これはAMX(行列コプロセッサ)を使用しており、32x32を超えるあらゆる行列に対して50〜100倍高速である。

cblas_sgemm(CblasRowMajor,
            ta ? CblasTrans : CblasNoTrans,
            tb ? CblasTrans : CblasNoTrans,
            m, n, k, 1.f,
            A, ta ? m : k,
            B, tb ? k : n,
            0.f, C, n);

しかし、さらに進んで、大規模な行列のためにMetalとGPUの行列乗算を使用することもできる。MetalにはMPSMatrixクラスと乗算を行ういくつかのメソッドが用意されている。しかし、これは2次元行列のみなので、2次元を超えるテンソルを処理するための独自のカーネルを実装する必要がある。

kernel void bmatmul(device
  const float * a, device
  const float * b_, device float * c,
    constant int * p, uint idx[[thread_position_in_grid]]) {
  int M = p[1], N = p[2], K = p[3];
  int tot = p[0] * M * N;
  if ((int) idx >= tot) return;
  int n = (int) idx % N, t = (int) idx / N, m = t % M, bat = t / M;
  float s = 0;
  int ao = bat * M * K + m * K, bo = bat * K * N + n;
  for (int k = 0; k < K; k++) s += a[ao + k] * b_[bo + k * N];
  c[idx] = s;
}

全体的なut_matmul関数は次のようになるだろう。

ut_tensor *ut_matmul(ut_tensor *a, ut_tensor *b) {
    // special case: 2D x 2D
    if (a->shape.ndim == 2 && b->shape.ndim == 2) {
        int n = ..., m = ..., k = ...; // dimensions: a: [m, k], b: [k, n]
        if (a->dev == UT_METAL || b->dev == UT_METAL) {
            // GPU matmul
            ut_tensor *out = ut_alloc(2, (int[]){m, n}, UT_METAL);
            ut_mtl_matmul(a, b, out);
            return out;
        } else {
            // CPU matmul
            ut_tensor *out = ut_alloc(2, (int[]){m, n}, UT_CPU);
            cblas_sgemm(CblasRowMajor,
                        CblasNoTrans, CblasNoTrans,
                        m, n, k, 1.f,
                        a->data, k,
                        b->data, n,
                        0.f, out->data, n);
            return out;
        }
    }
    // special case: 3D x 3D (batches)
    if (a->shape.ndim == 3 && b->shape.ndim == 3) {
        int B, n, m, k; // dimensions: a: [B, m, k], b: [B, k, n]
        // similarly, for Metal: call a custom kernel, for CPU - sgemm in a loop for each batch
    }
}

欠けているのは、転置行列の行列乗算である。以前、データコピーなしで行列を「転置」する方法(ストライドの更新のみ)を見つけたが、乗算のためにも特別な方法で処理すべきである。幸いなことに、すべての実装は、わずかなコード変更(cblas_sgemmのtaとtbフラグ、およびMetalカーネルの数行の追加)で転置をサポートしているように見える。

Autograd by hand

この時点で、テンソル上の算術演算を実行でき、新しい演算の追加はほとんど簡単になる。ニューラルネットワーク構築の良い基盤となるが、まだ重要な機能が一つ欠けている。それは適切な微分である。

ネットワークが「学習」するとき、損失関数を最小化するようにパラメータを調整する。これを行うには、パラメータに対する損失関数の勾配を計算する必要がある。ここで自動微分が通常使われる。PyTorchやTensorFlowのような「大きな」フレームワークでは、微分エンジンがフォワードパス中に計算グラフを記録し、その後逆方向にたどって勾配を計算する。私はもっと簡単なことをする、手動バックプロパゲーションを行う。ネットワークの各層は、「フォワード」関数と「バックワード」関数を持つ構造体になり、勾配は各学習可能パラメータと同じ形状のテンソルとして事前に割り当てられる。

フォワードパスは入力テンソルを受け取り、出力テンソルを生成する。バックワードパスは、出力テンソルに対する損失の勾配を受け取り、入力テンソルとパラメータに対する損失の勾配を計算する。これはオートグラッドほどユーザーフレンドリーではないかもしれないが、よく知られたネットワークアーキテクチャのほとんどではC言語での実装が容易である。

線形層から始めよう。これは、重み行列 NxM(Nは入力特徴数、Mは出力特徴数)と、オプションでバイアスベクトルで構成される。

typedef struct ut_linear {
  ut_tensor* weight;  // [in, out]
  ut_tensor* bias;    // [out]
  int nin, nout;
  bool has_bias;
} ut_linear;

フォワードパスは非常に単純である。行列乗算の後にバイアスベクトルを加算する(後でこれらの2つの操作を1つに融合して少し高速化することを検討するかもしれない)。

ut_tensor *ut_linear_forward(ut_linear *l, ut_tensor *x) {
    ut_tensor *out = ut_matmul(x, l->weight);   // [B, in] @ [in, out]
    if (l->bias)
        for (int b = 0; b < out->shape.shape[0]; b++)
            for (int j = 0; j < l->nout; j++)
                out->data[b * l->nout + j] += l->bias->data[j];
    return out;
}

実際には、Metal/非Metalの分岐があるためフォワードパスはより冗長になるが、ロジックは単純なままである。バックワードパスは少し難しく、入力とパラメータに対する勾配を計算する必要がある。

行列乗算のバックプロパゲーションに関する素晴らしい説明は、この記事で見つけることができる。数学に疎い私にとっては、PyTorchがどのように実装したかを読む方が簡単だった。

# forward(x: Tensor, w: Tensor): Tensor
y = x@w

# backward(dldy: Tensor): Tensor
dldx = dldy @ w.T
dldw = x.T @ dldy

バイアスを含めると、y=x@w+bとなり、dldbは単にdldyである。バイアスは加算操作なので、勾配はそのまま保持される。ミニバッチトレーニングの場合、バッチ次元全体で出力勾配を合計する必要があり、それがバイアス勾配となる。

ut_tensor *ut_linear_backward(ut_linear *l,
                                ut_tensor *x,
                                ut_tensor *grad_out,
                                ut_tensor *dW, ut_tensor *db) {
    // dW += x.T @ grad_out
    ut_tensor *xT    = ut_transpose(x, 0, 1);
    ut_tensor *dW_b  = ut_matmul(xT, grad_out);
    for (int i = 0; i < dW->shape.nelem; i++) dW->data[i] += dW_b->data[i];

    // db += colsum(grad_out)
    for (int b = 0; b < grad_out->shape.shape[0]; b++)
        for (int j = 0; j < l->nout; j++)
            db->data[j] += grad_out->data[b * l->nout + j];

    // dx = grad_out @ W.T 
    ut_tensor *WT = ut_transpose(l->weight, 0, 1);
    ut_tensor *dx = ut_matmul(grad_out, WT);

    ut_free(xT); ut_free(dW_b); ut_free(WT);
    return dx;
}

そして、ここでさらに最適化できる。バックワードパスでは、重み行列のマテリアライジング転置を行い、実質的にテンソル全体をコピーする。GPUアクセラレーションを使っても、まだ最適ではない。転置行列を入力として受け取る行列乗算の特別なケースを実装し、追加の割り当てとコピーを回避できる。ut_matmul_tである。

最後に、単純な全結合ニューラルネットワークを実装してトレーニングできる段階に達した。

Loss

何かを学習するには、善悪を判断できる必要がある。そこで損失関数が登場する。これは、予測が実際のラベルからどれだけ離れているかを測定する。分類タスクでは、一般的な損失関数はクロスエントロピーなので、そこから始める。

ネットワークは、各入力サンプルに対してクラスの確率分布を予測しようとする。クロスエントロピー損失は、予測された分布と真の分布(通常はワンホットエンコードされたベクトル)との差を測定する。

A loss can be calculated like this:

float cross_entropy_loss(ut_tensor *logits, const int *labels, int B) {
    float total = 0.f;
    int C = logits->shape.shape[1];
    for (int b = 0; b < B; b++) {
        float *row = logits->data + b * C;
        float mx = row[0];
        for (int j = 1; j < C; j++) if (row[j] > mx) mx = row[j];
        float sum = 0.f;
        for (int j = 0; j < C; j++) sum += expf(row[j] - mx);
        total += logf(sum) + mx - row[labels[b]];
    }
    return total / (float)B;
}

exp()の前にmax(row)を引くことでオーバーフローを防ぎ、すべての指数を1未満に保ち、exp(89)のようなfloat32範囲を簡単にオーバーフローさせるケースを防ぐ。

結果は数値であり、値が低いほどネットワークはよくトレーニングされていることになる。しかし、この値を使用して、バックプロパゲーションで使用されるロジットに対する損失の勾配を計算する必要もある。

// Backward: d_logits[b][j] = softmax[b][j] - (j == labels[b])
ut_tensor *cross_entropy_backward(ut_tensor *logits,
                                  const int *labels, int B) {
    int C = logits->shape.shape[1];
    ut_tensor *d = ut_like(logits);
    for (int b = 0; b < B; b++) {
        float *row  = logits->data + b * C;
        float *drow = d->data      + b * C;
        float mx = row[0];
        for (int j = 1; j < C; j++) if (row[j] > mx) mx = row[j];
        float sum = 0.f;
        for (int j = 0; j < C; j++) sum += expf(row[j] - mx);
        float ls = logf(sum) + mx;
        for (int j = 0; j < C; j++) drow[j] = expf(row[j] - ls) / (float)B;
        drow[labels[b]] -= 1.f / (float)B;
    }
    return d;
}

これは動作するが、さらに進んで、損失と勾配を単一のパスで計算する「融合」クロスエントロピー損失バージョンを実装できる。これはより効率的である。融合操作は深層学習フレームワークにおける一般的な最適化手法であり、適切なテンソルライブラリはそれらを多用する。

Optimiser

最適化といえば、バックプロパゲーション中に計算された勾配に基づいてモデルパラメータを更新するためのオプティマイザを実装する必要がある。

バックプロパゲーション中に計算された勾配は、損失を悪化させる方向を示している。モデルを改善するために、パラメータを逆方向に、ある「学習率」係数でスケーリングして移動させる。したがって、勾配はパラメータが損失にどれだけ影響を与えているか、そして損失を小さくするためにどの方向に移動させるかを示し、オプティマイザは各パラメータを実際にどのように更新するかを決定する。パラメータを小さすぎるとトレーニングに時間がかかり、大きすぎると「スイートスポット」を逃し、ネットワークの学習が不安定になる可能性がある。

最も単純なオプティマイザールールは、確率的勾配降下法(SGD)である。各パラメータを勾配に小さな数値(学習率)を掛けたもので調整する。

「モーメンタム」を追加することで、これをわずかに改善できる。勾配を直接追跡するのではなく、以前の更新を考慮に入れた速度ベクトルを蓄積する。これにより、振動が平滑化され、平坦な領域での加速が促進される。

さらに、勾配クリッピングを使用できる。いずれかの勾配成分が特定のしきい値を超えた場合は、それをクランプする。これにより、少数の悪い入力サンプルが残りのトレーニングを破壊するのを防ぐことができる。

void ut_sgd_step(ut_sgd* o, float clip) {
 for each parameter p, gradient g:
   g = clamp(g, -clip, clip)
   if momentum > 0: v = mom*v - lr*g;  p += v
   else:            p -= lr*g
   zero gradient for next iteration
}

Adamのようなより優れたオプティマイザもあるが、SGDはおそらく最初に実装するのが最も簡単なものである。

MNIST

MNISTデータセットは深層学習の「ハローワールド」である。60,000のトレーニング画像と10,000のテスト画像からなり、手書きの数字(0〜9)が各28x28ピクセルのグレースケール画像で構成されている。タスクは、各画像を10個の数字クラスのいずれかに分類することである。

[画像: MNIST example]

私たちのテンソルライブラリを実践的なタスクでテストする時が来た!

データセットのデータ形式は単純である。画像は生のバイト、ラベルは個別の単一バイトである。トレーニングには、ランダムなバッチを使用するためのシャッフルされたインデックスの配列が必要になる。それ以外は、非常に簡単である。

// Model: 784 -> 128 -> ReLU -> 10 (known to have good results)
ut_linear fc1 = ut_linear_alloc(784, 128, true, UT_CPU);
ut_linear fc2 = ut_linear_alloc(128, 10, true, UT_CPU);

// Optimiser: SGD + momentum
ut_tensor* params[] = {fc1.weight, fc1.bias, fc2.weight, fc2.bias};
ut_sgd opt = ut_sgd_alloc(params, 4, 0.01f, 0.9f);

// Batch of 64, 15 epochs, 60k / 64 = 937 batches
int B = 64, epochs = 15, batches = train.n / B;
ut_tensor* grad_logits = ut_alloc(2, (int[]){B, 10}, UT_CPU);
int* idx = malloc((size_t)train.n * sizeof(int));
for (int i = 0; i < train.n; i++) idx[i] = i;

for (int ep = 0; ep < epochs; ep++) {
  shuffle(idx, train.n);
  for (int bi = 0; bi < batches; bi++) {
    // pack batch from shuffled indices
    float bx[B * 784]; int bl[B];
    for (int i = 0; i < B; i++) {
      int ii = idx[bi * B + i];
      memcpy(bx + i * 784, train.imgs + ii * 784, 784 * sizeof(float));
      bl[i] = train.labels[ii];
    }
    ut_tensor* x = ut_from_data(2, (int[]){B, 784}, bx, UT_CPU);

    // forward
    ut_tensor *h1 = ut_linear_forward(&fc1, x);
    ut_tensor *h1r = ut_relu(h1);
    ut_tensor *logits = ut_linear_forward(&fc2, h1r);
    // loss + grad
    float loss = ut_cross_entropy(logits, bl, grad_logits);
    // backward
    ut_tensor* dh1r = ut_linear_backward(&fc2, h1r, grad_logits, opt.grads[2], opt.grads[3]);
    ut_tensor* dh1 = ut_relu_backward(dh1r, h1);
    ut_linear_backward(&fc1, x, dh1, opt.grads[0], opt.grads[1]);
    ut_sgd_step(&opt, 5.0f);
    ut_free(x); ut_free(h1); ut_free(h1r); ut_free(logits); ut_free(dh1r); ut_free(dh1);
  }
}

M1 MacBookで実行すると、エポックあたり0.8秒かかり、5エポック以内にトレーニングセットで99%の精度、テストセットで約97%の精度に達する。この小さなデータセットではCPUとGPUのパフォーマンスに違いはないが、より大きなモデルではGPUが有利になるだろう。

比較のために言うと、PyTorchは同じ精度を達成するが、エポックあたり約2秒かかる。他の、より大きなモデルでは、C言語はPyTorchよりも通常2〜4倍高速であることがわかった。特に、ほとんどの操作が適切に融合されている場合である。

What’s next?

これは最小限のものである。本格的なテンソルライブラリには、さらに多くのレイヤーと操作が必要になるが、それらの追加は些細な(ただし、退屈な)プロセスである。CPU実装を追加し、GPUカーネルを追加し、ディスパッチラッパーを作成する(単項/二項ディスパッチ、またはカスタムディスパッチを呼び出す)。バックワードパスを追加する。

例えば、gelu(または他のアクティベーションレイヤー)を追加するのは、約20行のコードである。

私にとっての主な目標は、MacBookでtinyML/edgeAIモデルをトレーニングするための基盤を構築することだった。そして、これまでのところ気に入っている。完全なライブラリには、畳み込みレイヤー(画像処理用)、プーリング、バッチ正規化、ドロップアウト、さらにいくつかのオプティマイザと損失関数が含まれている。テンソルを生のバイナリファイルにロード/保存でき、CIFAR、HAR、音声コマンドなどのトイデータセットで良好なパフォーマンスを発揮する。

OpenCLバックエンドを追加して、さらに多くのデバイスをサポートし、いくつかの最適化を追加することを検討している。

GPT2のような小さなトランスフォーマーを、minGPTのようにトレーニングすることさえできた。

何が欠けているか?オートグラッドは間違いなく惜しい。手動バックプロパゲーションは面倒になることがある。後で追加するかもしれない。すでにすべてのバックワード関数を実装しているので、「テープ」を追加してすべての操作を保存し、適切な順序で勾配を計算するためにトポロジーソートを行うことができる。しかし、今のところ、それなしでもやっていける。

また、シングルヘッダー、ヘッダーオンリーのテンソルライブラリであることの意図的な制限により、CUDAのサポートを犠牲にした。CUDAはカーネルを.cuファイルに保存し、nvccでコンパイルする必要がある(私が知らない他の方法がない限り)。WebGPUアクセラレーションも可能かもしれない。まだ調べていないが、非同期の性質と比較的未熟な状態は私に疑問を抱かせる。

C言語の選択は気に入っている。ユーザーがすべてのメモリ操作と最適化を完全に制御できる。他の言語へのバインディングについても少し実験した。C++は簡単だった。すべてのC APIをクラスにラップするだけで、演算子オーバーロードのおかげでコードは突然短く、読みやすくなった。Goバインディングも試したが、CGoのオーバーヘッドにより、正当化するのが少し難しくなった。

これはPyTorchの競合相手ではない。これは、半分真面目なアンチPyTorchであり、ざっと見て理解できるほど小さく、しかし様々なモデルを構築してトレーニングするのに十分実用的である。

完全なライブラリはhttps://github.com/zserge/utensilで入手可能であり、この長い投稿が興味をそそったなら、リポジトリをクローンして、レイヤーを追加し、モデルをトレーニングし、壊してデバッグしてみてほしい。貢献やフィードバックはいつでも歓迎する。

この記事を楽しんでいただけたなら幸いです。GitHub、Mastodon、Twitterでフォロー(および貢献)するか、RSSで購読できます。

2026年7月14日

関連記事:AI or ain't: Neural Networks および more