pip install nltk textblob vaderSentiment transformers torch
pip install konlpy  # 한글 분석용
pip install pandas numpy matplotlib

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import torch.nn.functional as F

class KoreanSentimentAnalyzer:
    """
    한국어 감정 분석 클래스
    KoBERT 기반 모델 사용
    """
    
    def __init__(self):
        # 한국어 감정 분석 모델 로드
        model_name = "beomi/kcbert-base"
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(
            "beomi/KcELECTRA-base-v2022"
        )
        self.model.eval()
    
    def analyze(self, text):
        """텍스트 감정 분석"""
        # 토큰화
        inputs = self.tokenizer(
            text,
            return_tensors="pt",
            truncation=True,
            max_length=512,
            padding=True
        )
        
        # 예측
        with torch.no_grad():
            outputs = self.model(**inputs)
            predictions = F.softmax(outputs.logits, dim=-1)
        
        # 결과 해석
        scores = predictions[0].tolist()
        labels = ['부정 😢', '중립 😐', '긍정 😊']
        
        max_idx = scores.index(max(scores))
        sentiment = labels[max_idx]
        confidence = max(scores) * 100
        
        return {
            'text': text,
            'sentiment': sentiment,
            'confidence': round(confidence, 2),
            'scores': {
                '부정': round(scores[0] * 100, 2),
                '중립': round(scores[1] * 100, 2),
                '긍정': round(scores[2] * 100, 2)
            }
        }

# 간단한 한글 감정 분석 (KoNLPy 사용)
from konlpy.tag import Okt

def simple_korean_sentiment(text):
    """
    간단한 한글 감정 분석 (사전 기반)
    """
    okt = Okt()
    
    # 긍정/부정 단어 사전
    positive_words = [
        '좋다', '훌륭하다', '최고', '감사', '행복', '사랑', '완벽',
        '멋지다', '예쁘다', '맛있다', '재미있다', '신나다', '기쁘다'
    ]
    
    negative_words = [
        '나쁘다', '싫다', '최악', '실망', '슬프다', '화나다', '짜증',
        '별로', '형편없다', '지루하다', '불편하다', '후회', '아쉽다'
    ]
    
    # 형태소 분석
    morphs = okt.morphs(text)
    
    # 점수 계산
    pos_score = sum(1 for word in morphs if any(pw in word for pw in positive_words))
    neg_score = sum(1 for word in morphs if any(nw in word for nw in negative_words))
    
    # 감정 판단
    if pos_score > neg_score:
        sentiment = "긍정 😊"
    elif neg_score > pos_score:
        sentiment = "부정 😢"
    else:
        sentiment = "중립 😐"
    
    return {
        'text': text,
        'sentiment': sentiment,
        'positive_score': pos_score,
        'negative_score': neg_score
    }

# 한글 테스트
korean_texts = [
    "이 영화 정말 재미있고 감동적이에요! 최고예요!",
    "서비스가 너무 별로였어요. 다시는 안 갈 것 같아요.",
    "그냥 그래요. 특별한 건 없었어요.",
    "가격 대비 훌륭한 품질이네요. 강력 추천합니다!",
    "기대했는데 실망스러워요. 아쉽네요."
]

print("\n" + "=" * 60)
print("한글 감정 분석 결과")
print("=" * 60)

for text in korean_texts:
    result = simple_korean_sentiment(text)
    print(f"\n텍스트: {result['text']}")
    print(f"감정: {result['sentiment']}")
    print(f"긍정 단어: {result['positive_score']}개 | "
          f"부정 단어: {result['negative_score']}개")
    print("-" * 60)

import pandas as pd
import matplotlib.pyplot as plt
from collections import Counter
import re

