Create a YouTube comment analyzer

To create a YouTube comment analyzer, the goal is to process and analyze comments to extract insights such as sentiment, engagement metrics, keyword frequency, and other relevant data. Below is a basic approach to building such an analyzer using Python and popular libraries like pandas, nltk, TextBlob, and google-api-python-client. This is a simple implementation but can be expanded to handle more advanced analysis.

Steps to create a YouTube Comment Analyzer:

1. Set up YouTube Data API

   • First, you need to enable the YouTube Data API v3 on the Google Cloud Console and get an API key.

   • Install the required libraries:

     bash
     CopyEdit
     pip install google-api-python-client nltk textblob pandas
     

2. Fetching YouTube Comments
   The google-api-python-client library allows you to interact with the YouTube API and fetch the comments from a specific video.

   python
   CopyEdit
   from googleapiclient.discovery import build
   import pandas as pd
   
   api_key = 'YOUR_YOUTUBE_API_KEY'  # Replace with your API key
   youtube = build('youtube', 'v3', developerKey=api_key)
   
   def get_comments(video_id):
       comments = []
       response = youtube.commentThreads().list(
           part='snippet',
           videoId=video_id,
           textFormat='plainText',
           maxResults=100  # You can adjust this number to fetch more comments
       ).execute()
   
       while response:
           for item in response['items']:
               comment = item['snippet']['topLevelComment']['snippet']['textDisplay']
               comments.append(comment)
   
           if 'nextPageToken' in response:
               response = youtube.commentThreads().list(
                   part='snippet',
                   videoId=video_id,
                   textFormat='plainText',
                   pageToken=response['nextPageToken'],
                   maxResults=100
               ).execute()
           else:
               break
   
       return comments
   
   video_id = 'VIDEO_ID'  # Replace with your video ID
   comments = get_comments(video_id)
   

3. Sentiment Analysis
   Using the TextBlob library, you can perform sentiment analysis to determine the mood of the comments (positive, negative, or neutral).

   python
   CopyEdit
   from textblob import TextBlob
   
   def analyze_sentiment(comments):
       sentiment_scores = {'positive': 0, 'neutral': 0, 'negative': 0}
   
       for comment in comments:
           blob = TextBlob(comment)
           sentiment = blob.sentiment.polarity
           if sentiment > 0:
               sentiment_scores['positive'] += 1
           elif sentiment == 0:
               sentiment_scores['neutral'] += 1
           else:
               sentiment_scores['negative'] += 1
   
       return sentiment_scores
   
   sentiment_scores = analyze_sentiment(comments)
   print(sentiment_scores)
   

4. Keyword Frequency
   To analyze which keywords are most common in the comments, you can use nltk for tokenization and stopword removal.

   python
   CopyEdit
   import nltk
   from nltk.corpus import stopwords
   from collections import Counter
   
   nltk.download('punkt')
   nltk.download('stopwords')
   
   def get_keywords(comments):
       stop_words = set(stopwords.words('english'))
       words = []
   
       for comment in comments:
           tokens = nltk.word_tokenize(comment)
           for token in tokens:
               if token.lower() not in stop_words and token.isalpha():
                   words.append(token.lower())
   
       return Counter(words).most_common(10)  # Top 10 keywords
   
   keywords = get_keywords(comments)
   print(keywords)
   

5. Engagement Metrics
   You can also retrieve engagement metrics like the number of likes and replies to each comment.

   python
   CopyEdit
   def get_engagement_metrics(video_id):
       response = youtube.commentThreads().list(
           part='snippet',
           videoId=video_id,
           textFormat='plainText',
           maxResults=100
       ).execute()
   
       engagement = []
   
       while response:
           for item in response['items']:
               comment = item['snippet']['topLevelComment']['snippet']
               likes = comment['likeCount']
               replies = item['snippet']['totalReplyCount']
               engagement.append({'comment': comment['textDisplay'], 'likes': likes, 'replies': replies})
   
           if 'nextPageToken' in response:
               response = youtube.commentThreads().list(
                   part='snippet',
                   videoId=video_id,
                   textFormat='plainText',
                   pageToken=response['nextPageToken'],
                   maxResults=100
               ).execute()
           else:
               break
   
       return engagement
   
   engagement = get_engagement_metrics(video_id)
   df_engagement = pd.DataFrame(engagement)
   print(df_engagement)
   

Final Output

After running these functions, you’ll have:

1. Sentiment distribution (positive, neutral, and negative comments count).

2. Top keywords mentioned in the comments.

3. Engagement metrics such as likes and replies for each comment.

Example Output:

python
CopyEdit
{
    'positive': 75,
    'neutral': 10,
    'negative': 15
}

[('amazing', 50), ('great', 30), ('love', 25), ('video', 20)]

   comment                                          likes  replies
0  This video is amazing!                         50     5
1  Loved the content!                             35     2
2  Not a fan of the intro.                        5     0

Enhancements:

• Advanced Sentiment Analysis: You can use libraries like VADER or fine-tune models with Transformers for more accurate sentiment analysis.

• Visualization: Use matplotlib or seaborn to visualize the sentiment distribution and keyword frequencies.

• Dashboard: You can set up a simple dashboard using Dash or Streamlit to display the insights interactively.

Let me know if you’d like a more detailed breakdown or help on any specific part!