fix 1652

app.py

@@ -1,331 +1,108 @@
-import gradio as gr
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-import os
-import shutil
-from scrape.trendyol_scraper import scrape_reviews
-import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
-import re
-from tqdm import tqdm
-import nltk
-from nltk.corpus import stopwords
-from dotenv import load_dotenv
-import google.generativeai as genai
-from pathlib import Path
-
-class ReviewAnalysisApp:
-    def __init__(self):
-        self.setup_models()
-        self.setup_stopwords()
-        self.setup_gemini()
-        
-    def setup_stopwords(self):
-        """Türkçe stopwords'leri yükle"""
-        try:
-            nltk.data.find('corpora/stopwords')
-        except LookupError:
-            nltk.download('stopwords')
-        
-        self.turkish_stopwords = set(stopwords.words('turkish'))
-        # Ekstra stopwords ekle
-        self.logistics_seller_words = {
-            'kargo', 'kargocu', 'paket', 'gönderi', 'satıcı', 'mağaza', 
-            'sipariş', 'teslimat', 'gönderim', 'kutu', 'paketleme'
-        }
-        self.turkish_stopwords.update(self.logistics_seller_words)
-        
-    def setup_models(self):
-        """Modelleri yükle ve hazırla"""
-        # Sadece sentiment model
-        self.device = "cpu"
-        print(f"Cihaz: {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,
-                low_cpu_mem_usage=False
-            )
-            .to(self.device)
-            .to(torch.float32)
-        )
-        
-    def setup_gemini(self):
-        """Gemini API'yi hazırla"""
-        try:
-            # Önce .env dosyasından API key'i al
-            load_dotenv()
-            api_key = os.getenv('GOOGLE_API_KEY')
-            if not api_key:
-                raise ValueError("API key bulunamadı!")
-            
-            # Gemini'yi yapılandır
-            genai.configure(api_key=api_key)
-            
-            # Modeli ayarla
-            self.gemini_model = genai.GenerativeModel('gemini-pro')
-            
-        except Exception as e:
-            print(f"Gemini API yapılandırma hatası: {str(e)}")
-            self.gemini_model = None
-    
-    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 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 predict_sentiment(self, text):
-        """Tek bir yorum için sentiment analizi yap"""
-        # Önce metni temizle
-        text = self.preprocess_text(text)
-        
-        if not text:
-            return {"label": "nötr", "score": 0.5}
-            
-        inputs = self.sentiment_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-        
-        with torch.no_grad():
-            outputs = self.sentiment_model(**inputs)
-            scores = torch.nn.functional.softmax(outputs.logits, dim=1)
-            
-        positive_score = scores[0][1].item()
-        label = "pozitif" if positive_score > 0.5 else "negatif"
-        
-        return {"label": label, "score": positive_score}
-    
-    def analyze_reviews(self, df):
-        """Tüm yorumları analiz et"""
-        print("\nSentiment analizi başlatılıyor...")
-        
-        # Önce ürün ile ilgili olmayan yorumları filtrele
-        df = self.filter_product_reviews(df)
-        
-        # Sentiment analizi
-        results = []
-        for text in tqdm(df['Yorum'], desc="Yorumlar analiz ediliyor"):
-            sentiment = self.predict_sentiment(text)
-            results.append(sentiment)
-        
-        df['sentiment_score'] = [r['score'] for r in results]
-        df['sentiment_label'] = [r['label'] for r in results]
-        
-        return df
-    
-    def generate_summary(self, df):
-        """İstatistiksel özet ve Gemini ile detaylı analiz"""
-        # Temel istatistikler
-        avg_rating = df['Yıldız Sayısı'].mean()
-        total_reviews = len(df)
-        
-        # Sentiment bazlı gruplandırma
-        positive_comments = df[df['sentiment_label'] == 'pozitif']['Yorum'].tolist()
-        negative_comments = df[df['sentiment_label'] == 'negatif']['Yorum'].tolist()
-        positive_count = len(positive_comments)
-        negative_count = len(negative_comments)
-        
-        # Yıldız dağılımı
-        star_dist = df['Yıldız Sayısı'].value_counts().sort_index()
-        star_dist_text = "\n".join([f"{star} yıldız: {count} yorum" for star, count in star_dist.items()])
-        
-        # En sık kelimeler
-        all_words = []
-        for text in df['Yorum']:
-            cleaned_text = self.preprocess_text(text)
-            if cleaned_text:
-                all_words.extend(cleaned_text.split())
-        
-        from collections import Counter
-        word_freq = Counter(all_words).most_common(10)
-        frequent_words = ", ".join([f"{word} ({count} kez)" for word, count in word_freq])
-        
-        # İstatistiksel özet metni
-        stats_summary = f"""📊 ÜRÜN ANALİZ RAPORU
-
-⭐ Ortalama Puan: {avg_rating:.1f}/5
-📝 Toplam Yorum: {total_reviews}
-✅ Pozitif Yorum: {positive_count}
-❌ Negatif Yorum: {negative_count}
-
-📈 YILDIZ DAĞILIMI:
-{star_dist_text}
-
-🔍 EN SIK KULLANILAN KELİMELER:
-{frequent_words}
-
-💬 ÖRNEK YORUMLAR:
-✅ Pozitif Yorumlar:
-{' | '.join(positive_comments[:3])}
-
-❌ Negatif Yorumlar:
-{' | '.join(negative_comments[:3])}"""
-
-        # Gemini ile detaylı analiz
-        if self.gemini_model:
-            try:
-                prompt = f"""Aşağıdaki ürün yorumları verilerine dayanarak detaylı bir analiz yap:
-
-1. İstatistikler:
-- Toplam {total_reviews} yorum
-- Ortalama puan: {avg_rating:.1f}/5
-- {positive_count} pozitif, {negative_count} negatif yorum
-
-2. Örnek Pozitif Yorumlar:
-{' | '.join(positive_comments[:3])}
-
-3. Örnek Negatif Yorumlar:
-{' | '.join(negative_comments[:3])}
-
-4. En Sık Kullanılan Kelimeler:
-{frequent_words}
-
-Lütfen şu başlıklar altında bir değerlendirme yap:
-1. Ürünün güçlü yönleri
-2. Ürünün zayıf yönleri
-3. Genel kullanıcı memnuniyeti
-4. Potansiyel alıcılar için öneriler
-
-Yanıtını Türkçe olarak ver ve mümkün olduğunca özlü tut."""
-
-                response = self.gemini_model.generate_content(prompt)
-                ai_analysis = response.text
-
-                # İstatistiksel özet ve AI analizini birleştir
-                return f"{stats_summary}\n\n🤖 YAPAY ZEKA ANALİZİ:\n{ai_analysis}"
-            
-            except Exception as e:
-                print(f"Gemini API hatası: {str(e)}")
-                return stats_summary
-        
-        return stats_summary
-        
-    def analyze_url(self, url):
-        try:
-            # Temizlik
-            if os.path.exists("data"):
-                shutil.rmtree("data")
-            
-            # Yorumları çek
-            df = scrape_reviews(url)
-            
-            if df.empty:
-                return "Yorumlar çekilemedi. Lütfen URL'yi kontrol edin.", None, None, None
-            
-            # Sentiment analizi yap
-            analyzed_df = self.analyze_reviews(df)
-            
-            # Özet oluştur
-            summary = self.generate_summary(analyzed_df)
-            
-            # Grafikleri oluştur
-            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:
-            return f"Bir hata oluştu: {str(e)}", None, None, None
-        
-        finally:
-            # Temizlik
-            if os.path.exists("data"):
-                shutil.rmtree("data")
-    
-    def create_sentiment_distribution(self, df):
-        fig = px.pie(df, 
-                    names='sentiment_label', 
-                    title='Duygu Analizi Dağılımı')
-        return fig
-    
-    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
-    
-    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()
-    
-    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]
-        )
-    
-    return interface
-
-if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",  # Dış bağlantılara izin ver
-        share=True,  # Public link oluştur
-        server_port=7860  # Space'in varsayılan portu
-    ) 
+import gradio as gr
+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
+
+# ChromeDriver kurulumu için fonksiyon
+def setup_chrome():
+    # Chrome kurulumu
+    os.system('apt-get update && apt-get install -y wget gnupg')
+    os.system('wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add -')
+    os.system('echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list')
+    os.system('apt-get update && apt-get install -y google-chrome-stable')
+    
+    # ChromeDriver kurulumu
+    chrome_version = subprocess.check_output(['google-chrome', '--version']).decode().strip().split()[2].split('.')[0]
+    os.system(f'wget -q "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_{chrome_version}" -O chrome_version')
+    os.system('wget -q "https://chromedriver.storage.googleapis.com/$(cat chrome_version)/chromedriver_linux64.zip"')
+    os.system('unzip chromedriver_linux64.zip && mv chromedriver /usr/local/bin/ && chmod +x /usr/local/bin/chromedriver')
+
+# Ana uygulama başlamadan önce Chrome kurulumunu yap
+setup_chrome()
+
+class ReviewAnalysisApp:
+    def __init__(self):
+        self.analyzer = ReviewAnalyzer()
+        
+    def analyze_url(self, url):
+        # Yorumları çek
+        df = scrape_reviews(url)
+        
+        # Sentiment analizi yap
+        analyzed_df = self.analyzer.analyze_reviews(df)
+        
+        # Özet oluştur
+        summary = self.analyzer.generate_summary(analyzed_df)
+        
+        # Grafikleri oluştur
+        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
+    
+    def create_sentiment_distribution(self, df):
+        fig = px.pie(df, 
+                    names='sentiment_label', 
+                    title='Duygu Analizi Dağılımı')
+        return fig
+    
+    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
+    
+    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()
+    
+    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]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch() 

