# Libraries used
import re                          # pattern matching for cleaning text (apostrophes, etc.)
import pandas as pd                # storing and manipulating the corpus as a dataframe
from collections import Counter    # counting word frequencies
import spacy                       # NLP library used for lemmatization
from wordcloud import WordCloud    # generating word cloud visualizations
import matplotlib.pyplot as plt    # plotting and displaying visualizations
from gensim.parsing.preprocessing import (
    strip_punctuation,             # removes punctuation from tokens
    strip_multiple_whitespaces,    # collapses extra whitespace into one
    remove_stopwords,              # removes common words with no analytical value
    strip_short,                   # removes very short tokens (e.g. single letters)
    preprocess_string              # applies a pipeline of cleaning filters to text
)
from gensim.models.phrases import Phrases, ENGLISH_CONNECTOR_WORDS   # bigram detection
from gensim import models                                             # general gensim modeling utilities
from gensim.corpora.dictionary import Dictionary                      # builds word-to-id mappings for LDA
import gensim                                                         # core gensim library
from gensim.models.ldamodel import LdaModel, CoherenceModel          # LDA model and coherence scoring
from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS        # predefined list of common English stopwords
import nltk                                                            # natural language processing toolkit
from nltk.sentiment.vader import SentimentIntensityAnalyzer           # VADER sentiment analysis
import seaborn as sns                                                  # statistical data visualization
from sklearn.feature_extraction.text import TfidfVectorizer           # converts text to TF-IDF numerical features
from sklearn.svm import SVC                                           # support vector classification model
from sklearn.model_selection import train_test_split                  # splits data into training and testing sets
from sklearn.metrics import accuracy_score                            # calculates model accuracy
from sklearn.metrics import classification_report                     # generates precision, recall, and F1 scores
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay  # generates and displays confusion matrix
import pyLDAvis                                                        # interactive LDA topic visualization
import pyLDAvis.gensim                                                 # gensim compatibility for pyLDAvis
pyLDAvis.enable_notebook()                                            # enables pyLDAvis rendering in Jupyter

# Import the four JSONL files output by the scraper notebook
# Each file represents a different stage of the data collection and filtering pipeline

# All the posts that passed the initial keyword search and prefilter
posts_debate_candidates = pd.read_json(
    "../data/raw/posts_debate_candidates.jsonl",
    lines=True
)

# All threads with stats attached (PvP/PvE mention >=10 and >=5 diff people commented)
threads_with_stats = pd.read_json(
    "../data/raw/threads_with_stats.jsonl",
    lines=True
)

# All comments from threads that passed debate density filter
comments_kept_threads = pd.read_json(
    "../data/raw/comments_keptthreads.jsonl",
    lines=True
)

# All comments that mention PvP/PvE or moral/trait language, plus direct replies for context
df = pd.read_json(
    "../data/raw/comments_debate_slice.jsonl",
    lines=True
)

# Summary print outs
print("Number of candidate threads:", len(posts_debate_candidates))
print("Number of kept threads:", len(threads_with_stats))
print("Total keptthread comments:", len(comments_kept_threads))
print("Final dataset to analyze:", len(df))

Number of candidate threads: 350
Number of kept threads: 293
Total keptthread comments: 5276
Final dataset to analyze: 3027

# Custom stopwords for gaming corpus
# These are words that slipped through gensim's default stopword list
# but don't add meaningful content to this analysis
custom_stopwords = {
    
    # Generic words too broad to be analytically useful
    "game", "just", "really", "people", "players", "player", "think",
    "know", "want", "like", "good", "going", "make", "way", "thing", "things",
    "right", "said", "say", "got", "getting", "actually", "maybe", "pretty",
    "need", "time", "times", "better", "best", "lot", "use", "using", "yeah",
    "play", "playing", "games", "guy", "guys", "bad", "free", "fun", "high",
    "try", "feel", "does", "work", "run", "team", "point", "reason",
    "experience", "enjoy", "having", "doing", "making", "trying", "sure",
    "fine", "long", "big", "day", "little", "different", "real", "probably",
    "simply", "especially", "literally", "instead", "away", "able", "come",
    "let", "stop", "bring", "mean", "kind", "care", "abmm", "arc", "https", "www",
    
    # Contractions stripped of apostrophes (e.g. "don't" becomes "dont" after cleaning)
    "dont", "doesnt", "isnt", "cant", "wont", "didnt", "wouldnt", "shouldnt",
    "wasnt", "werent", "hasnt", "havent", "hadnt", "youre", "theyre", "ive",
    "im", "thats", "its", "itll", "theres", "heres", "whats", "lets"
}

# Strip all apostrophe variants before tokenizing
# Applied multiple times because different apostrophe characters kept slipping through
df["body"] = df["body"].str.replace("'", "", regex=False)
df["body"] = df["body"].str.replace("'", "", regex=False)
df["body"] = df["body"].str.replace("`", "", regex=False)
df["body"] = df["body"].str.replace("'", "", regex=False)

