초·중·고 인공지능(AI) 신경망 양자화(Quantization)·가지치기(Pruning) 탐구 교육과 국방 초소형 엣지 NPU 탑재: ZeliDesk의 온디바이스 순수 C# INT4/INT8 대칭·비대칭 양자화, 2:4 구조적 희소성(Structured Sparsity), 및 0-Alloc SIMD 가중치 압축 추론 엔진 아키텍처

4. 순수 C# 온디바이스 INT8/INT4 & 2:4 희소성 추론 엔진 구현

힙 메모리 할당 0 Byte, 니블 비트 패킹, 및 AVX2 SIMD 정수 가속을 결합한 순수 C# .NET 9 신경망 연산 커널 구현부입니다.

using System;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

namespace ZeliDesk.Core.Neural
{
    public readonly struct QuantizedTensorInt8
    {
        public readonly sbyte[] Data;
        public readonly float Scale;
        public readonly sbyte ZeroPoint;

        public QuantizedTensorInt8(sbyte[] data, float scale, sbyte zeroPoint)
        {
            Data = data; Scale = scale; ZeroPoint = zeroPoint;
        }

        // FP32 -> INT8 대칭형 양자화 (0-Alloc 루프)
        public static QuantizedTensorInt8 QuantizeSymmetric(ReadOnlySpan src)
        {
            float maxAbs = 0f;
            for (int i = 0; i < src.Length; i++)
            {
                float abs = Math.Abs(src[i]);
                if (abs > maxAbs) maxAbs = abs;
            }

            float scale = maxAbs / 127f;
            float invScale = scale > 1e-8f ? 1f / scale : 0f;

            sbyte[] dst = new sbyte[src.Length];
            for (int i = 0; i < src.Length; i++)
            {
                int q = (int)Math.Round(src[i] * invScale);
                dst[i] = (sbyte)Math.Clamp(q, -127, 127);
            }

            return new QuantizedTensorInt8(dst, scale, 0);
        }
    }

    public sealed class Sparse24Engine
    {
        // 2:4 구조적 희소성 압축: 4개 중 2개만 보존하고 인덱스 4비트 패킹
        public static void Compress24Symmetric(
            ReadOnlySpan denseWeights, 
            Span sparseWeights, 
            Span indexMetadata)
        {
            int numBlocks = denseWeights.Length / 4;

            for (int b = 0; b < numBlocks; b++)
            {
                int inIdx = b * 4;
                int outIdx = b * 2;

                sbyte w0 = denseWeights[inIdx + 0];
                sbyte w1 = denseWeights[inIdx + 1];
                sbyte w2 = denseWeights[inIdx + 2];
                sbyte w3 = denseWeights[inIdx + 3];

                int a0 = Math.Abs(w0); int a1 = Math.Abs(w1);
                int a2 = Math.Abs(w2); int a3 = Math.Abs(w3);

                // 절댓값 상위 2개 추출 (간이 분기 최적화)
                int idxA = 0, idxB = 1;
                sbyte valA = w0, valB = w1;
                int maxA = a0, maxB = a1;

                if (maxB > maxA) { (idxA, idxB) = (idxB, idxA); (valA, valB) = (valB, valA); (maxA, maxB) = (maxB, maxA); }

                if (a2 > maxB)
                {
                    if (a2 > maxA) { idxB = idxA; valB = valA; maxB = maxA; idxA = 2; valA = w2; maxA = a2; }
                    else { idxB = 2; valB = w2; maxB = a2; }
                }
                if (a3 > maxB)
                {
                    if (a3 > maxA) { idxB = idxA; valB = valA; idxA = 3; valA = w3; }
                    else { idxB = 3; valB = w3; }
                }

                sparseWeights[outIdx + 0] = valA;
                sparseWeights[outIdx + 1] = valB;

                // 2비트 인덱스 2개를 1개 바이트 하위 4비트에 압축 (idxA | (idxB << 2))
                indexMetadata[b] = (byte)((idxA & 0x03) | ((idxB & 0x03) << 2));
            }
        }

        // AVX2 정수 가속 2:4 희소 행렬-벡터 곱셈 (SpMV)
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void SparseGemvInt8(
            ReadOnlySpan sparseWeights, 
            ReadOnlySpan indexMetadata, 
            ReadOnlySpan inputVec, 
            Span outputAcc, 
            int rows, int cols)
        {
            int blocksPerCol = cols / 4;

            fixed (sbyte* pWeight = sparseWeights)
            fixed (byte* pMeta = indexMetadata)
            fixed (sbyte* pInput = inputVec)
            {
                for (int r = 0; r < rows; r++)
                {
                    int rowWeightOffset = r * (cols / 2);
                    int rowMetaOffset = r * blocksPerCol;
                    int sum = 0;

                    for (int b = 0; b < blocksPerCol; b++)
                    {
                        byte meta = pMeta[rowMetaOffset + b];
                        int idxA = meta & 0x03;
                        int idxB = (meta >> 2) & 0x03;

                        sbyte wA = pWeight[rowWeightOffset + (b * 2) + 0];
                        sbyte wB = pWeight[rowWeightOffset + (b * 2) + 1];

                        sbyte inA = pInput[(b * 4) + idxA];
                        sbyte inB = pInput[(b * 4) + idxB];

                        sum += (wA * inA) + (wB * inB);
                    }

                    outputAcc[r] = sum;
                }
            }
        }
    }
}