python scripts/data_extraction.py --blog_path "../../ardkyer.github.io"                                              ✔ │ base Py 
🚀 데이터 추출 시작 (.md + .markdown)
📁 _posts 처리 중...
  📄 파일 수: 83개
📁 _dev_logs 처리 중...
  📄 파일 수: 34개
📁 _further_reading 처리 중...
  📄 파일 수: 2개
📁 _paper_reviews 처리 중...
  📄 파일 수: 25개
\n📊 총 144개 파일 발견
\n✅ 144개 파일 추출 완료!
\n📁 컬렉션별 분포:
  post: 83개 (평균 463.6단어)
  dev_log: 34개 (평균 690.1단어)
  further_reading: 2개 (평균 54.5단어)
  paper_review: 25개 (평균 647.9단어)
\n📄 파일 확장자 분포:
  .md: 93개
  .markdown: 51개
\n📁 저장 완료: data/raw/all_posts_dataset.csv
\n🔍 샘플 데이터:
                                     filename collection                        title  word_count
0  2024-12-17- FastAPI를 활용한 Online Serving.md       post  FastAPI를 활용한 Online Serving         308
1                       2024-10-29- 추천시스템1.md       post                  베이스라인 오피스아워           5
2                2024-10-07- 공원,학교 피처 돌려보기.md       post        공원, 학교 피처 베이스라인에 넣어보기         411
3                  2024-09-13- 모델 학습 파이프라인.md       post                  모델 학습 파이프라인         624
4           2024-08-25-Week3 주간 학습정리.markdown       post                Week3 주간 학습정리          58

python scripts/baseline_analysis.py                                                                                1 х │ base Py 
🚀 베이스라인 추천시스템 분석 시작
============================================================
📊 데이터 로드 중...
✅ 게시물 데이터: 144개
✅ 기존 추천 데이터: 65개 게시물

============================================================
📋 베이스라인 성능 요약
============================================================
🔬 베이스라인 관련성 분석
==================================================
평균 관련성 점수: 0.105
분석된 추천 수: 229개
🎯 추천 다양성 분석...
평균 다양성 점수: 0.225
📈 추천 커버리지 분석...
커버리지: 0.174 (17.4%)
🔍 추천 패턴 분석...
게시물당 평균 추천 수: 4.6개
가장 많이 사용된 이유: 태그와 카테고리 유사성...
📊 데이터 요약:
  - 총 게시물: 144개
  - 추천 시스템 적용 게시물: 65개

🎯 베이스라인 성능:
  - 관련성 점수: 0.105
  - 다양성 점수: 0.225
  - 커버리지: 0.174

📈 성능 평가:
  ❌ 관련성 점수가 매우 낮습니다 (0.2 미만)
  ❌ 다양성이 매우 낮습니다
  ❌ 커버리지가 매우 낮습니다

💾 결과 저장 완료: results/baseline/baseline_analysis.json

🎉 베이스라인 분석 완료!
💡 다음 단계: 커스텀 ML 모델 개발로 성능 개선
🎯 목표: 관련성 점수 0.105 → 0.4+ (100%+ 개선)

BaselineAnalyzer 클래스
 ├─ __init__         : 파일 경로, 데이터 초기화
 ├─ load_data        : 게시물 CSV + 기존 추천 JSON 로드
 ├─ calculate_baseline_relevance : TF-IDF + cosine similarity로 관련성 계산
 ├─ calculate_diversity_score    : 추천들의 collection 다양성 측정
 ├─ calculate_coverage           : 추천된 게시물들이 전체 dataset의 몇 %인지
 ├─ analyze_recommendation_patterns : 추천 갯수, 이유 통계 분석
 ├─ generate_summary_report      : 모든 지표 종합 + 출력 + 저장
 └─ run_analysis                 : 전체 분석 프로세스 실행

보조 함수
 └─ convert_numpy_types           : numpy 타입을 Python 타입으로 바꿔 JSON 저장 대응

def load_data(self):
        """데이터 로드"""
        print("📊 데이터 로드 중...")
        
        self.df = pd.read_csv(self.data_path)
        print(f"✅ 게시물 데이터: {len(self.df)}개")
        
        try:
            rec_path = os.path.join(self.blog_path, '_data', 'related_posts.json')
            with open(rec_path, 'r', encoding='utf-8') as f:
                self.existing_recs = json.load(f)
            print(f"✅ 기존 추천 데이터: {len(self.existing_recs)}개 게시물")
        except Exception as e:
            print(f"⚠️ 기존 추천 데이터 로드 실패: {e}")
            self.existing_recs = {}

#!/usr/bin/env python3
"""
간결한 베이스라인 관련성 점수 분석 스크립트
"""