requirements.txt

@@ -1,15 +1,14 @@
-pandas
-numpy
-torch
-transformers
-nltk
-plotly
-gradio
-selenium
-webdriver_manager
-tqdm
-regex
-scikit-learn
-accelerate>=0.26.0
-python-dotenv
-google-generativeai
+pandas
+numpy
+torch
+transformers
+nltk
+plotly
+gradio
+selenium
+webdriver-manager
+tqdm
+regex
+scikit-learn
+google-generativeai
+python-dotenv

scrape/trendyol_scraper.py

@@ -3,136 +3,108 @@ from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.chrome.options import Options
 import time
 import pandas as pd
 import os
-import random
+
+def comprehensive_scroll(driver):
+    # Scroll until no more new content is loaded
+    last_height = driver.execute_script("return document.body.scrollHeight")
+    while True:
+        # Scroll to bottom
+        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+        time.sleep(3)  # Wait for potential content loading
+        
+        # Calculate new scroll height
+        new_height = driver.execute_script("return document.body.scrollHeight")
+        
+        # Check if bottom has been reached
+        if new_height == last_height:
+            break
+        
+        last_height = new_height
 
 def scrape_reviews(url):
-    print("Scraping başlatılıyor...")
-    
+    """URL'den yorumları çeken fonksiyon"""
+    # Data directory oluştur
     data_directory = "data"
     if not os.path.exists(data_directory):
         os.makedirs(data_directory)
 
