GPT 아키텍처 완전 분석: 수학적 기초부터 실제 구현까지

2.1 기본 하이퍼파라미터와 표기법

본 절에서는 GPT 아키텍처의 수학적 분석에 필요한 표기법을 정의한다. 모든 표기법은 Vaswani et al. (2017)^[1]과 Radford et al. (2019)^[2]의 관례를 따른다.

2.2 텐서 정의와 차원 분석

2.3 중간 표현 텐서들

// advanced_tensor.hpp - 차원 안전 텐서 클래스
class AdvancedTensor {
private:
    std::vector<float> data_;           // 실제 데이터 저장
    std::vector<int> shape_;            // 각 차원의 크기
    std::vector<int> strides_;          // 메모리 레이아웃 정보
    
public:
    // 생성자: 차원 정보와 함께 텐서 생성
    AdvancedTensor(const std::vector<int>& shape) 
        : shape_(shape) {
        int total_size = 1;
        for (int dim : shape_) total_size *= dim;
        data_.resize(total_size, 0.0f);
        compute_strides();  // 효율적인 메모리 접근을 위한 stride 계산
    }
    
    // 안전한 인덱싱: 차원 경계 검사 포함
    float& at(const std::vector<int>& indices) {
        assert(indices.size() == shape_.size());
        int linear_index = 0;
        for (size_t i = 0; i < indices.size(); ++i) {
            assert(indices[i] >= 0 && indices[i] < shape_[i]);
            linear_index += indices[i] * strides_[i];
        }
        return data_[linear_index];
    }
    
    // 차원 정보 접근
    const std::vector<int>& shape() const { return shape_; }
    int numel() const { return data_.size(); }  // 총 원소 개수
};
        

2.4 메모리 레이아웃과 성능 최적화

구현 참조: back/advanced_tensor.cpp의 AdvancedTensor 클래스가 메모리 정렬과 캐시 최적화를 고려한 텐서 연산을 제공한다.

3.1 토큰화의 정보 압축 이론

// 최적화된 BPE 토큰화 구현
class OptimizedBPETokenizer {
private:
    std::unordered_map<std::string, int> vocab_map;
    std::vector<std::string> id_to_token;
    std::vector<std::pair<std::string, std::string>> bpe_merges;
    int vocab_size;
    
public:
    OptimizedBPETokenizer(const std::string& vocab_file, 
                         const std::string& merges_file) {
        load_vocabulary(vocab_file);
        load_merges(merges_file);
        vocab_size = vocab_map.size();
    }
    
    // O(n log n) 시간복잡도의 최적화된 인코딩
    std::vector<int> encode(const std::string& text) {
        auto words = pre_tokenize(text);
        std::vector<int> token_ids;
        token_ids.reserve(words.size() * 1.5);  // 예상 크기 사전 할당
        
        for (const auto& word : words) {
            auto word_tokens = encode_word(word);
            token_ids.insert(token_ids.end(), 
                           word_tokens.begin(), word_tokens.end());
        }
        return token_ids;
    }
    
private:
    std::vector<int> encode_word(const std::string& word) {
        if (word.empty()) return {};
        
        std::vector<std::string> subwords = {word};
        
        // BPE 병합 규칙 적용
        for (const auto& merge : bpe_merges) {
            apply_merge(subwords, merge.first, merge.second);
        }
        
        // 토큰 ID로 변환
        std::vector<int> ids;
        for (const auto& subword : subwords) {
            auto it = vocab_map.find(subword);
            ids.push_back(it != vocab_map.end() ? it->second : vocab_map["<unk>"]);
        }
        return ids;
    }
};

3.2 토큰 임베딩의 기하학적 해석

// 고성능 토큰 임베딩 클래스
class TokenEmbedding {
private:
    AdvancedTensor embedding_weights;  // [vocab_size, d_model]
    int vocab_size, d_model;
    float embedding_scale;
    
public:
    TokenEmbedding(int vocab_size, int d_model) 
        : vocab_size(vocab_size), d_model(d_model) {
        embedding_weights = AdvancedTensor({vocab_size, d_model});
        embedding_scale = 1.0f;  // GPT-2는 스케일링 없음
        
        // Improved Xavier initialization for stability
        float xavier_std = sqrt(2.0f / (vocab_size + d_model));
        embedding_weights.normal_(0.0f, xavier_std);
    }
    
    // 최적화된 임베딩 룩업 (O(L) 시간복잡도)
    AdvancedTensor forward(const std::vector<int>& token_ids) {
        int seq_len = token_ids.size();
        auto output = AdvancedTensor({seq_len, d_model});
        
        const float* emb_data = embedding_weights.data();
        float* out_data = output.data();
        
        // 메모리 지역성을 고려한 배치 복사
        for (int i = 0; i < seq_len; ++i) {
            int token_id = token_ids[i];
            if (token_id >= 0 && token_id < vocab_size) {
                const float* src = emb_data + token_id * d_model;
                float* dst = out_data + i * d_model;
                
                // SIMD 최적화된 메모리 복사
                std::memcpy(dst, src, d_model * sizeof(float));
            } else {
                // Unknown token handling
                std::fill_n(out_data + i * d_model, d_model, 0.0f);
            }
        }
        
        return output;
    }
    
    // 임베딩 가중치 정규화 (훈련 안정성)
    void normalize_weights(float max_norm = 1.0f) {
        float* data = embedding_weights.data();
        for (int i = 0; i < vocab_size; ++i) {
            float* row = data + i * d_model;
            float norm = 0.0f;
            
            // L2 norm 계산
            for (int j = 0; j < d_model; ++j) {
                norm += row[j] * row[j];
            }
            norm = sqrt(norm);
            
            // 정규화 적용
            if (norm > max_norm) {
                float scale = max_norm / norm;
                for (int j = 0; j < d_model; ++j) {
                    row[j] *= scale;
                }
            }
        }
    }
};

3.3 위치 인코딩의 주파수 분석

// GPT-2 스타일 학습 가능한 위치 임베딩
class LearnablePositionalEmbedding {
private:
    AdvancedTensor position_embeddings;  // [max_seq_len, d_model]
    int max_seq_len, d_model;
    
public:
    LearnablePositionalEmbedding(int max_seq_len, int d_model)
        : max_seq_len(max_seq_len), d_model(d_model) {
        position_embeddings = AdvancedTensor({max_seq_len, d_model});
        
        // 작은 표준편차로 초기화 (일반적으로 0.02)
        position_embeddings.normal_(0.0f, 0.02f);
    }
    
    AdvancedTensor forward(int seq_len) {
        assert(seq_len <= max_seq_len && "Sequence length exceeds maximum");
        
        // 시퀀스 길이만큼 위치 임베딩 슬라이스
        auto output = AdvancedTensor({seq_len, d_model});
        const float* pos_data = position_embeddings.data();
        float* out_data = output.data();
        
        // 효율적인 메모리 복사
        size_t copy_size = seq_len * d_model * sizeof(float);
        std::memcpy(out_data, pos_data, copy_size);
        
        return output;
    }
    
    // 토큰 임베딩과 위치 임베딩 결합
    AdvancedTensor add_to_embeddings(const AdvancedTensor& token_embeddings) {
        auto shape = token_embeddings.shape();
        int seq_len = shape[0];  // [seq_len, d_model] 가정
        
        auto pos_emb = forward(seq_len);
        return token_embeddings + pos_emb;  // element-wise addition
    }
    
    // 위치 임베딩 정규화 (옵션)
    void apply_weight_decay(float decay_rate) {
        float* data = position_embeddings.data();
        int total_elements = position_embeddings.numel();
        
        for (int i = 0; i < total_elements; ++i) {
            data[i] *= (1.0f - decay_rate);
        }
    }
};

3.4 드롭아웃과 정규화 기법

// 수치적으로 안정한 드롭아웃 구현
class EmbeddingDropout {
private:
    float dropout_prob;
    std::mt19937 rng;
    std::uniform_real_distribution<float> uniform_dist;
    bool training_mode;
    
public:
    EmbeddingDropout(float p = 0.1f) 
        : dropout_prob(p), uniform_dist(0.0f, 1.0f), training_mode(true) {
        rng.seed(std::random_device{}());
    }
    
    AdvancedTensor forward(const AdvancedTensor& input) {
        if (!training_mode || dropout_prob == 0.0f) {
            return input;  // 추론 모드에서는 드롭아웃 비활성화
        }
        
        auto output = input.clone();
        float* data = output.data();
        int total_elements = output.numel();
        float inv_keep_prob = 1.0f / (1.0f - dropout_prob);
        
        // 벡터화된 드롭아웃 적용
        #pragma omp parallel for
        for (int i = 0; i < total_elements; ++i) {
            if (uniform_dist(rng) < dropout_prob) {
                data[i] = 0.0f;
            } else {
                data[i] *= inv_keep_prob;  // 스케일 보정
            }
        }
        
        return output;
    }
    