# Standardize British spelling to American spelling for consistency
df["body"] = df["body"].str.replace("behaviour", "behavior", regex=False)

# Remove newline characters so each comment is treated as continuous text
df["body"] = df["body"].str.replace(r"\n", " ", regex=True)

# Lowercase all text for consistent matching
df_body_lower = [text.lower() for text in df["body"]]

# Lemmatize each token to reduce words to their base form
# e.g. "rats" -> "rat", "attempts" -> "attempt"
nlp = spacy.load("en_core_web_sm")

df_body_lemmatized = []
for text in df_body_lower:
    doc = nlp(text)
    lemmas = [token.lemma_ for token in doc]
    df_body_lemmatized.append(lemmas)

# Define the gensim preprocessing pipeline
# Applies punctuation removal, whitespace normalization, stopword removal, and short token removal
CUSTOM_FILTERS = [strip_punctuation, strip_multiple_whitespaces, remove_stopwords, strip_short]

# Apply the preprocessing pipeline to each lemmatized comment
df_tokens = [preprocess_string(" ".join(lemmas), CUSTOM_FILTERS) for lemmas in df_body_lemmatized]

# Save tokens and readable cleaned text as new columns
df["tokens"] = df_tokens
df["text_clean"] = [" ".join(tokens) for tokens in df_tokens]

# Second apostrophe pass applied directly to tokens
# Some unicode apostrophe variants survived the first pass and required token-level removal
df["tokens"] = df["tokens"].apply(
    lambda tokens: [t.replace("\u2019", "").replace("\u2018", "").replace("'", "") for t in tokens]
)

# Remove custom stopwords from token list
df["tokens"] = df["tokens"].apply(
    lambda tokens: [t for t in tokens if t not in custom_stopwords]
)

# Rebuild cleaned text column from final token list
df["text_clean"] = df["tokens"].apply(lambda x: " ".join(x))

example_idx = 31

print("==== BEFORE PREPROCESSING ===")
print(df["body"].iloc[example_idx])

print()

print("=== AFTER PREPROCESSING ===")
print(df["text_clean"].iloc[example_idx])

==== BEFORE PREPROCESSING ===
Yeah, even more evidence of how toxic this place is. No engagement, just cheap attempts to shut you up. Sadly expected.

=== AFTER PREPROCESSING ===
evidence toxic place engagement cheap attempt shut sadly expect

# Train the bigram model on the tokenized corpus
# min_count=5: a pair must appear at least 5 times to be considered a bigram
# threshold=10: minimum score a pair needs to qualify as a bigram
# connector_words: allows common words like "of" or "on" to sit between tokens (e.g. "shoot on sight")
phrases = Phrases(df["tokens"], min_count=5, threshold=10, connector_words=ENGLISH_CONNECTOR_WORDS)

# Apply the trained bigram model to each row's token list
# Joined bigrams appear as a single token with an underscore (e.g. skill_issue)
df["tokens_bigram"] = df["tokens"].apply(lambda tokens: phrases[tokens])

# Extract only the bigram tokens (identified by the underscore) across all rows
bigrams_found = [token for tokens in df["tokens_bigram"] for token in tokens if "_" in token]

print("=== BI-GRAMS FOUND ==")
Counter(bigrams_found).most_common(20)

=== BI-GRAMS FOUND ==

[('extraction_shooter', 171),
 ('friendly_lobby', 140),
 ('pve_mode', 88),
 ('shoot_sight', 51),
 ('skill_issue', 33),
 ('pve_content', 28),
 ('pvpve_extraction', 27),
 ('mixed_lobby', 27),
 ('battle_royale', 22),
 ('blue_gate', 20),
 ('kill_sight', 20),
 ('stella_montis', 20),
 ('lose_gear', 19),
 ('trigger_nade', 18),
 ('aggression_base', 18),
 ('kill_queen', 18),
 ('duos_trio', 17),
 ('queen_matriarch', 17),
 ('pure_pve', 16),
 ('middle_ground', 16)]

# Train the trigram model on the tokenized bigrams
trigram_phrases = Phrases(df["tokens_bigram"], min_count=5, threshold=10, connector_words=ENGLISH_CONNECTOR_WORDS)

# Apply the trained bigram model to each row's token list
# Joined bigrams appear as a single token with an underscore (e.g. skill_issue)
df["tokens_trigram"] = df["tokens_bigram"].apply(lambda tokens: trigram_phrases[tokens])

# Extract only the bigram tokens (identified by the underscore) across all rows
trigrams_found = [token for tokens in df["tokens_trigram"] for token in tokens if token.count("_") >= 2]

print("=== Tri-GRAMS FOUND ==")
Counter(trigrams_found).most_common(20)

=== Tri-GRAMS FOUND ==

[('pvpve_extraction_shooter', 24),
 ('aggression_base_matchmaking', 12),
 ('amp_auto_webp_amp', 10),
 ('youtube_com_watch', 8),
 ('edit_post_address_comment', 7),
 ('shoot_fish_barrel', 6),
 ('solo_duos_trio', 6)]

