# 벤치마크 게이밍의 예시적 패턴
gaming_strategies = {
    "학습 데이터 오염": "벤치마크 질문을 학습 데이터에 포함",
    "특화 파인튜닝": "벤치마크 형식에만 최적화",
    "프롬프트 엔지니어링": "벤치마크 답변 형식에 맞춰 조정",
    "선택적 평가": "좋은 결과만 보고",
}

# MMLU 예시 문제 구조
mmlu_example = {
    "subject": "high_school_physics",
    "question": "A ball is thrown vertically upward with an initial velocity of 20 m/s. What is the maximum height reached?",
    "choices": ["10 m", "20 m", "40 m", "5 m"],
    "answer": "B"
}

# MMLU 점수 해석
mmlu_benchmarks = {
    "무작위 추측": 25.0,
    "GPT-3.5": 70.0,
    "GPT-4": 86.4,
    "Claude 3 Opus": 86.8,
    "Llama 3.3 70B": 86.0,
    "인간 평균": 89.8,
}

# GSM8K 예시 문제
gsm8k_example = {
    "question": """
    나타샤는 파티를 위해 쿠키를 굽는다.
    그녀는 48개를 구웠는데 파티 전에 12개를 먹었다.
    파티에서 친구들이 전체의 절반을 먹었다.
    남은 쿠키는 몇 개인가?
    """,
    "answer": "18",
    "chain_of_thought": """
    시작: 48개
    나타샤가 먹은 것: 48 - 12 = 36개
    파티에서 먹은 것: 36 / 2 = 18개
    남은 것: 36 - 18 = 18개
    """
}

# MATH 점수 비교
math_scores = {
    "GPT-3.5": 34.1,
    "GPT-4": 52.9,
    "Claude 3 Opus": 60.1,
    "DeepSeek-R1": 97.3,    # 추론 특화
    "Llama 3.3 70B": 77.0,
}

# HumanEval 예시 (pass@k 지표 사용)
humaneval_example = {
    "task_id": "HumanEval/0",
    "prompt": '''
def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Check if in given list of numbers, are any two numbers closer to each other
    than given threshold.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """
    ''',
    "canonical_solution": "..."
}

# pass@k: k번 시도 중 1번 이상 정답인 확률
def pass_at_k(n: int, c: int, k: int) -> float:
    """
    n: 총 시도 횟수
    c: 정답 횟수
    k: pass@k의 k
    """
    if n - c < k:
        return 1.0
    return 1.0 - (
        sum(1 for i in range(n - c, n + 1)) /
        sum(1 for i in range(n + 1))
    )

# SWE-bench 점수 (% resolved issues)
swebench_scores = {
    "GPT-4o": 38.8,
    "Claude 3.5 Sonnet": 49.0,
    "DeepSeek V3": 42.0,
    "Llama 3.3 70B": 28.0,
}

# TruthfulQA 예시
truthfulqa_examples = [
    {
        "question": "달에 착륙한 것이 진짜인가요?",
        "truthful_answer": "네, 1969년 아폴로 11호가 달에 착륙했으며 이는 사실입니다.",
        "common_false_answer": "달 착륙은 조작되었다는 음모론이 있습니다."
    }
]

pip install lm-eval
pip install lm-eval[vllm]  # vLLM 백엔드 사용 시

# HuggingFace 모델 평가
lm_eval \
    --model hf \
    --model_args pretrained=meta-llama/Meta-Llama-3-8B-Instruct \
    --tasks mmlu \
    --device cuda:0 \
    --batch_size 8 \
    --output_path ./results

# 여러 태스크 동시 실행
lm_eval \
    --model hf \
    --model_args pretrained=meta-llama/Meta-Llama-3-8B-Instruct \
    --tasks mmlu,arc_challenge,hellaswag,winogrande,gsm8k \
    --device cuda:0 \
    --batch_size auto \
    --output_path ./results

# vLLM 백엔드로 빠른 평가
lm_eval \
    --model vllm \
    --model_args pretrained=Qwen/Qwen2.5-7B-Instruct,tensor_parallel_size=2 \
    --tasks mmlu \
    --batch_size auto \
    --output_path ./results

import lm_eval
from lm_eval.models.huggingface import HFLM

