diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/.gitignore b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/.gitignore new file mode 100644 index 000000000..00f4b6d68 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/.gitignore @@ -0,0 +1,4 @@ +training.1600000.processed.noemoticon.csv +__pycache__/ +*.pyc +.ipynb_checkpoints/ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/Dockerfile b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/Dockerfile new file mode 100644 index 000000000..34a8fdb1d --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.11-slim + +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update && apt-get install -y \ + default-jdk \ + curl \ + vim \ + && rm -rf /var/lib/apt/lists/* + +ENV JAVA_HOME=/usr/lib/jvm/default-java +ENV PATH="${JAVA_HOME}/bin:${PATH}" + +RUN pip install --upgrade pip +RUN pip install jupyterlab jupyterlab_vim + +COPY requirements.txt /install/requirements.txt +RUN pip install --no-cache-dir -r /install/requirements.txt + +WORKDIR /app +COPY . /app + +EXPOSE 8888 + +CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=", "--NotebookApp.password="] diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/README.md b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/README.md new file mode 100644 index 000000000..4e54db1f3 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/README.md @@ -0,0 +1,294 @@ +# Real-Time Tweet Sentiment Analysis using Apache Kafka and HuggingFace Transformers + +## Author +- **Name**: Aashish Vinod +- **Course**: DATA605 Spring 2026 +- **GitHub**: @aashishvinod +- **Project**: UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka + +## Project Overview + +This project builds a real-time tweet sentiment analysis pipeline using Apache Kafka +for stream ingestion and a pre-trained HuggingFace transformer model +(cardiffnlp/twitter-roberta-base-sentiment) for sentiment classification. + +Tweets from the Sentiment140 dataset (1.6M labeled tweets) are published to a Kafka +topic by a producer. A Kafka consumer reads the stream, runs each tweet through the +sentiment model, and classifies it as positive, negative, or neutral in real time. +Results are aggregated and visualized using Spark SQL, matplotlib, and a live +Streamlit dashboard. + +## Architecture + +``` +Sentiment140 Dataset (1.6M tweets) + | + v + Kafka Producer + (kafka-python) + | + v + Kafka Topic: tweets + (3 partitions) + | + v + Kafka Consumer + | + v + HuggingFace Sentiment Model + (cardiffnlp/twitter-roberta-base-sentiment) + | + v + Real-Time Classification + (positive / negative / neutral) + | + v + Spark SQL + Aggregations + | + v + Streamlit Dashboard + Visualizations +``` + +## Description of Files + +- `Dockerfile` + - Docker image configuration with Python 3.11, Java, PyTorch, and HuggingFace + +- `docker-compose.yml` + - Orchestrates 3 containers: Zookeeper, Kafka broker, and JupyterLab + +- `requirements.txt` + - All pinned Python dependencies for the project + +- `kafka_sentiment_utils.py` + - Core utility functions: load_sentiment140(), preprocess_tweet(), + create_tweet_event(), compute_sentiment_stats(), format_sentiment_summary() + +- `kafka_sentiment.API.ipynb` + - API reference notebook documenting each component individually: + dataset loading, preprocessing, HuggingFace model, Kafka producer/consumer + +- `kafka_sentiment.example.ipynb` + - Full pipeline demo notebook running end-to-end sentiment analysis + +- `dashboard.py` + - Live Streamlit dashboard with real-time sentiment metrics, pie chart, + and trend visualization + +- `README.md` + - This documentation file + +- `docker_build.sh` + - Script to build the Docker container image + +- `docker_bash.sh` + - Script to launch an interactive bash shell inside the container + +- `docker_jupyter.sh` + - Script to launch JupyterLab inside the container + +- `docker_name.sh` + - Configuration file defining Docker image naming variables + +- `docker_clean.sh` + - Script to remove Docker images for this project + +- `docker_cmd.sh` + - Script to execute arbitrary commands inside the container + +- `docker_exec.sh` + - Script to attach to a running container + +- `docker_push.sh` + - Script to push the Docker image to a registry + +- `run_jupyter.sh` + - Script to start JupyterLab server inside the container + +- `utils.sh` + - Bash utility library used by all docker_*.sh scripts + +- `version.sh` + - Script to report Python, pip, and Jupyter version information + +- `bashrc` + - Bash configuration file for the container environment + +- `etc_sudoers` + - Sudoers configuration for container permissions + +- `copy_docker_files.py` + - Python script for copying Docker configuration files + +## Dataset + +**Sentiment140** +- Source: Kaggle (https://www.kaggle.com/datasets/kazanova/sentiment140) +- Size: 1.6 million tweets +- Labels: 0 = negative, 4 = positive +- Access: Free download with Kaggle account +- Note: The dataset file is excluded from the repository via .gitignore due to + its size (228MB). Download it from Kaggle and place it in the project folder + before running. + +## Model + +**cardiffnlp/twitter-roberta-base-sentiment** +- Pre-trained RoBERTa model fine-tuned on approximately 58 million tweets +- Labels: LABEL_0 = negative, LABEL_1 = neutral, LABEL_2 = positive +- Source: HuggingFace Model Hub (free, no API key needed) +- Size: approximately 499MB (downloaded automatically on first run) + +## How to Run + +### Step 1: Download the dataset +Download `training.1600000.processed.noemoticon.csv` from Kaggle and place it +in this project directory. + +### Step 2: Build the Docker image +```bash +> docker-compose build +``` + +### Step 3: Start all services +```bash +> docker-compose up -d +``` + +### Step 4: Verify all containers are running +```bash +> docker-compose ps +``` +You should see Zookeeper, Kafka, and Jupyter all showing status "Up". + +### Step 5: Open JupyterLab +Open your browser and go to: +``` +http://localhost:8888 +``` + +### Step 6: Run the notebooks +1. Open `kafka_sentiment.API.ipynb` and run all cells to understand each component +2. Open `kafka_sentiment.example.ipynb` and run all cells for the full pipeline demo + +### Step 7: Run the Streamlit dashboard +In the JupyterLab terminal run: +```bash +> streamlit run /app/dashboard.py --server.port 8502 --server.address 0.0.0.0 +``` +Then open `http://localhost:8502` in your browser and click Run Pipeline. + +### Step 8: Stop all services +```bash +> docker-compose down +``` + +## Workflows + +- Build the container: + ```bash + > docker_build.sh + ``` + +- Start JupyterLab: + ```bash + > docker_jupyter.sh + # Go to localhost:8888 + ``` + +- Open a bash shell inside the container: + ```bash + > docker_bash.sh + ``` + +- Check versions: + ```bash + > version.sh + ``` + +## Dependencies + +| Package | Version | Purpose | +|---------|---------|---------| +| kafka-python | 2.0.2 | Kafka producer and consumer | +| transformers | 4.35.0 | HuggingFace sentiment model | +| torch | 2.1.0 | PyTorch backend for transformers | +| pyspark | 3.5.1 | Spark SQL and aggregations | +| pandas | 2.1.0 | Data manipulation | +| numpy | 1.26.0 | Numerical computing | +| matplotlib | 3.7.0 | Visualization | +| seaborn | 0.13.0 | Statistical visualization | +| wordcloud | 1.9.2 | Word cloud visualization | +| streamlit | 1.28.0 | Live dashboard | +| plotly | 6.7.0 | Interactive charts in dashboard | +| scikit-learn | 1.3.0 | Model evaluation metrics | +| findspark | 2.0.1 | PySpark initialization in Jupyter | +| tqdm | 4.66.1 | Progress bars | + +## Results + +From a full pipeline run on 500 tweets from Sentiment140: + +| Metric | Value | +|--------|-------| +| Tweets produced | 500 | +| Tweets consumed | 500 | +| Positive | 184 (36.8%) | +| Negative | 168 (33.6%) | +| Neutral | 148 (29.6%) | +| Binary accuracy (RoBERTa) | 81.82% | +| DistilBERT accuracy (comparison) | 73.00% | +| Anomalies detected | 56 | +| Kafka throughput | up to 5732 tweets/sec | + +## Architectural Decisions + +### Why Apache Kafka? +Kafka was chosen as the message broker because it provides high-throughput, +fault-tolerant, and persistent message streaming. Unlike a simple queue, Kafka +retains all messages until the retention period expires, which allows multiple +consumers to read the same data independently. This is critical for a real-time +sentiment monitoring system where you may want to replay events for debugging. + +### Why RoBERTa over other models? +The cardiffnlp/twitter-roberta-base-sentiment model was chosen because it is +specifically trained on 58 million tweets, making it well-suited for informal +Twitter language including abbreviations, hashtags, and slang. General-purpose +models trained on formal text tend to perform worse on tweets. + +### Why Spark for aggregations? +PySpark was used for the aggregation layer because it provides a SQL interface +for querying large datasets and scales horizontally. While pandas would work for +500 tweets, Spark allows the same code to scale to millions of tweets without +modification. + +### Why Streamlit for the dashboard? +Streamlit was chosen for the dashboard because it allows building interactive +web applications entirely in Python without requiring JavaScript or HTML knowledge. +The dashboard updates in real time as tweets are classified, providing the live +visualization required by the project description. + +## Challenges and Solutions + +### Challenge 1: Docker networking +When Kafka runs inside a Docker container, other containers cannot connect to it +using localhost:9092. The correct address is kafka:29092 using the internal Docker +network service name. This caused NoBrokersAvailable errors until the broker +address was corrected in the notebook configuration. + +### Challenge 2: Kafka topic retention +Kafka retains all messages by default until the retention period expires. After +multiple test runs, the consumer was reading thousands of old messages from previous +runs. The solution was to delete and recreate the Kafka topic at the start of each +pipeline run to ensure only fresh tweets are processed. + +### Challenge 3: Model label mapping +The cardiffnlp model returns LABEL_0, LABEL_1, and LABEL_2 instead of +human-readable labels. A mapping dictionary was created in kafka_sentiment_utils.py +to translate these to negative, neutral, and positive respectively. + +### Challenge 4: Sentiment140 binary labels +The Sentiment140 dataset only has positive and negative labels (0 and 4). The +RoBERTa model also predicts neutral which the dataset does not have. Accuracy is +therefore measured only on positive and negative predictions, ignoring tweets +classified as neutral. diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/bashrc b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/bashrc new file mode 100644 index 000000000..4b7ff4c49 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/bashrc @@ -0,0 +1 @@ +set -o vi diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/copy_docker_files.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/copy_docker_files.py new file mode 100644 index 000000000..0e97c194c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/copy_docker_files.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python + +""" +Copy Docker-related files from the source directory to a destination directory. + +This script copies all Docker configuration and utility files from +class_project/project_template/ to a specified destination directory. + +Usage examples: + # Copy all files to a target directory. + > ./copy_docker_files.py --dst_dir /path/to/destination + + # Copy with verbose logging. + > ./copy_docker_files.py --dst_dir /path/to/destination -v DEBUG + +Import as: + +import class_project.project_template.copy_docker_files as cpdccodo +""" + +import argparse +import logging +import os +from typing import List + +import helpers.hdbg as hdbg +import helpers.hio as hio +import helpers.hparser as hparser +import helpers.hsystem as hsystem + +_LOG = logging.getLogger(__name__) + +# ############################################################################# +# Constants +# ############################################################################# + +# List of files to copy from the source directory. +_FILES_TO_COPY = [ + "bashrc", + "docker_bash.sh", + "docker_build.sh", + "docker_clean.sh", + "docker_cmd.sh", + "docker_exec.sh", + "docker_jupyter.sh", + "docker_name.sh", + "docker_push.sh", + "etc_sudoers", + "install_jupyter_extensions.sh", + "run_jupyter.sh" + "version.sh", +] + + +# ############################################################################# +# Helper functions +# ############################################################################# + + +def _get_source_dir() -> str: + """ + Get the absolute path to the source directory containing Docker files. + + :return: absolute path to class_project/project_template/ + """ + # Get the directory where this script is located. + script_dir = os.path.dirname(os.path.abspath(__file__)) + _LOG.debug("Script directory='%s'", script_dir) + return script_dir + + +def _copy_files( + *, + src_dir: str, + dst_dir: str, + files: List[str], +) -> None: + """ + Copy specified files from source directory to destination directory. + + :param src_dir: source directory path + :param dst_dir: destination directory path + :param files: list of filenames to copy + """ + # Verify source directory exists. + hdbg.dassert_dir_exists(src_dir, "Source directory does not exist:", src_dir) + # Create destination directory if it doesn't exist. + hio.create_dir(dst_dir, incremental=True) + _LOG.info("Copying %d files from '%s' to '%s'", len(files), src_dir, dst_dir) + # Copy each file. + copied_count = 0 + for filename in files: + src_path = os.path.join(src_dir, filename) + dst_path = os.path.join(dst_dir, filename) + # Verify source file exists. + hdbg.dassert_path_exists( + src_path, "Source file does not exist:", src_path + ) + # Copy the file using cp -a to preserve all permissions and attributes. + _LOG.debug("Copying '%s' -> '%s'", src_path, dst_path) + cmd = f"cp -a {src_path} {dst_path}" + hsystem.system(cmd) + copied_count += 1 + # + _LOG.info("Successfully copied %d files", copied_count) + + +# ############################################################################# + + +def _parse() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--dst_dir", + action="store", + required=True, + help="Destination directory where files will be copied", + ) + hparser.add_verbosity_arg(parser) + return parser + + +def _main(parser: argparse.ArgumentParser) -> None: + args = parser.parse_args() + hdbg.init_logger(verbosity=args.log_level, use_exec_path=True) + # Get source directory. + src_dir = _get_source_dir() + # Copy files to destination. + _copy_files( + src_dir=src_dir, + dst_dir=args.dst_dir, + files=_FILES_TO_COPY, + ) + + +if __name__ == "__main__": + _main(_parse()) diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/dashboard.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/dashboard.py new file mode 100644 index 000000000..1fa105243 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/dashboard.py @@ -0,0 +1,225 @@ +""" +Real-Time Tweet Sentiment Analysis Dashboard +Run with: streamlit run dashboard.py --server.port 8501 +""" +import json +import time +import random +import pandas as pd +import streamlit as st +import plotly.express as px +import plotly.graph_objects as go +from kafka import KafkaProducer, KafkaConsumer +from kafka.admin import KafkaAdminClient, NewTopic +from kafka.errors import TopicAlreadyExistsError, UnknownTopicOrPartitionError +from transformers import pipeline +from kafka_sentiment_utils import ( + load_sentiment140, preprocess_tweet, create_tweet_event, + TOPIC_NAME, SENTIMENT_LABELS, SENTIMENT_COLORS, +) + +# +# Page config +# +st.set_page_config( + page_title="Real-Time Tweet Sentiment Dashboard", + page_icon="", + layout="wide", +) + +st.title(" Real-Time Tweet Sentiment Analysis") +st.markdown("Apache Kafka + HuggingFace Transformers | DATA605 Spring 2026 | Aashish Vinod") +st.divider() + +# +# Sidebar controls +# +st.sidebar.title("️ Controls") +n_tweets = st.sidebar.slider("Number of tweets to process", 50, 500, 100, 50) +batch_size = st.sidebar.slider("Batch size per update", 10, 50, 20, 10) +dataset_path = st.sidebar.text_input( + "Dataset path", + value="/app/training.1600000.processed.noemoticon.csv" +) +run_button = st.sidebar.button(" Run Pipeline", type="primary", use_container_width=True) +st.sidebar.divider() +st.sidebar.markdown("**About**") +st.sidebar.markdown("This dashboard streams tweets through Apache Kafka and classifies sentiment in real time using the `cardiffnlp/twitter-roberta-base-sentiment` model.") + +# +# Layout placeholders +# +col1, col2, col3, col4 = st.columns(4) +positive_metric = col1.empty() +negative_metric = col2.empty() +neutral_metric = col3.empty() +accuracy_metric = col4.empty() + +st.divider() +col_left, col_right = st.columns(2) +pie_chart = col_left.empty() +trend_chart = col_right.empty() +st.divider() +tweet_table = st.empty() + +# +# Initialize metrics +# +positive_metric.metric(" Positive", "0", "0%") +negative_metric.metric(" Negative", "0", "0%") +neutral_metric.metric(" Neutral", "0", "0%") +accuracy_metric.metric(" Accuracy", "N/A") + +# +# Main pipeline +# +if run_button: + KAFKA_BROKER = "kafka:29092" + + # Load data + with st.spinner("Loading Sentiment140 dataset..."): + df = load_sentiment140(dataset_path, n_samples=n_tweets * 2) + st.success(f"Loaded {len(df)} tweets from Sentiment140!") + + # Load model + with st.spinner("Loading HuggingFace RoBERTa model..."): + sentiment_model = pipeline( + "sentiment-analysis", + model="cardiffnlp/twitter-roberta-base-sentiment", + tokenizer="cardiffnlp/twitter-roberta-base-sentiment", + truncation=True, + max_length=128, + top_k=1, + ) + st.success("Model loaded!") + + # Reset Kafka topic + with st.spinner("Setting up Kafka topic..."): + admin = KafkaAdminClient(bootstrap_servers=KAFKA_BROKER) + try: + admin.delete_topics([TOPIC_NAME]) + time.sleep(2) + except Exception: + pass + try: + admin.create_topics([NewTopic(name=TOPIC_NAME, num_partitions=3, replication_factor=1)]) + except Exception: + pass + admin.close() + st.success("Kafka topic ready!") + + # Produce tweets + producer = KafkaProducer( + bootstrap_servers=KAFKA_BROKER, + value_serializer=lambda v: json.dumps(v).encode("utf-8"), + key_serializer=lambda k: k.encode("utf-8"), + ) + df_produce = df.head(n_tweets) + for i, row in df_produce.iterrows(): + event = create_tweet_event(row["text"], row["sentiment"], tweet_id=i) + producer.send(TOPIC_NAME, key="tweet", value=event) + producer.flush() + producer.close() + + # Consume and classify in real time + consumer = KafkaConsumer( + TOPIC_NAME, + bootstrap_servers=KAFKA_BROKER, + auto_offset_reset="earliest", + enable_auto_commit=True, + group_id="dashboard-group", + value_deserializer=lambda x: json.loads(x.decode("utf-8")), + consumer_timeout_ms=8000, + ) + + results = [] + progress = st.progress(0, text="Classifying tweets...") + + for msg in consumer: + event = msg.value + text = event["text"] + true_label = event["true_label"] + + result = sentiment_model(text[:128])[0] + if isinstance(result, list): + result = result[0] + predicted = SENTIMENT_LABELS.get(result["label"], result["label"]) + score = round(result["score"], 4) + + results.append({ + "text": text[:80] + "..." if len(text) > 80 else text, + "true_label": true_label, + "predicted": predicted, + "score": score, + "correct": predicted == true_label, + }) + + # Update dashboard every batch_size tweets + if len(results) % batch_size == 0 or len(results) == n_tweets: + df_res = pd.DataFrame(results) + total = len(df_res) + pos = int((df_res["predicted"] == "positive").sum()) + neg = int((df_res["predicted"] == "negative").sum()) + neu = int((df_res["predicted"] == "neutral").sum()) + + # Accuracy + df_binary = df_res[df_res["true_label"].isin(["positive", "negative"])] + df_binary = df_binary[df_binary["predicted"].isin(["positive", "negative"])] + acc = df_binary["correct"].mean() * 100 if len(df_binary) > 0 else 0 + + # Update metrics + positive_metric.metric(" Positive", pos, f"{pos/total*100:.1f}%") + negative_metric.metric(" Negative", neg, f"{neg/total*100:.1f}%") + neutral_metric.metric(" Neutral", neu, f"{neu/total*100:.1f}%") + accuracy_metric.metric(" Accuracy", f"{acc:.1f}%") + + # Pie chart + pie_fig = px.pie( + values=[pos, neg, neu], + names=["Positive", "Negative", "Neutral"], + color_discrete_map={ + "Positive": SENTIMENT_COLORS["positive"], + "Negative": SENTIMENT_COLORS["negative"], + "Neutral": SENTIMENT_COLORS["neutral"], + }, + title=f"Sentiment Distribution ({total} tweets processed)", + ) + pie_chart.plotly_chart(pie_fig, use_container_width=True) + + # Trend chart + window = min(30, total) + df_res["is_positive"] = (df_res["predicted"] == "positive").astype(int) + df_res["is_negative"] = (df_res["predicted"] == "negative").astype(int) + df_res["rolling_pos"] = df_res["is_positive"].rolling(window, min_periods=1).mean() * 100 + df_res["rolling_neg"] = df_res["is_negative"].rolling(window, min_periods=1).mean() * 100 + + trend_fig = go.Figure() + trend_fig.add_trace(go.Scatter( + y=df_res["rolling_pos"], mode="lines", + name="Positive", line=dict(color=SENTIMENT_COLORS["positive"], width=2) + )) + trend_fig.add_trace(go.Scatter( + y=df_res["rolling_neg"], mode="lines", + name="Negative", line=dict(color=SENTIMENT_COLORS["negative"], width=2) + )) + trend_fig.update_layout( + title=f"Real-Time Sentiment Trend (Rolling {window}-tweet window)", + xaxis_title="Tweet Index", + yaxis_title="Sentiment %", + yaxis_range=[0, 100], + ) + trend_chart.plotly_chart(trend_fig, use_container_width=True) + + # Recent tweets table + tweet_table.dataframe( + df_res[["text", "true_label", "predicted", "score"]].tail(10), + use_container_width=True, + ) + + # Progress bar + progress.progress(min(total / n_tweets, 1.0), text=f"Processed {total}/{n_tweets} tweets...") + + consumer.close() + progress.progress(1.0, text="Pipeline complete!") + st.balloons() + st.success(f"Pipeline complete! Processed {len(results)} tweets with {acc:.1f}% accuracy.") diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker-compose.yml b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker-compose.yml new file mode 100644 index 000000000..11056ea63 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker-compose.yml @@ -0,0 +1,34 @@ +version: '3.8' +services: + zookeeper: + image: confluentinc/cp-zookeeper:7.4.0 + environment: + ZOOKEEPER_CLIENT_PORT: 2181 + ZOOKEEPER_TICK_TIME: 2000 + + kafka: + image: confluentinc/cp-kafka:7.4.0 + depends_on: + - zookeeper + ports: + - "9092:9092" + environment: + KAFKA_BROKER_ID: 1 + KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 + KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092 + KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT + KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT + KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1 + + jupyter: + build: . + ports: + - "8888:8888" + - "8501:8501" + - "8502:8502" + volumes: + - .:/app + depends_on: + - kafka + environment: + - KAFKA_BROKER=kafka:29092 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_bash.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_bash.sh new file mode 100644 index 000000000..0025e81f4 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_bash.sh @@ -0,0 +1,34 @@ +#!/bin/bash +# """ +# This script launches a Docker container with an interactive bash shell for +# development. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions from the project template. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List the available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" + +# Configure and run the Docker container with interactive bash shell. +# - Container is removed automatically on exit (--rm) +# - Interactive mode with TTY allocation (-ti) +# - Port forwarding for Jupyter or other services +# - Git root mounted to /git_root inside container +CONTAINER_NAME=${IMAGE_NAME}_bash +PORT= +DOCKER_CMD=$(get_docker_bash_command) +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_build.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_build.sh new file mode 100644 index 000000000..5b0957a99 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_build.sh @@ -0,0 +1,40 @@ +#!/bin/bash +# """ +# Build a Docker container image for the project. +# +# This script sets up the build environment with error handling and command +# tracing, loads Docker configuration from docker_name.sh, and builds the +# Docker image using the build_container_image utility function. It supports +# both single-architecture and multi-architecture builds via the +# DOCKER_BUILD_MULTI_ARCH environment variable. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args are passed to the build. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Load Docker configuration variables (REPO_NAME, IMAGE_NAME, FULL_IMAGE_NAME). +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Configure Docker build settings. +# Enable BuildKit for improved build performance and features. +export DOCKER_BUILDKIT=1 +#export DOCKER_BUILDKIT=0 + +# Configure single-architecture build (set to 1 for multi-arch build). +#export DOCKER_BUILD_MULTI_ARCH=1 +export DOCKER_BUILD_MULTI_ARCH=0 + +# Build the container image. +# Pass extra arguments (e.g., --no-cache) via command line after -v. +build_container_image "$@" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_clean.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_clean.sh new file mode 100644 index 000000000..7e40839ae --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_clean.sh @@ -0,0 +1,26 @@ +#!/bin/bash +# """ +# Remove Docker container image for the project. +# +# This script cleans up Docker images by removing the container image +# matching the project configuration. Useful for freeing disk space or +# ensuring a fresh build. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Remove the container image. +remove_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_cmd.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_cmd.sh new file mode 100644 index 000000000..906d7a77b --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_cmd.sh @@ -0,0 +1,41 @@ +#!/bin/bash +# """ +# Execute a command in a Docker container. +# +# This script runs a specified command inside a new Docker container instance. +# The container is removed automatically after the command completes. The +# git root is mounted to /git_root inside the container. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args form the command. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Capture the command to execute from remaining arguments. +CMD="$@" +echo "Executing: '$CMD'" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" +#(docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true + +# Configure and run the Docker container with the specified command. +CONTAINER_NAME=$IMAGE_NAME +DOCKER_CMD=$(get_docker_cmd_command) +PORT="" +DOCKER_RUN_OPTS="" +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT $DOCKER_RUN_OPTS) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME bash -c '$CMD'" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_exec.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_exec.sh new file mode 100644 index 000000000..24f8e401a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_exec.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Execute a bash shell in a running Docker container. +# +# This script connects to an already running Docker container and opens an +# interactive bash session for debugging or inspection purposes. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Execute bash shell in the running container. +exec_container diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_jupyter.sh new file mode 100644 index 000000000..1a60dfd3a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_jupyter.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# """ +# Execute Jupyter Lab in a Docker container. +# +# This script launches a Docker container running Jupyter Lab with +# configurable port, directory mounting, and vim bindings. It passes +# command-line options to the run_jupyter.sh script inside the container. +# +# Usage: +# > docker_jupyter.sh [options] +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse command-line options and set Jupyter configuration variables. +parse_docker_jupyter_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images and inspect architecture. +list_and_inspect_docker_image + +# Run the Docker container with Jupyter Lab. +CMD=$(get_run_jupyter_cmd "${BASH_SOURCE[0]}" "$OLD_CMD_OPTS") +CONTAINER_NAME=$IMAGE_NAME +# Kill existing container if -f flag is set. +kill_existing_container_if_forced + +DOCKER_CMD=$(get_docker_jupyter_command) +DOCKER_CMD_OPTS=$(get_docker_jupyter_options $CONTAINER_NAME $JUPYTER_HOST_PORT $JUPYTER_USE_VIM) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME $CMD" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_name.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_name.sh new file mode 100644 index 000000000..32a546cf3 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_name.sh @@ -0,0 +1,12 @@ +#!/bin/bash +# """ +# Docker image naming configuration. +# +# This file defines the repository name, image name, and full image name +# variables used by all docker_*.sh scripts in the project template. +# """ + +REPO_NAME=gpsaggese +# The file should be all lower case. +IMAGE_NAME=umd_project_template +FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_push.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_push.sh new file mode 100644 index 000000000..27d752dd9 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/docker_push.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Push Docker container image to Docker Hub or registry. +# +# This script authenticates with the Docker registry using credentials from +# ~/.docker/passwd.$REPO_NAME.txt and pushes the locally built container +# image to the remote repository. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker image naming configuration. +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source $SCRIPT_DIR/docker_name.sh + +# Push the container image to the registry. +push_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/etc_sudoers b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/etc_sudoers new file mode 100644 index 000000000..ee0816a15 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/etc_sudoers @@ -0,0 +1,31 @@ +# +# This file MUST be edited with the 'visudo' command as root. +# +# Please consider adding local content in /etc/sudoers.d/ instead of +# directly modifying this file. +# +# See the man page for details on how to write a sudoers file. +# +Defaults env_reset +Defaults mail_badpass +Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin" + +# Host alias specification + +# User alias specification + +# Cmnd alias specification + +# User privilege specification +root ALL=(ALL:ALL) ALL + +# Members of the admin group may gain root privileges +%admin ALL=(ALL) ALL + +# Allow members of group sudo to execute any command +%sudo ALL=(ALL:ALL) ALL + +# See sudoers(5) for more information on "#include" directives: +postgres ALL=(ALL) NOPASSWD:ALL + +#includedir /etc/sudoers.d diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.API.ipynb b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.API.ipynb new file mode 100644 index 000000000..73271d0c6 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.API.ipynb @@ -0,0 +1,413 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# kafka_sentiment.API.ipynb\n", + "## API Reference: Tweet Sentiment Analysis using Kafka and HuggingFace\n", + "**Author**: Aashish Vinod \n", + "**Course**: DATA605 Spring 2026\n", + "\n", + "## Why I built this\n", + "\n", + "As a grad student I have used Kafka before but never combined it with an NLP model.\n", + "The idea of classifying tweet sentiment in real time as messages flow through Kafka\n", + "is a genuinely useful pattern - companies like Twitter and Reddit use similar\n", + "architectures to monitor public opinion at scale.\n", + "\n", + "The hardest part was getting the HuggingFace model to run inside Docker with the\n", + "correct torch version and enough memory allocated.\n", + "\n", + "## Notebook structure\n", + "1. Dataset loading API\n", + "2. Tweet preprocessing API\n", + "3. HuggingFace sentiment model API\n", + "4. Kafka Producer API\n", + "5. Kafka Consumer API\n", + "6. Utility Functions API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Imports and Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All imports successful!\n", + "Kafka topic: tweets\n", + "Sentiment labels: {'LABEL_0': 'negative', 'LABEL_1': 'neutral', 'LABEL_2': 'positive'}\n" + ] + } + ], + "source": [ + "import json\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from kafka import KafkaProducer, KafkaConsumer\n", + "from kafka.admin import KafkaAdminClient, NewTopic\n", + "from kafka_sentiment_utils import (\n", + " load_sentiment140, preprocess_tweet, create_tweet_event,\n", + " serialize_event, deserialize_event,\n", + " compute_sentiment_stats, format_sentiment_summary,\n", + " TOPIC_NAME, SENTIMENT_LABELS, SENTIMENT_COLORS,\n", + ")\n", + "print('All imports successful!')\n", + "print(f'Kafka topic: {TOPIC_NAME}')\n", + "print(f'Sentiment labels: {SENTIMENT_LABELS}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Dataset Loading API" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 1000 tweets\n", + "Columns: ['text', 'label', 'sentiment']\n", + "Sentiment distribution:\n", + "sentiment\n", + "positive 500\n", + "negative 500\n", + "Name: count, dtype: int64\n", + "\n", + "Sample tweets:\n", + " text sentiment\n", + "0 @indiemoviemaker thanks 4 including me in your shoutout positive\n", + "1 No santigold for me tonight. work til 10 and I'm off tomorrow positive\n", + "2 @JonathanRKnight for realz! Safe travels- hope things go much more smoothly this time around. & that you are having a great day so far! positive\n", + "3 @thomaskattus you asked about my SF schedule, dahling...maybe next time positive\n", + "4 My throat kinda hurts negative\n" + ] + } + ], + "source": [ + "# Load a sample of the Sentiment140 dataset\n", + "# Full dataset has 1.6M tweets - we use 1000 for the API demo\n", + "DATASET_PATH = '/app/training.1600000.processed.noemoticon.csv'\n", + "df = load_sentiment140(DATASET_PATH, n_samples=1000)\n", + "print(f'Loaded {len(df)} tweets')\n", + "print(f'Columns: {df.columns.tolist()}')\n", + "print(f'Sentiment distribution:')\n", + "print(df['sentiment'].value_counts())\n", + "print()\n", + "print('Sample tweets:')\n", + "print(df[['text', 'sentiment']].head(5).to_string())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Tweet Preprocessing API" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Raw : @user I love this product! http://example.com\n", + "Cleaned: @user I love this product!\n", + "\n", + "Raw : This is terrible, I hate it @user @user2\n", + "Cleaned: This is terrible, I hate it @user @user\n", + "\n", + "Raw : Just had coffee at Starbucks \n", + "Cleaned: Just had coffee at Starbucks\n", + "\n" + ] + } + ], + "source": [ + "# preprocess_tweet() cleans raw tweets before sending to model\n", + "raw_tweets = [\n", + " '@user I love this product! http://example.com',\n", + " 'This is terrible, I hate it @user @user2',\n", + " 'Just had coffee at Starbucks ',\n", + "]\n", + "for tweet in raw_tweets:\n", + " cleaned = preprocess_tweet(tweet)\n", + " print(f'Raw : {tweet}')\n", + " print(f'Cleaned: {cleaned}')\n", + " print()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. HuggingFace Sentiment Model API" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading sentiment model (this may take a minute on first run)...\n", + "Model loaded successfully!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/site-packages/transformers/pipelines/text_classification.py:105: UserWarning: `return_all_scores` is now deprecated, if want a similar functionality use `top_k=None` instead of `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Load pre-trained Twitter sentiment model\n", + "# cardiffnlp/twitter-roberta-base-sentiment is trained on 58M tweets\n", + "from transformers import pipeline\n", + "\n", + "print('Loading sentiment model (this may take a minute on first run)...')\n", + "sentiment_pipeline = pipeline(\n", + " 'sentiment-analysis',\n", + " model='cardiffnlp/twitter-roberta-base-sentiment',\n", + " tokenizer='cardiffnlp/twitter-roberta-base-sentiment',\n", + " return_all_scores=False,\n", + ")\n", + "print('Model loaded successfully!')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment classification results:\n", + "------------------------------------------------------------\n", + "Tweet : I absolutely love this! Best day ever!\n", + "Sentiment: positive (confidence: 0.9925)\n", + "\n", + "Tweet : This is the worst experience I have ever had\n", + "Sentiment: negative (confidence: 0.9808)\n", + "\n", + "Tweet : Just woke up and having breakfast\n", + "Sentiment: neutral (confidence: 0.7346)\n", + "\n", + "Tweet : So happy about the news today!\n", + "Sentiment: positive (confidence: 0.992)\n", + "\n", + "Tweet : I am really disappointed with this service\n", + "Sentiment: negative (confidence: 0.9815)\n", + "\n" + ] + } + ], + "source": [ + "# Classify individual tweets\n", + "test_tweets = [\n", + " 'I absolutely love this! Best day ever!',\n", + " 'This is the worst experience I have ever had',\n", + " 'Just woke up and having breakfast',\n", + " 'So happy about the news today!',\n", + " 'I am really disappointed with this service',\n", + "]\n", + "print('Sentiment classification results:')\n", + "print('-' * 60)\n", + "for tweet in test_tweets:\n", + " result = sentiment_pipeline(tweet)[0]\n", + " label = SENTIMENT_LABELS.get(result['label'], result['label'])\n", + " score = round(result['score'], 4)\n", + " print(f'Tweet : {tweet}')\n", + " print(f'Sentiment: {label} (confidence: {score})')\n", + " print()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Kafka Producer API" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kafka Producer connected successfully!\n", + "Tweet event to send:\n", + "{\n", + " \"tweet_id\": 0,\n", + " \"text\": \"@user thanks 4 including me in your shoutout\",\n", + " \"true_label\": \"positive\",\n", + " \"timestamp\": \"2026-05-08T23:49:38.244603\"\n", + "}\n", + "Event sent to Kafka successfully!\n" + ] + } + ], + "source": [ + "# Connect to Kafka broker\n", + "# Note: using kafka:29092 (internal Docker network), not localhost:9092\n", + "producer = KafkaProducer(\n", + " bootstrap_servers='kafka:29092',\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8') if k else None,\n", + ")\n", + "print('Kafka Producer connected successfully!')\n", + "\n", + "# Send a single tweet event\n", + "sample_row = df.iloc[0]\n", + "event = create_tweet_event(sample_row['text'], sample_row['sentiment'], tweet_id=0)\n", + "print(f'Tweet event to send:')\n", + "print(json.dumps(event, indent=2))\n", + "producer.send(TOPIC_NAME, key='tweet', value=event)\n", + "producer.flush()\n", + "print('Event sent to Kafka successfully!')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Kafka Consumer API" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total messages received: 0\n" + ] + } + ], + "source": [ + "# Read messages from Kafka topic\n", + "consumer = KafkaConsumer(\n", + " TOPIC_NAME,\n", + " bootstrap_servers='kafka:29092',\n", + " auto_offset_reset='earliest',\n", + " enable_auto_commit=True,\n", + " group_id='api-demo-group',\n", + " value_deserializer=lambda x: json.loads(x.decode('utf-8')),\n", + " consumer_timeout_ms=3000,\n", + ")\n", + "messages = []\n", + "for msg in consumer:\n", + " messages.append(msg.value)\n", + "consumer.close()\n", + "print(f'Total messages received: {len(messages)}')\n", + "if messages:\n", + " print(f'Sample message:')\n", + " print(json.dumps(messages[0], indent=2))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Utility Functions API" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment Statistics:\n", + "Total tweets analyzed : 5\n", + "Positive : 2 (40.0%)\n", + "Negative : 2 (40.0%)\n", + "Neutral : 1 (20.0%)\n", + "Model accuracy : 80.0%\n" + ] + } + ], + "source": [ + "# compute_sentiment_stats() - computes statistics from classified tweets\n", + "sample_results = [\n", + " {'text': 'I love this', 'predicted_sentiment': 'positive', 'true_label': 'positive', 'score': 0.95},\n", + " {'text': 'I hate this', 'predicted_sentiment': 'negative', 'true_label': 'negative', 'score': 0.92},\n", + " {'text': 'Just woke up', 'predicted_sentiment': 'neutral', 'true_label': 'positive', 'score': 0.71},\n", + " {'text': 'Great day!', 'predicted_sentiment': 'positive', 'true_label': 'positive', 'score': 0.88},\n", + " {'text': 'Terrible!', 'predicted_sentiment': 'negative', 'true_label': 'negative', 'score': 0.91},\n", + "]\n", + "stats = compute_sentiment_stats(sample_results)\n", + "print('Sentiment Statistics:')\n", + "print(format_sentiment_summary(stats))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.example.ipynb b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.example.ipynb new file mode 100644 index 000000000..4f7ddf50e --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment.example.ipynb @@ -0,0 +1,1441 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# kafka_sentiment.example.ipynb\n", + "## Full Pipeline: Real-Time Tweet Sentiment Analysis\n", + "**Author**: Aashish Vinod \n", + "**Course**: DATA605 Spring 2026\n", + "\n", + "## Why I chose this project\n", + "\n", + "Sentiment analysis on streaming social media data is one of the most\n", + "practical applications of big data systems. Companies monitor Twitter\n", + "in real time to detect product issues, track brand sentiment, and respond\n", + "to PR crises before they escalate. I wanted to build the core architecture\n", + "behind that.\n", + "\n", + "The most interesting result was the model accuracy - the pre-trained\n", + "RoBERTa model achieved around 78-82% accuracy on the Sentiment140 test\n", + "set without any fine-tuning, which is impressive for a zero-shot approach.\n", + "\n", + "## Pipeline Steps\n", + "1. Setup and configuration\n", + "2. Load and explore Sentiment140 dataset\n", + "3. Publish tweets to Kafka\n", + "4. Consume tweets and classify sentiment\n", + "5. Real-time sentiment aggregation\n", + "6. Spark SQL analysis\n", + "7. Visualizations\n", + "8. Performance and accuracy analysis\n", + "9. Summary and conclusions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete!\n", + "Dataset : /app/training.1600000.processed.noemoticon.csv\n", + "Samples : 5000\n", + "Kafka : kafka:29092\n" + ] + } + ], + "source": [ + "import json\n", + "import time\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from wordcloud import WordCloud\n", + "from kafka import KafkaProducer, KafkaConsumer\n", + "from kafka.admin import KafkaAdminClient, NewTopic\n", + "from kafka.errors import TopicAlreadyExistsError\n", + "from transformers import pipeline\n", + "from kafka_sentiment_utils import (\n", + " load_sentiment140, preprocess_tweet, create_tweet_event,\n", + " serialize_event, deserialize_event,\n", + " compute_sentiment_stats, format_sentiment_summary,\n", + " TOPIC_NAME, SENTIMENT_LABELS, SENTIMENT_COLORS,\n", + ")\n", + "\n", + "KAFKA_BROKER = 'kafka:29092'\n", + "DATASET_PATH = '/app/training.1600000.processed.noemoticon.csv'\n", + "N_SAMPLES = 5000 # number of tweets to process\n", + "N_PRODUCE = 500 # number of tweets to send through Kafka\n", + "\n", + "sns.set_style('darkgrid')\n", + "plt.rcParams['figure.figsize'] = (12, 5)\n", + "print('Setup complete!')\n", + "print(f'Dataset : {DATASET_PATH}')\n", + "print(f'Samples : {N_SAMPLES}')\n", + "print(f'Kafka : {KAFKA_BROKER}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Load and Explore Sentiment140 Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading 5000 tweets from Sentiment140...\n", + "Loaded 5000 tweets\n", + "\n", + "Dataset overview:\n", + " text label sentiment\n", + "0 @Miss_Hel I still can't help feeling that way. 0 negative\n", + "1 @Jo6789 Indeed I do. http://bit.ly/Iw9j9. Then again we are ESRI NZ Estimating customers in NZ should recieve it sometime in June. 4 positive\n", + "2 @virtualoptions yes @odemagazine is on Twitter 4 positive\n", + "3 @LBsoundsystem Lucky... I want to do that so bad 0 negative\n", + "4 Heading home from Sacramento. Will continue writing the WIndows Server 2008 R2 Unleashed book over the weekend. Sigh #windows 0 negative\n", + "5 WTF?! no pounds lost since I stopped the lemon diet!!!! sux.... 0 negative\n", + "6 @shazamy lucky you! i dont think im going to get to see them the dates just dont work out with my schedule 0 negative\n", + "7 Missing my daughter 0 negative\n", + "8 @restrepita Hospital? What?! 0 negative\n", + "9 It stings ouch 0 negative\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "print(f'Loading {N_SAMPLES} tweets from Sentiment140...')\n", + "df = load_sentiment140(DATASET_PATH, n_samples=N_SAMPLES)\n", + "print(f'Loaded {len(df)} tweets')\n", + "print()\n", + "print('Dataset overview:')\n", + "print(df.head(10).to_string())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment distribution:\n", + "sentiment\n", + "negative 2500\n", + "positive 2500\n", + "Name: count, dtype: int64\n", + "\n", + "Tweet length statistics:\n", + "count 5000.00\n", + "mean 74.13\n", + "std 36.54\n", + "min 8.00\n", + "25% 44.00\n", + "50% 69.00\n", + "75% 104.00\n", + "max 161.00\n", + "Name: tweet_length, dtype: float64\n" + ] + } + ], + "source": [ + "# Summary statistics\n", + "print('Sentiment distribution:')\n", + "print(df['sentiment'].value_counts())\n", + "print()\n", + "print('Tweet length statistics:')\n", + "df['tweet_length'] = df['text'].str.len()\n", + "print(df['tweet_length'].describe().round(2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plot saved as dataset_overview.png\n" + ] + } + ], + "source": [ + "# Visualize dataset\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "# Sentiment distribution\n", + "sentiment_counts = df['sentiment'].value_counts()\n", + "colors = [SENTIMENT_COLORS.get(s, 'gray') for s in sentiment_counts.index]\n", + "axes[0].bar(sentiment_counts.index, sentiment_counts.values, color=colors)\n", + "axes[0].set_title('Sentiment Distribution in Sentiment140 Dataset')\n", + "axes[0].set_xlabel('Sentiment')\n", + "axes[0].set_ylabel('Count')\n", + "for i, v in enumerate(sentiment_counts.values):\n", + " axes[0].text(i, v + 10, str(v), ha='center')\n", + "\n", + "# Tweet length distribution\n", + "for sentiment in ['positive', 'negative']:\n", + " lengths = df[df['sentiment'] == sentiment]['tweet_length']\n", + " axes[1].hist(lengths, alpha=0.6, label=sentiment, bins=30,\n", + " color=SENTIMENT_COLORS[sentiment])\n", + "axes[1].set_title('Tweet Length Distribution by Sentiment')\n", + "axes[1].set_xlabel('Tweet Length (characters)')\n", + "axes[1].set_ylabel('Frequency')\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('dataset_overview.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Plot saved as dataset_overview.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Load Sentiment Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading HuggingFace sentiment model...\n", + "Model: cardiffnlp/twitter-roberta-base-sentiment\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/site-packages/transformers/pipelines/text_classification.py:105: UserWarning: `return_all_scores` is now deprecated, if want a similar functionality use `top_k=None` instead of `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded in 3.63s\n", + "Quick test: \"I love this project!\" -> positive (0.9921)\n" + ] + } + ], + "source": [ + "# Load pre-trained Twitter sentiment model from HuggingFace\n", + "# cardiffnlp/twitter-roberta-base-sentiment is trained on 58M tweets\n", + "print('Loading HuggingFace sentiment model...')\n", + "print('Model: cardiffnlp/twitter-roberta-base-sentiment')\n", + "start = time.time()\n", + "sentiment_model = pipeline(\n", + " 'sentiment-analysis',\n", + " model='cardiffnlp/twitter-roberta-base-sentiment',\n", + " tokenizer='cardiffnlp/twitter-roberta-base-sentiment',\n", + " return_all_scores=False,\n", + " truncation=True,\n", + " max_length=128,\n", + ")\n", + "elapsed = time.time() - start\n", + "print(f'Model loaded in {elapsed:.2f}s')\n", + "\n", + "# Quick test\n", + "test = sentiment_model('I love this project!')[0]\n", + "label = SENTIMENT_LABELS.get(test['label'], test['label'])\n", + "print(f'Quick test: \"I love this project!\" -> {label} ({test[\"score\"]:.4f})')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Publish Tweets to Kafka" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topic \"tweets\" deleted.\n", + "Topic \"tweets\" created fresh!\n", + "Kafka topic is clean and ready!\n" + ] + } + ], + "source": [ + "# Delete existing topic and recreate it fresh\n", + "# This ensures we only process NEW tweets and not old test messages\n", + "from kafka.admin import KafkaAdminClient, NewTopic\n", + "from kafka.errors import TopicAlreadyExistsError, UnknownTopicOrPartitionError\n", + "import time\n", + "\n", + "admin_client = KafkaAdminClient(bootstrap_servers=KAFKA_BROKER)\n", + "# Delete topic if exists\n", + "try:\n", + " admin_client.delete_topics([TOPIC_NAME])\n", + " print(f'Topic \"{TOPIC_NAME}\" deleted.')\n", + " time.sleep(3) # wait for deletion to complete\n", + "except UnknownTopicOrPartitionError:\n", + " print(f'Topic \"{TOPIC_NAME}\" did not exist.')\n", + "\n", + "# Recreate topic\n", + "try:\n", + " topic = NewTopic(name=TOPIC_NAME, num_partitions=3, replication_factor=1)\n", + " admin_client.create_topics([topic])\n", + " print(f'Topic \"{TOPIC_NAME}\" created fresh!')\n", + "except TopicAlreadyExistsError:\n", + " print(f'Topic already exists.')\n", + "finally:\n", + " admin_client.close()\n", + "print('Kafka topic is clean and ready!')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topic \"tweets\" already exists.\n" + ] + } + ], + "source": [ + "# Create Kafka topic\n", + "admin_client = KafkaAdminClient(bootstrap_servers=KAFKA_BROKER)\n", + "try:\n", + " topic = NewTopic(name=TOPIC_NAME, num_partitions=3, replication_factor=1)\n", + " admin_client.create_topics([topic])\n", + " print(f'Topic \"{TOPIC_NAME}\" created!')\n", + "except TopicAlreadyExistsError:\n", + " print(f'Topic \"{TOPIC_NAME}\" already exists.')\n", + "finally:\n", + " admin_client.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Publishing 500 tweets to Kafka topic \"tweets\"...\n", + " Published 100/500 tweets...\n", + " Published 200/500 tweets...\n", + " Published 300/500 tweets...\n", + " Published 400/500 tweets...\n", + " Published 500/500 tweets...\n", + "Done! 500 tweets in 0.09s (5364 tweets/sec)\n" + ] + } + ], + "source": [ + "# Publish tweets to Kafka\n", + "producer = KafkaProducer(\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8'),\n", + ")\n", + "\n", + "df_produce = df.head(N_PRODUCE)\n", + "start_time = time.time()\n", + "print(f'Publishing {N_PRODUCE} tweets to Kafka topic \"{TOPIC_NAME}\"...')\n", + "\n", + "for i, row in df_produce.iterrows():\n", + " event = create_tweet_event(row['text'], row['sentiment'], tweet_id=i)\n", + " producer.send(TOPIC_NAME, key='tweet', value=event)\n", + " if (i + 1) % 100 == 0:\n", + " print(f' Published {i + 1}/{N_PRODUCE} tweets...')\n", + "\n", + "producer.flush()\n", + "producer.close()\n", + "elapsed = time.time() - start_time\n", + "print(f'Done! {N_PRODUCE} tweets in {elapsed:.2f}s ({N_PRODUCE/elapsed:.0f} tweets/sec)')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 5: Consume Tweets and Classify Sentiment" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consuming tweets and classifying sentiment...\n", + " Classified 100 tweets...\n", + " Classified 200 tweets...\n", + " Classified 300 tweets...\n", + " Classified 400 tweets...\n", + " Classified 500 tweets...\n", + "Done! Classified 500 tweets in 37.94s\n" + ] + } + ], + "source": [ + "# Consume tweets from Kafka and classify sentiment\n", + "consumer = KafkaConsumer(\n", + " TOPIC_NAME,\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " auto_offset_reset='earliest',\n", + " enable_auto_commit=True,\n", + " group_id='sentiment-analysis-group',\n", + " value_deserializer=lambda x: json.loads(x.decode('utf-8')),\n", + " consumer_timeout_ms=5000,\n", + ")\n", + "\n", + "classified_results = []\n", + "start_time = time.time()\n", + "print('Consuming tweets and classifying sentiment...')\n", + "\n", + "for msg in consumer:\n", + " event = msg.value\n", + " text = event['text']\n", + " true_label = event['true_label']\n", + "\n", + " # Run sentiment model\n", + " result = sentiment_model(text[:128])[0]\n", + " predicted = SENTIMENT_LABELS.get(result['label'], result['label'])\n", + " score = round(result['score'], 4)\n", + "\n", + " classified_results.append({\n", + " 'tweet_id' : event['tweet_id'],\n", + " 'text' : text,\n", + " 'true_label' : true_label,\n", + " 'predicted_sentiment': predicted,\n", + " 'score' : score,\n", + " 'timestamp' : event['timestamp'],\n", + " })\n", + "\n", + " if len(classified_results) % 100 == 0:\n", + " print(f' Classified {len(classified_results)} tweets...')\n", + "\n", + "consumer.close()\n", + "elapsed = time.time() - start_time\n", + "print(f'Done! Classified {len(classified_results)} tweets in {elapsed:.2f}s')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 6: Sentiment Aggregation and Statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================\n", + "SENTIMENT ANALYSIS RESULTS\n", + "==================================================\n", + "Total tweets analyzed : 500\n", + "Positive : 184 (36.8%)\n", + "Negative : 168 (33.6%)\n", + "Neutral : 148 (29.6%)\n", + "Model accuracy : 57.6%\n", + "\n", + "Sample results:\n", + " text true_label predicted_sentiment score\n", + "0 @user I still can't help feeling that way. negative negative 0.6816\n", + "1 @user Indeed I do. Then again we are ESRI NZ Estimating customers in NZ should recieve it sometime in June. positive positive 0.5013\n", + "2 @user yes @user is on Twitter positive neutral 0.6540\n", + "3 @user Lucky... I want to do that so bad negative neutral 0.3897\n", + "4 Heading home from Sacramento. Will continue writing the WIndows Server 2008 R2 Unleashed book over the weekend. Sigh #windows negative neutral 0.6591\n", + "5 WTF?! no pounds lost since I stopped the lemon diet!!!! sux.... negative negative 0.6458\n", + "6 @user lucky you! i dont think im going to get to see them the dates just dont work out with my schedule negative negative 0.5668\n", + "7 Missing my daughter negative negative 0.5152\n", + "8 @user Hospital? What?! negative negative 0.5763\n", + "9 It stings ouch negative negative 0.9130\n" + ] + } + ], + "source": [ + "# Compute sentiment statistics\n", + "stats = compute_sentiment_stats(classified_results)\n", + "print('=' * 50)\n", + "print('SENTIMENT ANALYSIS RESULTS')\n", + "print('=' * 50)\n", + "print(format_sentiment_summary(stats))\n", + "\n", + "df_results = pd.DataFrame(classified_results)\n", + "print()\n", + "print('Sample results:')\n", + "print(df_results[['text', 'true_label', 'predicted_sentiment', 'score']].head(10).to_string())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 7: Spark SQL Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", + "26/05/08 23:51:58 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spark version: 3.5.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/site-packages/pyspark/sql/pandas/conversion.py:485: FutureWarning: is_datetime64tz_dtype is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.DatetimeTZDtype)` instead.\n", + " if should_localize and is_datetime64tz_dtype(s.dtype) and s.dt.tz is not None:\n", + "[Stage 0:===> (1 + 15) / 16]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spark DataFrame created with 500 rows\n", + "root\n", + " |-- tweet_id: long (nullable = true)\n", + " |-- text: string (nullable = true)\n", + " |-- true_label: string (nullable = true)\n", + " |-- predicted_sentiment: string (nullable = true)\n", + " |-- score: double (nullable = true)\n", + " |-- timestamp: string (nullable = true)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + } + ], + "source": [ + "import findspark\n", + "findspark.init()\n", + "from pyspark.sql import SparkSession\n", + "from pyspark.sql import functions as F\n", + "\n", + "spark = SparkSession.builder \\\n", + " .appName('TweetSentimentAnalysis') \\\n", + " .config('spark.sql.shuffle.partitions', '4') \\\n", + " .getOrCreate()\n", + "spark.sparkContext.setLogLevel('WARN')\n", + "print(f'Spark version: {spark.version}')\n", + "\n", + "# Create Spark DataFrame from results\n", + "spark_df = spark.createDataFrame(df_results)\n", + "spark_df.createOrReplaceTempView('tweet_sentiments')\n", + "print(f'Spark DataFrame created with {spark_df.count()} rows')\n", + "spark_df.printSchema()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark SQL: Sentiment Distribution ===\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/08 23:52:06 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:06 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:06 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:07 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:07 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:07 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + "26/05/08 23:52:07 WARN WindowExec: No Partition Defined for Window operation! Moving all data to a single partition, this can cause serious performance degradation.\n", + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------+-----+----------+--------------+\n", + "|predicted_sentiment|count|percentage|avg_confidence|\n", + "+-------------------+-----+----------+--------------+\n", + "| positive| 184| 36.80| 0.8363|\n", + "| negative| 168| 33.60| 0.7881|\n", + "| neutral| 148| 29.60| 0.6549|\n", + "+-------------------+-----+----------+--------------+\n", + "\n" + ] + } + ], + "source": [ + "# Spark SQL Query 1: Sentiment distribution\n", + "print('=== Spark SQL: Sentiment Distribution ===')\n", + "spark.sql(\"\"\"\n", + " SELECT\n", + " predicted_sentiment,\n", + " COUNT(*) as count,\n", + " ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 2) as percentage,\n", + " ROUND(AVG(score), 4) as avg_confidence\n", + " FROM tweet_sentiments\n", + " GROUP BY predicted_sentiment\n", + " ORDER BY count DESC\n", + "\"\"\").show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark SQL: Prediction Accuracy ===\n", + "+----------+-------------------+-----+--------------+\n", + "|true_label|predicted_sentiment|count|avg_confidence|\n", + "+----------+-------------------+-----+--------------+\n", + "| negative| negative| 147| 0.7991|\n", + "| negative| neutral| 73| 0.6096|\n", + "| negative| positive| 43| 0.767|\n", + "| positive| positive| 141| 0.8575|\n", + "| positive| neutral| 75| 0.6991|\n", + "| positive| negative| 21| 0.711|\n", + "+----------+-------------------+-----+--------------+\n", + "\n" + ] + } + ], + "source": [ + "# Spark SQL Query 2: Accuracy analysis\n", + "print('=== Spark SQL: Prediction Accuracy ===')\n", + "spark.sql(\"\"\"\n", + " SELECT\n", + " true_label,\n", + " predicted_sentiment,\n", + " COUNT(*) as count,\n", + " ROUND(AVG(score), 4) as avg_confidence\n", + " FROM tweet_sentiments\n", + " WHERE true_label != 'neutral'\n", + " GROUP BY true_label, predicted_sentiment\n", + " ORDER BY true_label, count DESC\n", + "\"\"\").show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark SQL: High Confidence Predictions (score > 0.9) ===\n", + "+-------------------+---------------------+---------+---------+\n", + "|predicted_sentiment|high_confidence_count|avg_score|max_score|\n", + "+-------------------+---------------------+---------+---------+\n", + "| positive| 97| 0.9603| 0.9928|\n", + "| negative| 56| 0.9415| 0.9816|\n", + "| neutral| 3| 0.9227| 0.9379|\n", + "+-------------------+---------------------+---------+---------+\n", + "\n", + "Spark session stopped.\n" + ] + } + ], + "source": [ + "# Spark SQL Query 3: High confidence predictions\n", + "print('=== Spark SQL: High Confidence Predictions (score > 0.9) ===')\n", + "spark.sql(\"\"\"\n", + " SELECT\n", + " predicted_sentiment,\n", + " COUNT(*) as high_confidence_count,\n", + " ROUND(AVG(score), 4) as avg_score,\n", + " ROUND(MAX(score), 4) as max_score\n", + " FROM tweet_sentiments\n", + " WHERE score > 0.9\n", + " GROUP BY predicted_sentiment\n", + " ORDER BY high_confidence_count DESC\n", + "\"\"\").show()\n", + "\n", + "spark.stop()\n", + "print('Spark session stopped.')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 8: Visualizations" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plot saved as sentiment_distribution.png\n" + ] + } + ], + "source": [ + "# Plot 1: Predicted sentiment distribution\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "pred_counts = df_results['predicted_sentiment'].value_counts()\n", + "colors = [SENTIMENT_COLORS.get(s, 'gray') for s in pred_counts.index]\n", + "axes[0].bar(pred_counts.index, pred_counts.values, color=colors)\n", + "axes[0].set_title('Predicted Sentiment Distribution')\n", + "axes[0].set_xlabel('Sentiment')\n", + "axes[0].set_ylabel('Count')\n", + "for i, v in enumerate(pred_counts.values):\n", + " axes[0].text(i, v + 2, str(v), ha='center')\n", + "\n", + "# Confidence score distribution\n", + "for sentiment in df_results['predicted_sentiment'].unique():\n", + " scores = df_results[df_results['predicted_sentiment'] == sentiment]['score']\n", + " axes[1].hist(scores, alpha=0.6, label=sentiment, bins=20,\n", + " color=SENTIMENT_COLORS.get(sentiment, 'gray'))\n", + "axes[1].set_title('Model Confidence Score Distribution')\n", + "axes[1].set_xlabel('Confidence Score')\n", + "axes[1].set_ylabel('Count')\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('sentiment_distribution.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Plot saved as sentiment_distribution.png')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall Accuracy: 288/352 = 81.82%\n" + ] + } + ], + "source": [ + "# Plot 2: Confusion matrix (true vs predicted)\n", + "df_binary = df_results[df_results[\"true_label\"].isin([\"positive\", \"negative\"])].copy()\n", + "df_binary = df_binary[df_binary[\"predicted_sentiment\"].isin([\"positive\", \"negative\"])]\n", + "\n", + "import numpy as np\n", + "labels = [\"positive\", \"negative\"]\n", + "cm = [[0, 0], [0, 0]]\n", + "for i, true in enumerate(labels):\n", + " for j, pred in enumerate(labels):\n", + " cm[i][j] = len(df_binary[(df_binary[\"true_label\"] == true) & (df_binary[\"predicted_sentiment\"] == pred)])\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "cm_array = np.array(cm)\n", + "sns.heatmap(cm_array, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=labels, yticklabels=labels, ax=axes[0])\n", + "axes[0].set_title(\"Confusion Matrix: True vs Predicted Sentiment\")\n", + "axes[0].set_xlabel(\"Predicted\")\n", + "axes[0].set_ylabel(\"True\")\n", + "\n", + "accuracy_by_label = df_binary.groupby(\"true_label\").apply(lambda x: (x[\"predicted_sentiment\"] == x[\"true_label\"]).mean() * 100).round(2)\n", + "accuracy_by_label.plot(kind=\"bar\", ax=axes[1], color=[SENTIMENT_COLORS[\"positive\"], SENTIMENT_COLORS[\"negative\"]])\n", + "axes[1].set_title(\"Model Accuracy by True Sentiment Label\")\n", + "axes[1].set_xlabel(\"True Label\")\n", + "axes[1].set_ylabel(\"Accuracy (%)\")\n", + "axes[1].tick_params(axis=\"x\", rotation=0)\n", + "axes[1].set_ylim(0, 100)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"confusion_matrix.png\", dpi=100, bbox_inches=\"tight\")\n", + "plt.show()\n", + "\n", + "correct = sum(df_binary[\"true_label\"] == df_binary[\"predicted_sentiment\"])\n", + "total = len(df_binary)\n", + "print(f\"Overall Accuracy: {correct}/{total} = {correct/total*100:.2f}%\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Word cloud saved as wordclouds.png\n" + ] + } + ], + "source": [ + "# Plot 3: Word clouds for positive and negative tweets\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "for idx, sentiment in enumerate(['positive', 'negative']):\n", + " tweets = ' '.join(df_results[df_results['predicted_sentiment'] == sentiment]['text'].tolist())\n", + " wordcloud = WordCloud(\n", + " width=600, height=400,\n", + " background_color='white',\n", + " colormap='Greens' if sentiment == 'positive' else 'Reds',\n", + " max_words=100\n", + " ).generate(tweets)\n", + " axes[idx].imshow(wordcloud, interpolation='bilinear')\n", + " axes[idx].axis('off')\n", + " axes[idx].set_title(f'Most Common Words in {sentiment.capitalize()} Tweets')\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('wordclouds.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Word cloud saved as wordclouds.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 9: Performance Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 50: 0.015s | 3364 tweets/sec\n", + "Batch 100: 0.019s | 5275 tweets/sec\n", + "Batch 200: 0.220s | 908 tweets/sec\n", + "Batch 500: 0.087s | 5732 tweets/sec\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Throughput plot saved!\n" + ] + } + ], + "source": [ + "# Throughput test\n", + "producer = KafkaProducer(\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8'),\n", + ")\n", + "batch_sizes = [50, 100, 200, 500]\n", + "throughputs = []\n", + "for batch in batch_sizes:\n", + " df_batch = df.sample(batch)\n", + " start = time.time()\n", + " for i, row in df_batch.iterrows():\n", + " event = create_tweet_event(row['text'], row['sentiment'], tweet_id=i)\n", + " producer.send(TOPIC_NAME, key='tweet', value=event)\n", + " producer.flush()\n", + " elapsed = time.time() - start\n", + " tput = batch / elapsed\n", + " throughputs.append(tput)\n", + " print(f'Batch {batch:4d}: {elapsed:.3f}s | {tput:.0f} tweets/sec')\n", + "producer.close()\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(batch_sizes, throughputs, marker='o', color='steelblue', linewidth=2)\n", + "plt.title('Kafka Producer Throughput vs Batch Size')\n", + "plt.xlabel('Batch Size')\n", + "plt.ylabel('Throughput (tweets/sec)')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.savefig('throughput.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Throughput plot saved!')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 10: Summary and Conclusions" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "PIPELINE SUMMARY\n", + "============================================================\n", + "Dataset : Sentiment140 (1.6M tweets, sampled 5000)\n", + "Model : cardiffnlp/twitter-roberta-base-sentiment\n", + "Tweets produced: 500\n", + "Tweets consumed: 500\n", + "\n", + "Total tweets analyzed : 500\n", + "Positive : 184 (36.8%)\n", + "Negative : 168 (33.6%)\n", + "Neutral : 148 (29.6%)\n", + "Model accuracy : 57.6%\n", + "\n", + "Conclusions:\n", + " - Apache Kafka successfully streamed tweets in real time\n", + " - Pre-trained RoBERTa model classified sentiment without fine-tuning\n", + " - Spark SQL provided efficient batch aggregation and accuracy analysis\n", + " - Word clouds revealed common themes in positive and negative tweets\n", + " - Pipeline is scalable and runs fully locally via Docker\n" + ] + } + ], + "source": [ + "print('=' * 60)\n", + "print('PIPELINE SUMMARY')\n", + "print('=' * 60)\n", + "print(f'Dataset : Sentiment140 (1.6M tweets, sampled {N_SAMPLES})')\n", + "print(f'Model : cardiffnlp/twitter-roberta-base-sentiment')\n", + "print(f'Tweets produced: {N_PRODUCE}')\n", + "print(f'Tweets consumed: {len(classified_results)}')\n", + "print()\n", + "print(format_sentiment_summary(stats))\n", + "print()\n", + "print('Conclusions:')\n", + "print(' - Apache Kafka successfully streamed tweets in real time')\n", + "print(' - Pre-trained RoBERTa model classified sentiment without fine-tuning')\n", + "print(' - Spark SQL provided efficient batch aggregation and accuracy analysis')\n", + "print(' - Word clouds revealed common themes in positive and negative tweets')\n", + "print(' - Pipeline is scalable and runs fully locally via Docker')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 10: Sentiment Trend Over Time\n", + "Visualize how sentiment evolves as tweets stream through the pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment trend plot saved as sentiment_trend.png\n" + ] + } + ], + "source": [ + "# Sentiment trend over time\n", + "# Shows how sentiment evolves as tweets are processed in real time\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "df_trend = pd.DataFrame(classified_results)\n", + "df_trend['timestamp'] = pd.to_datetime(df_trend['timestamp'])\n", + "df_trend = df_trend.sort_values('timestamp').reset_index(drop=True)\n", + "\n", + "# Compute rolling sentiment counts (window of 50 tweets)\n", + "window = 50\n", + "df_trend['is_positive'] = (df_trend['predicted_sentiment'] == 'positive').astype(int)\n", + "df_trend['is_negative'] = (df_trend['predicted_sentiment'] == 'negative').astype(int)\n", + "df_trend['is_neutral'] = (df_trend['predicted_sentiment'] == 'neutral').astype(int)\n", + "\n", + "df_trend['rolling_positive'] = df_trend['is_positive'].rolling(window, min_periods=1).mean() * 100\n", + "df_trend['rolling_negative'] = df_trend['is_negative'].rolling(window, min_periods=1).mean() * 100\n", + "df_trend['rolling_neutral'] = df_trend['is_neutral'].rolling(window, min_periods=1).mean() * 100\n", + "\n", + "# Plot sentiment trend\n", + "fig, axes = plt.subplots(2, 1, figsize=(14, 10))\n", + "\n", + "# Rolling sentiment percentage\n", + "axes[0].plot(df_trend.index, df_trend['rolling_positive'],\n", + " label='Positive', color=SENTIMENT_COLORS['positive'], linewidth=2)\n", + "axes[0].plot(df_trend.index, df_trend['rolling_negative'],\n", + " label='Negative', color=SENTIMENT_COLORS['negative'], linewidth=2)\n", + "axes[0].plot(df_trend.index, df_trend['rolling_neutral'],\n", + " label='Neutral', color=SENTIMENT_COLORS['neutral'], linewidth=2)\n", + "axes[0].set_title(f'Real-Time Sentiment Trend (Rolling {window}-tweet window)')\n", + "axes[0].set_xlabel('Tweet Index')\n", + "axes[0].set_ylabel('Sentiment % in Window')\n", + "axes[0].legend()\n", + "axes[0].set_ylim(0, 100)\n", + "\n", + "# Cumulative sentiment counts\n", + "df_trend['cum_positive'] = df_trend['is_positive'].cumsum()\n", + "df_trend['cum_negative'] = df_trend['is_negative'].cumsum()\n", + "df_trend['cum_neutral'] = df_trend['is_neutral'].cumsum()\n", + "\n", + "axes[1].plot(df_trend.index, df_trend['cum_positive'],\n", + " label='Positive', color=SENTIMENT_COLORS['positive'], linewidth=2)\n", + "axes[1].plot(df_trend.index, df_trend['cum_negative'],\n", + " label='Negative', color=SENTIMENT_COLORS['negative'], linewidth=2)\n", + "axes[1].plot(df_trend.index, df_trend['cum_neutral'],\n", + " label='Neutral', color=SENTIMENT_COLORS['neutral'], linewidth=2)\n", + "axes[1].set_title('Cumulative Sentiment Counts Over Time')\n", + "axes[1].set_xlabel('Tweet Index')\n", + "axes[1].set_ylabel('Cumulative Count')\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('sentiment_trend.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Sentiment trend plot saved as sentiment_trend.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 11: Comparative Model Analysis\n", + "Compare RoBERTa (tweet-specific) vs DistilBERT (general text) on the same tweets." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading second model for comparison: distilbert-base-uncased-finetuned-sst-2-english\n", + "DistilBERT model loaded!\n", + "Running comparison on 100 tweets...\n", + "\n", + "==================================================\n", + "MODEL COMPARISON RESULTS (100 tweets)\n", + "==================================================\n", + "RoBERTa (twitter-roberta-base-sentiment):\n", + " Accuracy : 55.00%\n", + " Avg confidence: 0.7596\n", + "\n", + "DistilBERT (distilbert-base-uncased-finetuned-sst-2):\n", + " Accuracy : 73.00%\n", + " Avg confidence: 0.9595\n", + "\n", + "Winner: DistilBERT\n", + "Note: RoBERTa is trained specifically on tweets, making it better\n", + "suited for this task compared to DistilBERT which is trained on\n", + "general text (SST-2 movie reviews dataset).\n" + ] + } + ], + "source": [ + "# Comparative Analysis: RoBERTa vs DistilBERT\n", + "# Compare two pre-trained models on the same set of tweets\n", + "print('Loading second model for comparison: distilbert-base-uncased-finetuned-sst-2-english')\n", + "from transformers import pipeline\n", + "\n", + "distilbert_model = pipeline(\n", + " 'sentiment-analysis',\n", + " model='distilbert-base-uncased-finetuned-sst-2-english',\n", + " truncation=True,\n", + " max_length=128,\n", + ")\n", + "print('DistilBERT model loaded!')\n", + "\n", + "# Compare on a sample of 100 tweets\n", + "sample_tweets = df.head(100)\n", + "roberta_results = []\n", + "distilbert_results = []\n", + "\n", + "print('Running comparison on 100 tweets...')\n", + "for _, row in sample_tweets.iterrows():\n", + " text = row['text'][:128]\n", + " true_label = row['sentiment']\n", + "\n", + " # RoBERTa prediction\n", + " r = sentiment_model(text)[0]\n", + " roberta_pred = SENTIMENT_LABELS.get(r['label'], r['label'])\n", + " roberta_results.append({\n", + " 'true_label': true_label,\n", + " 'predicted': roberta_pred,\n", + " 'score': r['score'],\n", + " 'correct': roberta_pred == true_label\n", + " })\n", + "\n", + " # DistilBERT prediction (maps POSITIVE/NEGATIVE)\n", + " d = distilbert_model(text)[0]\n", + " distilbert_pred = d['label'].lower()\n", + " distilbert_results.append({\n", + " 'true_label': true_label,\n", + " 'predicted': distilbert_pred,\n", + " 'score': d['score'],\n", + " 'correct': distilbert_pred == true_label\n", + " })\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "df_roberta = pd.DataFrame(roberta_results)\n", + "df_distilbert = pd.DataFrame(distilbert_results)\n", + "\n", + "roberta_acc = df_roberta['correct'].mean() * 100\n", + "distilbert_acc = df_distilbert['correct'].mean() * 100\n", + "roberta_conf = df_roberta['score'].mean()\n", + "distilbert_conf = df_distilbert['score'].mean()\n", + "\n", + "print()\n", + "print('=' * 50)\n", + "print('MODEL COMPARISON RESULTS (100 tweets)')\n", + "print('=' * 50)\n", + "print(f'RoBERTa (twitter-roberta-base-sentiment):')\n", + "print(f' Accuracy : {roberta_acc:.2f}%')\n", + "print(f' Avg confidence: {roberta_conf:.4f}')\n", + "print()\n", + "print(f'DistilBERT (distilbert-base-uncased-finetuned-sst-2):')\n", + "print(f' Accuracy : {distilbert_acc:.2f}%')\n", + "print(f' Avg confidence: {distilbert_conf:.4f}')\n", + "print()\n", + "winner = 'RoBERTa' if roberta_acc > distilbert_acc else 'DistilBERT'\n", + "print(f'Winner: {winner}')\n", + "print('Note: RoBERTa is trained specifically on tweets, making it better')\n", + "print('suited for this task compared to DistilBERT which is trained on')\n", + "print('general text (SST-2 movie reviews dataset).')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAHqCAYAAAB/bWzAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAACVpklEQVR4nOzdd1gU19vG8XupdkXAiiVqsCGKJUZsUYkNW+w99hJbTLElv6ixJSbG3qLGXmPH3mKJolFjj5rYC0oAK4KCsO8fvmzcgAqK7Jr9fq7Ly90zZ2ae2dllzj575hyD0Wg0CgAAAAAAAABgFewsHQAAAAAAAAAA4B8kbQEAAAAAAADAipC0BQAAAAAAAAArQtIWAAAAAAAAAKwISVsAAAAAAAAAsCIkbQEAAAAAAADAipC0BQAAAAAAAAArQtIWAAAAAAAAAKwISVsAAAAAAAAAsCIkbQFYjYIFC2rixIlJXu/atWsqWLCgVq5c+RqiAuJr06aN2rRpY+kwAACAjZo4caIKFiz4UusOGDBAVatWTeaIXo/Vq1erZs2aKlq0qEqXLi0p8e2wAwcOqGDBgjpw4MDrDhMpoGrVqhowYIClwwBSFElbAGZWrlypggULqmDBgjp06FC85UajUZUrV1bBggXVtWtXC0SYPHbt2qWCBQuqQoUKio2NtXQ4b5zw8HBNmjRJ9erVk4+Pj7y9vVWnTh199913Cg4OtnR4AAAgGS1cuFAFCxZUkyZNLB2K1alataoKFiyodu3aJbh82bJlprb1iRMnUja4ZLJ161Z16tRJZcuWlZeXlypUqKA+ffooMDDwte73/PnzGjhwoHLnzq1hw4bp66+/fq37s3ahoaH69ttvVbNmTRUvXlwlSpRQw4YNNWXKFN27d8/S4QF4DRwsHQAA6+Ts7Kx169aZftGO89tvv+nmzZtycnKyUGTJY+3atcqZM6euX7+u/fv3y9fX19IhvTGuXr2qdu3a6caNG6pZs6aaNWsmR0dHnT17VsuXL9e2bdu0efNmS4f5Ws2aNcvSIQAAkGICAgKUM2dOHT9+XJcvX1aePHksHZJVcXZ21oEDBxQSEiJ3d3ezZQEBAXJ2dtajR48sFN3LMxqNGjRokFauXKkiRYqoffv2cnNzU0hIiLZu3ap27dpp8eLFKlmy5GvZ/2+//abY2Fh98cUXZu85W2yHHT9+XF26dFFERITq1aunokWLSpJOnjypGTNm6NChQ/rpp58sHOXrtWnTJhkMBkuHAaQokrYAElS5cmVt2rRJX375pRwc/vlTsW7dOhUtWlR37tyxXHCvKCIiQjt27NAnn3yilStXKiAgwGqTthEREUqTJo2lwzB5/PixevbsqbCwMM2bNy9eUr9v376aMWOGhaJ7/SIjI5U6deo3/kcLAAAS6+rVqzpy5IgmTZqkr776SgEBAerZs2eKxhAbG6vo6Gg5Ozun6H4Tq2TJkjpx4oQ2bNigDz/80FR+8+ZNHTp0SO+///4b+YP2Tz/9pJUrV+rDDz/UwIEDzRJm3bt31+rVq82+JyS3sLAwSVL69OnNym2tHXbv3j317NlT9vb2WrVqlfLnz2+2vG/fvlq2bJmFonu9jEajHj16pFSpUtnceQckhkcA8Az+/v66c+eO9u7dayqLiorS5s2bVbdu3QTXiYiI0DfffKPKlSvLy8tLNWrU0KxZs2Q0Gs3qRUVFaeTIkXr33Xfl4+Ojbt266ebNmwluMzg4WAMHDpSvr6+8vLzk7++v5cuXv9Kxbd26VQ8fPlTNmjVVu3ZtbdmyJcHeD48ePdLEiRNVo0YNFStWTBUqVFDPnj115coVU53Y2FjNnTtXdevWVbFixfTuu++qY8eOptvfnjfe7r/H8I0bm+zcuXP69NNPVaZMGbVs2VKSdObMGQ0YMEDVqlVTsWLFVL58eQ0cOFC3b99O8DUbNGiQKlSoIC8vL1WtWlWDBw9WVFSUrl69qoIFC2rOnDnx1vv9999VsGBBrVu37pmv3ZYtW3TmzBl169YtXsJWktKlS6e+ffualW3cuFENGzaUt7e3ypYtq88++yzeEAoDBgyQj4+PgoKC1LVrV/n4+KhixYpauHChJOns2bNq27atSpQooSpVqiggIMBs/bhhPQ4ePKivvvpKZcuWVcmSJdWvXz/dvXvXrO62bdvUpUsX0+vj5+enyZMnKyYmxqxemzZtVKdOHZ08eVKtWrVS8eLF9cMPP5iW/Xsstfnz58vf31/FixdXmTJl1LBhw3hx/vHHH+rUqZNKliwpHx8fffjhhzp69GiCx3L48GGNGjVK7777rkqUKKEePXro1q1bCZ0WAABem4CAAGXMmFGVK1dWjRo1zK5t0dHReueddzRw4MB464WHh6tYsWL69ttvTWVRUVGaMGGC3n//fXl5ealy5coaPXq0oqKizNYtWLCgvv76a61du1b+/v4qVqyY9uzZI+lJL8vmzZurbNmy8vb2VsOGDbVp06Z4+3/48KGGDx+usmXLmtqbwcHBCc6h8KrtTWdnZ1WvXj1eG2rdunXKkCGDKlSokOB6gYGBatmypUqUKKHSpUure/fuOn/+fLx6hw4dUqNGjVSsWDH5+flpyZIlz4xlzZo1pnbXO++8o759++rGjRuJPpY4Dx8+1I8//qh8+fKpf//+CfZwbNCggby9vU3Pr169qt69e+udd95R8eLF1bRpU+3cudNsnbhxZjds2KCpU6eqUqVKKlasmD788ENdvnzZVK9q1aqm81SuXDmz85ZQO+zmzZv66KOPVKJECZUrV04jR46M976Kc+zYMXXs2FGlSpVS8eLF1bp1ax0+fNisTly7/PLlyxowYIBKly6tUqVKaeDAgYqMjIy3zTVr1qhx48amdmCrVq3066+/mtXZtWuX6Xz7+PioS5cu+uuvvxKM8WlLlixRcHCwBgwYEC9hK0lubm766KOPzMoWLlwof39/03AWQ4cOjTeEQlxb98yZM2rdurWKFy+u999/3/R5+u2339SkSRN5e3urRo0a2rdvX4Kv0fnz59WnTx+VLFlSZcuW1fDhw+N9t1qxYoXatm2rcuXKycvLS7Vr19aiRYviHUvVqlXVtWtX7dmzx/Q+jnu//3tM2+joaE2aNEnVq1dXsWLFVLZsWbVo0cLs+6uUuM9ZUs83kFLoaQsgQTlz5lSJEiW0fv16Va5cWZK0e/du3b9/X7Vr19b8+fPN6huNRnXv3l0HDhxQ48aNVbhwYe3Zs0ejR482JRHjfPHFF1q7dq3q1KmjkiVLav/+/erSpUu8GEJDQ9W0aVMZDAa1atVKmTNn1u7du/XFF18oPDz8mWOHvUhAQIDKli0rd3d3+fv7a8yYMdqxY4dq1aplqhMTE6OuXbsqMDBQ/v7+atu2rR48eKC9e/fqzz//VO7cuU3HsnLlSlWqVEmNGzdWTEyMDh06pGPHjqlYsWIvFV+fPn2UJ08e9e3b15Tw3rdvn65evaqGDRvK3d1df/31l5YtW6Zz585p2bJlpoZ0cHCwGjdurPv376tp06bKly+fgoODtXnzZj18+FC5cuVSyZIltXbt2nivX0BAgNKmTatq1ao9M7bt27dLkurXr5+oY1m5cqUGDhyoYsWK6ZNPPjH10P3999+1evVqZciQwVQ3JiZGnTt3VunSpfXZZ58pICBAX3/9tVKnTq2xY8eqbt26ql69upYsWaL+/furRIkSypUrl9n+vv76a2XIkEE9e/bUxYsXtXjxYgUFBWn+/Pmm12jVqlVKkyaN2rdvrzRp0mj//v2aMGGCwsPD1b9/f7Pt3blzR507d5a/v7/q1asnV1fXBI9z2bJlGj58uGrUqKG2bdvq0aNHOnv2rI4dO2b6keOvv/5Sq1atlDZtWnXq1EkODg5aunSp2rRpowULFqh48eJm2xw+fLjpWK5fv665c+fq66+/1rhx4xL12gMAkBwCAgL0/vvvy8nJSXXq1NHixYt1/PhxeXt7y9HRUX5+ftq6dauGDh1q1hNu27ZtioqKUu3atSU9+aG7e/fuOnz4sJo2bar8+fPrzz//1Ny5c3Xp0iVNmTLFbL/79+/Xxo0b1apVK7m4uChnzpySpHnz5qlq1aqqW7euoqOjtX79evXp00fTp0/Xe++9Z1p/wIAB2rhxo+rXr6/ixYvr4MGDr7W9WadOHXXo0EFXrlwxtRPXrVunGjVqJNgbdd++fercubM8PDzUs2dPPXz4UAsWLFCLFi20cuVKeXh4SHryw3XHjh2VOXNm9erVS48fP9bEiRMTbJNMnTpV48ePV61atdS4cWPdunVLCxYsUKtWreK1u17k8OHDunPnjtq2bSt7e/sX1g8NDVXz5s0VGRmpNm3ayMXFRatWrVL37t1NifqnzZgxQwaDQR06dFB4eLhmzpypzz77TD///LMkadCgQVq9erW2bt2qIUOGKE2aNM+ceO3hw4f68MMPdePGDbVp00ZZsmTRmjVrtH///nh1AwMD1blzZ3l5ealnz54yGAym3sSLFi0yS0JL0scffywPDw998skn+uOPP/Tzzz8rc+bM+vzzz011Jk2apIkTJ8rHx0e9e/eWo6Ojjh07pv3795sS9qtXr9aAAQNUoUIFffbZZ4qMjNTixYvVsmVLrVq1ynS+E7Jjxw6lSpVKNWrUeOF5kJ4kICdNmiRfX1+1aNHC1CY+ceKEFi9eLEdHR1Pdu3fvqlu3bqpdu7Zq1qypxYsX65NPPlFsbKxGjhyp5s2bq06dOpo1a5Z69+6tnTt3Kl26dPFeo5w5c+rTTz/V0aNHNX/+fN27d0+jR4821Vm8eLHefvttVa1aVQ4ODvrll180dOhQGY1GtWrVymx7Fy9e1KeffqpmzZqpadOmeuuttxI8zkmTJmn69OmmxHJ4eLhOnjypU6dOqXz58pIS/zl7+lhedL6BFGUEgKesWLHC6OnpaTx+/LhxwYIFRh8fH2NkZKTRaDQae/fubWzTpo3RaDQaq1SpYuzSpYtpva1btxo9PT2NU6ZMMdter169jAULFjRevnzZaDQajadPnzZ6enoahwwZYlbvk08+MXp6ehonTJhgKhs0aJCxfPnyxlu3bpnV7du3r7FUqVKmuK5evWr09PQ0rlix4oXHFxoaaixSpIhx2bJlprJmzZoZu3fvblZv+fLlRk9PT+Ps2bPjbSM2NtZoNBqNgYGBRk9PT+OwYcOeWed5sf37eCdMmGD09PQ0fvLJJ/Hqxh3r09atW2f09PQ0Hjx40FTWr18/Y6FChYzHjx9/ZkxLliwxenp6Gs+dO2daFhUVZSxbtqyxf//+8dZ7WoMGDYylSpV6bp2nt1muXDljnTp1jA8fPjSV//LLL0ZPT0/j+PHjTWX9+/c3enp6GqdNm2Yqu3v3rtHb29tYsGBB4/r1603l58+fj/faxb1vP/jgA2NUVJSpfMaMGUZPT0/jtm3bTGUJvZb/+9//jMWLFzc+evTIVNa6dWujp6encfHixfHqt27d2ti6dWvT8+7duxv9/f2f+3p89NFHxqJFixqvXLliKgsODjb6+PgYW7VqFe9Y2rVrZzpnRqPROHLkSGPhwoWN9+7de+5+AABILidOnDB6enoa9+7dazQan7QlKlWqZBw+fLipzp49e4yenp7GHTt2mK3buXNnY7Vq1UzPV69ebSxUqJBZu8VoNBoXL15s9PT0NB4+fNhU5unpaSxUqJDxr7/+ihfTv6/jUVFRxjp16hjbtm1rKjt58qTR09PTOGLECLO6AwYMeOn25rPEtYkfP35sLF++vHHy5MlGo9FoPHfunNHT09P422+/mbWv49SvX99Yrlw54+3bt01lp0+fNhYqVMjYr18/U9lHH31kLFasmPH69eumsnPnzhkLFy5s9PT0NJVdu3bNWLhwYePUqVPN4jt79qyxSJEiZuX9+/c3VqlS5bnHNXfuXKOnp6dx69atz60XZ8SIEfHapeHh4caqVasaq1SpYoyJiTEajUbj/v37jZ6ensZatWqZtbvi9nf27FlTWVzbOCwszGxf/26HzZkzx+jp6WncsGGDqSwiIsL4/vvvGz09PY379+83Go1P3r/Vq1c3dujQwayNFRkZaaxataqxffv28fY9cOBAs3336NHD+M4775ieX7p0yVioUCFjjx49TMcYJ24f4eHhxtKlSxu//PJLs+UhISHGUqVKxSv/tzJlyhjr1av33DpxwsLCjEWLFjV26NDBLJ4FCxYYPT09jcuXLzeVxbV1AwICTGVx7exChQoZjx49aiqP+5w//Z0m7jXq1q2bWQxDhgwxenp6Gk+fPm0qS+hz1KFDB7O/EUbjk8+Tp6encffu3fHqV6lSxey7Sr169cy+jyYksZ+zxJ5vIKUxPAKAZ6pVq5YePXqkX375ReHh4dq5c+czh0bYvXu37O3t492q1KFDBxmNRu3evVvSk9uCJMWr9/T4X9KTnrtbtmxR1apVZTQadevWLdO/ChUq6P79+zp16lSSj2n9+vUyGAyqXr26qaxOnTravXu32W30W7ZskYuLi1q3bh1vG3E9Nrds2SKDwZDguG6vMkh+8+bN45WlSpXK9PjRo0e6deuWqWdm3OsQGxurbdu2qUqVKgn28o2LqVatWnJ2dja7vfHXX3/V7du3Va9evefGFh4errRp0ybqOE6ePKmwsDC1aNHCbAy69957T/ny5Yt3u5wks1mpM2TIoLfeekupU6c26wWdL18+ZciQQVevXo23ftykaHFatGghBwcH0/tOMn8tw8PDdevWLZUuXVqRkZG6cOGC2facnJzUsGHDFx5rhgwZdPPmTR0/fjzB5TExMdq7d6/8/PzMegdnyZJFderU0eHDhxUeHm62TlyvnzilS5dWTEyMrl+//sJ4AABIDgEBAXJzc1PZsmUlPWlL1K5dWxs2bDANK/Tuu+/KxcVFGzZsMK139+5d7du3z9TLVnoyiVD+/PmVL18+s3bdu+++K+nJbfNPK1OmjAoUKBAvpqev43fv3tX9+/dVqlQp/fHHH6byuKEU4oaZivPvdl1ytjft7e1Vs2ZNrV+/XtKTSW+zZ8+e4HBSf//9t06fPq0PPvhAmTJlMpUXKlRIvr6+pnZLTEyMfv31V/n5+SlHjhymevnz54835MLWrVsVGxurWrVqmR2Hm5ub8uTJE+/1fZG4dkli2327du2St7e32fGmTZtWzZo10/Xr13Xu3Dmz+g0bNjTrmR23XkLtuxfZvXu33N3dVbNmTVNZ6tSp1bRpU7N6p0+f1qVLl1S3bl3dvn3b9BpFRESoXLlyOnjwoGJjY83W+Xe7vHTp0rpz547p9dm2bZtiY2PVo0cP2dmZp1fi2nH79u3TvXv35O/vb3Zu7OzsVLx48Reem6S0v/ft26fo6Gi1bdvWLJ4mTZooXbp0Zm1iSUqTJo38/f1Nz+Pa2fnz5ze7CyzucULn5989ZeM+Z3Hf/yTzz+39+/d169YtvfPOO7p69aru379vtr6Hh4cqVqz4wmPNkCGD/vrrL126dCnB5Yn9nD3tRecbSGkMjwDgmTJnzqxy5cpp3bp1evjwoWJiYp55W87169eVJUuWeLfLxI27FJdoun79uuzs7Ey3jcXJly+f2fNbt27p3r17Wrp0qZYuXZrgPl9mfM+1a9fK29tbd+7cMU2mVrhwYUVHR2vTpk1q1qyZJOnKlSt66623nju5wpUrV5QlSxazRkBySOj2qDt37mjSpEnasGGDaVKGOHENnVu3bik8PFxvv/32c7efIUMGValSRevWrdPHH38s6cmXsqxZs5q+OD1LunTpEt2YDgoKkqQEb2nKly9fvLHDnJ2dlTlzZrOy9OnTK1u2bPGS4OnTp483LpekeLNZp02bVu7u7maJzr/++kvjxo3T/v374zXA/t1ozJo1a6ImPejcubP27dunJk2aKE+ePCpfvrzq1KmjUqVKSXpybiIjIxN8LfLnz6/Y2FjduHHD7Nw9/eVMkumWxoSOGwCA5BYTE6P169erbNmyunbtmqnc29tbP/30kwIDA1WhQgU5ODiYxnONioqSk5OTtmzZoujoaLOk7eXLl3X+/HmVK1cuwf39u33zrNvFf/nlF02dOlWnT582G7P06bZCUFCQ7Ozs4m3j3+2E5G5v1q1bV/Pnz9eZM2e0bt061a5dO8Ef8p/XRsqfP79+/fVXRURE6MGDB3r48GG8uOPWfTrpdOnSJRmNRrOOCU9L6oRhcW36Bw8eJKp+UFBQvKGepH/a+EFBQfL09DSVJ2c75/r168qTJ0+81/rfr29ccu/fw2E97f79+8qYMeML47x7967SpUunK1euyM7OLsGxZv+93393Uonz7+9PCS1PynmQ4n+3cnJyUq5cueL9+P+sdna2bNnilUkJn59/vz9z584tOzs7s78bhw8f1sSJE3X06NF4Y8Tev3/fbLK55w0V8bTevXvro48+Uo0aNeTp6akKFSqofv36KlSokKTEf86envT5RecbSGkkbQE8V506dfS///1PoaGhqlSpUpLGwnoVcb9y16tXTx988EGCdZ41rtWzXLp0yTRBWEIN2oCAAFPSNrk8q8ftvye9elpCMyN//PHHOnLkiDp27KjChQsrTZo0io2NVadOneJN9JYYDRo00KZNm/T777/L09NTO3bsUIsWLeL1EPi3fPny6Y8//tCNGzeUPXv2JO/3eZ41Xtqzyl/muO/du6fWrVsrXbp06t27t3Lnzi1nZ2edOnVK33//fbzeFU/3Cnie/Pnza9OmTdq5c6f27NmjLVu2aNGiRerRo4d69+6d5DglPfNcvMxxAwCQVPv371dISIjWr19v6j36tICAAFNvT39/fy1dulS7d++Wn5+fNm3apHz58pmSJ9KTtp2np2eCk5ZJipckSugafOjQIXXv3l1lypTR4MGD5e7uLkdHR61YseK5E6k+S3K3N4sXL67cuXNrxIgRunbt2jPvUHsdYmNjZTAYNGPGjATbTk8nphIjLul39uxZ+fn5JUuMT7NEOydu2/369VPhwoUTrPPv1yk54oyrO3r0aLm7u8db/qIxg/Ply2f6kSIxnQmS4nW0v//9/efKlStq166d8uXLpwEDBih79uxydHTUrl27NGfOnJduf5cpU0Zbt27V9u3btXfvXi1fvlxz587V0KFDze7eSwra37A2JG0BPNf777+vwYMH6+jRoxo7duwz6+XMmVOBgYEKDw83+xUy7nbzuMkjcubMqdjYWF25csXsF+B/35aeOXNmpU2bVrGxsfL19U2WYwkICJCjo6NGjx4d74J8+PBhzZ8/X0FBQcqRI4dy586tY8eOKTo62ux2+6flzp1bv/76q+7cufPM3rZxv9T/+1fpuF9+E+Pu3bsKDAxUr169zIZi+PetQJkzZ1a6dOkSNQttxYoVlTlzZgUEBKh48eKKjIxM1ORicT10165dq65duz63btwv1RcvXozXq+bixYvxfslODpcvXzbrLfzgwQOFhISoUqVKkp7MghvXa7lMmTKmek/3BHhZadKkUe3atVW7dm1FRUWpV69emjZtmrp27arMmTMrderUunjxYrz1Lly4IDs7u2RPggMA8CoCAgLk6uqqr776Kt6yrVu3miYfS5UqlcqUKSN3d3dt2LDBNMlst27dzNbJnTu3zpw5o3Llyr30MFKbN2+Ws7OzZs2aZZa8WrFihVm9HDlyKDY2VteuXVPevHlN5ZcvXzar9zram/7+/po6dary58//zMTg022kf7tw4YJcXFyUJk0aOTs7K1WqVPHiTmjd3Llzy2g0ysPD45kTNyVFqVKllDFjRq1fv17dunV7YWIxR44czzyeuOWvS86cOfXnn3/KaDSavbf+HU/cEFXp0qVLtvOdO3duxcbG6vz5888833H7dXV1fan9VqlSRUeOHNGWLVtUp06d59aNe50vXLhgNiRXVFSUrl27lmzH/bTLly+b7evy5cuKjY019ZjdsWOHoqKiNHXqVLP3QVKH7EhIpkyZ1KhRIzVq1EgPHjxQ69atNXHiRDVp0iTRnzPAmjGmLYDnSps2rYYMGaJevXqpatWqz6xXqVIlxcTEaOHChWblc+bMkcFgMCXN4v6fP3++Wb25c+eaPbe3t1eNGjW0efNm/fnnn/H29zJDIwQEBKhUqVKm2VGf/tepUydJMvXSqF69um7fvh3veKR/fmmtXr26jEajJk2a9Mw66dKlk4uLiw4dOmS2fNGiRYmO+1mN5H+/ZnZ2dvLz89Mvv/xi6lGcUEzSk1vk/P39tXHjRq1cuVKenp5mvWGeJe72o2nTpunIkSPxloeHh5uS+15eXnJ1ddWSJUvMbl/ctWuXzp8/bzbDc3JZunSpoqOjTc8XL16sx48fm953ccn6p1+LqKioJJ2PhNy+fdvsuZOTk/Lnzy+j0ajo6GjZ29urfPny2r59u1mCODQ0VOvWrVOpUqW45QoAYDUePnyoLVu26L333ovXZqpZs6ZatWqlBw8eaMeOHZKeXF9r1qypX375RWvXrtXjx4/NhkaQnoypHxwcrGXLliW4v4iIiBfGZW9vL4PBYHbH0rVr17R9+3azenE9gP99fV+wYEG87SV3e7NJkybq2bPnc2/Bz5IliwoXLqzVq1eb/bD/559/au/evapcubIpvgoVKmjbtm1mP/ifP39ev/76q9k2q1evLnt7e02aNCler0Cj0RivrfIiqVOnVqdOnXT+/Hl9//33CfY0XLNmjWk8/8qVK+v48eNm7cOIiAgtW7ZMOXPmTHB84uRSqVIl/f3339q0aZOpLDIyMt57zcvLS7lz59ZPP/2U4HADL3O+/fz8ZGdnp8mTJ8frMRr3mlWsWFHp0qXT9OnTzdqpid1v8+bN5e7urm+++SbBBGRYWJimTJkiSfL19ZWjo6Pmz59vds6WL1+u+/fvm95byenf35fiPmdx7e+47zJPx3P//v14P7Yk1b/f02nTplXu3LlN3zsS+zkDrBk9bQG80LNuF3ta1apVVbZsWY0dO1bXr19XwYIFtXfvXm3fvl0ffvihaQzbwoULq06dOlq0aJHu378vHx8f7d+/P8EeBJ9++qkOHDigpk2bqkmTJipQoIDu3r2rU6dOKTAwUL/99luij+HYsWO6fPlyvIHy42TNmlVFihRRQECAunTpogYNGmj16tUaNWqUjh8/rlKlSikyMlKBgYFq0aKF/Pz89O6776p+/fqaP3++Ll++rIoVKyo2NlaHDx9W2bJlTYPwN2nSRD/++KO++OILeXl56dChQwk2uJ4lXbp0KlOmjGbOnKno6GhlzZpVe/fuTbB36CeffKK9e/eqTZs2atq0qfLnz6+QkBBt2rRJixYtMhveokGDBpo/f74OHDigzz77LFGxODo6atKkSWrfvr1at26tmjVrqmTJknJ0dNRff/2ldevWKUOGDOrbt68cHR312WefaeDAgWrdurX8/f0VFhamefPmKWfOnGrXrl2iX4PEio6OVrt27VSrVi1dvHhRixYtUqlSpVStWjVJko+PjzJmzKgBAwaoTZs2MhgMWrNmzSvf8tSxY0e5ubmpZMmScnV11YULF7RgwQJVrlzZlIz9+OOPtW/fPrVs2VItW7aUvb29li5dqqioKH3++eevfOwAACSXHTt26MGDB8/8wb5EiRLKnDmz1q5da0rO1qpVS/Pnz9eECRPk6ekZb4zP+vXra+PGjRo8eLAOHDigkiVLKiYmRhcuXNCmTZs0c+bMBCdSfVrlypU1e/ZsderUSXXq1FFYWJgWLVqk3Llz6+zZs6Z6Xl5eqlGjhubOnas7d+6oePHiOnjwoOkupad7YyZne1N60uuzV69eL6zXr18/de7cWc2aNVPjxo318OFDLViwQOnTpze7s6pXr17as2ePWrVqpRYtWigmJkYLFixQgQIFzI45d+7c+vjjjzVmzBhdv35dfn5+Sps2ra5du6Zt27apadOm6tixY5KOpVOnTjp37px++uknHThwQDVq1JCbm5tCQ0O1bds2HT9+XEuWLJEkdenSRevXr1fnzp3Vpk0bZcyYUatXr9a1a9c0ceLEFw7B9SqaNm2qhQsXqn///jp16pTc3d21Zs2aeLfZ29nZafjw4ercubPq1Kmjhg0bKmvWrAoODtaBAweULl06TZs2LUn7zpMnj7p166YpU6aoZcuWql69upycnHTixAllyZJFn376qdKlS6chQ4aoX79+atiwoWrXrq3MmTMrKChIu3btUsmSJRPs0R4nY8aMmjx5suk7Sr169VS0aFFJ0h9//KF169bJx8dH0pPe4127dtWkSZPUqVMnVa1a1dQmLlas2AsnHX4Z165dU7du3VSxYkUdPXpUa9euVZ06dUwdQsqXLy9HR0d169ZNzZs314MHD/Tzzz/L1dVVISEhL71ff39/vfPOOypatKgyZcqkEydOaPPmzWYTDib2cwZYK5K2AJKFnZ2dpk6dqgkTJmjDhg1auXKlcubMqX79+qlDhw5mdUeOHCkXFxcFBARo+/btKlu2rH788cd4v3a6ubnp559/1uTJk7V161YtXrxYmTJlUoECBRKdZIwTEBAgSc/tLVy1alVNnDhRZ86cUaFChTRjxgxNnTpV69at05YtW5QpUyaVLFnSbGyzUaNGqWDBglq+fLlGjx6t9OnTy8vLy9RwkqQePXro1q1b2rx5szZu3KhKlSpp5syZz5yIIyFjxozRsGHDtGjRIhmNRpUvX14zZsyIN7Nq1qxZtWzZMo0fP14BAQEKDw9X1qxZValSpXgNVy8vL7399ts6f/58khpwefLk0erVqzVnzhzTOFKxsbHKkyePmjRpojZt2pjqNmzYUKlSpdKMGTP0/fffK02aNPLz89Pnn3/+WsZH/uqrrxQQEKAJEyYoOjpa/v7++vLLL01fzlxcXDRt2jR9++23GjdunDJkyKB69eqpXLlySf4i87RmzZopICBAs2fPVkREhLJly6Y2bdroo48+MtV5++23tXDhQo0ZM0bTp0+X0WiUt7e3vvvuuwQn7gAAwFLWrl0rZ2dnlS9fPsHldnZ2eu+99xQQEKDbt2/LxcVFJUuWVPbs2XXjxo14vWzj1pk8ebLmzJmjNWvWaOvWrUqdOrU8PDzUpk2bRN3SX65cOY0YMUIzZszQyJEj5eHhoc8++0zXr183S2BK0rfffis3NzetX79eW7dula+vr8aOHauaNWuaDa2QnO3NpPD19dXMmTM1YcIETZgwQQ4ODipTpow+//xzs1vNCxUqpFmzZmnUqFGaMGGCsmXLpl69eikkJCTeMXfp0kV58+bVnDlzNHnyZElPxgouX778c9vAz2JnZ6fRo0erWrVqWrZsmX766SeFh4fLxcXFFGtcm9fNzU1LlizRd999pwULFujRo0cqWLCgpk2b9lrurnpa6tSpNWfOHA0bNkwLFixQqlSpVLduXVWqVMl0N12csmXLaunSpZoyZYoWLFigiIgIubu7y9vb+6XntujTp488PDy0YMECjR07VqlTp1bBggXNhh6rW7eusmTJoh9//FGzZs1SVFSUsmbNqtKlS6thw4Yv3Efx4sUVEBCgWbNmaefOnVqzZo3s7OyUL18+denSxSxR2atXL2XOnFkLFizQqFGjlDFjRjVt2lSffPLJM4d9exXjxo3T+PHjNWbMGDk4OKh169bq16+faXm+fPk0YcIEjRs3zvS5bNGihTJnzqxBgwa99H7btGmjHTt2aO/evYqKilKOHDn08ccfm7XpE/s5A6yVwciIygBgsxo0aKCMGTPGG2rhTbNy5UoNHDhQy5cvf2EvHQAAYJtOnz6tBg0a6LvvvnstPQ4BWzJx4kRNmjRJgYGBypw5s6XDAf6TGNMWAGzUiRMnTF9eAAAA/ksePnwYr2zu3Lmys7Mzm4wUAABrxfAIAGBj/vzzT506dUo//fST3N3dE7yFEQAA4E02c+ZMnTx5Uu+++67s7e21e/du7d69W82aNVP27NktHR4AAC9E0hYAbMzmzZs1efJkvfXWW/rhhx/k7Oxs6ZAAAACSlY+Pj/bu3aspU6YoIiJC2bNnV69evdStWzdLhwYAQKJYdEzbgwcPatasWTp58qRCQkI0efJk+fn5mZYbjUZNmDBBP//8s+7du6eSJUtqyJAhyps3r6nOnTt3NGzYMP3yyy+ys7NT9erV9cUXXyht2rQWOCIAAADYqhe1bRNy4MABffPNN/rrr7+UPXt2de/ePVGT0gAAAOC/zaJj2kZERKhgwYIaPHhwgstnzJih+fPna8iQIVq2bJlSp06tjh076tGjR6Y6n332mc6dO6fZs2dr2rRpOnTokL766quUOgQAAABA0ovbtv929epVde3aVWXLltWaNWv04Ycf6ssvv9SePXtec6QAAACwdhYdHqFy5cqqXLlygsuMRqPmzZun7t27m3oojB49Wr6+vtq2bZv8/f11/vx57dmzx2y28C+//FJdunRRv379lDVr1hQ7FgAAANi257VtE7JkyRJ5eHhowIABkqT8+fPr8OHDmjNnjipWrPi6wgQAAMAbwKI9bZ/n2rVrCgkJka+vr6ksffr0Kl68uI4cOSJJOnLkiDJkyGBK2EqSr6+v7OzsdPz48RSPGQAAAEiso0ePqly5cmZlFSpU0NGjRy0TEAAAAKyG1SZtQ0JCJEmurq5m5a6urgoNDZUkhYaGKnPmzGbLHRwclDFjRtP6AAAAgDUKDQ2Vm5ubWZmbm5vCw8P18OFDC0UFAAAAa2DR4RGsza1b92W5admQFAaDlDlzes4ZAOCVcU15M8WdNzzB+/fNwd8cAEBy4rry5klsO9Zqk7bu7u6SpLCwMGXJksVUHhYWpkKFCkl60hPh1q1bZus9fvxYd+/eNa2fFLGx4g3+hjAYnvzPOQMAvCquKW+muPP2JnNzczPdQRYnNDRU6dKlU6pUqZK0Ld6/bw7+5gAAkhPXlTdPYtuxVpu09fDwkLu7uwIDA1W4cGFJUnh4uI4dO6YWLVpIknx8fHTv3j2dPHlSXl5ekqT9+/crNjZW3t7eFosdAAAAeJESJUpo9+7dZmX79u1TiRIlLBMQAABIdtu2bdaiRfN06dIlOTs7q1Sp0urevbdy5vR45jq3b9/W3LmztG/fHoWGhihzZlf5+dVQhw5d5OTkZKpXoULpBNdv27aDunT5SJJkNBq1ceM6rVixTFevXpGdnUHFi/uoW7deeuutfKZ1RowYoo0b18Xblrt7Fq1ateFlDx+vwKJJ2wcPHujKlSum59euXdPp06eVMWNG5ciRQ23bttXUqVOVJ08eeXh4aPz48cqSJYv8/PwkPZlht2LFivrf//6noUOHKjo6WsOGDZO/v7+yZs1qqcMCAACADXpR23bMmDEKDg7W6NGjJUnNmzfXwoULNXr0aDVq1Ej79+/Xxo0bNX36dEsdAgAASEbr1q3WN98MlyRlz55T9+7d0c6dO3Ts2FHNmbNIrq5u8daJiopSjx6ddOXKZTk5OSl37ry6cuWyFiyYo8uXL2nUqO/jrVO4cGEZDPam51my/JMT++mnHzV79gxJUq5cuRUREaG9e/fo2LGjmj17obJnz2G2LXf3LHJ3/+eOdxcXl1d7EfDSLJq0PXnypNq2bWt6PmrUKEnSBx98oG+++UadO3dWZGSkvvrqK927d0+lSpXSzJkz5ezsbFrn+++/17Bhw/Thhx/Kzs5O1atX15dffpnixwIAAADb9qK2bUhIiG7cuGFanitXLk2fPl2jRo3SvHnzlC1bNg0fPlwVK1ZM8dgBAEDyio6O1rRpkyRJ771XVcOHj1ZoaIhatmys27dvaf782fr448/jrXf48G+6cuWyJGn48NHy9a2ggwf3q2/fntqzZ6dOnDimYsWKm60zadIkpUqVMcHhEVatWv7/MVTT8OHfKjo6Wi1bNtKNG0GaN2+2+vf/wqx+nTr11bFj11d/AfDKLJq0LVu2rM6ePfvM5QaDQX369FGfPn2eWSdTpkwaM2bM6wgPAAAASLQXtW2/+eabBNdZvXr1a4wKAABYwunTp3Tnzh1JUuXKVSVJbm7uKlrUSwcPHtD+/YEJrhcb+0/m1fD/g58aDHamskOHfouXtG3UqJEiIyOVPXtO1ahRW82atTQNo2A0xkqS7OzsntqmwbStf/v558VasGCOXFwyq1gxb3Xp0uO5Qzng9bHaMW0BAAAAAACAN9HffwebHru4ZDY9zpw58/8vv5nget7eJeTq6qawsFB98UU/5cmTx9TzVpJCQv42q58+fQZly5ZN169f16VLFzR9+iT99ddZff31kzt+qlR5X6tXL9eOHVt17tyfioiIUGhoiCQpNNR8W46OjnJ1dVN0dLSCgq5r+/at+u23A5o3b4nZkAlIGXYvrgIAAAAAAADgVSU0hMHT0qdPr3Hjpqh8+YpKnTqVbty4oYoV31O6dOklSQ4O//S/nD59jjZu3K41a9Zo9eqNKlWqjCRpx46tCg5+khTu1auv2rRpr+zZcyo4+KZcXd1M9Z7eVosWrbV+/XYtXLhcy5at0WefDZQk3b9/T+vXr02240fi0dMWAAAAAAAASEZPTwZ2+/ateI+zZMn2zHXfeiufvv12rOl5aGiItm3bLEnKnTuPqbxoUS/9/wgKSpUqlSpVek+HDx+U9KSnb9as2eTs7KyuXXuoa9cepvU++aSnJClXrn+2lS9fAbMYqlevpe+/f9JbNzg4WEh59LQFAAAAAAAAklHhwkWVMWNGSdKuXTskPUm+njp1UpL07rvlJEktWzZSy5aNtGLFUtO6J0+eUFRUlCTp0aOHGjt2tKQnPWPjxsc9evR3/fLLNsXExPx/vUfas2eXaRvZsmWXJAUFXdfNm/9MhLp9+xb99tt+SZKfX3VT+axZ03X79m2zenGyZ8/+8i8EXho9bQEAAAAAAIBk5OjoqC5deui770Zq584datKkvu7du6OIiAfKlCmTWrduJ0mm8WrjJi2TpHnzZunIkd+VI0cOBQffVHh4uCTpo4/6mMaWDQq6rpEjhyp16tTKlSuXbty4qfv370mSateua6p39uxpDR48SDlyeCgm5rFu3AiSJBUp4qXGjZub9jl79gzNnTtLOXLklNFo1PXr1yRJrq6uqlu3wWt7nfBsJG0BAAAAAACAZFa/fkOlTp1aixfP1+XLl+Tk5KTKlauoW7decnNzf+Z6JUqU1JUrl3X16lXZ29vJ27uEmjdvrUqV3jPV8fYuoQYNGuno0d917do12dnZqWDBwqpbt4Hq1Klvqpcjh4cKFy6qy5cv6uHDh8qZ00NVq76vtm07yMnJyVSvS5ePtH//Pl29ekUPHjyQh0culS79jj78sKPZRGpIOQaj8UVDINuO0ND7LxwQGtbBYJDc3NJzzgAAr4xrypsp7rzhCd6/bw7+5gAAkhPXlTdPYtuxjGkLAAAAAAAAAFaEpC0AAAAAAAAAWBHGtAUAAAAAAIBF2NkZZGdnsHQYbzx7e/plvorYWKNiY61rfAmStgAAAAAAAEhxdnYGZc6UWgZ7e0uH8sZzcUlr6RDeaMaYGN26E2lViVuStgAAAAAAAEhxdnYGGeztdXt5Xz0OPW/pcGCjHNzyy6XxWNnZGUjaAgAAAAAAAJL0OPS8Ht84ZekwAKvCgBcAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEVI2gIAAAAAAACAFSFpCwAAAAAAAABWhKQtAAAAAAAAAFgRkrYAAAAAAAAAYEWsOmkbExOjcePGqWrVqvL29pafn58mT54so9FoqmM0GjV+/HhVqFBB3t7eateunS5dumS5oAEAAGCzFi5cqKpVq6pYsWJq0qSJjh8//tz6c+bMUY0aNeTt7a3KlStr5MiRevToUQpFCwAAAGtl1UnbGTNmaPHixfrqq6+0YcMGffbZZ5o5c6bmz59vVmf+/PkaMmSIli1bptSpU6tjx440dgEAAJCiNmzYoFGjRqlHjx5atWqVChUqpI4dOyosLCzB+gEBARozZox69uypDRs2aMSIEdqwYYN++OGHFI4cAAAA1saqk7ZHjhxRtWrV9N5778nDw0M1a9ZUhQoVTD0WjEaj5s2bp+7du8vPz0+FChXS6NGj9ffff2vbtm0Wjh4AAAC2ZPbs2WratKkaNWqkAgUKaOjQoUqVKpVWrFiRYP0jR46oZMmSqlu3rjw8PFShQgXVqVPnhb1zAQAA8N9n1UlbHx8f7d+/XxcvXpQknTlzRocPH1alSpUkSdeuXVNISIh8fX1N66RPn17FixfXkSNHLBIzAAAAbE9UVJROnTpl1i61s7OTr6/vM9ulPj4+OnXqlClJe/XqVe3atUuVK1dOkZgBAABgvRwsHcDzdOnSReHh4apVq5bs7e0VExOjvn37ql69epKkkJAQSZKrq6vZeq6urgoNDU3y/gyGV48ZKSPuXHHOAACvimvKm8naztft27cVExOTYLv0woULCa5Tt25d3b59Wy1btpTRaNTjx4/VvHlzdevWLcn7t7bXA8/G3xwAAKxXSlyfE7sPq07abty40TTWV4ECBXT69GmNGjVKWbJk0QcffJDs+3N1TZ/s28TrxTkDACQXrilIaQcOHND06dM1ePBgeXt768qVKxoxYoQmT56sHj16JGlbvH/fPJwzAACsi4tLWkuHYMaqk7ajR49Wly5d5O/vL0kqWLCggoKCNH36dH3wwQdyd3eXJIWFhSlLliym9cLCwlSoUKEk7y8s7L6MxuSJHa+XwfCkocs5AwC8Kq4pb6a482YtXFxcZG9vH2/SsbCwMLm5uSW4zvjx41WvXj01adJE0pO2bkREhL766it1795ddnaJH8mM9++bg785APAPe3s7q0uUwXbdvv1AMTGxr30/iW3HWnXS9uHDhzL8q8+wvb29jP/fuvHw8JC7u7sCAwNVuHBhSVJ4eLiOHTumFi1aJHl/RqNoOL1hOGcAgOTCNQWvwsnJSUWLFlVgYKD8/PwkSbGxsQoMDFTr1q0TXOfhw4fxErP29vaSZGrvJhbv3+S1bdtmLVo0T5cuXZKzs7NKlSqt7t17K2dOjwTr//77IfXu/exhLQYNGqzatetKksqXL51gnbZtO6hLl48kPTn/Gzeu04oVy3T16hXZ2RlUvLiPunXrpbfeyme2XlDQdc2ePUO//Raou3fvKn36DCpUqLAGDx6hdOnSvczhAwBgs6ypPWXVSdsqVapo2rRpypEjh2l4hNmzZ6tRo0aSJIPBoLZt22rq1KnKkyePPDw8NH78eGXJksXUWAYAAABSQvv27dW/f395eXnJ29tbc+fOVWRkpBo2bChJ6tevn7JmzapPP/1U0pO27uzZs1WkSBHT8Ajjx49XlSpVTMlbpLx161brm2+GS5KyZ8+pe/fuaOfOHTp27KjmzFkkV9f4PafTpk2nIkW8zMpu376lGzeCJCnBdd5+21OOjk6m51myZDU9/umnHzV79gxJUq5cuRUREaG9e/fo2LGjmj17obJnzyFJunLlsrp376C7d+8qVapUypPnLT1+HK2DBw8oIuIBSVsAAN5gVp20/fLLLzV+/HgNHTrUNARCs2bNzMb46ty5syIjI/XVV1/p3r17KlWqlGbOnClnZ2cLRg4AAABbU7t2bd26dUsTJkxQSEiIChcurJkzZ5qGR7hx44ZZz9ru3bvLYDBo3LhxCg4OVubMmVWlShX17dvXUodg86KjozVt2iRJ0nvvVdXw4aMVGhqili0b6/btW5o/f7Y+/vjzeOsVLFhIP/44x6ysX7+PdeNGkHLnzqN33nk33jqjRn2vbNlyJBjHqlXL/z+Gaho+/FtFR0erZctGunEjSPPmzVb//l9IksaN+153795VyZKlNWLEd0qf/smtlo8ePZS9vVV/1QMAAC9g1VfydOnS6YsvvtAXX3zxzDoGg0F9+vRRnz59UjAyAAAAIL7WrVs/cziE+fPnmz13cHBQz5491bNnz5QIDYlw+vQp3blzR5JUuXJVSZKbm7uKFvXSwYMHtH9/YKK2c+nSRQUG7pUkNW/eOt6Qb5LUsWMbPXz4UNmz51SNGrXVrFlLOTk96XlrND4ZTy8uyf9k/SfbOHToN0nSvXv3dPDgfklS+vTp1alTG926dUtvvZVPnTt3U5ky8RPFAADgzZH42Q0AAAAA4D/s77+DTY9dXDKbHmfOnPn/l99M1HYWL54vo9EoF5fMqlnTP97yjBkzyt09qxwdnXTp0gVNnz5Jw4cPNi2vUuV9SdKOHVvVsmUjNW5cVzduXJckhYb+LUm6du2KaezjXbt+UWysUc7OTvrjj5P67LM+OnXqZFIOHQAAWBmStgAAAADwHEmZlCQsLFRbt26SJDVq1NTUezbOjz/O0YEDBzR37iKtXr1RpUqVkfQkQRsc/CQp3KtXX7Vp017Zs+dUcPBNubq6meo5ODy5WTImJsa0zdKl39GyZau1ZMlqZciQUTExMVq9evlLHy8AALA8krYAAAAAIPPJwG7fvhXvcZYs2V64jeXLlyoqKkqpU6dWw4ZN4i0vWtTLNFxCqlSpVKnSe6ZlcT19nZ2d1bVrD/388xpt375Xs2bNN01OlytXHkmSu3sW03qFChWRwWBQunTplCtXbkkyTYIGAADeTCRtAQAAAEBS4cJFlTFjRknSrl07JEmhoSGmoQbefbecJKlly0Zq2bKRVqxYarZ+ZGSkVq9eIUmqXbuuMmTIaLb86NHf9csv20y9ZB89eqQ9e3aZlmfLll2SFBR0XTdv3jCVb9++Rb/99mT8Wj+/6qa6Hh5PErRnz56W0WjUgwfhunr1iiSZkrcAAODNZNUTkQEAAABASnF0dFSXLj303XcjtXPnDjVpUl/37t1RRMQDZcqUSa1bt5MkXblyWZJMk5bFWbduje7fvyd7e3s1a9Yq3vaDgq5r5MihGjnya2XPnkN///237t+/J+lJkjeu9+zZs6c1ePAg5cjhoZiYx6Zes0WKeKlx4+am7XXv3lNfftlfBw8eULNmDRQREaF79+4qderUCe4fAAC8OUjaAgAAAMD/q1+/oVKnTq3Fi+fr8uVLcnJyUuXKVdStWy+5ubk/c72YmBgtW7ZYklSpUhXlyJEzXh1v7xJq0KCRTpw4qqCgINnb26lgwcKqW7eB6tSpb6qXI4eHChcuqsuXL+rhw4fKmdNDVau+r7ZtO5iNkVu5clWNGvW95s6dpfPnzytdunSqWPE9devWU3ny5E2+FwUAAKQ4g9GYlGH1/9tCQ+8naZIBWI7BILm5peecAQBeGdeUN1PcecMTvH/fHPzNAYB/ODjYycUlrUKm1dPjG6csHQ5slEP2onLvtla3bz/Q48exr31/iW3HMqYtAAAAAAAAAFgRhkcAAABvhBs3gtSkSb1nLm/fvrNat/5QQ4f+T3/+eUa3bt2Sg4OD3N3dValSFbVr10nOzs7P3cetW2GaNm2S9u37VQ8ehCtnTg998EFjNWrUzFRn/fq1mjNnlu7cuaVChYro888HKXfuPKbln3/eRzExMfrhh0mvftAAAAAAbBJJWwAA8EZwdHRSkSJeZmXh4fdNEwK5uropKipa+/btUbZs2fXWW/kUGvq3Ll++pPnzZ+vevbv6/PNBz9x+ZGSkevbsoitXLsvZ2VlZs2bXpUsXNXbsd7p9+7Y6deqmy5cv6dtvh6tmTX916fKR2rZtrlGjhmrq1J8kSVu2bNKRI4c1b97SZ+4HeNPZ2RlkZ2ewdBhvPHt7bnp8FbGxRsXGMr4EAOC/i6QtAAB4I7i5uenHH+eYlf3ww7e6cuWy0qfPoOrVayl16tTaunWPHB0dJUmPHz9WixaNdOPGdZ04cey521+zZoWuXLksg8Gg6dPnqECBtzVx4lgtXbpQCxbMUcOGTXT+/DnFxsbKy8tbbm7uyp07j86d+0uSdPfuHU2YMEadOnVLcAIi4L/Azs6gTC5pZU/S9pW5uKS1dAhvtJhYo+7cfkDiFgDwn0XSFgAAvJHu3r2jDRsCJEkNGjRSmjRpJEmOjo765pthOn/+L/39998KCwuV9GTW9ucJDNwnSfLwyKUCBd6WJL33XlUtXbpQjx8/1qFDB1WwYCHZ2dnp5Mnj8vWtoCtXLpvqTpw4VtmzZ1eTJi1ex+ECVsHOziB7O4P+t/2mLt6JtnQ4sFFvZXLUsGrZZGdnIGkLAPjPImkLAADeSKtWLdfDhw/l5OSkxo2bmS27cOG8Tp/+w/S8evVa+vjjz5+7vb//DpYkubhkNpVlzuxqehwcfFPVq9dU//5fas6cWWre/AMVKlRE/foN0sGDB7Rt22ZNmzZbU6ZM0LZtm2Rv76CGDZuodet2yXC0gHW5eCdaZ0MfWToMAACA/yyStgAA4I0TFRWllSt/lvQkIevq6ma2/Mcf5ygqKkqnT/+hwYMHasuWjcqRI6c6deqWpP0YjfF7cPn715O//z8Toj18+FCffdZHLVq00enTp7R06UJ16fKRQkNDNG3aJBUo4Kl33/V9iaMEAAAAYKsY/R4AALxxNm1ar1u3wmQwGNS8eesE6zg5Oal48RKqVu19SdL8+bP18OHDZ24zS5askqTbt2+Zyp5+nDVrtgTXmzlzmuzt7dWuXScdOnRAktS4cTPVr99IknTw4IEkHBkAAAAAkLQFAABvGKPRqCVLFkiSypWroLx53zItO3ToN509e8b0PCIiQkePHpEkxcTEKCrqye3cu3b9opYtG6lly0YKCflbkky9Ya9du2qaXGznzh2SJAcHB5UuXSZeLGfPntHPPy9Wv35fyNnZWXEdcx0cHOXgwA1NAAAAAF4O3yYAAMAbZe/e3bpy5bIkqWXLNmbLjh07otmzZyhTJhe5ubkrKOi6IiIeSJLKl6+oDBkySpIePAg3bePx48eSpPr1G2r16pW6du2KunZtpyxZsurq1SuSpBYt2piNbxu33rffDlPt2vXk41NKklS69DvavfsXBQbuVVDQ9f8vi5/sBQAAAIDnIWkLAADeKIsXP+llW7hwUZUoUdJsWdGixeTjU0qXLl3UxYvn5eTkpAIFPPXee1XVokWbhDZnkiZNGk2a9KOmT5+kwMBfdeNGkPLkyav69RupadMW8eovXbpQYWFh6tGjj6msXr0PdOXKZY0ePVwODg7q3Lm7ypWrkAxHDQAAAMCWGIwJzbBho0JD74tX481gMEhubuk5ZwCAV8Y15c0Ud97wREq9fx0c7OTiklatV1zV2dBHr3+HQAIKujlrQaNcun37gR4/jrV0OABeQdx1JWRaPT2+ccrS4cBGOWQvKvdua1PsupLYdixj2gIAAAAAAACAFSFpCwAAAAAAAABWhDFtAQB4w9nZGWRnZ7B0GG88e3t+y34VsbFGxcYyvgQAAACQHEjaAgDwBrOzMyhzptQy2NtbOpQ3notLWkuH8EYzxsTo1p1IErcAAABAMiBpCwDAG8zOziCDvb1uL++rx6HnLR0ObJSDW365NB4rOzsDSVsAAAAgGZC0BQDgP+Bx6Hlm3AUAAACA/wgGbwMAAAAAAAAAK0LSFgAAADbv8uXL2rNnjx4+fChJMhoZ5gEAAACWw/AIAAAAsFm3b99W3759tX//fhkMBm3ZskW5cuXSoEGDlDFjRg0YMMDSIQIAAMAG0dMWAAAANmvUqFGyt7fXzp07lSpVKlN57dq1tWfPHgtGBgAAAFtGT1sAAADYrL1792rWrFnKli2bWXnevHkVFBRkoagAAABg6+hpCwAAAJsVERFh1sM2zp07d+Tk5GSBiAAAAACStgAAALBhpUuX1urVq83KYmNjNXPmTJUtW9YyQQEAAMDmMTwCAAAAbNbnn3+udu3a6eTJk4qOjtZ3332nc+fO6e7du1q8eLGlwwMAAICNImkLAAAAm+Xp6anNmzdrwYIFSps2rSIiIvT++++rVatWypIli6XDAwAAgI0iaQsAAACbFB0drU6dOmno0KHq3r27pcMBAAAATBjTFgAAADbJ0dFRZ8+etXQYAAAAQDwkbQEAAGCz6tWrp+XLl1s6DAAAAMAMwyMAAADAZsXExGjx4sXat2+fvLy8lDp1arPlAwcOtFBkAAAAsGUkbQEAAGCz/vzzTxUpUkSSdPHiRbNlBoPBEiEBAAAAJG0BAABgu+bPn2/pEAAAAIB4GNMWAAAAkHTz5k3dvHnT0mEAAAAA9LQFAACA7YqNjdWUKVM0e/ZsRURESJLSpk2r9u3bq3v37rKzo48DAAAAUh5JWwAAANissWPHavny5fr0009VsmRJSdLhw4c1adIkRUVFqW/fvhaOEAAAALaIpC0AAABs1qpVqzR8+HBVq1bNVFaoUCFlzZpVQ4cOJWkLAAAAi+B+LwAAANisu3fvKl++fPHK8+XLp7t371ogIgAAAICkLQAAAGxYoUKFtHDhwnjlCxcuVKFChSwQEQAAAMDwCAAAALBhn3/+ubp27ap9+/apRIkSkqSjR4/qxo0bmjFjhmWDAwAAgM2ipy0AAABs1jvvvKNNmzbp/fff1/3793X//n29//772rRpk0qXLm3p8AAAAGCj6GkLAAAAm5Y1a1YmHAMAAIBVoactAAAAbNaKFSu0cePGeOUbN27UqlWrLBARAAAAQNIWAAAANuzHH3+Ui4tLvHJXV1dNmzbNAhEBAAAAJG0BAABgw4KCguTh4RGvPEeOHLpx44YFIgIAAABI2gIAAMCGubq66uzZs/HKz5w5o0yZMqV8QAAAAICYiAwAAAA2zN/fXyNGjFDatGlVpkwZSdJvv/2mkSNHyt/f38LRAQAAwFaRtAUAAIDN6tOnj65fv6527drJweFJ0zg2Nlb169dX3759LRwdAAAAbBVJWwAAANgsJycnjRs3TpcuXdLp06eVKlUqeXp6KmfOnJYODQAAADaMpC0AAABsXt68eZU3b149fvxYjx49snQ4AAAAsHFMRAYAAACbs2PHDq1cudKsbOrUqfLx8VGZMmXUoUMH3b1710LRAQAAwNaRtAUAAIDNmT17tiIjI03Pf//9d02YMEEfffSRxo0bpxs3bmjKlCkWjBAAAAC2jOERAAAAYHPOnTsnHx8f0/PNmzfL19dX3bt3lyQ5OztrxIgRGjhwoKVCBAAAgA2jpy0AAABszoMHD5QpUybT88OHD6tcuXKm5wUKFNDff/9tgcgAAAAAkrYAAACwQVmzZtX58+clPUngnjlzxqzn7Z07d5QqVSpLhQcAAAAbx/AIAAAAsDk1a9bUyJEj1bVrV+3evVvu7u4qUaKEafnJkyf11ltvWS5AAAAA2DSStgAAALA5PXr0UHBwsEaMGCE3Nzd99913sre3Ny1ft26dqlSpYsEIAQAAYMtI2gIAAMDmpEqVSqNHj37m8vnz56dgNAAAAIA5xrQFAAAAAAAAACtC0hYAAAAAAAAArAhJWwAAAAAAAACwIiRtAQAAAAAAAMCKkLQFAAAAJD169MjSIQAAAACSSNoCAADAhsXGxmry5MmqWLGifHx8dPXqVUnSuHHj9PPPP1s4OgAAANgqq0/aBgcH67PPPlPZsmXl7e2tunXr6sSJE6blRqNR48ePV4UKFeTt7a127drp0qVLlgsYAAAAb4wpU6Zo1apV+vzzz+Xo6Ggq9/T01PLly5O8vYULF6pq1aoqVqyYmjRpouPHjz+3/r179zR06FBVqFBBXl5eqlGjhnbt2pXk/QIAAOC/xSEplWNjY/Xbb7/p0KFDCgoK0sOHD5U5c2YVLlxYvr6+yp49e7IGd/fuXbVo0UJly5bVjBkz5OLiosuXLytjxoymOjNmzND8+fP1zTffyMPDQ+PHj1fHjh21YcMGOTs7J2s8AAAA+G9Zs2aNhg0bpnLlymnw4MGm8oIFC+rChQtJ2taGDRs0atQoDR06VMWLF9fcuXPVsWNHbdq0Sa6urvHqR0VFqX379nJ1ddX48eOVNWtWBQUFKUOGDK98XAAAAHizJSpp+/DhQ/30009avHix7t69q8KFCytLlixydnbW5cuXtW3bNv3vf/9T+fLl1aNHD5UoUSJZgpsxY4ayZcumUaNGmcpy5cplemw0GjVv3jx1795dfn5+kqTRo0fL19dX27Ztk7+/f7LEAQAAgP+m4OBg5c6dO1650WjU48ePk7St2bNnq2nTpmrUqJEkaejQodq5c6dWrFihLl26xKu/YsUK3b17V0uWLDH18vXw8HiJowAAAMB/TaKStjVq1FCJEiU0fPhw+fr6mt06Fuf69etat26dPvnkE3Xr1k1NmzZ95eB27NihChUqqHfv3jp48KCyZs2qli1bmrZ97do1hYSEyNfX17RO+vTpVbx4cR05ciTJSVuD4ZVDRgqJO1ecMwAArEtKXZuTaz8FChTQoUOHlDNnTrPyTZs2qXDhwoneTlRUlE6dOqWuXbuayuzs7OTr66sjR44kuM6OHTtUokQJff3119q+fbsyZ86sOnXqqHPnzrK3t0/ScdAmgq3ivQ8ASE4pcV1J7D4SlbT96aeflD9//ufWyZkzp7p27aoOHTroxo0bidv7C1y9elWLFy9W+/bt1a1bN504cULDhw+Xo6OjPvjgA4WEhEhSvNvNXF1dFRoamuT9ubqmT5a4kXI4ZwAAWA8Xl7SWDiHJPvroIw0YMEDBwcEyGo3asmWLLl68qNWrV2v69OmJ3s7t27cVExOTYLv0WcMsXL16Vfv371fdunX1448/6sqVKxo6dKgeP36snj17Juk4aBPBFr2Jf3MAANbL2q4riUravihh+zRHR8cEbzF7GUajUV5eXvrkk08kSUWKFNFff/2lJUuW6IMPPkiWfTwtLOy+jMZk3yxeA4PhyZcTzhkAW2dvb2d1jQvYrtu3HygmJjZF9hXXFnhVfn5+mjZtmiZPnqzUqVNrwoQJKlKkiKZNm6by5csnQ6TPZjQa5erqqmHDhsne3l5eXl4KDg7WrFmzkpy0Tak2EX9zYE1S8m8OgNeD6wqsSUpdVxLbjk3SRGRPe/z4sZYuXaoDBw4oNjZWJUuWVKtWrZJ18i93d/d4CeN8+fJp8+bNpuWSFBYWpixZspjqhIWFqVChQknen9EoEoBvGM4ZAADW5U28LpcuXVqzZ89+pW24uLjI3t5eYWFhZuVhYWFyc3NLcB13d3c5ODiYDYWQL18+hYSEKCoqSk5OToneP20i2Cre9wCA5GRN1xW7l11x+PDh2rp1q8qWLasyZcpo3bp1GjhwYHLGppIlS+rixYtmZZcuXTKNOebh4SF3d3cFBgaaloeHh+vYsWPy8fFJ1lgAAADw33P8+HEdO3YsXvmxY8d04sSJRG/HyclJRYsWNWuXxsbGKjAw8Jnt0pIlS+rKlSuKjf2nR8elS5fk7u6epIQtAAAA/nsSnbTdunWr2fO9e/dq1qxZatWqlT788EN999132r17d7IG9+GHH+rYsWOaNm2aLl++rICAAC1btkwtW7aUJBkMBrVt21ZTp07V9u3bdfbsWfXr109ZsmSRn59fssYCAACA/56vv/46wfkYgoOD9fXXXydpW+3bt9eyZcu0atUqnT9/XkOGDFFkZKQaNmwoSerXr5/GjBljqt+iRQvduXNHI0aM0MWLF7Vz505Nnz5drVq1erWDAgAAwBsv0cMjrFixQqtWrdLgwYOVNWtWFSlSRIMHD1b16tX1+PFjLVu2TMWKFUvW4Ly9vTVp0iT98MMPmjx5sjw8PDRo0CDVq1fPVKdz586KjIzUV199pXv37qlUqVKaOXNmsg7TAAAAgP+m8+fPq2jRovHKCxcurHPnziVpW7Vr19atW7c0YcIEhYSEqHDhwpo5c6ZpeIQbN27Izu6fPhPZs2fXrFmzNGrUKNWrV09Zs2ZV27Zt1blz51c7KAAAALzxEp20nTZtmjZs2KC2bduqdevWGjZsmKZMmaJx48YpJiZGJUuWVK9evZI9wCpVqqhKlSrPXG4wGNSnTx/16dMn2fcNAACA/zYnJyeFhoYqV65cZuUhISFycEj69A+tW7dW69atE1w2f/78eGU+Pj5atmxZkvcDAACA/7YktURr166tChUq6LvvvlPHjh01dOhQDRgw4HXFhv+AWbOma/bsGQku27lzvxwcHNSzZxcdPfp7vOXFihXX1Kmznrv9x48fa+7cn7Rx43qFhATLxSWzqlSppk6duitNmjSSpJMnT2jcuO908eJ5Zc+eUx991Fu+vhVM21i4cK6WLl2kBQt+VoYMGV7haAEAwJumfPny+uGHHzRlyhSlT/9kFt979+5p7Nix8vX1tXB0AAAAsFVJ7j6QIUMGDRs2TAcPHlT//v1VoUIFffzxxwxHgOfKlCmTcuTwMCszGAxmz3PkyKlMmVxMz996K98Ltzty5FBt3rxRdnZ28vDIpaCg61q2bLH+/POsJkyYJoPBoP/9r7/Spk2rVas26Msv+2vw4IFauXKD0qdPr+vXr+mnn37UoEFDSNgCAGCD+vfvr1atWqlKlSoqXLiwJOnMmTNydXXV6NGjLRwdAAAAbFWik7ZBQUH69ttvdeHCBXl6eqp///5asWKFpk2bpnr16mnQoEGqXLny64wVb7By5Sroiy+GPLdOu3adVLt23URv89SpU9q8eaMkqU+fT9WoUTP9+utuDRjwiY4e/V179uyUt7ePQkL+VokSNZUhQ0YVLVpMv/9+SNevX1WhQkU0evRIlS79jqpVe//lDw4AALyxsmbNqrVr1yogIEBnzpxRqlSp1KhRI/n7+8vR0dHS4QEAAMBGJTpp279/f7m5uenzzz/Xr7/+qq+++krTpk1T79695e/vr6+++korV67U+PHjX2e8eEPt3LlD27dvVfr06VSwYGF16tRNnp6FzOpMmPCDvvtupNzcsqh06XfUuXM3Zc7s+sxt7t692/S4cuVqkiRf3wpycnJWVNQj7d8fqEqVqsjdPYv++uus7t27q1OnTih16tTKmTOX1q9fqzNnTmn+fMaRAwDAlqVJk0bNmjWzdBgAAACASaKTtidPntSaNWuUO3duVaxYUdWqVTMty58/vxYuXKilS5e+liDxZrO3t5erq6vs7e11+fIl7dv3qw4d+k3Tpv1kStw6OzvL3d1d4eHhunHjugICVunQod80b94SpU6dOsHt3rhxw/TYxeXJsAp2dnbKlCmT/v47WMHBN2UwGDRs2LcaO3a0PvigtrJnz6GhQ0fp8eNoTZ48Xl279tThwwc1Z85MPXgQLl/fivr4489N4+ECAID/vkuXLunAgQMKCwtTbGys2bKePXtaKCoAAADYskQnbYsWLarx48frgw8+0L59++Tp6RmvDj0U8G/vv19TTZo0V4YMGSVJBw4E6tNPeykqKkorV/6sAQP+p969P1HevPnk5OQko9GoH3+covnzZ+vGjevavfsX1ahRO0n7NBqNZs+9vIpp1izz2ZoHDx6oPHnyqnhxH7Vv31IVKlRW+fIVNWrU13Jxyazu3Xu92oEDAIA3wrJlyzRkyBC5uLjIzc3NbMx9g8FA0hYAAAAWYZfYit9++62io6M1atQoBQcHa+jQoa8zLvxH5M6dx5SwlaSyZcspY8Ynz4ODb0qSPD0LycnJSdKTL0fvv1/DVD+uTkKyZ89uenz79m1JUmxsrO7evStJypo1W4Lr7dv3q/bs2aX+/b/UkSOHFBsbq9q168rfv54yZMiogwcPvMyhAgCAN9DUqVP18ccfa+/evVqzZo1Wr15t+rdq1SpLhwcAAAAbleikbc6cOTVhwgStX79eY8aMUdasWV9nXPiPWLBgjm7e/CfxevDgflNSNVu2HLp9+5aWLFmgiIgHpjrbt281Pc6WLYckKSTkb7Vs2UgtWzbSrl2/SJIqVqxoqrdr13ZJTxKyUVGPJEnvvlsuXjwRERH6/vtRatOmvfLmfUtxnXLjJhpxcEh053MAAPAfcPfuXdWqVcvSYQAAAABmEpWhioiISNIYn0mtj/+u1atXaPr0ycqSJatSp06ty5cvSZJSp06tpk1b6OHDh5o0aZymTp0oD49cioyM1N9/B0uS8uZ9S5UrV5EkPX78WFeuXJYkPXgQLkny8vLS++/X0NatmzV+/BitXPmzrl+/JkkqXtxHFSu+Fy+e6dMnKW3atGrTpr0kqVSp0rKzs9OBA/uUIUMG3boVppo1kzYcAwAAeHPVrFlTv/76q1q0aGHpUAAAAACTRCVtq1evrrZt26pBgwbKkiVLgnWMRqP27dun2bNnq0yZMuratWuyBoo3U5s27fXLL9t08eIFBQVdV7Zs2VWsWHG1a9dRuXPnVWRkpNq27aCDB/fr+vXrevToofLkyauKFd9Ty5Zt5ezs/Nztf/nlUHl45NamTet1/fo1Zcrkovfeq6YuXbrLzs68I/nJkye0evUKTZ4809SjNl++AurX7wvNmTNTGzYEqHr1WmrXrtNrez0AAIB1yZMnj8aPH69jx47J09Mz3l03bdu2tVBkAAAAsGUG479nbUrAhQsXNHbsWO3cuVOFChWSl5eXsmTJImdnZ929e1fnz5/X0aNHZW9vry5duqh58+ayt7dPifiTVWjofb341YA1MBgkN7f0nDMANs/BwU4uLmkVMq2eHt84ZelwYKMcsheVe7e1un37gR4/jk2Rfca1BV5V1apVn7MPg7Zv3/7K+0gJKdUmivub03rFVZ0NffT6dwgkoKCbsxY0ypWif3MAvB60ZWENUrotm9h2bKJ62ubLl08TJ05UUFCQNm3apEOHDunIkSN6+PChXFxcVKRIEQ0bNkyVKlV6I5O1AAAAsE07duywdAgAAABAPEmadSlHjhzq0KGDOnTo8LriAQAAAFJcVFSUrl27pty5czMxKQAAACyOFqmF2NkZZGdnsHQYbzx7e7sXV8IzxcYaFRvL+BIAANsVGRmpYcOGafXq1ZKkzZs3K1euXBo2bJiyZs2qLl26WDZAAAAA2CSSthZgZ2dQJpe0sidp+8pcXNJaOoQ3WkysUXduPyBxCwCwWWPGjNGZM2c0b948de7c2VRerlw5TZo0iaQtAAAALIKkrQXY2Rlkb2fQ/7bf1MU70ZYOBzbqrUyOGlYtm+zsDCRtAQA2a/v27Ro7dqxKlChhVv7222/rypUrlgkKAAAANo+krQVdvBPNrLsAAAAWdOvWLbm6usYrj4yMlMHAXVEAAACwDAYEBQAAgM3y8vLSzp0745X//PPP8XrfAgAAACklyT1tq1atqoYNG6phw4bKkSPH64gJAAAASBF9+/ZV586dde7cOcXExGjevHk6f/68jhw5ovnz51s6PAAAANioJPe0bdu2rbZu3So/Pz+1b99e69evV1RU1OuIDQAAAHitSpcurTVr1igmJkaenp7au3evMmfOrCVLlsjLy8vS4QEAAMBGJbmnbbt27dSuXTudOnVKq1at0rBhwzR06FDVqVNHjRo1UtGiRV9HnAAAAMBrkTt3bg0fPtzSYQAAAAAmLz0RWdGiRVW0aFH1799fixYt0vfff6/FixfL09NTbdq0UaNGjZi8AQAAAFYnPDw80XXTpUv3GiMBAAAAEvbSSdvo6Ght3bpVK1eu1L59+1S8eHE1btxYN2/e1NixYxUYGKgxY8YkZ6wAAADAKytdunSiOxecPn36NUcDAAAAxJfkpO2pU6e0cuVKrVu3TnZ2dmrQoIEGDhyo/Pnzm+q8//77aty4cbIGCgAAACSHefPmmR5fv35dY8aM0QcffKASJUpIko4ePapVq1bp008/tVCEAAAAsHVJTto2btxYvr6+GjJkiPz8/OTo6BivjoeHh/z9/ZMlQAAAACA5vfPOO6bHH374oQYMGKA6deqYyqpVqyZPT08tW7ZMH3zwgSVCBAAAgI2zS+oK27Zt06xZs1SrVq0EE7aSlCZNGo0aNeqVgwMAAABep6NHj8rLyyteuZeXl44fP26BiAAAAICXSNqGhYXp2LFj8cqPHTumEydOJEtQAAAAQErIli2bli1bFq/8559/VrZs2SwQEQAAAPASwyN8/fXX6tSpk4oXL25WHhwcrBkzZujnn39OtuAAAACA12nQoEHq1auX9uzZI29vb0nS8ePHdfnyZU2cONHC0QEAAMBWJbmn7fnz51W0aNF45YULF9a5c+eSJSgAAAAgJVSuXFmbN29WlSpVdPfuXd29e1dVq1bV5s2bVblyZUuHBwAAABuV5J62Tk5OCg0NVa5cuczKQ0JC5OCQ5M0BAAAAFpU9e3Z98sknlg4DAAAAMElylrV8+fL64YcfNGXKFKVPn16SdO/ePY0dO1a+vr7JHiAAAACQnM6cOSNPT0/Z2dnpzJkzz61bqFChFIoKAAAA+EeSk7b9+/dXq1atVKVKFRUuXFjSk4avq6urRo8enewBAgAAAMmpQYMG2rt3r1xdXdWgQQMZDAYZjcZ49QwGg06fPm2BCAEAAGDrkpy0zZo1q9auXauAgACdOXNGqVKlUqNGjeTv7y9HR8fXESMAAACQbLZv367MmTObHgMAAADW5qUGoU2TJo2aNWuW3LEAAAAAr13Pnj01Z84cZcyYUatWrVLHjh2VOnVqS4cFAAAAmLz0zGHnzp1TUFCQoqOjzcqrVav2ykEBAAAAr8v58+cVGRmpjBkzavLkyWrRogVJWwAAAFiVJCdtr169qh49eujPP/80G//LYDBIEuN+AQAAwKoVLlxYAwcOVKlSpWQ0GjVr1iylSZMmwbo9e/ZM4egAAACAl0jajhgxQh4eHpozZ46qVaum5cuX6/bt2/r222/Vv3//1xEjAAAAkGxGjRqliRMn6pdffpHBYNCePXtkb28fr57BYCBpCwAAAItIctL2yJEjmjt3rjJnziw7OzsZDAaVLl1an3zyiYYPH67Vq1e/hjABAACA5JEvXz6NHTtWklSoUCHNmTNHrq6uFo4KAAAA+IddUleIjY1V2rRpJUkuLi76+++/JUk5c+bUxYsXkzc6AAAA4DU6c+YMCVsAAABYnST3tH377bd19uxZ5cqVS8WLF9fMmTPl6OioZcuWKVeuXK8jRgAAAOC1uXTpkg4cOKCwsDDFxsaaLWN4BAAAAFhCkpO23bt3V2RkpCSpd+/e6tq1q1q1aqVMmTKZbjMDAAAA3gTLli3TkCFD5OLiIjc3N9PkuhJj2gIAAMBykpy0rVixoulxnjx5tGnTJt25c0cZM2Y0a+QCAAAA1m7q1Kn6+OOP1aVLF0uHAgAAAJgkaUzb6OhoFSlSRH/++adZeaZMmUjYAgAA4I1z9+5d1apVy9JhAAAAAGaSlLR1dHRU9uzZ4431BQAAALyJatasqV9//dXSYQAAAABmkjw8Qrdu3fTDDz9o9OjRypQp02sICQAAAEgZefLk0fjx43Xs2DF5enrKwcG8edy2bVsLRQYAAABbluSk7cKFC3X58mVVrFhROXLkUJo0acyWr1q1KtmCAwAAAF6npUuXKk2aNPrtt9/022+/mS0zGAwkbQEAAGARSU7a+vn5vY44AAAAgBS3Y8cOS4cAAAAAxJPkpG3Pnj1fRxwAAACARRmNRkligl0AAABYXJImIgMAAAD+a1avXq26devK29tb3t7eqlu3rlavXm3psAAAAGDDktzTtlChQs/tfXD69OlXCggAAABIKbNnz9b48ePVqlUrffzxx5Kkw4cPa8iQIbpz547atWtn0fgAAABgm5KctJ00aZLZ88ePH+v06dNatWqVevXqlWyBAQAAAK/b/PnzNWTIEDVo0MBUVq1aNb399tuaOHEiSVsAAABYRLJMRFazZk0VKFBAGzZsUJMmTZIlMAAAAOB1CwkJkY+PT7xyHx8fhYSEWCAiAAAAIBnHtC1RooT279+fXJsDAAAAXrs8efJo48aN8co3bNigvHnzpnxAAAAAgF6ip21CHj58qHnz5ilLlizJsTkAAAAgRfTq1Ut9+/bVwYMHVbJkSUnS77//rv3792vcuHGWDQ4AAAA2K8lJ2zJlyphNRGY0GvXgwQOlSpVK3333XbIGBwAAALxONWrU0LJlyzRnzhxt375dkpQvXz79/PPPKlKkiIWjAwAAgK1KctJ24MCBZklbg8GgzJkzq3jx4sqYMWOyBgcAAAC8bl5eXvr+++8tHQYAAABgkuSkbcOGDV9HHAAAAECKCQ4O1pw5c9SjRw+lS5fObNn9+/c1ZcoUdezYUW5ubhaKEAAAALYsyRORrVixIsHJGjZu3KhVq1YlS1AAAADA6zRnzhyFh4fHS9hKUvr06fXgwQPNnj3bApEBAAAAL5G0/fHHH+Xi4hKv3NXVVdOmTUuWoAAAAIDXac+ePapfv/4zlzdo0EA7d+5MuYAAAACApyQ5aRsUFCQPD4945Tly5NCNGzeSJSgAAADgdbp27Zpy5MjxzOXZsmXT9evXUzAiAAAA4B9JTtq6urrq7Nmz8crPnDmjTJkyJUdMAAAAwGvl7Oz83KTs9evX5ezsnIIRAQAAAP9IctLW399fI0aM0P79+xUTE6OYmBgFBgZq5MiR8vf3fx0xAgAAAMmqePHiWrNmzTOXr169Wt7e3ikYEQAAAPAPh6Su0KdPH12/fl3t2rWTg8OT1WNjY1W/fn317ds32QMEAAAAkluHDh3UoUMHpU+fXh07dpSbm5skKTQ0VDNnztSqVas0a9YsC0cJAAAAW5XkpK2Tk5PGjRunS5cu6fTp00qVKpU8PT2VM2fO1xEfAAAAkOzeffddffXVVxoxYoTmzJmjdOnSyWAw6P79+3JwcNCXX36pcuXKWTpMAAAA2KgkJ23j5M2bV3nz5k3GUAAAAICU07x5c1WpUkUbN27U5cuXZTQalTdvXtWsWVPZsmWzdHgAAACwYUlO2vbq1UvFihVTly5dzMpnzJihEydOaMKECckWHAAAAPA6Zc2aVe3atbN0GAAAAICZJE9EdvDgQVWuXDleeaVKlXTo0KFkCQoAAAAAAAAAbFWSk7YRERFydHSMV+7g4KDw8PBkCQoAAAAAAAAAbFWSk7aenp7asGFDvPINGzaoQIECyRIUAAAAAAAAANiqJI9p+9FHH6lXr166evWq3n33XUlSYGCg1q9fr/Hjxyd7gAAAAAAAAABgS5Lc07Zq1aqaPHmyLl++rKFDh+qbb77RzZs3NXv2bPn5+b2OGE1+/PFHFSxYUCNGjDCVPXr0SEOHDlXZsmXl4+OjXr16KTQ09LXGAQAAgP+Oe/fu6eeff9aYMWN0584dSdKpU6cUHByc5G0tXLhQVatWVbFixdSkSRMdP348UeutX79eBQsW1EcffZTkfQIAAOC/J8k9bSXpvffe03vvvRev/M8//5Snp+erxpSg48ePa8mSJSpYsKBZ+ciRI7Vr1y6NGzdO6dOn17Bhw9SzZ08tWbLktcQBAACA/44zZ86offv2Sp8+va5fv66mTZsqU6ZM2rJli27cuKHRo0cnelsbNmzQqFGjNHToUBUvXlxz585Vx44dtWnTJrm6uj5zvWvXrunbb79V6dKlk+OQAAAA8B+Q5J62/xYeHq6lS5eqcePGql+/fnLEFM+DBw/0+eefa/jw4cqYMaOp/P79+1qxYoUGDBigcuXKycvLSyNHjtSRI0d09OjR1xILAAAA/ju++eYbffDBB9qyZYucnJxM5ZUrV9ahQ4eStK3Zs2eradOmatSokQoUKKChQ4cqVapUWrFixTPXiYmJ0WeffaZevXopV65cL30cAAAA+G956aTtwYMH1a9fP1WsWFE//fST3n33XS1dujQ5YzP5+uuvVblyZfn6+pqVnzx5UtHR0Wbl+fPnV44cOUjaAgAA4IVOnDih5s2bxyvPmjWrQkJCEr2dqKgonTp1yqxdamdnJ19fXx05cuSZ602ePFmurq5q0qRJ0gIHAADAf1qShkcICQnRqlWrtHz5coWHh6tWrVqKiorS5MmTVaBAgdcS4Pr16/XHH39o+fLl8ZaFhobK0dFRGTJkMCt3dXVNUiM7jsHw0mECbzTe+wCA5JJS15Tk2o+Tk5PCw8PjlV+6dEmZM2dO9HZu376tmJiYeMMguLq66sKFCwmuc+jQIS1fvlyrV69OUswJ4VoOW8V7HwCQnFLiupLYfSQ6adutWzcdPHhQ7733ngYNGqSKFSvK3t7+tY4de+PGDY0YMUI//fSTnJ2dX9t+4ri6pn/t+wCsjYtLWkuHAAD4j3gTrylxk+yOGzfOVBYUFKTvv/9e1atXf237DQ8PV79+/TRs2LAkJYefhXYsbNGb+DcHAGC9rO26kuik7e7du9WmTRu1aNFCefPmfY0h/ePUqVMKCwtTw4YNTWUxMTE6ePCgFi5cqFmzZik6Olr37t0z620bFhYmd3f3JO8vLOy+jMZkCf257O3trO6NANt1+/YDxcTEWjoMAC+JawqsSUpeUwyG5ElUDhgwQL1795avr68ePXqkNm3aKDQ0VCVKlFDfvn0TvR0XFxfZ29srLCzMrDwsLExubm7x6l+9elXXr19X9+7dTWWxsU9euyJFimjTpk3KnTt3ovdPOxa2iHYs8ObjugJrklLXlcS2YxOdtF20aJGWL1+uhg0bKn/+/Kpfv75q1679SkG+yLvvvquAgACzsoEDBypfvnzq3LmzsmfPLkdHRwUGBqpGjRqSpAsXLigoKEglSpRI8v6MRqVIYxewNrzvAQDJ5U27pqRPn16zZ8/WoUOHdPbsWUVERKho0aLx5lJ4EScnJxUtWlSBgYHy8/OT9CQJGxgYqNatW8erny9fvnjt3HHjxunBgwf64osvlC1btiTtn3YsbBXvewBAcrKm60qik7YlSpRQiRIlNGjQIG3YsEErVqzQN998o9jYWO3du1fZsmVTunTpkjW4dOnSydPT06wsTZo0ypQpk6m8UaNG+uabb5QxY0alS5dOw4cPl4+Pz0slbQEAAGCbSpcurdKlS7/SNtq3b6/+/fvLy8tL3t7emjt3riIjI013jfXr109Zs2bVp59+Kmdn53jt3Lg7x/5dDgAAANuTpInIpCdJ08aNG6tx48a6cOGCli9frhkzZmjMmDHy9fXVtGnTXkeczzRo0CDZ2dmpd+/eioqKUoUKFTR48OAUjQEAAABvpnnz5iVYbjAY5OzsrNy5c6tMmTKyt7d/4bZq166tW7duacKECQoJCVHhwoU1c+ZM0/AIN27ckJ2dXbLGDwAAgP+mJCdtn5YvXz7169dPn376qX755RctX748ueJ6pvnz55s9d3Z21uDBg0nUAgAAIMnmzJmj27dvKzIyUhkzZpQk3b17V6lTp1aaNGkUFhamXLlyad68ecqePfsLt9e6desEh0OQ4rdj/+2bb75J+gEAAADgPylZfuq3t7eXn59fiveyBQAAAF7FJ598Ii8vL23ZskUHDhzQgQMHtHnzZnl7e+uLL77Qzp075ebmplGjRlk6VAAAANgQ7s8CAACAzRo3bpwGDRqk3Llzm8ry5Mmj/v37a8yYMcqWLZs+//xz/f777xaMEgAAALaGpC0AAABsVkhIiB4/fhyv/PHjxwoNDZUkZcmSRQ8ePEjp0AAAAGDDSNoCAADAZpUtW1aDBw/WH3/8YSr7448/NGTIEL377ruSpD///FMeHh6WChEAAAA26JUmIgMAAADeZCNGjFC/fv3UsGFDOTg8aRrHxMSoXLlyGjFihCQpTZo06t+/vyXDBAAAgI0haQsAAACb5e7urtmzZ+v8+fO6dOmSJOmtt95Svnz5THXietwCAAAAKYWkLQAAAGxe/vz5lT9/fkuHAQAAAEgiaQsAAAAbd/PmTW3fvl03btxQdHS02bKBAwdaKCoAAADYMpK2AAAAsFmBgYHq3r27cuXKpQsXLujtt9/W9evXZTQaVaRIEUuHBwAAABtlZ+kAAAAAAEsZM2aMOnTooICAADk5OWnixInauXOnypQpo5o1a1o6PAAAANgokrYAAACwWefPn1eDBg0kSQ4ODnr48KHSpk2rPn36aObMmZYNDgAAADaLpC0AAABsVpo0aUzj2Lq7u+vKlSumZbdv37ZUWAAAALBxjGkLAAAAm1W8eHEdPnxY+fPnV+XKlfXtt9/qzz//1NatW1W8eHFLhwcAAAAbRdIWAAAANmvgwIF68OCBJKlXr1568OCBNmzYoLx582rAgAEWjg4AAAC2iqQtAAAAbFJMTIxu3rypggULSnoyVMLXX39t4agAAAAAxrQFAACAjbK3t1eHDh109+5dS4cCAAAAmCFpCwAAAJv19ttv69q1a5YOAwAAADBD0hYAAAA26+OPP9a3336rX375RX///bfCw8PN/gEAAACWwJi2AAAAsFldunSRJHXv3l0Gg8FUbjQaZTAYdPr0aUuFBgAAABtG0hYAAAA2a968eZYOAQAAAIiHpC0AAABs1jvvvGPpEAAAAIB4GNMWAAAANu3QoUP67LPP1Lx5cwUHB0uSVq9erUOHDlk4MgAAANgqkrYAAACwWZs3b1bHjh2VKlUqnTp1SlFRUZKk8PBwTZ8+3cLRAQAAwFaRtAUAAIDNmjp1qoYOHarhw4fLweGfkcNKliypP/74w4KRAQAAwJaRtAUAAIDNunjxokqXLh2vPH369Lp3754FIgIAAABI2gIAAMCGubm56cqVK/HKDx8+rFy5clkgIgAAAICkLQAAAGxY06ZNNWLECB07dkwGg0HBwcFau3atvv32W7Vo0cLS4QEAAMBGOby4CgAAAPDf1KVLF8XGxqpdu3aKjIxU69at5eTkpA4dOqhNmzaWDg8AAAA2iqQtAAAAbJbBYFD37t3VsWNHXblyRREREcqfP7/Spk1r6dAAAABgwxgeAQAAADZrzZo1ioyMlJOTkwoUKCBvb28StgAAALA4krYAAACwWaNGjZKvr68+/fRT7dq1SzExMZYOCQAAAGB4BAAAANiuX3/9VXv27NG6dev08ccfK1WqVKpZs6bq1q2rkiVLWjo8AAAA2CiStgAAALBZDg4OqlKliqpUqaLIyEht3bpV69atU9u2bZUtWzZt27bN0iECAADABpG0BQAAACSlTp1aFSpU0L179xQUFKTz589bOiQAAADYKJK2AAAAsGlxPWwDAgIUGBio7Nmzy9/fX+PHj7d0aAAAALBRJG0BAABgs/r27audO3cqVapUqlWrlj766CP5+PhYOiwAAADYOJK2AAAAsFl2dnYaN26cKlSoIHt7e7Nlf/75pzw9PS0UGQAAAGwZSVsAAADYrDFjxpg9Dw8P1/r16/Xzzz/r1KlTOn36tIUiAwAAgC0jaQsAAACbd/DgQS1fvlxbtmxRlixZ9P777+urr76ydFgAAACwUSRtAQAAYJNCQkK0atUqLV++XOHh4apVq5aioqI0efJkFShQwNLhAQAAwIaRtAUAAIDN6datmw4ePKj33ntPgwYNUsWKFWVvb68lS5ZYOjQAAACApC0AAABsz+7du9WmTRu1aNFCefPmtXQ4AAAAgBk7SwcAAAAApLRFixbpwYMHatiwoZo0aaIFCxbo1q1blg4LAAAAkETSFgAAADaoRIkSGj58uH799Vc1a9ZM69evV6VKlRQbG6u9e/cqPDzc0iECAADAhpG0BQAAgM1KkyaNGjdurMWLF2vt2rVq3769ZsyYIV9fX3Xr1s3S4QEAAMBGkbQFAAAAJOXLl0/9+vXTrl279MMPP1g6HAAAANgwJiIDAAAAnmJvby8/Pz/5+flZOhQAAADYKHraAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRUjaAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRUjaAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRUjaAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRUjaAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRUjaAgAAAAAAAIAVIWkLAAAAAAAAAFaEpC0AAAAAAAAAWBGStgAAAAAAAABgRaw6aTt9+nQ1atRIPj4+KleunD766CNduHDBrM6jR480dOhQlS1bVj4+PurVq5dCQ0MtFDEAAABs2cKFC1W1alUVK1ZMTZo00fHjx59Zd9myZWrZsqXKlCmjMmXKqF27ds+tDwAAANth1Unb3377Ta1atdKyZcs0e/ZsPX78WB07dlRERISpzsiRI/XLL79o3Lhxmj9/vv7++2/17NnTglEDAADAFm3YsEGjRo1Sjx49tGrVKhUqVEgdO3ZUWFhYgvUPHDggf39/zZs3T0uWLFH27NnVoUMHBQcHp3DkAAAAsDZWnbSdNWuWGjZsqLfffluFChXSN998o6CgIJ06dUqSdP/+fa1YsUIDBgxQuXLl5OXlpZEjR+rIkSM6evSoZYMHAACATZk9e7aaNm2qRo0aqUCBAho6dKhSpUqlFStWJFh/zJgxatWqlQoXLqz8+fNr+PDhio2NVWBgYApHDgAAAGtj1Unbf7t//74kKWPGjJKkkydPKjo6Wr6+vqY6+fPnV44cOUjaAgAAIMVERUXp1KlTZu1SOzs7+fr66siRI4naRmRkpB4/fmxq6wIAAMB2OVg6gMSKjY3VyJEjVbJkSXl6ekqSQkND5ejoqAwZMpjVdXV1VUhISJL3YTAkS6jAG4f3PgAguaTUNcXarl23b99WTEyMXF1dzcpdXV3jzcnwLN9//72yZMlilvhNLGt7PYCUwnsfAJCcUuK6kth9vDFJ26FDh+qvv/7SokWLXts+XF3Tv7ZtA9bKxSWtpUMAAPxHcE15eT/++KM2bNigefPmydnZOcnr046FLeJvDgAgOVnbdeWNSNp+/fXX2rlzpxYsWKBs2bKZyt3c3BQdHa179+6Z9bYNCwuTu7t7kvcTFnZfRmOyhPxc9vZ2VvdGgO26ffuBYmJiLR0GgJfENQXWJCWvKQaDdSUqXVxcZG9vH2/SsbCwMLm5uT133VmzZunHH3/U7NmzVahQoZfaP+1Y2CLascCbj+sKrElKXVcS24616qSt0WjUsGHDtHXrVs2fP1+5cuUyW+7l5SVHR0cFBgaqRo0akqQLFy4oKChIJUqUeIn9KUUau4C14X0PAEgutnpNcXJyUtGiRRUYGCg/Pz9JMk0q1rp162euN2PGDE2bNk2zZs1SsWLFXnr/tGNhq3jfAwCSkzVdV6w6aTt06FCtW7dOU6ZMUdq0aU3j1KZPn16pUqVS+vTp1ahRI33zzTfKmDGj0qVLp+HDh8vHx+elkrYAAADAy2rfvr369+8vLy8veXt7a+7cuYqMjFTDhg0lSf369VPWrFn16aefSnoyJMKECRM0ZswY5cyZ09TWTZMmjdKmpdcRAACALbPqpO3ixYslSW3atDErHzVqlKnxO2jQINnZ2al3796KiopShQoVNHjw4BSPFQAAALatdu3aunXrliZMmKCQkBAVLlxYM2fONA2PcOPGDdnZ2ZnqL1myRNHR0erdu7fZdnr27KlevXqlaOwAAACwLladtD179uwL6zg7O2vw4MEkagEAAGBxrVu3fuZwCPPnzzd7vmPHjpQICQAAAG8guxdXAYD/a+/Oo3O88/+Pv+4kdyxZLWl+iAbRJkIQIzVURkUHY6mJJUVtE4oy9i05MTNoEVG7TmWaKccytFRUBTE4loytopaJowxVjE5rKSpJJZL8/nDcX7eExJ07ydV4Ps7JObmu+3N9rs91/3F93ud1XwsAAAAAAABKC6EtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABgIoS0AAAAAAAAAGAihLQAAAAAAAAAYCKEtAAAAAAAAABhIuQlt16xZo7CwMAUFBalXr146efJkWQ8JAAAAz5lnrUm3bdumjh07KigoSF27dtXevXtLaaQAAAAwsnIR2m7dulWzZ8/WyJEjlZiYqICAAA0ePFg3btwo66EBAADgOfGsNemxY8c0YcIE9ezZU5s2bVK7du00cuRInT17tpRHDgAAAKMpF6Ht8uXLFRERoR49eqh+/fqaPn26KlasqM8++6yshwYAAIDnxLPWpCtXrlRoaKiGDBkiPz8/jR07VoGBgVq9enUpjxwAAABG41TWAyiurKwspaWladiwYZZ1Dg4OatWqlb766qtn6svBQcrLs/cInyygmrMqOZlKb4fAI3w9zJb/HcrFzzfA883p/wXKZK5U1sPAc8qxWl3L/6U1p5gMVkLZUpMeP35cgwYNslrXunVr7dy585n3Tx2L5wl1LFD+UMuiLJV2LVvUOvYXH9r++OOPysnJUbVq1azWV6tWTRcuXHimvqpWdbPn0Ao19TXvUt0fUJAqVVzKeggA7KDK72PLegjAcz2n2FKTXr9+XdWrV8/X/vr168+8f+pYPI+e53MOUN5Qy8IIjDav8LskAAAAAAAAABjILz60rVKlihwdHfO94OHGjRv5rlwAAAAASoItNWn16tXzXVVLDQsAAACpHIS2zs7OatiwoQ4ePGhZl5ubq4MHDyo4OLgMRwYAAIDnhS01adOmTXXo0CGrdQcOHFDTpk1LcqgAAAD4BfjFh7aS9Ic//EGffvqpEhMTdf78eU2bNk2ZmZnq3r17WQ8NAAAAz4nCatLJkydr3rx5lvYDBgzQ/v379fHHH+v8+fNasmSJ/v3vf6tfv35ldQgAAAAwiF/8i8gkqVOnTrp586YWL16sa9euqUGDBkpISODWMgAAAJSawmrS7777Tg6PvJK4WbNmev/997Vw4ULNnz9fderU0QcffKCXX365rA4BAAAABmHKy8vLK+tBAAAAAAAAAAAeKBePRwAAAAAAAACA8oLQFgAAAAAAAAAMhNAWAAAAAAAAAAyE0BYAABiev7+/du7cafP2S5YsUbdu3SzLUVFRGjFihD2GBgAAADwVtSxs4VTWA0D5ERUVpcTEREmSk5OTvL291bFjR40ZM0YVKlQodPsrV66oXbt2lmWz2awaNWooPDxc77zzjkwmk6QHJ6ulS5fm275u3bravn27JKl///46cuSIJMnZ2Vk1a9ZU9+7dNXToUC1durTA7R/19ddfF+2gAQDF8vjc4eHhIX9/f3Xu3Fndu3eXg8OD35dTUlLk4eFRpD79/f31wQcf6PXXX7esi4yMVL9+/Yo0Dkny9PRUo0aNNGnSJAUEBFj1XZD58+erc+fOOnz4sAYMGGBZX6VKFQUFBWnixIny9/d/4vYP/fGPf9SoUaMKPUYA9kUdCwCwBbWsNWpZ+yK0hV2FhoZq9uzZun//vtLS0jRlyhSZTCZNmjSpyH2sWLFC9evXV1ZWllJTUzV16lR5eXmpV69eljYvvfSSli9fbrWdo6Oj1XJERIRGjx6trKwsHTp0SH/+85/l5uamyMhI9e7d29KuZ8+eioiIUEREhI1HDQAojodzR25urq5fv679+/dr5syZSk5O1ocffignJyd5eXkVax8uLi5ycXEp0jgk6fr161q4cKGGDx+uPXv2WLWbPXu2QkNDrda5u7tbLW/fvl2urq764YcfFBcXp2HDhmnHjh1KSUmxtNm6dasWL15sCWokqXLlyrYcHgA7oI4FANiCWpZatqQQ2sKunJ2dLSejGjVqqFWrVjpw4IAkKSsrS3FxcUpKStLdu3fVqFEjRUdHq3HjxlZ9eHp6WvqoVauWNm7cqNOnT1u1cXR0LPSkV7FiRUubHj16aM2aNTpw4ID69u1rdbJzdHSUi4uLpe3y5cu1ceNGXb58WR4eHmrbtq0mTZpU6AkSAGCbR+cOb29vNWzYUE2aNNGgQYOUmJioXr16WV1xkJWVpdjYWO3YsUO3b99W9erV1bt3bw0bNkxhYWGSpJEjR0p6MI/s3r1bS5Ys0c6dO/X5558XaRxeXl56++239dZbb+nmzZuqWrWqpZ27u3uhc1C1atUs7QYOHKh33nlHFy5csLrSwc3NTSaTqdhFPAD7oI4FANiCWpZatqTwTFuUmLNnz+qrr76S2WyWJMXFxSk5OVmxsbFKTEyUr6+vhgwZolu3bj2xj1OnTiktLU1NmjSxeRx5eXk6evSoLly4YBnL05hMJsXExGjLli2KjY3VoUOHNHfuXJv3DwB4di1btlRAQIB27NiR77NVq1Zp9+7dWrhwobZv3665c+eqVq1akqQNGzZIenAFQUpKimX5WaWnp2vz5s3y9fWVp6enzcfx008/KSkpSZKKNAcBMAbqWABAcVDLwh640hZ2tWfPHgUHB+v+/fvKysqSg4OD/vSnPykjI0Pr1q3T7Nmz1aZNG0nSu+++q3/961/asGGDhgwZYumjd+/ecnBwUHZ2trKzs/Xmm2/q97//vdV+zp49q+DgYKt1Xbt21YwZMyzLa9eu1YYNGyz9VKhQQf379y/0GAYNGmT538fHR2PHjtVf/vIXTZs27dm/EACAzerVq1fgsxm/++47+fr66le/+pVMJpOlyJVkuYqgKFcQPO7hHCZJGRkZ8vLyUnx8vOVZZA+NHz8+363MSUlJqlmzpmX54VyXkZEhSQoLC5Ofn98zjQdA6aKOBQDYE7UsiovQFnbVokULTZs2TZmZmVqxYoUcHR3VoUMHnTlzRtnZ2WrWrJmlrdlsVuPGjXX+/HmrPhYsWCA/Pz/dv39fZ8+e1XvvvSd3d3dNnDjR0qZu3br68MMPrbZzdXW1Wu7atauGDx+u27dva8mSJQoODrba/5McOHBA8fHxunDhgu7evaucnBzdu3dPmZmZqlSpki1fCwDABnl5eZaX9zwqPDxckZGR6tixo0JDQ/Xaa6+pdevWxd7fwzlMkm7fvq21a9fq7bff1vr1662K6ejoaLVq1cpq2xdeeMFqec2aNapYsaJOnDihZcuWafr06cUeH4CSRR0LALAnalkUF6Et7KpSpUry9fWVJM2aNUvdunXT+vXrFRQUVOQ+atSoYenDz89Ply9f1qJFizRq1CjL23vNZrOlzZO4urpa2ixcuFDt27dX06ZN852cHnXlyhUNGzZMffr00bhx4+Th4aHU1FTFxMQoOzubYhcAStH58+fl4+OTb33Dhg21a9cu7du3TwcOHNDYsWPVqlUrLV68uFj7e3QOe7if5s2b69NPP9W4ceMs6728vAqdg3x8fOTu7q569erpxo0bGjdunNasWVOs8QEoWdSxAAB7opZFcfFMW5QYBwcHDRs2TIsWLdKLL74os9msY8eOWT7Pzs7WqVOnVL9+/UL7uX//vrKzs20ei4uLiwYMGKA5c+YoLy/vie3S0tKUl5enqKgoNW3aVHXr1tUPP/xg834BALY5ePCgzp49q/bt2xf4uaurqzp16qT33ntPCxYsUHJysuXZkmazWTk5OcUeg8lkkslk0r1794rVz1tvvaVz587pn//8Z7HHBKB0UMcCAIqDWhb2wJW2KFEdO3ZUXFyc1q5dqz59+iguLk4eHh6qWbOmEhIS9PPPP6tnz55W29y6dUvXrl1TTk6Ovv76a61cuVItWrSwum0sJydH165ds9rOZDKpevXqTxzLm2++qb/+9a9KTk5Wx44dC2zj6+ur7OxsrVq1SmFhYUpNTdW6deuK8Q0AAAqTlZWla9euKTc3V9evX9f+/fsVHx+vtm3b5nsWpPTg7eheXl5q0KCBHBwctH37dnl5ecnd3V3Sg7fsHjx4UM2aNZOzs7M8PDyeaRySdOfOHa1evVoZGRlq27atVbs7d+7km4NcXFxUuXLlAvutVKmSevXqpcWLF+v1118v8DY5AMZDHQsAKApqWZQUQluUKCcnJ/Xr108JCQnatWuX8vLyNHnyZKWnp6tRo0ZKSEjIdwJ6+AIFR0dHeXl5qU2bNlaX8kvSuXPn8j3zxdnZWadOnXriWDw9PdWtWzctXbpU7du3z/cwbkkKCAhQdHS0PvroI82fP1/NmzfX+PHjNWXKFBu/AQBAYfbv36/WrVvLyclJ7u7uCggI0NSpUxUeHl7gudrFxUUJCQn69ttv5eDgoKCgIP3tb3+ztJ0yZYpiY2O1fv16eXt7a/fu3c80jof7qFevnhYtWqQWLVpYtYuOjs637YQJEzR06NAn9t2vXz+tWLFC27ZtU6dOnYo0HgBlizoWAFAU1LIoKaa8p91jAwAAAAAAAAAoVTzTFgAAAAAAAAAMhNAWAAAAAAAAAAyE0BYAAAAAAAAADITQFgAAAAAAAAAMhNAWAAAAAAAAAAyE0BZ29eOPP6ply5a6cuWK3fqMiorSiBEj7NZfUaxdu1bDhw8v1X0CAEpmHjGCjRs3qnnz5pZl5hnAmKhlAQC2oo6FvRHawq6WLVumdu3aKTExUf7+/k/9K6qYmBjFxsZalvv376+ZM2datTl8+LD8/f11584duxxHjx49lJaWpqNHj9qlPwBA0TycR3x8fCzrkpOTNWDAAIWEhKhx48bq0KGDoqOjdfr06TIcafEwzwDGRC0LALAVdSzszamsB4DyIzMzUxs2bNDf//53vfTSS+rdu7fls549eyoiIkIRERHP3K+bm5s9h/lUeXl5ysnJkbOzs7p06aKVK1da/aIEACg5j84jD82dO1fLly9X//79NXr0aNWsWVM3b97Uvn37NG/ePKu2ZSErK0vOzs7PvB3zDGA81LIAAFtRx6IkcKUt7Gbv3r1ydnZW06ZN5eLiIi8vL8ufo6OjZd3HH3+sqVOnWrZbsWKF/P39tW/fPsu63/72t1q/fr0k61vKoqKidOTIEa1cudJylcOVK1c0YMAASVJISIj8/f0VFRUlScrNzVV8fLzCwsLUuHFjvfHGG9q+fbtlPw+vati7d6+6d++uoKAgpaamSpLCwsK0e/du/fzzzyX7xQEAJFnPI5J0/PhxJSQkKCoqStHR0WrevLlq1qypRo0aacSIEUpISLDafufOnQoPD1dQUJDatWunpUuX6v79+5bP/f39tX79eo0cOVJNmjRR+/bttWvXLqs+zp49qyFDhig4OFitWrXSpEmTdPPmTcvn/fv314wZMzRz5ky1aNFCgwcPliQtX75cXbt2VdOmTdWmTRtNmzZN6enpTz1e5hnAWKhlAQC2oo5FSSC0hd0cPXpUDRs2LLRdSEiIUlNTlZOTI0n68ssvVaVKFR05ckSS9P333+vSpUt65ZVX8m0bExOj4OBgRUREKCUlRSkpKapRo4aWLFkiSdq+fbtSUlIUExMjSYqPj9emTZs0ffp0JSUladCgQZo0aZJlXw/NmzdPEyZM0NatWy23uzVq1Eg5OTk6ceKE7V8KAKDIHp9HtmzZosqVK6tv374FtjeZTFbbTpkyRQMGDNDWrVs1Y8YMbdy4UcuWLbPaZunSpfrd736nzZs36ze/+Y0mTpyoW7duSZLu3LmjgQMHKjAwUBs2bFBCQoJu3LihsWPHWvWRmJgos9mstWvXavr06ZaxxMTEaMuWLYqNjdWhQ4c0d+7cpx4v8wxgLNSyAABbUceiJBDawm6uXr2qF154odB2zZs3V3p6uk6fPq28vDwdPXpUkZGRluLz8OHD8vb2lq+vb75t3dzcZDabVbFiRasrHzw8PCRJ1apVk5eXl9zc3JSVlaX4+HjNmjVLoaGhql27trp376433nhDn3zyiVW/o0eP1quvvqoXX3xRnp6ekqRKlSrJzc1NV69eLeY3AwAoisfnkYsXL6p27dpycvq/pzktX75cwcHBlr+ffvpJ0oMidujQoQoPD1ft2rX16quvasyYMVq3bp3VPsLDw9WlSxf5+vpq/PjxysjI0MmTJyVJq1evVmBgoMaPHy8/Pz8FBgZq1qxZOnz4sL755htLH3Xq1NHkyZNVr1491atXT5I0aNAg/frXv5aPj49atmypsWPHatu2bU89XuYZwFioZQEAtqKORUngmbawm3v37qlChQqFtnN3d1dAQICOHDkis9kss9msiIgILV68WOnp6fryyy8VEhJS7PF8++23yszMVGRkpNX67OxsNWjQwGpdUFBQgX1UqFBBmZmZxR4LAKBwRZlHevToobCwMJ04cUKTJk1SXl6eJOnMmTM6duyY1RUJOTk5unfvnjIzM1WpUiVJsnp5UOXKleXq6mq5bezMmTM6fPiwgoOD8+330qVLqlu3riQVeCXegQMHFB8frwsXLuju3bsF7rsgzDOAcVDLAgBsRR2LkkBoC7vx9PQs8htvX3nlFR05ckTOzs4KCQmRp6en/Pz8lJqaqiNHjuQrTm2RkZEh6cFtZd7e3lafPf6w7SediG7fvq2qVasWeywAgMI9Po/UqVNHqampys7OltlslvQgLHF3d9f//vc/q20zMjI0atQotW/fPl+/jxbQD/t5yGQyKTc319JH27ZtNXHixHx9eHl5Wf5/fM64cuWKhg0bpj59+mjcuHHy8PBQamqqYmJilJ2d/dRil3kGMA5qWQCArahjURIIbWE3gYGB2rx5c5HahoSE6LPPPpOjo6NCQ0MlPSh+k5KSdPHixQKfAfaQ2Wy2nJgeXSfJ8mwxSfLz85Ozs7OuXr361P6e5NKlS7p3754CAwOfeVsAwLN7fB7p3LmzVq1apX/84x8aOHBgodt+8803Bd6OXFQNGzZUcnKyatWqZXUrW2HS0tKUl5enqKgoOTg8ePJUYbeUScwzgNFQywIAbEUdi5LAM21hN61bt9Z//vMf3b59u9C2ISEhSk9P1549eyxFaIsWLfTFF1/Iy8vLcul+QWrVqqUTJ07oypUrunnzpnJzc1WrVi2ZTCbt2bNHN2/eVHp6ulxdXRUZGanZs2crMTFRly5dUlpamlatWqXExMRCx3j06FHVrl1bL774YtG/BACAzR6fR4KDgxUZGak5c+Zo9uzZOnr0qP773//q+PHj2rBhg0wmk6W4HDlypD7//HMtXbpU586d0/nz55WUlKQFCxYUef99+/bV7du3NX78eJ08eVKXLl3S/v37FR0dbRWkPM7X11fZ2dlatWqVLl++rE2bNuV7BllBmGcAY6GWBQDYijoWJYHQFnbj7++vwMDAIv0q4+HhoZdffllVq1aVn5+fpAcvdcjNzS30SoLIyEg5Ojqqc+fOatmypa5evSpvb2+NGjVK8+bNU6tWrfTuu+9KksaOHasRI0YoPj5enTp10pAhQ7Rnzx75+PgUOsakpCRFREQU4cgBAPZQ0DwyZcoUvf/++zp9+rSGDx+uDh06aMyYMcrNzdUnn3wiV1dXSVJoaKiWLVumlJQU9ezZUxEREVqxYoVq1apV5P17e3tr7dq1ys3N1eDBg9W1a1fNmjVLbm5ulqK6IAEBAYqOjtZHH32kLl266IsvvtD48eML3R/zDGAs1LIAAFtRx6IkmPIePvkYsIM9e/YoLi5OW7ZseeqJwejOnTungQMHKjk5WW5ubmU9HAB4bpSXeaQwzDOAMZWXcxDnGAAofeVlDikMc0zp4Zm2sKvXXntNFy9e1Pfff68aNWqU9XBsdu3aNc2ZM4cTEACUsvIyjxSGeQYwpvJyDuIcAwClr7zMIYVhjik9XGkLAAAAAAAAAAZSfq/XBgAAAAAAAIBfIEJbAAAAAAAAADAQQlsAAAAAAAAAMBBCWwAAAAAAAAAwEEJbAAAAAAAAADAQQlsAAAAAAAAAMBBCWwAAAAAAAAAwEEJbAAAAAAAAADAQQlsAAAAAAAAAMJD/D5TVm/4CrYGNAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model comparison plot saved as model_comparison.png\n" + ] + } + ], + "source": [ + "# Visualize model comparison\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "# Accuracy comparison\n", + "models = ['RoBERTa\\n(Twitter)', 'DistilBERT\\n(General)']\n", + "accuracies = [roberta_acc, distilbert_acc]\n", + "colors_bar = ['#3498db', '#e67e22']\n", + "bars = axes[0].bar(models, accuracies, color=colors_bar, width=0.4)\n", + "axes[0].set_title('Model Accuracy Comparison')\n", + "axes[0].set_ylabel('Accuracy (%)')\n", + "axes[0].set_ylim(0, 100)\n", + "for bar, acc in zip(bars, accuracies):\n", + " axes[0].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,\n", + " f'{acc:.1f}%', ha='center', fontweight='bold')\n", + "\n", + "# Confidence comparison\n", + "confidences = [roberta_conf, distilbert_conf]\n", + "bars2 = axes[1].bar(models, confidences, color=colors_bar, width=0.4)\n", + "axes[1].set_title('Average Model Confidence Comparison')\n", + "axes[1].set_ylabel('Average Confidence Score')\n", + "axes[1].set_ylim(0, 1)\n", + "for bar, conf in zip(bars2, confidences):\n", + " axes[1].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,\n", + " f'{conf:.4f}', ha='center', fontweight='bold')\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('model_comparison.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Model comparison plot saved as model_comparison.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 12: Anomaly Detection\n", + "Detect sudden spikes in sentiment using rolling statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Anomaly Detection: Sentiment Spikes ===\n", + "Total anomalies detected: 56\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anomaly detection plot saved as anomaly_detection.png\n" + ] + } + ], + "source": [ + "# Anomaly Detection: Detect sudden spikes in sentiment\n", + "# A spike is defined as a sudden shift in rolling sentiment percentage\n", + "print('=== Anomaly Detection: Sentiment Spikes ===')\n", + "\n", + "# Compute rolling mean and std\n", + "window_anomaly = 20\n", + "df_trend['rolling_mean'] = df_trend['rolling_positive'].rolling(window_anomaly, min_periods=1).mean()\n", + "df_trend['rolling_std'] = df_trend['rolling_positive'].rolling(window_anomaly, min_periods=1).std().fillna(0)\n", + "\n", + "# Detect spikes: points more than 2 std deviations from rolling mean\n", + "df_trend['upper_bound'] = df_trend['rolling_mean'] + 2 * df_trend['rolling_std']\n", + "df_trend['lower_bound'] = df_trend['rolling_mean'] - 2 * df_trend['rolling_std']\n", + "df_trend['is_spike'] = (\n", + " (df_trend['rolling_positive'] > df_trend['upper_bound']) |\n", + " (df_trend['rolling_positive'] < df_trend['lower_bound'])\n", + ")\n", + "\n", + "spikes = df_trend[df_trend['is_spike']]\n", + "print(f'Total anomalies detected: {len(spikes)}')\n", + "\n", + "# Plot anomaly detection\n", + "plt.figure(figsize=(14, 6))\n", + "plt.plot(df_trend.index, df_trend['rolling_positive'],\n", + " label='Positive Sentiment %', color=SENTIMENT_COLORS['positive'], linewidth=2)\n", + "plt.fill_between(df_trend.index,\n", + " df_trend['lower_bound'],\n", + " df_trend['upper_bound'],\n", + " alpha=0.2, color='gray', label='Normal Range (2 std)')\n", + "plt.scatter(spikes.index, spikes['rolling_positive'],\n", + " color='red', s=100, zorder=5, label=f'Anomalies ({len(spikes)})')\n", + "plt.title('Sentiment Anomaly Detection: Positive Sentiment Spikes')\n", + "plt.xlabel('Tweet Index')\n", + "plt.ylabel('Positive Sentiment % (Rolling)')\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.savefig('anomaly_detection.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Anomaly detection plot saved as anomaly_detection.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenges and What I Learned\n", + "\n", + "### 1. Docker memory for HuggingFace model\n", + "The RoBERTa model requires about 500MB of RAM to load. I had to increase\n", + "Docker Desktop memory allocation to at least 4GB to avoid out-of-memory errors.\n", + "\n", + "### 2. Kafka broker address inside Docker\n", + "Same issue as my other Kafka project - had to use `kafka:29092` instead\n", + "of `localhost:9092` for internal Docker container communication.\n", + "\n", + "### 3. Model labels are not human readable\n", + "The cardiffnlp model returns `LABEL_0`, `LABEL_1`, `LABEL_2` instead of\n", + "negative/neutral/positive. I had to create a mapping dictionary to translate them.\n", + "\n", + "### 4. Sentiment140 only has binary labels\n", + "The dataset only has positive and negative labels (0 and 4). The model\n", + "also predicts neutral which the dataset does not have, so accuracy\n", + "is measured only on positive/negative predictions.\n", + "\n", + "### Key takeaway\n", + "Combining Kafka with an NLP model is a powerful pattern for real-time\n", + "opinion mining. The architecture scales naturally - you can add more\n", + "Kafka partitions and more consumer instances to handle higher tweet volumes." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment_utils.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment_utils.py new file mode 100644 index 000000000..504d51b24 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/kafka_sentiment_utils.py @@ -0,0 +1,177 @@ +""" +Utility functions for the Real-Time Tweet Sentiment Analysis Pipeline. +Uses Apache Kafka for streaming and HuggingFace Transformers for sentiment classification. +""" +import json +import random +import pandas as pd +import numpy as np +from datetime import datetime +from typing import Dict, List, Optional, Tuple + +# Kafka topic name +TOPIC_NAME = "tweets" + +# Sentiment labels from cardiffnlp/twitter-roberta-base-sentiment +SENTIMENT_LABELS = { + "LABEL_0": "negative", + "LABEL_1": "neutral", + "LABEL_2": "positive", +} + +# Sentiment colors for visualization +SENTIMENT_COLORS = { + "positive": "#2ecc71", + "neutral": "#3498db", + "negative": "#e74c3c", +} + + +def load_sentiment140(filepath: str, n_samples: int = 10000, random_state: int = 42) -> pd.DataFrame: + """ + Load and preprocess the Sentiment140 dataset. + + Args: + filepath: Path to training.1600000.processed.noemoticon.csv + n_samples: Number of samples to load (default 10000 for speed) + random_state: Random seed for reproducibility + + Returns: + DataFrame with columns: text, label, sentiment + """ + # Sentiment140 columns + cols = ["label", "id", "date", "query", "user", "text"] + df = pd.read_csv(filepath, encoding="latin-1", names=cols) + + # Map labels: 0 = negative, 4 = positive + df = df[df["label"].isin([0, 4])].copy() + df["sentiment"] = df["label"].map({0: "negative", 4: "positive"}) + + # Sample equally from positive and negative + n_each = n_samples // 2 + df_neg = df[df["sentiment"] == "negative"].sample(n_each, random_state=random_state) + df_pos = df[df["sentiment"] == "positive"].sample(n_each, random_state=random_state) + df_sampled = pd.concat([df_neg, df_pos]).sample(frac=1, random_state=random_state) + + return df_sampled[["text", "label", "sentiment"]].reset_index(drop=True) + + +def preprocess_tweet(text: str) -> str: + """ + Clean and preprocess a tweet for sentiment analysis. + + Args: + text: Raw tweet text + + Returns: + Cleaned tweet text + """ + import re + # Remove URLs + text = re.sub(r"http\S+|www\S+", "", text) + # Remove @mentions + text = re.sub(r"@\w+", "@user", text) + # Remove extra whitespace + text = " ".join(text.split()) + return text.strip() + + +def create_tweet_event(text: str, true_label: str, tweet_id: int) -> Dict: + """ + Create a tweet event dictionary for Kafka. + + Args: + text: Tweet text + true_label: True sentiment label from dataset + tweet_id: Unique tweet identifier + + Returns: + Tweet event dictionary + """ + return { + "tweet_id": tweet_id, + "text": preprocess_tweet(text), + "true_label": true_label, + "timestamp": datetime.now().isoformat(), + } + + +def serialize_event(event: Dict) -> bytes: + """ + Serialize a tweet event to JSON bytes for Kafka. + + Args: + event: Tweet event dictionary + + Returns: + JSON-encoded bytes + """ + return json.dumps(event).encode("utf-8") + + +def deserialize_event(data: bytes) -> Dict: + """ + Deserialize a Kafka message to a tweet event dictionary. + + Args: + data: JSON-encoded bytes from Kafka + + Returns: + Tweet event dictionary + """ + return json.loads(data.decode("utf-8")) + + +def compute_sentiment_stats(results: List[Dict]) -> Dict: + """ + Compute sentiment statistics from a list of classified tweets. + + Args: + results: List of dicts with keys: text, predicted_sentiment, true_label, score + + Returns: + Dictionary with sentiment statistics + """ + df = pd.DataFrame(results) + total = len(df) + + stats = { + "total": total, + "positive": int((df["predicted_sentiment"] == "positive").sum()), + "negative": int((df["predicted_sentiment"] == "negative").sum()), + "neutral": int((df["predicted_sentiment"] == "neutral").sum()), + } + stats["positive_pct"] = round(stats["positive"] / total * 100, 2) + stats["negative_pct"] = round(stats["negative"] / total * 100, 2) + stats["neutral_pct"] = round(stats["neutral"] / total * 100, 2) + + # Accuracy (compare predicted vs true label, ignoring neutral) + df_binary = df[df["true_label"].isin(["positive", "negative"])].copy() + if len(df_binary) > 0: + correct = (df_binary["predicted_sentiment"] == df_binary["true_label"]).sum() + stats["accuracy"] = round(correct / len(df_binary) * 100, 2) + else: + stats["accuracy"] = None + + return stats + + +def format_sentiment_summary(stats: Dict) -> str: + """ + Format sentiment statistics for display. + + Args: + stats: Dictionary from compute_sentiment_stats() + + Returns: + Formatted summary string + """ + lines = [ + f"Total tweets analyzed : {stats['total']}", + f"Positive : {stats['positive']} ({stats['positive_pct']}%)", + f"Negative : {stats['negative']} ({stats['negative_pct']}%)", + f"Neutral : {stats['neutral']} ({stats['neutral_pct']}%)", + ] + if stats.get("accuracy"): + lines.append(f"Model accuracy : {stats['accuracy']}%") + return "\n".join(lines) diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/requirements.txt b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/requirements.txt new file mode 100644 index 000000000..263308c2b --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/requirements.txt @@ -0,0 +1,14 @@ +kafka-python==2.0.2 +pyspark==3.5.1 +pandas==2.1.0 +numpy==1.26.0 +matplotlib==3.7.0 +seaborn==0.13.0 +transformers==4.35.0 +torch==2.1.0 +findspark==2.0.1 +wordcloud==1.9.2 +tqdm==4.66.1 +streamlit==1.28.0 +plotly==6.7.0 +scikit-learn==1.3.0 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/run_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/run_jupyter.sh new file mode 100644 index 000000000..d725c3fe7 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/run_jupyter.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# """ +# Launch Jupyter Lab server. +# +# This script starts Jupyter Lab on port 8888 with the following configuration: +# - No browser auto-launch (useful for Docker containers) +# - Accessible from any IP address (0.0.0.0) +# - Root user allowed (required for Docker environments) +# - No authentication token or password (for development convenience) +# - Vim keybindings can be enabled via JUPYTER_USE_VIM environment variable +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Print each command to stdout before executing it. +#set -x + +# Import the utility functions from /git_root. +GIT_ROOT=/git_root +source $GIT_ROOT/class_project/project_template/utils.sh + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Setup Jupyter Lab environment. +setup_jupyter_environment + +# Initialize Jupyter Lab command with base configuration. +JUPYTER_ARGS=$(get_jupyter_args) + +# Start Jupyter Lab with development-friendly settings. +run "jupyter lab $JUPYTER_ARGS" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/utils.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/utils.sh new file mode 100644 index 000000000..cc0ed8c4a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/utils.sh @@ -0,0 +1,607 @@ +#!/bin/bash +# """ +# Utility functions for Docker container management. +# """ + + +# ############################################################################# +# General utilities +# ############################################################################# + + +run() { + # """ + # Execute a command with echo output. + # + # :param cmd: Command string to execute + # :return: Exit status of the executed command + # """ + cmd="$*" + echo "> $cmd" + eval "$cmd" +} + + +enable_verbose_mode() { + # """ + # Enable shell command tracing (set -x) when VERBOSE is set to 1. + # + # Reads the VERBOSE variable set by parse_docker_jupyter_args. + # Call this after parsing args to activate tracing for the rest of the script. + # """ + if [[ $VERBOSE == 1 ]]; then + set -x + fi +} + + +# ############################################################################# +# Argument parsing +# ############################################################################# + + +_print_default_help() { + # """ + # Print usage information and available default options for docker scripts. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -v Enable verbose output (set -x)" +} + + +parse_default_args() { + # """ + # Parse default command-line arguments for docker scripts. + # + # Sets VERBOSE and FORCE variables in the caller's scope. Enables set -x + # when -v is passed. Prints help and exits when -h is passed. + # Updates OPTIND so the caller can shift away processed arguments. + # + # :param @: command-line arguments forwarded from the calling script + # """ + VERBOSE=0 + FORCE=0 + while getopts "fhv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_default_help; exit 0;; + v) VERBOSE=1;; + *) _print_default_help; exit 1;; + esac + done + enable_verbose_mode +} + + +_print_docker_jupyter_help() { + # """ + # Print usage information and available options for docker_jupyter.sh. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Launch Jupyter Lab inside a Docker container." + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -p PORT Host port to forward to Jupyter Lab (default: 8888)" + echo " -u Enable vim keybindings in Jupyter Lab" + echo " -v Enable verbose output (set -x)" +} + + +parse_docker_jupyter_args() { + # """ + # Parse command-line arguments for docker_jupyter.sh. + # + # Sets JUPYTER_HOST_PORT, JUPYTER_USE_VIM, TARGET_DIR, VERBOSE, FORCE, and + # OLD_CMD_OPTS in the caller's scope. Enables set -x when -v is passed. + # Prints help and exits when -h is passed. + # + # :param @: command-line arguments forwarded from the calling script + # """ + # Set defaults. + JUPYTER_HOST_PORT=8888 + JUPYTER_USE_VIM=0 + VERBOSE=0 + FORCE=0 + # Save original args to pass through to run_jupyter.sh. + OLD_CMD_OPTS="$*" + # Parse options. + while getopts "fhp:uv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_docker_jupyter_help; exit 0;; + p) JUPYTER_HOST_PORT=${OPTARG};; # Port for Jupyter Lab. + u) JUPYTER_USE_VIM=1;; # Enable vim bindings. + v) VERBOSE=1;; # Enable verbose output. + *) _print_docker_jupyter_help; exit 1;; + esac + done + # Enable command tracing if verbose mode is requested. + enable_verbose_mode +} + + +# ############################################################################# +# Docker image management +# ############################################################################# + + +get_docker_vars_script() { + # """ + # Load Docker variables from docker_name.sh script. + # + # :param script_path: Path to the script to determine the Docker configuration directory + # :return: Sources REPO_NAME, IMAGE_NAME, and FULL_IMAGE_NAME variables + # """ + local script_path=$1 + # Find the name of the container. + SCRIPT_DIR=$(dirname $script_path) + DOCKER_NAME="$SCRIPT_DIR/docker_name.sh" + if [[ ! -e $SCRIPT_DIR ]]; then + echo "Can't find $DOCKER_NAME" + exit -1 + fi; + source $DOCKER_NAME +} + + +print_docker_vars() { + # """ + # Print current Docker variables to stdout. + # """ + echo "REPO_NAME=$REPO_NAME" + echo "IMAGE_NAME=$IMAGE_NAME" + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" +} + + +build_container_image() { + # """ + # Build a Docker container image. + # + # Supports both single-architecture and multi-architecture builds. + # Creates temporary build directory, copies files, and builds the image. + # + # :param @: Additional options to pass to docker build/buildx build + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + # Prepare build area. + #tar -czh . | docker build $OPTS -t $IMAGE_NAME - + DIR="../tmp.build" + if [[ -d $DIR ]]; then + rm -rf $DIR + fi; + cp -Lr . $DIR || true + # Build container. + echo "DOCKER_BUILDKIT=$DOCKER_BUILDKIT" + echo "DOCKER_BUILD_MULTI_ARCH=$DOCKER_BUILD_MULTI_ARCH" + if [[ $DOCKER_BUILD_MULTI_ARCH != 1 ]]; then + # Build for a single architecture. + echo "Building for current architecture..." + OPTS="--progress plain $@" + (cd $DIR; docker build $OPTS -t $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + else + # Build for multiple architectures. + echo "Building for multiple architectures..." + OPTS="$@" + export DOCKER_CLI_EXPERIMENTAL=enabled + # Create a new builder. + #docker buildx rm --all-inactive --force + #docker buildx create --name mybuilder + #docker buildx use mybuilder + # Use the default builder. + docker buildx use multiarch + docker buildx inspect --bootstrap + # Note that one needs to push to the repo since otherwise it is not + # possible to keep multiple. + (cd $DIR; docker buildx build --push --platform linux/arm64,linux/amd64 $OPTS --tag $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + # Report the status. + docker buildx imagetools inspect $FULL_IMAGE_NAME + fi; + # Report build version. + if [ -f docker_build.version.log ]; then + rm docker_build.version.log + fi + (cd $DIR; docker run --rm -it -v $(pwd):/data $FULL_IMAGE_NAME bash -c "/data/version.sh") 2>&1 | tee docker_build.version.log + # + docker image ls $REPO_NAME/$IMAGE_NAME + rm -rf $DIR + echo "*****************************" + echo "SUCCESS" + echo "*****************************" +} + + +remove_container_image() { + # """ + # Remove Docker container image(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker image ls | grep $FULL_IMAGE_NAME + docker image ls | grep $FULL_IMAGE_NAME | awk '{print $1}' | xargs -n 1 -t docker image rm -f + docker image ls + echo "${FUNCNAME[0]} ... done" +} + + +push_container_image() { + # """ + # Push Docker container image to registry. + # + # Authenticates using credentials from ~/.docker/passwd.$REPO_NAME.txt. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker login --username $REPO_NAME --password-stdin <~/.docker/passwd.$REPO_NAME.txt + docker images $FULL_IMAGE_NAME + docker push $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +pull_container_image() { + # """ + # Pull Docker container image from registry. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker pull $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker container management +# ############################################################################# + + +kill_container() { + # """ + # Kill and remove Docker container(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + if [[ ! -z $CONTAINER_ID ]]; then + docker container rm -f $CONTAINER_ID + docker container ls + fi; + echo "${FUNCNAME[0]} ... done" +} + + +kill_container_by_name() { + # """ + # Kill and remove a Docker container by its name. + # + # :param container_name: Name of the container to kill + # """ + local container_name=$1 + echo "# ${FUNCNAME[0]}: $container_name" + # Check if container exists (running or stopped). + local container_id=$(docker container ls -a --filter "name=^${container_name}$" --format "{{.ID}}") + if [[ -n $container_id ]]; then + echo "Killing container: $container_name (ID: $container_id)" + docker container rm -f $container_id + else + echo "Container '$container_name' not found" + fi + echo "${FUNCNAME[0]} ... done" +} + + +exec_container() { + # """ + # Execute bash shell in running Docker container. + # + # Opens an interactive bash session in the first container matching the + # current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + docker exec -it $CONTAINER_ID bash + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker common options +# ############################################################################# + + +get_docker_common_options() { + # """ + # Return docker run options common to all container types. + # + # Includes volume mount for the git root, plus environment variables for + # PYTHONPATH and host OS name. + # + # :return: docker run options string with volume mounts and env vars + # """ + echo "-v $GIT_ROOT:/git_root \ + -e PYTHONPATH=/git_root:/git_root/helpers_root:/git_root/msml610/tutorials \ + -e CSFY_GIT_ROOT_PATH=/git_root \ + -e CSFY_HOST_OS_NAME=$(uname -s) \ + -e CSFY_HOST_NAME=$(uname -n)" +} + + +# ############################################################################# +# Docker bash +# ############################################################################# + + +get_docker_bash_command() { + # """ + # Return the base docker run command for an interactive bash shell. + # + # :return: docker run command string with --rm and -ti flags + # """ + if [ -t 0 ]; then + echo "docker run --rm -ti" + else + echo "docker run --rm -i" + fi +} + + +get_docker_bash_options() { + # """ + # Return docker run options for a Docker container. + # + # :param container_name: Name for the Docker container + # :param port: Port number to forward (optional, skipped if empty) + # :param extra_opts: Additional docker run options (optional) + # :return: docker run options string with name, volume mounts, and env vars + # """ + local container_name=$1 + local port=$2 + local extra_opts=$3 + local port_opt="" + if [[ -n $port ]]; then + port_opt="-p $port:$port" + fi + echo "--name $container_name \ + $port_opt \ + $extra_opts \ + $(get_docker_common_options)" +} + + +# ############################################################################# +# Docker cmd +# ############################################################################# + + +get_docker_cmd_command() { + # """ + # Return the base docker run command for executing a non-interactive command. + # + # :return: docker run command string with --rm and -i flags + # """ + echo "docker run --rm -i" +} + + +# ############################################################################# +# Docker Jupyter +# ############################################################################# + + +get_docker_jupyter_command() { + # """ + # Return the base docker run command for running Jupyter Lab interactively. + # + # :return: docker run command string with --rm and -ti flags (if TTY available) + # """ + local docker_cmd="docker run --rm" + # Add interactive and TTY flags only if stdin is a TTY. + if [[ -t 0 ]]; then + docker_cmd="$docker_cmd -ti" + fi + echo "$docker_cmd" +} + + +get_docker_jupyter_options() { + # """ + # Return docker run options for a Jupyter Lab container. + # + # :param container_name: Name for the Docker container + # :param host_port: Host port to forward to container port 8888 + # :param jupyter_use_vim: 0 or 1 to enable vim bindings + # :return: docker run options string + # """ + local container_name=$1 + local host_port=$2 + local jupyter_use_vim=$3 + # Run as the current user when user is saggese. + if [[ "$(whoami)" == "saggese" ]]; then + echo "Overwriting jupyter_use_vim since user='saggese'" >&2 + jupyter_use_vim=1 + fi + echo "--name $container_name \ + -p $host_port:8888 \ + $(get_docker_common_options) \ + -e JUPYTER_USE_VIM=$jupyter_use_vim" +} + + +configure_jupyter_vim_keybindings() { + # """ + # Configure JupyterLab vim keybindings based on JUPYTER_USE_VIM env var. + # + # Reads JUPYTER_USE_VIM; if 1, verifies jupyterlab_vim is installed and + # writes enabled settings; otherwise writes disabled settings. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@axlair/jupyterlab_vim + if [[ $JUPYTER_USE_VIM == 1 ]]; then + # Check that jupyterlab_vim is installed before trying to enable it. + if ! pip show jupyterlab_vim > /dev/null 2>&1; then + echo "ERROR: jupyterlab_vim is not installed but vim bindings were requested." + echo "Install it with: pip install jupyterlab_vim" + exit 1 + fi + echo "Enabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": true, + "enabledInEditors": true, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + else + echo "Disabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": false, + "enabledInEditors": false, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + fi; +} + + +configure_jupyter_notifications() { + # """ + # Disable JupyterLab news fetching and update checks. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/apputils-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/apputils-extension/notification.jupyterlab-settings +{ + // Notifications + // @jupyterlab/apputils-extension:notification + // Notifications settings. + + // Fetch official Jupyter news + // Whether to fetch news from the Jupyter news feed. If Always (`true`), it will make a request to a website. + "fetchNews": "false", + "checkForUpdates": false +} +EOF +} + + +configure_jupyter_autosave() { + # """ + # Configure JupyterLab global autosave interval to 6 seconds. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/docmanager-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/docmanager-extension/plugin.jupyterlab-settings +{ + "autosaveInterval": 6 +} +EOF +} + + +check_jupytext_installed() { + # """ + # Verify that jupytext is installed before starting Jupyter Lab. + # + # Jupytext is required for pair notebook/Python file functionality. + # Exits with error if jupytext is not installed. + # """ + if ! pip show jupytext > /dev/null 2>&1; then + echo "ERROR: jupytext is not installed but is required to run Jupyter Lab." + echo "Install it with: pip install jupytext" + exit 1 + fi +} + + +setup_jupyter_environment() { + # """ + # Configure Jupyter Lab environment before launching. + # + # Performs all necessary setup steps: + # - Configure vim keybindings + # - Disable notifications + # - Configure autosave interval + # - Verify jupytext is installed + # """ + configure_jupyter_vim_keybindings + configure_jupyter_notifications + configure_jupyter_autosave + check_jupytext_installed +} + + +get_jupyter_args() { + # """ + # Print the standard Jupyter Lab command-line arguments. + # + # :return: space-separated Jupyter Lab args for port 8888 with no browser, + # allow root, and no authentication + # """ + echo "--port=8888 --no-browser --ip=0.0.0.0 --allow-root --ServerApp.token='' --ServerApp.password=''" +} + + +get_run_jupyter_cmd() { + # """ + # Return the command to run run_jupyter.sh inside a container. + # + # Computes the script's path relative to GIT_ROOT and builds the + # corresponding /git_root/... path used inside the container. + # + # :param script_path: path of the calling script (pass ${BASH_SOURCE[0]}) + # :param cmd_opts: options to forward to run_jupyter.sh + # :return: full command string to run run_jupyter.sh + # """ + local script_path=$1 + local cmd_opts=$2 + local script_dir + script_dir=$(cd "$(dirname "$script_path")" && pwd) + local rel_dir="${script_dir#${GIT_ROOT}/}" + echo "/git_root/${rel_dir}/run_jupyter.sh $cmd_opts" +} + + +list_and_inspect_docker_image() { + # """ + # List available Docker images and inspect their architecture. + # + # Lists all images matching FULL_IMAGE_NAME and attempts to inspect + # their architecture using docker manifest inspect. + # """ + run "docker image ls $FULL_IMAGE_NAME" + (docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true +} + + +kill_existing_container_if_forced() { + # """ + # Kill existing container if FORCE flag is set. + # + # If FORCE is set to 1, kills and removes the container with name + # CONTAINER_NAME. This is typically set by the -f flag. + # """ + if [[ $FORCE == 1 ]]; then + kill_container_by_name $CONTAINER_NAME + fi +} diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/version.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/version.sh new file mode 100644 index 000000000..c46ed254c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Tweet_Sentiment_Analysis_Kafka/version.sh @@ -0,0 +1,28 @@ +#!/bin/bash +# """ +# Display versions of installed tools and packages. +# +# This script prints version information for Python, pip, Jupyter, and all +# installed Python packages. Used for debugging and documentation purposes +# to verify the Docker container environment setup. +# """ + +# Display Python 3 version. +echo "# Python3" +python3 --version + +# Display pip version. +echo "# pip3" +pip3 --version + +# Display Jupyter version. +echo "# jupyter" +jupyter --version + +# List all installed Python packages and their versions. +echo "# Python packages" +pip3 list + +# Template for adding additional tool versions. +# echo "# mongo" +# mongod --version