# Regex pattern to detect any mention of pvp, pve, or pvpve (case insensitive)
pvp_re = re.compile(r"\b(?:pvp|pve|pvpve)\b", re.IGNORECASE)

# List of moral and trait-based keywords used to identify Group A comments
moral_terms = [
    "unfair", "toxic", "ruin", "ruins", "cheat", "cheater",
    "grief", "griefer", "coward", "rat", "sweat", "sweaty",
    "tryhard", "entitled", "deserve", "skill issue", "cheap",
    "cheating", "camping", "rats"
]
# Compile moral terms into a single regex pattern for efficient matching
moral_re = re.compile(r"\b(?:" + "|".join([re.escape(t) for t in moral_terms]) + r")\b", re.IGNORECASE)

# Create boolean masks to flag which comments match each pattern
mask_moral = df["body"].str.contains(moral_re, regex=True, na=False)
mask_pvp = df["body"].str.contains(pvp_re, regex=True, na=False)

# Group A: comments containing at least one moral or trait-based keyword
df_moral = df[mask_moral].copy()

# Group B: comments mentioning pvp/pve but containing no moral keywords
df_debate_only = df[mask_pvp & ~mask_moral].copy()

print("Total debate-slice comments:", len(df))
print("Group A (moral/trait):", len(df_moral))
print("Group B (pvp/pve but no moral keywords):", len(df_debate_only))

Total debate-slice comments: 3027
Group A (moral/trait): 404
Group B (pvp/pve but no moral keywords): 1479

# Regex pattern that matches only alphabetic words of 3 or more characters
# Filters out numbers, symbols, and very short tokens like "a" or "to"
token_pattern = re.compile(r"[a-zA-Z]{3,}")  # words 3+ letters

def tokenize(text):
    tokens = token_pattern.findall(text.lower())
    # Remove sklearn's built-in English stopwords before counting
    return [t for t in tokens if t not in ENGLISH_STOP_WORDS]

# Count tokens in each group
def count_tokens(series):
    counter = Counter()                        # tracks frequency of each unique token
    total_tokens = 0                           # running total of all tokens across all comments
    
    for text in series:                        # iterate through each comment in the group
        tokens = tokenize(text)
        counter.update(tokens)
        total_tokens += len(tokens)
        
    return counter, total_tokens

# Count token frequencies separately for each group
moral_counter, moral_total = count_tokens(df_moral["body"])
debate_counter, debate_total = count_tokens(df_debate_only["body"])

# Print token counts per group and combined total
print("Moral tokens:", moral_total)
print("Debate-only tokens:", debate_total)
print("Total tokens:", moral_total + debate_total)

Moral tokens: 18319
Debate-only tokens: 48274
Total tokens: 66593

# Example of before and after tokenization
example_text = df_moral["body"].iloc[31]

print("=== GROUP A: MORAL/TRAIT BASED LANGUAGE ===")
print()
print("BEFORE:")
print(example_text)
print()
print("AFTER:")
print(tokenize(example_text))
print()

# Example of before and after tokenization
example_text = df_debate_only["body"].iloc[31]

print("------------------------------------")
print()
print("=== GROUP B: DEBATE-ONLY ===")
print()
print("BEFORE:")
print(example_text)
print()
print("AFTER:")
print(tokenize(example_text))

=== GROUP A: MORAL/TRAIT BASED LANGUAGE ===

BEFORE:
When getting shot in the back with your expensive kit is the end result, you either sweep the corners, or you take the loss for what it is.   You certainly don’t complain about the other guy being unfair to you, especially when your bobcat is completely pristine at the **end** of an unfriendly encounter.    In short, you PvE, he PvP, this is a PvPvE game. You got rolled. GG.

AFTER:
['getting', 'shot', 'expensive', 'kit', 'end', 'result', 'sweep', 'corners', 'loss', 'certainly', 'don', 'complain', 'guy', 'unfair', 'especially', 'bobcat', 'completely', 'pristine', 'end', 'unfriendly', 'encounter', 'short', 'pve', 'pvp', 'pvpve', 'game', 'got', 'rolled']

------------------------------------

=== GROUP B: DEBATE-ONLY ===

BEFORE:
Currebtly the pve leads to being targeted by people who go in with free kits and dont actually engage in the pve content. This game is great if you wanna just shoot people. Engaging in the actual game leads to you losing your gear to free kits.

AFTER:
['currebtly', 'pve', 'leads', 'targeted', 'people', 'free', 'kits', 'dont', 'actually', 'engage', 'pve', 'content', 'game', 'great', 'wanna', 'just', 'shoot', 'people', 'engaging', 'actual', 'game', 'leads', 'losing', 'gear', 'free', 'kits']