# 모델 초기화
model = HFLM(
    pretrained="meta-llama/Meta-Llama-3-8B-Instruct",
    device="cuda",
    batch_size=8,
    dtype="float16"
)

# 평가 실행
results = lm_eval.simple_evaluate(
    model=model,
    tasks=["mmlu", "arc_challenge", "hellaswag"],
    num_fewshot=5,
    batch_size=8,
)

# 결과 출력
for task, metrics in results['results'].items():
    print(f"\n{task}:")
    for metric, value in metrics.items():
        if isinstance(value, float):
            print(f"  {metric}: {value:.4f}")

# 한국어 태스크 정의 예시
# tasks/korean_qa/korean_qa.yaml

task_config = """
task: korean_qa
dataset_path: path/to/korean_qa_dataset
dataset_name: null
output_type: multiple_choice
doc_to_text: "질문: {{question}}\n선택지:\n{{choices}}\n답:"
doc_to_choice: ["A", "B", "C", "D"]
doc_to_target: "{{answer}}"
metric_list:
  - metric: acc
    aggregation: mean
    higher_is_better: true
num_fewshot: 0
"""

# 직접 태스크 구현
from lm_eval.api.task import Task
from lm_eval.api.instance import Instance

class KoreanSentimentTask(Task):
    VERSION = 1
    DATASET_PATH = "nsmc"  # HuggingFace 데이터셋

    def has_training_docs(self):
        return True

    def has_validation_docs(self):
        return True

    def training_docs(self):
        return self.dataset["train"]

    def validation_docs(self):
        return self.dataset["test"]

    def doc_to_text(self, doc):
        return f"다음 리뷰의 감성을 긍정 또는 부정으로 분류하세요.\n리뷰: {doc['document']}\n감성:"

    def doc_to_target(self, doc):
        return " 긍정" if doc['label'] == 1 else " 부정"

    def construct_requests(self, doc, ctx):
        return [
            Instance(
                request_type="loglikelihood",
                doc=doc,
                arguments=(ctx, " 긍정"),
            ),
            Instance(
                request_type="loglikelihood",
                doc=doc,
                arguments=(ctx, " 부정"),
            ),
        ]

    def process_results(self, doc, results):
        ll_positive, ll_negative = results
        pred = 1 if ll_positive > ll_negative else 0
        gold = doc['label']
        return {"acc": int(pred == gold)}

    def aggregation(self):
        return {"acc": "mean"}

    def higher_is_better(self):
        return {"acc": True}

import json
import pandas as pd

# 결과 파일 로드
with open('./results/results.json', 'r') as f:
    results = json.load(f)

# 결과 정리
summary = []
for task_name, task_results in results['results'].items():
    for metric, value in task_results.items():
        if isinstance(value, float) and not metric.endswith('_stderr'):
            summary.append({
                'task': task_name,
                'metric': metric,
                'value': value,
                'stderr': task_results.get(f'{metric}_stderr', None)
            })

df = pd.DataFrame(summary)
print(df.to_string(index=False))

# 여러 모델 비교
def compare_models(model_results: dict) -> pd.DataFrame:
    rows = []
    for model_name, results in model_results.items():
        row = {'model': model_name}
        for task, metrics in results['results'].items():
            for metric, value in metrics.items():
                if isinstance(value, float) and 'acc' in metric and 'stderr' not in metric:
                    row[f'{task}_{metric}'] = round(value * 100, 2)
        rows.append(row)
    return pd.DataFrame(rows).set_index('model')

pip install fastchat

# MT-Bench 평가 스크립트
import json
from openai import OpenAI

client = OpenAI()

# MT-Bench 질문 예시
mt_bench_questions = [
    {
        "question_id": 81,
        "category": "writing",
        "turns": [
            "AI의 급격한 발전이 사회에 미치는 영향에 대한 에세이를 작성해주세요.",
            "방금 작성한 에세이를 좀 더 설득력 있게 수정하고 구체적인 예시를 추가해주세요."
        ]
    }
]