    void set_training(bool training) {
        training_mode = training;
    }
    
    // 재현 가능한 결과를 위한 시드 설정
    void set_seed(unsigned int seed) {
        rng.seed(seed);
    }
};

3.5 계산 복잡도 및 최적화 전략

전체 구현 참조: back/advanced_gpt.hpp의 InputEmbedding 클래스가 본 섹션에서 설명한 모든 최적화 기법을 통합하여 구현한다.

4.1 Pre-LN vs Post-LN 아키텍처 비교 분석

// 수치적으로 안정한 Pre-LN 트랜스포머 블록
class PreLNTransformerBlock {
private:
    LayerNorm attn_ln, ffn_ln;
    MultiHeadAttention mha;
    FeedForwardNetwork ffn;
    float dropout_prob;
    
public:
    PreLNTransformerBlock(int d_model, int n_heads, int d_ff, float dropout = 0.1)
        : attn_ln(d_model), ffn_ln(d_model), 
          mha(d_model, n_heads, dropout), 
          ffn(d_model, d_ff, dropout),
          dropout_prob(dropout) {}
    
    AdvancedTensor forward(const AdvancedTensor& input, 
                          const AdvancedTensor& attention_mask = {},
                          bool training = true) {
        // 1단계: Self-Attention with residual connection
        auto attn_input = attn_ln.forward(input);
        auto attn_output = mha.forward(attn_input, attn_input, attn_input, 
                                     attention_mask, training);
        auto residual_1 = input + attn_output;  // 잔차 연결
        
        // 2단계: Feed-Forward with residual connection  
        auto ffn_input = ffn_ln.forward(residual_1);
        auto ffn_output = ffn.forward(ffn_input, training);
        auto residual_2 = residual_1 + ffn_output;  // 잔차 연결
        
        return residual_2;
    }
    
    // 그래디언트 흐름 분석을 위한 진단 함수
    std::map<std::string, float> analyze_gradient_flow(
        const AdvancedTensor& grad_output) {
        std::map<std::string, float> metrics;
        
        // 그래디언트 크기 측정
        metrics["grad_norm"] = grad_output.norm();
        metrics["grad_mean"] = grad_output.mean();
        metrics["grad_std"] = grad_output.std();
        
        return metrics;
    }
};

4.2 층 정규화의 수치적 안정성 분석

// 고정밀도 Layer Normalization 구현
class NumericallyStableLayerNorm {
private:
    int d_model;
    AdvancedTensor gamma, beta;  // 학습 가능한 매개변수
    float eps;
    
public:
    NumericallyStableLayerNorm(int d_model, float eps = 1e-5f)
        : d_model(d_model), eps(eps) {
        // γ = 1, β = 0으로 초기화
        gamma = AdvancedTensor({d_model});
        beta = AdvancedTensor({d_model});
        gamma.fill_(1.0f);
        beta.fill_(0.0f);
    }
    
    AdvancedTensor forward(const AdvancedTensor& input) {
        auto shape = input.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        auto output = AdvancedTensor(shape);
        const float* in_data = input.data();
        float* out_data = output.data();
        const float* gamma_data = gamma.data();
        const float* beta_data = beta.data();
        
        // 각 토큰별로 정규화 적용
        for (int b = 0; b < batch_size; ++b) {
            for (int t = 0; t < seq_len; ++t) {
                const float* x = in_data + (b * seq_len + t) * d_model;
                float* y = out_data + (b * seq_len + t) * d_model;
                
                // Welford 알고리즘으로 안정한 평균/분산 계산
                float mean = 0.0f;
                float m2 = 0.0f;
                
                // 온라인 평균 계산
                for (int i = 0; i < d_model; ++i) {
                    float delta = x[i] - mean;
                    mean += delta / (i + 1);
                    float delta2 = x[i] - mean;
                    m2 += delta * delta2;
                }
                
                float variance = m2 / d_model;
                float inv_std = 1.0f / std::sqrt(variance + eps);
                
                // 정규화 적용
                for (int i = 0; i < d_model; ++i) {
                    y[i] = gamma_data[i] * (x[i] - mean) * inv_std + beta_data[i];
                }
            }
        }
        
        return output;
    }
    
    // 역전파를 위한 그래디언트 계산
    std::tuple<AdvancedTensor, AdvancedTensor, AdvancedTensor> 
    backward(const AdvancedTensor& grad_output, const AdvancedTensor& input) {
        // 입력, γ, β에 대한 그래디언트 계산
        auto grad_input = AdvancedTensor(input.shape());
        auto grad_gamma = AdvancedTensor({d_model});
        auto grad_beta = AdvancedTensor({d_model});
        
        // 복잡한 그래디언트 계산 (수치적 안정성 고려)
        // ... 구현 생략 ...
        
        return std::make_tuple(grad_input, grad_gamma, grad_beta);
    }
};

4.3 잔차 연결의 이론적 분석

// 메모리 효율적인 잔차 연결 구현
class OptimizedResidualConnection {
public:
    // In-place 잔차 연결 (메모리 효율성)
    static void add_residual_inplace(AdvancedTensor& output, 
                                   const AdvancedTensor& residual) {
        assert(output.shape() == residual.shape());
        
        float* out_data = output.data();
        const float* res_data = residual.data();
        int total_elements = output.numel();
        
        // SIMD 최적화된 벡터 덧셈
        #pragma omp parallel for simd
        for (int i = 0; i < total_elements; ++i) {
            out_data[i] += res_data[i];
        }
    }
    
    // 그래디언트 흐름 안정성 측정
    static float measure_gradient_stability(const AdvancedTensor& grad_input,
                                          const AdvancedTensor& grad_output) {
        float input_norm = grad_input.norm();
        float output_norm = grad_output.norm();
        
        // 그래디언트 비율 (1.0에 가까울수록 안정)
        return input_norm / (output_norm + 1e-8f);
    }
    
    // 활성화 분산 분석
    static float analyze_activation_variance(const AdvancedTensor& activations) {
        float mean = activations.mean();
        float variance = 0.0f;
        
        const float* data = activations.data();
        int total_elements = activations.numel();
        
        for (int i = 0; i < total_elements; ++i) {
            float diff = data[i] - mean;
            variance += diff * diff;
        }
        
        return variance / total_elements;
    }
};

4.4 트랜스포머 블록의 복잡도 분석

참고문헌: Pre-LN 구조의 이론적 분석은 Xiong et al. (2020)^[8]과 Wang et al. (2019)^[5]의 연구를 기반으로 한다.

5.1 Self-Attention의 정보 이론적 기초

// 수치적으로 안정한 Attention 구현
class ScaledDotProductAttention {
private:
    float scale_factor;
    float dropout_prob;
    
public:
    ScaledDotProductAttention(int d_k, float dropout = 0.1f) 
        : scale_factor(1.0f / std::sqrt(d_k)), dropout_prob(dropout) {}
    
    AdvancedTensor forward(const AdvancedTensor& Q, 
                          const AdvancedTensor& K, 
                          const AdvancedTensor& V,
                          const AdvancedTensor& mask = {},
                          bool training = true) {
        // Q, K, V shape: [batch, heads, seq_len, d_k]
        auto shape = Q.shape();
        int batch_size = shape[0];
        int num_heads = shape[1]; 
        int seq_len = shape[2];
        int d_k = shape[3];
        
        // 1단계: QK^T 계산 및 스케일링
        auto scores = Q.matmul(K.transpose(-2, -1)) * scale_factor;
        
        // 2단계: Causal Mask 적용 (GPT의 핵심)
        if (!mask.empty()) {
            scores = scores + mask;  // -inf로 미래 토큰 차단
        }
        
        // 3단계: 수치적으로 안정한 Softmax
        auto attention_weights = stable_softmax(scores);
        
        // 4단계: Dropout 적용 (훈련 시)
        if (training && dropout_prob > 0.0f) {
            attention_weights = apply_dropout(attention_weights, dropout_prob);
        }
        
        // 5단계: Value와 가중합
        auto output = attention_weights.matmul(V);
        
        return output;
    }
    
private:
    AdvancedTensor stable_softmax(const AdvancedTensor& input) {
        // LogSumExp trick으로 수치적 안정성 확보
        auto max_vals = input.max(-1, true);  // 각 행의 최대값
        auto shifted = input - max_vals;      // 오버플로우 방지
        auto exp_vals = shifted.exp();
        auto sum_exp = exp_vals.sum(-1, true);
        return exp_vals / sum_exp;
    }
};

5.2 Multi-Head Attention의 표현력 분석