# Custom stopwords for gaming corpus
# These are words that slipped through gensim's default stopword list
# but don't add meaningful content to this analysis
custom_stopwords = {
    # Generic words too broad to be analytically useful
    "game", "just", "really", "people", "players", "player", "think",
    "know", "want", "like", "good", "going", "make", "way", "thing", "things",
    "right", "said", "say", "got", "getting", "actually", "maybe", "pretty",
    "need", "time", "times", "better", "best", "lot", "use", "using", "yeah",
    "play", "playing", "games", "guy", "guys", "bad", "free", "fun", "high",
    "try", "feel", "does", "work", "run", "team", "point", "reason",
    "experience", "enjoy", "having", "doing", "making", "trying", "sure",
    "fine", "long", "big", "day", "little", "different", "real", "probably",
    "simply", "especially", "literally", "instead", "away", "able", "come",
    "let", "stop", "bring", "mean", "kind", "care", "abmm", "arc",
    # Contractions stripped of apostrophes (e.g. "don't" becomes "dont" after cleaning)
    "dont", "doesnt", "isnt", "cant", "wont", "didnt", "wouldnt", "shouldnt",
    "wasnt", "werent", "hasnt", "havent", "hadnt", "youre", "theyre", "ive",
    "im", "thats", "its", "itll", "theres", "heres", "whats", "lets"
}

# Remove custom stopwords from each row's token list and rebuild cleaned text column
df["tokens"] = df["tokens"].apply(
    lambda tokens: [t for t in tokens if t not in custom_stopwords]
)
df["text_clean"] = df["tokens"].apply(lambda x: " ".join(x))

# Recount Group A token frequencies using the updated cleaned tokens
moral_counter = Counter()
for tokens in df[mask_moral]["tokens"]:
    moral_counter.update(tokens)

# Apply custom stopwords to the counter as a second pass for word cloud accuracy
filtered_moral_counter = {
    word: count 
    for word, count in moral_counter.items() 
    if word not in custom_stopwords
}

# Count bigram frequencies in Group A only (tokens containing underscore are bigrams)
moral_bigram_counter = Counter()
for tokens in df[mask_moral]["tokens_bigram"]:
    for token in tokens:
        if "_" in token:
            moral_bigram_counter[token] += 1

# Remove generic bigrams that don't add meaningful content to the analysis
bigram_stopwords = {
    "feel_like", "feels_like", "dont_want", "dont_know", 
    "sounds_like", "getting_shot"
}
# Keep only bigrams not in the stoplist and appearing at least 5 times
filtered_bigram_counter = {
    word: count 
    for word, count in moral_bigram_counter.items() 
    if word not in bigram_stopwords and count >= 5
}

# Merge unigram and bigram counters into one for the combined word cloud
combined_counter = {**filtered_moral_counter, **filtered_bigram_counter}

# Merge unigram and bigram counters into one for the combined word cloud
wordcloud_combined = WordCloud(
    width=800,
    height=600,
    background_color="white",
    colormap="gist_heat_r",    # warm red/orange tones for Group A
    max_words=100              # cap at 100 words for readability
).generate_from_frequencies(combined_counter)

plt.figure(figsize=(8, 6))
plt.imshow(wordcloud_combined, interpolation="bilinear")
plt.axis("off")
plt.title("Most Frequent Words + Bigrams: Group A (moral/trait)", fontweight='bold', fontsize=12, pad=40)
plt.tight_layout()
plt.savefig("wordcloud_combined_groupA.png", dpi=150)
plt.show()

# Recount Group B token frequencies using updated cleaned tokens
debate_counter = Counter()
for tokens in df[mask_pvp & ~mask_moral]["tokens"]:
    debate_counter.update(tokens)

# Apply custom stopwords to the counter as a second pass for word cloud accuracy
filtered_debate_counter = {
    word: count 
    for word, count in debate_counter.items() 
    if word not in custom_stopwords
}

# Count bigram frequencies in Group B only
debate_bigram_counter = Counter()
for tokens in df[mask_pvp & ~mask_moral]["tokens_bigram"]:
    for token in tokens:
        if "_" in token:
            debate_bigram_counter[token] += 1

# Remove generic bigrams that don't add meaningful content to the analysis
bigram_stopwords = {
    "feel_like", "feels_like", "dont_want", "dont_know", 
    "sounds_like", "getting_shot"
}
# Keep only bigrams not in the stoplist and appearing at least 5 times
filtered_bigram_counter = {
    word: count 
    for word, count in debate_bigram_counter.items() 
    if word not in bigram_stopwords and count >= 5
}

# Merge unigram and bigram counters for the combined word cloud
combined_counter2 = {**filtered_debate_counter, **filtered_bigram_counter}

# Generate word cloud for Group B using a different colormap to visually distinguish from Group A
wordcloud_combined2 = WordCloud(
    width=800,
    height=600,
    background_color="white",
    colormap="gist_heat",      # warm red/orange tones for Group B
    max_words=100
).generate_from_frequencies(combined_counter2)

plt.figure(figsize=(8, 6))
plt.imshow(wordcloud_combined2, interpolation="bilinear")
plt.axis("off")
plt.title("Most Frequent Words + Bigrams: Group B (debate-only)", fontweight='bold', fontsize=12, pad=40)
plt.tight_layout()
plt.savefig("wordcloud_combined_groupB.png", dpi=150)
plt.show()

# Compute relative frequencies and ratio of each word between Group A and Group B