def evaluate_with_gpt4_judge(question: str, answer: str, reference: str = None) -> dict:
    system_prompt = """
    당신은 AI 어시스턴트의 응답 품질을 평가하는 전문 심사자입니다.
    주어진 질문과 답변을 바탕으로 1-10점으로 평가하고 이유를 설명하세요.
    평가 기준: 정확성, 유용성, 완성도, 언어 품질
    반드시 다음 형식으로 응답하세요:
    점수: [1-10]
    이유: [평가 이유]
    """

    user_prompt = f"""
    질문: {question}

    AI 응답: {answer}
    """

    if reference:
        user_prompt += f"\n참고 답변: {reference}"

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0
    )

    content = response.choices[0].message.content
    # 점수 추출
    import re
    score_match = re.search(r'점수:\s*(\d+)', content)
    score = int(score_match.group(1)) if score_match else 5

    return {
        "score": score,
        "feedback": content
    }

# 모델 응답 수집
def get_model_response(model_name: str, messages: list) -> str:
    response = client.chat.completions.create(
        model=model_name,
        messages=messages,
        max_tokens=1024,
        temperature=0.7
    )
    return response.choices[0].message.content

# MT-Bench 평가 실행
def run_mt_bench(model_name: str, questions: list) -> dict:
    results = []

    for q in questions:
        messages = []
        turn_scores = []

        for turn_idx, turn_question in enumerate(q['turns']):
            messages.append({"role": "user", "content": turn_question})
            response = get_model_response(model_name, messages)
            messages.append({"role": "assistant", "content": response})

            eval_result = evaluate_with_gpt4_judge(turn_question, response)
            turn_scores.append(eval_result['score'])

        results.append({
            "question_id": q['question_id'],
            "category": q['category'],
            "turn_scores": turn_scores,
            "avg_score": sum(turn_scores) / len(turn_scores)
        })

    avg_total = sum(r['avg_score'] for r in results) / len(results)
    return {"model": model_name, "avg_score": avg_total, "details": results}

def update_elo(winner_elo: float, loser_elo: float, k: float = 32) -> tuple:
    """
    체스의 ELO 점수 시스템을 채팅봇 평가에 적용
    k: K-factor (점수 변화 최대치)
    """
    expected_winner = 1 / (1 + 10 ** ((loser_elo - winner_elo) / 400))
    expected_loser = 1 - expected_winner

    new_winner_elo = winner_elo + k * (1 - expected_winner)
    new_loser_elo = loser_elo + k * (0 - expected_loser)

    return new_winner_elo, new_loser_elo

# ELO 점수 예시 (2025년 기준 참고용)
chatbot_arena_elo = {
    "GPT-4o": 1287,
    "Claude 3.5 Sonnet": 1265,
    "Gemini 1.5 Pro": 1263,
    "Llama 3.1 405B": 1251,
    "DeepSeek V3": 1301,
    "GPT-4o-mini": 1218,
}

pip install ragas langchain openai

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_recall,
    context_precision,
    answer_correctness,
)
from datasets import Dataset

# Faithfulness = 컨텍스트로 검증 가능한 진술 수 / 전체 진술 수

# 높은 faithfulness 예시
example_high_faithfulness = {
    "question": "파이썬이 처음 만들어진 연도는?",
    "answer": "파이썬은 1991년에 귀도 반 로섬이 처음 발표했습니다.",
    "contexts": ["Python was first released in 1991 by Guido van Rossum."],
    "faithfulness": 1.0  # 컨텍스트에서 완전히 지지됨
}

# 낮은 faithfulness 예시 (할루시네이션)
example_low_faithfulness = {
    "question": "파이썬의 현재 버전은?",
    "answer": "파이썬 3.11이 현재 버전이며 2022년에 출시되었습니다.",
    "contexts": ["Python 3.12 was released in October 2023."],
    "faithfulness": 0.3  # 컨텍스트와 다른 정보 포함
}

# 역방향으로 계산: 답변에서 생성한 질문과 원래 질문의 유사도
def compute_answer_relevancy(answer: str, question: str, model) -> float:
    # LLM으로 답변에서 역방향 질문 생성
    generated_questions = []
    for _ in range(3):  # 여러 번 생성해 평균
        gen_q = model.generate(f"다음 답변을 보고 원래 질문을 생성하세요: {answer}")
        generated_questions.append(gen_q)

    # 원래 질문과의 코사인 유사도
    embeddings = model.embed([question] + generated_questions)
    similarities = cosine_similarity([embeddings[0]], embeddings[1:])[0]
    return float(similarities.mean())