-    def comprehensive_scroll(driver):
-        print("Sayfa kaydırma başlıyor...")
-        last_height = driver.execute_script("return document.body.scrollHeight")
-        scroll_count = 0
-        while True:
-            driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-            time.sleep(3)
-            new_height = driver.execute_script("return document.body.scrollHeight")
-            scroll_count += 1
-            print(f"Scroll {scroll_count}: {new_height}")
-            if new_height == last_height:
-                break
-            last_height = new_height
-        print("Sayfa kaydırma tamamlandı")
-
-    chrome_options = Options()
+    # Chrome options ayarları
+    chrome_options = webdriver.ChromeOptions()
     chrome_options.add_argument('--headless')
+    chrome_options.add_argument('--disable-gpu')
     chrome_options.add_argument('--no-sandbox')
     chrome_options.add_argument('--disable-dev-shm-usage')
-    chrome_options.add_argument('--disable-gpu')
-    chrome_options.add_argument('--lang=tr')
-    chrome_options.add_argument('--disable-notifications')
     chrome_options.add_argument("--window-size=1920,1080")
-    
+
     try:
-        print("Chrome başlatılıyor...")
-        service = Service()
+        # Linux için ChromeDriver ayarı
+        service = Service('chromedriver')  # Linux'ta path belirtmeye gerek yok
         driver = webdriver.Chrome(service=service, options=chrome_options)
         