class ReviewSentimentAnalyzer:
    """
    대량 리뷰 감정 분석 시스템
    """
    
    def __init__(self, analyzer_type='vader'):
        self.analyzer_type = analyzer_type
        
        if analyzer_type == 'vader':
            from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
            self.analyzer = SentimentIntensityAnalyzer()
        elif analyzer_type == 'textblob':
            from textblob import TextBlob
            self.analyzer = TextBlob
    
    def preprocess_text(self, text):
        """텍스트 전처리"""
        # 소문자 변환
        text = text.lower()
        # 특수문자 제거 (이모티콘은 유지)
        text = re.sub(r'[^\w\s!?.,😊😢😡😍🎉]', '', text)
        # 공백 정리
        text = ' '.join(text.split())
        return text
    
    def analyze_single(self, text):
        """단일 텍스트 분석"""
        text = self.preprocess_text(text)
        
        if self.analyzer_type == 'vader':
            scores = self.analyzer.polarity_scores(text)
            compound = scores['compound']
            
            if compound >= 0.05:
                sentiment = 'positive'
            elif compound <= -0.05:
                sentiment = 'negative'
            else:
                sentiment = 'neutral'
            
            return {
                'sentiment': sentiment,
                'score': compound,
                'details': scores
            }
        
        elif self.analyzer_type == 'textblob':
            blob = self.analyzer(text)
            polarity = blob.sentiment.polarity
            
            if polarity > 0.1:
                sentiment = 'positive'
            elif polarity < -0.1:
                sentiment = 'negative'
            else:
                sentiment = 'neutral'
            
            return {
                'sentiment': sentiment,
                'score': polarity,
                'details': {'polarity': polarity}
            }
    
    def analyze_batch(self, texts):
        """대량 텍스트 분석"""
        results = []
        for text in texts:
            result = self.analyze_single(text)
            result['text'] = text
            results.append(result)
        return pd.DataFrame(results)
    
    def generate_report(self, df):
        """분석 리포트 생성"""
        report = {
            'total_reviews': len(df),
            'positive_count': len(df[df['sentiment'] == 'positive']),
            'negative_count': len(df[df['sentiment'] == 'negative']),
            'neutral_count': len(df[df['sentiment'] == 'neutral']),
            'average_score': df['score'].mean(),
            'positive_ratio': len(df[df['sentiment'] == 'positive']) / len(df) * 100,
            'negative_ratio': len(df[df['sentiment'] == 'negative']) / len(df) * 100
        }
        return report

# 샘플 리뷰 데이터
sample_reviews = [
    "This product exceeded all my expectations! Absolutely love it!",
    "Terrible quality. Broke after one day. Very disappointed.",
    "It's okay, nothing special but does the job.",
    "Best purchase ever! Highly recommend to everyone!",
    "Not worth the money. Poor customer service too.",
    "Good value for the price. Satisfied with my purchase.",
    "Worst experience. Will never buy again.",
    "Amazing quality and fast shipping! Very happy!",
    "Average product. Expected more for this price.",
    "Fantastic! Exactly what I was looking for!"
] * 10  # 100개 리뷰 시뮬레이션

# 분석 실행
print("\n" + "=" * 60)
print("대량 리뷰 감정 분석 시스템")
print("=" * 60)

analyzer = ReviewSentimentAnalyzer(analyzer_type='vader')
results_df = analyzer.analyze_batch(sample_reviews)
report = analyzer.generate_report(results_df)

print(f"\n📊 분석 결과 요약:")
print(f"총 리뷰 수: {report['total_reviews']}개")
print(f"긍정 리뷰: {report['positive_count']}개 ({report['positive_ratio']:.1f}%)")
print(f"부정 리뷰: {report['negative_count']}개 ({report['negative_ratio']:.1f}%)")
print(f"중립 리뷰: {report['neutral_count']}개")
print(f"평균 감정 점수: {report['average_score']:.3f}")

# 상위/하위 리뷰 출력
print("\n🌟 가장 긍정적인 리뷰 TOP 3:")
top_positive = results_df.nlargest(3, 'score')
for idx, row in top_positive.iterrows():
    print(f"  • {row['text'][:60]}... (점수: {row['score']:.3f})")

print("\n💔 가장 부정적인 리뷰 TOP 3:")
top_negative = results_df.nsmallest(3, 'score')
for idx, row in top_negative.iterrows():
    print(f"  • {row['text'][:60]}... (점수: {row['score']:.3f})")

import matplotlib.pyplot as plt
import seaborn as sns
from wordcloud import WordCloud