rows = []

for word in moral_counter:
    # Relative frequency = word count / total tokens in that group
    # Allows fair comparison between groups of different sizes
    moral_freq = (moral_counter[word] + 1) / (moral_total + 1)
    debate_freq = (debate_counter[word] + 1) / (debate_total + 1)
    
    # Higher ratio = word is proportionally more common in Group A than Group B
    ratio = moral_freq / debate_freq
    
    rows.append({
        "word": word,
        "moral_freq": moral_freq,
        "debate_freq": debate_freq,
        "ratio": ratio,
        "moral_count": moral_counter[word]
    })

df_compare = pd.DataFrame(rows)

# Filter to meaningful candidates only:
# - must appear at least 10 times in Group A to avoid rare noise
# - must appear at least twice as often in Group A as Group B
df_candidates = df_compare[
    (df_compare["moral_count"] >= 10) &
    (df_compare["ratio"] > 2)
].sort_values("ratio", ascending=False)

# Display top 30 words most distinctive to the moral/trait group
df_candidates.head(30)

# Group A (Moral/Trait-language) ===============================

# Encapsulates mapping between normalized words and integer ids
grpa_dictionary = Dictionary(df_moral["tokens"]) 

# Filters out tokens that appear in less than 3 documents
# And shrinks resulting gaps in word ids
# Small number no_below because group a is smaller than group b
grpa_dictionary.filter_extremes(no_below=3) 

# Removes gaps in word ID sequences
grpa_dictionary.compactify()

# Converts lists of tokes into bag-of-words presentation
grpa_bow = [grpa_dictionary.doc2bow(a) for a in df_moral["tokens"]]

# Group B (debate-only) ==================================================

# Encapsulates mapping between normalized words and integer ids
grpb_dictionary = Dictionary(df_debate_only["tokens"])

# Filters out tokens that appear in less than 10 documents
# Larger no_below number due to being the larger group
# And shrinks resulting gaps in word ids
grpb_dictionary.filter_extremes(no_below=10)

# Removes gaps in word ID sequences
grpb_dictionary.compactify()

# Converts lists of tokes into bag-of-words presentation
grpb_bow = [grpb_dictionary.doc2bow(a) for a in df_debate_only["tokens"]]

# Builds the LDA model using raw bag-of-words

# Group A (Moral/Trait-language)
lda_model_a = LdaModel(grpa_bow,       # The training corpus
                    num_topics=3,      # Number of latent topics to extract
                    random_state=2026, # Random seed for reproducibility
                    id2word=grpa_dictionary, # Mapping from word IDs (integers) to words (strings)
                    passes=10)         # Number of iterations

# Group B (debate-only)
lda_model_b = LdaModel(grpb_bow,       # The training corpus
                    num_topics=4,      # Number of latent topics to extract
                    random_state=2026, # Random seed for reproducibility
                    id2word=grpb_dictionary, # Mapping from word IDs (integers) to words (strings)
                     passes=10)        # Number of iterations

# Prints the top words per topic
# Interprets the top words to infer the topic label
lda_model_a.print_topics(num_words=10)

[(0,
  '0.021*"rat" + 0.021*"loot" + 0.019*"shoot" + 0.019*"kill" + 0.017*"pve" + 0.015*"lobby" + 0.011*"fight" + 0.007*"gear" + 0.007*"friendly" + 0.007*"unfair"'),
 (1,
  '0.034*"lobby" + 0.023*"rat" + 0.019*"pve" + 0.018*"kill" + 0.014*"shoot" + 0.014*"fight" + 0.012*"raider" + 0.011*"issue" + 0.011*"toxic" + 0.010*"friendly"'),
 (2,
  '0.027*"pve" + 0.013*"kill" + 0.012*"friendly" + 0.011*"extraction" + 0.010*"loot" + 0.009*"nt" + 0.008*"ruin" + 0.008*"behavior" + 0.008*"mode" + 0.007*"lobby"')]

# Prints the top words per topic
# Interprets the top words to infer the topic label
lda_model_b.print_topics(num_words=10)

[(0,
  '0.027*"pvpve" + 0.020*"extraction" + 0.020*"mode" + 0.019*"shooter" + 0.017*"raider" + 0.014*"add" + 0.013*"fight" + 0.011*"devs" + 0.010*"shoot" + 0.009*"nt"'),
 (1,
  '0.092*"lobby" + 0.041*"shoot" + 0.033*"friendly" + 0.017*"kill" + 0.015*"matchmaking" + 0.014*"solo" + 0.014*"match" + 0.013*"raider" + 0.010*"base" + 0.009*"trio"'),
 (2,
  '0.029*"kill" + 0.021*"loot" + 0.020*"weapon" + 0.018*"lose" + 0.016*"gun" + 0.015*"loadout" + 0.013*"kit" + 0.010*"shoot" + 0.010*"risk" + 0.010*"issue"'),
 (3,
  '0.018*"shooter" + 0.017*"extraction" + 0.014*"friendly" + 0.014*"shoot" + 0.013*"nt" + 0.012*"kill" + 0.010*"skill" + 0.010*"fight" + 0.009*"shield" + 0.009*"agree"')]

