「SINQ」を編集中

'''SINQ''' (SInkhorn Normalized Quantization) とは、[[Huawei]]が2025年に発表した新しい[[オープンソース]]な[[量子化アルゴリズム]]です。[[大規模言語モデル]]（LLM）の重みを低精度に変換しつつ、性能をほとんど落とさずに[[メモリ]]使用量を大幅に削減できるのが特徴です。

== 特徴 ==
* デュアルスケーリング：行方向と列方向に別々のスケールを導入し、外れ値の影響を分散。
* Sinkhorn型正規化：行・列を交互に正規化して分散を均一化し、量子化誤差を抑制。
* 低ビット量子化：3〜4bitでも高精度を維持可能。
* 効果：メモリ使用量を60〜70%削減し、安価なGPUや低性能ハードでも大規模モデルを動作可能に。

== 擬似コード ==
人工知能以外でも使えそうなので調べてみた。
<source lang=csharp>
// SINQ量子化の擬似コード（C#風）

class SinqQuantizer
{
    public int BitWidth { get; set; } = 4;   // 量子化ビット幅（例: 3bit, 4bit）
    public int SinkhornIters { get; set; } = 20; // Sinkhorn反復回数
    public float Eps { get; set; } = 1e-6f;  // 数値安定用

    // 重み行列Wを量子化
    public QuantizedMatrix Quantize(float[,] W)
    {
        // 1. 行・列スケールをSinkhorn正規化で計算
        var (rowScale, colScale) = ComputeDualScaling(W);

        // 2. スケーリングを適用
        float[,] S = ApplyScaling(W, rowScale, colScale);

        // 3. ブロックごとに量子化（例: 行単位）
        var blocks = PartitionByRow(S);
        var qBlocks = new List<QuantizedBlock>();

        foreach (var block in blocks)
        {
            var stats = ComputeRange(block);       // min/maxやscaleを計算
            var qBlock = QuantizeBlock(block, stats, BitWidth);
            qBlocks.Add(qBlock);
        }

        return new QuantizedMatrix
        {
            RowScale = rowScale,
            ColScale = colScale,
            Blocks = qBlocks,
            BitWidth = BitWidth
        };
    }

    // Sinkhorn型の行列正規化
    private (float[] rowScale, float[] colScale) ComputeDualScaling(float[,] W)
    {
        int R = W.GetLength(0);
        int C = W.GetLength(1);
        float[] r = Enumerable.Repeat(1f, R).ToArray();
        float[] c = Enumerable.Repeat(1f, C).ToArray();

        for (int t = 0; t < SinkhornIters; t++)
        {
            // 行方向の正規化
            for (int i = 0; i < R; i++)
            {
                float variance = RowVariance(W, i, c);
                r[i] = 1.0f / (float)Math.Sqrt(variance + Eps);
            }

            // 列方向の正規化
            for (int j = 0; j < C; j++)
            {
                float variance = ColVariance(W, j, r);
                c[j] = 1.0f / (float)Math.Sqrt(variance + Eps);
            }
        }
        return (r, c);
    }

    // スケーリング適用
    private float[,] ApplyScaling(float[,] W, float[] r, float[] c)
    {
        int R = W.GetLength(0);
        int C = W.GetLength(1);
        float[,] S = new float[R, C];
        for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            S[i, j] = r[i] * W[i, j] * c[j];
        return S;
    }

    // ブロック分割（例: 行単位）
    private IEnumerable<float[]> PartitionByRow(float[,] S)
    {
        int R = S.GetLength(0);
        int C = S.GetLength(1);
        for (int i = 0; i < R; i++)
        {
            float[] row = new float[C];
            for (int j = 0; j < C; j++) row[j] = S[i, j];
            yield return row;
        }
    }

    // 範囲計算（min/max）
    private (float min, float max, float scale) ComputeRange(float[] block)
    {
        float min = block.Min();
        float max = block.Max();
        float scale = (max - min) / ((1 << BitWidth) - 1);
        return (min, max, scale);
    }

    // ブロック量子化
    private QuantizedBlock QuantizeBlock(float[] block, (float min, float max, float scale) stats, int bits)
    {
        int n = block.Length;
        byte[] qVals = new byte[n];
        for (int i = 0; i < n; i++)
        {
            int q = (int)Math.Round((block[i] - stats.min) / stats.scale);
            qVals[i] = (byte)Math.Clamp(q, 0, (1 << bits) - 1);
        }
        return new QuantizedBlock { Values = qVals, Stats = stats };
    }
}

// データ構造
class QuantizedMatrix
{
    public float[] RowScale;
    public float[] ColScale;
    public List<QuantizedBlock> Blocks;
    public int BitWidth;
}

class QuantizedBlock
{
    public byte[] Values;
    public (float min, float max, float scale) Stats;
}
</source>

== 外部リンク ==
* https://www.arxiv.org/abs/2509.22944
* 

[[category: 大規模言語モデル]]
[[category: 量子化アルゴリズム]]