fix gradio

app.py

@@ -1,156 +1,204 @@
-import gradio as gr
+import os
+import time
+import requests
+import re
 import pandas as pd
-from scrape.trendyol_scraper import scrape_reviews
-from scripts.review_summarizer import ReviewAnalyzer
 import plotly.express as px
-import plotly.graph_objects as go
-import os
-import subprocess
-import logging
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service
-
-# Logging ayarları
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def setup_chrome():
-    """Chrome ve ChromeDriver kurulumu"""
+import gradio as gr
+from dotenv import load_dotenv
+from scripts.review_summarizer import analyze_reviews
+
+# Load environment variables
+load_dotenv()
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+
+if not os.path.exists("data"):
+    os.makedirs("data")
+
+def create_sentiment_plot(df):
+    """Creates a pie chart visualization for sentiment distribution"""
+    sentiment_counts = df["sentiment_label"].value_counts()
+    fig = px.pie(
+        values=sentiment_counts.values,
+        names=sentiment_counts.index,
+        title="Duygu Analizi Dağılımı",
+        color_discrete_map={
+            "Pozitif": "#2ecc71",
+            "Nötr": "#95a5a6",
+            "Negatif": "#e74c3c",
+        },
+    )
+    return fig
+
+def create_star_plot(df):
+    """Creates a bar chart visualization for star rating distribution"""
+    star_counts = df["Yıldız Sayısı"].value_counts().sort_index()
+    fig = px.bar(
+        x=star_counts.index,
+        y=star_counts.values,
+        title="Yıldız Dağılımı",
+        labels={"x": "Yıldız Sayısı", "y": "Yorum Sayısı"},
+        color_discrete_sequence=["#f39c12"],
+    )
+    fig.update_layout(
+        xaxis=dict(
+            tickmode="array",
+            ticktext=["⭐", "⭐⭐", "⭐⭐⭐", "⭐⭐⭐⭐", "⭐⭐⭐⭐⭐"],
+        )
+    )
+    return fig
+
+def scrape_product_comments_v2(url):
+    headers = {
+        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        "accept-language": "en-US,en;q=0.9",
+        "cache-control": "max-age=0",
+        "upgrade-insecure-requests": "1",
+        "user-agent": "Mozilla/5.0 (iPad; CPU OS 14_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/129.0 Mobile/15E148 Safari/605.1.15"
+    }
+
+    # Extract product_id using regex
+    match = re.search(r"-p-(\d+)", url)
+    if not match:
+        raise ValueError("Product ID not found in URL")
+    
+    product_id = match.group(1)
+    api_url = f"https://apigw.trendyol.com/discovery-web-websfxsocialreviewrating-santral/product-reviews-detailed?contentId={product_id}&page=1&order=DESC&orderBy=Score&channelId=1"
+
+    def fetch_reviews(api_url, headers):
+        all_reviews = []
+        response = requests.get(api_url, headers=headers)
+        if response.status_code != 200:
+            raise ConnectionError(f"Initial request failed: {response.status_code}")
+        
+        data = response.json()
+        total_pages = data["result"]["productReviews"]["totalPages"]
+        all_reviews.extend(data["result"]["productReviews"]["content"])
+
+        for page in range(2, total_pages + 1):
+            paginated_url = api_url.replace("page=1", f"page={page}")
+            response = requests.get(paginated_url, headers=headers)
+            if response.status_code == 200:
+                page_data = response.json()
+                all_reviews.extend(page_data["result"]["productReviews"]["content"])
+            else:
+                print(f"Failed to fetch page {page}: {response.status_code}")
+
+        return all_reviews
+
+    reviews = fetch_reviews(api_url, headers)
+    reviews_df = pd.DataFrame(reviews)
+    reviews_df = reviews_df.rename(columns={
+        "id": "Kullanıcı_id",
+        "userFullName": "Kullanıcı Adı",
+        "comment": "Yorum",
+        "lastModifiedDate": "Tarih",
+        "rate": "Yıldız Sayısı"
+    })
+    reviews_df = reviews_df[["Kullanıcı_id", "Kullanıcı Adı", "Yorum", "Tarih", "Yıldız Sayısı"]]
+    return reviews_df
+
+def analyze_product(url, progress=gr.Progress()):
     try:
-        # Chromium kullanarak Chrome yerine (Hugging Face'de önceden yüklü)
-        chrome_options = webdriver.ChromeOptions()
-        chrome_options.add_argument('--headless')
-        chrome_options.add_argument('--no-sandbox')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.binary_location = '/usr/bin/chromium'  # Chromium path
+        # Fetch reviews
+        progress(0.1, desc="Yorumlar çekiliyor...")
+        df = scrape_product_comments_v2(url)
+        
+        if df is None or len(df) == 0:
+            return None, None, None, None, None, None, None, "Yorumlar çekilemedi. URL'yi kontrol edin."
+
+        # Save to CSV
+        data_path = os.path.join("data", "product_comments.csv")
+        df.to_csv(data_path, index=False, encoding="utf-8-sig")
+
+        # Analyze reviews
+        progress(0.4, desc="Yorumlar analiz ediliyor...")
+        summary, analyzed_df = analyze_reviews(data_path, GEMINI_API_KEY)
+
+        progress(0.7, desc="Sonuçlar hazırlanıyor...")
         
-        # ChromeDriver'ı webdriver-manager ile yönet
-        from webdriver_manager.chrome import ChromeDriverManager
-        from webdriver_manager.core.utils import ChromeType
+        # Calculate metrics
+        total_reviews = len(df)
+        total_analyzed = len(analyzed_df)
+        avg_rating = f"{analyzed_df['Yıldız Sayısı'].mean():.1f}⭐"
+        positive_ratio = len(analyzed_df[analyzed_df["sentiment_label"] == "Pozitif"]) / len(analyzed_df) * 100
+        positive_ratio_str = f"%{positive_ratio:.1f}"
         
-        driver_path = ChromeDriverManager(chrome_type=ChromeType.CHROMIUM).install()
-        logger.info(f"ChromeDriver path: {driver_path}")
+        # Create plots
+        sentiment_plot = create_sentiment_plot(analyzed_df)
+        star_plot = create_star_plot(analyzed_df)
         
-        # Test et
-        service = Service(driver_path)
-        with webdriver.Chrome(service=service, options=chrome_options) as driver:
-            driver.get("https://www.google.com")
-            logger.info("Chrome test başarılı!")
-            
-    except Exception as e:
-        logger.error(f"Chrome kurulumunda hata: {str(e)}", exc_info=True)
-        raise
-
-class ReviewAnalysisApp:
-    def __init__(self):
-        try:
-            logger.info("Chrome kurulumu başlatılıyor...")
-            setup_chrome()  # Uygulama başlatılırken Chrome'u kur
-            
-            logger.info("ReviewAnalyzer başlatılıyor...")
-            self.analyzer = ReviewAnalyzer()
-            logger.info("ReviewAnalyzer başarıyla başlatıldı")
-            
-        except Exception as e:
-            logger.error(f"ReviewAnalyzer başlatılırken hata: {str(e)}", exc_info=True)  # Tam hata stack'ini göster
-            self.analyzer = None
+        # Create info message for removed reviews
+        removed_reviews = total_reviews - total_analyzed
+        info_message = ""
+        if removed_reviews > 0:
+            info_message = f"Not: Toplam {removed_reviews} adet kargo, teslimat ve satıcı ile ilgili yorum analiz dışı bırakılmıştır."
+
+        progress(1.0, desc="Analiz tamamlandı!")
         
-    def analyze_url(self, url):
-        try:
-            # Analyzer'ın başarıyla başlatılıp başlatılmadığını kontrol et
-            if self.analyzer is None:
-                logger.error("Analyzer başlatılamadı")
-                return "Sistem başlatılamadı. Lütfen daha sonra tekrar deneyin.", None, None, None
-
-            if not url or not url.startswith("https://www.trendyol.com/"):
-                return "Lütfen geçerli bir Trendyol ürün yorumları URL'si girin.", None, None, None
-            
-            logger.info("Yorumlar çekiliyor...")
-            df = scrape_reviews(url)
-            
-            if df.empty:
-                return "Yorumlar çekilemedi. Lütfen URL'yi kontrol edin.", None, None, None
-            
-            logger.info("Sentiment analizi yapılıyor...")
-            analyzed_df = self.analyzer.analyze_reviews(df)
-            
-            if analyzed_df.empty:
-                return "Sentiment analizi yapılamadı.", None, None, None
-            
-            logger.info("Özet oluşturuluyor...")
-            summary = self.analyzer.generate_summary(analyzed_df)
-            
-            logger.info("Grafikler oluşturuluyor...")
-            fig1 = self.create_sentiment_distribution(analyzed_df)
-            fig2 = self.create_rating_distribution(analyzed_df)
-            fig3 = self.create_sentiment_by_rating(analyzed_df)
-            
-            return summary, fig1, fig2, fig3
-            
-        except Exception as e:
-            error_msg = f"Analiz sırasında hata oluştu: {str(e)}"
-            logger.error(error_msg)
-            return error_msg, None, None, None
-    
-    def create_sentiment_distribution(self, df):
-        fig = px.pie(df, 
-                    names='sentiment_label', 
-                    title='Duygu Analizi Dağılımı')
-        return fig
+        return (
+            str(total_reviews),
+            str(total_analyzed),
+            avg_rating,
+            positive_ratio_str,
+            sentiment_plot,
+            star_plot,
+            summary,
+            info_message
+        )
+        
+    except Exception as e:
+        return None, None, None, None, None, None, None, f"Bir hata oluştu: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Trendyol Yorum Analizi") as demo:
+    gr.Markdown("""
+    # Trendyol Yorum Analizi
     
-    def create_rating_distribution(self, df):
-        fig = px.bar(df['Yıldız Sayısı'].value_counts().sort_index(), 
-                    title='Yıldız Dağılımı')
-        fig.update_layout(xaxis_title='Yıldız Sayısı', 
-                         yaxis_title='Yorum Sayısı')
-        return fig
+    Bu uygulama, Trendyol ürün sayfasındaki yorumları analiz eder ve özetler.
     
-    def create_sentiment_by_rating(self, df):
-        avg_sentiment = df.groupby('Yıldız Sayısı')['sentiment_score'].mean()
-        fig = px.line(avg_sentiment, 
-                     title='Yıldız Sayısına Göre Ortalama Sentiment Skoru')
-        fig.update_layout(xaxis_title='Yıldız Sayısı', 
-                         yaxis_title='Ortalama Sentiment Skoru')
-        return fig
-
-def create_interface():
-    app = ReviewAnalysisApp()
+    Kullanım:
+    1. Trendyol ürün yorumlar sayfasının URL'sini girin
+    2. 'Analiz Et' butonuna tıklayın
+    """)
     