// 메모리 효율적인 Multi-Head Attention 구현
class MultiHeadAttention {
private:
    int d_model, num_heads, d_k;
    LinearLayer W_Q, W_K, W_V, W_O;
    ScaledDotProductAttention attention;
    
public:
    MultiHeadAttention(int d_model, int num_heads, float dropout = 0.1f)
        : d_model(d_model), num_heads(num_heads), 
          d_k(d_model / num_heads),
          W_Q(d_model, d_model), W_K(d_model, d_model), 
          W_V(d_model, d_model), W_O(d_model, d_model),
          attention(d_k, dropout) {
        
        assert(d_model % num_heads == 0);
        
        // Xavier 초기화 for stable training
        float std = std::sqrt(2.0f / d_model);
        W_Q.init_weights(std);
        W_K.init_weights(std);
        W_V.init_weights(std);
        W_O.init_weights(std);
    }
    
    AdvancedTensor forward(const AdvancedTensor& input,
                          const AdvancedTensor& causal_mask = {},
                          bool training = true) {
        auto shape = input.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // 1단계: Q, K, V 계산
        auto Q = W_Q.forward(input);  // [batch, seq_len, d_model]
        auto K = W_K.forward(input);
        auto V = W_V.forward(input);
        
        // 2단계: 다중 헤드로 재구성
        Q = reshape_for_heads(Q);  // [batch, num_heads, seq_len, d_k]
        K = reshape_for_heads(K);
        V = reshape_for_heads(V);
        
        // 3단계: Scaled Dot-Product Attention
        auto attention_output = attention.forward(Q, K, V, causal_mask, training);
        
        // 4단계: 헤드 병합
        attention_output = merge_heads(attention_output);  // [batch, seq_len, d_model]
        
        // 5단계: 최종 투영
        auto output = W_O.forward(attention_output);
        
        return output;
    }
    
private:
    AdvancedTensor reshape_for_heads(const AdvancedTensor& tensor) {
        auto shape = tensor.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // [batch, seq_len, d_model] → [batch, seq_len, num_heads, d_k]
        auto reshaped = tensor.view({batch_size, seq_len, num_heads, d_k});
        
        // [batch, seq_len, num_heads, d_k] → [batch, num_heads, seq_len, d_k]
        return reshaped.transpose(1, 2);
    }
    
    AdvancedTensor merge_heads(const AdvancedTensor& tensor) {
        auto shape = tensor.shape();
        int batch_size = shape[0];
        int seq_len = shape[2];
        
        // [batch, num_heads, seq_len, d_k] → [batch, seq_len, num_heads, d_k]
        auto transposed = tensor.transpose(1, 2);
        
        // [batch, seq_len, num_heads, d_k] → [batch, seq_len, d_model]
        return transposed.contiguous().view({batch_size, seq_len, d_model});
    }
};

5.4 Causal Masking의 정보 이론적 분석

// 메모리 효율적인 Causal Mask 생성
class CausalMaskGenerator {
public:
    // 삼각 마스크 생성 (한 번만 계산, 재사용)
    static AdvancedTensor create_causal_mask(int seq_len, float mask_value = -1e9f) {
        auto mask = AdvancedTensor({seq_len, seq_len});
        float* data = mask.data();
        
        // 상삼각행렬에 mask_value 채우기
        for (int i = 0; i < seq_len; ++i) {
            for (int j = 0; j < seq_len; ++j) {
                if (j > i) {
                    data[i * seq_len + j] = mask_value;
                } else {
                    data[i * seq_len + j] = 0.0f;
                }
            }
        }
        
        return mask;
    }
    
    // 배치 브로드캐스팅을 위한 마스크 확장
    static AdvancedTensor expand_for_batch(const AdvancedTensor& mask,
                                         int batch_size, int num_heads) {
        auto seq_len = mask.shape()[0];
        
        // [seq_len, seq_len] → [1, 1, seq_len, seq_len]
        auto expanded = mask.unsqueeze(0).unsqueeze(0);
        
        // 배치와 헤드 차원으로 브로드캐스트
        return expanded.expand({batch_size, num_heads, seq_len, seq_len});
    }
    
    // 동적 시퀀스 길이를 위한 슬라이싱
    static AdvancedTensor slice_mask(const AdvancedTensor& full_mask, 
                                   int current_seq_len) {
        return full_mask.slice(0, 0, current_seq_len)
                       .slice(1, 0, current_seq_len);
    }
};

5.5 Flash Attention과 메모리 최적화

// Flash Attention의 간소화된 구현 (핵심 아이디어)
class FlashAttention {
private:
    int block_size_q, block_size_kv;
    
public:
    FlashAttention(int d_k, int sram_size = 96 * 1024) {  // 96KB SRAM 가정
        block_size_q = sram_size / (4 * d_k * sizeof(float));
        block_size_kv = std::min(block_size_q, d_k);
    }
    
    AdvancedTensor forward(const AdvancedTensor& Q, 
                          const AdvancedTensor& K, 
                          const AdvancedTensor& V) {
        auto shape = Q.shape();
        int batch_size = shape[0];
        int num_heads = shape[1];
        int seq_len = shape[2];
        int d_k = shape[3];
        
        auto output = AdvancedTensor({batch_size, num_heads, seq_len, d_k});
        
        // Query 블록별로 처리
        for (int q_start = 0; q_start < seq_len; q_start += block_size_q) {
            int q_end = std::min(q_start + block_size_q, seq_len);
            
            // 현재 Query 블록
            auto Q_block = Q.slice(2, q_start, q_end);
            auto O_block = AdvancedTensor({batch_size, num_heads, 
                                         q_end - q_start, d_k});
            
            // 온라인 Softmax를 위한 누적 변수
            auto row_max = AdvancedTensor({batch_size, num_heads, 
                                         q_end - q_start, 1});
            row_max.fill_(-std::numeric_limits<float>::infinity());
            
            auto row_sum = AdvancedTensor({batch_size, num_heads, 
                                         q_end - q_start, 1});
            row_sum.fill_(0.0f);
            
            // Key-Value 블록별로 처리
            for (int kv_start = 0; kv_start < seq_len; kv_start += block_size_kv) {
                int kv_end = std::min(kv_start + block_size_kv, seq_len);
                
                // Causal masking 적용
                if (kv_start >= q_end) break;  // 미래 토큰 스킵
                
                auto K_block = K.slice(2, kv_start, kv_end);
                auto V_block = V.slice(2, kv_start, kv_end);
                
                // 블록별 어텐션 계산
                compute_block_attention(Q_block, K_block, V_block,
                                      O_block, row_max, row_sum,
                                      q_start, kv_start);
            }
            
            // 정규화 및 출력 저장
            normalize_output(O_block, row_sum);
            output.slice_copy(2, q_start, q_end, O_block);
        }
        
        return output;
    }
    
private:
    void compute_block_attention(const AdvancedTensor& Q_block,
                                const AdvancedTensor& K_block,
                                const AdvancedTensor& V_block,
                                AdvancedTensor& O_block,
                                AdvancedTensor& row_max,
                                AdvancedTensor& row_sum,
                                int q_offset, int kv_offset) {
        // 상세 구현 (온라인 Softmax 알고리즘)
        // ... 복잡한 수치적 안정성 고려사항들 ...
    }
};

5.6 어텐션 메커니즘의 복잡도 및 최적화

참고문헌: 본 섹션의 이론적 분석은 Vaswani et al. (2017)^[1]의 원논문과 Dao et al. (2022)^[4]의 Flash Attention 연구를 기반으로 한다.

6.1 위치별 피드포워드 네트워크의 함수론적 분석

// 메모리 효율적인 Position-wise FFN 구현
class PositionwiseFeedForward {
private:
    LinearLayer fc1, fc2;  // 첫 번째와 두 번째 완전연결층
    int d_model, d_ff;
    float dropout_prob;
    
public:
    PositionwiseFeedForward(int d_model, int d_ff, float dropout = 0.0f)
        : d_model(d_model), d_ff(d_ff), dropout_prob(dropout),
          fc1(d_model, d_ff), fc2(d_ff, d_model) {
        
        // He 초기화 for GELU (더 적합한 분산)
        float he_std_1 = std::sqrt(2.0f / d_model);
        float he_std_2 = std::sqrt(2.0f / d_ff);
        
        fc1.init_weights(he_std_1);
        fc2.init_weights(he_std_2);
    }
    