-        print(f"URL'ye gidiliyor: {url}")
         driver.get(url)
-        time.sleep(5)  # Sayfa yüklenme süresini artırdık
-        
-        # Sayfa kaynağını kontrol et
-        page_source = driver.page_source
-        print(f"Sayfa uzunluğu: {len(page_source)}")
         
-        try:
-            print("Çerez popup'ı aranıyor...")
-            cookie_button = WebDriverWait(driver, 10).until(
-                EC.presence_of_element_located((By.ID, "onetrust-accept-btn-handler"))
-            )
-            cookie_button.click()
-            print("Çerez popup'ı kapatıldı")
-        except Exception as e:
-            print(f"Çerez popup'ı işlemi: {str(e)}")
+        # Çerez popup'ını kabul et
+        WebDriverWait(driver, 10).until(
+            EC.element_to_be_clickable((By.ID, 'onetrust-accept-btn-handler'))
+        ).click()
 
         comprehensive_scroll(driver)
-
-        print("Yorum elementleri aranıyor...")
-        # Önce yorum container'ını bul
-        review_container = driver.find_element(By.CLASS_NAME, "pr-rnr-com-w")
-        print("Yorum container'ı bulundu")
         
-        # Yorum elementlerini bul
-        comment_elements = review_container.find_elements(By.CLASS_NAME, "comment-cards-item")
+        comment_elements = driver.find_elements(By.XPATH, '/html/body/div[1]/div[4]/div/div/div/div/div[3]/div/div/div[3]/div[2]/div')
         total_comments = len(comment_elements)
-        
-        if total_comments == 0:
-            print("Alternatif yorum elementi aranıyor...")
-            comment_elements = driver.find_elements(By.CSS_SELECTOR, "div.comment-cards-item")
-            total_comments = len(comment_elements)
-        
-        print(f"Bulunan yorum sayısı: {total_comments}")
-        
-        if total_comments == 0:
-            print("Hiç yorum bulunamadı!")
-            return pd.DataFrame()
-            
+
         data = []
-        for i, element in enumerate(comment_elements, 1):
+        for i in range(1, total_comments + 1):
+            kullanıcı_id = i
             try:
-                username = element.find_element(By.CLASS_NAME, "user-name").text
+                username_xpath = f'/html/body/div[1]/div[4]/div/div/div/div/div[3]/div/div/div[3]/div[2]/div[{i}]/div[1]/div[2]/div[1]'
+                username = driver.find_element(By.XPATH, username_xpath).text
             except:
                 username = "N/A"
-                print(f"Kullanıcı adı alınamadı: {i}")
 
             try:
-                comment = element.find_element(By.CLASS_NAME, "comment-text").text
+                comment_xpath = f'/html/body/div[1]/div[4]/div/div/div/div/div[3]/div/div/div[3]/div[2]/div[{i}]/div[2]/p'
+                comment = driver.find_element(By.XPATH, comment_xpath).text
             except:
                 comment = "N/A"
