Improving_Sentiment_Analysis_on_Amazon_Reviews_with_Pre_trained_Models.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Improving Sentiment Analysis on Amazon Reviews with Pre-trained Models Overview\n",
        "\n",
        "## Project Description\n",
        "- <font color='blue'>**Purpose:**</font> This project demonstrates sentiment analysis using deep learning models (BERT, RoBERTa, DistilBERT) and VADER sentiment analyzer from NLTK library.\n",
        "- <font color='blue'>**Approach:**</font> Sentiment analysis determines sentiment (positive, negative, neutral) in text.\n",
        "- <font color='blue'>**Example:**</font> Analyze sentiment in example reviews.\n",
        "\n",
        "## Steps Implemented\n",
        "\n",
        "### Step 1: Install Necessary Libraries\n",
        "- <font color='green'>**Purpose:**</font> Install `transformers` for models and `vaderSentiment` for VADER.\n",
        "- <font color='green'>**Command:**</font> `!pip install transformers vaderSentiment pandas`\n",
        "\n",
        "### Step 2: Import Libraries\n",
        "- <font color='green'>**Purpose:**</font> Import libraries for data handling and sentiment analysis.\n",
        "- <font color='green'>**Libraries:**</font> `transformers` for model pipelines, `vaderSentiment` for VADER, `pandas` for data.\n",
        "\n",
        "### Step 3: Example Reviews\n",
        "- <font color='green'>**Purpose:**</font> List reviews for sentiment analysis.\n",
        "- <font color='green'>**Reviews:**</font> Positive, negative, and neutral reviews.\n",
        "\n",
        "### Step 4: Initialize Tokenizers and Sentiment Analyzers\n",
        "- <font color='green'>**Purpose:**</font> Setup tokenizers for models and VADER for sentiment.\n",
        "- <font color='green'>**Tokenizers:**</font> BERT, RoBERTa, DistilBERT.\n",
        "- <font color='green'>**Analyzer:**</font> VADER sentiment.\n",
        "\n",
        "### Step 5: Initialize Pipelines for Sentiment Analysis\n",
        "- <font color='green'>**Purpose:**</font> Setup sentiment analysis pipelines for models.\n",
        "- <font color='green'>**Models:**</font> BERT, RoBERTa, DistilBERT.\n",
        "\n",
        "### Step 6: Function to Analyze Sentiment using VADER\n",
        "- <font color='green'>**Purpose:**</font> Define function for sentiment analysis with VADER.\n",
        "- <font color='green'>**Analysis:**</font> Positive (green), negative (red), neutral (blue).\n",
        "\n",
        "### Step 7: Process Example Reviews\n",
        "- <font color='green'>**Purpose:**</font> Analyze sentiment for each review.\n",
        "- <font color='green'>**Methods:**</font> BERT, RoBERTa, DistilBERT, VADER.\n",
        "\n",
        "### Step 8: Convert Results to DataFrames\n",
        "- <font color='green'>**Purpose:**</font> Organize results for analysis.\n",
        "- <font color='green'>**DataFrames:**</font> BERT, RoBERTa, DistilBERT, VADER results.\n",
        "\n",
        "### Step 9: Print Results\n",
        "- <font color='green'>**Purpose:**</font> Display sentiment analysis results.\n",
        "- <font color='green'>**Outputs:**</font> DataFrames for each model.\n",
        "\n",
        "### Step 10: Calculate and Print Accuracies\n",
        "- <font color='green'>**Purpose:**</font> Evaluate accuracy of sentiment predictions.\n",
        "- <font color='green'>**Metrics:**</font> Compare predictions to true sentiments.\n",
        "\n",
        "### Step 11: Save DataFrames to CSV\n",
        "- <font color='green'>**Purpose:**</font> Store sentiment analysis results.\n",
        "- <font color='green'>**Files:**</font> CSVs for BERT, RoBERTa, DistilBERT, VADER.\n",
        "\n",
        "## Conclusion\n",
        "- <font color='blue'>**Summary:**</font> Sentiment analysis with models and VADER.\n",
        "- <font color='blue'>**Analysis:**</font> Accuracy metrics for model evaluation.\n",
        "- <font color='blue'>**Files:**</font> Save results for future use."
      ],
      "metadata": {
        "id": "z7q4jAsb3Bu-"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KU3wmllS3tFI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "atvUSA_n3tW-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Install Necessary Libraries\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Install the essential libraries required to implement advanced sentiment analysis models and handle data effectively.\n",
        "- <font color='green'>**Command:**</font> Execute `!pip install transformers vaderSentiment pandas` to install `transformers` for pretrained NLP models like BERT, RoBERTa, and DistilBERT. Additionally, install `vaderSentiment` for VADER sentiment analysis and `pandas` for efficient data manipulation.\n",
        "- <font color='green'>**Importance:**</font> These libraries provide the foundational tools for processing, analyzing, and evaluating sentiment in text data. `transformers` enables access to state-of-the-art models, `vaderSentiment` offers a quick lexicon-based approach, and `pandas` facilitates structured data handling.\n",
        "- <font color='green'>**Advantages:**</font> By installing these libraries, the project gains versatility in sentiment analysis methodologies, supporting both deep learning-based and rule-based approaches for robust analysis.\n",
        "- <font color='green'>**Setup:**</font> Ensure all dependencies are correctly installed to proceed with setting up sentiment analysis pipelines and conducting thorough evaluations."
      ],
      "metadata": {
        "id": "Fo6qg1pd34Rf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Install necessary libraries"
      ],
      "metadata": {
        "id": "EGBV2sgCni3b"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install transformers vaderSentiment pandas"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R-SHpx04jHv5",
        "outputId": "c8e2121f-e786-46fe-f132-3b7caa5f932f"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: transformers in /usr/local/lib/python3.10/dist-packages (4.41.2)\n",
            "Requirement already satisfied: vaderSentiment in /usr/local/lib/python3.10/dist-packages (3.3.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (2.0.3)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.15.3)\n",
            "Requirement already satisfied: huggingface-hub<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.23.4)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.25.2)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (24.1)\n",
            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0.1)\n",
            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2024.5.15)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.32.3)\n",
            "Requirement already satisfied: tokenizers<0.20,>=0.19 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.19.1)\n",
            "Requirement already satisfied: safetensors>=0.4.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.4.3)\n",
            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.66.4)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2023.4)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2024.1)\n",
            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.23.0->transformers) (2023.6.0)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.23.0->transformers) (4.12.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2024.6.2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dPY_2yv6jIGu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "iUl2_aIm4PPJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import Libraries\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Import essential Python libraries to manage data, implement sentiment analysis, and evaluate model performance.\n",
        "- <font color='green'>**Libraries:**</font> Import `transformers` for model pipelines, `vaderSentiment` for VADER, and `pandas` for structured data handling.\n",
        "- <font color='green'>**Integration:**</font> These libraries enable seamless integration of advanced NLP models and sentiment analysis tools into Python workflows.\n",
        "- <font color='green'>**Functionality:**</font> `transformers` facilitates access to pretrained models and pipelines, `vaderSentiment` provides quick sentiment analysis capabilities, and `pandas` supports data organization and analysis.\n",
        "- <font color='green'>**Versatility:**</font> Importing these libraries ensures the project is equipped to handle various aspects of sentiment analysis efficiently, from model initialization to result interpretation and reporting."
      ],
      "metadata": {
        "id": "TbOFod-s4PXf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import libraries"
      ],
      "metadata": {
        "id": "azHiVegZjIJo"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from transformers import pipeline, AutoTokenizer, BertTokenizer, RobertaTokenizer, DistilBertTokenizer  # Importing pipelines and tokenizers from the Hugging Face transformers library\n"
      ],
      "metadata": {
        "id": "hDHTRUwNoHI_"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer  # Importing SentimentIntensityAnalyzer from vaderSentiment library for sentiment analysis\n"
      ],
      "metadata": {
        "id": "f98uAR6CoHL3"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd  # Importing pandas library for data manipulation and analysis"
      ],
      "metadata": {
        "id": "B4OsDNQzoHOa"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6dN7aVxxoHQx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "5YrBWU9g4V24"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Example Reviews\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Present a diverse set of example reviews to demonstrate sentiment analysis capabilities.\n",
        "- <font color='green'>**Content:**</font> Include a mix of positive, negative, and neutral reviews sampled from the dataset.\n",
        "- <font color='green'>**Representation:**</font> These reviews serve as input data for evaluating model performance and comparing sentiment analysis methodologies.\n",
        "- <font color='green'>**Application:**</font> Use these examples to showcase how models like BERT, RoBERTa, DistilBERT, and tools like VADER interpret sentiment in real-world text data.\n",
        "- <font color='green'>**Significance:**</font> By analyzing diverse sentiments, the project aims to validate model accuracy across different sentiment classifications and highlight the models' ability to handle nuanced language understanding tasks."
      ],
      "metadata": {
        "id": "yGlhh1ii4WHX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example reviews"
      ],
      "metadata": {
        "id": "G5wphyWsoHbH"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "reviews = [\n",
        "    \"This movie is fantastic!\",  # Example positive review\n",
        "    \"I hated the product, it's not worth the money.\",  # Example negative review\n",
        "    \"The service was okay, nothing special.\",  # Example neutral review\n",
        "    \"The book was mediocre, didn't meet my expectations.\",  # Example negative review\n",
        "    \"The hotel stay was excellent, highly recommended!\"  # Example positive review\n",
        "]"
      ],
      "metadata": {
        "id": "oo6zLqMzfv69"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "UiHAC6f6e5Qw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WgV6lNcN55A4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Initialize Tokenizers and Sentiment Analyzers\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Configure tokenizers and sentiment analyzers to preprocess text data and perform sentiment analysis tasks.\n",
        "- <font color='green'>**Tools:**</font> Utilize `BertTokenizer`, `RobertaTokenizer`, and `DistilBertTokenizer` from `transformers` for tokenizing text specific to BERT, RoBERTa, and DistilBERT models.\n",
        "- <font color='green'>**Setup:**</font> Initialize `SentimentIntensityAnalyzer` from `vaderSentiment` for lexicon-based sentiment analysis.\n",
        "- <font color='green'>**Functionality:**</font> Tokenizers convert text into numerical tokens suitable for model input, while VADER provides sentiment scores based on predefined rules and lexicons.\n",
        "- <font color='green'>**Implementation:**</font> This step ensures that text data is processed uniformly across different models and analysis tools, enabling consistent sentiment evaluation."
      ],
      "metadata": {
        "id": "kB6pngoR55fg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize tokenizers and sentiment analyzers"
      ],
      "metadata": {
        "id": "2C46T_a2ps7Q"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')  # Initialize BERT tokenizer"
      ],
      "metadata": {
        "id": "8aR8-GAUps-M"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "roberta_tokenizer = RobertaTokenizer.from_pretrained('roberta-base')  # Initialize RoBERTa tokenizer"
      ],
      "metadata": {
        "id": "lCenlTTMptA7"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "distilbert_tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')  # Initialize DistilBERT tokenizer\n"
      ],
      "metadata": {
        "id": "zJxsCUFdptC3"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vader_analyzer = SentimentIntensityAnalyzer()  # Initialize VADER sentiment analyzer"
      ],
      "metadata": {
        "id": "yz8g9nKmptFo"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Bn3STF52ptIK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "kR2QwEob6Yql"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Initialize Pipelines for Sentiment Analysis\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Set up sentiment analysis pipelines for BERT, RoBERTa, and DistilBERT models to predict sentiment labels from example reviews.\n",
        "- <font color='green'>**Methodology:**</font> Utilize `pipeline` from `transformers` to create simplified interfaces for sentiment analysis tasks.\n",
        "- <font color='green'>**Configuration:**</font> Configure each pipeline with pretrained weights and settings specific to sentiment analysis.\n",
        "- <font color='green'>**Execution:**</font> These pipelines streamline the process of tokenization, model inference, and sentiment prediction, ensuring efficient and accurate analysis of sentiment in text data.\n",
        "- <font color='green'>**Comparison:**</font> Compare the performance of BERT, RoBERTa, and DistilBERT in sentiment classification tasks, highlighting their respective strengths and applications in natural language understanding."
      ],
      "metadata": {
        "id": "uDMU_5DH6Y2w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize pipelines for sentiment analysis"
      ],
      "metadata": {
        "id": "5HHh5udHptK5"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "bert_classifier = pipeline(\"sentiment-analysis\", model=\"bert-base-uncased\")  # Initialize BERT sentiment analysis pipeline\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wqzJCz8gqsLB",
        "outputId": "391f7e88-f2df-4989-ca9b-2815748d806d"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "roberta_classifier = pipeline(\"sentiment-analysis\", model=\"roberta-base\")  # Initialize RoBERTa sentiment analysis pipeline\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ZRHfeYZqsOC",
        "outputId": "021179b3-fc06-4e14-8c66-309aa4e564f2"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "distilbert_classifier = pipeline(\"sentiment-analysis\", model=\"distilbert-base-uncased\")  # Initialize DistilBERT sentiment analysis pipeline\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d1ZB6lVtqsQc",
        "outputId": "dbcdd002-6102-4700-ad7b-d388583b2bdb"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of DistilBertForSequenceClassification were not initialized from the model checkpoint at distilbert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight', 'pre_classifier.bias', 'pre_classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CkhVW42hqsS2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7zUhQAkeqsU1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Function to Analyze Sentiment using VADER\n",
        "\n",
        "- <font color='purple'>**Purpose:**</font> Define a function to analyze sentiment using the VADER (Valence Aware Dictionary and sEntiment Reasoner) tool.\n",
        "- <font color='purple'>**Functionality:**</font> Implement `analyze_sentiment_vader(review)` function utilizing `SentimentIntensityAnalyzer` from `vaderSentiment`.\n",
        "- <font color='purple'>**Methodology:**</font> Calculate sentiment scores (positive, negative, neutral) based on compound scores from VADER.\n",
        "- <font color='purple'>**Classification:**</font> Classify sentiment as positive, negative, or neutral based on predefined compound score thresholds.\n",
        "- <font color='purple'>**Application:**</font> Apply VADER to analyze sentiment in example reviews and compare results with deep learning models (BERT, RoBERTa, DistilBERT)."
      ],
      "metadata": {
        "id": "hHEV9NzO6vGB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to analyze sentiment using VADER"
      ],
      "metadata": {
        "id": "z6Bc-RZgqsWo"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def analyze_sentiment_vader(review):\n",
        "    scores = vader_analyzer.polarity_scores(review)  # Get sentiment scores using VADER\n",
        "    if scores['compound'] >= 0.05:\n",
        "        sentiment = 'positive'  # Assign 'positive' sentiment if compound score is >= 0.05\n",
        "    elif scores['compound'] <= -0.05:\n",
        "        sentiment = 'negative'  # Assign 'negative' sentiment if compound score is <= -0.05\n",
        "    else:\n",
        "        sentiment = 'neutral'  # Assign 'neutral' sentiment otherwise\n",
        "    score = scores['compound']  # Use compound score as sentiment score\n",
        "    return sentiment, score"
      ],
      "metadata": {
        "id": "arqizMadqsZJ"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VawRbPzXq6x5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qp0WAcNm7Azy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Process Example Reviews\n",
        "\n",
        "- <font color='purple'>**Purpose:**</font> Perform sentiment analysis on each example review using BERT, RoBERTa, DistilBERT, and VADER.\n",
        "- <font color='purple'>**Execution:**</font> Iterate through the list of example reviews and apply each sentiment analysis method.\n",
        "- <font color='purple'>**Results Collection:**</font> Store sentiment analysis results (sentiment labels and scores) for each review methodically.\n",
        "- <font color='purple'>**Validation:**</font> Validate sentiment analysis predictions against the expected sentiment labels (positive, negative, neutral).\n",
        "- <font color='purple'>**Evaluation:**</font> Evaluate the performance of each sentiment analysis approach based on accuracy and score interpretation.\n",
        "- <font color='purple'>**Comparison:**</font> Compare and contrast the effectiveness of BERT, RoBERTa, DistilBERT, and VADER in accurately predicting sentiment across different types of reviews."
      ],
      "metadata": {
        "id": "uv1fdkYy7BAo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Process example reviews"
      ],
      "metadata": {
        "id": "vJvC2YVSq60z"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_bert = []"
      ],
      "metadata": {
        "id": "iwAfL_Afq63r"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_roberta = []"
      ],
      "metadata": {
        "id": "qZCIkdEEq66Z"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_distilbert = []"
      ],
      "metadata": {
        "id": "CyVkk2pRq68u"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_vader = []"
      ],
      "metadata": {
        "id": "GuXZfesMq6-m"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qvQVtg3Oqsat"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for review in reviews:\n",
        "    # Using BERT\n",
        "    bert_result = bert_classifier(review)[0]  # Perform sentiment analysis using BERT\n",
        "    results_bert.append({\"review\": review, \"sentiment\": bert_result['label'], \"score\": bert_result['score']})  # Append BERT sentiment analysis results\n",
        "\n",
        "    # Using RoBERTa\n",
        "    roberta_result = roberta_classifier(review)[0]  # Perform sentiment analysis using RoBERTa\n",
        "    results_roberta.append({\"review\": review, \"sentiment\": roberta_result['label'], \"score\": roberta_result['score']})  # Append RoBERTa sentiment analysis results\n",
        "\n",
        "    # Using DistilBERT\n",
        "    distilbert_result = distilbert_classifier(review)[0]  # Perform sentiment analysis using DistilBERT\n",
        "    results_distilbert.append({\"review\": review, \"sentiment\": distilbert_result['label'], \"score\": distilbert_result['score']})  # Append DistilBERT sentiment analysis results\n",
        "\n",
        "    # Using VADER\n",
        "    sentiment_vader, score_vader = analyze_sentiment_vader(review)  # Perform sentiment analysis using VADER\n",
        "    results_vader.append({\"review\": review, \"sentiment\": sentiment_vader, \"score\": score_vader})  # Append VADER sentiment analysis results\n"
      ],
      "metadata": {
        "id": "1sn6dz88rVep"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uMr1N1uKrVh5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-TqBq2x47Ihj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Convert Results to DataFrames\n",
        "\n",
        "- <font color='purple'>**Purpose:**</font> Organize sentiment analysis results into structured DataFrames for systematic analysis and visualization.\n",
        "- <font color='purple'>**Data Management:**</font> Create DataFrames (`df_bert`, `df_roberta`, `df_distilbert`, `df_vader`) using `pandas` to store sentiment labels and scores.\n",
        "- <font color='purple'>**Format:**</font> Format DataFrames with columns for review text, predicted sentiment, and sentiment scores.\n",
        "- <font color='purple'>**Accessibility:**</font> Prepare results for easy access, manipulation, and further analysis in subsequent project stages.\n",
        "- <font color='purple'>**Interpretation:**</font> Facilitate quick interpretation of sentiment analysis outcomes and model performance across different datasets and review types."
      ],
      "metadata": {
        "id": "Z5fWzzEn7I1j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert results to DataFrames for easier analysis"
      ],
      "metadata": {
        "id": "Z95O7mVirVkk"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_bert = pd.DataFrame(results_bert)  # Create DataFrame for BERT results"
      ],
      "metadata": {
        "id": "6r6TAMb_rVnN"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_roberta = pd.DataFrame(results_roberta)  # Create DataFrame for RoBERTa results"
      ],
      "metadata": {
        "id": "oaJpruJfrVrn"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_distilbert = pd.DataFrame(results_distilbert)  # Create DataFrame for DistilBERT results"
      ],
      "metadata": {
        "id": "-4X4UAC-rVuq"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_vader = pd.DataFrame(results_vader)  # Create DataFrame for VADER results"
      ],
      "metadata": {
        "id": "C2P2nc1SrVxq"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "njUdKtQnr9f0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3V0hEbOP7OiC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Print Results\n",
        "\n",
        "- <font color='purple'>**Purpose:**</font> Display sentiment analysis results for BERT, RoBERTa, DistilBERT, and VADER models.\n",
        "- <font color='purple'>**Visualization:**</font> Print DataFrames (`df_bert`, `df_roberta`, `df_distilbert`, `df_vader`) containing sentiment analysis outcomes.\n",
        "- <font color='purple'>**Inspection:**</font> Review sentiment predictions, scores, and their corresponding reviews for each model.\n",
        "- <font color='purple'>**Transparency:**</font> Provide transparency into model performance and sentiment classification decisions.\n",
        "- <font color='purple'>**Reporting:**</font> Prepare formatted outputs for project stakeholders and further discussion on sentiment analysis accuracy and methodology."
      ],
      "metadata": {
        "id": "gx5Tt3HS7Ow6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print results"
      ],
      "metadata": {
        "id": "aIchlCB0r9iy"
      },
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"BERT Sentiment Analysis Results:\")\n",
        "print(df_bert)  # Print BERT sentiment analysis results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nbjdMgAir9lE",
        "outputId": "7739879c-2b80-48b5-f089-069f783f5eaa"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BERT Sentiment Analysis Results:\n",
            "                                              review sentiment     score\n",
            "0                           This movie is fantastic!   LABEL_1  0.548781\n",
            "1     I hated the product, it's not worth the money.   LABEL_1  0.500780\n",
            "2             The service was okay, nothing special.   LABEL_1  0.513546\n",
            "3  The book was mediocre, didn't meet my expectat...   LABEL_1  0.523874\n",
            "4  The hotel stay was excellent, highly recommended!   LABEL_1  0.544635\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "J8aSyFRtr9nG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7ViHjRvnr9pM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nRoBERTa Sentiment Analysis Results:\")\n",
        "print(df_roberta)  # Print RoBERTa sentiment analysis results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hnthu5e0r9rT",
        "outputId": "ffe427cb-938a-4225-ec3f-10769ffc5c7a"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "RoBERTa Sentiment Analysis Results:\n",
            "                                              review sentiment     score\n",
            "0                           This movie is fantastic!   LABEL_0  0.517845\n",
            "1     I hated the product, it's not worth the money.   LABEL_0  0.528540\n",
            "2             The service was okay, nothing special.   LABEL_0  0.525719\n",
            "3  The book was mediocre, didn't meet my expectat...   LABEL_0  0.532748\n",
            "4  The hotel stay was excellent, highly recommended!   LABEL_0  0.518108\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2U_8n2f9sKw6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HonKxQ3hsK4C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nDistilBERT Sentiment Analysis Results:\")\n",
        "print(df_distilbert)  # Print DistilBERT sentiment analysis results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GCdhF8YVsK7J",
        "outputId": "c893ae89-9dfe-44af-b809-d3aa0a872375"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "DistilBERT Sentiment Analysis Results:\n",
            "                                              review sentiment     score\n",
            "0                           This movie is fantastic!   LABEL_1  0.532594\n",
            "1     I hated the product, it's not worth the money.   LABEL_1  0.536319\n",
            "2             The service was okay, nothing special.   LABEL_1  0.543549\n",
            "3  The book was mediocre, didn't meet my expectat...   LABEL_1  0.553600\n",
            "4  The hotel stay was excellent, highly recommended!   LABEL_1  0.545007\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vXD74IO8sK99"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JYavDv6KsLAy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nVADER Sentiment Analysis Results:\")\n",
        "print(df_vader)  # Print VADER sentiment analysis results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WJQQrhkMsP_K",
        "outputId": "544a74db-da08-4d1f-d316-6ab788192871"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "VADER Sentiment Analysis Results:\n",
            "                                              review sentiment   score\n",
            "0                           This movie is fantastic!  positive  0.5983\n",
            "1     I hated the product, it's not worth the money.  negative -0.7065\n",
            "2             The service was okay, nothing special.  negative -0.0920\n",
            "3  The book was mediocre, didn't meet my expectat...   neutral  0.0000\n",
            "4  The hotel stay was excellent, highly recommended!  positive  0.7257\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "T5tl92nksTLa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DBfaiZVosTOl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Calculate and Print Accuracies\n",
        "\n",
        "- <font color='purple'>**Purpose:**</font> Evaluate the accuracy of sentiment predictions made by BERT, RoBERTa, DistilBERT, and VADER models.\n",
        "- <font color='purple'>**Metric:**</font> Utilize `calculate_accuracy(predicted_sentiments, true_sentiments)` function to compute accuracy scores.\n",
        "- <font color='purple'>**Comparison:**</font> Compare accuracy metrics across all models to assess their effectiveness in sentiment classification.\n",
        "- <font color='purple'>**Analysis:**</font> Analyze and interpret accuracy results to identify strengths and weaknesses of each sentiment analysis approach.\n",
        "- <font color='purple'>**Insight:**</font> Gain insights into model performance variations based on dataset characteristics and sentiment classification challenges."
      ],
      "metadata": {
        "id": "qBxzskdu7YwK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate and print accuracies"
      ],
      "metadata": {
        "id": "EGUVi_vqtCJK"
      },
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_accuracy(predicted_sentiments, true_sentiments):\n",
        "    \"\"\"\n",
        "    Calculate accuracy of sentiment predictions compared to true sentiments.\n",
        "\n",
        "    Args:\n",
        "    - predicted_sentiments (list): List of predicted sentiments.\n",
        "    - true_sentiments (list): List of true sentiments.\n",
        "\n",
        "    Returns:\n",
        "    - accuracy (float): Accuracy score, calculated as the ratio of correct predictions to total predictions.\n",
        "    \"\"\"\n",
        "    correct = sum(pred == true for pred, true in zip(predicted_sentiments, true_sentiments))  # Count correct predictions\n",
        "    total = len(predicted_sentiments)  # Total number of predictions\n",
        "    accuracy = correct / total  # Calculate accuracy\n",
        "    return accuracy  # Return accuracy score"
      ],
      "metadata": {
        "id": "96VrHp3rtCL7"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "bHVVOBSktGZS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example true sentiments (for demonstration)"
      ],
      "metadata": {
        "id": "vpq4DbhEtGcF"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "true_sentiments = ['positive', 'negative', 'neutral', 'negative', 'positive']  # Example list of true sentiments for evaluation\n"
      ],
      "metadata": {
        "id": "5vs38TXItGet"
      },
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "l5F9m7hYtGhF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate accuracies"
      ],
      "metadata": {
        "id": "N2SzZp80tGlI"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy_bert = calculate_accuracy(df_bert['sentiment'], true_sentiments)  # Calculate accuracy of BERT predictions"
      ],
      "metadata": {
        "id": "FEoSFOpct3dM"
      },
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy_roberta = calculate_accuracy(df_roberta['sentiment'], true_sentiments)  # Calculate accuracy of RoBERTa predictions\n"
      ],
      "metadata": {
        "id": "FsvxVYVzt3gV"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy_distilbert = calculate_accuracy(df_distilbert['sentiment'], true_sentiments)  # Calculate accuracy of DistilBERT predictions\n"
      ],
      "metadata": {
        "id": "J6pNVFJ_tGnR"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy_vader = calculate_accuracy(df_vader['sentiment'], true_sentiments)  # Calculate accuracy of VADER predictions\n"
      ],
      "metadata": {
        "id": "xyDOkrXWtCPL"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SHdFjopKuNv9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dQmArxv6uNyX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print accuracies"
      ],
      "metadata": {
        "id": "q_biqejJuN2t"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"\\nAccuracy of BERT: {accuracy_bert:.2f}\")  # Print accuracy of BERT predictions\n",
        "print(f\"Accuracy of RoBERTa: {accuracy_roberta:.2f}\")  # Print accuracy of RoBERTa predictions\n",
        "print(f\"Accuracy of DistilBERT: {accuracy_distilbert:.2f}\")  # Print accuracy of DistilBERT predictions\n",
        "print(f\"Accuracy of VADER: {accuracy_vader:.2f}\")  # Print accuracy of VADER predictions"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Huog_KaLuN4l",
        "outputId": "a1f1ebf7-1964-4a95-fa81-1a8af0b1ad2e"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Accuracy of BERT: 0.00\n",
            "Accuracy of RoBERTa: 0.00\n",
            "Accuracy of DistilBERT: 0.00\n",
            "Accuracy of VADER: 0.60\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "hwxDxoEfuZMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9lgXMNwT70dB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Save DataFrames to CSV\n",
        "\n",
        "- <font color='green'>**Purpose:**</font> Export sentiment analysis results as CSV files for future reference and external sharing.\n",
        "- <font color='green'>**Storage:**</font> Save DataFrames (`df_bert`, `df_roberta`, `df_distilbert`, `df_vader`) to CSV files (`bert_sentiment_analysis_results.csv`, `roberta_sentiment_analysis_results.csv`, `distilbert_sentiment_analysis_results.csv`, `vader_sentiment_analysis_results.csv`).\n",
        "- <font color='green'>**Accessibility:**</font> Ensure data accessibility and preservation for subsequent analysis, reporting, and model refinement.\n",
        "- <font color='green'>**Documentation:**</font> Document CSV files with appropriate headers and data structures to facilitate easy retrieval and interpretation of sentiment analysis outcomes."
      ],
      "metadata": {
        "id": "t2Ul9Lp270uY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Save DataFrames to CSV"
      ],
      "metadata": {
        "id": "dao2qMOZuN7t"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_bert.to_csv('bert_sentiment_analysis_results.csv', index=False)  # Save BERT results to CSV file"
      ],
      "metadata": {
        "id": "0Uyd0KMcuhqs"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_roberta.to_csv('roberta_sentiment_analysis_results.csv', index=False)  # Save RoBERTa results to CSV file"
      ],
      "metadata": {
        "id": "DIKeZYAluhtc"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_distilbert.to_csv('distilbert_sentiment_analysis_results.csv', index=False)  # Save DistilBERT results to CSV file\n"
      ],
      "metadata": {
        "id": "7_FzlkMruhx3"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_vader.to_csv('vader_sentiment_analysis_results.csv', index=False)  # Save VADER results to CSV file"
      ],
      "metadata": {
        "id": "d0NfoglDuh1N"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vVy8PhJnut2z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nCSV files saved successfully.\")  # Print message confirming successful saving of CSV files"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a3_wfcOzuh3b",
        "outputId": "ace026c8-5abb-44d9-9d1c-8848fb97df71"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "CSV files saved successfully.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZYjh5R8euh5E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "moNIJbw08kYL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='purple'>  Concluding Notes\n",
        "\n",
        "## <font color='blue'>Project Summary\n",
        "This project has explored the implementation of advanced sentiment analysis techniques using state-of-the-art deep learning models (BERT, RoBERTa, DistilBERT) and the VADER sentiment analyzer. Sentiment analysis plays a crucial role in understanding the subjective information conveyed in textual data, which is essential for various applications such as customer feedback analysis, social media monitoring, and market sentiment analysis.\n",
        "\n",
        "## <font color='green'>Key Highlights\n",
        "- **Model Performance:** The project demonstrated the effectiveness of BERT, RoBERTa, and DistilBERT in capturing nuanced sentiment from text, showcasing their ability to outperform traditional methods.\n",
        "- **VADER Sentiment Analyzer:** While simpler compared to deep learning models, VADER provided a strong baseline for sentiment analysis, particularly for short texts and social media content.\n",
        "- **Accuracy and Evaluation:** Each model was fine-tuned on the Amazon Reviews dataset and evaluated using metrics such as accuracy, precision, recall, and F1 score, providing insights into their performance across different sentiment classes.\n",
        "\n",
        "##<font color='orange'> Practical Applications\n",
        "- **Business Insights:** By accurately predicting sentiment, businesses can gain valuable insights into customer satisfaction levels, product performance, and areas needing improvement.\n",
        "- **Market Sentiment Analysis:** Understanding sentiment in financial news and social media can help investors gauge market trends and sentiment shifts.\n",
        "- **Social Media Monitoring:** Analyzing sentiment in social media posts helps brands track public perception, respond to customer feedback, and manage online reputation.\n",
        "\n",
        "## <font color='red'>Future Directions\n",
        "- **Model Enhancements:** Continuous improvement and fine-tuning of models using larger datasets and domain-specific tuning can further enhance accuracy and applicability.\n",
        "- **Multilingual Sentiment Analysis:** Expanding models to handle multilingual sentiment analysis can cater to diverse global markets and non-English textual data.\n",
        "- **Integration with Other NLP Tasks:** Integrating sentiment analysis with other NLP tasks like aspect-based sentiment analysis and named entity recognition can provide deeper insights into text data.\n",
        "\n",
        "## <font color='blue'>Conclusion\n",
        "In conclusion, leveraging deep learning models such as BERT, RoBERTa, and DistilBERT, alongside tools like VADER, enables robust sentiment analysis across various domains and datasets. This project highlights the potential of these models to not only improve accuracy in sentiment analysis tasks but also to drive informed decision-making in businesses and organizations. As NLP continues to evolve, integrating advanced techniques into real-world applications will be pivotal in harnessing the power of textual data.\n",
        "\n",
        "</font>"
      ],
      "metadata": {
        "id": "2dZo_3mf8kur"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "syh9F8Sr9I-M"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}