    AdvancedTensor forward(const AdvancedTensor& input, bool training = true) {
        auto shape = input.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // 1단계: 차원 확장 (d_model → d_ff)
        auto hidden = fc1.forward(input);  // [batch, seq_len, d_ff]
        
        // 2단계: GELU 활성화 (확률론적 게이팅)
        hidden = gelu_activation(hidden);
        
        // 3단계: 드롭아웃 (GPT-2에서는 일반적으로 사용하지 않음)
        if (training && dropout_prob > 0.0f) {
            hidden = apply_dropout(hidden, dropout_prob);
        }
        
        // 4단계: 차원 축소 (d_ff → d_model)
        auto output = fc2.forward(hidden);
        
        return output;
    }
    
private:
    AdvancedTensor gelu_activation(const AdvancedTensor& input) {
        // 수치적으로 안정한 GELU 근사 구현
        const float sqrt_2_over_pi = std::sqrt(2.0f / M_PI);
        const float coeff = 0.044715f;
        
        auto output = input.clone();
        float* data = output.data();
        int total_elements = output.numel();
        
        // 벡터화된 GELU 계산
        #pragma omp parallel for simd
        for (int i = 0; i < total_elements; ++i) {
            float x = data[i];
            float cubic_term = coeff * x * x * x;
            float tanh_arg = sqrt_2_over_pi * (x + cubic_term);
            float tanh_val = std::tanh(tanh_arg);
            data[i] = 0.5f * x * (1.0f + tanh_val);
        }
        
        return output;
    }
};

6.2 GELU 활성화 함수의 확률론적 해석

// 수치적으로 최적화된 GELU 구현
class OptimizedGELU {
public:
    // 표준 GELU (정확한 구현)
    static float gelu_exact(float x) {
        const float sqrt_2_over_pi = 0.7978845608f;  // sqrt(2/π)
        return 0.5f * x * (1.0f + std::erf(x / std::sqrt(2.0f)));
    }
    
    // 근사 GELU (빠른 구현)
    static float gelu_approximate(float x) {
        const float sqrt_2_over_pi = 0.7978845608f;
        const float coeff = 0.044715f;
        
        float x_cubed = x * x * x;
        float tanh_arg = sqrt_2_over_pi * (x + coeff * x_cubed);
        float tanh_val = fast_tanh(tanh_arg);
        
        return 0.5f * x * (1.0f + tanh_val);
    }
    
    // 룩업 테이블 기반 초고속 GELU (양자화된 환경)
    static float gelu_lookup(float x) {
        // 사전 계산된 룩업 테이블 사용
        static bool initialized = false;
        static std::array<float, 2048> lookup_table;
        
        if (!initialized) {
            for (int i = 0; i < 2048; ++i) {
                float val = (i - 1024) * 0.01f;  // [-10.24, 10.23] 범위
                lookup_table[i] = gelu_exact(val);
            }
            initialized = true;
        }
        
        // 클램핑 및 인덱스 계산
        float clamped = std::max(-10.24f, std::min(10.23f, x));
        int index = static_cast<int>((clamped + 10.24f) * 100.0f);
        return lookup_table[index];
    }
    
    // 텐서 전체에 대한 벡터화된 GELU
    static AdvancedTensor gelu_vectorized(const AdvancedTensor& input) {
        auto output = input.clone();
        float* data = output.data();
        int total_elements = output.numel();
        
        // OpenMP를 통한 병렬 처리
        #pragma omp parallel for schedule(static)
        for (int i = 0; i < total_elements; i += 8) {
            // SIMD 친화적인 배치 처리
            int remaining = std::min(8, total_elements - i);
            for (int j = 0; j < remaining; ++j) {
                data[i + j] = gelu_approximate(data[i + j]);
            }
        }
        
        return output;
    }
    
private:
    // 고속 tanh 근사 (Padé 근사)
    static float fast_tanh(float x) {
        if (x > 5.0f) return 1.0f;
        if (x < -5.0f) return -1.0f;
        
        float x2 = x * x;
        float x3 = x2 * x;
        return x * (27.0f + x2) / (27.0f + 9.0f * x2 + x2 * x2);
    }
};

6.3 차원 확장-축소 구조의 정보 처리 분석

// FFN의 정보 처리 특성 분석 도구
class FFNAnalyzer {
public:
    // 활성화 분포 분석
    static std::map<std::string, float> analyze_activations(
        const AdvancedTensor& pre_activation,
        const AdvancedTensor& post_activation) {
        
        std::map<std::string, float> metrics;
        
        // 희소성 측정 (0에 가까운 활성화 비율)
        float sparsity = compute_sparsity(post_activation, 0.01f);
        metrics["sparsity"] = sparsity;
        
        // 정보 엔트로피
        float entropy = compute_entropy(post_activation);
        metrics["entropy"] = entropy;
        
        // 활성화 분산
        float variance = post_activation.var();
        metrics["variance"] = variance;
        
        // 그래디언트 크기 (훈련 시)
        float grad_norm = post_activation.grad().norm();
        metrics["gradient_norm"] = grad_norm;
        
        return metrics;
    }
    
    // 표현 다양성 측정
    static float compute_representation_diversity(const AdvancedTensor& features) {
        // 특이값 분해를 통한 effective rank 계산
        auto svd_result = features.svd();
        auto singular_values = svd_result.S;
        
        float total_variance = singular_values.sum();
        float effective_rank = 0.0f;
        
        // Shannon entropy 기반 effective rank
        for (int i = 0; i < singular_values.size(0); ++i) {
            float ratio = singular_values[i] / total_variance;
            if (ratio > 1e-10f) {
                effective_rank += -ratio * std::log2(ratio);
            }
        }
        
        return effective_rank;
    }
    
    // 정보 병목 분석
    static float compute_information_bottleneck(
        const AdvancedTensor& input,
        const AdvancedTensor& intermediate,
        const AdvancedTensor& output) {
        
        // 상호 정보량 I(input; output) vs I(intermediate; output)
        float input_output_mi = mutual_information(input, output);
        float intermediate_output_mi = mutual_information(intermediate, output);
        
        // 정보 압축 비율
        return intermediate_output_mi / (input_output_mi + 1e-8f);
    }
    
private:
    static float compute_sparsity(const AdvancedTensor& tensor, float threshold) {
        const float* data = tensor.data();
        int total_elements = tensor.numel();
        int sparse_count = 0;
        
        for (int i = 0; i < total_elements; ++i) {
            if (std::abs(data[i]) < threshold) {
                sparse_count++;
            }
        }
        
        return static_cast<float>(sparse_count) / total_elements;
    }
    
    static float compute_entropy(const AdvancedTensor& tensor) {
        // 히스토그램 기반 엔트로피 추정
        const int num_bins = 256;
        std::vector<int> histogram(num_bins, 0);
        
        // 활성화값 범위 정규화 및 히스토그램 생성
        auto normalized = (tensor - tensor.min()) / (tensor.max() - tensor.min());
        const float* data = normalized.data();
        int total_elements = normalized.numel();
        
        for (int i = 0; i < total_elements; ++i) {
            int bin = std::min(num_bins - 1, static_cast<int>(data[i] * num_bins));
            histogram[bin]++;
        }
        
        // Shannon 엔트로피 계산
        float entropy = 0.0f;
        for (int count : histogram) {
            if (count > 0) {
                float prob = static_cast<float>(count) / total_elements;
                entropy += -prob * std::log2(prob);
            }
        }
        
        return entropy;
    }
};

6.4 계산 최적화 및 메모리 효율성

6.5 FFN의 언어학적 해석

참고문헌: GELU 활성화 함수는 Hendrycks & Gimpel (2016)^[6]에서 제안되었으며, GLU 변형은 Shazeer (2020)^[10]의 연구를 참조하였다.

6.1 최종 층 정규화의 역할과 안정성

// 언어 모델링을 위한 최종 정규화
class FinalLayerNorm {
private:
    LayerNorm norm;
    int d_model;
    
public:
    FinalLayerNorm(int d_model, float eps = 1e-5f) 
        : d_model(d_model), norm(d_model, eps) {}
    
    AdvancedTensor forward(const AdvancedTensor& input) {
        // 표준 LayerNorm 적용
        auto normalized = norm.forward(input);
        
        // 언어 모델링에 특화된 후처리
        return post_process_for_lm(normalized);
    }
    
private:
    AdvancedTensor post_process_for_lm(const AdvancedTensor& normalized) {
        // 언어 모델링 헤드의 안정성을 위한 추가 처리
        auto output = normalized.clone();
        float* data = output.data();
        int total_elements = output.numel();
        
        // 극단값 클리핑 (수치적 안정성)
        const float max_val = 10.0f;
        for (int i = 0; i < total_elements; ++i) {
            data[i] = std::max(-max_val, std::min(max_val, data[i]));
        }
        
        return output;
    }
};

6.2 어휘 투사와 Weight Tying의 이론적 분석

// Weight Tying을 적용한 언어 모델링 헤드
class LanguageModelHead {
private:
    AdvancedTensor* embedding_weights;  // 임베딩 가중치 참조
    AdvancedTensor bias;                // 선택적 편향
    int vocab_size, d_model;
    bool use_bias;
    
public:
    LanguageModelHead(AdvancedTensor* embed_weights, bool use_bias = false)
        : embedding_weights(embed_weights), use_bias(use_bias) {
        vocab_size = embed_weights->shape()[0];
        d_model = embed_weights->shape()[1];
        
        if (use_bias) {
            bias = AdvancedTensor({vocab_size});
            bias.fill_(0.0f);  // 편향을 0으로 초기화
        }
    }
    