import pandas as pd
import json
import numpy as np
import os
import argparse
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class SimpleRelevanceAnalyzer:
    def __init__(self, data_path='data/raw/all_posts_dataset.csv', 
                 blog_path='../../ardkyer.github.io'):
        self.data_path = data_path
        self.blog_path = blog_path
        self.df = None
        self.existing_recs = {}
        
    def load_data(self):
        """데이터 로드"""
        print("📊 데이터 로드 중...")
        
        self.df = pd.read_csv(self.data_path)
        print(f"✅ 게시물 데이터: {len(self.df)}개")
        
        try:
            rec_path = os.path.join(self.blog_path, '_data', 'related_posts.json')
            with open(rec_path, 'r', encoding='utf-8') as f:
                self.existing_recs = json.load(f)
            print(f"✅ 기존 추천 데이터: {len(self.existing_recs)}개 게시물")
        except Exception as e:
            print(f"⚠️ 기존 추천 데이터 로드 실패: {e}")
            self.existing_recs = {}
    
    def calculate_relevance_score(self, sample_size=50):
        """관련성 점수 계산 (코사인 유사도 기반)"""
        print("🔬 관련성 점수 분석 중...")
        
        if not self.existing_recs:
            print("❌ 추천 데이터가 없습니다")
            return 0.0
        
        # TF-IDF 벡터화
        vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
        tfidf_matrix = vectorizer.fit_transform(self.df['content'].fillna(''))
        
        relevance_scores = []
        
        for url, recs in list(self.existing_recs.items())[:sample_size]:
            # 현재 포스트 찾기
            current_post_idx = None
            url_filename = url.split('/')[-1]
            
            for idx, row in self.df.iterrows():
                if (url_filename in row['filename'] or 
                    row['filename'].replace('.md', '').replace('.markdown', '') in url):
                    current_post_idx = idx
                    break
            
            if current_post_idx is None:
                continue
            
            # 각 추천 항목과의 유사도 계산
            for rec in recs:
                rec_post_idx = None
                
                for idx, row in self.df.iterrows():
                    if rec['title'] in row['title'] or row['title'] in rec['title']:
                        rec_post_idx = idx
                        break
                
                if rec_post_idx is not None:
                    similarity = cosine_similarity(
                        tfidf_matrix[current_post_idx], 
                        tfidf_matrix[rec_post_idx]
                    )[0][0]
                    relevance_scores.append(similarity)
        
        if relevance_scores:
            avg_relevance = float(np.mean(relevance_scores))
            print(f"📊 평균 관련성 점수: {avg_relevance:.3f}")
            print(f"📈 분석된 추천 수: {len(relevance_scores)}개")
            return avg_relevance
        else:
            print("❌ 분석 가능한 추천이 없습니다")
            return 0.0
    
    def run_analysis(self):
        """분석 실행"""
        print("🚀 관련성 점수 분석 시작")
        print("="*50)
        
        try:
            self.load_data()
            relevance_score = self.calculate_relevance_score()
            
            print("\n" + "="*50)
            print("📋 분석 결과")
            print("="*50)
            print(f"🎯 관련성 점수: {relevance_score:.3f}")
            
            # 성능 평가
            if relevance_score < 0.2:
                print("❌ 관련성 점수가 매우 낮습니다 (< 0.2)")
                improvement_needed = (0.4 - relevance_score) / relevance_score * 100
                print(f"💡 목표 달성을 위해 {improvement_needed:.0f}% 개선 필요")
            elif relevance_score < 0.4:
                print("⚠️ 관련성 점수가 낮습니다 (< 0.4)")
                improvement_needed = (0.4 - relevance_score) / relevance_score * 100
                print(f"💡 목표 달성을 위해 {improvement_needed:.0f}% 개선 필요")
            else:
                print("✅ 관련성 점수가 양호합니다")
            
            print(f"\n🎉 분석 완료!")
            return relevance_score
            
        except Exception as e:
            print(f"❌ 분석 중 오류 발생: {e}")
            raise

def main():
    parser = argparse.ArgumentParser(description="관련성 점수 분석")
    parser.add_argument('--data_path', default='data/raw/all_posts_dataset.csv')
    parser.add_argument('--blog_path', default='../../ardkyer.github.io')
    parser.add_argument('--sample_size', type=int, default=50, help='분석할 샘플 크기')
    
    args = parser.parse_args()
    
    analyzer = SimpleRelevanceAnalyzer(args.data_path, args.blog_path)
    score = analyzer.run_analysis()
    
    return score

if __name__ == "__main__":
    main()

vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
tfidf_matrix = vectorizer.fit_transform(self.df['content'].fillna(''))