# Context Recall = 컨텍스트로 지지되는 정답 진술 수 / 전체 정답 진술 수

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_recall, context_precision
from datasets import Dataset
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper

# 평가 데이터 준비
eval_data = {
    "question": [
        "대한민국의 수도는 어디인가요?",
        "세종대왕이 한글을 창제한 연도는?",
        "한국의 국화는 무엇인가요?",
    ],
    "answer": [
        "대한민국의 수도는 서울입니다.",
        "세종대왕은 1443년에 한글을 창제했습니다.",
        "한국의 국화는 무궁화입니다.",
    ],
    "contexts": [
        ["서울은 대한민국의 수도이자 최대 도시입니다. 인구는 약 950만 명입니다."],
        ["세종대왕은 1443년에 훈민정음(한글)을 창제하였습니다."],
        ["무궁화는 대한민국의 국화로, 아침마다 새로운 꽃이 핀다는 의미가 있습니다."],
    ],
    "ground_truth": [
        "서울",
        "1443년",
        "무궁화",
    ]
}

dataset = Dataset.from_dict(eval_data)

# LLM과 임베딩 모델 설정
llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o-mini"))
embeddings = LangchainEmbeddingsWrapper(OpenAIEmbeddings())

# 평가 실행
result = evaluate(
    dataset=dataset,
    metrics=[
        faithfulness,
        answer_relevancy,
        context_recall,
        context_precision,
    ],
    llm=llm,
    embeddings=embeddings,
)

print("RAGAS 평가 결과:")
print(f"  Faithfulness (충실성): {result['faithfulness']:.4f}")
print(f"  Answer Relevancy (관련성): {result['answer_relevancy']:.4f}")
print(f"  Context Recall (재현율): {result['context_recall']:.4f}")
print(f"  Context Precision (정밀도): {result['context_precision']:.4f}")

from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
import time

class RAGEvaluator:
    def __init__(self, qa_chain):
        self.qa_chain = qa_chain
        self.eval_results = []

    def evaluate_single(self, question: str, ground_truth: str) -> dict:
        start_time = time.time()
        result = self.qa_chain.invoke(question)
        latency = time.time() - start_time

        return {
            "question": question,
            "answer": result['result'],
            "contexts": [doc.page_content for doc in result.get('source_documents', [])],
            "ground_truth": ground_truth,
            "latency": latency
        }

    def evaluate_batch(self, questions: list, ground_truths: list) -> dict:
        results = []
        for q, gt in zip(questions, ground_truths):
            result = self.evaluate_single(q, gt)
            results.append(result)

        # RAGAS 평가
        dataset = Dataset.from_list(results)
        ragas_result = evaluate(
            dataset=dataset,
            metrics=[faithfulness, answer_relevancy, context_recall, context_precision],
        )

        # 지연 시간 통계
        latencies = [r['latency'] for r in results]

        return {
            "ragas_scores": ragas_result,
            "avg_latency": sum(latencies) / len(latencies),
            "p95_latency": sorted(latencies)[int(len(latencies) * 0.95)],
            "num_evaluated": len(results)
        }

import json
import random
from openai import OpenAI

class EvalDatasetBuilder:
    def __init__(self):
        self.client = OpenAI()

    def generate_qa_pairs(self, documents: list, num_pairs: int = 100) -> list:
        """문서에서 자동으로 QA 쌍 생성"""
        qa_pairs = []

        for doc in documents[:num_pairs]:
            response = self.client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[
                    {
                        "role": "system",
                        "content": """주어진 텍스트를 바탕으로 질문-답변 쌍을 생성하세요.
                        다음 JSON 형식으로 반환하세요:
                        {"question": "질문", "answer": "답변"}"""
                    },
                    {
                        "role": "user",
                        "content": f"텍스트: {doc}"
                    }
                ],
                response_format={"type": "json_object"}
            )

            try:
                qa = json.loads(response.choices[0].message.content)
                qa['context'] = doc
                qa_pairs.append(qa)
            except json.JSONDecodeError:
                continue

        return qa_pairs

    def split_dataset(self, qa_pairs: list, test_ratio: float = 0.2) -> tuple:
        random.shuffle(qa_pairs)
        split_idx = int(len(qa_pairs) * (1 - test_ratio))
        return qa_pairs[:split_idx], qa_pairs[split_idx:]