    AdvancedTensor forward(const AdvancedTensor& hidden_states) {
        auto shape = hidden_states.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // Weight Tying: embedding^T 사용
        // hidden_states: [batch, seq_len, d_model]
        // embedding_weights: [vocab_size, d_model]
        // output: [batch, seq_len, vocab_size]
        
        auto logits = hidden_states.matmul(embedding_weights->transpose(0, 1));
        
        if (use_bias) {
            // 편향 추가 (브로드캐스팅)
            logits = logits + bias.unsqueeze(0).unsqueeze(0);
        }
        
        return logits;
    }
    
    // 메모리 공유 확인 (디버깅용)
    bool verify_weight_sharing() const {
        return embedding_weights != nullptr;
    }
    
    // 가중치 정규화 (선택적)
    void apply_weight_decay(float decay_rate) {
        if (embedding_weights) {
            *embedding_weights *= (1.0f - decay_rate);
        }
        if (use_bias) {
            bias *= (1.0f - decay_rate);
        }
    }
};

6.3 Softmax와 확률 분포의 수치적 안정성

// 언어 모델링을 위한 고성능 Softmax
class NumericallyStableSoftmax {
public:
    // 표준 Softmax (안정성 보장)
    static AdvancedTensor softmax(const AdvancedTensor& logits, 
                                 float temperature = 1.0f) {
        auto shape = logits.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        int vocab_size = shape[2];
        
        auto output = AdvancedTensor(shape);
        const float* logits_data = logits.data();
        float* output_data = output.data();
        
        // 각 위치별로 독립적으로 softmax 적용
        #pragma omp parallel for
        for (int b = 0; b < batch_size; ++b) {
            for (int t = 0; t < seq_len; ++t) {
                int offset = (b * seq_len + t) * vocab_size;
                const float* input_ptr = logits_data + offset;
                float* output_ptr = output_data + offset;
                
                compute_stable_softmax(input_ptr, output_ptr, 
                                     vocab_size, temperature);
            }
        }
        
        return output;
    }
    
    // Log-Softmax (수치적 안정성 더욱 강화)
    static AdvancedTensor log_softmax(const AdvancedTensor& logits) {
        auto output = logits.clone();
        float* data = output.data();
        auto shape = logits.shape();
        int vocab_size = shape[shape.size() - 1];
        int total_sequences = output.numel() / vocab_size;
        
        for (int i = 0; i < total_sequences; ++i) {
            float* seq_ptr = data + i * vocab_size;
            
            // LogSumExp 계산
            float max_val = *std::max_element(seq_ptr, seq_ptr + vocab_size);
            float log_sum_exp = max_val;
            
            float sum_exp = 0.0f;
            for (int j = 0; j < vocab_size; ++j) {
                sum_exp += std::exp(seq_ptr[j] - max_val);
            }
            log_sum_exp += std::log(sum_exp + 1e-8f);
            
            // Log-Softmax 적용
            for (int j = 0; j < vocab_size; ++j) {
                seq_ptr[j] -= log_sum_exp;
            }
        }
        
        return output;
    }
    
private:
    static void compute_stable_softmax(const float* input, float* output,
                                     int size, float temperature) {
        // 1단계: 최대값 찾기
        float max_val = *std::max_element(input, input + size);
        
        // 2단계: exp 계산 및 합 구하기
        float sum_exp = 0.0f;
        for (int i = 0; i < size; ++i) {
            float scaled = (input[i] - max_val) / temperature;
            output[i] = std::exp(scaled);
            sum_exp += output[i];
        }
        
        // 3단계: 정규화
        float inv_sum = 1.0f / (sum_exp + 1e-8f);
        for (int i = 0; i < size; ++i) {
            output[i] *= inv_sum;
        }
    }
};

6.4 자기회귀적 언어 모델의 확률적 일관성

8.1 자기회귀적 최대우도 추정의 이론적 기초

// 수치적으로 안정한 교차엔트로피 손실 계산
class CrossEntropyLoss {
private:
    float label_smoothing;
    bool ignore_padding;
    int padding_idx;
    
public:
    CrossEntropyLoss(float label_smoothing = 0.0f, 
                    bool ignore_padding = true, 
                    int padding_idx = 0)
        : label_smoothing(label_smoothing), 
          ignore_padding(ignore_padding),
          padding_idx(padding_idx) {}
    
    float compute_loss(const AdvancedTensor& logits,      // [B, L, V]
                      const AdvancedTensor& targets) {   // [B, L]
        auto shape = logits.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        int vocab_size = shape[2];
        
        float total_loss = 0.0f;
        int valid_tokens = 0;
        
        const float* logits_data = logits.data();
        const int* targets_data = reinterpret_cast<const int*>(targets.data());
        
        for (int b = 0; b < batch_size; ++b) {
            for (int t = 0; t < seq_len; ++t) {
                int target = targets_data[b * seq_len + t];
                
                // 패딩 토큰 무시
                if (ignore_padding && target == padding_idx) {
                    continue;
                }
                
                // 해당 위치의 로짓 포인터
                const float* position_logits = logits_data + 
                    (b * seq_len + t) * vocab_size;
                
                // 수치적으로 안정한 로그 확률 계산
                float log_prob = compute_log_probability(position_logits, 
                                                        vocab_size, target);
                
                // 라벨 스무딩 적용
                if (label_smoothing > 0.0f) {
                    log_prob = apply_label_smoothing(log_prob, vocab_size);
                }
                
                total_loss -= log_prob;
                valid_tokens++;
            }
        }
        
        return total_loss / valid_tokens;  // 평균 손실
    }
    
private:
    float compute_log_probability(const float* logits, int vocab_size, int target) {
        // LogSumExp trick으로 수치적 안정성 확보
        float max_logit = *std::max_element(logits, logits + vocab_size);
        
        float sum_exp = 0.0f;
        for (int i = 0; i < vocab_size; ++i) {
            sum_exp += std::exp(logits[i] - max_logit);
        }
        
        float log_sum_exp = max_logit + std::log(sum_exp + 1e-8f);
        return logits[target] - log_sum_exp;
    }
    
    float apply_label_smoothing(float log_prob, int vocab_size) {
        // 라벨 스무딩: (1-α) * log P(true) + α/V * ∑ log P(v)
        float smooth_prob = (1.0f - label_smoothing) * log_prob + 
                          label_smoothing * (-std::log(vocab_size));
        return smooth_prob;
    }
};

8.2 Teacher Forcing과 Exposure Bias 분석

8.3 라벨 시프팅의 수학적 정당성

// 효율적인 라벨 시프팅 구현
class LabelShifter {
public:
    // 입력 시퀀스 준비 (디코더 입력용)
    static AdvancedTensor prepare_decoder_input(const AdvancedTensor& sequence,
                                               int bos_token_id) {
        auto shape = sequence.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // [batch_size, seq_len + 1] 크기로 확장
        auto decoder_input = AdvancedTensor({batch_size, seq_len + 1});
        
        int* input_data = reinterpret_cast<int*>(decoder_input.data());
        const int* seq_data = reinterpret_cast<const int*>(sequence.data());
        
        for (int b = 0; b < batch_size; ++b) {
            // BOS 토큰을 맨 앞에 추가
            input_data[b * (seq_len + 1)] = bos_token_id;
            
            // 원본 시퀀스를 한 칸씩 오른쪽으로 시프트
            for (int t = 0; t < seq_len; ++t) {
                input_data[b * (seq_len + 1) + t + 1] = seq_data[b * seq_len + t];
            }
        }
        
        return decoder_input;
    }
    
    // 타겟 시퀀스 준비 (손실 계산용)
    static AdvancedTensor prepare_targets(const AdvancedTensor& sequence,
                                        int eos_token_id,
                                        int padding_idx = -100) {
        auto shape = sequence.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        auto targets = AdvancedTensor({batch_size, seq_len + 1});
        
        int* target_data = reinterpret_cast<int*>(targets.data());
        const int* seq_data = reinterpret_cast<const int*>(sequence.data());
        
        for (int b = 0; b < batch_size; ++b) {
            // 원본 시퀀스 복사
            for (int t = 0; t < seq_len; ++t) {
                target_data[b * (seq_len + 1) + t] = seq_data[b * seq_len + t];
            }
            
            // 마지막에 EOS 토큰 추가
            target_data[b * (seq_len + 1) + seq_len] = eos_token_id;
        }
        
        return targets;
    }
    
