[통산 210편 금자탑 달성 🏆] 초·중·고 인공지능(AI) 비전 트랜스포머(ViT) 교육과 국방 복합 광학(EO/IR) 다중 모달리티 표적 획득: ZeliDesk의 온디바이스 순수 C# ViT 패치 임베딩, 교차 어텐션(Cross-Attention) 0-Alloc SIMD 텐서 코어, 및 안개·야간 투과 120fps 실시간 멀티스펙트럴 퓨전 추적 아키텍처

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
using System.Threading.Tasks;

namespace ZeliDesk.Core.AI.VisionTransformer
{
    public sealed unsafe class CrossAttentionEngine
    {
        private readonly int _seqLen;   // 패치 시퀀스 길이 (예: 196)
        private readonly int _dim;      // 특징 차원 (예: 256)
        private readonly int _headDim;  // 헤드별 차원 (예: 64)
        private readonly int _heads;    // 멀티헤드 수 (예: 4)
        private readonly float _scale;

        public CrossAttentionEngine(int seqLen, int dim, int heads)
        {
            _seqLen = seqLen;
            _dim = dim;
            _heads = heads;
            _headDim = dim / heads;
            _scale = 1.0f / MathF.Sqrt(_headDim);
        }

        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ComputeCrossAttention(
            ReadOnlySpan qEO, 
            ReadOnlySpan kIR, 
            ReadOnlySpan vIR, 
            Span outFused)
        {
            int seq = _seqLen;
            int hDim = _headDim;
            float scale = _scale;

            fixed (float* pQ = qEO)
            fixed (float* pK = kIR)
            fixed (float* pV = vIR)
            fixed (float* pOut = outFused)
            {
                // 각 어텐션 헤드별 병렬 가속
                Parallel.For(0, _heads, h =>
                {
                    int headOffset = h * hDim;
                    float* scores = stackalloc float[seq];

                    for (int i = 0; i < seq; i++)
                    {
                        float* qRow = pQ + i * _dim + headOffset;

                        // 1. Q * K^T 스케일드 닷 프로덕트 (AVX2 SIMD 가속)
                        float maxVal = float.NegativeInfinity;
                        for (int j = 0; j < seq; j++)
                        {
                            float* kRow = pK + j * _dim + headOffset;
                            float dot = DotProductSimd(qRow, kRow, hDim) * scale;
                            scores[j] = dot;
                            if (dot > maxVal) maxVal = dot;
                        }

                        // 2. 수치적 안정 Softmax (Online Exponent Sum)
                        float sumExp = 0.0f;
                        for (int j = 0; j < seq; j++)
                        {
                            float expVal = MathF.Exp(scores[j] - maxVal);
                            scores[j] = expVal;
                            sumExp += expVal;
                        }

                        float invSum = 1.0f / (sumExp + 1e-6f);
                        for (int j = 0; j < seq; j++) scores[j] *= invSum;

                        // 3. Softmax Scores * V 어텐션 출력 누적
                        float* outRow = pOut + i * _dim + headOffset;
                        for (int d = 0; d < hDim; d++) outRow[d] = 0f;

                        for (int j = 0; j < seq; j++)
                        {
                            float weight = scores[j];
                            float* vRow = pV + j * _dim + headOffset;
                            Vector256 wVec = Vector256.Create(weight);

                            for (int d = 0; d < hDim; d += 8)
                            {
                                Vector256 vVec = Avx.LoadVector256(vRow + d);
                                Vector256 curOut = Avx.LoadVector256(outRow + d);
                                Vector256 res = Avx.Add(curOut, Avx.Multiply(wVec, vVec));
                                Avx.Store(outRow + d, res);
                            }
                        }
                    }
                });
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static float DotProductSimd(float* a, float* b, int count)
        {
            Vector256 sum = Vector256.Zero;
            for (int i = 0; i < count; i += 8)
            {
                Vector256 va = Avx.LoadVector256(a + i);
                Vector256 vb = Avx.LoadVector256(b + i);
                sum = Avx.Add(sum, Avx.Multiply(va, vb));
            }
            Vector128 lo = sum.GetLower();
            Vector128 hi = sum.GetUpper();
            Vector128 s128 = Sse.Add(lo, hi);
            s128 = Sse3.HorizontalAdd(s128, s128);
            s128 = Sse3.HorizontalAdd(s128, s128);
            return s128.ToScalar();
        }
    }
}