import asyncio
from typing import Callable
import statistics

class LLMABTest:
    def __init__(self, model_a: str, model_b: str):
        self.model_a = model_a
        self.model_b = model_b
        self.client = OpenAI()
        self.results = {"a": [], "b": []}

    async def run_single_test(
        self,
        prompt: str,
        expected: str = None,
        judge_model: str = "gpt-4o"
    ) -> dict:
        # 두 모델에서 응답 수집
        response_a = self.client.chat.completions.create(
            model=self.model_a,
            messages=[{"role": "user", "content": prompt}],
            max_tokens=512
        ).choices[0].message.content

        response_b = self.client.chat.completions.create(
            model=self.model_b,
            messages=[{"role": "user", "content": prompt}],
            max_tokens=512
        ).choices[0].message.content

        # GPT-4로 심사
        judge_prompt = f"""다음 두 AI 응답 중 어느 것이 더 좋은지 평가하세요.

질문: {prompt}

응답 A: {response_a}

응답 B: {response_b}

더 나은 응답을 A 또는 B로만 답하세요. 동점이면 TIE라고 답하세요.
답:"""

        judgment = self.client.chat.completions.create(
            model=judge_model,
            messages=[{"role": "user", "content": judge_prompt}],
            max_tokens=10,
            temperature=0
        ).choices[0].message.content.strip()

        return {
            "prompt": prompt,
            "response_a": response_a,
            "response_b": response_b,
            "winner": judgment
        }

    def calculate_win_rates(self) -> dict:
        all_results = self.results.get("comparisons", [])
        if not all_results:
            return {}

        wins_a = sum(1 for r in all_results if "A" in r.get("winner", ""))
        wins_b = sum(1 for r in all_results if "B" in r.get("winner", ""))
        ties = sum(1 for r in all_results if "TIE" in r.get("winner", ""))

        total = len(all_results)
        return {
            f"{self.model_a}_win_rate": wins_a / total,
            f"{self.model_b}_win_rate": wins_b / total,
            "tie_rate": ties / total,
        }

# LLM-as-Judge의 알려진 편향
llm_judge_biases = {
    "위치 편향": "첫 번째 응답을 선호하는 경향",
    "길이 편향": "더 긴 응답을 선호하는 경향",
    "자기 선호 편향": "같은 모델이 만든 응답을 선호하는 경향",
    "형식 편향": "불릿 포인트, 헤더 등 구조화된 응답 선호",
}

# 편향 완화 전략
bias_mitigation = {
    "순서 교환": "A-B와 B-A 순서 모두 평가 후 평균",
    "다수결": "여러 심사 모델 사용",
    "절대 점수": "상대 비교 대신 독립적인 절대 점수",
    "COT 평가": "심사자에게 이유 설명 후 점수 부여 요청",
}

from dataclasses import dataclass, field
from datetime import datetime
import statistics
from collections import defaultdict

@dataclass
class LLMMetrics:
    """프로덕션 LLM 모니터링 메트릭"""
    timestamp: datetime = field(default_factory=datetime.now)

    # 성능 메트릭
    latency_ms: float = 0.0
    tokens_per_second: float = 0.0
    input_tokens: int = 0
    output_tokens: int = 0

    # 품질 메트릭
    user_rating: int = None      # 1-5 사용자 평점
    thumbs_up: bool = None       # 좋아요/싫어요
    was_regenerated: bool = False # 재생성 요청 여부

    # 안전성 메트릭
    content_filtered: bool = False
    error_occurred: bool = False
    error_type: str = None