    // 동적 배치 처리 (가변 길이 시퀀스)
    static std::pair<AdvancedTensor, AdvancedTensor> 
    prepare_dynamic_batch(const std::vector<AdvancedTensor>& sequences,
                         int bos_token_id, int eos_token_id, int pad_token_id) {
        
        int batch_size = sequences.size();
        int max_len = 0;
        
        // 최대 길이 계산
        for (const auto& seq : sequences) {
            max_len = std::max(max_len, seq.shape()[0]);
        }
        
        auto decoder_inputs = AdvancedTensor({batch_size, max_len + 1});
        auto targets = AdvancedTensor({batch_size, max_len + 1});
        
        decoder_inputs.fill_(pad_token_id);
        targets.fill_(-100);  // Cross-entropy에서 무시할 값
        
        for (int b = 0; b < batch_size; ++b) {
            const auto& seq = sequences[b];
            int seq_len = seq.shape()[0];
            
            // 디코더 입력 설정
            decoder_inputs.slice(0, b, b+1).slice(1, 0, 1).fill_(bos_token_id);
            decoder_inputs.slice(0, b, b+1).slice(1, 1, seq_len+1) = seq;
            
            // 타겟 설정
            targets.slice(0, b, b+1).slice(1, 0, seq_len) = seq;
            targets.slice(0, b, b+1).slice(1, seq_len, seq_len+1).fill_(eos_token_id);
        }
        
        return {decoder_inputs, targets};
    }
};

8.4 대규모 언어 모델 훈련의 최적화 전략

9.1 온도 스케일링과 엔트로피 제어

9.2 오토레그레시브 생성 프로세스

9.3 고급 샘플링 전략 분석

9.4 품질-다양성 트레이드오프 최적화

참고문헌: 생성 전략의 이론적 분석은 Holtzman et al. (2020)^[13]의 Nucleus sampling과 Zhang et al. (2021)^[14]의 품질-다양성 연구를 바탕으로 한다.

10.1 시간 복잡도의 정밀 분석

// 메모리 효율적인 어텐션 구현
class OptimizedAttention {
private:
    int d_model;
    int num_heads;
    int d_head;
    bool use_flash_attention;
    
public:
    OptimizedAttention(int d_model, int num_heads, bool use_flash_attention = true)
        : d_model(d_model), num_heads(num_heads), 
          d_head(d_model / num_heads), use_flash_attention(use_flash_attention) {}
    
    // 표준 어텐션: O(L²d) 메모리, O(L²d + Ld²) 시간
    AdvancedTensor standard_attention(const AdvancedTensor& Q,
                                     const AdvancedTensor& K,
                                     const AdvancedTensor& V) {
        auto shape = Q.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // 어텐션 스코어 계산: [B, H, L, L]
        auto scores = batch_matmul(Q, K.transpose(-2, -1));
        scores = scores / std::sqrt(static_cast<float>(d_head));
        
        // 소프트맥스 적용
        auto attn_weights = softmax(scores, -1);
        
        // 가중합 계산: [B, H, L, d_h]
        auto output = batch_matmul(attn_weights, V);
        
        return output;
    }
    
    // 플래시 어텐션: O(L) 메모리, O(L²d) 시간
    AdvancedTensor flash_attention(const AdvancedTensor& Q,
                                  const AdvancedTensor& K,
                                  const AdvancedTensor& V,
                                  int block_size = 128) {
        auto shape = Q.shape();
        int batch_size = shape[0];
        int seq_len = shape[1];
        
        // 출력 및 정규화 상수 초기화
        auto output = AdvancedTensor({batch_size, seq_len, d_head});
        auto l = AdvancedTensor({batch_size, seq_len});
        auto m = AdvancedTensor({batch_size, seq_len});
        
        output.fill_(0.0f);
        l.fill_(0.0f);
        m.fill_(-std::numeric_limits<float>::infinity());
        
        // 블록별 처리
        for (int i = 0; i < seq_len; i += block_size) {
            int end_i = std::min(i + block_size, seq_len);
            auto Q_block = Q.slice(1, i, end_i);  // [B, block_size, d_h]
            
            for (int j = 0; j <= i; j += block_size) {  // 인과적 마스킹
                int end_j = std::min(j + block_size, seq_len);
                auto K_block = K.slice(1, j, end_j);  // [B, block_size, d_h]
                auto V_block = V.slice(1, j, end_j);  // [B, block_size, d_h]
                
                // 블록 어텐션 스코어
                auto S_block = batch_matmul(Q_block, K_block.transpose(-2, -1));
                S_block = S_block / std::sqrt(static_cast<float>(d_head));
                
                // 인과적 마스킹 적용
                if (i >= j) {
                    apply_causal_mask(S_block, i - j);
                }
                
                // 온라인 소프트맥스 업데이트
                update_online_softmax(output, l, m, S_block, V_block, i, j);
            }
        }
        
        return output;
    }
    
private:
    void apply_causal_mask(AdvancedTensor& scores, int offset) {
        auto shape = scores.shape();
        int rows = shape[1];
        int cols = shape[2];
        
        float* data = scores.data();
        
        for (int b = 0; b < shape[0]; ++b) {
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    if (offset + i < j) {
                        data[b * rows * cols + i * cols + j] = -std::numeric_limits<float>::infinity();
                    }
                }
            }
        }
    }
    
    void update_online_softmax(AdvancedTensor& output, AdvancedTensor& l, AdvancedTensor& m,
                              const AdvancedTensor& S_block, const AdvancedTensor& V_block,
                              int i_offset, int j_offset) {
        // 온라인 소프트맥스 알고리즘 구현
        // Rabe & Staats (2021) Flash Attention의 핵심 알고리즘
        
        auto S_shape = S_block.shape();
        int block_rows = S_shape[1];
        int block_cols = S_shape[2];
        
        for (int b = 0; b < S_shape[0]; ++b) {
            for (int i = 0; i < block_rows; ++i) {
                int global_i = i_offset + i;
                
                // 현재 행의 최대값 계산
                float row_max = -std::numeric_limits<float>::infinity();
                for (int j = 0; j < block_cols; ++j) {
                    float score = S_block.at({b, i, j});
                    row_max = std::max(row_max, score);
                }
                
                // 이전 최대값과 비교하여 업데이트
                float old_m = m.at({b, global_i});
                float new_m = std::max(old_m, row_max);
                
                // 정규화 상수 업데이트
                float old_l = l.at({b, global_i});
                float exp_diff = std::exp(old_m - new_m);
                
                float block_sum = 0.0f;
                for (int j = 0; j < block_cols; ++j) {
                    block_sum += std::exp(S_block.at({b, i, j}) - new_m);
                }
                
                float new_l = exp_diff * old_l + block_sum;
                
                // 출력 업데이트
                float alpha = exp_diff * old_l / new_l;
                for (int d = 0; d < d_head; ++d) {
                    float old_output = output.at({b, global_i, d});
                    float new_contribution = 0.0f;
                    
                    for (int j = 0; j < block_cols; ++j) {
                        float weight = std::exp(S_block.at({b, i, j}) - new_m) / new_l;
                        new_contribution += weight * V_block.at({b, j, d});
                    }
                    
                    output.set({b, global_i, d}, alpha * old_output + new_contribution);
                }
                
                // 상태 업데이트
                m.set({b, global_i}, new_m);
                l.set({b, global_i}, new_l);
            }
        }
    }
};

10.2 공간 복잡도와 메모리 최적화

10.3 병렬화 이론과 통신 복잡도

10.4 실제 성능 벤치마크와 최적화 지침

참고문헌: Flash Attention의 메모리 최적화는 Dao et al. (2022)^[15]에서 제안되었으며, 대규모 모델 병렬화 전략은 Narayanan et al. (2021)^[16]에서 체계적으로 분석되었다.

12.1 가중치 초기화의 이론적 기초

// 이론적으로 최적화된 초기화 클래스
class OptimalInitializer {
private:
    std::random_device rd;
    std::mt19937 gen;
    
public:
    OptimalInitializer() : gen(rd()) {}
    
    // Transformer용 어텐션 가중치 초기화
    void initialize_attention_weights(AdvancedTensor& W_Q, AdvancedTensor& W_K, 
                                     AdvancedTensor& W_V, AdvancedTensor& W_O,
                                     int d_model, int num_layers) {
        
        float attn_std = std::sqrt(2.0f / d_model);
        float output_std = std::sqrt(2.0f / (num_layers * d_model));
        
        // Q, K, V 프로젝션 초기화
        initialize_normal(W_Q, 0.0f, attn_std);
        initialize_normal(W_K, 0.0f, attn_std);
        initialize_normal(W_V, 0.0f, attn_std);
        
        // 출력 프로젝션은 레이어 수로 스케일링
        initialize_normal(W_O, 0.0f, output_std);
    }
    
