diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/Dockerfile b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/Dockerfile new file mode 100644 index 000000000..0448d1e3e --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/Dockerfile @@ -0,0 +1,70 @@ +FROM ubuntu:20.04 +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update && apt-get install -y \ + wget curl unzip gnupg \ + sudo git vim \ + python3 python3-pip python3-dev \ + build-essential libffi-dev libssl-dev libpng-dev libjpeg-dev \ + libfreetype6-dev gfortran libopenblas-dev liblapack-dev \ + libnss3 libatk-bridge2.0-0 libgtk-3-0 libx11-xcb1 \ + libxcomposite1 libxcursor1 libxdamage1 libxi6 libxtst6 \ + libxrandr2 libasound2 libpangocairo-1.0-0 libpangoft2-1.0-0 \ + fonts-liberation libgbm1 xdg-utils ca-certificates \ + && apt-get clean && rm -rf /var/lib/apt/lists/* + + +# Install Chrome +RUN wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | apt-key add - && \ + echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" > /etc/apt/sources.list.d/google-chrome.list && \ + apt-get update && apt-get install -y google-chrome-stable && \ + rm -rf /var/lib/apt/lists/* + +# Set ChromeDriver version matching Chrome 136 +ENV CHROMEDRIVER_VERSION=136.0.7103.113 + +# Install ChromeDriver manually +RUN wget -O /tmp/chromedriver.zip "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/${CHROMEDRIVER_VERSION}/linux64/chromedriver-linux64.zip" && \ + unzip -o /tmp/chromedriver.zip -d /tmp/ && \ + mv /tmp/chromedriver-linux64/chromedriver /usr/local/bin/chromedriver && \ + chmod +x /usr/local/bin/chromedriver && \ + rm -rf /tmp/chromedriver.zip /tmp/chromedriver-linux64 + + +# Upgrade pip and install core Python dependencies +RUN python3 -m pip install --upgrade pip setuptools wheel && \ + pip3 install numpy==1.24.4 && \ + pip3 install "cython<3" "blis<0.8" "thinc<8.2" "murmurhash<1.1.0" "cymem<2.1.0" "preshed<3.1.0" + +# Now install high-level packages that depend on those +RUN pip3 install spacy==3.5.4 && \ + python3 -m spacy download en_core_web_sm && \ + pip3 install \ + ipython \ + notebook \ + psycopg2-binary \ + yapf \ + selenium \ + pandas \ + matplotlib \ + requests \ + vaderSentiment \ + jupyter \ + seaborn \ + scipy + +# Download spaCy model +RUN python3 -m spacy download en_core_web_sm + +# Copy your local files into the container +COPY . /data +WORKDIR /data + +# Optional scripts (handle gracefully if not present) +RUN bash /data/install_jupyter_extensions.sh || true +RUN bash /data/version.sh || true + +# Jupyter exposed +EXPOSE 8888 +CMD ["jupyter-notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''", "--NotebookApp.password=''"] + diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/README.md b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/README.md new file mode 100644 index 000000000..500e6a0f7 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/README.md @@ -0,0 +1,217 @@ +# Real-Time Bitcoin Sentiment Analysis with spaCy and Selenium + +**Author**: Siddhi Rohan +**UID**: 121302823 +**Course**: DATA605 — Spring 2025 + +## Project Overview and Goals + +This project, **TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium**, is a real-time sentiment analysis pipeline focused on Bitcoin-related tweets from X (Twitter). It leverages Selenium for web scraping, spaCy for natural language processing, VADER for sentiment analysis, and the CoinGecko API for Bitcoin price data, with results visualized in Jupyter notebooks. Developed for the DATA605 course in Spring 2025, the pipeline analyzes public sentiment and its correlation with Bitcoin price trends. + +### Goals +- **Data Collection**: Scrape tweets containing keywords "Bitcoin" and "BTC" to capture public sentiment. +- **Sentiment Analysis**: Use VADER to analyze tweet sentiment, categorizing tweets as positive, negative, or neutral. +- **Correlation Analysis**: Compute multiple correlation measures (Pearson, Spearman, Kendall, lagged Pearson, and rolling) between sentiment scores and Bitcoin prices. +- **Visualization**: Generate insightful visualizations, including: + - Line plot of sentiment vs. Bitcoin price over time. + - Box plot of sentiment distribution. + - Area plot of cumulative sentiment vs. Bitcoin price. + - Correlation heatmap of sentiment, price, price change, and rolling correlation. + - Rolling correlation plot over time. +- **Usability**: Display visualizations inline in Jupyter notebooks for easy analysis and exploration. + +## Project Structure + +The project is organized within the `tutorials` repository under the `DATA605/Spring2025/projects` directory. Below is the project structure: + +``` +TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/ +│ +├── README.md # Project documentation and setup instructions +├── spacy_selenium_API.md # Documentation for the sentiment analysis pipeline +├── spacy_selenium_example.md # Example usage of the sentiment analysis pipeline +├── spacy_selenium_utils.py # Core class for scraping, NLP, sentiment analysis, and visualization +├── spacy_selenium_API.ipynb # Tutorial notebook demonstrating spaCy and Selenium APIs +├── spacy_selenium_example.ipynb # End-to-end pipeline notebook +├── requirements.txt # List of Python dependencies +├── Dockerfile # Docker configuration for the project +├── .gitignore # Specifies files and directories to ignore in Git +├── docker_build.sh # Builds the Docker container +├── docker_bash.sh # Launches Jupyter notebook server +├── install_project_packages.sh # Installs pip dependencies inside the container +└── bashrc, etc_sudoers, utils.sh # Helper configurations +``` + +## How It Works + +The pipeline operates in the following steps: + +1. **Data Ingestion**: + - Uses Selenium to scrape tweets from X for keywords "Bitcoin" and "BTC". + - Handles X login requirements with provided credentials to access live search results. + - Removes duplicate tweets based on text content. + +2. **Data Preprocessing**: + - Cleans tweets using spaCy for tokenization, stop-word removal, lemmatization, and Named Entity Recognition (NER). + - Matches extracted entities with cryptocurrencies using CoinGecko data. + +3. **Sentiment Analysis**: + - Analyzes tweet sentiment using the VADER sentiment analyzer. + - Categorizes tweets as positive, negative, or neutral based on compound scores. + +4. **Correlation with Bitcoin Prices**: + - Fetches Bitcoin price data from the CoinGecko API over a 1-day period. + - Computes multiple correlation measures: + - **Pearson**: Linear relationship. + - **Spearman**: Monotonic relationship. + - **Kendall**: Rank-based correlation. + - **Lagged Pearson**: Explores if past sentiment predicts price. + +5. **Visualizations**: + - Generates inline plots in Jupyter notebooks: + - **Sentiment vs. Price Over Time**: Line plot of sentiment scores and Bitcoin prices. + - **Sentiment Distribution**: Box plot of sentiment score distribution. + - **Cumulative Sentiment vs. Price**: Area plot comparing cumulative sentiment with price trends. + - **Correlation Heatmap**: Heatmap of correlations between sentiment, price, price change, and rolling correlation. + - **Rolling Correlation**: Line plot of rolling correlation over time. + +## Getting Started + +### Prerequisites +- **Python 3.9+**: Ensure Python is installed. +- **Google Chrome and ChromeDriver**: ChromeDriver must match your Chrome version for Selenium. +- **X (Twitter) Account**: Valid credentials (`x_username`, `x_password`) are required for scraping. +- **Docker and Docker Compose** (optional): For containerized execution. +- **Stable Internet Connection**: Required for scraping tweets and fetching price data. +- **(Optional) CoinGecko API Key**: For paid tier to avoid rate limits. + +### Setup Instructions (Local Development) + +1. **Clone the Repository**: + ```bash + git clone https://github.com/causify-ai/tutorials.git + cd tutorials/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium + ``` + +2. **Create and Activate a Virtual Environment (Windows)**: + ```bash + python -m venv venv + venv\Scripts\activate + ``` + +3. **Create and Activate a Virtual Environment (macOS/Linux)**: + ```bash + python3 -m venv venv + source venv/bin/activate + ``` + +4. **Install Dependencies**: + ```bash + pip install -r requirements.txt + ``` + +5. **Install ChromeDriver**: + - Download ChromeDriver matching your Chrome version from [chromedriver.chromium.org](https://chromedriver.chromium.org/downloads). + - Place `chromedriver` in the project directory or a directory in your `PATH`. + - Update `spacy_selenium_example.ipynb` or `spacy_selenium_utils.py` with the correct ChromeDriver path if needed. + +6. **Update X Credentials**: + - Open `spacy_selenium_example.ipynb` or `Bitcoin_Sentiment_Analysis.ipynb`. + - Update the `x_username` and `x_password` fields in the relevant cell: + ```python + x_username="your_username" + x_password="your_password" + ``` + - Ensure 2FA is disabled for your X account, as Selenium cannot handle 2FA prompts. + +7. **(Optional) Set Up CoinGecko API Key**: + - Create a `.env` file in the project root: + ```ini + COINGECKO_API_KEY=your_key_here + ``` + +8. **Run the Jupyter Notebook Locally**: + ```bash + jupyter notebook + ``` + - Open `spacy_selenium_example.ipynb` or `Bitcoin_Sentiment_Analysis.ipynb` in your browser and run the cells to execute the pipeline. + +### Setup Instructions (Docker) +Some of the Docker-related scripts were adjusted as per the project requirements. (Dockerfile, docker_build.sh and docker_bash.sh) +1. **Install Docker Desktop** for your operating system. + +2. **Build the Docker Image**: + ```bash + chmod +x docker_data605_style/docker_*.sh + ./docker_data605_style/docker_build.sh + ``` + +3. **Jupyter Notebook Server**: + - Start the container: + ```bash + ./docker_data605_style/docker_bash.sh + ``` + - The jupyter notebook server loads up for you to dive right into the project for easier and faster access. + + + +## Usage + +### Run the API Functionality Demo +```bash +jupyter notebook spacy_selenium_API.ipynb +``` +This notebook demonstrates: +- **spaCy API**: Tokenization, lemmatization, NER, and dependency parsing. +- **Selenium API**: Scraping tweets from X with authenticated login. +- Integration with `spacy_selenium_utils.py` for preprocessing and analysis. + +### Run the Full Pipeline +```bash +jupyter notebook spacy_selenium_example.ipynb +``` +The pipeline: +- Scrapes tweets for "Bitcoin" and "BTC". +- Preprocesses tweets with spaCy. +- Analyzes sentiment with VADER. +- Fetches Bitcoin price data from CoinGecko. +- Computes correlations and generates visualizations. + +### Explore Interactively +- Start with `spacy_selenium_API.ipynb` to understand the APIs. +- Run `spacy_selenium_example.ipynb` or `Bitcoin_Sentiment_Analysis.ipynb` for the full pipeline. +- Use **Restart & Run All** in JupyterLab for consistent results. + +## Troubleshooting + +- **X Login Failure**: + - Verify `x_username` and `x_password` in `spacy_selenium_example.ipynb` or `spacy_selenium_utils.py`. + - Disable 2FA on your X account. + - Check for verification prompts (email/phone) and handle manually (screenshots saved as `*.png`). + +- **Selenium TimeoutException**: + - Ensure ChromeDriver matches your Chrome version. + - Increase `WebDriverWait` timeouts in `spacy_selenium_utils.py` (e.g., from 15s to 30s). + +- **CoinGecko API Rate Limits**: + - Use a paid API key in `.env` if rate-limited. + - Reduce `max_tweets` in `spacy_selenium_example.ipynb`. + +- **Docker Port Issues**: + - Confirm `-p 8888:8888` is included in Docker commands. + - Ensure port 8888 is free on your host machine. + +- **Visualization Issues**: + - Add `%matplotlib inline` at the top of notebook cells. + - Update `matplotlib`, `seaborn`, and `ipython`: + ```bash + pip install --upgrade matplotlib seaborn ipython + ``` + +## References +- [spaCy Documentation](https://spacy.io/usage) +- [Selenium Documentation](https://www.selenium.dev/documentation/) +- [VADER Sentiment Analysis](https://github.com/cjhutto/vaderSentiment) +- [CoinGecko API Documentation](https://www.coingecko.com/en/api/documentation) +- [Matplotlib Documentation](https://matplotlib.org/stable/contents.html) +- [Seaborn Documentation](https://seaborn.pydata.org/) \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/bashrc b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/bashrc new file mode 120000 index 000000000..df303716e --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/bashrc @@ -0,0 +1 @@ +../../../../../docker_common/bashrc \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/chromedriver.exe b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/chromedriver.exe new file mode 100644 index 000000000..04a48c188 Binary files /dev/null and b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/chromedriver.exe differ diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_bash.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_bash.sh new file mode 100755 index 000000000..3ef70d52e --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_bash.sh @@ -0,0 +1,14 @@ +#!/bin/bash -xe + +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template +FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + +docker image ls $FULL_IMAGE_NAME + +CONTAINER_NAME=$IMAGE_NAME +docker run --rm -ti \ + --name $CONTAINER_NAME \ + -p 8888:8888 \ + -v $(pwd):/data \ + $FULL_IMAGE_NAME diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.sh new file mode 100755 index 000000000..384494217 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.sh @@ -0,0 +1,12 @@ +#!/bin/bash -e + +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/docker_common/utils.sh + +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template + +# Build container. +export DOCKER_BUILDKIT=1 +#export DOCKER_BUILDKIT=0 +build_container_image diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.version.log b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.version.log new file mode 100644 index 000000000..6970b3eb1 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_build.version.log @@ -0,0 +1,181 @@ +# Pytho3 +Python 3.8.10 +# pip3 +pip 25.0.1 from /usr/local/lib/python3.8/dist-packages/pip (python 3.8) +# jupyter +Selected Jupyter core packages... +IPython : 8.12.3 +ipykernel : 6.29.5 +ipywidgets : 8.1.7 +jupyter_client : 8.6.3 +jupyter_core : 5.7.2 +jupyter_server : 2.14.2 +jupyterlab : 4.3.7 +nbclient : 0.10.1 +nbconvert : 7.16.6 +nbformat : 5.10.4 +notebook : 7.3.3 +qtconsole : not installed +traitlets : 5.14.3 +# Python packages +Package Version +------------------------- -------------- +annotated-types 0.7.0 +anyio 4.5.2 +argon2-cffi 23.1.0 +argon2-cffi-bindings 21.2.0 +arrow 1.3.0 +asttokens 3.0.0 +async-lru 2.0.4 +attrs 25.3.0 +babel 2.17.0 +backcall 0.2.0 +beautifulsoup4 4.13.4 +bleach 6.1.0 +blis 0.7.11 +catalogue 2.0.10 +certifi 2025.4.26 +cffi 1.17.1 +charset-normalizer 3.4.2 +click 8.1.8 +comm 0.2.2 +confection 0.1.5 +contourpy 1.1.1 +cycler 0.12.1 +cymem 2.0.11 +Cython 0.29.37 +dbus-python 1.2.16 +debugpy 1.8.14 +decorator 5.2.1 +defusedxml 0.7.1 +en-core-web-sm 3.5.0 +exceptiongroup 1.3.0 +executing 2.2.0 +fastjsonschema 2.21.1 +fonttools 4.57.0 +fqdn 1.5.1 +h11 0.16.0 +httpcore 1.0.9 +httpx 0.28.1 +idna 3.10 +importlib_metadata 8.5.0 +importlib_resources 6.4.5 +ipykernel 6.29.5 +ipython 8.12.3 +ipywidgets 8.1.7 +isoduration 20.11.0 +jedi 0.19.2 +Jinja2 3.1.6 +json5 0.12.0 +jsonpointer 3.0.0 +jsonschema 4.23.0 +jsonschema-specifications 2023.12.1 +jupyter 1.1.1 +jupyter_client 8.6.3 +jupyter-console 6.6.3 +jupyter_core 5.7.2 +jupyter-events 0.10.0 +jupyter-lsp 2.2.5 +jupyter_server 2.14.2 +jupyter_server_terminals 0.5.3 +jupyterlab 4.3.7 +jupyterlab_pygments 0.3.0 +jupyterlab_server 2.27.3 +jupyterlab_widgets 3.0.15 +kiwisolver 1.4.7 +langcodes 3.4.1 +language_data 1.3.0 +marisa-trie 1.2.1 +MarkupSafe 2.1.5 +matplotlib 3.7.5 +matplotlib-inline 0.1.7 +mistune 3.1.3 +murmurhash 1.0.12 +nbclient 0.10.1 +nbconvert 7.16.6 +nbformat 5.10.4 +nest-asyncio 1.6.0 +notebook 7.3.3 +notebook_shim 0.2.4 +numpy 1.24.4 +outcome 1.3.0.post0 +overrides 7.7.0 +packaging 25.0 +pandas 2.0.3 +pandocfilters 1.5.1 +parso 0.8.4 +pathlib_abc 0.1.1 +pathy 0.11.0 +pexpect 4.9.0 +pickleshare 0.7.5 +pillow 10.4.0 +pip 25.0.1 +pkgutil_resolve_name 1.3.10 +platformdirs 4.3.6 +preshed 3.0.9 +prometheus_client 0.21.1 +prompt_toolkit 3.0.51 +psutil 7.0.0 +psycopg2-binary 2.9.10 +ptyprocess 0.7.0 +pure_eval 0.2.3 +pycparser 2.22 +pydantic 1.10.22 +pydantic_core 2.27.2 +Pygments 2.19.1 +PyGObject 3.36.0 +pyparsing 3.1.4 +PySocks 1.7.1 +python-dateutil 2.9.0.post0 +python-json-logger 3.3.0 +pytz 2025.2 +PyYAML 6.0.2 +pyzmq 26.4.0 +referencing 0.35.1 +requests 2.32.3 +rfc3339-validator 0.1.4 +rfc3986-validator 0.1.1 +rpds-py 0.20.1 +scipy 1.10.1 +seaborn 0.13.2 +selenium 4.27.1 +Send2Trash 1.8.3 +setuptools 75.3.2 +six 1.17.0 +smart-open 6.4.0 +sniffio 1.3.1 +sortedcontainers 2.4.0 +soupsieve 2.7 +spacy 3.5.4 +spacy-legacy 3.0.12 +spacy-loggers 1.0.5 +srsly 2.4.8 +stack-data 0.6.3 +terminado 0.18.1 +thinc 8.1.12 +tinycss2 1.2.1 +tomli 2.2.1 +tornado 6.4.2 +tqdm 4.67.1 +traitlets 5.14.3 +trio 0.27.0 +trio-websocket 0.12.2 +typer 0.9.4 +types-python-dateutil 2.9.0.20241206 +typing_extensions 4.13.2 +tzdata 2025.2 +uri-template 1.3.0 +urllib3 2.2.3 +vaderSentiment 3.3.2 +wasabi 1.1.3 +wcwidth 0.2.13 +webcolors 24.8.0 +webencodings 0.5.1 +websocket-client 1.8.0 +wheel 0.45.1 +widgetsnbextension 4.0.14 +wsproto 1.2.0 +yapf 0.43.0 +zipp 3.20.2 +# mongo +/data/version.sh: line 11: mongod: command not found diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_clean.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_clean.sh new file mode 100755 index 000000000..42b67ae09 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_clean.sh @@ -0,0 +1,9 @@ +#!/bin/bash -e + +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/tutorial_github_simple/docker_common/utils.sh + +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template + +remove_container_image diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_exec.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_exec.sh new file mode 100755 index 000000000..34c661a96 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_exec.sh @@ -0,0 +1,9 @@ +#!/bin/bash -e + +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/tutorial_github_simple/docker_common/utils.sh + +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template + +exec_container diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_jupyter.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_jupyter.sh new file mode 100755 index 000000000..88d158dd2 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_jupyter.sh @@ -0,0 +1,61 @@ +#!/bin/bash +# +# Execute run_jupyter.sh in the container. +# +# Usage: +# > docker_jupyter.sh -d /Users/saggese/src/git_gp1/code/book.2018.Martin.Bayesian_Analysis_with_Python.2e -v -u -p 8889 +# + +set -e +#set -x + +# Parse params. +export JUPYTER_HOST_PORT=8888 +export JUPYTER_USE_VIM=0 +export TARGET_DIR="" +export VERBOSE=0 + +OLD_CMD_OPTS=$@ +while getopts p:d:uv flag +do + case "${flag}" in + p) JUPYTER_HOST_PORT=${OPTARG};; + u) JUPYTER_USE_VIM=1;; + d) TARGET_DIR=${OPTARG};; + # /Users/saggese/src/git_gp1/code/ + v) VERBOSE=1;; + esac +done + +if [[ $VERBOSE == 1 ]]; then + set -x +fi; + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/docker_common/utils.sh + +# Execute the script setting the vars for this tutorial. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Run the script. +DOCKER_RUN_OPTS="-p $JUPYTER_HOST_PORT:$JUPYTER_HOST_PORT" +if [[ $TARGET_DIR != "" ]]; then + DOCKER_RUN_OPTS="$DOCKER_RUN_OPTS -v $TARGET_DIR:/data" +fi; +CMD="/curr_dir/run_jupyter.sh $OLD_CMD_OPTS" + +# From docker_cmd.sh passing DOCKER_OPTS. +run "docker image ls $FULL_IMAGE_NAME" +(docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true + +CONTAINER_NAME=$IMAGE_NAME +run "docker run \ + --rm -ti \ + --name $CONTAINER_NAME \ + $DOCKER_RUN_OPTS \ + -v $(pwd):/curr_dir \ + $FULL_IMAGE_NAME \ + $CMD" diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_name.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_name.sh new file mode 100755 index 000000000..0bc749b03 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_name.sh @@ -0,0 +1,3 @@ +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template +FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_push.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_push.sh new file mode 100755 index 000000000..9078d3a94 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/docker_push.sh @@ -0,0 +1,9 @@ +#!/bin/bash -e + +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/tutorial_github_simple/docker_common/utils.sh + +REPO_NAME=umd_data605 +IMAGE_NAME=umd_data605_template + +push_container_image diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/etc_sudoers b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/etc_sudoers new file mode 120000 index 000000000..79f31c6bc --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/etc_sudoers @@ -0,0 +1 @@ +../../../../../docker_common/etc_sudoers \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/install_jupyter_extensions.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/install_jupyter_extensions.sh new file mode 120000 index 000000000..acceb1c4b --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/install_jupyter_extensions.sh @@ -0,0 +1 @@ +../../../../../docker_common/install_jupyter_extensions.sh \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/requirements.txt b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/requirements.txt new file mode 100644 index 000000000..1f2c7d363 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/requirements.txt @@ -0,0 +1,20 @@ +numpy==1.23.5 +cython==0.29.37 +blis==0.7.9 +murmurhash==1.0.9 +cymem==2.0.7 +preshed==3.0.6 +thinc==8.1.7 +spacy==3.5.4 +notebook +spacy==3.7.2 +selenium==4.11.2 +pandas==2.0.3 +matplotlib==3.7.2 +requests==2.31.0 +vaderSentiment==3.3.2 +jupyter==1.0.0 +numpy +seaborn==0.13.2 +scipy==1.10.1 +en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/run_jupyter.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/run_jupyter.sh new file mode 100755 index 000000000..65a765e08 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/run_jupyter.sh @@ -0,0 +1,7 @@ +#!/bin/bash -xe + +jupyter-notebook \ + --port=8888 \ + --no-browser --ip=0.0.0.0 \ + --allow-root \ + --NotebookApp.token='' --NotebookApp.password='' diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.ipynb b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.ipynb new file mode 100644 index 000000000..8b4278f49 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.ipynb @@ -0,0 +1,382 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **spaCy and Selenium API Demonstration**\n", + "\n", + "This notebook is designed to walk you through the core API functions used in the **Real-Time Bitcoin Sentiment Analysis with spaCy and Selenium** project. We'll focus on two powerful tools: **spaCy** for natural language processing (NLP) and **Selenium** for web scraping. This notebook serves as a companion to the main pipeline notebook, `spacy_selenium_example.ipynb`, and uses functions from `spacy_selenium_utils.py`.\n", + "\n", + "If you're new to NLP or web scraping, don't worry! We'll break down each step, explain what’s happening, and share tips to help you get started. By the end, you'll have a solid understanding of how to process text data with spaCy and scrape tweets from X (Twitter) using Selenium." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Step 1: spaCy Demonstration**\n", + "\n", + "spaCy is a popular Python library for NLP, widely used for tasks like tokenization, lemmatization, named entity recognition (NER), dependency parsing, and part-of-speech (POS) tagging. In our Bitcoin sentiment analysis project, we use spaCy to preprocess tweets before analyzing their sentiment. Let’s explore these capabilities with a simple example.\n", + "\n", + "### **What You’ll Learn Here**\n", + "- How to clean and preprocess raw text (like tweets).\n", + "- How to break text into tokens (tokenization).\n", + "- How to simplify words to their base form (lemmatization).\n", + "- How to identify entities like people, organizations, or monetary values (NER).\n", + "- How to understand the grammatical structure of a sentence (dependency parsing and POS tagging).\n", + "\n", + "\n", + "### **Code Example: Processing a Tweet with spaCy**\n", + "Let’s start with a sample tweet about Bitcoin and walk through the preprocessing steps. We’ll use spaCy’s `en_core_web_sm` model, a small English model that’s lightweight and great for beginners." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cleaned Text: I just bought some Bitcoin at $50,000!\n", + "\n", + "Tokens:\n", + "I (Lemma: I, POS: PRON)\n", + "just (Lemma: just, POS: ADV)\n", + "bought (Lemma: buy, POS: VERB)\n", + "some (Lemma: some, POS: DET)\n", + "Bitcoin (Lemma: Bitcoin, POS: PROPN)\n", + "at (Lemma: at, POS: ADP)\n", + "$ (Lemma: $, POS: SYM)\n", + "50,000 (Lemma: 50,000, POS: NUM)\n", + "! (Lemma: !, POS: PUNCT)\n", + "\n", + "Entities:\n", + "Bitcoin (PERSON)\n", + "50,000 (MONEY)\n", + "\n", + "Dependency Parsing:\n", + "I --> nsubj (Head: bought)\n", + "just --> advmod (Head: bought)\n", + "bought --> ROOT (Head: bought)\n", + "some --> det (Head: Bitcoin)\n", + "Bitcoin --> dobj (Head: bought)\n", + "at --> prep (Head: bought)\n", + "$ --> nmod (Head: 50,000)\n", + "50,000 --> pobj (Head: at)\n", + "! --> punct (Head: bought)\n", + "\n", + "POS Tags:\n", + "I: PRON (pronoun)\n", + "just: ADV (adverb)\n", + "bought: VERB (verb)\n", + "some: DET (determiner)\n", + "Bitcoin: PROPN (proper noun)\n", + "at: ADP (adposition)\n", + "$: SYM (symbol)\n", + "50,000: NUM (numeral)\n", + "!: PUNCT (punctuation)\n" + ] + } + ], + "source": [ + "import spacy\n", + "import re\n", + "\n", + "# Load the spaCy model\n", + "nlp = spacy.load(\"en_core_web_sm\")\n", + "\n", + "# Example tweet text\n", + "text = \"I just bought some Bitcoin #BTC at $50,000!\"\n", + "\n", + "# Clean the text\n", + "cleaned_text = re.sub(r\"http\\S+|www\\S+|https\\S+\", \"\", text, flags=re.MULTILINE)\n", + "cleaned_text = re.sub(r\"@\\w+|#\\w+\", \"\", cleaned_text)\n", + "cleaned_text = cleaned_text.encode(\"ascii\", \"ignore\").decode() # Remove emojis\n", + "cleaned_text = re.sub(r\"\\s+\", \" \", cleaned_text).strip()\n", + "print(f\"Cleaned Text: {cleaned_text}\\n\")\n", + "\n", + "# Process the text with spaCy\n", + "doc = nlp(cleaned_text)\n", + "\n", + "# Tokenization\n", + "print(\"Tokens:\")\n", + "for token in doc:\n", + " print(f\"{token.text} (Lemma: {token.lemma_}, POS: {token.pos_})\")\n", + "\n", + "# Named Entity Recognition (NER)\n", + "print(\"\\nEntities:\")\n", + "for ent in doc.ents:\n", + " print(f\"{ent.text} ({ent.label_})\")\n", + "\n", + "# Dependency Parsing\n", + "print(\"\\nDependency Parsing:\")\n", + "for token in doc:\n", + " print(f\"{token.text} --> {token.dep_} (Head: {token.head.text})\")\n", + "\n", + "# Part-of-Speech Tagging\n", + "print(\"\\nPOS Tags:\")\n", + "for token in doc:\n", + " print(f\"{token.text}: {token.pos_} ({spacy.explain(token.pos_)})\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Output Explanation**\n", + "Let’s break down the output to understand what spaCy is doing:\n", + "\n", + "- **Cleaned Text**: We start with a raw tweet: \"I just bought some Bitcoin #BTC at $$50,000!\". After cleaning, we remove URLs, mentions (@username), hashtags (#BTC), emojis, and extra spaces, leaving: \"I just bought some Bitcoin at $50,000!\".\n", + "- **Tokens**: spaCy splits the text into tokens (words or punctuation). For each token, we see its **lemma** (base form, e.g., \"bought\" becomes \"buy\") and its **POS** (part of speech, e.g., \"VERB\" for \"bought\"). This helps us understand the structure of the sentence.\n", + "- **Entities (NER)**: spaCy identifies named entities. Here, \"Bitcoin\" is tagged as a `PERSON` (which isn’t quite correct—more on that below), and \"$50,000\" is correctly tagged as `MONEY`. NER is useful for extracting meaningful entities like prices or cryptocurrency names.\n", + "- **Dependency Parsing**: This shows the grammatical relationships between words. For example, \"I\" is the subject (`nsubj`) of the verb \"bought\", and \"Bitcoin\" is the direct object (`dobj`). This helps us understand how words connect in a sentence.\n", + "- **POS Tags**: Each token is labeled with its part of speech (e.g., \"PRON\" for pronoun, \"VERB\" for verb). The `spacy.explain()` function gives a beginner-friendly description of each tag." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Insights for Beginners**\n", + "- **Why Clean Text First?** : Tweets often contain noise like URLs, hashtags, and emojis that can confuse NLP models. Cleaning ensures spaCy focuses on the meaningful content.\"\n", + "- **NER Misclassification**: spaCy tagged \"Bitcoin\" as a `PERSON`, but it’s a cryptocurrency. This happens because spaCy’s models are trained on general text, not crypto-specific data. For better accuracy, you can fine-tune spaCy with custom data or add a post-processing step to correct such labels.\n", + "- **Choosing a Model**: We used `en_core_web_sm` (small model) for speed. If you need better accuracy, try `en_core_web_md` (medium) or `en_core_web_lg` (large), but they require more memory and are slower.\n", + "- **Practical Tip**: If you’re new to spaCy, start with small examples like this to get comfortable. Use `spacy.explain()` to learn what tags mean, it’s a great way to build your NLP vocabulary!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Additional Example: Comparing Different Tweets**\n", + "Let’s try spaCy on another tweet to see how it handles variations in text. This helps us understand how spaCy behaves with different sentence structures." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cleaned Text: Elon Musk says Bitcoin will hit $100,000 by 2025!\n", + "\n", + "Tokens:\n", + "Elon (Lemma: Elon, POS: PROPN)\n", + "Musk (Lemma: Musk, POS: PROPN)\n", + "says (Lemma: say, POS: VERB)\n", + "Bitcoin (Lemma: Bitcoin, POS: PROPN)\n", + "will (Lemma: will, POS: AUX)\n", + "hit (Lemma: hit, POS: VERB)\n", + "$ (Lemma: $, POS: SYM)\n", + "100,000 (Lemma: 100,000, POS: NUM)\n", + "by (Lemma: by, POS: ADP)\n", + "2025 (Lemma: 2025, POS: NUM)\n", + "! (Lemma: !, POS: PUNCT)\n", + "\n", + "Entities:\n", + "Elon Musk (PERSON)\n", + "Bitcoin (PERSON)\n", + "100,000 (MONEY)\n", + "2025 (DATE)\n" + ] + } + ], + "source": [ + "# Another example tweet\n", + "text2 = \"Elon Musk says Bitcoin will hit $100,000 by 2025! 🚀 #CryptoNews\"\n", + "\n", + "# Clean the text\n", + "cleaned_text2 = re.sub(r\"http\\S+|www\\S+|https\\S+\", \"\", text2, flags=re.MULTILINE)\n", + "cleaned_text2 = re.sub(r\"@\\w+|#\\w+\", \"\", cleaned_text2)\n", + "cleaned_text2 = cleaned_text2.encode(\"ascii\", \"ignore\").decode()\n", + "cleaned_text2 = re.sub(r\"\\s+\", \" \", cleaned_text2).strip()\n", + "print(f\"Cleaned Text: {cleaned_text2}\\n\")\n", + "\n", + "# Process with spaCy\n", + "doc2 = nlp(cleaned_text2)\n", + "\n", + "# Tokenization\n", + "print(\"Tokens:\")\n", + "for token in doc2:\n", + " print(f\"{token.text} (Lemma: {token.lemma_}, POS: {token.pos_})\")\n", + "\n", + "# Named Entity Recognition (NER)\n", + "print(\"\\nEntities:\")\n", + "for ent in doc2.ents:\n", + " print(f\"{ent.text} ({ent.label_})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Expected Output**\n", + "- **Cleaned Text**: \"Elon Musk says Bitcoin will hit $$100,000 by 2025!\"\n", + "- **Tokens**: You’ll see tokens like \"Elon\" (Lemma: Elon, POS: PROPN), \"says\" (Lemma: say, POS: VERB), etc.\n", + "- **Entities**: \"Elon Musk\" should be tagged as `PERSON`, \"Bitcoin\" as `PERSON` (again, a misclassification), \"$100,000\" as `MONEY`, and \"2025\" as `DATE`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Beginner Insight: Handling NER Errors**\n", + "As you saw, spaCy sometimes mislabels \"Bitcoin\" as a `PERSON`. In a real project, you can fix this by:\n", + "\n", + "1. Using a Custom List: Check if entities match a list of known cryptocurrencies (like Bitcoin, Ethereum) and relabel them as `PRODUCT` or a custom label.\n", + "2. Training a Model: Fine-tune spaCy with crypto-related data to improve its accuracy.\n", + "3. Post-Processing: Write rules to correct common errors, e.g., if an entity is \"Bitcoin,\" change its label to `PRODUCT`.\n", + "\n", + "\n", + "### **Why This Matters for Sentiment Analysis**\n", + "In our project, we use spaCy to preprocess tweets before feeding them into the VADER sentiment analyzer. Tokenization and lemmatization help standardize the text (e.g., \"bought\" and \"buying\" become \"buy\"), which makes sentiment analysis more consistent. NER helps us identify key entities like prices or crypto names, which we can use to match with CoinGecko data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Step 2: Selenium Demonstration**\n", + "\n", + "Selenium is a tool for automating web browsers, and we use it to scrape tweets from X (Twitter). In our project, we need to collect Bitcoin-related tweets to analyze public sentiment. X requires users to log in to access search results, so we’ll use Selenium to automate the login process and scrape tweets.\n", + "\n", + "### **What You’ll Learn Here**\n", + "- How to set up Selenium to interact with a website.\n", + "- How to log in to X using Selenium.\n", + "- How to scrape tweets and handle dynamic content.\n", + "- Best practices for web scraping (e.g., avoiding rate limits, handling errors).\n", + "\n", + "### **Code Example: Scraping Tweets with Selenium**\n", + "We’ll use the `BitcoinSentimentAnalyzer` class from `spacy_selenium_utils.py` to scrape tweets. This class handles the login and scraping process for us." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample Tweets:\n", + "- Use your \n", + "\n", + "#BITCOIN $BTC #BTC\\n\n", + "- BREAKING: Nach einem Treffen mit El Salvadors Präsident \n", + "@nayibbukele\n", + " postet Panamas Bürgermeister \n", + "@Mayer\n", + " über eine „Bitcoin Reserve“. \\n\n", + "- Devs, degens, and even your grandma who still thinks Bitcoin is a slot machine. Let’s dive into what they’re building, why it’s a big deal for Crypto Twitter (CT), the blockchain, and us commoners, plus why you should be BULLISH\\n\n" + ] + } + ], + "source": [ + "from spacy_selenium_utils import BitcoinSentimentAnalyzer\n", + "\n", + "# Initialize the analyzer\n", + "analyzer = BitcoinSentimentAnalyzer(\n", + " \n", + " x_username=\"sidrohtest\",\n", + " x_password=\"siddhirohantesting#123\"\n", + ")\n", + "\n", + "# Scrape tweets\n", + "tweets = analyzer.scrape_tweets(keywords=[\"Bitcoin\"], max_tweets=3) # Limited to 3 tweets for demo\n", + "\n", + "# Display the scraped tweets\n", + "print(\"Sample Tweets:\")\n", + "for tweet in tweets:\n", + " print(f\"- {tweet['text']}\\\\n\")\n", + "\n", + "# Clean up\n", + "del analyzer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "### **Output Explanation**\n", + "The output shows three sample tweets about Bitcoin. Each tweet is a dictionary with `text` (the tweet content) and `timestamp` (when it was scraped). For example:\n", + "\n", + "- \"Bitcoin just touched $$74K. That same HR manager who flagged my crypto side hustle now runs 'on-chain payroll workshops.' Yeah Jessica, glad compliance caught up with capitalism.\"\n", + "- This tweet mentions Bitcoin’s price ($74K) and has a mix of sentiment (positive about Bitcoin, sarcastic about the HR manager).\n", + "\n", + "### **How Selenium Works in This Example**\n", + "1. **Login**: The `BitcoinSentimentAnalyzer` class navigates to X’s login page, enters the username and password, and clicks the \"Log in\" button.\n", + "2. **Search**: It searches for the keyword \"Bitcoin\" using X’s search bar.\n", + "3. **Scrolling**: X loads tweets dynamically as you scroll. Selenium scrolls down the page to load more tweets until it collects the desired number `(max_tweets=3)`.\n", + "4. **Extraction**: It extracts the text of each tweet and stores it with a timestamp.\n", + "\n", + "###\n", + "### **Insights for Beginners**\n", + "- **Why Selenium?** Unlike simple APIs, X requires a login to access tweets, and its content is dynamic (loaded via JavaScript). Selenium automates a real browser (like Chrome) to interact with the site as a human would.\n", + "- **Headless Mode**: The `BitcoinSentimentAnalyzer` uses Selenium in headless mode (no visible browser window) for efficiency. If you’re debugging, you can disable headless mode to watch Selenium in action. Just remove the `--headless` argument in `spacy_selenium_utils.py.`\n", + "- **ChromeDriver Setup**: You need to install ChromeDriver (a separate executable) that matches your Chrome browser version. If you get a version mismatch error, download the correct ChromeDriver from chromedriver.chromium.org and place it in your project directory or PATH.\n", + "- **Rate Limits and Ethics**: X has strict rules about scraping. Be cautious not to scrape too many tweets at once (we limited to 3 here for safety). Always respect X’s terms of service, and consider using X’s official API for larger projects (though it may require a paid plan)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Why This Matters for Sentiment Analysis**\n", + "Scraping tweets gives us raw data to analyze. In our project, we collect tweets mentioning \"Bitcoin\" to gauge public sentiment. The more diverse and recent the tweets, the better our sentiment analysis reflects current market moods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Step 3: Integration with Main Pipeline**\n", + "\n", + "The spaCy and Selenium functionalities we explored are integrated into the main pipeline in `spacy_selenium_utils.py`. The `BitcoinSentimentAnalyzer` class combines both tools to:\n", + "\n", + "1. Scrape tweets (Selenium).\n", + "2. Preprocess them (spaCy).\n", + "3. Analyze sentiment (using VADER, which we’ll cover in the main pipeline).\n", + "4. Correlate sentiment with Bitcoin prices (using CoinGecko API).\n", + "5. Visualize the results.\n", + "\n", + "For the full pipeline execution, see `spacy_selenium_example.ipynb`. That notebook ties everything together, showing how the preprocessing and scraping steps fit into the larger workflow." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.md b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.md new file mode 100644 index 000000000..df9324f4f --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_API.md @@ -0,0 +1,97 @@ +# spaCy and Selenium API Demonstration: A Walkthrough of `spacy_selenium_API.ipynb` + +## Overview + +The `spacy_selenium_API.ipynb` notebook is a foundational component of the Real-Time Bitcoin Sentiment Analysis project, developed for the DATA605 course in Spring 2025. This notebook focuses on demonstrating the core functionalities of two powerful tools: **spaCy** for natural language processing (NLP) and **Selenium** for web scraping. It serves as a companion to the main pipeline notebook, `spacy_selenium_example.ipynb`, and provides a detailed introduction to the APIs used in the project, specifically through functions in `spacy_selenium_utils.py`. + +Designed with beginners in mind, this notebook breaks down the essential steps of text preprocessing with spaCy and tweet scraping with Selenium, providing clear explanations, practical examples, and actionable insights. It’s an ideal starting point for those new to NLP and web scraping, laying the groundwork for understanding the full sentiment analysis pipeline. + +## Purpose + +The primary purpose of `spacy_selenium_API.ipynb` is to introduce and demonstrate the core API functions used in the Bitcoin sentiment analysis project, focusing on spaCy and Selenium. Its key objectives are to: + +- Showcase spaCy’s capabilities for preprocessing text data, including cleaning, tokenization, lemmatization, named entity recognition (NER), dependency parsing, and part-of-speech (POS) tagging. +- Demonstrate Selenium’s ability to scrape tweets from X (Twitter) by automating browser interactions, such as logging in and handling dynamic content. +- Provide beginner-friendly insights, practical tips, and additional examples to help users understand how these tools work and how they integrate into the larger pipeline. +- Highlight the importance of preprocessing and scraping as foundational steps for sentiment analysis, setting the stage for the full workflow in `spacy_selenium_example.ipynb`. + +This notebook is an educational resource, offering a hands-on introduction to spaCy and Selenium while preparing users for the more comprehensive analysis in the main pipeline notebook. + +## Notebook Structure + +The notebook is organized into three steps, each focusing on a critical aspect of the project’s foundational tools: + +### 1. spaCy Demonstration + +- **Purpose**: Introduce spaCy’s NLP capabilities by preprocessing a sample tweet about Bitcoin. +- **Process**: Uses spaCy’s `en_core_web_sm` model to clean a tweet ("I just bought some Bitcoin #BTC at $50,000!"), tokenize it, lemmatize words, perform NER, dependency parsing, and POS tagging. +- **Output**: + - Cleaned Text: "I just bought some Bitcoin at $50,000!" + - Tokens: E.g., "bought" (Lemma: buy, POS: VERB). + - Entities: "Bitcoin" (PERSON, misclassified), "$50,000" (MONEY). + - Dependency Parsing: E.g., "I" → nsubj (Head: bought). + - POS Tags: E.g., "I: PRON (pronoun)". +- **Additional Example**: Processes another tweet ("Elon Musk says Bitcoin will hit $100,000 by 2025! 🚀 #CryptoNews") to show spaCy’s handling of different sentence structures, identifying entities like "Elon Musk" (PERSON) and "2025" (DATE). +- **Insights**: + - Explains the importance of cleaning text to remove noise (e.g., URLs, hashtags). + - Discusses NER misclassifications (e.g., "Bitcoin" as PERSON) and offers solutions like custom lists, model training, or post-processing. + - Recommends starting with small examples and using `spacy.explain()` to learn NLP concepts. + - Highlights spaCy’s role in standardizing text for sentiment analysis by tokenizing and lemmatizing words. + +### 2. Selenium Demonstration + +- **Purpose**: Demonstrate Selenium’s web scraping capabilities by collecting Bitcoin-related tweets from X. +- **Process**: Uses the `BitcoinSentimentAnalyzer` class to log into X, search for tweets with the keyword "Bitcoin", scroll dynamically to gather 3 tweets, and extract their text. +- **Output**: Sample tweets, e.g., "Use your #BITCOIN $BTC #BTC", showing diverse content from technical discussions to casual mentions. +- **Additional Guidance**: Explains Selenium’s workflow (login, search, scrolling, extraction) and its use of headless mode for efficiency. +- **Insights**: + - Emphasizes Selenium’s necessity for scraping dynamic content on X, which requires login and JavaScript rendering. + - Offers tips for debugging (e.g., disabling headless mode, checking ChromeDriver compatibility) and ethical scraping (e.g., respecting rate limits). + - Highlights the importance of diverse tweets for capturing varied public sentiment in the project. + +### 3. Integration with Main Pipeline + +- **Purpose**: Connect the spaCy and Selenium demonstrations to the broader project pipeline. +- **Process**: Describes how the `BitcoinSentimentAnalyzer` class integrates spaCy and Selenium to scrape tweets, preprocess them, analyze sentiment with VADER, correlate with Bitcoin prices via CoinGecko, and visualize results. +- **Output**: Directs users to `spacy_selenium_example.ipynb` for the full pipeline execution, explaining how preprocessing and scraping fit into the larger workflow. +- **Insights**: Provides a high-level overview of the pipeline’s steps, preparing users for the comprehensive analysis in the main notebook. + +## Educational Value + +This notebook is a valuable learning resource for several reasons: + +- **Foundational Skills**: Offers a beginner-friendly introduction to spaCy and Selenium, two essential tools for NLP and web scraping, with clear, step-by-step demonstrations. +- **Practical Examples**: Includes hands-on examples (e.g., processing different tweets, scraping live data) to help users understand and experiment with the APIs. +- **Actionable Insights**: Provides tips for handling common issues (e.g., NER misclassifications, Selenium timeouts) and best practices (e.g., ethical scraping, model selection). +- **Preparation for Full Pipeline**: Sets the stage for the main pipeline in `spacy_selenium_example.ipynb`, ensuring users understand the core components before diving into the complete workflow. +- **Extensibility**: Encourages users to explore further, such as fine-tuning spaCy models or scraping additional tweet metadata, fostering deeper learning. + +## How to Use + +To run this notebook, follow the setup instructions in the project’s `README.md` to install dependencies, configure ChromeDriver, and provide X credentials. Then: + +1. Open the notebook in Jupyter: + + ```bash + jupyter notebook spacy_selenium_API.ipynb + ``` +2. Run the cells sequentially to explore spaCy and Selenium functionalities. +3. Experiment with the additional examples (e.g., process new tweets, scrape more data) to deepen your understanding. +4. Proceed to `spacy_selenium_example.ipynb` to see how these APIs integrate into the full pipeline. + +### Requirements + +- Python 3.9+ +- ChromeDriver matching your Chrome version +- X (Twitter) account credentials +- Stable internet connection +- Dependencies listed in `requirements.txt` + +## Key Takeaways + +- spaCy is a powerful tool for preprocessing tweets, enabling tokenization, lemmatization, and NER, though it may require customization for crypto-specific terms like "Bitcoin". +- Selenium effectively scrapes dynamic content from X, automating login and scrolling to collect tweets, but users must handle rate limits and setup carefully. +- The notebook provides a solid foundation for understanding the preprocessing and scraping steps, preparing users for the full Bitcoin sentiment analysis pipeline. +- Practical insights and examples make it an excellent resource for beginners learning NLP and web scraping, with opportunities for further exploration. + +For the complete pipeline, including sentiment analysis, correlation, and visualization, refer to `spacy_selenium_example.ipynb`. For setup and project context, see the `README.md`. \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.ipynb b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.ipynb new file mode 100644 index 000000000..55d283cbe --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **Example: Real-Time Bitcoin Sentiment Analysis**\n", + "\n", + "Welcome to this notebook! Here, we’ll walk you through the complete Bitcoin sentiment analysis pipeline using the `BitcoinSentimentAnalyzer` class from `spacy_selenium_utils.py`. This pipeline scrapes Bitcoin-related tweets from X (Twitter), preprocesses them with spaCy, analyzes sentiment with VADER, correlates sentiment with Bitcoin prices from the CoinGecko API, and visualizes the results. Whether you’re new to data science or an experienced practitioner, this notebook will guide you step-by-step, with tips to help you learn and troubleshoot." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **What You’ll Learn**\n", + "- How to scrape tweets from X using Selenium.\n", + "- How to preprocess text data with spaCy and analyze sentiment with VADER.\n", + "- How to fetch Bitcoin price data and calculate correlations with sentiment.\n", + "- How to create insightful visualizations to explore trends.\n", + "- Best practices for managing resources and avoiding common pitfalls." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let’s get started!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Step 1: Data Ingestion - Scrape Tweets**\n", + "\n", + "Our first step is to collect raw data tweets mentioning \"Bitcoin\" or \"BTC\" from X (Twitter). We’ll use the `BitcoinSentimentAnalyzer` class, which leverages Selenium to automate the process of logging into X and scraping tweets.\n", + "\n", + "### **What’s Happening Here**\n", + "- **Selenium Setup**: The analyzer opens a headless Chrome browser, logs into X with your credentials, and searches for tweets.\n", + "- **Dynamic Scraping**: X loads tweets as you scroll, so the analyzer scrolls down to gather more tweets until it reaches the desired number `(max_tweets=100)`.\n", + "- **Data Storage**: The scraped tweets are stored in a pandas DataFrame for easy handling.\n", + "\n", + "\n", + "### **Code Example: Scraping Tweets**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
texttimestamp
0Bonds and the dollar will probably provide mor...2025-05-18T19:20:25.477162
1Bitcoin hold become rich2025-05-18T19:20:25.504892
2In the ever-swinging pendulum of crypto market...2025-05-18T19:20:25.519081
3#BTCDOMINANCE \\n\\n%65 üzerinde kapanış gelmedi...2025-05-18T19:20:25.536037
4Bitcoin's journey is truly captivating. The de...2025-05-18T19:20:25.548796
\n", + "
" + ], + "text/plain": [ + " text \\\n", + "0 Bonds and the dollar will probably provide mor... \n", + "1 Bitcoin hold become rich \n", + "2 In the ever-swinging pendulum of crypto market... \n", + "3 #BTCDOMINANCE \\n\\n%65 üzerinde kapanış gelmedi... \n", + "4 Bitcoin's journey is truly captivating. The de... \n", + "\n", + " timestamp \n", + "0 2025-05-18T19:20:25.477162 \n", + "1 2025-05-18T19:20:25.504892 \n", + "2 2025-05-18T19:20:25.519081 \n", + "3 2025-05-18T19:20:25.536037 \n", + "4 2025-05-18T19:20:25.548796 " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from spacy_selenium_utils import BitcoinSentimentAnalyzer\n", + "import pandas as pd\n", + "\n", + "# Initialize the analyzer with the ChromeDriver path and X credentials\n", + "analyzer = BitcoinSentimentAnalyzer(\n", + " x_username=\"sidrohtest\",\n", + " x_password=\"siddhirohantesting#123\"\n", + ")\n", + "\n", + "# Scrape tweets\n", + "tweets = analyzer.scrape_tweets(keywords=[\"Bitcoin\", \"BTC\"], max_tweets=100)\n", + "\n", + "# Store tweets in a DataFrame\n", + "tweets_df = pd.DataFrame(tweets)\n", + "tweets_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Output Explanation**\n", + "The output is a DataFrame showing the first five scraped tweets:\n", + "\n", + "- **text**: The tweet content that is printed in the output, e.g. - \"Bitcoin hold become rich\" ( P.S For previously run output, if you run the above cell again, it might change)\n", + "- **timestamp**: When the tweet was scraped, e.g., \"2025-05-18T19:20:25.477162\". (Same follow for timestamp as text)\n", + "\n", + "\n", + "Notice the variety in the tweets, some discuss Bitcoin’s performance, others mention technical aspects like OpenTimeStamps, and one is a casual mention of a \"bitcoin acount.\" This diversity is great for sentiment analysis, as it captures different perspectives." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "### **Additional Example: Filtering Tweets by Keyword**\n", + "Let’s explore the scraped tweets further. We can filter tweets containing specific phrases to see what people are saying about certain topics, like Bitcoin’s price." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of tweets mentioning 'price': 5\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
texttimestamp
15It’s not about the price anymore. It’s about a...2025-05-18T19:20:28.248309
19$DOAI \\nThe price continues to rise now. We ne...2025-05-18T19:20:28.337092
29#Bitcoin Price:$104487.10\\nTrade Time:2024-09-...2025-05-18T19:20:32.514673
40Bitcoin Update\\n\\nI missed the early entry, ri...2025-05-18T19:20:34.731656
73Current Bitcoin price: $104542.61 USD #Bitcoin...2025-05-18T19:20:43.353179
\n", + "
" + ], + "text/plain": [ + " text \\\n", + "15 It’s not about the price anymore. It’s about a... \n", + "19 $DOAI \\nThe price continues to rise now. We ne... \n", + "29 #Bitcoin Price:$104487.10\\nTrade Time:2024-09-... \n", + "40 Bitcoin Update\\n\\nI missed the early entry, ri... \n", + "73 Current Bitcoin price: $104542.61 USD #Bitcoin... \n", + "\n", + " timestamp \n", + "15 2025-05-18T19:20:28.248309 \n", + "19 2025-05-18T19:20:28.337092 \n", + "29 2025-05-18T19:20:32.514673 \n", + "40 2025-05-18T19:20:34.731656 \n", + "73 2025-05-18T19:20:43.353179 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filter tweets mentioning \"price\"\n", + "price_tweets = tweets_df[tweets_df['text'].str.contains(\"price\", case=False, na=False)]\n", + "print(f\"Number of tweets mentioning 'price': {len(price_tweets)}\")\n", + "price_tweets.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Output Explaination**\n", + "This will show tweets that mention \"price,\" helping us focus on discussions about Bitcoin’s market value. For example, you might see tweets like \"As a bitcoin price increases this week. What is the next target for Bitcoin?\" (from the spacy_selenium_API.ipynb demo)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Handling Scraping Issues**\n", + "- **Login Errors**: If the login fails (e.g., wrong credentials), the analyzer will save a screenshot (e.g., `login_failure_screenshot.png`). Open it to see what went wrong, X might be asking for email/phone verification.\n", + "- **Timeouts**: If X loads slowly, you might get a `TimeoutException`. Increase the wait time in `spacy_selenium_utils.py` (e.g., change `time.sleep(5)` to `time.sleep(10)`).\n", + "- **Dynamic Content**: X’s HTML structure can change. If tweets aren’t being scraped, use Chrome’s Developer Tools (right-click, \"Inspect\") to update the selectors in `spacy_selenium_utils.py`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "## **Step 2: Data Preprocessing - Clean and Preprocess Tweets**\n", + "\n", + "Now that we have raw tweets, we need to clean and preprocess them to make them suitable for sentiment analysis. The `BitcoinSentimentAnalyzer` class uses spaCy for preprocessing and VADER for sentiment analysis.\n", + "\n", + "### **What’s Happening Here**\n", + "- **Cleaning**: Remove URLs, mentions (@username), hashtags (#tag), emojis, and extra spaces.\n", + "- **spaCy Preprocessing**: Tokenize the text, lemmatize words (e.g., \"running\" to \"run\"), remove stop words (e.g., \"the\", \"is\"), and extract entities (e.g., Bitcoin, prices).\n", + "- **Sentiment Analysis** : Use VADER to assign a sentiment score (from -1 to 1) and categorize each tweet as positive, negative, or neutral.\n", + "\n", + "\n", + "### **Code Example: Preprocessing and Sentiment Analysis**" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
textsentimentsentiment_categorycoins
0bond dollar probably provide information equit...-0.6369negative[]
1bitcoin hold rich0.5574positive[]
2swinge pendulum crypto market today drama cent...0.3182positive[]
365 zerinde kapan gelmedii srece boa sezonu umu...0.0000neutral[]
4bitcoin journey truly captivating devotion sup...0.8834positive[Bitcoin]
\n", + "
" + ], + "text/plain": [ + " text sentiment \\\n", + "0 bond dollar probably provide information equit... -0.6369 \n", + "1 bitcoin hold rich 0.5574 \n", + "2 swinge pendulum crypto market today drama cent... 0.3182 \n", + "3 65 zerinde kapan gelmedii srece boa sezonu umu... 0.0000 \n", + "4 bitcoin journey truly captivating devotion sup... 0.8834 \n", + "\n", + " sentiment_category coins \n", + "0 negative [] \n", + "1 positive [] \n", + "2 positive [] \n", + "3 neutral [] \n", + "4 positive [Bitcoin] " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Preprocess tweets\n", + "processed_tweets = analyzer.preprocess_tweets(tweets)\n", + "\n", + "# Analyze sentiment\n", + "tweets_with_sentiment = analyzer.analyze_sentiment(processed_tweets)\n", + "\n", + "# Store processed tweets with sentiment in a DataFrame\n", + "processed_df = pd.DataFrame(tweets_with_sentiment)\n", + "processed_df[['text', 'sentiment', 'sentiment_category', 'coins']].head()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Output Explanation\n", + "The output DataFrame shows the processed tweets:\n", + "\n", + "- **text**: The cleaned and lemmatized text, e.g., \"bond dollar probably provide information equit..\".\n", + "- **sentiment**: A score from -1 (negative) to 1 (positive), e.g., -0.6369 for the first tweet.\n", + "- **sentiment_category**: Categorized as \"negative\", \"positive\", or \"neutral\" based on the score.\n", + "- **coins**: Cryptocurrencies identified in the tweet, e.g., [\"Bitcoin\"].\n", + "\n", + "For example, the first tweet (\"bond dollar probably provide information equit...\") has a negative sentiment score (-0.6369) because of words like \"probably\"." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Insights for Beginners**\n", + "- **Why Preprocess?** Raw tweets are messy, full of URLs, emojis, and irrelevant symbols. Preprocessing simplifies the text, making it easier for VADER to focus on meaningful words for sentiment analysis.\n", + "- **VADER Explained**: VADER (Valence Aware Dictionary and sEntiment Reasoner) is great for social media because it understands slang, emojis, and emphasis (e.g., \"GREAT!!!\" is more positive than \"great\"). Scores > 0 are positive, < 0 are negative, and 0 is neutral.\n", + "- **NER Limitations**: The `coins` column shows that spaCy identified \"Bitcoin\" in some tweets but missed it in others (e.g., tweet 3: \"hi bitcoin acount\"). This is because spaCy’s NER isn’t perfect for crypto terms. You can improve this by adding custom rules or training a model.\n", + "- **Practical Tip**: If you’re new to NLP, experiment with a few tweets manually. Print the raw and processed text to see how preprocessing changes the content." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Additional Example: Analyzing Sentiment Distribution**\n", + "Let’s dig deeper by looking at the distribution of sentiment categories across all tweets. This helps us understand the overall mood about Bitcoin." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment Distribution:\n", + "sentiment_category\n", + "neutral 44\n", + "positive 42\n", + "negative 14\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Count the number of tweets in each sentiment category\n", + "sentiment_counts = processed_df['sentiment_category'].value_counts()\n", + "print(\"Sentiment Distribution:\")\n", + "print(sentiment_counts)\n", + "\n", + "# Visualize the distribution as a bar chart\n", + "import matplotlib.pyplot as plt\n", + "sentiment_counts.plot(kind='bar', color=['green', 'red', 'gray'])\n", + "plt.title(\"Distribution of Tweet Sentiments\")\n", + "plt.xlabel(\"Sentiment Category\")\n", + "plt.ylabel(\"Number of Tweets\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Output Explaination**\n", + "- **Sentiment Distribution**: You see something: 42 positive, 44 neutral, 14 negative (numbers will vary).\n", + "- **Bar Chart**: A visual showing the count of tweets in each category, making it easy to see if the sentiment is mostly positive, negative, or balanced." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Beginner Tip: Interpreting Sentiment**\n", + "- **Scores Close to 0**: A score of 0 (neutral) doesn’t always mean the tweet is neutral in meaning, it might lack strong sentiment words. For example, \"hi bitcoin acount\" (score 0) is neutral because it’s a simple statement.\n", + "- **Adjusting Thresholds**: VADER uses 0 as the cutoff for positive/negative. If you want stricter categories, you can adjust the thresholds (e.g., > 0.1 for positive, < -0.1 for negative) in `spacy_selenium_utils.py`.\n", + "- **Debugging Sentiment**: If a tweet’s sentiment seems off, check the processed text. Missing key words (e.g., due to stop-word removal) can affect the score." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "## **Step 3: Correlation with Bitcoin Prices - Fetch Prices and Analyze Correlation**\n", + "\n", + "Next, we fetch Bitcoin price data from the CoinGecko API and correlate it with the tweet sentiments. This step helps us explore whether public sentiment (from tweets) aligns with Bitcoin’s price movements.\n", + "\n", + "### **What’s Happening Here**\n", + "- **Fetch Prices**: The `fetch_bitcoin_price` method retrieves Bitcoin’s price history over the last day.\n", + "- **Correlation Analysis**: The `correlate_sentiment_price` method calculates several correlation measures:\n", + " - **Pearson**: Linear relationship between sentiment and price.\n", + " - **Spearman**: Monotonic relationship (less sensitive to outliers).\n", + " - **Kendall**: Rank-based correlation.\n", + " - **Lagged Pearson**: Checks if past sentiment predicts future price.Rolling Correlation: Tracks how the relationship changes over time.\n", + "\n", + "\n", + "### **Code Example: Fetching Prices and Calculating Correlations**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation between sentiment and Bitcoin price:\n", + "Pearson: 0.0267\n", + "Spearman: 0.0161\n", + "Kendall: 0.0101\n", + "Lagged_pearson: 0.0423\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestampsentimentprice_timestamppriceprice_changecumulative_sentimentsentiment_laggedrolling_corr
02025-05-18 19:20:25.477162-0.63692025-05-17 19:55:54.810103155.600954NaN-0.6369NaN0.000000
12025-05-18 19:20:25.5048920.55742025-05-17 20:01:22.531103179.9057960.000236-0.0795-0.63690.000000
22025-05-18 19:20:25.5190810.31822025-05-17 20:06:22.743103190.3735780.0001010.23870.55740.000000
32025-05-18 19:20:25.5360370.00002025-05-17 20:13:04.373103171.510055-0.0001830.23870.31820.000000
42025-05-18 19:20:25.5487960.88342025-05-17 20:16:34.004103162.805201-0.0000841.12210.00000.393383
\n", + "
" + ], + "text/plain": [ + " timestamp sentiment price_timestamp \\\n", + "0 2025-05-18 19:20:25.477162 -0.6369 2025-05-17 19:55:54.810 \n", + "1 2025-05-18 19:20:25.504892 0.5574 2025-05-17 20:01:22.531 \n", + "2 2025-05-18 19:20:25.519081 0.3182 2025-05-17 20:06:22.743 \n", + "3 2025-05-18 19:20:25.536037 0.0000 2025-05-17 20:13:04.373 \n", + "4 2025-05-18 19:20:25.548796 0.8834 2025-05-17 20:16:34.004 \n", + "\n", + " price price_change cumulative_sentiment sentiment_lagged \\\n", + "0 103155.600954 NaN -0.6369 NaN \n", + "1 103179.905796 0.000236 -0.0795 -0.6369 \n", + "2 103190.373578 0.000101 0.2387 0.5574 \n", + "3 103171.510055 -0.000183 0.2387 0.3182 \n", + "4 103162.805201 -0.000084 1.1221 0.0000 \n", + "\n", + " rolling_corr \n", + "0 0.000000 \n", + "1 0.000000 \n", + "2 0.000000 \n", + "3 0.000000 \n", + "4 0.393383 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Fetch Bitcoin price data\n", + "price_df = analyzer.fetch_bitcoin_price()\n", + "\n", + "# Correlate sentiment with price\n", + "combined_df, correlations = analyzer.correlate_sentiment_price(tweets_with_sentiment, price_df)\n", + "\n", + "# Display correlation coefficients\n", + "print(\"Correlation between sentiment and Bitcoin price:\")\n", + "for method, value in correlations.items():\n", + " print(f\"{method.capitalize()}: {value:.4f}\")\n", + "\n", + "# Display the combined DataFrame\n", + "combined_df.head()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Output Explanation**\n", + "- #### **Correlation Coefficients**:\n", + " - Pearson: 0.0267 (very weak positive linear relationship).\n", + " - Spearman: 0.0267 (very weak positive linear relationship).\n", + " - Kendall: 0.0267 (very weak positive linear relationship).\n", + " - Lagged Pearson: 0.0423 (slightly stronger, but still weak, positive correlation between past sentiment and current price).\n", + "- #### **Combined DataFrame**:\n", + " Shows sentiment scores alongside Bitcoin prices, price changes, cumulative sentiment, lagged sentiment, and rolling correlation.\n", + "\n", + "For example, the first row shows a sentiment of -0.6369 (negative) when Bitcoin’s price was $103,155.60, with a slight price increase (0.000236) in the next interval. The cumulative sentiment starts at -0.6369 (since it’s the first tweet), and there’s no lagged sentiment yet (NaN). The rolling correlation is 0 initially because we need more data points to calculate it.\n", + "\n", + "The correlation coefficients are all very close to 0, indicating a very weak positive relationship between tweet sentiment and Bitcoin price. The Pearson correlation (0.0267) suggests almost no linear relationship, sentiment and price don’t move together in a straight line. The Spearman correlation (0.0161) looks at whether sentiment and price move in the same direction (monotonically) and also shows a very weak relationship. The Kendall correlation (0.0101) confirms this weak connection when looking at the ranks of the data. Finally, the Lagged Pearson (0.0423) is slightly higher, hinting that past sentiment might have a tiny influence on future price, but the effect is still negligible. Overall, these low values suggest that, in this sample, public sentiment on X doesn’t strongly predict Bitcoin’s price movements." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "## **Step 4: Visualizations - Plot Sentiment and Price Trends**\n", + "\n", + "Visualizations help us explore the relationship between tweet sentiment and Bitcoin prices. The `BitcoinSentimentAnalyzer` class provides methods to create five types of plots: a line plot, box plot, area plot, heatmap, and rolling correlation plot.\n", + "\n", + "### **What’s Happening Here**\n", + "- **Line Plot**: Shows sentiment and price over time on dual axes.\n", + "- **Box Plot**: Displays the distribution of sentiment scores.\n", + "- **Area Plot**: Compares cumulative sentiment with price trends.\n", + "- **Heatmap**: Visualizes correlations between sentiment, price, and other metrics.\n", + "- **Rolling Correlation**: Tracks how the correlation between sentiment and price changes over time.\n", + "\n", + "### **Code Example: Generating Visualizations**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Enable inline plotting\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment vs Bitcoin Price Over Time:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the data\n", + "print(\"Sentiment vs Bitcoin Price Over Time:\")\n", + "analyzer.visualize_data(combined_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Line Plot (Sentiment vs Bitcoin Price Over Time)**:\n", + "- **What It Shows**: This plot has two lines: sentiment scores (orange) on the right y-axis and Bitcoin prices (blue) on the left y-axis, both plotted against time (x-axis). It helps you see how sentiment and price change together over time.\n", + "- **How to Read It**:\n", + " - Look at the orange line (sentiment) to see how public mood shifts. A rising line means sentiment is becoming more positive; a falling line means it’s becoming more negative.\n", + " - Look at the blue line (price) to see Bitcoin’s price trend. An upward slope means the price is increasing; a downward slope means it’s decreasing.\n", + " - Compare the two lines to spot patterns. For example, if sentiment spikes upward while the price drops, it might suggest that positive tweets aren’t driving price increases in this sample.\n", + "- **Reading Tip**: Since the y-axes are on different scales (sentiment from -1 to 1, price in thousands of USD), focus on the direction of the lines rather than their absolute values. If the orange line jumps up while the blue line dips, note the timestamps to see what might be happening (e.g., a news event).\n", + "\n", + "###" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment Distribution (Box Plot):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display Sentiment Distribution Box Plot\n", + "print(\"Sentiment Distribution (Box Plot):\")\n", + "analyzer.visualize_sentiment_distribution_box(combined_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Box Plot (Sentiment Distribution)**:\n", + "- **What It Shows**: This plot displays the distribution of sentiment scores across all tweets. It’s a box with a line in the middle (median), edges (quartiles), and \"whiskers\" showing the range, plus dots for outliers.\n", + "- **How to Read It**:\n", + " - The **median** (middle line) shows the typical sentiment. If it’s above 0, most tweets are positive; if below 0, most are negative.\n", + " - The **box** (middle 50% of data) shows the range of typical sentiment scores. A tall box means sentiment varies a lot; a short box means it’s more consistent.\n", + " - The **whiskers** show the full range of sentiment scores (excluding outliers). If the whiskers extend far, sentiment is diverse.\n", + " - **Outliers** (dots outside the whiskers) are extreme sentiments. Many outliers might indicate polarized opinions about Bitcoin.\n", + "- **Reading Tip**: If the median is close to 0 and the box spans both positive and negative values, it suggests mixed sentiment. A skewed box (e.g., longer on the positive side) indicates a lean toward one sentiment.\n", + "###" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cumulative Sentiment vs Bitcoin Price (Area Plot):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display Cumulative Sentiment Area Plot\n", + "print(\"Cumulative Sentiment vs Bitcoin Price (Area Plot):\")\n", + "analyzer.visualize_cumulative_sentiment_area(combined_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Area Plot (Cumulative Sentiment vs Bitcoin Price):\n", + "- **What It Shows**: This plot compares cumulative sentiment (orange area) with Bitcoin price (blue line) over time. Cumulative sentiment adds up all sentiment scores, showing the overall mood trend.\n", + "- **How to Read It**:\n", + " - The orange area grows as cumulative sentiment increases. A steep rise means a lot of positive tweets; a flat or declining area means neutral or negative sentiment dominates.\n", + " - The blue line (price) moves independently. Compare its trend with the orange area to see if cumulative sentiment aligns with price changes.\n", + " - For example, if the orange area rises steadily (more positive sentiment) but the blue line drops, it might mean positive sentiment isn’t translating to price increases.\n", + "- **Reading Tip**: Focus on the slope of the orange area. A sharp upward slope indicates a burst of positive tweets. Check the corresponding price to see if it reacts similarly.\n", + "###" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation Heatmap (Sentiment, Price, Price Change, Rolling Correlation):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display Correlation Heatmap\n", + "print(\"Correlation Heatmap (Sentiment, Price, Price Change, Rolling Correlation):\")\n", + "analyzer.visualize_correlation_heatmap(combined_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Heatmap (Correlation Heatmap)**:\n", + "- **What It Shows**: This is a color-coded grid showing correlations between sentiment, price, price change, and rolling correlation. Values range from -1 (strong negative correlation) to 1 (strong positive correlation).\n", + "- **How to Read It**:\n", + " - **Colors**: Red means positive correlation (closer to 1), blue means negative (closer to -1), and white means no correlation (near 0). In our case, with weak correlations (e.g., 0.0267 Pearson), expect pale colors.\n", + " - **Number**s: Each cell shows the exact correlation value. For example, the cell for sentiment vs. price might show 0.0267, confirming a very weak positive relationship.\n", + " - **Diagonal**: The diagonal (e.g., sentiment vs. sentiment) is always 1 (perfect correlation) and can be ignored.\n", + "- **Reading Tip**: Look for the brightest colors to spot the strongest relationships. If most cells are pale (like ours), it means sentiment and price aren’t strongly related in this dataset. Check the sentiment vs. price cell to confirm our earlier correlation results.\n", + "\n", + "###" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rolling Correlation Between Sentiment and Price Over Time:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display Rolling Correlation Plot\n", + "print(\"Rolling Correlation Between Sentiment and Price Over Time:\")\n", + "analyzer.visualize_rolling_correlation(combined_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rolling Correlation Plot (Rolling Correlation Between Sentiment and Price Over Time):\n", + "- **What It Shows**: This plot tracks the correlation between sentiment and price over a moving window of 5 tweets, showing how the relationship evolves over time.\n", + "- **How to Read It**:\n", + " - The y-axis shows the correlation coefficient (from -1 to 1), and the x-axis shows time.\n", + " - Early values are 0 because there aren’t enough data points to calculate the correlation (we need at least 5 tweets).\n", + " - Later values (e.g., 0.393383 in the sample) show the correlation for the most recent 5 tweets. A positive value means sentiment and price move together; a negative value means they move oppositely.\n", + " - For example, a value of 0.393383 suggests a moderate positive correlation in that window, positive sentiment might be associated with price increases.\n", + "- **Reading Tip**: Look for trends in the line. If it fluctuates a lot, the relationship between sentiment and price is unstable. A steady line (e.g., consistently near 0) means the relationship doesn’t change much over time. With only 100 tweets, expect some volatility—more data would smooth this out.\n", + "\n", + "###" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Additional Reading Tips for Beginners**\n", + "- **Spotting Patterns**: In the line and area plots, look for moments where sentiment and price diverge or align. For example, a sudden spike in sentiment might precede a price change, suggesting a predictive relationship.\n", + "- **Outliers Matter**: In the box plot, outliers can be significant, they might represent viral tweets or major events influencing sentiment. Cross-check these with the timestamps in the line plot to see what happened.\n", + "- **Correlation Context**: The heatmap and rolling correlation plot show weak relationships in our case. This doesn’t mean sentiment is irrelevant, it might mean other factors (e.g., market news, trading volume) are driving price more than X sentiment.\n", + "- **Zooming In**: If a plot looks crowded, focus on a smaller time range by filtering the DataFrame (e.g., `combined_df[combined_df['timestamp'] < '2025-05-18 19:30:00']`) and replotting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "## **Step 5: Cleanup**\n", + "\n", + "After running the pipeline, we need to clean up resources to avoid memory leaks and ensure the Selenium WebDriver closes properly.\n", + "\n", + "### **Code Example: Cleaning Up Resources**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Clean up\n", + "del analyzer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **What’s Happening Here**\n", + "- **Resource Management**: The `del analyzer` command removes the `BitcoinSentimentAnalyzer` instance from memory. The class’s `__del__` method automatically closes the Selenium WebDriver, freeing up system resources.\n", + "- **Why It’s Important**: If you don’t close the WebDriver, Chrome processes may keep running in the background, consuming memory and potentially slowing down your system." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Insights for Beginners**\n", + "- **Memory Leaks**: In Python, objects like the Selenium WebDriver can hold onto system resources (e.g., browser instances). Always clean up after you’re done to avoid issues.\n", + "- **Checking Processes**: If you’re unsure whether the WebDriver closed, check your system’s task manager (Ctrl+Shift+Esc on Windows) for lingering Chrome processes. If you see any, you might need to kill them manually.\n", + "- **Practical Tip**: If you’re running multiple experiments, restart the Jupyter kernel (Kernel > Restart) between runs to clear memory." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "### **Best Practice: Using Context Managers**\n", + "For better resource management, you can wrap the analyzer in a context manager. Here’s how you might modify the code to ensure cleanup even if an error occurs." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scraped 10 tweets.\n" + ] + } + ], + "source": [ + "from contextlib import contextmanager\n", + "\n", + "@contextmanager\n", + "def managed_analyzer(username, password):\n", + " analyzer = BitcoinSentimentAnalyzer(x_username=username, x_password=password)\n", + " try:\n", + " yield analyzer\n", + " finally:\n", + " del analyzer\n", + "\n", + "# Use the context manager\n", + "with managed_analyzer(\"sidrohtest\", \"siddhirohantesting#123\") as analyzer:\n", + " tweets = analyzer.scrape_tweets(keywords=[\"Bitcoin\", \"BTC\"], max_tweets=10)\n", + " print(f\"Scraped {len(tweets)} tweets.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###\n", + "## **Step 6: Conclusions and Insights**\n", + "Now that we’ve completed the Bitcoin sentiment analysis pipeline, let’s reflect on the results and visualizations to draw meaningful conclusions. Our goal was to explore whether public sentiment on X (Twitter) about Bitcoin correlates with its price movements. Here’s what we found and what it means for future analysis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Key Findings from Sentiment Analysis**\n", + "From the 100 tweets we scraped mentioning \"Bitcoin\" and \"BTC\", the sentiment analysis using VADER revealed a mix of opinions. The sentiment distribution (from the bar chart in Step 2) likely showed a higher volume of positive and neutral tweets, with some tweets expressing negative connotations. The box plot of sentiment distribution further confirmed this diversity, with a median likely hovering around 0, indicating that public sentiment on X isn’t overwhelmingly positive or negative. The presence of outliers suggests a few tweets with extreme sentiments, possibly driven by significant events or viral opinions about Bitcoin on the day of analysis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Correlation Between Sentiment and Price**\n", + "The correlation analysis in Step 3 provided the following coefficients:\n", + "\n", + "- **Pearson**: 0.0267\n", + "- **Spearman**: 0.0161\n", + "- **Kendall**: 0.0101\n", + "- **Lagged Pearson**: 0.0423\n", + "\n", + "These values are all very close to 0, indicating a very weak positive relationship between tweet sentiment and Bitcoin’s price. This means that, in our sample, changes in public sentiment on X don’t strongly correspond to changes in Bitcoin’s price. For example, the first tweet in our combined DataFrame had a negative sentiment (-0.6369) at a time when Bitcoin’s price was $103,155.60, followed by a slight price increase (0.000236) in the next interval. Despite this negative sentiment, the price didn’t drop significantly, which aligns with the weak correlation we observed. The slightly higher lagged Pearson correlation (0.0423) hints that past sentiment might have a marginally stronger influence on future price, but the effect is still minimal." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Insights from Visualizations**\n", + "The visualizations in Step 4 offered a deeper look into the relationship between sentiment and price:\n", + "\n", + "- **Line Plot (Sentiment vs Bitcoin Price Over Time)**: The dual-axis line plot showed that sentiment and price don’t move in lockstep. For instance, sentiment fluctuated (e.g., from -0.6369 to 0.5574), while the price showed a slight downward trend (from $103,155.60 to $103,162.81). This lack of alignment supports the weak correlation coefficients, suggesting that other factors (e.g., market news, trading volume) might be driving price more than X sentiment.\n", + "- **Box Plot (Sentiment Distribution)**: The box plot likely revealed a wide range of sentiment scores, with the median near 0 and some outliers. This indicates mixed feelings about Bitcoin on X, with no dominant positive or negative mood. The outliers (e.g., a highly positive score of 0.8834) might reflect specific events—like a viral tweet about Bitcoin’s potential, that didn’t impact the overall price trend.\n", + "- **Area Plot (Cumulative Sentiment vs Bitcoin Price)**: The cumulative sentiment started at -0.6369 and rose to 1.1221 by the fifth tweet, showing a gradual shift toward more positive sentiment over time. However, the price remained relatively stable, with minor fluctuations (e.g., a small drop of -0.000084 by the fifth interval). This divergence suggests that even as overall sentiment became more positive, it didn’t translate into significant price increases.\n", + "- **Heatmap (Correlation Heatmap)**: The heatmap confirmed the weak correlations, with pale colors across the board. The sentiment vs. price correlation (0.0267) was nearly white, indicating little to no relationship. Other metrics, like price change and rolling correlation, also showed weak connections, reinforcing that sentiment alone isn’t a strong predictor of price in this dataset.\n", + "- **Rolling Correlation Plot**: The rolling correlation started at 0 (not enough data) and rose to 0.393383 by the fifth tweet, indicating a moderate positive correlation in that specific window. However, with only 100 tweets, this value fluctuates significantly, and the overall trend remains weak. A larger dataset might reveal more stable patterns." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Conclusions**\n", + "1. **Weak Sentiment-Price Relationship**: The very weak positive correlations (e.g., Pearson: 0.0267) suggest that public sentiment on X, as captured in our sample of 100 tweets, doesn’t strongly influence Bitcoin’s price movements. While the lagged Pearson correlation (0.0423) hints at a slight predictive effect, it’s not strong enough to rely on for trading or forecasting decisions.\n", + "2. **Mixed Public Sentiment**: The sentiment analysis showed a balanced mix of positive, negative, and neutral opinions about Bitcoin. This diversity, combined with the weak correlation, indicates that X sentiment might be too noisy or varied to directly impact price. External factors—like institutional trading, regulatory news, or market sentiment from other platforms—could be more significant drivers.\n", + "3. **Time Misalignment Challenges**: The timestamps of our tweets and price data don’t perfectly align, which might dilute the correlation. In a real-world application, you’d want to align these more closely, perhaps by scraping tweets over a longer period and matching them to price data at finer intervals (e.g., every 15 minutes).\n", + "4. **Small Sample Size Limitation**: With only 100 tweets, our analysis captures a snapshot of sentiment but may not reflect broader trends. The rolling correlation’s volatility (e.g., reaching 0.393383 in one window) shows how sensitive results are to small data changes. Collecting more tweets (e.g., 500 or 1,000) over several days could provide more robust insights.\n", + "5. **Potential for Further Exploration**: The slight increase in the lagged Pearson correlation suggests that sentiment might have a delayed effect on price. This could be worth exploring further by collecting more data and testing different lag periods (e.g., 1 hour, 1 day). Additionally, the outliers in the sentiment distribution indicate that specific tweets might have a disproportionate impact—identifying these (e.g., viral tweets from influencers) could reveal more nuanced relationships." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Implications for Future Work**\n", + "- Increase Sample Size: Scrape more tweets over a longer period (e.g., a week) to capture broader sentiment trends and reduce noise. This would likely smooth out the rolling correlation and provide more reliable correlation coefficients.\n", + "- Incorporate More Data: Fetch additional metrics from CoinGecko, like trading volume or market cap, to see if they correlate better with sentiment. For example, high trading volume might amplify the impact of sentiment on price.\n", + "- Refine Sentiment Analysis: Fine-tune spaCy’s NER to better identify cryptocurrencies (e.g., correctly label \"Bitcoin\" as a product, not a person). Also, experiment with VADER’s sentiment thresholds to see if stricter categories (e.g., > 0.2 for positive) reveal stronger patterns.\n", + "- Account for External Events: On the day of analysis, Bitcoin’s price was relatively stable around $$103,155 to $103,162. Check news from this period—were there major events (e.g., regulatory announcements, market crashes) that might have overshadowed X sentiment? Incorporating such context could explain the weak correlation.\n", + "- Explore Other Platforms: X is just one source of sentiment. Analyzing sentiment from Reddit, news articles, or other platforms might provide a more comprehensive view of public opinion and its impact on Bitcoin’s price.\n", + "\n", + "\n", + "## **Final Thoughts**\n", + "This analysis highlights the complexity of linking social media sentiment to cryptocurrency prices. While our pipeline successfully scraped tweets, analyzed sentiment, and correlated it with price data, the weak relationship suggests that X sentiment alone isn’t a strong predictor of Bitcoin’s price in this sample. However, the pipeline lays a solid foundation for further exploration. By scaling up the data, refining the analysis, and incorporating additional factors, we can gain deeper insights into how public sentiment influences cryptocurrency markets. For beginners, this project is a great starting point to learn about web scraping, NLP, and data visualization. Keep experimenting and building on these techniques to uncover new patterns!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.md b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.md new file mode 100644 index 000000000..1b71e556c --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_example.md @@ -0,0 +1,127 @@ +# Real-Time Bitcoin Sentiment Analysis: A Walkthrough of `spacy_selenium_example.ipynb` + +## Overview + +The `spacy_selenium_example.ipynb` notebook is the core demonstration of the Real-Time Bitcoin Sentiment Analysis pipeline, a project developed for the DATA605 course in Spring 2025. This notebook provides a comprehensive, step-by-step guide to scraping Bitcoin-related tweets from X (Twitter), preprocessing them with spaCy, analyzing sentiment with VADER, correlating sentiment with Bitcoin prices from the CoinGecko API, and visualizing the results. + +Designed for both beginners and intermediate users, this notebook integrates web scraping, natural language processing (NLP), and data visualization to explore whether public sentiment on X influences Bitcoin price movements. It builds on the foundational concepts introduced in `spacy_selenium_API.ipynb` and serves as the main entry point for running the full pipeline, making it an ideal resource for learning practical data science techniques. + +## Purpose + +The `spacy_selenium_example.ipynb` notebook aims to showcase the complete Bitcoin sentiment analysis pipeline in a single, executable workflow. Its key objectives are to: + +- Scrape tweets mentioning "Bitcoin" and "BTC" from X using Selenium. +- Preprocess the tweet text using spaCy for cleaning, tokenization, lemmatization, and entity extraction. +- Analyze sentiment with VADER, categorizing tweets as positive, negative, or neutral. +- Fetch Bitcoin price data from the CoinGecko API and compute correlations with sentiment scores. +- Visualize the results through multiple plots to explore trends and relationships. +- Provide actionable insights and conclusions based on the analysis, along with suggestions for future work. + +The notebook includes detailed explanations, beginner-friendly insights, additional examples, and best practices to facilitate learning and experimentation. + +## Notebook Structure + +The notebook is organized into six steps, each focusing on a critical part of the pipeline: + +### 1. Data Ingestion - Scrape Tweets + +- **Purpose**: Collect raw tweets mentioning "Bitcoin" or "BTC" from X using the `BitcoinSentimentAnalyzer` class, which leverages Selenium for automated scraping. +- **Process**: Logs into X, searches for tweets, and scrolls dynamically to gather up to 100 tweets, storing them in a pandas DataFrame. +- **Output**: A DataFrame with columns `text` (tweet content) and `timestamp` (when scraped). For example, a tweet might read, "Bitcoin hold become rich." +- **Additional Example**: Filters tweets containing the word "price" to focus on market value discussions, e.g., "Current Bitcoin price: $104542.61 USD." +- **Insights**: Offers troubleshooting tips for common scraping issues like login errors, timeouts, and dynamic content changes, emphasizing the importance of respecting X’s rate limits. + +### 2. Data Preprocessing - Clean and Preprocess Tweets + +- **Purpose**: Clean and preprocess tweets to prepare them for sentiment analysis. +- **Process**: Uses spaCy to remove noise (URLs, hashtags, emojis), tokenize, lemmatize, and extract entities, followed by VADER sentiment analysis to assign scores and categories. +- **Output**: A DataFrame with columns `text` (processed text), `sentiment` (score from -1 to 1), `sentiment_category` (positive, negative, neutral), and `coins` (identified cryptocurrencies). For example, the processed tweet "bitcoin hold rich" has a sentiment score of 0.5574 (positive). +- **Additional Example**: Analyzes sentiment distribution with a bar chart, showing a mix of 44 neutral, 42 positive, and 14 negative tweets. +- **Insights**: Explains the importance of preprocessing, VADER’s suitability for social media, and spaCy’s NER limitations for crypto terms, with tips for manual experimentation. + +### 3. Correlation with Bitcoin Prices - Fetch Prices and Analyze Correlation + +- **Purpose**: Fetch Bitcoin price data and correlate it with tweet sentiment to explore relationships. +- **Process**: Retrieves 1-day price history from CoinGecko and computes Pearson (0.0267), Spearman (0.0161), Kendall (0.0101), lagged Pearson (0.0423), and rolling correlations. +- **Output**: A DataFrame combining sentiment and price data, e.g., a sentiment of -0.6369 corresponds to a price of $103,155.60, with a slight price increase (0.000236) in the next interval. +- **Additional Example**: Plots Bitcoin’s price trend over the last day to contextualize the correlation. +- **Insights**: Highlights the very weak positive correlations, suggesting sentiment on X doesn’t strongly predict price movements, and discusses time misalignment challenges. + +### 4. Visualizations - Plot Sentiment and Price Trends + +- **Purpose**: Visualize the relationship between sentiment and price through various plots. +- **Process**: Generates five plots: a line plot (sentiment vs. price), box plot (sentiment distribution), area plot (cumulative sentiment vs. price), correlation heatmap, and rolling correlation plot. +- **Output**: + - Line plot: Shows sentiment and price trends, revealing a lack of alignment. + - Box plot: Displays a wide range of sentiment scores with a median near 0. + - Area plot: Indicates a rise in cumulative sentiment (to 1.1221) without significant price changes. + - Heatmap: Confirms weak correlations with pale colors. + - Rolling correlation plot: Shows volatility, reaching 0.393383 in one window. +- **Additional Guidance**: Provides detailed instructions on reading each plot, e.g., focusing on trends in the line plot and outliers in the box plot. +- **Insights**: Emphasizes the weak relationship between sentiment and price, with tips for spotting patterns and zooming into specific time ranges. + +### 5. Cleanup + +- **Purpose**: Ensure proper resource management by closing the Selenium WebDriver. +- **Process**: Deletes the `BitcoinSentimentAnalyzer` instance, automatically closing the WebDriver. +- **Additional Example**: Introduces a context manager to safely handle resources, even if errors occur. +- **Insights**: Stresses the importance of avoiding memory leaks, with tips for checking processes and restarting the Jupyter kernel. + +### 6. Conclusions and Insights + +- **Key Findings**: + - Sentiment Analysis: A mix of opinions (44 neutral, 42 positive, 14 negative), with a median near 0 and some extreme outliers. + - Correlation: Very weak positive correlations (e.g., Pearson: 0.0267), indicating X sentiment doesn’t strongly influence price. + - Visualizations: Show a lack of alignment between sentiment and price trends, with cumulative sentiment rising but price remaining stable. +- **Conclusions**: + - Weak Sentiment-Price Relationship: Sentiment on X isn’t a strong predictor of Bitcoin price in this sample. + - Mixed Public Sentiment: Diverse opinions suggest X sentiment is noisy and not a dominant price driver. + - Time Misalignment: Mismatched timestamps dilute correlations, requiring better alignment in future work. + - Small Sample Size: 100 tweets limit the robustness of findings; more data could yield better insights. + - Further Exploration: The slight lagged correlation (0.0423) and outliers suggest potential for deeper analysis. +- **Implications**: + - Increase sample size to 500–1,000 tweets over a longer period. + - Incorporate additional metrics like trading volume or market cap. + - Refine spaCy’s NER and VADER’s thresholds for better accuracy. + - Account for external events (e.g., news) that might overshadow X sentiment. + - Explore sentiment from other platforms like Reddit or news articles. + +## Educational Value + +This notebook is an excellent learning resource for several reasons: + +- **Practical Workflow**: Demonstrates a complete pipeline from data collection to visualization, bridging web scraping, NLP, and data analysis. +- **Beginner-Friendly**: Includes detailed explanations, insights, and tips tailored for beginners, such as troubleshooting scraping issues, interpreting sentiment scores, and reading visualizations. +- **Hands-On Examples**: Provides additional examples (e.g., filtering tweets, customizing plots) to encourage experimentation and deeper understanding. +- **Best Practices**: Emphasizes resource management, rate limit considerations, and data quality improvements. +- **Extensibility**: Offers a scalable framework for analyzing other cryptocurrencies or platforms, making it a foundation for further projects. + +## How to Use + +To run this notebook, follow the setup instructions in the project’s `README.md` to install dependencies, configure ChromeDriver, and provide X credentials. Then: + +1. Open the notebook in Jupyter: + + ```bash + jupyter notebook spacy_selenium_example.ipynb + ``` +2. Run the cells sequentially to execute the pipeline. +3. Experiment with the additional examples (e.g., filter tweets, adjust visualizations) to explore the data further. +4. Review the "Conclusions and Insights" section for key takeaways and future directions. + +### Requirements + +- Python 3.9+ +- ChromeDriver matching your Chrome version +- X (Twitter) account credentials +- Stable internet connection +- Dependencies listed in `requirements.txt` + +## Key Takeaways + +- The pipeline successfully integrates scraping, NLP, and visualization to analyze Bitcoin sentiment, but the correlation with price is weak (e.g., Pearson: 0.0267). +- Public sentiment on X is diverse, with a mix of positive, neutral, and negative opinions, as seen in the sentiment distribution. +- Visualizations reveal a lack of strong alignment between sentiment and price, suggesting other factors (e.g., market news) may dominate price movements. +- The notebook provides a solid foundation for learning data science techniques, with opportunities for customization and further exploration. + +For a deeper understanding of spaCy and Selenium, refer to `spacy_selenium_API.ipynb`. For setup and project context, see the `README.md`. \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_utils.py b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_utils.py new file mode 100644 index 000000000..b281f47d0 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/spacy_selenium_utils.py @@ -0,0 +1,595 @@ +""" +Utility module for the Bitcoin sentiment analysis project, including spaCy and Selenium functionality. + +1. Citations: + - Selenium Twitter scraping inspired by: https://github.com/selenium-twitter-scraper + - VADER sentiment analysis: Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. + - CoinGecko API: https://www.coingecko.com/en/api/documentation +2. Run the linter on this script before committing changes to ensure consistency with the coding style. +3. Refer to spacy_API.md for detailed system documentation. + +Follow the coding style guide: https://github.com/causify-ai/helpers/blob/master/docs/coding/all.coding_style.how_to_guide.md +""" + +# Import libraries in this section. +import logging +import time +from typing import List, Tuple +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +import requests +import spacy +import re +from scipy.stats import spearmanr, kendalltau +from selenium import webdriver +from selenium.webdriver.chrome.options import Options +from selenium.webdriver.chrome.service import Service +from selenium.webdriver.common.by import By +from selenium.webdriver.support.ui import WebDriverWait +from selenium.webdriver.support import expected_conditions as EC +from selenium.common.exceptions import TimeoutException +from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer + +# Set up logger for the module. +_LOG = logging.getLogger(__name__) + +def log_message(message: str) -> None: + """ + Log a message with INFO level. + + :param message: The message to log. + :return: None + """ + _LOG.info(message) + +# ############################################################################# +# Bitcoin Sentiment Analyzer +# ############################################################################# + +class BitcoinSentimentAnalyzer: + """ + Analyze sentiment of Bitcoin-related tweets and correlate with price movements. + """ + + def __init__(self, chromedriver_path: str = None, x_username: str = None, x_password: str = None): + """ + Initialize the BitcoinSentimentAnalyzer. + + :param chromedriver_path: Path to the ChromeDriver executable (optional, defaults to None). + :param x_username: X username for login (optional, defaults to None). + :param x_password: X password for login (optional, defaults to None). + """ + # Initialize spaCy for NLP processing + self.nlp = spacy.load("en_core_web_sm") + # Initialize VADER for sentiment analysis + self.sid = SentimentIntensityAnalyzer() + # Fetch coin list from CoinGecko for entity matching + url = "https://api.coingecko.com/api/v3/coins/list" + try: + response = requests.get(url) + response.raise_for_status() + coins = response.json() + self.coin_list = [coin["name"].lower() for coin in coins] + except requests.RequestException as e: + log_message(f"Error fetching CoinGecko data: {str(e)}") + self.coin_list = [] + # Store X credentials + self.x_username = x_username + self.x_password = x_password + # Set up Selenium WebDriver in headless mode + chrome_options = Options() + chrome_options.add_argument("--headless") + chrome_options.add_argument("--no-sandbox") + chrome_options.add_argument("--disable-dev-shm-usage") + chrome_options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36") + if chromedriver_path: + service = Service(chromedriver_path) + self.driver = webdriver.Chrome(service=service, options=chrome_options) + else: + self.driver = webdriver.Chrome(options=chrome_options) + + def login_to_x(self): + """ + Log in to X using provided credentials. + """ + if not self.x_username or not self.x_password: + log_message("No X credentials provided. Attempting anonymous access.") + return + + log_message("Logging in to X...") + self.driver.get("https://x.com/login") + time.sleep(5) # Wait for login page to load + + try: + # Try multiple selectors for username field + username_selectors = [ + (By.NAME, "text"), + (By.CSS_SELECTOR, "input[autocomplete='username']"), + (By.XPATH, "//input[@name='text' or @autocomplete='username']") + ] + username_field = None + for by, selector in username_selectors: + try: + username_field = WebDriverWait(self.driver, 15).until( + EC.presence_of_element_located((by, selector)) + ) + break + except TimeoutException: + continue + + if not username_field: + raise TimeoutException("Username field not found with any selector.") + + username_field.send_keys(self.x_username) + + # Try multiple selectors for the Next button + next_button_selectors = [ + (By.XPATH, "//span[contains(text(), 'Next')]"), + (By.CSS_SELECTOR, "button[role='button'] span[contains(text(), 'Next')]"), + (By.XPATH, "//button[@role='button' and .//span[contains(text(), 'Next')]]") + ] + next_button = None + for by, selector in next_button_selectors: + try: + next_button = WebDriverWait(self.driver, 10).until( + EC.element_to_be_clickable((by, selector)) + ) + break + except TimeoutException: + continue + + if not next_button: + raise TimeoutException("Next button not found with any selector.") + + # Retry clicking "Next" button up to 3 times + retry_attempts = 3 + for attempt in range(retry_attempts): + try: + next_button.click() + break + except Exception as e: + log_message(f"Attempt {attempt + 1} to click Next button failed: {str(e)}") + if attempt == retry_attempts - 1: + raise TimeoutException("Failed to click Next button after retries.") + time.sleep(2) + + time.sleep(10) # Increased delay to ensure password page loads + + # Check for intermediate verification prompts (e.g., email verification) + try: + verification_prompt = WebDriverWait(self.driver, 5).until( + EC.presence_of_element_located((By.XPATH, "//*[contains(text(), 'Verify your email') or contains(text(), 'Verify your phone')]")) + ) + log_message("Verification prompt detected (email/phone). Manual intervention required.") + self.driver.save_screenshot("verification_prompt_screenshot.png") + log_message("Screenshot saved as verification_prompt_screenshot.png") + raise Exception("Verification prompt encountered. Please handle manually.") + except TimeoutException: + # No email/phone verification prompt detected, continue + pass + + # Try multiple selectors for password field + password_selectors = [ + (By.NAME, "password"), + (By.CSS_SELECTOR, "input[autocomplete='current-password']"), + (By.XPATH, "//input[@name='password' or @autocomplete='current-password']"), + (By.CSS_SELECTOR, "input[type='password']"), + (By.XPATH, "//input[@type='password']"), + (By.CSS_SELECTOR, "input[data-testid='password']"), + (By.XPATH, "//input[contains(@class, 'password')]") + ] + password_field = None + for by, selector in password_selectors: + try: + password_field = WebDriverWait(self.driver, 30).until( + EC.presence_of_element_located((by, selector)) + ) + break + except TimeoutException: + continue + + if not password_field: + # Log the page source for debugging + log_message("Password field not found. Current URL: " + self.driver.current_url) + log_message("Page source snippet:") + page_source = self.driver.page_source + log_message(page_source[:1000]) + self.driver.save_screenshot("password_field_failure_screenshot.png") + log_message("Screenshot saved as password_field_failure_screenshot.png") + raise TimeoutException("Password field not found with any selector.") + + password_field.send_keys(self.x_password) + + # Try multiple selectors for the Log in button + login_button_selectors = [ + (By.XPATH, "//span[contains(text(), 'Log in')]"), + (By.CSS_SELECTOR, "button[role='button'] span[contains(text(), 'Log in')]"), + (By.XPATH, "//button[@role='button' and .//span[contains(text(), 'Log in')]]"), + (By.CSS_SELECTOR, "button[data-testid='LoginForm_Login_Button']") + ] + login_button = None + for by, selector in login_button_selectors: + try: + login_button = WebDriverWait(self.driver, 10).until( + EC.element_to_be_clickable((by, selector)) + ) + break + except TimeoutException: + continue + + if not login_button: + raise TimeoutException("Log in button not found with any selector.") + + login_button.click() + time.sleep(5) # Wait for login to complete + + # Check for 2FA or verification prompts + try: + verification_prompt = WebDriverWait(self.driver, 5).until( + EC.presence_of_element_located((By.XPATH, "//input[@name='verification_code']")) + ) + log_message("2FA or verification prompt detected. Manual intervention required.") + self.driver.save_screenshot("2fa_verification_screenshot.png") + log_message("Screenshot saved as 2fa_verification_screenshot.png") + raise Exception("2FA or verification prompt encountered. Please handle manually.") + except TimeoutException: + # No 2FA prompt detected, continue + pass + + log_message("Successfully logged in to X.") + except Exception as e: + log_message(f"Failed to log in to X: {str(e)}") + self.driver.save_screenshot("login_failure_screenshot.png") + log_message("Screenshot of login failure saved as login_failure_screenshot.png") + raise + + def scrape_tweets(self, keywords: List[str], max_tweets: int) -> List[dict]: + """ + Scrape tweets containing the specified keywords using Selenium. + + :param keywords: List of search terms to query on Twitter (e.g., ["Bitcoin", "BTC"]). + :param max_tweets: The maximum number of tweets to scrape. + :return: A list of dictionaries with tweet text and timestamp. + """ + # Log in to X if credentials are provided + self.login_to_x() + + all_tweets = [] + seen_texts = set() # To track unique tweets and avoid duplicates + + for keyword in keywords: + log_message(f"Scraping tweets for keyword: {keyword}") + self.driver.get(f"https://x.com/search?q={keyword}&src=typed_query&f=live") + time.sleep(5) # Wait for initial page load + + tweets = [] + scroll_attempts = 0 + max_scroll_attempts = 50 # Limit to avoid infinite scrolling + + while len(tweets) < max_tweets and scroll_attempts < max_scroll_attempts: + try: + # Try multiple selectors for tweet elements + tweet_selectors = [ + (By.CSS_SELECTOR, 'article[data-testid="tweet"]'), + (By.CSS_SELECTOR, 'article[data-testid="post"]'), + (By.CSS_SELECTOR, 'div[data-testid="tweetText"]') + ] + tweet_elements = None + for by, selector in tweet_selectors: + try: + WebDriverWait(self.driver, 60).until( + EC.presence_of_element_located((by, selector)) + ) + if selector == 'div[data-testid="tweetText"]': + # If using tweetText, the parent article element is needed for context + tweet_elements = self.driver.find_elements(By.CSS_SELECTOR, 'article') + else: + tweet_elements = self.driver.find_elements(by, selector) + break + except TimeoutException: + continue + + if not tweet_elements: + raise TimeoutException("Tweet elements not found with any selector.") + + for element in tweet_elements: + try: + # Adjust text extraction based on selector + if 'tweetText' in selector: + text = element.find_element(By.CSS_SELECTOR, 'div[data-testid="tweetText"]').text + else: + text = element.find_element(By.CSS_SELECTOR, 'div[lang]').text + if text not in seen_texts: # Check for duplicates + timestamp = pd.Timestamp.now().isoformat() + tweets.append({"text": text, "timestamp": timestamp}) + seen_texts.add(text) + except: + continue + + # Scroll down to load more tweets + self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);") + time.sleep(2) # Wait for new tweets to load + scroll_attempts += 1 + + except TimeoutException as e: + log_message("Timeout waiting for tweet elements. Debugging info:") + log_message(f"Page URL: {self.driver.current_url}") + log_message("Page source snippet:") + page_source = self.driver.page_source + log_message(page_source[:1000]) + self.driver.save_screenshot("timeout_screenshot.png") + log_message("Screenshot saved as timeout_screenshot.png") + raise e + + log_message(f"Scraped {len(tweets)} tweets for keyword: {keyword}") + all_tweets.extend(tweets) + + # Sort tweets by timestamp and limit to max_tweets + all_tweets.sort(key=lambda x: x["timestamp"]) + all_tweets = all_tweets[:max_tweets] + log_message(f"Total unique tweets after combining: {len(all_tweets)}") + return all_tweets + + def preprocess_tweets(self, tweets: List[dict]) -> List[dict]: + """ + Preprocess tweets using spaCy for tokenization, lemmatization, and cleaning. + + :param tweets: A list of tweet dictionaries with text and timestamp. + :return: A list of preprocessed tweet dictionaries with entities. + """ + log_message(f"Preprocessing {len(tweets)} tweets.") + processed_tweets = [] + for tweet in tweets: + # Inline clean_text logic + cleaned_text = re.sub(r"http\S+|www\S+|https\S+", "", tweet["text"], flags=re.MULTILINE) + cleaned_text = re.sub(r"@\w+|#\w+", "", cleaned_text) + cleaned_text = cleaned_text.encode("ascii", "ignore").decode() # Remove emojis + cleaned_text = re.sub(r"\s+", " ", cleaned_text).strip() + + # Inline extract_entities logic + doc = self.nlp(cleaned_text) + tokens = [token.lemma_.lower() for token in doc if not token.is_stop and not token.is_punct] + processed_text = " ".join(tokens) + entities = [(ent.text, ent.label_) for ent in doc.ents] + + # Inline match_entities_with_coins logic + matched_coins = [] + for text, label in entities: + if label in ["ORG", "PRODUCT", "PERSON"] and text.lower() in self.coin_list: + matched_coins.append(text) + + processed_tweets.append({ + "text": processed_text, + "timestamp": tweet["timestamp"], + "entities": entities, + "coins": matched_coins + }) + log_message("Completed preprocessing.") + return processed_tweets + + def analyze_sentiment(self, tweets: List[dict]) -> List[dict]: + """ + Analyze the sentiment of tweets using VADER and categorize them. + + :param tweets: A list of preprocessed tweet dictionaries. + :return: A list of tweet dictionaries with sentiment scores and categories. + """ + log_message(f"Analyzing sentiment for {len(tweets)} tweets.") + for tweet in tweets: + sentiment = self.sid.polarity_scores(tweet["text"]) + tweet["sentiment"] = sentiment["compound"] + # Categorize sentiment + if tweet["sentiment"] > 0: + tweet["sentiment_category"] = "positive" + elif tweet["sentiment"] < 0: + tweet["sentiment_category"] = "negative" + else: + tweet["sentiment_category"] = "neutral" + log_message("Sentiment analysis complete.") + return tweets + + def fetch_bitcoin_price(self) -> pd.DataFrame: + """ + Fetch Bitcoin price data from CoinGecko API. + + :return: A pandas DataFrame with columns 'timestamp' and 'price'. + """ + log_message("Fetching Bitcoin price data from CoinGecko API.") + url = "https://api.coingecko.com/api/v3/coins/bitcoin/market_chart?vs_currency=usd&days=1" + response = requests.get(url).json() + prices = response["prices"] + df = pd.DataFrame(prices, columns=["timestamp", "price"]) + df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms") + log_message(f"Fetched {len(df)} price data points.") + return df + + def correlate_sentiment_price(self, tweets: List[dict], price_df: pd.DataFrame) -> Tuple[pd.DataFrame, dict]: + """ + Correlate sentiment scores with Bitcoin price data using multiple methods. + + :param tweets: A list of tweet dictionaries with sentiment scores. + :param price_df: A DataFrame with Bitcoin price data. + :return: A tuple containing the combined DataFrame and a dictionary of correlation coefficients. + """ + log_message("Correlating sentiment with Bitcoin price.") + sentiment_df = pd.DataFrame({ + "timestamp": [tweet["timestamp"] for tweet in tweets], + "sentiment": [tweet["sentiment"] for tweet in tweets] + }) + sentiment_df["timestamp"] = pd.to_datetime(sentiment_df["timestamp"]) + # Resample price data to match the number of tweets (simplified) + price_df = price_df.iloc[:len(tweets)] + # Rename timestamp column in price_df to avoid conflict + price_df = price_df.rename(columns={"timestamp": "price_timestamp"}) + combined_df = pd.concat([sentiment_df, price_df.reset_index(drop=True)], axis=1) + + # Calculate additional metrics + combined_df["price_change"] = combined_df["price"].pct_change() + combined_df["cumulative_sentiment"] = combined_df["sentiment"].cumsum() + + # Calculate multiple correlation coefficients + correlations = {} + # Pearson correlation (linear) + correlations["pearson"] = combined_df["sentiment"].corr(combined_df["price"]) + # Spearman correlation (monotonic) + spearman_corr, _ = spearmanr(combined_df["sentiment"], combined_df["price"]) + correlations["spearman"] = spearman_corr + # Kendall correlation (rank-based) + kendall_corr, _ = kendalltau(combined_df["sentiment"], combined_df["price"]) + correlations["kendall"] = kendall_corr + + # Lagged correlation (shift sentiment by 1 to see if past sentiment predicts price) + combined_df["sentiment_lagged"] = combined_df["sentiment"].shift(1) + correlations["lagged_pearson"] = combined_df["sentiment_lagged"].corr(combined_df["price"]) + + # Rolling correlation (window of 5) + rolling_corr = combined_df["sentiment"].rolling(window=5).corr(combined_df["price"]).fillna(0) + combined_df["rolling_corr"] = rolling_corr + + log_message("Correlation coefficients:") + for method, value in correlations.items(): + log_message(f"{method.capitalize()}: {value:.4f}") + + return combined_df, correlations + + def visualize_data(self, combined_df: pd.DataFrame) -> None: + """ + Visualize sentiment scores and Bitcoin price trends. + + :param combined_df: A DataFrame with sentiment and price data. + :return: None + """ + log_message("Generating visualization of sentiment and price trends.") + plt.figure(figsize=(10, 6)) + plt.plot(combined_df["timestamp"], combined_df["price"], label="Bitcoin Price (USD)", color="blue") + plt.twinx() + plt.plot(combined_df["timestamp"], combined_df["sentiment"], label="Sentiment Score", color="orange") + plt.title("Bitcoin Price vs Sentiment Over Time") + plt.legend() + plt.show() + plt.close() + + def visualize_sentiment_distribution_box(self, combined_df: pd.DataFrame) -> None: + """ + Visualize the distribution of sentiment scores as a box plot. + + :param combined_df: A DataFrame with sentiment data. + :return: None + """ + log_message("Generating box plot of sentiment distribution.") + plt.figure(figsize=(8, 6)) + plt.boxplot(combined_df["sentiment"], vert=False) + plt.title("Distribution of Sentiment Scores") + plt.xlabel("Sentiment Score") + plt.show() + plt.close() + + def visualize_cumulative_sentiment_area(self, combined_df: pd.DataFrame) -> None: + """ + Visualize cumulative sentiment and Bitcoin price as an area plot. + + :param combined_df: A DataFrame with sentiment and price data. + :return: None + """ + log_message("Generating area plot of cumulative sentiment and price.") + fig, ax1 = plt.subplots(figsize=(10, 6)) + ax1.fill_between(combined_df["timestamp"], combined_df["cumulative_sentiment"], color="orange", alpha=0.3, label="Cumulative Sentiment") + ax1.set_xlabel("Time") + ax1.set_ylabel("Cumulative Sentiment", color="orange") + ax1.tick_params(axis="y", labelcolor="orange") + ax2 = ax1.twinx() + ax2.plot(combined_df["timestamp"], combined_df["price"], color="blue", label="Bitcoin Price (USD)") + ax2.set_ylabel("Bitcoin Price (USD)", color="blue") + ax2.tick_params(axis="y", labelcolor="blue") + fig.suptitle("Cumulative Sentiment vs Bitcoin Price") + fig.legend(loc="upper right") + plt.show() + plt.close() + + def visualize_correlation_heatmap(self, combined_df: pd.DataFrame) -> None: + """ + Visualize a heatmap of correlations between sentiment, price, and other metrics. + + :param combined_df: A DataFrame with sentiment and price data. + :return: None + """ + log_message("Generating correlation heatmap.") + corr_matrix = combined_df[["sentiment", "price", "price_change", "rolling_corr"]].corr() + plt.figure(figsize=(8, 6)) + sns.heatmap(corr_matrix, annot=True, cmap="coolwarm", vmin=-1, vmax=1) + plt.title("Correlation Heatmap") + plt.show() + plt.close() + + def visualize_rolling_correlation(self, combined_df: pd.DataFrame) -> None: + """ + Visualize the rolling correlation between sentiment and price over time. + + :param combined_df: A DataFrame with sentiment and price data. + :return: None + """ + log_message("Generating rolling correlation plot.") + plt.figure(figsize=(10, 6)) + plt.plot(combined_df["timestamp"], combined_df["rolling_corr"], label="Rolling Correlation (window=5)", color="purple") + plt.title("Rolling Correlation Between Sentiment and Bitcoin Price") + plt.xlabel("Time") + plt.ylabel("Correlation Coefficient") + plt.legend() + plt.show() + plt.close() + + def run_analysis(self, keywords: List[str] = ["Bitcoin", "BTC"], max_tweets: int = 50) -> None: + """ + Run the full sentiment analysis pipeline. + + :param keywords: List of search terms to query on Twitter (default: ["Bitcoin", "BTC"]). + :param max_tweets: The maximum number of tweets to scrape (default: 50). + :return: None + """ + log_message("Starting Bitcoin sentiment analysis pipeline.") + tweets = self.scrape_tweets(keywords, max_tweets) + processed_tweets = self.preprocess_tweets(tweets) + tweets_with_sentiment = self.analyze_sentiment(processed_tweets) + price_df = self.fetch_bitcoin_price() + combined_df, correlations = self.correlate_sentiment_price(tweets_with_sentiment, price_df) + + # Visualizations + self.visualize_data(combined_df) + self.visualize_sentiment_distribution_box(combined_df) + self.visualize_cumulative_sentiment_area(combined_df) + self.visualize_correlation_heatmap(combined_df) + self.visualize_rolling_correlation(combined_df) + + log_message("Analysis pipeline completed.") + + def __del__(self): + """ + Clean up resources when the object is deleted. + + :return: None + """ + log_message("Closing Selenium WebDriver.") + if hasattr(self, 'driver'): + self.driver.quit() + + +def main() -> None: + """ + Execute the main Bitcoin sentiment analysis pipeline. + + :return: None + """ + logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s") + log_message("Starting main function.") + analyzer = BitcoinSentimentAnalyzer( + chromedriver_path="path/to/chromedriver", + x_username="your_username", # Replace with your X username + x_password="your_password" # Replace with your X password + ) + analyzer.run_analysis(keywords=["Bitcoin", "BTC"], max_tweets=50) + log_message("Main function completed.") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/version.sh b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/version.sh new file mode 100755 index 000000000..534d5a694 --- /dev/null +++ b/DATA605/Spring2025/projects/TutorTask204_Spring2025_RealTime_Bitcoin_Sentiment_Analysis_spaCy_Selenium/docker_data605_style/version.sh @@ -0,0 +1,11 @@ +#!/bin/bash +echo "# Pytho3" +python3 --version +echo "# pip3" +pip3 --version +echo "# jupyter" +jupyter --version +echo "# Python packages" +pip3 list +echo "# mongo" +mongod --version