# Group A (moral/trait-based language)

# View the comment/post tokens at index 1 in group A
print(df_moral["tokens"].iloc[1])

# Find the topic(s) for this particular comment/post
lda_model_a.get_document_topics(grpa_bow[1])

['mmm', 'boss', 'lobby', 'pve', 'address', 'issue', 'lately', 'lobby', 'start', 'kill', 'boss', 'stay', 'far', 'loot', 'map', 'loadout', 'loot', 'chamber', 'ignore', 'boss', 'ppl', 'kill', 'rat', 'lobby', 'intend', 'beginnibg', 'situation', 'ppl', 'aleay', 'raise', 'community', 'lobby', 'ppl', 'far', 'afraid', 'boss', 'start', 'focus', 'raise', 'difficulty', 'raid', 'wander', 'ecc', 'ppl', 'start', 'communicate', 'enemy']

[(0, np.float32(0.9803885)), (1, np.float32(0.010043411))]

# Group B (debate-only)

# View the comment/post tokens at index 1 in Group B
print(df_debate_only["tokens"].iloc[1])

# Find the topic(s) for this particular comment/post
lda_model_b.get_document_topics(grpb_bow[1])

['imo', 'issue', 'balancing', 'incentiv', 'disincentive', 'pvp', 'moment', 'loadout', 'essentialy', 'pvp', 'chaos', 'tool', 'fundamentaly', 'reimagine', '2nd', 'pvp', 'damage', 'fast', 'incentive', 'chaos', 'uncertainty', 'exitement', 'pvpve']

[(0, np.float32(0.405523)),
 (1, np.float32(0.023285972)),
 (2, np.float32(0.5450438)),
 (3, np.float32(0.026147205))]

# Group A (moral/trait)
# prepare() converts the gensim LDA model into a format pyLDAvis can render
# takes the model, the bag-of-words corpus, and the dictionary as inputs
vis_a = pyLDAvis.gensim.prepare(lda_model_a, grpa_bow, grpa_dictionary)
pyLDAvis.display(vis_a)   # renders the interactive visualization inline

# Group B (debate-only)
vis_b = pyLDAvis.gensim.prepare(lda_model_b, grpb_bow, grpb_dictionary)
pyLDAvis.display(vis_b)

# downloads the VADER sentiment lexicon if not already installed
nltk.download('vader_lexicon')

[nltk_data] Downloading package vader_lexicon to
[nltk_data]     C:\Users\anjel\AppData\Roaming\nltk_data...
[nltk_data]   Package vader_lexicon is already up-to-date!

True

# Initializes the VADER sentiment analyzer
# Returns pos, neg, neu, and compound scores for each comment
# Compound score represents overall sentiment (-1 to +1)

# Group A (moral/trait)
sentim_analyzer = SentimentIntensityAnalyzer()
grpa_scores = []

for comment in df_moral['body']:
    scores = sentim_analyzer.polarity_scores(comment)
    grpa_scores.append(scores['compound'])

# Group B (debate-only)
grpb_scores = []

for comment in df_debate_only['body']:
    scores = sentim_analyzer.polarity_scores(comment)
    grpb_scores.append(scores['compound'])

# Calculate average compound sentiment score for each group
# Divides total compound scores by number of comments to get the mean

grpa_avg_score = sum(grpa_scores) / len(grpa_scores)
grpb_avg_score = sum(grpb_scores) / len(grpb_scores)

print("Group A average sentiment:", grpa_avg_score)
print("Group B average sentiment:", grpb_avg_score)

Group A average sentiment: -0.062477475247524755
Group B average sentiment: 0.12794543610547668

# Creates a dataframe with the average sentiment score for each group
# Used to generate the bar chart in the next cell

grp_avg_scores = pd.DataFrame({
    'Group': ['Group A (moral/trait)', 'Group B (debate-only)'],
    'Average Sentiment': [grpa_avg_score, grpb_avg_score]
})

# Bar chart comparing average sentiment scores between groups
# axhline adds a reference line at 0 to clearly show positive vs negative sentiment

plt.figure(figsize=(8, 6))

ax = sns.barplot(data=grp_avg_scores,
                 x='Group', 
                 y='Average Sentiment',
                 hue='Group',
                 palette="gist_heat",
                 legend=False)

plt.title("Average Sentiment Score by Group", fontweight='bold', pad=20)
plt.xlabel('Group', fontweight='bold')
plt.ylabel('Average Sentiment', fontweight='bold')
plt.axhline(0, color='grey', linewidth=.5)
plt.show()

# Creates a dataframe with individual compound scores for each comment in both groups
# Used to generate the boxplot in the next cell showing sentiment distribution
grp_scores = pd.DataFrame({
    'Group': ['Group A (moral/trait)'] * len(grpa_scores) + ['Group B (debate-only)'] * len(grpb_scores),
    'Compound Score': grpa_scores + grpb_scores
})