    // 피드포워드 네트워크 초기화
    void initialize_ffn_weights(AdvancedTensor& W1, AdvancedTensor& b1,
                               AdvancedTensor& W2, AdvancedTensor& b2,
                               int d_model, int d_ff, int num_layers) {
        
        float w1_std = std::sqrt(2.0f / d_model);
        float w2_std = std::sqrt(2.0f / (num_layers * d_ff));
        
        // 첫 번째 선형 변환
        initialize_normal(W1, 0.0f, w1_std);
        initialize_zeros(b1);
        
        // 두 번째 선형 변환 (레이어 수로 스케일링)
        initialize_normal(W2, 0.0f, w2_std);
        initialize_zeros(b2);
    }
    
    // 임베딩 가중치 초기화
    void initialize_embedding(AdvancedTensor& embedding, int vocab_size, int d_model) {
        float emb_std = std::pow(d_model, -0.5f);
        initialize_normal(embedding, 0.0f, emb_std);
    }
    
    // 위치 인코딩 초기화 (학습 가능한 경우)
    void initialize_positional_encoding(AdvancedTensor& pos_emb, int max_len, int d_model) {
        // 사인/코사인 기반으로 초기화 후 미세 조정 허용
        float* data = pos_emb.data();
        
        for (int pos = 0; pos < max_len; ++pos) {
            for (int i = 0; i < d_model; ++i) {
                float angle = pos / std::pow(10000.0f, 2.0f * i / d_model);
                if (i % 2 == 0) {
                    data[pos * d_model + i] = std::sin(angle);
                } else {
                    data[pos * d_model + i] = std::cos(angle);
                }
            }
        }
        
        // 미세 조정을 위한 작은 노이즈 추가
        float noise_std = 0.02f;
        add_gaussian_noise(pos_emb, 0.0f, noise_std);
    }
    
    // Layer Normalization 파라미터 초기화
    void initialize_layer_norm(AdvancedTensor& gamma, AdvancedTensor& beta) {
        initialize_ones(gamma);   // 스케일링 파라미터는 1로
        initialize_zeros(beta);   // 시프트 파라미터는 0으로
    }
    
private:
    void initialize_normal(AdvancedTensor& tensor, float mean, float std) {
        std::normal_distribution<float> dist(mean, std);
        float* data = tensor.data();
        int size = tensor.numel();
        
        for (int i = 0; i < size; ++i) {
            data[i] = dist(gen);
        }
    }
    
    void initialize_uniform(AdvancedTensor& tensor, float low, float high) {
        std::uniform_real_distribution<float> dist(low, high);
        float* data = tensor.data();
        int size = tensor.numel();
        
        for (int i = 0; i < size; ++i) {
            data[i] = dist(gen);
        }
    }
    
    void initialize_zeros(AdvancedTensor& tensor) {
        tensor.fill_(0.0f);
    }
    
    void initialize_ones(AdvancedTensor& tensor) {
        tensor.fill_(1.0f);
    }
    
    void add_gaussian_noise(AdvancedTensor& tensor, float mean, float std) {
        std::normal_distribution<float> dist(mean, std);
        float* data = tensor.data();
        int size = tensor.numel();
        
        for (int i = 0; i < size; ++i) {
            data[i] += dist(gen);
        }
    }
};

12.2 고성능 추론 엔진 아키텍처

// 프로덕션 GPT 추론 엔진
class GPTInferenceEngine {
private:
    struct ModelConfig {
        int vocab_size;
        int max_seq_len;
        int d_model;
        int num_layers;
        int num_heads;
        int d_ff;
        float dropout_rate;
    };
    
    struct RuntimeConfig {
        int max_batch_size;
        int max_cache_size;
        bool use_fp16;
        bool use_flash_attention;
        int num_threads;
    };
    
    ModelConfig model_config;
    RuntimeConfig runtime_config;
    std::unique_ptr<KVCacheManager> kv_cache;
    std::unique_ptr<MemoryPool> memory_pool;
    std::unique_ptr<ThreadPool> thread_pool;
    
    // 모델 가중치
    std::vector<AdvancedTensor> transformer_weights;
    AdvancedTensor token_embedding;
    AdvancedTensor position_embedding;
    AdvancedTensor layer_norm_final_weight;
    AdvancedTensor layer_norm_final_bias;
    AdvancedTensor output_projection;
    
public:
    GPTInferenceEngine(const ModelConfig& model_cfg, const RuntimeConfig& runtime_cfg)
        : model_config(model_cfg), runtime_config(runtime_cfg) {
        
        initialize_components();
        load_model_weights();
    }
    
    // 단일 시퀀스 추론
    std::vector<int> generate(const std::vector<int>& input_tokens,
                             int max_new_tokens,
                             float temperature = 1.0f,
                             int top_k = 50,
                             float top_p = 0.9f) {
        
        auto batch_input = std::vector<std::vector<int>>{input_tokens};
        auto batch_output = generate_batch(batch_input, max_new_tokens, 
                                         temperature, top_k, top_p);
        return batch_output[0];
    }
    
    // 배치 추론 (주요 성능 경로)
    std::vector<std::vector<int>> generate_batch(
        const std::vector<std::vector<int>>& input_batch,
        int max_new_tokens,
        float temperature = 1.0f,
        int top_k = 50,
        float top_p = 0.9f) {
        
        int batch_size = input_batch.size();
        
        // 입력 검증 및 패딩
        auto padded_batch = prepare_batch_input(input_batch);
        int seq_len = padded_batch.shape()[1];
        
        // KV 캐시 초기화
        auto cache_keys = initialize_kv_cache(batch_size, seq_len);
        
        // 초기 프리필 단계 (모든 입력 토큰 처리)
        auto current_logits = prefill_phase(padded_batch, cache_keys);
        
        // 자기회귀적 생성 단계
        auto results = autoregressive_generation(current_logits, cache_keys,
                                               max_new_tokens, temperature,
                                               top_k, top_p);
        
        return postprocess_batch_output(results, input_batch);
    }
    
private:
    void initialize_components() {
        // 메모리 풀 초기화
        size_t pool_size = calculate_memory_requirements();
        memory_pool = std::make_unique<MemoryPool>(pool_size);
        
        // KV 캐시 관리자 초기화
        kv_cache = std::make_unique<KVCacheManager>(
            runtime_config.max_batch_size,
            model_config.max_seq_len,
            model_config.num_layers,
            model_config.num_heads,
            model_config.d_model / model_config.num_heads
        );
        
        // 스레드 풀 초기화
        thread_pool = std::make_unique<ThreadPool>(runtime_config.num_threads);
    }
    
    AdvancedTensor prefill_phase(const AdvancedTensor& input_batch,
                                const std::vector<KVCacheEntry>& cache_entries) {
        // 임베딩 계산
        auto embedded = compute_embeddings(input_batch);
        
        // 트랜스포머 레이어들 순차 실행
        auto hidden_states = embedded;
        
        for (int layer = 0; layer < model_config.num_layers; ++layer) {
            hidden_states = forward_transformer_layer(hidden_states, layer, 
                                                    cache_entries[layer]);
        }
        
        // 최종 레이어 정규화
        hidden_states = layer_norm(hidden_states, layer_norm_final_weight, 
                                 layer_norm_final_bias);
        
        // 언어 모델링 헤드
        auto logits = linear_projection(hidden_states, output_projection);
        
        // 마지막 토큰 위치의 로짓만 반환
        return extract_last_token_logits(logits);
    }
    
    std::vector<std::vector<int>> autoregressive_generation(
        AdvancedTensor current_logits,
        std::vector<KVCacheEntry>& cache_entries,
        int max_new_tokens,
        float temperature,
        int top_k,
        float top_p) {
        
        int batch_size = current_logits.shape()[0];
        std::vector<std::vector<int>> generated_tokens(batch_size);
        std::vector<bool> finished(batch_size, false);
        
        AdvancedSampler sampler;
        
        for (int step = 0; step < max_new_tokens; ++step) {
            // 샘플링
            auto next_tokens = sampler.sample_batch(current_logits, temperature, 
                                                  top_k, top_p);
            
            // 결과 업데이트
            for (int b = 0; b < batch_size; ++b) {
                if (!finished[b]) {
                    int token = next_tokens[b];
                    generated_tokens[b].push_back(token);
                    
                    // EOS 토큰 체크
                    if (token == EOS_TOKEN_ID) {
                        finished[b] = true;
                    }
                }
            }
            
            // 모든 시퀀스가 완료되었는지 확인
            if (std::all_of(finished.begin(), finished.end(), 
                           [](bool f) { return f; })) {
                break;
            }
            
            // 다음 스텝을 위한 forward pass
            if (step < max_new_tokens - 1) {
                auto next_input = create_next_input_tensor(next_tokens);
                current_logits = forward_single_step(next_input, cache_entries);
            }
        }
        
        return generated_tokens;
    }
    
