# 기본 Seq2Seq 설정
config = {
    "encoder": {
        "vocab_size": 32000,
        "embed_dim": 256,
        "hidden_dim": 512,
        "num_layers": 2,
        "bidirectional": True,
        "dropout": 0.1
    },
    "decoder": {
        "vocab_size": 32000,
        "embed_dim": 256,
        "hidden_dim": 512,
        "num_layers": 2,
        "dropout": 0.1
    }
}

def analyze_position_accuracy(source, reference, hypothesis):
    """
    문장 내 위치별 번역 정확도 분석
    """
    # 문장을 5등분하여 각 구간의 정확도 측정
    # Front (0-20%), Mid-Front (20-40%), Middle (40-60%),
    # Mid-Back (60-80%), Back (80-100%)
    ...

def measure_information_content(encoder, sentences_by_length):
    """
    문장 길이별 context vector의 effective rank 측정
    """
    results = {}

    for length_group, sentences in sentences_by_length.items():
        context_vectors = []

        for sent in sentences:
            src = tokenize(sent)
            _, hidden, _ = encoder(src)
            context_vectors.append(hidden.detach().numpy())

        # SVD로 effective rank 계산
        matrix = np.stack(context_vectors)
        _, s, _ = np.linalg.svd(matrix)

        # Effective rank (Shannon entropy of normalized singular values)
        s_norm = s / s.sum()
        effective_rank = np.exp(-np.sum(s_norm * np.log(s_norm + 1e-10)))

        results[length_group] = effective_rank

    return results

import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

def visualize_bottleneck(encoder, short_sentences, long_sentences):
    """
    t-SNE로 context vector 분포 시각화
    """
    # 짧은 문장들의 context vector
    short_vectors = [encoder(s)[1] for s in short_sentences]

    # 긴 문장들의 context vector
    long_vectors = [encoder(s)[1] for s in long_sentences]

    all_vectors = short_vectors + long_vectors
    labels = ['short'] * len(short_vectors) + ['long'] * len(long_vectors)

    # t-SNE 적용
    tsne = TSNE(n_components=2, perplexity=30)
    embedded = tsne.fit_transform(np.stack(all_vectors))

    # 시각화
    plt.figure(figsize=(10, 8))
    for label, color in [('short', 'blue'), ('long', 'red')]:
        mask = np.array(labels) == label
        plt.scatter(embedded[mask, 0], embedded[mask, 1],
                   c=color, label=label, alpha=0.6)
    plt.legend()
    plt.title('Context Vector Distribution (Short vs Long Sentences)')
    plt.show()

def analyze_gradient_by_position(model, src, tgt):
    """
    입력 토큰 위치별 gradient magnitude 측정
    """
    model.zero_grad()

    # Forward pass
    output = model(src, tgt)
    loss = F.cross_entropy(output.view(-1, output.size(-1)), tgt.view(-1))

    # Backward pass
    loss.backward()

    # 임베딩 gradient 추출
    embed_grad = model.encoder.embedding.weight.grad

    # 각 입력 토큰의 gradient magnitude
    gradients = []
    for pos, token_id in enumerate(src[0]):
        grad_magnitude = embed_grad[token_id].norm().item()
        gradients.append(grad_magnitude)

    return gradients

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from nltk.translate.bleu_score import corpus_bleu

def evaluate_by_length(model, test_data, length_buckets):
    """
    문장 길이별 BLEU score 평가
    """
    model.eval()
    results = {}

    for bucket_name, (min_len, max_len) in length_buckets.items():
        # 해당 길이의 문장만 필터링
        filtered_data = [
            (src, tgt) for src, tgt in test_data
            if min_len <= len(src.split()) <= max_len
        ]

        if len(filtered_data) == 0:
            continue

        predictions = []
        references = []

        for src, tgt in filtered_data:
            # 번역 생성
            pred = model.translate(src)
            predictions.append(pred.split())
            references.append([tgt.split()])

        # BLEU 계산
        bleu = corpus_bleu(references, predictions)
        results[bucket_name] = {
            'bleu': bleu * 100,
            'num_samples': len(filtered_data)
        }

    return results

# 실행
length_buckets = {
    '1-10': (1, 10),
    '11-20': (11, 20),
    '21-30': (21, 30),
    '31-40': (31, 40),
    '41-50': (41, 50),
    '51+': (51, 100)
}

results = evaluate_by_length(model, test_data, length_buckets)

for bucket, data in results.items():
    print(f"{bucket}: BLEU={data['bleu']:.1f} (n={data['num_samples']})")