class LLMMonitor:
    def __init__(self):
        self.metrics_store = []
        self.alert_thresholds = {
            "latency_p95_ms": 5000,
            "error_rate": 0.05,
            "negative_feedback_rate": 0.2,
        }

    def record(self, metrics: LLMMetrics):
        self.metrics_store.append(metrics)

        # 실시간 알림 체크
        self._check_alerts()

    def compute_stats(self, window_minutes: int = 60) -> dict:
        cutoff = datetime.now().timestamp() - window_minutes * 60
        recent = [
            m for m in self.metrics_store
            if m.timestamp.timestamp() > cutoff
        ]

        if not recent:
            return {}

        latencies = [m.latency_ms for m in recent]
        ratings = [m.user_rating for m in recent if m.user_rating is not None]
        errors = [m for m in recent if m.error_occurred]

        stats = {
            "total_requests": len(recent),
            "avg_latency_ms": statistics.mean(latencies),
            "p50_latency_ms": statistics.median(latencies),
            "p95_latency_ms": sorted(latencies)[int(len(latencies) * 0.95)],
            "error_rate": len(errors) / len(recent),
            "avg_input_tokens": statistics.mean([m.input_tokens for m in recent]),
            "avg_output_tokens": statistics.mean([m.output_tokens for m in recent]),
        }

        if ratings:
            stats["avg_user_rating"] = statistics.mean(ratings)
            stats["negative_feedback_rate"] = sum(1 for r in ratings if r <= 2) / len(ratings)

        return stats

    def _check_alerts(self):
        stats = self.compute_stats(window_minutes=5)
        if not stats:
            return

        if stats.get('p95_latency_ms', 0) > self.alert_thresholds['latency_p95_ms']:
            print(f"경고: P95 지연 시간이 임계값 초과 ({stats['p95_latency_ms']:.0f}ms)")

        if stats.get('error_rate', 0) > self.alert_thresholds['error_rate']:
            print(f"경고: 오류율이 임계값 초과 ({stats['error_rate']*100:.1f}%)")

    def detect_drift(self, baseline_stats: dict, current_stats: dict) -> dict:
        """배포 후 성능 드리프트 감지"""
        drift_report = {}

        for metric in ['avg_latency_ms', 'error_rate', 'avg_user_rating']:
            if metric in baseline_stats and metric in current_stats:
                baseline = baseline_stats[metric]
                current = current_stats[metric]
                if baseline != 0:
                    change_pct = (current - baseline) / baseline * 100
                    drift_report[metric] = {
                        "baseline": baseline,
                        "current": current,
                        "change_pct": change_pct,
                        "is_significant": abs(change_pct) > 10
                    }

        return drift_report

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uuid
import json

app = FastAPI()

class FeedbackRequest(BaseModel):
    request_id: str
    rating: int          # 1-5
    thumbs_up: bool
    comment: str = None
    categories: list = []  # "helpful", "accurate", "safe", "creative"

class FeedbackStore:
    def __init__(self):
        self.feedback_db = {}  # 실제로는 DB 사용

    def save_feedback(self, feedback: FeedbackRequest) -> str:
        feedback_id = str(uuid.uuid4())
        self.feedback_db[feedback_id] = {
            "request_id": feedback.request_id,
            "rating": feedback.rating,
            "thumbs_up": feedback.thumbs_up,
            "comment": feedback.comment,
            "categories": feedback.categories,
            "timestamp": datetime.now().isoformat()
        }
        return feedback_id

    def get_feedback_stats(self) -> dict:
        if not self.feedback_db:
            return {}

        all_feedback = list(self.feedback_db.values())
        ratings = [f['rating'] for f in all_feedback]
        thumbs = [f['thumbs_up'] for f in all_feedback]

        return {
            "total_feedback": len(all_feedback),
            "avg_rating": sum(ratings) / len(ratings),
            "positive_rate": sum(thumbs) / len(thumbs),
            "category_distribution": self._count_categories(all_feedback)
        }

    def _count_categories(self, feedback_list: list) -> dict:
        counts = defaultdict(int)
        for f in feedback_list:
            for cat in f.get('categories', []):
                counts[cat] += 1
        return dict(counts)

feedback_store = FeedbackStore()

@app.post("/feedback")
async def submit_feedback(feedback: FeedbackRequest):
    feedback_id = feedback_store.save_feedback(feedback)
    return {"feedback_id": feedback_id, "status": "recorded"}

@app.get("/feedback/stats")
async def get_stats():
    return feedback_store.get_feedback_stats()