# Boxplot showing the distribution of compound sentiment scores for each group
# Reveals median, spread, and outliers within each group's sentiment range

sns.boxplot(x='Group', 
            y='Compound Score', 
            data=grp_scores, 
            palette='gist_heat', 
            hue='Group', 
            legend=False)

plt.title("Sentiment Score Distribution by Group", fontweight='bold', pad=20)
plt.xlabel('Group', fontweight='bold')
plt.ylabel('Compound Score', fontweight='bold')
plt.show()

# Descriptive statistics for Group A (moral/trait) sentiment scores
# Includes mean, std, min, max, and percentiles
pd.Series(grpa_scores).describe()

count    404.000000
mean      -0.062477
std        0.700407
min       -0.996100
25%       -0.753500
50%       -0.161450
75%        0.674600
max        0.998200
dtype: float64

# Descriptive statistics for Group B (debate-only) sentiment scores
# Includes mean, std, min, max, and percentiles
pd.Series(grpb_scores).describe()

count    1479.000000
mean        0.127945
std         0.623916
min        -0.990800
25%        -0.444050
50%         0.177900
75%         0.710600
max         0.997600
dtype: float64

# Calculates the average number of words per comment for each group
# split() breaks each comment into words and len() counts them
grpa_avg_words = df_moral['body'].apply(lambda x: len(x.split())).mean().round()
grpb_avg_words = df_debate_only['body'].apply(lambda x: len(x.split())).mean().round()

print("Group A (moral/trait):", grpa_avg_words, "words per comment")
print("Group B (debate-only):", grpb_avg_words, "words per comment")

Group A (moral/trait): 100.0 words per comment
Group B (debate-only): 72.0 words per comment

# Creates a dataframe with the average comment length for each group
# Used to generate the bar chart in the next cell

grp_avg_words = pd.DataFrame({
    'Group': ['Group A (moral/trait)', 'Group B (debate-only)'],
    'Average Length': [grpa_avg_words, grpb_avg_words]
})

grp_avg_words

# Bar chart comparing average comment length between groups
# axhline adds a reference line at 0 as a baseline
plt.figure(figsize=(8, 6))
ax = sns.barplot(data=grp_avg_words,
                 x='Group', 
                 y='Average Length',
                 hue='Group',
                 palette="gist_heat",
                 legend=False)
plt.title("Comment Length Comparison: Group A (moral/trait) vs Group B (debate-only)", fontweight='bold', pad=20)
plt.xlabel('Group', fontweight='bold')
plt.ylabel('Average Comment Length (By Word)', fontweight='bold')
plt.axhline(0, color='grey', linewidth=.5)
plt.show()

# Calculates the word count for each individual comment in Group A (moral/trait)
# Returns a series of word counts used to generate the boxplot in the next cell
grpa_comment_length = df_moral['body'].apply(lambda x: len(x.split()))

# Calculates the word count for each individual comment in Group B (debate-only)
grpb_comment_length = df_debate_only['body'].apply(lambda x: len(x.split()))

# Combines both groups into a single dataframe for the boxplot
grp_comment_length = pd.DataFrame({
    'Group': ['Group A (moral/trait)'] * len(grpa_comment_length) + ['Group B (debate-only)'] * len(grpb_comment_length),
    'Word Count': list(grpa_comment_length) + list(grpb_comment_length)
})

# Boxplot showing the distribution of comment lengths for each group
# Reveals median, spread, and outliers in comment length within each group

plt.figure(figsize=(6,8))

sns.boxplot(x='Group', 
            y='Word Count', 
            data=grp_comment_length, 
            palette='gist_heat', 
            hue='Group', 
            legend=False)

plt.title("Comment Length: Group A (moral/trait) vs Group B (debate-only)", fontweight='bold', pad=20)
plt.xlabel('Group', fontweight='bold', labelpad=10)
plt.ylabel('Comment Length (By Word)', fontweight='bold', labelpad=10)
plt.show()

# Descriptive statistics for Group A (moral/trait) comment lengths
# Includes mean, std, min, max, and percentiles

grpa_comment_length.describe()

count    404.000000
mean     100.220297
std       91.545855
min        2.000000
25%       38.000000
50%       75.000000
75%      134.000000
max      626.000000
Name: body, dtype: float64

# Descriptive statistics for Group B (debate-only) comment lengths
# Includes mean, std, min, max, and percentiles

grpb_comment_length.describe()

count    1479.000000
mean       71.580798
std        61.701177
min         3.000000
25%        30.000000
50%        54.000000
75%        93.500000
max       499.000000
Name: body, dtype: float64

# Assigns binary labels for the SVM model
# 1 = Group A (moral/trait), 0 = Group B (debate-only)
df_moral['label'] = 1
df_debate_only['label'] = 0

# Combines both groups into a single dataframe for the SVM model
df_svm = pd.concat([df_moral, df_debate_only])

# Converts cleaned text into numerical TF-IDF features the SVM model can process
vectorizer = TfidfVectorizer()
matrix = vectorizer.fit_transform(df_svm['text_clean'])
X = matrix
y = df_svm['label']

