model_v24/label_independence_analysis.py

import pickle
import json
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from scipy.stats import pearsonr, spearmanr
import warnings
warnings.filterwarnings('ignore')

# 한글 폰트 설정
plt.rcParams['font.family'] = 'DejaVu Sans'
plt.rcParams['axes.unicode_minus'] = False

def load_label_data():
    """라벨 관련 데이터 로드"""
    # 라벨 매핑 로드
    with open('label_mapping.json', 'r', encoding='utf-8') as f:
        label_mapping = json.load(f)
    
    # 라벨 임베딩 로드
    with open('label_embeddings.pkl', 'rb') as f:
        label_embeddings = pickle.load(f)
    
    return label_mapping, label_embeddings

def analyze_label_similarity(label_embeddings, label_mapping):
    """라벨 간 유사도 분석"""
    print("=== 라벨 간 유사도 분석 ===")
    
    # 코사인 유사도 계산
    similarity_matrix = cosine_similarity(label_embeddings)
    
    # 유사도 통계
    print(f"라벨 개수: {len(label_embeddings)}")
    print(f"임베딩 차원: {label_embeddings.shape[1]}")
    print(f"평균 유사도: {np.mean(similarity_matrix):.4f}")
    print(f"유사도 표준편차: {np.std(similarity_matrix):.4f}")
    print(f"최대 유사도: {np.max(similarity_matrix):.4f}")
    print(f"최소 유사도: {np.min(similarity_matrix):.4f}")
    
    # 가장 유사한 라벨 쌍 찾기
    np.fill_diagonal(similarity_matrix, 0)  # 자기 자신 제외
    max_sim_idx = np.unravel_index(np.argmax(similarity_matrix), similarity_matrix.shape)
    max_sim_value = similarity_matrix[max_sim_idx]
    
    labels = list(label_mapping.keys())
    print(f"\n가장 유사한 라벨 쌍:")
    print(f"  {labels[max_sim_idx[0]]} <-> {labels[max_sim_idx[1]]}: {max_sim_value:.4f}")
    
    return similarity_matrix

def analyze_label_correlation(label_embeddings, label_mapping):
    """라벨 임베딩 간 상관관계 분석"""
    print("\n=== 라벨 임베딩 상관관계 분석 ===")
    
    # 피어슨 상관계수 계산
    corr_matrix = np.corrcoef(label_embeddings.T)
    
    # 상관계수 통계
    print(f"평균 상관계수: {np.mean(corr_matrix):.4f}")
    print(f"상관계수 표준편차: {np.std(corr_matrix):.4f}")
    print(f"최대 상관계수: {np.max(corr_matrix):.4f}")
    print(f"최소 상관계수: {np.min(corr_matrix):.4f}")
    
    # 높은 상관관계를 가진 특성 쌍 찾기
    np.fill_diagonal(corr_matrix, 0)
    high_corr_threshold = 0.8
    high_corr_pairs = np.where(np.abs(corr_matrix) > high_corr_threshold)
    
    print(f"\n높은 상관관계 (|r| > {high_corr_threshold})를 가진 특성 쌍 수: {len(high_corr_pairs[0])}")
    
    return corr_matrix

def analyze_label_distribution(label_embeddings, label_mapping):
    """라벨 분포 분석"""
    print("\n=== 라벨 분포 분석 ===")
    
    # 각 라벨 임베딩의 L2 노름 (크기)
    embedding_norms = np.linalg.norm(label_embeddings, axis=1)
    
    print(f"임베딩 크기 통계:")
    print(f"  평균: {np.mean(embedding_norms):.4f}")
    print(f"  표준편차: {np.std(embedding_norms):.4f}")
    print(f"  최대: {np.max(embedding_norms):.4f}")
    print(f"  최소: {np.min(embedding_norms):.4f}")
    
    # 크기가 가장 큰/작은 라벨
    labels = list(label_mapping.keys())
    max_norm_idx = np.argmax(embedding_norms)
    min_norm_idx = np.argmin(embedding_norms)
    
    print(f"\n가장 큰 임베딩 크기: {labels[max_norm_idx]} ({embedding_norms[max_norm_idx]:.4f})")
    print(f"가장 작은 임베딩 크기: {labels[min_norm_idx]} ({embedding_norms[min_norm_idx]:.4f})")
    
    return embedding_norms