-                print(f"Yorum metni alınamadı: {i}")
 
             try:
-                date = element.find_element(By.CLASS_NAME, "comment-date").text
+                date_xpath = f'/html/body/div[1]/div[4]/div/div/div/div/div[3]/div/div/div[3]/div[2]/div[{i}]/div[1]/div[2]/div[2]'
+                date = driver.find_element(By.XPATH, date_xpath).text
             except:
                 date = "N/A"
-                print(f"Tarih alınamadı: {i}")
 
+            star_xpath_base = f'/html/body/div[1]/div[4]/div/div/div/div/div[3]/div/div/div[3]/div[2]/div[{i}]/div[1]/div[1]/div'
             try:
-                stars = len(element.find_elements(By.CSS_SELECTOR, "div.full[style='width: 100%; max-width: 100%;']"))
+                full_stars = driver.find_elements(By.XPATH, f"{star_xpath_base}/div[@class='star-w']/div[@class='full'][@style='width: 100%; max-width: 100%;']")
+                star_count = len(full_stars)
             except:
-                stars = 0
-                print(f"Yıldız sayısı alınamadı: {i}")
+                star_count = 0
 
             data.append({
-                "Kullanıcı_id": i,
+                "Kullanıcı_id": kullanıcı_id,
                 "Kullanıcı Adı": username,
                 "Yorum": comment,
                 "Tarih": date,
-                "Yıldız Sayısı": stars
+                "Yıldız Sayısı": star_count
             })
 
-            if i % 5 == 0:
-                print(f"{i} yorum işlendi")
-
-        print("Veri toplama tamamlandı")
-        return pd.DataFrame(data)
+        # Geçici dosya olarak kaydet
+        temp_file = os.path.join(data_directory, 'temp_comments.csv')
+        df = pd.DataFrame(data)
+        df.to_csv(temp_file, index=False, encoding='utf-8-sig')
+        
+        return df
 
     except Exception as e:
-        print(f"Kritik hata: {str(e)}")
-        if 'driver' in locals():
-            print("Son sayfa kaynağı:")
-            print(driver.page_source[:500])  # İlk 500 karakteri göster
-        return pd.DataFrame()
-
+        print(f"Hata oluştu: {str(e)}")
+        return pd.DataFrame()  # Boş DataFrame döndür
+        
     finally:
-        if 'driver' in locals():
-            driver.quit()
-            print("Chrome kapatıldı")
+        driver.quit()
+        # Geçici dosyayı sil
+        if os.path.exists(os.path.join(data_directory, 'temp_comments.csv')):
+            os.remove(os.path.join(data_directory, 'temp_comments.csv'))

scripts/data_prp_eda.py

@@ -0,0 +1,357 @@
+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()

scripts/review_summarizer.py

@@ -0,0 +1,256 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    pipeline
+)
+import torch
+import os
+import requests
+from collections import Counter
+import warnings
+from nltk.tokenize import word_tokenize
+from nltk.util import ngrams
+import nltk
+from wordcloud import WordCloud
+import re
+import google.generativeai as genai
+from dotenv import load_dotenv
+warnings.filterwarnings('ignore')
+
+nltk.download('stopwords')
+nltk.download('punkt')
+
+class ReviewAnalyzer:
+    def __init__(self):
+        # Load environment variables
+        load_dotenv()
+        
+        # Configure Gemini API
+        genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
+        self.model = genai.GenerativeModel('gemini-pro')
+        
+        # Diğer model kurulumları (sentiment analizi için)
+        self.setup_sentiment_model()
+
+        self.turkish_stopwords = self.get_turkish_stopwords()
+
+        # 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 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"""
+        # Mevcut analiz fonksiyonu aynen kalabilir
+        pass
+
+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

@@ -0,0 +1,166 @@
+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()