-    with gr.Blocks(theme=gr.themes.Soft()) as interface:
-        gr.Markdown("# Trendyol Yorum Analizi")
-        
-        with gr.Row():
-            url_input = gr.Textbox(
-                label="Trendyol Ürün Yorumları URL'si",
-                placeholder="https://www.trendyol.com/..."
-            )
-        
-        analyze_btn = gr.Button("Analiz Et")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                summary_output = gr.Textbox(
-                    label="Özet",
-                    lines=10
-                )
-            
-            with gr.Column(scale=2):
-                with gr.Tab("Duygu Analizi"):
-                    sentiment_dist = gr.Plot()
-                with gr.Tab("Yıldız Dağılımı"):
-                    rating_dist = gr.Plot()
-                with gr.Tab("Sentiment-Yıldız İlişkisi"):
-                    sentiment_rating = gr.Plot()
-        
-        analyze_btn.click(
-            fn=app.analyze_url,
-            inputs=[url_input],
-            outputs=[summary_output, sentiment_dist, rating_dist, sentiment_rating]
+    with gr.Row():
+        url_input = gr.Textbox(
+            label="Trendyol Ürün Yorumları URL",
+            placeholder="ürünün linki"
         )
     
-    return interface
+    analyze_btn = gr.Button("Analiz Et")
+    
+    with gr.Row():
+        total_reviews = gr.Textbox(label="Toplam Yorum")
+        total_analyzed = gr.Textbox(label="Ürün Değerlendirme Sayısı")
+        avg_rating = gr.Textbox(label="Ortalama Puan")
+        positive_ratio = gr.Textbox(label="Olumlu Yorum Oranı")
+    
+    info_message = gr.Markdown()
+    
+    with gr.Row():
+        sentiment_plot = gr.Plot()
+        star_plot = gr.Plot()
+    
+    summary = gr.Markdown(label="📝 Genel Değerlendirme")
+    error_message = gr.Markdown()
+    
+    analyze_btn.click(
+        analyze_product,
+        inputs=[url_input],
+        outputs=[
+            total_reviews,
+            total_analyzed,
+            avg_rating,
+            positive_ratio,
+            sentiment_plot,
+            star_plot,
+            summary,
+            error_message
+        ]
+    )
 
 if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch() 
+    demo.launch()

requirements.txt

@@ -1,19 +1,13 @@
-pandas
-numpy==1.24.3
-seaborn
-matplotlib
-torch==2.1.2
-transformers==4.36.2
-nltk
-plotly
-gradio
-selenium
-webdriver-manager
-tqdm
-regex
-scikit-learn
-google-generativeai
-python-dotenv
-requests
-sentencepiece
-protobuf
+pandas==2.2.3
+numpy==1.26.4
+torch==2.5.1
+transformers==4.47.0
+nltk==3.8.1
+requests==2.32.3
+google-generativeai==0.8.3
+selenium==4.27.1
+streamlit==1.36.0
+plotly==5.18.0
+python-dotenv==1.0.1
+tqdm==4.67.1
+regex

scripts/data_prp_eda.py

@@ -1,357 +1,491 @@
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from wordcloud import WordCloud
-import re
-from collections import Counter
-from datetime import datetime
-import warnings
-from textblob import TextBlob
-import nltk
-from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize
-from nltk.util import ngrams
-import requests
-import os
-warnings.filterwarnings('ignore')
-plt.style.use('seaborn')
-
-nltk.download('stopwords')
-nltk.download('punkt')
-
-class ReviewAnalyzer:
-    def __init__(self, file_path):
-        self.df = pd.read_csv(file_path)
-        self.turkish_stopwords = self.get_turkish_stopwords()
-        
-        # Lojistik ve satıcı ile ilgili kelimeleri genişletilmiş liste ile tanımla
-        self.logistics_seller_words = {
-            # Kargo ve teslimat ile ilgili
-            'kargo', 'kargocu', 'paket', 'paketleme', 'teslimat', 'teslim', 
-            'gönderi', 'gönderim', 'ulaştı', 'ulaşım', 'geldi', 'kurye',
-            'dağıtım', 'hasarlı', 'hasar', 'kutu', 'ambalaj', 'zamanında',
-            'geç', 'hızlı', 'yavaş', 'günde', 'saatte',
-            
-            # Satıcı ve mağaza ile ilgili
-            'satıcı', 'mağaza', 'sipariş', 'trendyol', 'tedarik', 'stok',
-            'garanti', 'fatura', 'iade', 'geri', 'müşteri', 'hizmet',
-            'destek', 'iletişim', 'şikayet', 'sorun', 'çözüm', 'hediye',
-            
-            # Fiyat ve ödeme ile ilgili
-            'fiyat', 'ücret', 'para', 'bedava', 'ücretsiz', 'indirim',
-            'kampanya', 'taksit', 'ödeme', 'bütçe', 'hesap', 'kur',
-            
-            # Zaman ile ilgili teslimat kelimeleri
-            'bugün', 'yarın', 'dün', 'hafta', 'gün', 'saat', 'süre',
-            'bekleme', 'gecikme', 'erken', 'geç'
-        }
-
-        # Sentiment analizi için kelimeler
-        self.positive_words = {
-            'güzel', 'harika', 'mükemmel', 'süper', 'iyi', 'muhteşem', 
-            'teşekkür', 'memnun', 'başarılı', 'kaliteli', 'kusursuz', 
-            'özgün', 'şahane', 'enfes', 'ideal'
-        }
-        
-        self.negative_words = {
-            'kötü', 'berbat', 'rezalet', 'yetersiz', 'başarısız', 'vasat',
-            'korkunç', 'düşük', 'zayıf', 'çöp', 'pişman', 'kırık', 'bozuk'
-        }
-
-        # Türkçe-İngilizce ay çevirisi
-        self.month_map = {
-            'Ocak': 'January', 'Şubat': 'February', 'Mart': 'March',
-            'Nisan': 'April', 'Mayıs': 'May', 'Haziran': 'June',
-            'Temmuz': 'July', 'Ağustos': 'August', 'Eylül': 'September',
-            'Ekim': 'October', 'Kasım': 'November', 'Aralık': 'December'
-        }
-
-    def get_turkish_stopwords(self):
-        """Türkçe stop words listesini oluştur"""
-        turkish_stops = set(stopwords.words('turkish'))
-        
-        github_url = "https://raw.githubusercontent.com/sgsinclair/trombone/master/src/main/resources/org/voyanttools/trombone/keywords/stop.tr.turkish-lucene.txt"
-        try:
-            response = requests.get(github_url)
-            if response.status_code == 200:
-                github_stops = set(word.strip() for word in response.text.split('\n') if word.strip())
-                turkish_stops.update(github_stops)
-        except Exception as e:
-            print(f"GitHub'dan stop words çekilirken hata oluştu: {e}")
-        
-        custom_stops = {'bir', 've', 'çok', 'bu', 'de', 'da', 'için', 'ile', 'ben', 
-                       'sen', 'o', 'biz', 'siz', 'onlar', 'bu', 'şu', 'ama', 'fakat', 
-                       'ancak', 'lakin', 'ki', 'dahi', 'mi', 'mı', 'mu', 'mü'}
-        turkish_stops.update(custom_stops)
-        
-        return turkish_stops
-
-    def filter_product_reviews(self):
-        """Salt ürün yorumlarını filtrele"""
-        def is_pure_product_review(text):
-            if not isinstance(text, str):
-                return False
-            
-            text_lower = text.lower()
-            return not any(word in text_lower for word in self.logistics_seller_words)
-
-        # Filtrelenmiş DataFrame 
-        original_count = len(self.df)
-        self.df = self.df[self.df['Yorum'].apply(is_pure_product_review)]
-        filtered_count = len(self.df)
-        
-        print(f"\nFiltreleme İstatistikleri:")
-        print(f"Orijinal yorum sayısı: {original_count}")
-        print(f"Salt ürün yorumu sayısı: {filtered_count}")
-        print(f"Çıkarılan yorum sayısı: {original_count - filtered_count}")
-        print(f"Filtreleme oranı: {((original_count - filtered_count) / original_count * 100):.2f}%")
-
-        print("\nÖrnek Salt Ürün Yorumları:")
-        sample_reviews = self.df['Yorum'].sample(min(3, len(self.df)))
-        for idx, review in enumerate(sample_reviews, 1):
-            print(f"{idx}. {review[:100]}...")
-
-    def convert_turkish_date(self, date_str):
-        """Türkçe tarihleri İngilizce'ye çevir"""
-        try:
-            day, month, year = date_str.split()
-            english_month = self.month_map[month]
-            return f"{day} {english_month} {year}"
-        except:
-            return None
-
-    def preprocess_text(self, text):
-        """Metin ön işleme"""
-        if isinstance(text, str):
-            text = text.lower()
-            text = re.sub(r'[^\w\s]', '', text)
-            text = re.sub(r'\d+', '', text)
-            text = re.sub(r'\s+', ' ', text).strip()
-            return text
-        return ''
-    
-
-    def analyze_timestamps(self):
-        """Zaman bazlı analizler"""
-        # Tarihleri dönüştür
-        self.df['Tarih'] = self.df['Tarih'].apply(self.convert_turkish_date)
-        self.df['Tarih'] = pd.to_datetime(self.df['Tarih'], format='%d %B %Y')
-        
-        # Günlük dağılım
-        plt.figure(figsize=(12, 6))
-        plt.hist(self.df['Tarih'], bins=20, edgecolor='black')
-        plt.title('Yorumların Zaman İçindeki Dağılımı')
-        plt.xlabel('Tarih')
-        plt.ylabel('Yorum Sayısı')
-        plt.xticks(rotation=45)
-        plt.tight_layout()
-        plt.savefig('images/yorum_zaman_dagilimi.png')
-        plt.close()
-
-        # Aylık dağılım
-        monthly_reviews = self.df.groupby(self.df['Tarih'].dt.to_period('M')).size()
-        plt.figure(figsize=(12, 6))
-        monthly_reviews.plot(kind='bar')
-        plt.title('Aylık Yorum Dağılımı')
-        plt.xlabel('Ay')
-        plt.ylabel('Yorum Sayısı')
-        plt.xticks(rotation=45)
-        plt.tight_layout()
-        plt.savefig('images/aylik_yorum_dagilimi.png')
-        plt.close()
-
-        # Mevsimsel analiz
-        self.df['Mevsim'] = self.df['Tarih'].dt.month.map({
-            12: 'Kış', 1: 'Kış', 2: 'Kış',
-            3: 'İlkbahar', 4: 'İlkbahar', 5: 'İlkbahar',
-            6: 'Yaz', 7: 'Yaz', 8: 'Yaz',
-            9: 'Sonbahar', 10: 'Sonbahar', 11: 'Sonbahar'
-        })
-        seasonal_reviews = self.df.groupby('Mevsim').size()
-        plt.figure(figsize=(10, 6))
-        seasonal_reviews.plot(kind='bar')
-        plt.title('Mevsimsel Yorum Dağılımı')
-        plt.xlabel('Mevsim')
-        plt.ylabel('Yorum Sayısı')
-        plt.tight_layout()
-        plt.savefig('images/mevsimsel_dagilim.png')
-        plt.close()
-
-    def analyze_ratings(self):
-        """Yıldız bazlı analizler"""
-        plt.figure(figsize=(10, 6))
-        sns.countplot(data=self.df, x='Yıldız Sayısı')
-        plt.title('Yıldız Dağılımı')
-        plt.xlabel('Yıldız Sayısı')
-        plt.ylabel('Yorum Sayısı')
-        plt.savefig('images/yildiz_dagilimi.png')
-        plt.close()
-
-        return {
-            'Ortalama Yıldız': self.df['Yıldız Sayısı'].mean(),
-            'Medyan Yıldız': self.df['Yıldız Sayısı'].median(),
-            'Mod Yıldız': self.df['Yıldız Sayısı'].mode()[0],
-            'Standart Sapma': self.df['Yıldız Sayısı'].std()
-        }
-
-    def create_wordcloud(self):
-        """Kelime bulutu oluştur"""
-        all_comments = ' '.join([self.preprocess_text(str(comment)) 
-                               for comment in self.df['Yorum']])
-        
-        words = word_tokenize(all_comments)
-        filtered_words = [word for word in words 
-                         if word not in self.turkish_stopwords]
-        clean_text = ' '.join(filtered_words)
-        
-        wordcloud = WordCloud(
-            width=800, height=400,
-            background_color='white',
-            max_words=100,
-            font_path='C:/Windows/Fonts/arial.ttf'  # Windows varsayılan font
-        ).generate(clean_text)
-        
-        plt.figure(figsize=(15,8))
-        plt.imshow(wordcloud, interpolation='bilinear')
-        plt.axis('off')
-        plt.savefig('images/wordcloud.png')
-        plt.close()
-
-    def analyze_ngrams(self, max_n=3, top_n=10):
-        """N-gram analizi"""
-        all_texts = []
-        for comment in self.df['Yorum']:
-            if isinstance(comment, str):
-                words = self.preprocess_text(comment).split()
-                filtered_words = [word for word in words 
-                                if word not in self.turkish_stopwords]
-                all_texts.extend(filtered_words)
-
-        for n in range(1, max_n + 1):
-            print(f"\n{n}-gram Analizi:")
-            
-            if n == 1:
-                ngrams_list = all_texts
-            else:
-                ngrams_list = list(ngrams(all_texts, n))
-            
-            ngram_freq = Counter(ngrams_list).most_common(top_n)
-            
-            if n == 1:
-                labels = [item[0] for item in ngram_freq]
-            else:
-                labels = [' '.join(item[0]) for item in ngram_freq]
-            
-            values = [item[1] for item in ngram_freq]
-            
-            plt.figure(figsize=(12, 6))
-            bars = plt.barh(range(len(values)), values)
-            plt.yticks(range(len(labels)), labels)
-            plt.title(f'En Sık Kullanılan {n}-gramlar')
-            plt.xlabel('Frekans')
-            
-            for i, bar in enumerate(bars):
-                width = bar.get_width()
-                plt.text(width, bar.get_y() + bar.get_height()/2,
-                        f'{int(width)}',
-                        ha='left', va='center', fontweight='bold')
-            
-            plt.tight_layout()
-            plt.savefig(f'images/{n}gram_analizi.png')
-            plt.close()
-            
-            print(f"\nEn sık kullanılan {n}-gramlar:")
-            for ngram, freq in ngram_freq:
-                if n == 1:
-                    print(f"{ngram}: {freq}")
-                else:
-                    print(f"{' '.join(ngram)}: {freq}")
-
-    def analyze_sentiment(self):
-        """Duygu analizi"""
-        def count_sentiment_words(text):
-            if not isinstance(text, str):
-                return 0, 0
-            
-            text_lower = text.lower()
-            words = text_lower.split()
-            positive_count = sum(1 for word in words if word in self.positive_words)
-            negative_count = sum(1 for word in words if word in self.negative_words)
-            return positive_count, negative_count
-        
-        sentiment_counts = self.df['Yorum'].apply(count_sentiment_words)
-        self.df['Pozitif_Kelime_Sayisi'] = [count[0] for count in sentiment_counts]
-        self.df['Negatif_Kelime_Sayisi'] = [count[1] for count in sentiment_counts]
-        self.df['Sentiment_Skor'] = self.df['Pozitif_Kelime_Sayisi'] - self.df['Negatif_Kelime_Sayisi']
-        
-        plt.figure(figsize=(10, 6))
-        sns.boxplot(data=self.df, x='Yıldız Sayısı', y='Sentiment_Skor')
-        plt.title('Yıldız Sayısı ve Sentiment Skoru İlişkisi')
-        plt.savefig('images/sentiment_yildiz_iliskisi.png')
-        plt.close()
-        
-        plt.figure(figsize=(10, 6))
-        plt.hist(self.df['Sentiment_Skor'], bins=20)
-        plt.title('Sentiment Skor Dağılımı')
-        plt.xlabel('Sentiment Skoru')
-        plt.ylabel('Yorum Sayısı')
-        plt.savefig('images/sentiment_dagilimi.png')
-        plt.close()
-
-    def analyze_comment_lengths(self):
-        """Yorum uzunluğu analizi"""
-        self.df['Yorum_Uzunlugu'] = self.df['Yorum'].str.len()
-        
-        plt.figure(figsize=(10, 6))
-        plt.hist(self.df['Yorum_Uzunlugu'].dropna(), bins=30)
-        plt.title('Yorum Uzunluğu Dağılımı')
-        plt.xlabel('Karakter Sayısı')
-        plt.ylabel('Yorum Sayısı')
-        plt.savefig('images/yorum_uzunluk_dagilimi.png')
-        plt.close()
-        
-        plt.figure(figsize=(10, 6))
-        sns.boxplot(data=self.df, x='Yıldız Sayısı', y='Yorum_Uzunlugu')
-        plt.title('Yıldız Sayısı ve Yorum Uzunluğu İlişkisi')
-        plt.xlabel('Yıldız')
-        plt.ylabel('Yorum Uzunluğu (Karakter)')
-        plt.savefig('images/yildiz_uzunluk_iliskisi.png')
-        plt.close()
-
-    def run_analysis(self):
-        """Ana analiz fonksiyonu"""
-        print("Analiz başlatılıyor...")
-        
-        if not os.path.exists('images'):
-            os.makedirs('images')
-        
-        print("\nÜrün odaklı yorum filtresi uygulanıyor...")
-        self.filter_product_reviews()
-        
-        print("\n1. Yorum Uzunluğu Analizi")
-        self.analyze_comment_lengths()
-        
-        print("\n2. Zaman Analizi")
-        self.analyze_timestamps()
-        
-        print("\n3. Yıldız Analizi")
-        rating_stats = self.analyze_ratings()
-        print("\nYıldız İstatistikleri:")
-        for key, value in rating_stats.items():
-            print(f"{key}: {value:.2f}")
-        
-        print("\n4. Kelime Bulutu Oluşturuluyor")
-        self.create_wordcloud()
-        
-        print("\n5. N-gram Analizleri")
-        self.analyze_ngrams(max_n=3, top_n=10)
-        
-        print("\n6. Duygu Analizi")
-        self.analyze_sentiment()
-        
-        print("\nAnaliz tamamlandı! Tüm görseller 'images' klasörüne kaydedildi.")
-
-if __name__ == "__main__":
-    analyzer = ReviewAnalyzer('data/macbook_product_comments_with_ratings.csv')
-    analyzer.run_analysis()
+import os
+import re
+import warnings
+from collections import Counter
+from datetime import datetime
+
+import matplotlib.pyplot as plt
+import nltk
+import numpy as np
+import pandas as pd
+import requests
+import seaborn as sns
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from nltk.util import ngrams
+from textblob import TextBlob
+from wordcloud import WordCloud
+
+warnings.filterwarnings("ignore")
+plt.style.use("seaborn")
+
+nltk.download("stopwords")
+nltk.download("punkt")
+
+
+class ReviewAnalyzer:
+    def __init__(self, file_path):
+        self.df = pd.read_csv(file_path)
+        self.turkish_stopwords = self.get_turkish_stopwords()
+
+        # Lojistik ve satıcı ile ilgili kelimeleri genişletilmiş liste ile tanımla
+        self.logistics_seller_words = {
+            # Kargo ve teslimat ile ilgili
+            "kargo",
+            "kargocu",
+            "paket",
+            "paketleme",
+            "teslimat",
+            "teslim",
+            "gönderi",
+            "gönderim",
+            "ulaştı",
+            "ulaşım",
+            "geldi",
+            "kurye",
+            "dağıtım",
+            "hasarlı",
+            "hasar",
+            "kutu",
+            "ambalaj",
+            "zamanında",
+            "geç",
+            "hızlı",
+            "yavaş",
+            "günde",
+            "saatte",
+            # Satıcı ve mağaza ile ilgili
+            "satıcı",
+            "mağaza",
+            "sipariş",
+            "trendyol",
+            "tedarik",
+            "stok",
+            "garanti",
+            "fatura",
+            "iade",
+            "geri",
+            "müşteri",
+            "hizmet",
+            "destek",
+            "iletişim",
+            "şikayet",
+            "sorun",
+            "çözüm",
+            "hediye",
+            # Fiyat ve ödeme ile ilgili
+            "fiyat",
+            "ücret",
+            "para",
+            "bedava",
+            "ücretsiz",
+            "indirim",
+            "kampanya",
+            "taksit",
+            "ödeme",
+            "bütçe",
+            "hesap",
+            "kur",
+            # Zaman ile ilgili teslimat kelimeleri
+            "bugün",
+            "yarın",
+            "dün",
+            "hafta",
+            "gün",
+            "saat",
+            "süre",
+            "bekleme",
+            "gecikme",
+            "erken",
+            "geç",
+        }
+
+        # Sentiment analizi için kelimeler
+        self.positive_words = {
+            "güzel",
+            "harika",
+            "mükemmel",
+            "süper",
+            "iyi",
+            "muhteşem",
+            "teşekkür",
+            "memnun",
+            "başarılı",
+            "kaliteli",
+            "kusursuz",
+            "özgün",
+            "şahane",
+            "enfes",
+            "ideal",
+        }
+
+        self.negative_words = {
+            "kötü",
+            "berbat",
+            "rezalet",
+            "yetersiz",
+            "başarısız",
+            "vasat",
+            "korkunç",
+            "düşük",
+            "zayıf",
+            "çöp",
+            "pişman",
+            "kırık",
+            "bozuk",
+        }
+
+        # Türkçe-İngilizce ay çevirisi
+        self.month_map = {
+            "Ocak": "January",
+            "Şubat": "February",
+            "Mart": "March",
+            "Nisan": "April",
+            "Mayıs": "May",
+            "Haziran": "June",
+            "Temmuz": "July",
+            "Ağustos": "August",
+            "Eylül": "September",
+            "Ekim": "October",
+            "Kasım": "November",
+            "Aralık": "December",
+        }
+
+    def get_turkish_stopwords(self):
+        """Türkçe stop words listesini oluştur"""
+        turkish_stops = set(stopwords.words("turkish"))
+
+        github_url = "https://raw.githubusercontent.com/sgsinclair/trombone/master/src/main/resources/org/voyanttools/trombone/keywords/stop.tr.turkish-lucene.txt"
+        try:
+            response = requests.get(github_url)
+            if response.status_code == 200:
+                github_stops = set(
+                    word.strip() for word in response.text.split("\n") if word.strip()
+                )
+                turkish_stops.update(github_stops)
+        except Exception as e:
+            print(f"GitHub'dan stop words çekilirken hata oluştu: {e}")
+
+        custom_stops = {
+            "bir",
+            "ve",
+            "çok",
+            "bu",
+            "de",
+            "da",
+            "için",
+            "ile",
+            "ben",
+            "sen",
+            "o",
+            "biz",
+            "siz",
+            "onlar",
+            "bu",
+            "şu",
+            "ama",
+            "fakat",
+            "ancak",
+            "lakin",
+            "ki",
+            "dahi",
+            "mi",
+            "mı",
+            "mu",
+            "mü",
+        }
+        turkish_stops.update(custom_stops)
+
+        return turkish_stops
+
+    def filter_product_reviews(self):
+        """Salt ürün yorumlarını filtrele"""
+
+        def is_pure_product_review(text):
+            if not isinstance(text, str):
+                return False
+
+            text_lower = text.lower()
+            return not any(word in text_lower for word in self.logistics_seller_words)
+
+        # Filtrelenmiş DataFrame
+        original_count = len(self.df)
+        self.df = self.df[self.df["Yorum"].apply(is_pure_product_review)]
+        filtered_count = len(self.df)
+
+        print(f"\nFiltreleme İstatistikleri:")
+        print(f"Orijinal yorum sayısı: {original_count}")
+        print(f"Salt ürün yorumu sayısı: {filtered_count}")
+        print(f"Çıkarılan yorum sayısı: {original_count - filtered_count}")
+        print(
+            f"Filtreleme oranı: {((original_count - filtered_count) / original_count * 100):.2f}%"
+        )
+
+        print("\nÖrnek Salt Ürün Yorumları:")
+        sample_reviews = self.df["Yorum"].sample(min(3, len(self.df)))
+        for idx, review in enumerate(sample_reviews, 1):
+            print(f"{idx}. {review[:100]}...")
+
+    def convert_turkish_date(self, date_str):
+        """Türkçe tarihleri İngilizce'ye çevir"""
+        try:
+            day, month, year = date_str.split()
+            english_month = self.month_map[month]
+            return f"{day} {english_month} {year}"
+        except:
+            return None
+
+    def preprocess_text(self, text):
+        """Metin ön işleme"""
+        if isinstance(text, str):
+            text = text.lower()
+            text = re.sub(r"[^\w\s]", "", text)
+            text = re.sub(r"\d+", "", text)
+            text = re.sub(r"\s+", " ", text).strip()
+            return text
+        return ""
+
+    def analyze_timestamps(self):
+        """Zaman bazlı analizler"""
+        # Tarihleri dönüştür
+        self.df["Tarih"] = self.df["Tarih"].apply(self.convert_turkish_date)
+        self.df["Tarih"] = pd.to_datetime(self.df["Tarih"], format="%d %B %Y")
+
+        # Günlük dağılım
+        plt.figure(figsize=(12, 6))
+        plt.hist(self.df["Tarih"], bins=20, edgecolor="black")
+        plt.title("Yorumların Zaman İçindeki Dağılımı")
+        plt.xlabel("Tarih")
+        plt.ylabel("Yorum Sayısı")
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        plt.savefig("images/yorum_zaman_dagilimi.png")
+        plt.close()
+
+        # Aylık dağılım
+        monthly_reviews = self.df.groupby(self.df["Tarih"].dt.to_period("M")).size()
+        plt.figure(figsize=(12, 6))
+        monthly_reviews.plot(kind="bar")
+        plt.title("Aylık Yorum Dağılımı")
+        plt.xlabel("Ay")
+        plt.ylabel("Yorum Sayısı")
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        plt.savefig("images/aylik_yorum_dagilimi.png")
+        plt.close()
+
+        # Mevsimsel analiz
+        self.df["Mevsim"] = self.df["Tarih"].dt.month.map(
+            {
+                12: "Kış",
+                1: "Kış",
+                2: "Kış",
+                3: "İlkbahar",
+                4: "İlkbahar",
+                5: "İlkbahar",
+                6: "Yaz",
+                7: "Yaz",
+                8: "Yaz",
+                9: "Sonbahar",
+                10: "Sonbahar",
+                11: "Sonbahar",
+            }
+        )
+        seasonal_reviews = self.df.groupby("Mevsim").size()
+        plt.figure(figsize=(10, 6))
+        seasonal_reviews.plot(kind="bar")
+        plt.title("Mevsimsel Yorum Dağılımı")
+        plt.xlabel("Mevsim")
+        plt.ylabel("Yorum Sayısı")
+        plt.tight_layout()
+        plt.savefig("images/mevsimsel_dagilim.png")
+        plt.close()
+
+    def analyze_ratings(self):
+        """Yıldız bazlı analizler"""
+        plt.figure(figsize=(10, 6))
+        sns.countplot(data=self.df, x="Yıldız Sayısı")
+        plt.title("Yıldız Dağılımı")
+        plt.xlabel("Yıldız Sayısı")
+        plt.ylabel("Yorum Sayısı")
+        plt.savefig("images/yildiz_dagilimi.png")
+        plt.close()
+
+        return {
+            "Ortalama Yıldız": self.df["Yıldız Sayısı"].mean(),
+            "Medyan Yıldız": self.df["Yıldız Sayısı"].median(),
+            "Mod Yıldız": self.df["Yıldız Sayısı"].mode()[0],
+            "Standart Sapma": self.df["Yıldız Sayısı"].std(),
+        }
+
+    def create_wordcloud(self):
+        """Kelime bulutu oluştur"""
+        all_comments = " ".join(
+            [self.preprocess_text(str(comment)) for comment in self.df["Yorum"]]
+        )
+
+        words = word_tokenize(all_comments)
+        filtered_words = [word for word in words if word not in self.turkish_stopwords]
+        clean_text = " ".join(filtered_words)
+
+        wordcloud = WordCloud(
+            width=800,
+            height=400,
+            background_color="white",
+            max_words=100,
+            font_path="C:/Windows/Fonts/arial.ttf",  # Windows varsayılan font
+        ).generate(clean_text)
+
+        plt.figure(figsize=(15, 8))
+        plt.imshow(wordcloud, interpolation="bilinear")
+        plt.axis("off")
+        plt.savefig("images/wordcloud.png")
+        plt.close()
+
+    def analyze_ngrams(self, max_n=3, top_n=10):
+        """N-gram analizi"""
+        all_texts = []
+        for comment in self.df["Yorum"]:
+            if isinstance(comment, str):
+                words = self.preprocess_text(comment).split()
+                filtered_words = [
+                    word for word in words if word not in self.turkish_stopwords
+                ]
+                all_texts.extend(filtered_words)
+
+        for n in range(1, max_n + 1):
+            print(f"\n{n}-gram Analizi:")
+
+            if n == 1:
+                ngrams_list = all_texts
+            else:
+                ngrams_list = list(ngrams(all_texts, n))
+
+            ngram_freq = Counter(ngrams_list).most_common(top_n)
+
+            if n == 1:
+                labels = [item[0] for item in ngram_freq]
+            else:
+                labels = [" ".join(item[0]) for item in ngram_freq]
+
+            values = [item[1] for item in ngram_freq]
+
+            plt.figure(figsize=(12, 6))
+            bars = plt.barh(range(len(values)), values)
+            plt.yticks(range(len(labels)), labels)
+            plt.title(f"En Sık Kullanılan {n}-gramlar")
+            plt.xlabel("Frekans")
+
+            for i, bar in enumerate(bars):
+                width = bar.get_width()
+                plt.text(
+                    width,
+                    bar.get_y() + bar.get_height() / 2,
+                    f"{int(width)}",
+                    ha="left",
+                    va="center",
+                    fontweight="bold",
+                )
+
+            plt.tight_layout()
+            plt.savefig(f"images/{n}gram_analizi.png")
+            plt.close()
+
+            print(f"\nEn sık kullanılan {n}-gramlar:")
+            for ngram, freq in ngram_freq:
+                if n == 1:
+                    print(f"{ngram}: {freq}")
+                else:
+                    print(f"{' '.join(ngram)}: {freq}")
+
+    def analyze_sentiment(self):
+        """Duygu analizi"""
+
+        def count_sentiment_words(text):
+            if not isinstance(text, str):
+                return 0, 0
+
+            text_lower = text.lower()
+            words = text_lower.split()
+            positive_count = sum(1 for word in words if word in self.positive_words)
+            negative_count = sum(1 for word in words if word in self.negative_words)
+            return positive_count, negative_count
+
+        sentiment_counts = self.df["Yorum"].apply(count_sentiment_words)
+        self.df["Pozitif_Kelime_Sayisi"] = [count[0] for count in sentiment_counts]
+        self.df["Negatif_Kelime_Sayisi"] = [count[1] for count in sentiment_counts]
+        self.df["Sentiment_Skor"] = (
+            self.df["Pozitif_Kelime_Sayisi"] - self.df["Negatif_Kelime_Sayisi"]
+        )
+
+        plt.figure(figsize=(10, 6))
+        sns.boxplot(data=self.df, x="Yıldız Sayısı", y="Sentiment_Skor")
+        plt.title("Yıldız Sayısı ve Sentiment Skoru İlişkisi")
+        plt.savefig("images/sentiment_yildiz_iliskisi.png")
+        plt.close()
+
+        plt.figure(figsize=(10, 6))
+        plt.hist(self.df["Sentiment_Skor"], bins=20)
+        plt.title("Sentiment Skor Dağılımı")
+        plt.xlabel("Sentiment Skoru")
+        plt.ylabel("Yorum Sayısı")
+        plt.savefig("images/sentiment_dagilimi.png")
+        plt.close()
+
+    def analyze_comment_lengths(self):
+        """Yorum uzunluğu analizi"""
+        self.df["Yorum_Uzunlugu"] = self.df["Yorum"].str.len()
+
+        plt.figure(figsize=(10, 6))
+        plt.hist(self.df["Yorum_Uzunlugu"].dropna(), bins=30)
+        plt.title("Yorum Uzunluğu Dağılımı")
+        plt.xlabel("Karakter Sayısı")
+        plt.ylabel("Yorum Sayısı")
+        plt.savefig("images/yorum_uzunluk_dagilimi.png")
+        plt.close()
+
+        plt.figure(figsize=(10, 6))
+        sns.boxplot(data=self.df, x="Yıldız Sayısı", y="Yorum_Uzunlugu")
+        plt.title("Yıldız Sayısı ve Yorum Uzunluğu İlişkisi")
+        plt.xlabel("Yıldız")
+        plt.ylabel("Yorum Uzunluğu (Karakter)")
+        plt.savefig("images/yildiz_uzunluk_iliskisi.png")
+        plt.close()
+
+    def run_analysis(self):
+        """Ana analiz fonksiyonu"""
+        print("Analiz başlatılıyor...")
+
+        if not os.path.exists("images"):
+            os.makedirs("images")
+
+        print("\nÜrün odaklı yorum filtresi uygulanıyor...")
+        self.filter_product_reviews()
+
+        print("\n1. Yorum Uzunluğu Analizi")
+        self.analyze_comment_lengths()
+
+        print("\n2. Zaman Analizi")
+        self.analyze_timestamps()
+
+        print("\n3. Yıldız Analizi")
+        rating_stats = self.analyze_ratings()
+        print("\nYıldız İstatistikleri:")
+        for key, value in rating_stats.items():
+            print(f"{key}: {value:.2f}")
+
+        print("\n4. Kelime Bulutu Oluşturuluyor")
+        self.create_wordcloud()
+
+        print("\n5. N-gram Analizleri")
+        self.analyze_ngrams(max_n=3, top_n=10)
+
+        print("\n6. Duygu Analizi")
+        self.analyze_sentiment()
+
+        print("\nAnaliz tamamlandı! Tüm görseller 'images' klasörüne kaydedildi.")
+
+
+if __name__ == "__main__":
+    analyzer = ReviewAnalyzer("data/macbook_product_comments_with_ratings.csv")
+    analyzer.run_analysis()

scripts/review_summarizer.py

@@ -1,291 +1,323 @@
-import pandas as pd
-import numpy as np
-from transformers import (
-    AutoTokenizer,
-    AutoModelForSequenceClassification
-)
-import torch
-import os
-import requests
-from collections import Counter
-import warnings
-from nltk.tokenize import word_tokenize
-import nltk
-import re
-import google.generativeai as genai
-from dotenv import load_dotenv
-import logging
-
-warnings.filterwarnings('ignore')
-
-# NLTK indirmelerini try-except bloğuna alalım
-try:
-    nltk.download('stopwords', quiet=True)
-    nltk.download('punkt', quiet=True)
-except:
-    print("NLTK dosyaları indirilemedi, devam ediliyor...")
-
-logger = logging.getLogger(__name__)
-
-class ReviewAnalyzer:
-    def __init__(self):
-        try:
-            # Load environment variables
-            load_dotenv()
-            
-            # Configure Gemini API
-            api_key = os.getenv('GOOGLE_API_KEY')
-            if not api_key:
-                raise ValueError("GOOGLE_API_KEY bulunamadı")
-            
-            genai.configure(api_key=api_key)
-            self.model = genai.GenerativeModel('gemini-pro')
-            
-            # Sentiment model kurulumu
-            self.setup_sentiment_model()
-            
-            # Stop words yükleme
-            self.turkish_stopwords = self.get_turkish_stopwords()
-            
-            logger.info("ReviewAnalyzer başarıyla başlatıldı")
-            
-        except Exception as e:
-            logger.error(f"ReviewAnalyzer başlatılırken hata: {str(e)}")
-            raise
-
-        # Lojistik ve satıcı ile ilgili kelimeleri tanımla
-        self.logistics_seller_words = {
-            # Kargo ve teslimat ile ilgili
-            'kargo', 'kargocu', 'paket', 'paketleme', 'teslimat', 'teslim',
-            'gönderi', 'gönderim', 'ulaştı', 'ulaşım', 'geldi', 'kurye',
-            'dağıtım', 'hasarlı', 'hasar', 'kutu', 'ambalaj', 'zamanında',
-            'geç', 'hızlı', 'yavaş', 'günde', 'saatte',
-
-            # Satıcı ve mağaza ile ilgili
-            'satıcı', 'mağaza', 'sipariş', 'trendyol', 'tedarik', 'stok',
-            'garanti', 'fatura', 'iade', 'geri', 'müşteri', 'hizmet',
-            'destek', 'iletişim', 'şikayet', 'sorun', 'çözüm', 'hediye',
-
-            # Fiyat ve ödeme ile ilgili
-            'fiyat', 'ücret', 'para', 'bedava', 'ücretsiz', 'indirim',
-            'kampanya', 'taksit', 'ödeme', 'bütçe', 'hesap', 'kur',
-
-            # Zaman ile ilgili teslimat kelimeleri
-            'bugün', 'yarın', 'dün', 'hafta', 'gün', 'saat', 'süre',
-            'bekleme', 'gecikme', 'erken', 'geç'
-        }
-
-    def get_turkish_stopwords(self):
-        """Genişletilmiş stop words listesini hazırla"""
-        github_url = "https://raw.githubusercontent.com/sgsinclair/trombone/master/src/main/resources/org/voyanttools/trombone/keywords/stop.tr.turkish-lucene.txt"
-        stop_words = set()
-
-        try:
-            response = requests.get(github_url)
-            if response.status_code == 200:
-                github_stops = set(word.strip() for word in response.text.split('\n') if word.strip())
-                stop_words.update(github_stops)
-        except Exception as e:
-            print(f"GitHub'dan stop words çekilirken hata oluştu: {e}")
-
-        stop_words.update(set(nltk.corpus.stopwords.words('turkish')))
-
-        additional_stops = {'bir', 've', 'çok', 'bu', 'de', 'da', 'için', 'ile', 'ben', 'sen',
-                          'o', 'biz', 'siz', 'onlar', 'bu', 'şu', 'ama', 'fakat', 'ancak',
-                          'lakin', 'ki', 'dahi', 'mi', 'mı', 'mu', 'mü', 'var', 'yok',
-                          'olan', 'içinde', 'üzerinde', 'bana', 'sana', 'ona', 'bize',
-                          'size', 'onlara', 'evet', 'hayır', 'tamam', 'oldu', 'olmuş',
-                          'olacak', 'etmek', 'yapmak', 'kez', 'kere', 'defa', 'adet'}
-        stop_words.update(additional_stops)
-
-        print(f"Toplam {len(stop_words)} adet stop words yüklendi.")
-        return stop_words
-
-    def preprocess_text(self, text):
-        """Metin ön işleme"""
-        if isinstance(text, str):
-            # Küçük harfe çevir
-            text = text.lower()
-            # Özel karakterleri temizle
-            text = re.sub(r'[^\w\s]', '', text)
-            # Sayıları temizle
-            text = re.sub(r'\d+', '', text)
-            # Fazla boşlukları temizle
-            text = re.sub(r'\s+', ' ', text).strip()
-            # Stop words'leri çıkar
-            words = text.split()
-            words = [word for word in words if word not in self.turkish_stopwords]
-            return ' '.join(words)
-        return ''
-
-    def setup_sentiment_model(self):
-        """Sentiment analiz modelini hazırla"""
-        try:
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-            logger.info(f"Using device for sentiment: {self.device}")
-
-            model_name = "savasy/bert-base-turkish-sentiment-cased"
-            
-            logger.info(f"Tokenizer yükleniyor: {model_name}")
-            self.sentiment_tokenizer = AutoTokenizer.from_pretrained(model_name)
-            
-            logger.info(f"Model yükleniyor: {model_name}")
-            self.sentiment_model = (
-                AutoModelForSequenceClassification.from_pretrained(model_name)
-                .to(self.device)
-                .to(torch.float32)
-            )
-            logger.info("Sentiment model başarıyla yüklendi")
-            
-        except Exception as e:
-            logger.error(f"Sentiment model kurulumunda hata: {str(e)}", exc_info=True)
-            raise
-
-    def filter_reviews(self, df):
-        """Ürün ile ilgili olmayan yorumları filtrele"""
-        def is_product_review(text):
-            if not isinstance(text, str):
-                return False
-            return not any(word in text.lower() for word in self.logistics_seller_words)
-
-        filtered_df = df[df['Yorum'].apply(is_product_review)].copy()
-
-        print(f"\nFiltreleme İstatistikleri:")
-        print(f"Toplam yorum sayısı: {len(df)}")
-        print(f"Ürün yorumu sayısı: {len(filtered_df)}")
-        print(f"Filtrelenen yorum sayısı: {len(df) - len(filtered_df)}")
-        print(f"Filtreleme oranı: {((len(df) - len(filtered_df)) / len(df) * 100):.2f}%")
-
-        return filtered_df
-
-    def analyze_sentiment(self, df):
-        """Sentiment analizi yap"""
-        def predict_sentiment(text):
-            if not isinstance(text, str) or len(text.strip()) == 0:
-                return {"label": "Nötr", "score": 0.5}
-
-            try:
-                cleaned_text = self.preprocess_text(text)
-
-                inputs = self.sentiment_tokenizer(
-                    cleaned_text,
-                    return_tensors="pt",
-                    truncation=True,
-                    max_length=512,
-                    padding=True
-                ).to(self.device)
-
-                with torch.no_grad():
-                    outputs = self.sentiment_model(**inputs)
-                    probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-                    prediction = probs.cpu().numpy()[0]
-
-                score = float(prediction[1])
-
-                if score > 0.75:
-                    label = "Pozitif"
-                elif score < 0.25:
-                    label = "Negatif"
-                elif score > 0.55:
-                    label = "Pozitif"
-                elif score < 0.45:
-                    label = "Negatif"
-                else:
-                    label = "Nötr"
-
-                return {"label": label, "score": score}
-
-            except Exception as e:
-                print(f"Error in sentiment prediction: {e}")
-                return {"label": "Nötr", "score": 0.5}
-
-        print("\nSentiment analizi yapılıyor...")
-        results = [predict_sentiment(text) for text in df['Yorum']]
-
-        df['sentiment_score'] = [r['score'] for r in results]
-        df['sentiment_label'] = [r['label'] for r in results]
-        df['cleaned_text'] = df['Yorum'].apply(self.preprocess_text)
-
-        return df
-
-    def get_key_phrases(self, text_series):
-        """En önemli anahtar kelimeleri bul"""
-        text = ' '.join(text_series.astype(str))
-        words = self.preprocess_text(text).split()
-        word_freq = Counter(words)
-        # En az 3 kez geçen kelimeleri al
-        return {word: count for word, count in word_freq.items()
-               if count >= 3 and len(word) > 2}
-
-    def generate_summary(self, df):
-        """Yorumları özetle"""
-        # Yorumları ve yıldızları birleştir
-        reviews_with_ratings = [
-            f"Yıldız: {row['Yıldız Sayısı']}, Yorum: {row['Yorum']}"
-            for _, row in df.iterrows()
-        ]
-        
-        # Prompt hazırla
-        prompt = f"""
-        Aşağıdaki ürün yorumlarını analiz edip özet çıkar:
-
-        {reviews_with_ratings[:50]}  # İlk 50 yorumu al (API limiti için)
-
-        Lütfen şu başlıklar altında özetle:
-        1. Genel Değerlendirme
-        2. Olumlu Yönler
-        3. Olumsuz Yönler
-        4. Öneriler
-
-        Önemli: Yanıtını Türkçe olarak ver ve madde madde listele.
-        """
-        
-        try:
-            response = self.model.generate_content(prompt)
-            summary = response.text
-        except Exception as e:
-            summary = f"Özet oluşturulurken hata oluştu: {str(e)}"
-        
-        return summary
-
-    def analyze_reviews(self, df):
-        """Tüm yorumları analiz et"""
-        try:
-            # Yorumları filtrele
-            filtered_df = self.filter_reviews(df)
-            
-            # Sentiment analizi yap
-            analyzed_df = self.analyze_sentiment(filtered_df)
-            
-            return analyzed_df
-            
-        except Exception as e:
-            print(f"Analiz sırasında hata oluştu: {str(e)}")
-            return pd.DataFrame()
-
-def analyze_reviews(file_path):
-    df = pd.read_csv(file_path)
-
-    analyzer = ReviewAnalyzer()
-
-    filtered_df = analyzer.filter_reviews(df)
-
-    print("Sentiment analizi başlatılıyor...")
-    analyzed_df = analyzer.analyze_sentiment(filtered_df)
-
-    analyzed_df.to_csv('sentiment_analyzed_reviews.csv', index=False, encoding='utf-8-sig')
-    print("Sentiment analizi tamamlandı ve kaydedildi.")
-
-    print("\nÜrün özeti oluşturuluyor...")
-    summary = analyzer.generate_summary(analyzed_df)
-
-    with open('urun_ozeti.txt', 'w', encoding='utf-8') as f:
-        f.write(summary)
-
-    print("\nÜrün Özeti:")
-    print("-" * 50)
-    print(summary)
-    print("\nÖzet 'urun_ozeti.txt' dosyasına kaydedildi.")
-
-if __name__ == "__main__":
-    analyze_reviews('data/macbook_product_comments_with_ratings.csv')
+import os
+import re
+import warnings
+from collections import Counter
+
+import google.generativeai as genai
+import nltk
+import numpy as np
+import pandas as pd
+import requests
+import torch
+from nltk.tokenize import word_tokenize
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+warnings.filterwarnings("ignore")
+
+nltk.download("stopwords", quiet=True)
+nltk.download("punkt", quiet=True)
+
+
+class ReviewAnalyzer:
+    def __init__(self, gemini_api_key):
+        self.turkish_stopwords = self.get_turkish_stopwords()
+        self.setup_sentiment_model()
+        self.setup_gemini_model(gemini_api_key)
+
+        self.logistics_seller_words = {
+            "kargo",
+            "kargocu",
+            "paket",
+            "paketleme",
+            "teslimat",
+            "teslim",
+            "gönderi",
+            "gönderim",
+            "ulaştı",
+            "ulaşım",
+            "geldi",
+            "kurye",
+            "dağıtım",
+            "hasarlı",
+            "hasar",
+            "kutu",
+            "ambalaj",
+            "zamanında",
+            "geç",
+            "hızlı",
+            "yavaş",
+            "günde",
+            "saatte",
+            "satıcı",
+            "mağaza",
+            "sipariş",
+            "trendyol",
+            "tedarik",
+            "stok",
+            "garanti",
+            "fatura",
+            "iade",
+            "geri",
+            "müşteri",
+            "hizmet",
+            "destek",
+            "iletişim",
+            "şikayet",
+            "sorun",
+            "çözüm",
+            "hediye",
+            "fiyat",
+            "ücret",
+            "para",
+            "bedava",
+            "ücretsiz",
+            "indirim",
+            "kampanya",
+            "taksit",
+            "ödeme",
+            "bütçe",
+            "hesap",
+            "kur",
+            "bugün",
+            "yarın",
+            "dün",
+            "hafta",
+            "gün",
+            "saat",
+            "süre",
+            "bekleme",
+            "gecikme",
+            "erken",
+            "geç",
+        }
+
+    def get_turkish_stopwords(self):
+        """Türkçe stop words listesi oluştur"""
+        github_url = "https://raw.githubusercontent.com/sgsinclair/trombone/master/src/main/resources/org/voyanttools/trombone/keywords/stop.tr.turkish-lucene.txt"
+        stop_words = set()
+
+        try:
+            response = requests.get(github_url)
+            if response.status_code == 200:
+                github_stops = set(
+                    word.strip() for word in response.text.split("\n") if word.strip()
+                )
+                stop_words.update(github_stops)
+        except Exception as e:
+            print(f"GitHub'dan stop words çekilirken hata oluştu: {e}")
+
+        stop_words.update(set(nltk.corpus.stopwords.words("turkish")))
+
+        additional_stops = {
+            "bir",
+            "ve",
+            "çok",
+            "bu",
+            "de",
+            "da",
+            "için",
+            "ile",
+            "ben",
+            "sen",
+            "o",
+            "biz",
+            "siz",
+            "onlar",
+            "bu",
+            "şu",
+            "ama",
+            "fakat",
+            "ancak",
+            "lakin",
+            "ki",
+            "dahi",
+            "mi",
+            "mı",
+            "mu",
+            "mü",
+            "var",
+            "yok",
+            "olan",
+            "içinde",
+            "üzerinde",
+            "bana",
+            "sana",
+            "ona",
+            "bize",
+            "size",
+            "onlara",
+            "evet",
+            "hayır",
+            "tamam",
+            "oldu",
+            "olmuş",
+            "olacak",
+            "etmek",
+            "yapmak",
+            "kez",
+            "kere",
+            "defa",
+            "adet",
+        }
+        stop_words.update(additional_stops)
+
+        print(f"Toplam {len(stop_words)} adet stop words yüklendi.")
+        return stop_words
+
+    def preprocess_text(self, text):
+        if isinstance(text, str):
+            text = text.lower()
+            text = re.sub(r"[^\w\s]", "", text)
+            text = re.sub(r"\d+", "", text)
+            text = re.sub(r"\s+", " ", text).strip()
+            words = text.split()
+            words = [word for word in words if word not in self.turkish_stopwords]
+            return " ".join(words)
+        return ""
+
+    def setup_sentiment_model(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device for sentiment: {self.device}")
+
+        model_name = "savasy/bert-base-turkish-sentiment-cased"
+        self.sentiment_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.sentiment_model = (
+            AutoModelForSequenceClassification.from_pretrained(model_name)
+            .to(self.device)
+            .to(torch.float32)
+        )
+
+    def setup_gemini_model(self, api_key):
+        genai.configure(api_key=api_key)
+        self.gemini_model = genai.GenerativeModel("gemini-pro")
+
+    def filter_reviews(self, df):
+        def is_product_review(text):
+            if not isinstance(text, str):
+                return False
+            return not any(word in text.lower() for word in self.logistics_seller_words)
+
+        filtered_df = df[df["Yorum"].apply(is_product_review)].copy()
+
+        print(f"\nFiltreleme İstatistikleri:")
+        print(f"Toplam yorum sayısı: {len(df)}")
+        print(f"Ürün yorumu sayısı: {len(filtered_df)}")
+        print(f"Filtrelenen yorum sayısı: {len(df) - len(filtered_df)}")
+        print(
+            f"Filtreleme oranı: {((len(df) - len(filtered_df)) / len(df) * 100):.2f}%"
+        )
+
+        return filtered_df
+
+    def analyze_sentiment(self, df):
+        def predict_sentiment(text):
+            if not isinstance(text, str) or len(text.strip()) == 0:
+                return {"label": "Nötr", "score": 0.5}
+
+            try:
+                cleaned_text = self.preprocess_text(text)
+                inputs = self.sentiment_tokenizer(
+                    cleaned_text,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=512,
+                    padding=True,
+                ).to(self.device)
+
+                with torch.no_grad():
+                    outputs = self.sentiment_model(**inputs)
+                    probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+                    prediction = probs.cpu().numpy()[0]
+
+                score = float(prediction[1])
+
+                if score > 0.75:
+                    label = "Pozitif"
+                elif score < 0.25:
+                    label = "Negatif"
+                elif score > 0.55:
+                    label = "Pozitif"
+                elif score < 0.45:
+                    label = "Negatif"
+                else:
+                    label = "Nötr"
+
+                return {"label": label, "score": score}
+
+            except Exception as e:
+                print(f"Error in sentiment prediction: {e}")
+                return {"label": "Nötr", "score": 0.5}
+
+        print("\nSentiment analizi yapılıyor...")
+        results = [predict_sentiment(text) for text in df["Yorum"]]
+
+        df["sentiment_score"] = [r["score"] for r in results]
+        df["sentiment_label"] = [r["label"] for r in results]
+        df["cleaned_text"] = df["Yorum"].apply(self.preprocess_text)
+
+        return df
+
+    def get_key_phrases(self, text_series):
+        text = " ".join(text_series.astype(str))
+        words = self.preprocess_text(text).split()
+        word_freq = Counter(words)
+        return {
+            word: count
+            for word, count in word_freq.items()
+            if count >= 3 and len(word) > 2
+        }
+
+    def generate_summary(self, df):
+        # en onemli yorumları sec
+        high_rated = df[df["Yıldız Sayısı"] >= 4]
+        low_rated = df[df["Yıldız Sayısı"] <= 2]
+
+        # onemli kelimleri ve yorumlari al
+        positive_features = self.get_key_phrases(high_rated["cleaned_text"])
+        negative_features = self.get_key_phrases(low_rated["cleaned_text"])
+
+        top_positive = (
+            high_rated.sort_values("sentiment_score", ascending=False)["Yorum"]
+            .head(3)
+            .tolist()
+        )
+        top_negative = (
+            low_rated.sort_values("sentiment_score")["Yorum"].head(2).tolist()
+        )
+
+        summary_prompt = f"""Bu ürünün genel değerlendirmesini doğal bir dille özetleyeceksin.
+
+Veriler:
+- Toplam {len(df)} değerlendirme var
+- Ortalama puan: {df['Yıldız Sayısı'].mean():.1f}/5
+- Pozitif yorum oranı: {(len(df[df['sentiment_label'] == 'Pozitif']) / len(df) * 100):.1f}%
+
+En çok tekrar eden olumlu ifadeler: {', '.join(list(positive_features.keys())[:5])}
+En çok tekrar eden olumsuz ifadeler: {', '.join(list(negative_features.keys())[:5])}
+
+Örnek olumlu yorumlar:
+{' '.join(top_positive)}
+
+Örnek olumsuz yorumlar:
+{' '.join(top_negative)}
+
+Lütfen bu bilgileri kullanarak, ürünle ilgili kullanıcı deneyimlerini tek bir paragrafta, sohbet eder gibi doğal bir dille özetle.
+İstatistikleri direkt verme, onları cümlelerin içine yerleştir. Olumlu ve olumsuz yönleri dengeli bir şekilde aktar."""
+
+        response = self.gemini_model.generate_content(summary_prompt)
+        return response.text
+
+
+def analyze_reviews(file_path, api_key):
+    print("Analiz başlatılıyor...")
+    df = pd.read_csv(file_path)
+
+    analyzer = ReviewAnalyzer(api_key)
+
+    filtered_df = analyzer.filter_reviews(df)
+
+    analyzed_df = analyzer.analyze_sentiment(filtered_df)
+
+    summary = analyzer.generate_summary(analyzed_df)
+
+    return summary, analyzed_df

scripts/review_summarizer_trendyol_llama.py

@@ -0,0 +1,411 @@
+import os
+import re
+import warnings
+from collections import Counter
+
+import matplotlib.pyplot as plt
+import nltk
+import numpy as np
+import pandas as pd
+import requests
+import seaborn as sns
+import torch
+from nltk.tokenize import word_tokenize
+from nltk.util import ngrams
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
+from wordcloud import WordCloud
+
+warnings.filterwarnings("ignore")
+
+nltk.download("stopwords")
+nltk.download("punkt")
+
+
+class ReviewAnalyzer:
+    def __init__(self):
+        self.turkish_stopwords = self.get_turkish_stopwords()
+        self.setup_sentiment_model()
+        self.setup_summary_model()
+
+        # Lojistik ve satıcı ile ilgili kelimeleri tanımla
+        self.logistics_seller_words = {
+            # Kargo ve teslimat ile ilgili
+            "kargo",
+            "kargocu",
+            "paket",
+            "paketleme",
+            "teslimat",
+            "teslim",
+            "gönderi",
+            "gönderim",
+            "ulaştı",
+            "ulaşım",
+            "geldi",
+            "kurye",
+            "dağıtım",
+            "hasarlı",
+            "hasar",
+            "kutu",
+            "ambalaj",
+            "zamanında",
+            "geç",
+            "hızlı",
+            "yavaş",
+            "günde",
+            "saatte",
+            # Satıcı ve mağaza ile ilgili
+            "satıcı",
+            "mağaza",
+            "sipariş",
+            "trendyol",
+            "tedarik",
+            "stok",
+            "garanti",
+            "fatura",
+            "iade",
+            "geri",
+            "müşteri",
+            "hizmet",
+            "destek",
+            "iletişim",
+            "şikayet",
+            "sorun",
+            "çözüm",
+            "hediye",
+            # Fiyat ve ödeme ile ilgili
+            "fiyat",
+            "ücret",
+            "para",
+            "bedava",
+            "ücretsiz",
+            "indirim",
+            "kampanya",
+            "taksit",
+            "ödeme",
+            "bütçe",
+            "hesap",
+            "kur",
+            # Zaman ile ilgili teslimat kelimeleri
+            "bugün",
+            "yarın",
+            "dün",
+            "hafta",
+            "gün",
+            "saat",
+            "süre",
+            "bekleme",
+            "gecikme",
+            "erken",
+            "geç",
+        }
+
+    def get_turkish_stopwords(self):
+        """Genişletilmiş stop words listesini hazırla"""
+        github_url = "https://raw.githubusercontent.com/sgsinclair/trombone/master/src/main/resources/org/voyanttools/trombone/keywords/stop.tr.turkish-lucene.txt"
+        stop_words = set()
+
+        try:
+            response = requests.get(github_url)
+            if response.status_code == 200:
+                github_stops = set(
+                    word.strip() for word in response.text.split("\n") if word.strip()
+                )
+                stop_words.update(github_stops)
+        except Exception as e:
+            print(f"GitHub'dan stop words çekilirken hata oluştu: {e}")
+
+        stop_words.update(set(nltk.corpus.stopwords.words("turkish")))
+
+        additional_stops = {
+            "bir",
+            "ve",
+            "çok",
+            "bu",
+            "de",
+            "da",
+            "için",
+            "ile",
+            "ben",
+            "sen",
+            "o",
+            "biz",
+            "siz",
+            "onlar",
+            "bu",
+            "şu",
+            "ama",
+            "fakat",
+            "ancak",
+            "lakin",
+            "ki",
+            "dahi",
+            "mi",
+            "mı",
+            "mu",
+            "mü",
+            "var",
+            "yok",
+            "olan",
+            "içinde",
+            "üzerinde",
+            "bana",
+            "sana",
+            "ona",
+            "bize",
+            "size",
+            "onlara",
+            "evet",
+            "hayır",
+            "tamam",
+            "oldu",
+            "olmuş",
+            "olacak",
+            "etmek",
+            "yapmak",
+            "kez",
+            "kere",
+            "defa",
+            "adet",
+        }
+        stop_words.update(additional_stops)
+
+        print(f"Toplam {len(stop_words)} adet stop words yüklendi.")
+        return stop_words
+
+    def preprocess_text(self, text):
+        """Metin ön işleme"""
+        if isinstance(text, str):
+            # Küçük harfe çevir
+            text = text.lower()
+            # Özel karakterleri temizle
+            text = re.sub(r"[^\w\s]", "", text)
+            # Sayıları temizle
+            text = re.sub(r"\d+", "", text)
+            # Fazla boşlukları temizle
+            text = re.sub(r"\s+", " ", text).strip()
+            # Stop words'leri çıkar
+            words = text.split()
+            words = [word for word in words if word not in self.turkish_stopwords]
+            return " ".join(words)
+        return ""
+
+    def setup_sentiment_model(self):
+        """Sentiment analiz modelini hazırla"""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device for sentiment: {self.device}")
+
+        model_name = "savasy/bert-base-turkish-sentiment-cased"
+        self.sentiment_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.sentiment_model = (
+            AutoModelForSequenceClassification.from_pretrained(model_name)
+            .to(self.device)
+            .to(torch.float32)
+        )
+
+    def setup_summary_model(self):
+        """Özet modelini hazırla"""
+        print("Loading Trendyol-LLM model...")
+        model_id = "Trendyol/Trendyol-LLM-8b-chat-v2.0"
+
+        self.summary_pipe = pipeline(
+            "text-generation",
+            model=model_id,
+            torch_dtype="auto",
+            device_map="auto",
+        )
+
+        self.terminators = [
+            self.summary_pipe.tokenizer.eos_token_id,
+            self.summary_pipe.tokenizer.convert_tokens_to_ids("<|eot_id|>"),
+        ]
+
+        self.sampling_params = {
+            "do_sample": True,
+            "temperature": 0.3,
+            "top_k": 50,
+            "top_p": 0.9,
+            "repetition_penalty": 1.1,
+        }
+
+    def filter_reviews(self, df):
+        """Ürün ile ilgili olmayan yorumları filtrele"""
+
+        def is_product_review(text):
+            if not isinstance(text, str):
+                return False
+            return not any(word in text.lower() for word in self.logistics_seller_words)
+
+        filtered_df = df[df["Yorum"].apply(is_product_review)].copy()
+
+        print(f"\nFiltreleme İstatistikleri:")
+        print(f"Toplam yorum sayısı: {len(df)}")
+        print(f"Ürün yorumu sayısı: {len(filtered_df)}")
+        print(f"Filtrelenen yorum sayısı: {len(df) - len(filtered_df)}")
+        print(
+            f"Filtreleme oranı: {((len(df) - len(filtered_df)) / len(df) * 100):.2f}%"
+        )
+
+        return filtered_df
+
+    def analyze_sentiment(self, df):
+        """Sentiment analizi yap"""
+
+        def predict_sentiment(text):
+            if not isinstance(text, str) or len(text.strip()) == 0:
+                return {"label": "Nötr", "score": 0.5}
+
+            try:
+                cleaned_text = self.preprocess_text(text)
+
+                inputs = self.sentiment_tokenizer(
+                    cleaned_text,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=512,
+                    padding=True,
+                ).to(self.device)
+
+                with torch.no_grad():
+                    outputs = self.sentiment_model(**inputs)
+                    probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+                    prediction = probs.cpu().numpy()[0]
+
+                score = float(prediction[1])
+
+                if score > 0.75:
+                    label = "Pozitif"
+                elif score < 0.25:
+                    label = "Negatif"
+                elif score > 0.55:
+                    label = "Pozitif"
+                elif score < 0.45:
+                    label = "Negatif"
+                else:
+                    label = "Nötr"
+
+                return {"label": label, "score": score}
+
+            except Exception as e:
+                print(f"Error in sentiment prediction: {e}")
+                return {"label": "Nötr", "score": 0.5}
+
+        print("\nSentiment analizi yapılıyor...")
+        results = [predict_sentiment(text) for text in df["Yorum"]]
+
+        df["sentiment_score"] = [r["score"] for r in results]
+        df["sentiment_label"] = [r["label"] for r in results]
+        df["cleaned_text"] = df["Yorum"].apply(self.preprocess_text)
+
+        return df
+
+    def get_key_phrases(self, text_series):
+        """En önemli anahtar kelimeleri bul"""
+        text = " ".join(text_series.astype(str))
+        words = self.preprocess_text(text).split()
+        word_freq = Counter(words)
+        # En az 3 kez geçen kelimeleri al
+        return {
+            word: count
+            for word, count in word_freq.items()
+            if count >= 3 and len(word) > 2
+        }
+
+    def generate_summary(self, df):
+        """Yorumların genel özetini oluştur"""
+        # En önemli yorumları seç
+        high_rated = df[df["Yıldız Sayısı"] >= 4]
+        low_rated = df[df["Yıldız Sayısı"] <= 2]
+
+        # Önemli kelimeleri bul
+        positive_phrases = self.get_key_phrases(high_rated["cleaned_text"])
+        negative_phrases = self.get_key_phrases(low_rated["cleaned_text"])
+
+        # En anlamlı yorumları seç
+        top_positive = (
+            high_rated.sort_values("sentiment_score", ascending=False)["Yorum"]
+            .head(3)
+            .tolist()
+        )
+        top_negative = (
+            low_rated.sort_values("sentiment_score")["Yorum"].head(2).tolist()
+        )
+
+        # En sık kullanılan kelimeler
+        pos_features = ", ".join(
+            [f"{word} ({count})" for word, count in list(positive_phrases.items())[:5]]
+        )
+        neg_features = ", ".join(
+            [f"{word} ({count})" for word, count in list(negative_phrases.items())[:5]]
+        )
+
+        summary_prompt = f"""
+        MacBook Air Kullanıcı Yorumları Analizi:
+
+        İSTATİSTİKLER:
+        - Toplam Yorum: {len(df)}
+        - Ortalama Puan: {df['Yıldız Sayısı'].mean():.1f}/5
+        - Pozitif Yorum Oranı: {(len(df[df['sentiment_label'] == 'Pozitif']) / len(df) * 100):.1f}%
+
+        SIKÇA KULLANILAN KELİMELER:
+        Olumlu: {pos_features}
+        Olumsuz: {neg_features}
+
+        ÖRNEK OLUMLU YORUMLAR:
+        {' '.join([f"• {yorum[:200]}..." for yorum in top_positive])}
+
+        ÖRNEK OLUMSUZ YORUMLAR:
+        {' '.join([f"• {yorum[:200]}..." for yorum in top_negative])}
+
+        Lütfen bu veriler ışığında bu ürün için kısa ve öz bir değerlendirme yap.
+        Özellikle kullanıcıların en çok beğendiği özellikler ve en sık dile getirilen sorunlara odaklan.
+        Değerlendirmeyi 3 paragrafla sınırla ve somut örnekler kullan.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "Sen bir ürün yorumları analiz uzmanısın. Yorumları özetlerken nesnel ve açık ol.",
+            },
+            {"role": "user", "content": summary_prompt},
+        ]
+
+        outputs = self.summary_pipe(
+            messages,
+            max_new_tokens=512,
+            eos_token_id=self.terminators,
+            return_full_text=False,
+            **self.sampling_params,
+        )
+
+        return outputs[0]["generated_text"]
+
+
+def analyze_reviews(file_path):
+    df = pd.read_csv(file_path)
+
+    analyzer = ReviewAnalyzer()
+
+    filtered_df = analyzer.filter_reviews(df)
+
+    print("Sentiment analizi başlatılıyor...")
+    analyzed_df = analyzer.analyze_sentiment(filtered_df)
+
+    analyzed_df.to_csv(
+        "sentiment_analyzed_reviews.csv", index=False, encoding="utf-8-sig"
+    )
+    print("Sentiment analizi tamamlandı ve kaydedildi.")
+
+    print("\nÜrün özeti oluşturuluyor...")
+    summary = analyzer.generate_summary(analyzed_df)
+
+    with open("urun_ozeti.txt", "w", encoding="utf-8") as f:
+        f.write(summary)
+
+    print("\nÜrün Özeti:")
+    print("-" * 50)
+    print(summary)
+    print("\nÖzet 'urun_ozeti.txt' dosyasına kaydedildi.")
+
+
+if __name__ == "__main__":
+    analyze_reviews("data/macbook_product_comments_with_ratings.csv")

scripts/sentiment_bert_model.py

@@ -1,166 +1,203 @@
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch
-import os
-import warnings
-warnings.filterwarnings('ignore')
-
-class TurkishSentimentAnalyzer:
-    def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"Using device: {self.device}")
-        
-        # sentiment model
-        model_name = "savasy/bert-base-turkish-sentiment-cased"
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.model = AutoModelForSequenceClassification.from_pretrained(model_name).to(self.device)
-        
-        # Lojistik ve satıcı kelimeleri
-        self.logistics_seller_words = {
-            'kargo', 'kargocu', 'paket', 'paketleme', 'teslimat', 'teslim', 
-            'gönderi', 'gönderim', 'ulaştı', 'ulaşım', 'geldi', 'kurye',
-            'satıcı', 'mağaza', 'sipariş', 'trendyol', 'tedarik', 'stok',
-            'fiyat', 'ücret', 'para', 'bedava', 'indirim', 'kampanya',
-            'havale', 'ödeme', 'garanti', 'fatura'
-        }
-
-    def predict_sentiment(self, text):
-        """Tek bir metin için sentiment tahmini yap"""
-        if not isinstance(text, str) or len(text.strip()) == 0:
-            return {"label": "Nötr", "score": 0.5}
-        
-        try:
-            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, 
-                                  max_length=512, padding=True).to(self.device)
-            
-            with torch.no_grad():
-                outputs = self.model(**inputs)
-                probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-                prediction = probs.cpu().numpy()[0]
-
-            # İki sınıflı model için (positive/negative)
-            score = float(prediction[1])  # Pozitif sınıfın olasılığı
-            
-            # Daha hassas skor eşikleri
-            if score > 0.75:  # Yüksek güvenle pozitif
-                label = "Pozitif"
-            elif score < 0.25:  # Yüksek güvenle negatif
-                label = "Negatif"
-            elif score > 0.55:  # Hafif pozitif eğilim
-                label = "Pozitif"
-            elif score < 0.45:  # Hafif negatif eğilim
-                label = "Negatif"
-            else:
-                label = "Nötr"
-                
-            return {"label": label, "score": score}
-            
-        except Exception as e:
-            print(f"Error in sentiment prediction: {e}")
-            return {"label": "Nötr", "score": 0.5}
-
-    def filter_product_reviews(self, df):
-        """Ürün ile ilgili olmayan yorumları filtrele"""
-        def is_product_review(text):
-            if not isinstance(text, str):
-                return False
-            return not any(word in text.lower() for word in self.logistics_seller_words)
-
-        filtered_df = df[df['Yorum'].apply(is_product_review)].copy()
-        
-        print(f"\nFiltreleme İstatistikleri:")
-        print(f"Toplam yorum sayısı: {len(df)}")
-        print(f"Ürün yorumu sayısı: {len(filtered_df)}")
-        print(f"Filtrelenen yorum sayısı: {len(df) - len(filtered_df)}")
-        print(f"Filtreleme oranı: {((len(df) - len(filtered_df)) / len(df) * 100):.2f}%")
-        
-        return filtered_df
-
-    def analyze_reviews(self, df):
-        """Tüm yorumları analiz et"""
-        print("\nSentiment analizi başlatılıyor...")
-        
-        filtered_df = self.filter_product_reviews(df)
-        
-        # Sentiment analizi
-        results = []
-        for text in filtered_df['Yorum']:
-            sentiment = self.predict_sentiment(text)
-            results.append(sentiment)
-        
-        filtered_df['sentiment_score'] = [r['score'] for r in results]
-        filtered_df['sentiment_label'] = [r['label'] for r in results]
-        
-        return filtered_df
-
-    def create_visualizations(self, df):
-        """Analiz sonuçlarını görselleştir"""
-        if not os.path.exists('images'):
-            os.makedirs('images')
-        
-        # 1. Sentiment Dağılımı
-        plt.figure(figsize=(12, 6))
-        sns.countplot(data=df, x='sentiment_label', 
-                     order=['Pozitif', 'Nötr', 'Negatif'])
-        plt.title('Sentiment Dağılımı')
-        plt.tight_layout()
-        plt.savefig('images/sentiment_distribution.png', bbox_inches='tight', dpi=300)
-        plt.close()
-
-        # 2. Yıldız-Sentiment İlişkisi
-        plt.figure(figsize=(12, 6))
-        df_mean = df.groupby('Yıldız Sayısı')['sentiment_score'].mean().reset_index()
-        sns.barplot(data=df_mean, x='Yıldız Sayısı', y='sentiment_score')
-        plt.title('Yıldız Sayısına Göre Ortalama Sentiment Skoru')
-        plt.tight_layout()
-        plt.savefig('images/star_sentiment_relation.png', bbox_inches='tight', dpi=300)
-        plt.close()
-
-        # 3. Sentiment Score Dağılımı
-        plt.figure(figsize=(12, 6))
-        sns.histplot(data=df, x='sentiment_score', bins=30)
-        plt.title('Sentiment Score Dağılımı')
-        plt.tight_layout()
-        plt.savefig('images/sentiment_score_distribution.png', bbox_inches='tight', dpi=300)
-        plt.close()
-
-    def print_statistics(self, df):
-        """Analiz istatistiklerini yazdır"""
-        print("\nSentiment Analizi Sonuçları:")
-        print("-" * 50)
-        
-        sentiment_counts = df['sentiment_label'].value_counts()
-        total_reviews = len(df)
-        
-        for label, count in sentiment_counts.items():
-            percentage = (count / total_reviews) * 100
-            print(f"{label}: {count} yorum ({percentage:.2f}%)")
-        
-        print("\nYıldız Bazlı Sentiment Skorları:")
-        print("-" * 50)
-        star_means = df.groupby('Yıldız Sayısı')['sentiment_score'].mean()
-        for star, score in star_means.items():
-            print(f"{star} Yıldız ortalama sentiment skoru: {score:.3f}")
-
-def main():
-    df = pd.read_csv('data/macbook_product_comments_with_ratings.csv')
-    
-    analyzer = TurkishSentimentAnalyzer()
-    
-    print("Analiz başlatılıyor...")
-    analyzed_df = analyzer.analyze_reviews(df)
-    
-    print("\nGörselleştirmeler oluşturuluyor...")
-    analyzer.create_visualizations(analyzed_df)
-    
-    analyzer.print_statistics(analyzed_df)
-    
-    output_file = 'sentiment_analyzed_reviews.csv'
-    analyzed_df.to_csv(output_file, index=False, encoding='utf-8-sig')
-    print(f"\nSonuçlar '{output_file}' dosyasına kaydedildi.")
-
-if __name__ == "__main__":
-    main()
+import os
+import warnings
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+warnings.filterwarnings("ignore")
+
+
+class TurkishSentimentAnalyzer:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        # sentiment model
+        model_name = "savasy/bert-base-turkish-sentiment-cased"
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(model_name).to(
+            self.device
+        )
+
+        # Lojistik ve satıcı kelimeleri
+        self.logistics_seller_words = {
+            "kargo",
+            "kargocu",
+            "paket",
+            "paketleme",
+            "teslimat",
+            "teslim",
+            "gönderi",
+            "gönderim",
+            "ulaştı",
+            "ulaşım",
+            "geldi",
+            "kurye",
+            "satıcı",
+            "mağaza",
+            "sipariş",
+            "trendyol",
+            "tedarik",
+            "stok",
+            "fiyat",
+            "ücret",
+            "para",
+            "bedava",
+            "indirim",
+            "kampanya",
+            "havale",
+            "ödeme",
+            "garanti",
+            "fatura",
+        }
+
+    def predict_sentiment(self, text):
+        """Tek bir metin için sentiment tahmini yap"""
+        if not isinstance(text, str) or len(text.strip()) == 0:
+            return {"label": "Nötr", "score": 0.5}
+
+        try:
+            inputs = self.tokenizer(
+                text, return_tensors="pt", truncation=True, max_length=512, padding=True
+            ).to(self.device)
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+                prediction = probs.cpu().numpy()[0]
+
+            # İki sınıflı model için (positive/negative)
+            score = float(prediction[1])  # Pozitif sınıfın olasılığı
+
+            # Daha hassas skor eşikleri
+            if score > 0.75:  # Yüksek güvenle pozitif
+                label = "Pozitif"
+            elif score < 0.25:  # Yüksek güvenle negatif
+                label = "Negatif"
+            elif score > 0.55:  # Hafif pozitif eğilim
+                label = "Pozitif"
+            elif score < 0.45:  # Hafif negatif eğilim
+                label = "Negatif"
+            else:
+                label = "Nötr"
+
+            return {"label": label, "score": score}
+
+        except Exception as e:
+            print(f"Error in sentiment prediction: {e}")
+            return {"label": "Nötr", "score": 0.5}
+
+    def filter_product_reviews(self, df):
+        """Ürün ile ilgili olmayan yorumları filtrele"""
+
+        def is_product_review(text):
+            if not isinstance(text, str):
+                return False
+            return not any(word in text.lower() for word in self.logistics_seller_words)
+
+        filtered_df = df[df["Yorum"].apply(is_product_review)].copy()
+
+        print(f"\nFiltreleme İstatistikleri:")
+        print(f"Toplam yorum sayısı: {len(df)}")
+        print(f"Ürün yorumu sayısı: {len(filtered_df)}")
+        print(f"Filtrelenen yorum sayısı: {len(df) - len(filtered_df)}")
+        print(
+            f"Filtreleme oranı: {((len(df) - len(filtered_df)) / len(df) * 100):.2f}%"
+        )
+
+        return filtered_df
+
+    def analyze_reviews(self, df):
+        """Tüm yorumları analiz et"""
+        print("\nSentiment analizi başlatılıyor...")
+
+        filtered_df = self.filter_product_reviews(df)
+
+        # Sentiment analizi
+        results = []
+        for text in filtered_df["Yorum"]:
+            sentiment = self.predict_sentiment(text)
+            results.append(sentiment)
+
+        filtered_df["sentiment_score"] = [r["score"] for r in results]
+        filtered_df["sentiment_label"] = [r["label"] for r in results]
+
+        return filtered_df
+
+    def create_visualizations(self, df):
+        """Analiz sonuçlarını görselleştir"""
+        if not os.path.exists("images"):
+            os.makedirs("images")
+
+        # 1. Sentiment Dağılımı
+        plt.figure(figsize=(12, 6))
+        sns.countplot(
+            data=df, x="sentiment_label", order=["Pozitif", "Nötr", "Negatif"]
+        )
+        plt.title("Sentiment Dağılımı")
+        plt.tight_layout()
+        plt.savefig("images/sentiment_distribution.png", bbox_inches="tight", dpi=300)
+        plt.close()
+
+        # 2. Yıldız-Sentiment İlişkisi
+        plt.figure(figsize=(12, 6))
+        df_mean = df.groupby("Yıldız Sayısı")["sentiment_score"].mean().reset_index()
+        sns.barplot(data=df_mean, x="Yıldız Sayısı", y="sentiment_score")
+        plt.title("Yıldız Sayısına Göre Ortalama Sentiment Skoru")
+        plt.tight_layout()
+        plt.savefig("images/star_sentiment_relation.png", bbox_inches="tight", dpi=300)
+        plt.close()
+
+        # 3. Sentiment Score Dağılımı
+        plt.figure(figsize=(12, 6))
+        sns.histplot(data=df, x="sentiment_score", bins=30)
+        plt.title("Sentiment Score Dağılımı")
+        plt.tight_layout()
+        plt.savefig(
+            "images/sentiment_score_distribution.png", bbox_inches="tight", dpi=300
+        )
+        plt.close()
+
+    def print_statistics(self, df):
+        """Analiz istatistiklerini yazdır"""
+        print("\nSentiment Analizi Sonuçları:")
+        print("-" * 50)
+
+        sentiment_counts = df["sentiment_label"].value_counts()
+        total_reviews = len(df)
+
+        for label, count in sentiment_counts.items():
+            percentage = (count / total_reviews) * 100
+            print(f"{label}: {count} yorum ({percentage:.2f}%)")
+
+        print("\nYıldız Bazlı Sentiment Skorları:")
+        print("-" * 50)
+        star_means = df.groupby("Yıldız Sayısı")["sentiment_score"].mean()
+        for star, score in star_means.items():
+            print(f"{star} Yıldız ortalama sentiment skoru: {score:.3f}")
+
+
+def main():
+    df = pd.read_csv("data/macbook_product_comments_with_ratings.csv")
+
+    analyzer = TurkishSentimentAnalyzer()
+
+    print("Analiz başlatılıyor...")
+    analyzed_df = analyzer.analyze_reviews(df)
+
+    print("\nGörselleştirmeler oluşturuluyor...")
+    analyzer.create_visualizations(analyzed_df)
+
+    analyzer.print_statistics(analyzed_df)
+
+    output_file = "sentiment_analyzed_reviews.csv"
+    analyzed_df.to_csv(output_file, index=False, encoding="utf-8-sig")
+    print(f"\nSonuçlar '{output_file}' dosyasına kaydedildi.")
+
+
+if __name__ == "__main__":
+    main()