class SentimentVisualizer:
    """
    감정 분석 결과 시각화 클래스
    """
    
    def __init__(self):
        # 한글 폰트 설정 (필요시)
        plt.rcParams['font.family'] = 'DejaVu Sans'
        plt.rcParams['axes.unicode_minus'] = False
        sns.set_style('whitegrid')
    
    def plot_sentiment_distribution(self, df, save_path=None):
        """감정 분포 파이 차트"""
        sentiment_counts = df['sentiment'].value_counts()
        
        colors = ['#81c784', '#e0e0e0', '#ef5350']
        labels = ['Positive 😊', 'Neutral 😐', 'Negative 😢']
        
        plt.figure(figsize=(10, 6))
        plt.pie(
            sentiment_counts.values,
            labels=labels,
            colors=colors,
            autopct='%1.1f%%',
            startangle=90,
            textprops={'fontsize': 12, 'weight': 'bold'}
        )
        plt.title('Sentiment Distribution', fontsize=16, weight='bold', pad=20)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        plt.show()
    
    def plot_score_histogram(self, df, save_path=None):
        """감정 점수 히스토그램"""
        plt.figure(figsize=(12, 6))
        
        # 긍정/부정 분리
        positive = df[df['sentiment'] == 'positive']['score']
        negative = df[df['sentiment'] == 'negative']['score']
        neutral = df[df['sentiment'] == 'neutral']['score']
        
        plt.hist(positive, bins=20, alpha=0.7, color='#81c784', label='Positive')
        plt.hist(neutral, bins=20, alpha=0.7, color='#e0e0e0', label='Neutral')
        plt.hist(negative, bins=20, alpha=0.7, color='#ef5350', label='Negative')
        
        plt.xlabel('Sentiment Score', fontsize=12, weight='bold')
        plt.ylabel('Frequency', fontsize=12, weight='bold')
        plt.title('Distribution of Sentiment Scores', fontsize=16, weight='bold', pad=20)
        plt.legend(fontsize=11)
        plt.grid(True, alpha=0.3)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        plt.show()
    
    def plot_timeline(self, df, date_column, save_path=None):
        """시간대별 감정 추이"""
        if date_column not in df.columns:
            print("날짜 컬럼이 없습니다.")
            return
        
        df['date'] = pd.to_datetime(df[date_column])
        daily_sentiment = df.groupby([df['date'].dt.date, 'sentiment']).size().unstack(fill_value=0)
        
        plt.figure(figsize=(14, 6))
        daily_sentiment.plot(
            kind='area',
            stacked=True,
            color=['#81c784', '#e0e0e0', '#ef5350'],
            alpha=0.7
        )
        
        plt.xlabel('Date', fontsize=12, weight='bold')
        plt.ylabel('Number of Reviews', fontsize=12, weight='bold')
        plt.title('Sentiment Trend Over Time', fontsize=16, weight='bold', pad=20)
        plt.legend(['Positive', 'Neutral', 'Negative'], fontsize=11)
        plt.grid(True, alpha=0.3)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        plt.show()
    
    def create_wordcloud(self, texts, sentiment_type='all', save_path=None):
        """워드클라우드 생성"""
        text = ' '.join(texts)
        
        # 감정별 색상
        color_map = {
            'positive': '#81c784',
            'negative': '#ef5350',
            'all': '#7b68a6'
        }
        
        wordcloud = WordCloud(
            width=1200,
            height=600,
            background_color='white',
            colormap='viridis' if sentiment_type == 'all' else None,
            max_words=100,
            relative_scaling=0.5,
            min_font_size=10
        ).generate(text)
        
        plt.figure(figsize=(14, 7))
        plt.imshow(wordcloud, interpolation='bilinear')
        plt.axis('off')
        plt.title(
            f'Word Cloud - {sentiment_type.capitalize()} Sentiment',
            fontsize=16,
            weight='bold',
            pad=20
        )
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        plt.show()

# 시각화 실행
visualizer = SentimentVisualizer()

print("\n📊 시각화 생성 중...")
visualizer.plot_sentiment_distribution(results_df)
visualizer.plot_score_histogram(results_df)

# 긍정/부정 리뷰 워드클라우드
positive_texts = results_df[results_df['sentiment'] == 'positive']['text'].tolist()
negative_texts = results_df[results_df['sentiment'] == 'negative']['text'].tolist()

print("\n☁️ 워드클라우드 생성 중...")
visualizer.create_wordcloud(positive_texts, sentiment_type='positive')
visualizer.create_wordcloud(negative_texts, sentiment_type='negative')

import schedule
import time
from datetime import datetime