def visualize_label_embeddings(label_embeddings, label_mapping):
    """라벨 임베딩 시각화"""
    print("\n=== 라벨 임베딩 시각화 ===")
    
    # PCA로 차원 축소
    pca = PCA(n_components=2)
    embeddings_2d = pca.fit_transform(label_embeddings)
    
    # t-SNE로 차원 축소
    tsne = TSNE(n_components=2, random_state=42, perplexity=min(30, len(label_embeddings)-1))
    embeddings_tsne = tsne.fit_transform(label_embeddings)
    
    # 시각화
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
    
    labels = list(label_mapping.keys())
    
    # PCA 시각화
    ax1.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1], alpha=0.7)
    ax1.set_title('PCA Visualization of Label Embeddings')
    ax1.set_xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.2%} variance)')
    ax1.set_ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.2%} variance)')
    
    # t-SNE 시각화
    ax2.scatter(embeddings_tsne[:, 0], embeddings_tsne[:, 1], alpha=0.7)
    ax2.set_title('t-SNE Visualization of Label Embeddings')
    ax2.set_xlabel('t-SNE 1')
    ax2.set_ylabel('t-SNE 2')
    
    plt.tight_layout()
    plt.savefig('label_embeddings_visualization.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print(f"PCA 설명된 분산 비율: {pca.explained_variance_ratio_[:2]}")
    print(f"총 설명된 분산 비율: {np.sum(pca.explained_variance_ratio_[:2]):.4f}")

def analyze_independence_metrics(label_embeddings, label_mapping):
    """독립성 지표 분석"""
    print("\n=== 독립성 지표 분석 ===")
    
    # 1. 라벨 간 평균 거리
    distances = []
    for i in range(len(label_embeddings)):
        for j in range(i+1, len(label_embeddings)):
            dist = np.linalg.norm(label_embeddings[i] - label_embeddings[j])
            distances.append(dist)
    
    print(f"라벨 간 평균 거리: {np.mean(distances):.4f}")
    print(f"라벨 간 거리 표준편차: {np.std(distances):.4f}")
    
    # 2. 라벨 임베딩의 직교성 (orthogonality)
    # 정규화된 임베딩으로 내적 계산
    normalized_embeddings = label_embeddings / np.linalg.norm(label_embeddings, axis=1, keepdims=True)
    dot_products = []
    
    for i in range(len(normalized_embeddings)):
        for j in range(i+1, len(normalized_embeddings)):
            dot_product = np.dot(normalized_embeddings[i], normalized_embeddings[j])
            dot_products.append(abs(dot_product))
    
    print(f"평균 내적 크기: {np.mean(dot_products):.4f}")
    print(f"내적 크기 표준편차: {np.std(dot_products):.4f}")
    
    # 3. 라벨 임베딩의 분산
    embedding_variance = np.var(label_embeddings, axis=0)
    print(f"임베딩 차원별 분산 평균: {np.mean(embedding_variance):.4f}")
    print(f"임베딩 차원별 분산 표준편차: {np.std(embedding_variance):.4f}")
    
    return distances, dot_products, embedding_variance

def main():
    """메인 분석 함수"""
    print("라벨과 입력 데이터 간의 독립성 분석을 시작합니다...")
    
    # 데이터 로드
    label_mapping, label_embeddings = load_label_data()
    
    # 라벨 임베딩을 numpy 배열로 변환
    if isinstance(label_embeddings, dict):
        # 딕셔너리인 경우 값들을 배열로 변환
        label_embeddings = np.array(list(label_embeddings.values()))
    elif isinstance(label_embeddings, list):
        # 리스트인 경우 numpy 배열로 변환
        label_embeddings = np.array(label_embeddings)
    
    print(f"로드된 라벨 임베딩 형태: {label_embeddings.shape}")
    
    # 1. 라벨 간 유사도 분석
    similarity_matrix = analyze_label_similarity(label_embeddings, label_mapping)
    
    # 2. 라벨 임베딩 상관관계 분석
    corr_matrix = analyze_label_correlation(label_embeddings, label_mapping)
    
    # 3. 라벨 분포 분석
    embedding_norms = analyze_label_distribution(label_embeddings, label_mapping)
    
    # 4. 독립성 지표 분석
    distances, dot_products, embedding_variance = analyze_independence_metrics(label_embeddings, label_mapping)
    
    # 5. 시각화
    visualize_label_embeddings(label_embeddings, label_mapping)
    
    # 종합 평가
    print("\n=== 종합 독립성 평가 ===")
    
    # 유사도 기반 평가
    avg_similarity = np.mean(similarity_matrix)
    if avg_similarity < 0.1:
        similarity_score = "매우 좋음"
    elif avg_similarity < 0.3:
        similarity_score = "좋음"
    elif avg_similarity < 0.5:
        similarity_score = "보통"
    else:
        similarity_score = "개선 필요"
    
    # 내적 기반 평가
    avg_dot_product = np.mean(dot_products)
    if avg_dot_product < 0.1:
        orthogonality_score = "매우 좋음"
    elif avg_dot_product < 0.3:
        orthogonality_score = "좋음"
    elif avg_dot_product < 0.5:
        orthogonality_score = "보통"
    else:
        orthogonality_score = "개선 필요"
    
    print(f"라벨 간 유사도 평가: {similarity_score} (평균 유사도: {avg_similarity:.4f})")
    print(f"라벨 직교성 평가: {orthogonality_score} (평균 내적: {avg_dot_product:.4f})")
    
    if similarity_score in ["매우 좋음", "좋음"] and orthogonality_score in ["매우 좋음", "좋음"]:
        print("전체 평가: 라벨과 입력 데이터 간의 독립성이 양호합니다.")
    elif similarity_score in ["보통"] and orthogonality_score in ["보통"]:
        print("전체 평가: 라벨과 입력 데이터 간의 독립성이 보통 수준입니다.")
    else:
        print("전체 평가: 라벨과 입력 데이터 간의 독립성 개선이 필요합니다.")

if __name__ == "__main__":
    main()