    AdvancedTensor forward_transformer_layer(const AdvancedTensor& input,
                                           int layer_idx,
                                           KVCacheEntry& cache_entry) {
        // Pre-LayerNorm
        auto normed_input = layer_norm(input, /* layer norm weights */);
        
        // Multi-Head Attention with KV Caching
        auto attn_output = multi_head_attention_with_cache(normed_input, 
                                                         layer_idx, 
                                                         cache_entry);
        
        // Residual connection
        auto after_attn = input + attn_output;
        
        // Pre-LayerNorm for FFN
        auto normed_attn = layer_norm(after_attn, /* layer norm weights */);
        
        // Feed Forward Network
        auto ffn_output = feed_forward_network(normed_attn, layer_idx);
        
        // Final residual connection
        return after_attn + ffn_output;
    }
    
    size_t calculate_memory_requirements() {
        // 활성화 메모리 + KV 캐시 + 임시 버퍼
        size_t activation_memory = runtime_config.max_batch_size * 
                                 model_config.max_seq_len * 
                                 model_config.d_model * sizeof(float);
        
        size_t kv_cache_memory = runtime_config.max_batch_size *
                               model_config.max_seq_len *
                               model_config.num_layers *
                               model_config.d_model * 2 * sizeof(float);
        
        size_t temp_buffer = activation_memory * 2;  // 안전 마진
        
        return activation_memory + kv_cache_memory + temp_buffer;
    }
};

12.3 KV 캐시 메모리 관리 최적화

12.4 시스템 성능 모니터링과 벤치마킹

참고문헌: 가중치 초기화 이론은 Glorot & Bengio (2010)^[17]과 He et al. (2015)^[18]에서 확립되었으며, KV 캐시 최적화는 최신 production system에서 검증된 기법들을 종합한다.

12.1 Causal Mask 행렬의 수학적 정의

12.2 KV 캐시 메커니즘 (Key-Value Caching)

12.3 고급 최적화 기법

KV 캐시는 추론 시에만 사용되며, 학습 시에는 Teacher Forcing으로 인해 불필요합니다. 실제 구현에서는 메모리 제약을 고려한 캐시 크기 제한이 필요합니다.

13.1 드롭아웃의 수학적 정의

13.2 GPT의 드롭아웃 적용 위치

13.3 LayerNorm의 정규화 효과

드롭아웃과 LayerNorm의 조합은 GPT의 핵심 정규화 전략으로, 과적합 방지와 학습 안정성을 동시에 확보합니다.

14.1 샘플링 전략 비교

14.2 온도 스케일링 (Temperature Scaling)

14.3 빔 서치 (Beam Search)

빔 서치는 시퀀스 생성에서 가장 유망한 후보들을 유지하며 최적의 시퀀스를 찾는 방법입니다. 빔 크기 B를 설정하여 상위 B개의 후보만을 유지합니다.

14.4 실전 생성 설정

실제 텍스트 생성에서는 다양한 하이퍼파라미터를 조정하여 최적의 결과를 얻습니다. 다음은 일반적인 설정입니다.

실제 구현에서는 반복 페널티(Repetition Penalty)와 최대 길이 제한을 추가로 적용하여 더 자연스러운 텍스트를 생성합니다.

15.1 GPT 디코더 전체 파이프라인

15.2 아키텍처 검증 및 논문 참조

15.3 초기화 전략 (Weight Initialization)

Residual 경로를 통해 학습 신호가 누적되므로 최종 LayerNorm이 안정성에 중요한 역할을 합니다.

15.4 C++ 구현 코드 뷰어

// tensor.hpp - 기본 텐서 연산
#pragma once
#include <vector>
#include <memory>
#include <cuda_runtime.h>

class Tensor {
private:
    std::vector<float> data;
    std::vector<int> shape;
    float* device_ptr = nullptr;
    bool on_device = false;
    
public:
    Tensor(const std::vector<int>& shape);
    ~Tensor();
    
    // 핵심 행렬 연산
    static Tensor matmul(const Tensor& A, const Tensor& B);
    
    // GPT에 필수적인 softmax 연산
    Tensor softmax(int dim = -1) const;
    
    // 원소별 연산
    Tensor add(const Tensor& other) const;
    Tensor multiply(float scalar) const;
    Tensor gelu() const;  // GELU 활성화 함수
    
    // GPU 메모리 관리
    void to_device();
    void to_host();
    void sync();
    
    // 접근자 및 유틸리티
    float& operator[](const std::vector<int>& indices);
    const std::vector<int>& get_shape() const { return shape; }
    size_t size() const;
    void zero_();
    void print() const;
};

16.1 실시간 텍스트 처리 및 토큰화

16.2 실제 GPT 아키텍처 플로우

16.3 토큰별 어텐션 매트릭스 시각화

16.4 실시간 하이퍼파라미터 모니터링

16.5 실제 계산 과정 보기

17.1 언어 모델링 손실 함수

GPT는 다음 단어 예측을 목표로 하는 언어 모델입니다. 손실 함수는 주어진 시퀀스에서 다음 단어를 예측하는 확률을 최대화하는 방식으로 정의됩니다.

17.2 최적화 알고리즘: AdamW

GPT는 AdamW 최적화 알고리즘을 사용하여 가중치 업데이트를 수행합니다. AdamW는 L2 정규화를 포함하여 가중치 감쇠를 적용합니다.

17.3 학습률 스케줄링

17.4 그래디언트 클리핑

17.5 표준 하이퍼파라미터 설정

실제 훈련에서는 Mixed Precision (FP16)과 Data Parallel/Model Parallel 기법을 활용하여 메모리 효율성과 학습 속도를 개선합니다. 대규모 모델일수록 학습률을 낮추고 배치 크기를 늘리는 것이 일반적입니다.

tensor.hpp

• 행렬곱 matmul(A,B)
• 행별 softmax
• 브로드캐스트 add
• 마스크 적용(음의 무한대 덧셈)

layernorm.hpp

• 토큰별 LN: 평균/분산 계산(ε 안정)
• \(\gamma, \beta\) 파라미터 보관

attention.hpp

• linear_qkv(x) → 분할 → reshape \([B, h, L, d_h]\)
• scores = (Q @ K^T) / sqrt(d_h)
• scores += mask (causal)
• A = softmax(scores); (선택) attn-dropout
• O = A @ V → concat → \(W_O\)

ffn.hpp

• H = GELU(x @ W1 + b1)
• (선택) dropout
• Y = H @ W2 + b2

transformer.hpp

• 임베딩 조회 + P 추가 + emb-dropout
• 블록 루프(Pre-LN → Attn → Residual → Pre-LN → FFN → Residual)
• 최종 LN → 출력 projection(선택: weight tying)

init_params()

• std::normal_distribution(0, 0.02)로 파라미터 초기화
• LN은 \(\gamma = 1, \beta = 0\)

주요 고려사항

• Softmax 전 마스크: 반드시 큰 음수(예: \(-1e9\))를 더하는 방식으로 구현. NaN 방지.
• GELU 근사: \[\text{GELU}(x) = 0.5x(1 + \tanh(\sqrt{2/\pi}(x + 0.044715x^3)))\] 근사식 그대로 쓰면 충분히 정확하고 빠름.
• 정밀도: float32 권장 (RPi4 등에서는 성능/정밀 균형).
• 메모리 레이아웃: [B, L, d] 고정, Q/K/V에서 [B, h, L, d_h]로 뷰 변경(reshape)만 하고 실데이터 복사는 최소화.

순방향만이라면 BN/검증 불필요. 학습 시에는 label shift/teacher forcing 및 마스크 확인.

20.1 계산 복잡도 분석

20.2 메모리 사용량 분석

20.3 실제 성능 벤치마크

back/는 간단한 Crow 서버를 제공합니다. 엔드포인트:

• GET /api/health — 상태 확인
• POST /api/attention — 표준 수식 \(\text{softmax}(QK^{\top}/\sqrt{d_k})V\) 계산 (단일 배치/헤드용 데모)
• GET /api/config — 현재 하이퍼파라미터

참조 구현 출처

본 문서의 모든 수학적 정의와 알고리즘은 다음 C++ 구현을 기반으로 합니다.

• 기본 텐서 연산: /back/include/model/tensor.hpp
• 어텐션 메커니즘: /back/include/model/attention.hpp
• FFN 구현: /back/include/model/ffn.hpp
• LayerNorm: /back/include/model/layernorm.hpp
• 고급 트랜스포머: /back/include/model/advanced_transformer.hpp

모든 수식이 실제 C++ 코드와 1:1 대응되어 이론과 실제 구현의 완벽한 일치를 보장합니다.

22.1 실시간 코딩 요청 처리: "C언어로 helloworld를 짜줘"

#include <stdio.h>

int main() {
    printf("Hello World\n");
    return 0;
}

22.2 고급 추론 분석

22.3 실시간 추론 최적화

22.4 코드 품질 검증 시스템

실제 ChatGPT 시스템은 이러한 기본 원리에 RLHF(인간 피드백 강화학습), Constitutional AI 등의 고급 기법을 추가로 적용합니다.