class ReviewMonitor:
    """
    실시간 리뷰 모니터링 시스템
    부정 리뷰 자동 알림
    """
    
    def __init__(self, alert_threshold=-0.5):
        self.analyzer = SentimentIntensityAnalyzer()
        self.alert_threshold = alert_threshold
        self.negative_reviews = []
    
    def check_new_reviews(self):
        """새 리뷰 확인 (실제로는 DB나 API에서 가져옴)"""
        # 여기서는 시뮬레이션
        new_reviews = [
            "Product broke after 2 days. Very disappointed!",
            "Great quality, love it!",
            "Worst customer service ever. Never again!"
        ]
        
        for review in new_reviews:
            self.analyze_and_alert(review)
    
    def analyze_and_alert(self, review):
        """리뷰 분석 및 알림"""
        scores = self.analyzer.polarity_scores(review)
        compound = scores['compound']
        
        if compound <= self.alert_threshold:
            alert = {
                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'review': review,
                'score': compound,
                'severity': 'HIGH' if compound < -0.7 else 'MEDIUM'
            }
            self.negative_reviews.append(alert)
            self.send_alert(alert)
    
    def send_alert(self, alert):
        """알림 전송 (이메일, 슬랙 등)"""
        print(f"\n🚨 부정 리뷰 감지!")
        print(f"시간: {alert['timestamp']}")
        print(f"심각도: {alert['severity']}")
        print(f"점수: {alert['score']:.3f}")
        print(f"내용: {alert['review']}")
        print("-" * 60)
    
    def generate_daily_report(self):
        """일일 리포트 생성"""
        if not self.negative_reviews:
            print("\n✅ 오늘은 심각한 부정 리뷰가 없습니다!")
            return
        
        print(f"\n📊 일일 부정 리뷰 리포트")
        print(f"총 {len(self.negative_reviews)}건의 부정 리뷰 감지")
        print("\n가장 심각한 리뷰 TOP 3:")
        
        sorted_reviews = sorted(self.negative_reviews, key=lambda x: x['score'])
        for i, review in enumerate(sorted_reviews[:3], 1):
            print(f"\n{i}. {review['review'][:50]}...")
            print(f"   점수: {review['score']:.3f}")
    
    def start_monitoring(self):
        """모니터링 시작"""
        print("🔍 리뷰 모니터링 시작...")
        
        # 10분마다 체크
        schedule.every(10).minutes.do(self.check_new_reviews)
        
        # 매일 오후 6시 리포트
        schedule.every().day.at("18:00").do(self.generate_daily_report)
        
        while True:
            schedule.run_pending()
            time.sleep(60)

# 모니터 실행 (실제 운영시)
# monitor = ReviewMonitor(alert_threshold=-0.5)
# monitor.start_monitoring()

class BrandSentimentTracker:
    """
    브랜드 감정 추적 시스템
    소셜 미디어 멘션 분석
    """
    
    def __init__(self, brand_name):
        self.brand_name = brand_name
        self.analyzer = SentimentIntensityAnalyzer()
        self.mentions = []
    
    def track_mentions(self, posts):
        """브랜드 멘션 추적"""
        for post in posts:
            if self.brand_name.lower() in post.lower():
                sentiment_data = self.analyze_post(post)
                self.mentions.append(sentiment_data)
        
        return self.mentions
    
    def analyze_post(self, post):
        """포스트 감정 분석"""
        scores = self.analyzer.polarity_scores(post)
        
        return {
            'post': post,
            'sentiment': self.classify_sentiment(scores['compound']),
            'score': scores['compound'],
            'engagement_potential': self.calculate_engagement(post, scores)
        }
    
    def classify_sentiment(self, compound):
        """감정 분류"""
        if compound >= 0.05:
            return 'positive'
        elif compound <= -0.05:
            return 'negative'
        return 'neutral'
    
    def calculate_engagement(self, post, scores):
        """참여 가능성 계산"""
        # 간단한 휴리스틱
        engagement_score = abs(scores['compound'])
        
        # 느낌표, 물음표 가중치
        engagement_score += post.count('!') * 0.1
        engagement_score += post.count('?') * 0.05
        
        return min(engagement_score, 1.0)
    
    def get_insights(self):
        """인사이트 생성"""
        if not self.mentions:
            return "멘션이 없습니다."
        
        total = len(self.mentions)
        positive = sum(1 for m in self.mentions if m['sentiment'] == 'positive')
        negative = sum(1 for m in self.mentions if m['sentiment'] == 'negative')
        
        avg_score = sum(m['score'] for m in self.mentions) / total
        
        # 높은 참여 가능성 포스트
        high_engagement = [m for m in self.mentions if m['engagement_potential'] > 0.7]
        
        insights = {
            'total_mentions': total,
            'sentiment_breakdown': {
                'positive': positive,
                'negative': negative,
                'neutral': total - positive - negative
            },
            'average_sentiment': avg_score,
            'positive_ratio': (positive / total) * 100,
            'high_engagement_posts': len(high_engagement),
            'recommendation': self.get_recommendation(avg_score, negative, total)
        }
        
        return insights
    
    def get_recommendation(self, avg_score, negative_count, total):
        """추천 액션"""
        if avg_score < -0.3:
            return "⚠️ 긴급: 브랜드 이미지 개선 필요. 즉각적인 대응 권장"
        elif negative_count / total > 0.3:
            return "⚡ 주의: 부정적 멘션 증가. 모니터링 강화 필요"
        elif avg_score > 0.5:
            return "✅ 우수: 긍정적 반응. 현재 전략 유지"
        else:
            return "📊 보통: 안정적 상태. 지속적 모니터링 권장"