# Splits data into 80% training and 20% testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Initializes SVC model with RBF kernel
# RBF handles non-linear relationships between features better than a linear kernel
model = SVC(kernel='rbf', C=1.0, gamma='scale')

# Fits model to training data
model.fit(X_train, y_train)

# Makes predictions on the test set
predictions = model.predict(X_test)

# Evaluates model performance
print("===== Classification Report =====")
print(classification_report(y_test, predictions))
print("===== Confusion Matrix =====")
print(confusion_matrix(y_test, predictions))

===== Classification Report =====
              precision    recall  f1-score   support

           0       0.84      1.00      0.91       296
           1       1.00      0.30      0.46        81

    accuracy                           0.85       377
   macro avg       0.92      0.65      0.68       377
weighted avg       0.87      0.85      0.81       377

===== Confusion Matrix =====
[[296   0]
 [ 57  24]]

# Generates confusion matrix heatmap showing model predictions vs actual labels
# cbar=False removes the colorbar since counts are already annotated in each cell
# xticks and yticks replace the default 0/1 labels with descriptive group names

cm = confusion_matrix(y_test, predictions)
plt.figure(figsize=(6, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Reds', cbar=False)
plt.title('SVM Confusion Matrix: Class Imbalance Between Groups', fontweight='bold', pad=20)
plt.xlabel('Predicted', fontweight='bold', labelpad=20)
plt.ylabel('Actual', fontweight='bold', labelpad=20)
plt.xticks(ticks=[0.5, 1.5], labels=['Group B (debate-only)', 'Group A (moral/trait)'])
plt.yticks(ticks=[0.5, 1.5], labels=['Group B (debate-only)', 'Group A (moral/trait)'])
plt.show()

	word	moral_freq	debate_freq	ratio	moral_count
85	toxic	0.003057	0.000021	147.565502	55
410	unfair	0.002129	0.000021	102.768832	38
88	cheap	0.001747	0.000021	84.323144	31
4	rat	0.010262	0.000124	82.566412	187
132	camping	0.001583	0.000021	76.417849	28
99	deserve	0.000655	0.000021	31.621179	11
250	cheating	0.000655	0.000021	31.621179	11
519	ruin	0.003766	0.000124	30.303630	68
189	cheat	0.001201	0.000062	19.324054	21
214	sweaty	0.001419	0.000104	13.702511	25
259	cheater	0.000819	0.000062	13.175491	14
313	sweat	0.001910	0.000166	11.528555	34
127	camp	0.001310	0.000166	7.905295	23
607	voice	0.000600	0.000124	4.831013	10
399	short	0.000600	0.000124	4.831013	10
327	claim	0.000655	0.000145	4.517311	11
49	fake	0.000655	0.000145	4.517311	11
403	behavior	0.002402	0.000725	3.312695	43
510	fuck	0.001310	0.000414	3.162118	23
442	exploit	0.000710	0.000228	3.114207	12
584	chat	0.000764	0.000249	3.074281	13
140	anymore	0.000819	0.000269	3.040498	14
692	rocketeer	0.000819	0.000269	3.040498	14
594	walk	0.000600	0.000207	2.898608	10
406	jump	0.000873	0.000331	2.635098	15
373	corner	0.000819	0.000311	2.635098	14
650	lore	0.000600	0.000228	2.635098	10
324	outside	0.000655	0.000249	2.635098	11
728	gain	0.000655	0.000249	2.635098	11
283	camper	0.000873	0.000352	2.480092	15

Final Project¶

To what extent do Reddit discussions of ARC Raiders use moral and trait-based language when debating PvP and PvE gameplay?¶

About the corpus¶

How the dataset was created¶

Preprocessing steps & justification¶

Import libraries & setup¶

Import data¶

Summary¶

Preprocessing¶

Example: Before and after preprocessing¶

Bigram creation¶

Trigram Creation¶

Dictionary Method¶

Tokenizing and counting¶

Here is an example of before and after tokenization for each group.¶

Word clouds¶

Group A: Moral/Trait Based Tokens¶

Group B: Debate Only Word Cloud¶

Word Cloud Observations¶

How much more likely is a certain word to appear in Group A compared to Group B?¶

What Are Each Group Talking About? A Topic Modeling Analysis¶

Group A (Moral/Trait Language) Topics¶

Group B (debate-only) Topics¶

LDA Results Discussion¶

Document-Level Topic Examples¶

Group A Example¶

Group B Example¶

LDA Topic-Modeling Visualization¶

Comparing the dictionary method vs LDA¶

Which group's language is more emotionally charged?¶

Which group uses more positive or negative language on average?¶

How does sentiment vary within each group?¶

Which group writes the most?¶

Do commenters who use moral language write longer comments?¶

How does comment length differ between the two groups?¶

Does a supervised model agree with the dictionary method?¶

SVM Results¶

What did this project reveal about how moral and trait-based language is used in PvP vs PvE debates on r/ARCRaiders?¶

Conclusion¶

Challenges¶

Next Steps¶

Citations¶