corpus = [ 
    'you know I want your love', 
    'I like you', 
    'what should I do' 
]

📌 단어별 IDF 값
do: 1.693
know: 1.693
like: 1.693
love: 1.693
should: 1.693
want: 1.693
what: 1.693
you: 1.288
your: 1.693

📌 문서별 TF (Term Frequency)
문서 1: {'you': np.float64(0.16666666666666666), 'know': np.float64(0.16666666666666666), 'want': np.float64(0.16666666666666666), 'your': np.float64(0.16666666666666666), 'love': np.float64(0.16666666666666666), 'like': 0.0, 'what': 0.0, 'should': 0.0, 'do': 0.0}
문서 2: {'you': np.float64(0.3333333333333333), 'know': 0.0, 'want': 0.0, 'your': 0.0, 'love': 0.0, 'like': np.float64(0.3333333333333333), 'what': 0.0, 'should': 0.0, 'do': 0.0}
문서 3: {'you': 0.0, 'know': 0.0, 'want': 0.0, 'your': 0.0, 'love': 0.0, 'like': 0.0, 'what': np.float64(0.25), 'should': np.float64(0.25), 'do': np.float64(0.25)}

📌 정규화 전 TF×IDF 매트릭스
      do   know   like   love  should   want   what    you   your
0  0.000  1.693  0.000  1.693   0.000  1.693  0.000  1.288  1.693
1  0.000  0.000  1.693  0.000   0.000  0.000  0.000  1.288  0.000
2  1.693  0.000  0.000  0.000   1.693  0.000  1.693  0.000  0.000
you know I want your love

📌 L2 정규화된 TF×IDF 매트릭스
      do   know   like   love  should   want   what    you   your
0  0.000  0.467  0.000  0.467   0.000  0.467  0.000  0.355  0.467
1  0.000  0.000  0.796  0.000   0.000  0.000  0.000  0.605  0.000
2  0.577  0.000  0.000  0.000   0.577  0.000  0.577  0.000  0.000

# TF-IDF 벡터화
        vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
        tfidf_matrix = vectorizer.fit_transform(self.df['content'].fillna(''))

def calculate_baseline_relevance(self, sample_size=50):
        """베이스라인 관련성 점수 계산"""

idx  filename           title                    content
0    python-basics.md   "Python 기초 문법"        "변수, 함수, 클래스에 대해..."
1    django-tutorial.md "Django 웹 개발"          "웹 프레임워크 Django로..."
2    data-analysis.md   "데이터 분석 기초"         "pandas, numpy를 활용한..."
3    machine-learning.md "머신러닝 입문"           "scikit-learn을 사용해서..."

{
  "blog.com/python-basics": [
    {"title": "Django 웹 개발"},
    {"title": "데이터 분석 기초"}
  ],
  "blog.com/django-tutorial": [
    {"title": "Python 기초 문법"},
    {"title": "머신러닝 입문"}
  ]
}

BasicRecommendationGenerator 클래스
├─ load_data()                데이터 로딩
├─ create_tfidf_vectors()     TF-IDF 벡터화
├─ calculate_similarity()     코사인 유사도 계산
├─ generate_recommendations() 게시물별 추천 생성
├─ save_recommendations()     JSON 저장 + 통계
├─ preview_recommendations()  출력 미리보기
└─ run()                      전체 파이프라인 실행

python scripts/simple_anal.py                                                                       ✔ │ base Py 
🚀 관련성 점수 분석 시작
==================================================
📊 데이터 로드 중...
✅ 게시물 데이터: 144개
✅ 기존 추천 데이터: 144개 게시물 (v2 구조)
🔬 관련성 점수 분석 중...
📊 평균 관련성 점수: 0.304
📈 분석된 추천 수: 200개
📈 추천 커버리지 분석 중...
📊 커버리지: 0.924 (92.4%)
📈 추천된 고유 콘텐츠: 133개 / 전체 144개

==================================================
📋 분석 결과
==================================================
🎯 관련성 점수: 0.304
📈 커버리지: 0.924 (92.4%)

📊 성능 평가:
⚠️ 관련성 점수가 낮습니다 (< 0.4)
💡 목표 달성을 위해 32% 개선 필요
✅ 커버리지가 양호합니다

🎉 분석 완료!

# TF-IDF 벡터화 (한국어 고려)
        vectorizer = TfidfVectorizer(
            max_features=2000,          # 특성 수 증가
            stop_words='english',       # 영어 불용어 제거
            ngram_range=(1, 2),         # 1-gram, 2-gram 사용
            min_df=2,                   # 최소 2개 문서에 나타나는 단어만
            max_df=0.8                  # 80% 이상 문서에 나타나는 단어 제외
        )