# 사용 예제
tracker = BrandSentimentTracker("MyBrand")

sample_posts = [
    "Just tried MyBrand's new product and I'm blown away! 😍",
    "MyBrand customer service is terrible. Very disappointed.",
    "Saw MyBrand at the store today. Looks interesting.",
    "MyBrand never disappoints! Best quality ever! 🔥",
    "Not impressed with MyBrand's latest release."
]

tracker.track_mentions(sample_posts)
insights = tracker.get_insights()

print("\n" + "=" * 60)
print(f"📊 {tracker.brand_name} 브랜드 감정 분석 리포트")
print("=" * 60)
print(f"\n총 멘션: {insights['total_mentions']}건")
print(f"긍정: {insights['sentiment_breakdown']['positive']}건")
print(f"부정: {insights['sentiment_breakdown']['negative']}건")
print(f"중립: {insights['sentiment_breakdown']['neutral']}건")
print(f"\n긍정 비율: {insights['positive_ratio']:.1f}%")
print(f"평균 감정 점수: {insights['average_sentiment']:.3f}")
print(f"높은 참여 가능성 포스트: {insights['high_engagement_posts']}건")
print(f"\n💡 추천 액션: {insights['recommendation']}")

from PIL import Image
import torch
from transformers import CLIPProcessor, CLIPModel

class MultimodalSentimentAnalyzer:
    """
    멀티모달 감정 분석
    텍스트 + 이미지 통합 분석
    """
    
    def __init__(self):
        # CLIP 모델 로드 (텍스트-이미지 연결)
        self.clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        self.clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
        
        # 텍스트 감정 분석기
        self.text_analyzer = SentimentIntensityAnalyzer()
    
    def analyze_text(self, text):
        """텍스트 감정 분석"""
        scores = self.text_analyzer.polarity_scores(text)
        return scores['compound']
    
    def analyze_image_sentiment(self, image_path):
        """
        이미지 감정 분석
        CLIP을 사용해 이미지와 감정 레이블 매칭
        """
        image = Image.open(image_path)
        
        # 감정 레이블
        sentiment_labels = [
            "a happy and joyful scene",
            "a sad and depressing scene",
            "an angry and aggressive scene",
            "a calm and peaceful scene",
            "an exciting and energetic scene"
        ]
        
        # CLIP으로 이미지-텍스트 유사도 계산
        inputs = self.clip_processor(
            text=sentiment_labels,
            images=image,
            return_tensors="pt",
            padding=True
        )
        
        outputs = self.clip_model(**inputs)
        logits_per_image = outputs.logits_per_image
        probs = logits_per_image.softmax(dim=1)
        
        # 가장 높은 확률의 감정
        max_idx = probs.argmax().item()
        confidence = probs[0][max_idx].item()
        
        sentiment_map = {
            0: ('positive', 0.8),
            1: ('negative', -0.8),
            2: ('negative', -0.6),
            3: ('neutral', 0.0),
            4: ('positive', 0.6)
        }
        
        sentiment, score = sentiment_map[max_idx]
        
        return {
            'sentiment': sentiment,
            'score': score,
            'confidence': confidence,
            'label': sentiment_labels[max_idx]
        }
    
    def analyze_multimodal(self, text, image_path, text_weight=0.6, image_weight=0.4):
        """
        텍스트 + 이미지 통합 분석
        가중치 기반 결합
        """
        # 텍스트 분석
        text_score = self.analyze_text(text)
        
        # 이미지 분석
        image_result = self.analyze_image_sentiment(image_path)
        image_score = image_result['score']
        
        # 가중 평균
        combined_score = (text_score * text_weight) + (image_score * image_weight)
        
        # 최종 감정 분류
        if combined_score >= 0.1:
            final_sentiment = 'positive 😊'
        elif combined_score <= -0.1:
            final_sentiment = 'negative 😢'
        else:
            final_sentiment = 'neutral 😐'
        
        return {
            'text': text,
            'text_score': round(text_score, 3),
            'image_score': round(image_score, 3),
            'image_label': image_result['label'],
            'combined_score': round(combined_score, 3),
            'final_sentiment': final_sentiment,
            'confidence': round(image_result['confidence'] * 100, 2)
        }

# 사용 예제 (이미지 파일이 있을 때)
# analyzer = MultimodalSentimentAnalyzer()
# result = analyzer.analyze_multimodal(
#     text="Had an amazing day at the beach!",
#     image_path="beach_photo.jpg"
# )
# print(result)