added app.py

app.py

@@ -0,0 +1,293 @@
+import gradio as gr
+import pandas as pd
+from nltk.sentiment import SentimentIntensityAnalyzer
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+import requests
+import re
+import sentence_transformers
+from sentence_transformers import SentenceTransformer
+from sklearn.feature_extraction.text import TfidfVectorizer
+import matplotlib.pyplot as plt
+import seaborn as sns
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk import pos_tag, ne_chunk
+from nltk.tree import Tree
+from googleapiclient.discovery import build
+import emoji
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+from google.colab import drive
+
+
+
+nltk.download('vader_lexicon')
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+nltk.download('maxent_ne_chunker')
+nltk.download('words')
+
+
+# Mount Google Drive
+drive.mount('/content/drive')
+
+# Initialize the SentimentIntensityAnalyzer
+sia = SentimentIntensityAnalyzer()
+
+# Load the Sarcasm Detection model
+sarcasm_tokenizer = AutoTokenizer.from_pretrained("jkhan447/sarcasm-detection-Bert-base-uncased")
+sarcasm_model = AutoModelForSequenceClassification.from_pretrained("jkhan447/sarcasm-detection-Bert-base-uncased")
+
+# Move model to GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+sarcasm_model.to(device)
+
+# Load SentenceTransformer model
+sentence_transformer_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+api_key = "AIzaSyDOw_v-T58ATLOmQjF00k5Mjha6VPQ-TAk"
+
+def extract_video_id(url):
+    match = re.search(r"v=([a-zA-Z0-9_-]{11})", url)
+    return match.group(1) if match else None
+
+def get_video_details(video_id):
+    url = f"https://www.googleapis.com/youtube/v3/videos?part=snippet&id={video_id}&key={api_key}"
+    response = requests.get(url).json()
+    if response["items"]:
+        snippet = response["items"][0]["snippet"]
+        return snippet["title"], snippet["categoryId"]
+    return None, None
+
+def get_comments(video_id):
+    comments = []
+    url = f"https://www.googleapis.com/youtube/v3/commentThreads?part=snippet&videoId={video_id}&key={api_key}&maxResults=100&order=relevance"
+    response = requests.get(url).json()
+    for item in response["items"]:
+        comment = item["snippet"]["topLevelComment"]["snippet"]["textOriginal"]
+        comments.append(comment)
+    return comments
+
+def sentiment_scores(comment_text):
+    sentiment_dict = sia.polarity_scores(comment_text)
+    return sentiment_dict['compound']
+
+def detect_sarcasm_batch(comments):
+    inputs = sarcasm_tokenizer(comments, return_tensors="pt", truncation=True, padding=True).to(device)
+    with torch.no_grad():
+        outputs = sarcasm_model(**inputs)
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    sarcasm_scores = probs[:, 1].tolist()
+    return sarcasm_scores
+
+def get_sentiment_label(row):
+    polarity = row['polarity']
+    sarcasm_score = row['sarcasm_score']
+    category = row['category']
+
+    if sarcasm_score > 0.5:
+        return "Sarcastic"
+
+    if category == "Comedy":
+        if polarity > 0.05:
+            return "Funny/Enjoyable"
+        elif polarity < -0.05:
+            return "Unfunny/Criticism"
+        else:
+            return "Neutral"
+
+    elif category == "Education":
+        if polarity > 0.05:
+            return "Helpful/Informative"
+        elif polarity < -0.05:
+            return "Confusing/Criticism"
+        else:
+            return "Neutral"
+
+    elif category == "Music":
+        if polarity > 0.05:
+            return "Enjoyed"
+        elif polarity < -0.05:
+            return "Criticism/Disliked"
+        else:
+            return "Neutral"
+
+    elif category == "Entertainment":
+        if polarity > 0.05:
+            return "Entertained"
+        elif polarity < -0.05:
+            return "Bored/Criticism"
+        else:
+            return "Neutral"
+
+    else:
+        if polarity > 0.05:
+            return "Positive"
+        elif polarity < -0.05:
+            return "Negative"
+        else:
+            return "Neutral"
+
+def extract_keywords(comments_for_video_df):
+    comment_embeddings = sentence_transformer_model.encode(comments_for_video_df['comment_text'].tolist())
+    tfidf = TfidfVectorizer(stop_words='english', max_features=20)
+    tfidf.fit(comments_for_video_df['comment_text'])
+    keywords = tfidf.get_feature_names_out()
+    keyword_importance = tfidf.idf_
+    keyword_importance_df = pd.DataFrame({'keyword': keywords, 'importance': keyword_importance})
+
+    plt.figure(figsize=(10, 6))
+    sns.barplot(y='keyword', x='importance', data=keyword_importance_df, palette='pastel')
+    plt.title('Top Keywords in Comments')
+    plt.xlabel('TF-IDF Importance')
+    plt.ylabel('Keyword')
+    plt.tight_layout()
+
+    return plt.gcf()
+
+def analyze_video_sentiment(video_url):
+    video_id = extract_video_id(video_url)
+    if video_id:
+        video_title, category_id = get_video_details(video_id)
+        
+        categories = {
+            "1": "Film & Animation", "2": "Autos & Vehicles", "10": "Music", "15": "Pets & Animals",
+            "17": "Sports", "18": "Short Movies", "19": "Travel & Events", "20": "Gaming",
+            "21": "Videoblogging", "22": "People & Blogs", "23": "Comedy", "24": "Entertainment",
+            "25": "News & Politics", "26": "Howto & Style", "27": "Education", "28": "Science & Technology",
+            "29": "Nonprofits & Activism", "30": "Movies", "31": "Anime/Animation", "32": "Action/Adventure",
+            "33": "Classics", "34": "Comedy", "35": "Documentary", "36": "Drama", "37": "Family",
+            "38": "Foreign", "39": "Horror", "40": "Sci-Fi/Fantasy", "41": "Thriller", "42": "Shorts",
+            "43": "Shows", "44": "Trailers"
+        }
+        category = categories.get(category_id, "Unknown Category")
+        
+        comments = get_comments(video_id)
+        if comments:
+            comments_for_video_df = pd.DataFrame(comments, columns=["comment_text"])
+            comments_for_video_df['polarity'] = comments_for_video_df['comment_text'].apply(sentiment_scores)
+            
+            batch_size = 32
+            sarcasm_scores = []
+            for i in range(0, len(comments_for_video_df), batch_size):
+                batch_comments = comments_for_video_df['comment_text'][i:i+batch_size].tolist()
+                batch_scores = detect_sarcasm_batch(batch_comments)
+                sarcasm_scores.extend(batch_scores)
+
+            comments_for_video_df['sarcasm_score'] = sarcasm_scores
+            comments_for_video_df['category'] = category  # Assign the correct category to each comment
+            
+            comments_for_video_df['Prominent sentiment'] = comments_for_video_df.apply(get_sentiment_label, axis=1)
+            
+            keyword_plot = extract_keywords(comments_for_video_df)
+            
+            # Analyze all comments but display only the top 10 comments based on relevance
+            top_10_comments = comments_for_video_df[['comment_text', 'Prominent sentiment']].head(10)
+            
+            return comments_for_video_df, top_10_comments, video_title, category, keyword_plot
+        else:
+            return pd.DataFrame({"Error": ["No comments found."]}), None, None, None, None
+    else:
+        return pd.DataFrame({"Error": ["Invalid YouTube URL."]}), None, None, None, None
+
+def plot_sentiment_distribution(df):
+    if 'Prominent sentiment' in df.columns:
+        sentiment_counts = df['Prominent sentiment'].value_counts().reset_index()
+        sentiment_counts.columns = ['Sentiment', 'Comment Count']
+
+        plt.figure(figsize=(10, 6))
+        sns.barplot(x='Sentiment', y='Comment Count', hue='Sentiment', data=sentiment_counts, palette="pastel", legend=False)
+        plt.title('Number of Comments by Sentiment', fontsize=14)
+        plt.xlabel('Sentiment', fontsize=12)
+        plt.ylabel('Number of Comments', fontsize=12)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+
+        return plt.gcf()
+    else:
+        return None
+
+def plot_sarcasm_vs_polarity(df):
+    if 'polarity' in df.columns and 'sarcasm_score' in df.columns:
+        plt.figure(figsize=(10, 6))
+        sns.scatterplot(x='polarity', y='sarcasm_score', hue='Prominent sentiment', data=df, palette="pastel")
+        plt.title('Polarity vs. Sarcasm Score', fontsize=14)
+        plt.xlabel('Polarity Score', fontsize=12)
+        plt.ylabel('Sarcasm Score', fontsize=12)
+        plt.tight_layout()
+
+        return plt.gcf()
+    else:
+        return None
+
+def gradio_interface(video_url):
+    full_df, df, video_title, category, keyword_plot = analyze_video_sentiment(video_url)
+    
+    if category:
+        sentiment_plot = plot_sentiment_distribution(full_df)
+        sarcasm_plot = plot_sarcasm_vs_polarity(full_df)
+        
+        insights = f"**Title:** {video_title}\n\n**Category:** {category}"
+        
+        return df, sentiment_plot, sarcasm_plot, keyword_plot, insights, insights
+    else:
+        return df, None, None, None, "No insights available.", None
+
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:  # Dark theme applied
+    gr.Markdown(
+        """
+        # 🎥 YouTube Sentiment Analysis 
+        Enter a YouTube video URL below to analyze the comments for sentiment and sarcasm
+        """
+    )
+    with gr.Row():
+        video_input = gr.Textbox(label="YouTube Video URL", placeholder="Enter a YouTube video URL here...")
+        analyze_button = gr.Button("Analyze", variant="primary", elem_id="analyze-btn")
+    
+    video_details = gr.Markdown(label="Video Details", elem_id="video-details-box")
+    
+    with gr.Accordion("Top 10 Comments", open=False):
+        comment_text = gr.Dataframe(label="Top 10 Comments", interactive=False)
+    
+    sentiment_graph = gr.Plot(label="Sentiment Distribution")
+    sarcasm_graph = gr.Plot(label="Sarcasm vs Polarity")
+    keyword_graph = gr.Plot(label="Top Keywords")
+    insights_box = gr.Markdown(label="Insights", elem_id="insights-box")
+    
+    analyze_button.click(gradio_interface, 
+                         inputs=video_input, 
+                         outputs=[comment_text, sentiment_graph, sarcasm_graph, keyword_graph, insights_box, video_details])
+    
+    # Custom CSS for improved styling
+    gr.HTML(
+        """
+        <style>
+        #analyze-btn {
+            background-color: #4CAF50; /* Green */
+            color: white;
+            border: none;
+            padding: 10px 24px;
+            text-align: center;
+            text-decoration: none;
+            display: inline-block;
+            font-size: 16px;
+            border-radius: 8px;
+            cursor: pointer;
+        }
+        #insights-box {
+            color: #FFD700;
+            font-weight: bold;
+        }
+        #video-details-box {
+            color: #1E90FF;
+            font-weight: bold;
+        }
+        body {
+            background-color: #1f1f1f;
+            color: #e0e0e0;
+        }
+        </style>
+        """
+    )
+
+demo.launch(debug=True)