LLM 미팅 [metric performance code]

from collections import Counter
import math
import numpy as np
from typing import List, Dict, Tuple

class BeerScorer:
    def __init__(self):
        # 가중치 설정 (실제 BEER 논문의 가중치와는 다를 수 있음)
        self.weights = {
            'char_ngram': 0.4,
            'word_ngram': 0.4,
            'length_penalty': 0.2
        }
        
    def get_char_ngrams(self, text: str, n: int) -> Counter:
        """문자 n-gram을 추출합니다."""
        chars = list(text.lower())
        return Counter([''.join(chars[i:i+n]) for i in range(len(chars)-n+1)])
    
    def get_word_ngrams(self, text: str, n: int) -> Counter:
        """단어 n-gram을 추출합니다."""
        words = text.lower().split()
        return Counter([' '.join(words[i:i+n]) for i in range(len(words)-n+1)])
    
    def calculate_precision_recall_f1(self, ref_counts: Counter, 
                                    cand_counts: Counter) -> Tuple[float, float, float]:
        """정밀도, 재현율, F1 점수를 계산합니다."""
        common = sum((ref_counts & cand_counts).values())
        ref_total = sum(ref_counts.values())
        cand_total = sum(cand_counts.values())
        
        precision = common / cand_total if cand_total > 0 else 0
        recall = common / ref_total if ref_total > 0 else 0
        
        if precision + recall > 0:
            f1 = 2 * (precision * recall) / (precision + recall)
        else:
            f1 = 0
            
        return precision, recall, f1
    
    def length_ratio_penalty(self, ref_len: int, cand_len: int) -> float:
        """길이 비율에 따른 페널티를 계산합니다."""
        ratio = cand_len / ref_len if ref_len > 0 else 0
        return math.exp(-abs(1 - ratio))
    
    def calculate_beer_score(self, reference: str, candidate: str) -> float:
        """BEER 점수를 계산합니다."""
        # 문자 n-gram (n=4) 계산
        ref_char_ngrams = self.get_char_ngrams(reference, 4)
        cand_char_ngrams = self.get_char_ngrams(candidate, 4)
        char_prec, char_rec, char_f1 = self.calculate_precision_recall_f1(
            ref_char_ngrams, cand_char_ngrams)
        
        # 단어 n-gram (n=2) 계산
        ref_word_ngrams = self.get_word_ngrams(reference, 2)
        cand_word_ngrams = self.get_word_ngrams(candidate, 2)
        word_prec, word_rec, word_f1 = self.calculate_precision_recall_f1(
            ref_word_ngrams, cand_word_ngrams)
        
        # 길이 페널티 계산
        length_penalty = self.length_ratio_penalty(
            len(reference.split()), len(candidate.split()))
        
        # 최종 BEER 점수 계산
        beer_score = (
            self.weights['char_ngram'] * char_f1 +
            self.weights['word_ngram'] * word_f1 +
            self.weights['length_penalty'] * length_penalty
        )
        
        return beer_score

# 사용 예시
def print_beer_score(reference: str, candidate: str):
    scorer = BeerScorer()
    score = scorer.calculate_beer_score(reference, candidate)
    print(f"BEER Score: {score:.4f}")

if __name__ == "__main__":
    # 예시 문장
    reference = "이것은 참조 문장입니다."
    candidate = "이것은 후보 문장입니다."
    
    print_beer_score(reference, candidate)