Merge branch 'main' of https://github.com/Deathshot78/ReviewSense

.gitattributes

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
@@ -35,3 +36,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
+=======
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+>>>>>>> e6de3c4338f79386345fa6e4bba5b0666ad808da

notebooks/reviewsense.ipynb

@@ -0,0 +1,1001 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1754f3bb",
+   "metadata": {},
+   "source": [
+    "# 🛍️ ReviewSense: Product Review Analysis Engine\n",
+    "\n",
+    "> *ReviewSense is a comprehensive, end-to-end Natural Language Processing application built to extract deep, actionable insights from unstructured product reviews.*  \n",
+    "Where a simple star rating only tells part of the story, ReviewSense dives into the text to uncover what customers are saying, why they're saying it, and how they feel about specific product features.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00d383d6",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d48ba17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pytorch_lightning as pl\n",
+    "from torch.utils.data import DataLoader, Dataset\n",
+    "from transformers import AutoTokenizer\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import torch\n",
+    "import os\n",
+    "import numpy as np\n",
+    "from sklearn.model_selection import train_test_split, ParameterGrid, StratifiedKFold\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.naive_bayes import MultinomialNB\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm.notebook import tqdm\n",
+    "from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping\n",
+    "from pytorch_lightning.loggers import TensorBoardLogger\n",
+    "from transformers import T5ForConditionalGeneration, T5Tokenizer\n",
+    "from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup, AutoConfig\n",
+    "from torch.optim import AdamW\n",
+    "import torch\n",
+    "from torchmetrics.functional import accuracy\n",
+    "from transformers import T5ForConditionalGeneration, T5Tokenizer, AutoTokenizer, pipeline\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8263bc02",
+   "metadata": {},
+   "source": [
+    "## Prepare the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5f8dcda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def explore_and_preprocess_reviews(\n",
+    "    train_path='data/train.csv', \n",
+    "    test_path='data/test.csv',\n",
+    "    output_dir='data'\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Loads the Amazon Sentiment Analysis dataset (https://www.kaggle.com/datasets/kritanjalijain/amazon-reviews)\n",
+    "    (you need to extract the train/test splits from the zip file in the data folder),\n",
+    "    performs basic EDA, and preprocesses it for model training.\n",
+    "\n",
+    "    Args:\n",
+    "        train_path (str): Path to the training CSV file.\n",
+    "        test_path (str): Path to the testing CSV file.\n",
+    "        output_dir (str): Directory to save the processed file.\n",
+    "    \"\"\"\n",
+    "    # --- 1. Load Data ---\n",
+    "    # This dataset typically comes without headers. We'll assign them.\n",
+    "    # Column 1: Sentiment (1 = Negative, 2 = Positive)\n",
+    "    # Column 2: Title\n",
+    "    # Column 3: Review Text\n",
+    "    print(f\"Loading data from '{train_path}' and '{test_path}'...\")\n",
+    "    try:\n",
+    "        col_names = ['sentiment_orig', 'title', 'review']\n",
+    "        train_df = pd.read_csv(train_path, header=None, names=col_names)\n",
+    "        test_df = pd.read_csv(test_path, header=None, names=col_names)\n",
+    "        \n",
+    "        # Combine for unified EDA and preprocessing\n",
+    "        df = pd.concat([train_df, test_df], ignore_index=True)\n",
+    "\n",
+    "    except FileNotFoundError:\n",
+    "        print(f\"\\nERROR: Make sure '{train_path}' and '{test_path}' are in the specified directory.\")\n",
+    "        print(\"This script is designed for the 'Amazon Reviews for Sentiment Analysis' dataset from Kaggle.\")\n",
+    "        return\n",
+    "\n",
+    "    df.dropna(inplace=True)\n",
+    "\n",
+    "    # --- 2. Preprocessing ---\n",
+    "    print(\"\\n--- Preprocessing Data for Sentiment Analysis ---\")\n",
+    "\n",
+    "    # a) Create new sentiment labels (0 = Negative, 1 = Positive)\n",
+    "    # This dataset is binary, not three-class like the previous one.\n",
+    "    df['sentiment'] = df['sentiment_orig'].apply(lambda x: 0 if x == 1 else 1)\n",
+    "\n",
+    "    # b) Combine title and review body\n",
+    "    df['full_text'] = df['title'].astype(str) + \". \" + df['review'].astype(str)\n",
+    "\n",
+    "    # c) Select and rename columns\n",
+    "    processed_df = df[['full_text', 'sentiment']].copy()\n",
+    "\n",
+    "    # --- 4. Save Processed Data ---\n",
+    "    os.makedirs(output_dir, exist_ok=True)\n",
+    "    output_path = os.path.join(output_dir, 'reviews_processed.csv')\n",
+    "    processed_df.to_csv(output_path, index=False)\n",
+    "    print(f\"\\nSaved {len(processed_df)} processed reviews to '{output_path}'\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60ab838c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#--- Preprocess the Reviews Dataset ---\n",
+    "print(\"\\n--- Preprocessing started ---\")\n",
+    "explore_and_preprocess_reviews()\n",
+    "print(\"\\n--- Preprocessing finished ---\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c381d73",
+   "metadata": {},
+   "source": [
+    "## Define a base model (Multinomial Naive Bayes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b3cd2b5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train_baseline_sentiment_model(data_path='data/reviews_processed.csv', grid_search=True, nb__alpha=0.1, tfidf__max_df=0.75, tfidf__ngram_range=(1, 2), sample_size: int = 50000):\n",
+    "    \"\"\"\n",
+    "    Trains and evaluates a Multinomial Naive Bayes model for sentiment analysis.\n",
+    "    Can optionally perform a grid search.\n",
+    "\n",
+    "    Args:\n",
+    "        data_path (str): Path to the processed reviews CSV file.\n",
+    "        grid_search (bool): If True, performs a grid search.\n",
+    "        nb__alpha (float): Alpha for MultinomialNB.\n",
+    "        tfidf__max_df (float): max_df for TfidfVectorizer.\n",
+    "        tfidf__ngram_range (tuple): ngram_range for TfidfVectorizer.\n",
+    "        sample_size (int, optional): Number of reviews to use. If None, uses all.\n",
+    "    \"\"\"\n",
+    "    # --- 1. Load Data ---\n",
+    "    print(f\"Loading data from '{data_path}'...\")\n",
+    "    if not os.path.exists(data_path):\n",
+    "        print(f\"\\nERROR: '{data_path}' not found. Please run the EDA script first!\")\n",
+    "        return\n",
+    "        \n",
+    "    df = pd.read_csv(data_path)\n",
+    "    df.dropna(inplace=True)\n",
+    "\n",
+    "    # --- 2. Sample Data ---\n",
+    "    if sample_size:\n",
+    "        print(f\"Using a sample of {sample_size} reviews for training the baseline model.\")\n",
+    "        df = df.sample(n=sample_size, random_state=42)\n",
+    "\n",
+    "    # --- 3. Train-Test Split ---\n",
+    "    print(\"Splitting data into training and testing sets...\")\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(\n",
+    "        df['full_text'],\n",
+    "        df['sentiment'],\n",
+    "        test_size=0.2,\n",
+    "        random_state=42,\n",
+    "        stratify=df['sentiment']\n",
+    "    )\n",
+    "\n",
+    "    # --- 4. Create a Pipeline ---\n",
+    "    pipeline = Pipeline([\n",
+    "        ('tfidf', TfidfVectorizer(stop_words='english')),\n",
+    "        ('nb', MultinomialNB()),\n",
+    "    ])\n",
+    "\n",
+    "    best_params = None\n",
+    "\n",
+    "    if grid_search:\n",
+    "        # --- 5a. Perform Grid Search ---\n",
+    "        print(\"Performing Grid Search to find the best hyperparameters...\")\n",
+    "        parameters = {\n",
+    "            'tfidf__ngram_range': [(1, 1), (1, 2)],\n",
+    "            'tfidf__max_df': [0.5, 0.75, 1.0],\n",
+    "            'nb__alpha': [0.1, 0.5, 1.0],\n",
+    "        }\n",
+    "        param_grid = list(ParameterGrid(parameters))\n",
+    "        best_score = -1\n",
+    "\n",
+    "        for params in tqdm(param_grid, desc=\"Grid Search Progress\"):\n",
+    "            pipeline.set_params(**params)\n",
+    "            pipeline.fit(X_train, y_train)\n",
+    "            score = pipeline.score(X_test, y_test)\n",
+    "            if score > best_score:\n",
+    "                best_score = score\n",
+    "                best_params = params\n",
+    "        \n",
+    "        print(f\"\\nBest score on test set: {best_score:.4f}\")\n",
+    "        print(\"Best parameters found:\")\n",
+    "        print(best_params)\n",
+    "\n",
+    "    else:\n",
+    "        # --- 5b. Use provided hyperparameters ---\n",
+    "        print(\"Skipping grid search and using provided hyperparameters...\")\n",
+    "        best_params = {\n",
+    "            'nb__alpha': nb__alpha,\n",
+    "            'tfidf__max_df': tfidf__max_df,\n",
+    "            'tfidf__ngram_range': tfidf__ngram_range\n",
+    "        }\n",
+    "\n",
+    "    # --- 6. Train the Final Model ---\n",
+    "    print(\"\\nTraining final model...\")\n",
+    "    best_model = pipeline.set_params(**best_params)\n",
+    "    best_model.fit(X_train, y_train)\n",
+    "    print(\"Model training complete.\")\n",
+    "\n",
+    "    # --- 7. Evaluate the Best Model ---\n",
+    "    print(\"\\n--- Model Evaluation ---\")\n",
+    "    y_pred = best_model.predict(X_test)\n",
+    "    \n",
+    "    accuracy = accuracy_score(y_test, y_pred)\n",
+    "    target_names = ['Negative', 'Positive']\n",
+    "    \n",
+    "    print(f\"Accuracy: {accuracy:.4f}\")\n",
+    "    print(\"\\nClassification Report:\")\n",
+    "    print(classification_report(y_test, y_pred, target_names=target_names))\n",
+    "    \n",
+    "    print(\"Confusion Matrix:\")\n",
+    "    cm = confusion_matrix(y_test, y_pred)\n",
+    "    plt.figure(figsize=(8, 6))\n",
+    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Greens', \n",
+    "                xticklabels=target_names, yticklabels=target_names)\n",
+    "    plt.title('Confusion Matrix for Naive Bayes on Amazon Reviews')\n",
+    "    plt.xlabel('Predicted Label')\n",
+    "    plt.ylabel('True Label')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "093e6ae9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#--- Train the base model ---\n",
+    "train_baseline_sentiment_model(sample_size=150000, grid_search=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71f5e4ba",
+   "metadata": {},
+   "source": [
+    "## Define the dataset and lightning DataModule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c977e0f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ReviewDataset(Dataset):\n",
+    "    \"\"\"\n",
+    "    Custom PyTorch Dataset for Amazon Reviews.\n",
+    "\n",
+    "    This class takes a pandas DataFrame of review data, a tokenizer, and a max\n",
+    "    token length, and prepares it for use in a PyTorch model. It handles the\n",
+    "    tokenization of the text and the formatting of the labels for each item.\n",
+    "\n",
+    "    Attributes:\n",
+    "        tokenizer: The Hugging Face tokenizer to use for processing text.\n",
+    "        data (pd.DataFrame): The DataFrame containing the review data.\n",
+    "        max_token_len (int): The maximum sequence length for the tokenizer.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, data: pd.DataFrame, tokenizer, max_token_len: int):\n",
+    "        \"\"\"\n",
+    "        Initializes the ReviewDataset.\n",
+    "\n",
+    "        Args:\n",
+    "            data (pd.DataFrame): The input DataFrame containing 'full_text' and\n",
+    "                                 'sentiment' columns.\n",
+    "            tokenizer: The pre-trained tokenizer instance.\n",
+    "            max_token_len (int): The maximum length for tokenized sequences.\n",
+    "        \"\"\"\n",
+    "        self.tokenizer = tokenizer\n",
+    "        self.data = data\n",
+    "        self.max_token_len = max_token_len\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        \"\"\"\n",
+    "        Returns the total number of samples in the dataset.\n",
+    "        \"\"\"\n",
+    "        return len(self.data)\n",
+    "\n",
+    "    def __getitem__(self, index: int):\n",
+    "        \"\"\"\n",
+    "        Retrieves one sample from the dataset at the specified index.\n",
+    "\n",
+    "        This method handles the tokenization of a single review text, including\n",
+    "        padding and truncation, and formats the output into a dictionary of\n",
+    "        tensors ready for the model.\n",
+    "\n",
+    "        Args:\n",
+    "            index (int): The index of the data sample to retrieve.\n",
+    "\n",
+    "        Returns:\n",
+    "            dict: A dictionary containing the tokenized inputs and the label,\n",
+    "                  with the following keys:\n",
+    "                  - 'input_ids': The token IDs of the review text.\n",
+    "                  - 'attention_mask': The attention mask for the review text.\n",
+    "                  - 'labels': The sentiment label as a tensor.\n",
+    "        \"\"\"\n",
+    "        data_row = self.data.iloc[index]\n",
+    "        text = str(data_row.full_text)\n",
+    "        labels = data_row.sentiment\n",
+    "\n",
+    "        encoding = self.tokenizer.encode_plus(\n",
+    "            text,\n",
+    "            add_special_tokens=True,\n",
+    "            max_length=self.max_token_len,\n",
+    "            return_token_type_ids=False,\n",
+    "            padding=\"max_length\",\n",
+    "            truncation=True,\n",
+    "            return_attention_mask=True,\n",
+    "            return_tensors='pt',\n",
+    "        )\n",
+    "\n",
+    "        return dict(\n",
+    "            input_ids=encoding[\"input_ids\"].flatten(),\n",
+    "            attention_mask=encoding[\"attention_mask\"].flatten(),\n",
+    "            labels=torch.tensor(labels, dtype=torch.long)\n",
+    "        )\n",
+    "\n",
+    "class ReviewDataModule(pl.LightningDataModule):\n",
+    "    \"\"\"\n",
+    "    PyTorch Lightning DataModule to handle the Amazon Reviews dataset.\n",
+    "\n",
+    "    This class encapsulates all the steps needed to process the data:\n",
+    "    loading, splitting, and creating PyTorch DataLoaders for training,\n",
+    "    validation, and testing. It allows for using a smaller random sample of the\n",
+    "    full dataset for faster experimentation.\n",
+    "\n",
+    "    Attributes:\n",
+    "        data_path (str): Path to the processed CSV file.\n",
+    "        batch_size (int): The size of each data batch.\n",
+    "        max_token_len (int): The maximum sequence length for the tokenizer.\n",
+    "        tokenizer: The Hugging Face tokenizer instance.\n",
+    "        num_workers (int): The number of CPU cores to use for data loading.\n",
+    "        sample_size (int, optional): The number of samples to use. If None,\n",
+    "                                     the full dataset is used.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, data_path: str, batch_size: int = 16, max_token_len: int = 256, model_name='distilbert-base-uncased', num_workers: int = 0, sample_size: int = None):\n",
+    "        \"\"\"\n",
+    "        Initializes the ReviewDataModule.\n",
+    "\n",
+    "        Args:\n",
+    "            data_path (str): The path to the processed CSV data file.\n",
+    "            batch_size (int): The number of samples per batch.\n",
+    "            max_token_len (int): Maximum length of tokenized sequences.\n",
+    "            model_name (str): The name of the pre-trained model to use for the tokenizer.\n",
+    "            num_workers (int): Number of subprocesses to use for data loading.\n",
+    "            sample_size (int, optional): If specified, a random sample of this\n",
+    "                                         size will be used from the dataset.\n",
+    "                                         Defaults to None, which uses the full dataset.\n",
+    "        \"\"\"\n",
+    "        super().__init__()\n",
+    "        self.data_path = data_path\n",
+    "        self.batch_size = batch_size\n",
+    "        self.max_token_len = max_token_len\n",
+    "        self.tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "        self.num_workers = num_workers\n",
+    "        self.sample_size = sample_size\n",
+    "        self.train_df = None\n",
+    "        self.val_df = None\n",
+    "        self.test_df = None\n",
+    "\n",
+    "    def setup(self, stage=None):\n",
+    "        \"\"\"\n",
+    "        Loads and splits the data for training, validation, and testing.\n",
+    "\n",
+    "        This method is called by PyTorch Lightning. It reads the CSV, handles\n",
+    "        missing values, optionally takes a random sample, and performs a\n",
+    "        stratified train-validation-test split. The indices of the resulting\n",
+    "        DataFrames are reset to prevent potential KeyErrors during data loading.\n",
+    "        \"\"\"\n",
+    "        df = pd.read_csv(self.data_path)\n",
+    "        df.dropna(inplace=True)\n",
+    "\n",
+    "        # If a sample size is provided, sample the dataframe\n",
+    "        if self.sample_size:\n",
+    "            print(f\"Using a sample of {self.sample_size} reviews.\")\n",
+    "            df = df.sample(n=self.sample_size, random_state=42)\n",
+    "\n",
+    "        # Stratified split to maintain label distribution\n",
+    "        train_val_df, self.test_df = train_test_split(df, test_size=0.1, random_state=42, stratify=df.sentiment)\n",
+    "        self.train_df, self.val_df = train_test_split(train_val_df, test_size=0.1, random_state=42, stratify=train_val_df.sentiment)\n",
+    "\n",
+    "        # Reset indices to prevent KeyErrors\n",
+    "        self.train_df = self.train_df.reset_index(drop=True)\n",
+    "        self.val_df = self.val_df.reset_index(drop=True)\n",
+    "        self.test_df = self.test_df.reset_index(drop=True)\n",
+    "\n",
+    "        print(f\"Size of training set: {len(self.train_df)}\")\n",
+    "        print(f\"Size of validation set: {len(self.val_df)}\")\n",
+    "        print(f\"Size of test set: {len(self.test_df)}\")\n",
+    "\n",
+    "    def train_dataloader(self):\n",
+    "        \"\"\"Returns the DataLoader for the training set.\"\"\"\n",
+    "        return DataLoader(\n",
+    "            ReviewDataset(self.train_df, self.tokenizer, self.max_token_len),\n",
+    "            batch_size=self.batch_size,\n",
+    "            shuffle=True,\n",
+    "            num_workers=self.num_workers\n",
+    "        )\n",
+    "\n",
+    "    def val_dataloader(self):\n",
+    "        \"\"\"Returns the DataLoader for the validation set.\"\"\"\n",
+    "        return DataLoader(\n",
+    "            ReviewDataset(self.val_df, self.tokenizer, self.max_token__len),\n",
+    "            batch_size=self.batch_size,\n",
+    "            num_workers=self.num_workers\n",
+    "        )\n",
+    "\n",
+    "    def test_dataloader(self):\n",
+    "        \"\"\"Returns the DataLoader for the test set.\"\"\"\n",
+    "        return DataLoader(\n",
+    "            ReviewDataset(self.test_df, self.tokenizer, self.max_token_len),\n",
+    "            batch_size=self.batch_size,\n",
+    "            num_workers=self.num_workers\n",
+    "        )\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "985ac47b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- Configuration ---\n",
+    "data_path = \"data/reviews_processed.csv\"\n",
+    "BATCH_SIZE = 64\n",
+    "MAX_TOKEN_LEN = 256\n",
+    "\n",
+    "print(\"Initializing ReviewDataModule...\")\n",
+    "review_datamodule = ReviewDataModule(\n",
+    "    data_path=data_path,\n",
+    "    batch_size=BATCH_SIZE,\n",
+    "    max_token_len=MAX_TOKEN_LEN,\n",
+    "    model_name='distilbert-base-uncased',\n",
+    "    sample_size=100000 # Pass the sample size to the datamodule\n",
+    ")\n",
+    "review_datamodule.setup()\n",
+    "\n",
+    "# Fetch one batch from the training dataloader to inspect its contents\n",
+    "print(\"\\n--- Fetching one batch from the training dataloader ---\")\n",
+    "train_batch = next(iter(review_datamodule.train_dataloader()))\n",
+    "\n",
+    "print(\"\\n--- Example Batch ---\")\n",
+    "print(f\"Input IDs shape: {train_batch['input_ids'].shape}\")\n",
+    "print(f\"Attention Mask shape: {train_batch['attention_mask'].shape}\")\n",
+    "print(f\"Labels: {train_batch['labels']}\")\n",
+    "print(f\"Labels shape: {train_batch['labels'].shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c7781f4",
+   "metadata": {},
+   "source": [
+    "## FineTune DistilBert"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d046b940",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SentimentClassifier(pl.LightningModule):\n",
+    "    \"\"\"\n",
+    "    PyTorch Lightning module for the sentiment classification model.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, model_name='distilbert-base-uncased', n_classes=2, learning_rate=2e-5, n_warmup_steps=0, n_training_steps=0, dropout_prob=0.2): # Added dropout\n",
+    "        super().__init__()\n",
+    "        self.save_hyperparameters()\n",
+    "\n",
+    "        # Configure dropout\n",
+    "        config = AutoConfig.from_pretrained(model_name)\n",
+    "        config.hidden_dropout_prob = dropout_prob\n",
+    "        config.attention_probs_dropout_prob = dropout_prob\n",
+    "        config.num_labels = n_classes\n",
+    "\n",
+    "        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, config=config)\n",
+    "\n",
+    "    def forward(self, input_ids, attention_mask, labels=None):\n",
+    "        return self.model(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask,\n",
+    "            labels=labels\n",
+    "        )\n",
+    "\n",
+    "    def training_step(self, batch, batch_idx):\n",
+    "        output = self.forward(**batch)\n",
+    "        self.log(\"train_loss\", output.loss, prog_bar=True, logger=True)\n",
+    "        return output.loss\n",
+    "\n",
+    "    def validation_step(self, batch, batch_idx):\n",
+    "        output = self.forward(**batch)\n",
+    "        preds = torch.argmax(output.logits, dim=1)\n",
+    "        val_acc = accuracy(preds, batch['labels'], task='binary')\n",
+    "        self.log(\"val_loss\", output.loss, prog_bar=True, logger=True)\n",
+    "        self.log(\"val_accuracy\", val_acc, prog_bar=True, logger=True)\n",
+    "        return output.loss\n",
+    "\n",
+    "    def test_step(self, batch, batch_idx):\n",
+    "        output = self.forward(**batch)\n",
+    "        preds = torch.argmax(output.logits, dim=1)\n",
+    "        test_acc = accuracy(preds, batch['labels'], task='binary')\n",
+    "        self.log(\"test_accuracy\", test_acc)\n",
+    "        return test_acc\n",
+    "\n",
+    "    def predict_step(self, batch, batch_idx, dataloader_idx=0):\n",
+    "        output = self.forward(input_ids=batch['input_ids'], attention_mask=batch['attention_mask'])\n",
+    "        return torch.argmax(output.logits, dim=1)\n",
+    "\n",
+    "    def configure_optimizers(self):\n",
+    "        optimizer = AdamW(self.parameters(), lr=self.hparams.learning_rate, weight_decay=0.01)\n",
+    "        scheduler = get_linear_schedule_with_warmup(\n",
+    "            optimizer,\n",
+    "            num_warmup_steps=self.hparams.n_warmup_steps,\n",
+    "            num_training_steps=self.hparams.n_training_steps\n",
+    "        )\n",
+    "        return dict(optimizer=optimizer, lr_scheduler=dict(scheduler=scheduler, interval='step'))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b3a3708d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train_sentiment_model(data_path='data/reviews_processed.csv', model_name='distilbert-base-uncased', n_epochs=5, sample_size: int = None):\n",
+    "    \"\"\"\n",
+    "    Main function to train the sentiment analysis model on the Amazon Reviews dataset.\n",
+    "\n",
+    "    Args:\n",
+    "        data_path (str): Path to the processed data file.\n",
+    "        model_name (str): Name of the transformer model to use.\n",
+    "        n_epochs (int): Maximum number of epochs for training.\n",
+    "        sample_size (int, optional): The number of reviews to use for training.\n",
+    "                                     If None, the full dataset is used.\n",
+    "    \"\"\"\n",
+    "    # --- 1. Hyperparameters ---\n",
+    "    BATCH_SIZE = 64\n",
+    "    MAX_TOKEN_LEN = 256\n",
+    "    LEARNING_RATE = 2e-5\n",
+    "    N_CLASSES = 2  # Negative, Positive\n",
+    "\n",
+    "    # --- 2. Initialize DataModule ---\n",
+    "    print(\"Initializing ReviewDataModule...\")\n",
+    "    review_datamodule = ReviewDataModule(\n",
+    "        data_path=data_path,\n",
+    "        batch_size=BATCH_SIZE,\n",
+    "        max_token_len=MAX_TOKEN_LEN,\n",
+    "        model_name=model_name,\n",
+    "        sample_size=sample_size # Pass the sample size to the datamodule\n",
+    "    )\n",
+    "    review_datamodule.setup()\n",
+    "\n",
+    "    n_training_steps = len(review_datamodule.train_dataloader()) * n_epochs\n",
+    "    n_warmup_steps = int(n_training_steps * 0.1)\n",
+    "\n",
+    "    # --- 3. Initialize Model ---\n",
+    "    print(\"Initializing SentimentClassifier model...\")\n",
+    "    model = SentimentClassifier(\n",
+    "        model_name=model_name,\n",
+    "        n_classes=N_CLASSES,\n",
+    "        learning_rate=LEARNING_RATE,\n",
+    "        n_warmup_steps=n_warmup_steps,\n",
+    "        n_training_steps=n_training_steps\n",
+    "    )\n",
+    "\n",
+    "    # --- 4. Configure Training Callbacks ---\n",
+    "    checkpoint_callback = ModelCheckpoint(\n",
+    "        dirpath=\"checkpoints\",\n",
+    "        filename=\"sentiment-binary-best-checkpoint\",\n",
+    "        save_top_k=1,\n",
+    "        verbose=True,\n",
+    "        monitor=\"val_loss\",\n",
+    "        mode=\"min\"\n",
+    "    )\n",
+    "    logger = TensorBoardLogger(\"lightning_logs\", name=\"sentiment-classifier-binary\")\n",
+    "    early_stopping_callback = EarlyStopping(monitor='val_loss', patience=2)\n",
+    "\n",
+    "    # --- 5. Initialize Trainer ---\n",
+    "    print(\"Initializing PyTorch Lightning Trainer...\")\n",
+    "    trainer = pl.Trainer(\n",
+    "        logger=logger,\n",
+    "        callbacks=[checkpoint_callback, early_stopping_callback],\n",
+    "        max_epochs=n_epochs,\n",
+    "        accelerator='gpu' if torch.cuda.is_available() else 'cpu',\n",
+    "        devices=1,\n",
+    "    )\n",
+    "\n",
+    "    # --- 6. Start Training ---\n",
+    "    print(f\"Starting training with {model_name} for up to {n_epochs} epochs...\")\n",
+    "    trainer.fit(model, review_datamodule)\n",
+    "\n",
+    "    # --- 7. Evaluate on Test Set and Generate Confusion Matrix ---\n",
+    "    print(\"\\nTraining complete. Evaluating on the test set...\")\n",
+    "    trainer.test(model, datamodule=review_datamodule)\n",
+    "\n",
+    "    predictions = trainer.predict(model, datamodule=review_datamodule)\n",
+    "    if predictions:\n",
+    "        all_preds = torch.cat(predictions).cpu().numpy()\n",
+    "        true_labels = review_datamodule.test_df.sentiment.to_numpy()\n",
+    "        target_names = ['Negative', 'Positive'] # Updated labels\n",
+    "\n",
+    "        cm = confusion_matrix(true_labels, all_preds)\n",
+    "        plt.figure(figsize=(8, 6))\n",
+    "        sns.heatmap(cm, annot=True, fmt='d', cmap='YlGnBu',\n",
+    "                    xticklabels=target_names, yticklabels=target_names)\n",
+    "        plt.title('Confusion Matrix for Sentiment Analysis')\n",
+    "        plt.xlabel('Predicted Label')\n",
+    "        plt.ylabel('True Label')\n",
+    "        plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3dae58e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#--- Train DistilBert ---\n",
+    "train_sentiment_model(data_path=data_path, sample_size=100000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddbc7315",
+   "metadata": {},
+   "source": [
+    "## Define the models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85bd352b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ReviewSummarizer:\n",
+    "    \"\"\"\n",
+    "    A class to handle the summarization of product reviews using a pre-trained T5 model.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, model_name='t5-small'):\n",
+    "        \"\"\"\n",
+    "        Initializes the summarizer with a pre-trained T5 model and tokenizer.\n",
+    "\n",
+    "        Args:\n",
+    "            model_name (str): The name of the pre-trained T5 model to use.\n",
+    "        \"\"\"\n",
+    "        print(f\"Loading summarization model: {model_name}...\")\n",
+    "        self.model_name = model_name\n",
+    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "\n",
+    "        # Load the tokenizer and model from Hugging Face\n",
+    "        self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)\n",
+    "        self.model = T5ForConditionalGeneration.from_pretrained(self.model_name).to(self.device)\n",
+    "        print(\"Summarization model loaded successfully.\")\n",
+    "\n",
+    "    def summarize(self, text: str, max_length: int = 50, min_length: int = 10) -> str:\n",
+    "        \"\"\"\n",
+    "        Generates a summary for a given text.\n",
+    "\n",
+    "        Args:\n",
+    "            text (str): The review text to summarize.\n",
+    "            max_length (int): The maximum length of the generated summary.\n",
+    "            min_length (int): The minimum length of the generated summary.\n",
+    "\n",
+    "        Returns:\n",
+    "            str: The generated summary.\n",
+    "        \"\"\"\n",
+    "        if not text or not isinstance(text, str):\n",
+    "            return \"\"\n",
+    "\n",
+    "        # T5 models require a prefix for the task. For summarization, it's \"summarize: \"\n",
+    "        preprocess_text = f\"summarize: {text.strip()}\"\n",
+    "\n",
+    "        # Tokenize the input text\n",
+    "        tokenized_text = self.tokenizer.encode(preprocess_text, return_tensors=\"pt\").to(self.device)\n",
+    "\n",
+    "        # Generate the summary\n",
+    "        summary_ids = self.model.generate(\n",
+    "            tokenized_text,\n",
+    "            max_length=max_length,\n",
+    "            min_length=min_length,\n",
+    "            length_penalty=2.0,\n",
+    "            num_beams=4,\n",
+    "            early_stopping=True\n",
+    "        )\n",
+    "\n",
+    "        # Decode the summary and return it\n",
+    "        summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)\n",
+    "        return summary\n",
+    "\n",
+    "class AspectAnalyzer:\n",
+    "    \"\"\"\n",
+    "    A class to handle Aspect-Based Sentiment Analysis (ABSA) using a pre-trained model.\n",
+    "    \"\"\"\n",
+    "    # Changed to a different, currently valid lightweight model for ABSA.\n",
+    "    def __init__(self, model_name='yangheng/deberta-v3-base-absa-v1.1', force_cpu=False):\n",
+    "        \"\"\"\n",
+    "        Initializes the ABSA pipeline with a pre-trained model.\n",
+    "\n",
+    "        Args:\n",
+    "            model_name (str): The name of the pre-trained ABSA model.\n",
+    "            force_cpu (bool): If True, forces the model to run on the CPU.\n",
+    "        \"\"\"\n",
+    "        print(f\"Loading Aspect-Based Sentiment Analysis model: {model_name}...\")\n",
+    "        self.model_name = model_name\n",
+    "\n",
+    "        if force_cpu:\n",
+    "            self.device = -1 # Use -1 for CPU in pipeline\n",
+    "            print(\"Forcing ABSA model to run on CPU.\")\n",
+    "        else:\n",
+    "            self.device = 0 if torch.cuda.is_available() else -1\n",
+    "\n",
+    "        print(f\"Using device: {self.device} (0 for GPU, -1 for CPU)\")\n",
+    "\n",
+    "        self.absa_pipeline = pipeline(\n",
+    "            \"text-classification\",\n",
+    "            model=self.model_name,\n",
+    "            tokenizer=self.model_name,\n",
+    "            device=self.device\n",
+    "        )\n",
+    "        print(\"ABSA model loaded successfully.\")\n",
+    "\n",
+    "    def analyze(self, text: str, aspects: list) -> dict:\n",
+    "        \"\"\"\n",
+    "        Analyzes the sentiment towards a list of aspects within a given text.\n",
+    "        \"\"\"\n",
+    "        if not text or not isinstance(text, str) or not aspects:\n",
+    "            return {}\n",
+    "\n",
+    "        # The model expects the review and aspect separated by a special token.\n",
+    "        # Note: Different ABSA models might expect different input formats.\n",
+    "        # This format is common but may need adjustment for other models.\n",
+    "        inputs = [f\"{text} [SEP] {aspect}\" for aspect in aspects]\n",
+    "        results = self.absa_pipeline(inputs)\n",
+    "\n",
+    "        # Process results into a user-friendly dictionary\n",
+    "        aspect_sentiments = {}\n",
+    "        for aspect, result in zip(aspects, results):\n",
+    "            aspect_sentiments[aspect] = {'sentiment': result['label'], 'score': result['score']}\n",
+    "\n",
+    "        return aspect_sentiments\n",
+    "\n",
+    "class FineTunedSentimentClassifier:\n",
+    "    \"\"\"\n",
+    "    This class handles loading the fine-tuned checkpoint and making predictions.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, checkpoint_path, model_name='distilbert-base-uncased', force_cpu=False):\n",
+    "        self.device = 'cpu' if force_cpu else ('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "        print(f\"Loading fine-tuned sentiment model from checkpoint: {checkpoint_path}...\")\n",
+    "        print(f\"Using device: {self.device}\")\n",
+    "\n",
+    "        self.model = SentimentClassifier.load_from_checkpoint(checkpoint_path, map_location=self.device)\n",
+    "        self.model.to(self.device)\n",
+    "        self.model.eval() # Set model to evaluation mode\n",
+    "\n",
+    "        self.tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "        self.labels = ['NEGATIVE', 'POSITIVE']\n",
+    "        print(\"Fine-tuned sentiment model loaded successfully.\")\n",
+    "\n",
+    "    def classify(self, text: str) -> dict:\n",
+    "        encoding = self.tokenizer.encode_plus(\n",
+    "            text, add_special_tokens=True, max_length=128,\n",
+    "            return_token_type_ids=False, padding=\"max_length\",\n",
+    "            truncation=True, return_attention_mask=True, return_tensors='pt',\n",
+    "        )\n",
+    "        input_ids = encoding[\"input_ids\"].to(self.device)\n",
+    "        attention_mask = encoding[\"attention_mask\"].to(self.device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)\n",
+    "        logits = outputs.logits\n",
+    "        probabilities = torch.softmax(logits, dim=1)\n",
+    "        prediction_idx = torch.argmax(probabilities, dim=1).item()\n",
+    "        return {'label': self.labels[prediction_idx], 'score': probabilities[0][prediction_idx].item()}\n",
+    "\n",
+    "class AspectExtractor:\n",
+    "    \"\"\"\n",
+    "    This class uses a Part-of-Speech (POS) tagging model to first extract all\n",
+    "    potential aspect terms (nouns) from a review text. It then filters these\n",
+    "    nouns against a pre-defined dictionary of valid aspects for a given\n",
+    "    product category to return only the relevant features.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, model_name=\"vblagoje/bert-english-uncased-finetuned-pos\", force_cpu=False):\n",
+    "        self.model_name = model_name\n",
+    "        self.device = 'cpu' if force_cpu else ('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "        print(f\"Loading Part-of-Speech (POS) tagging model: {self.model_name}...\")\n",
+    "        print(f\"Using device: {self.device}\")\n",
+    "\n",
+    "        self.pipeline = pipeline(\n",
+    "            \"token-classification\",\n",
+    "            model=self.model_name,\n",
+    "            device=-1 if self.device == 'cpu' else 0,\n",
+    "            aggregation_strategy=\"simple\"\n",
+    "        )\n",
+    "        print(\"POS tagging model loaded successfully.\")\n",
+    "\n",
+    "    def extract(self, text: str, aspect_dictionary: list) -> list:\n",
+    "        \"\"\"\n",
+    "        Extracts aspects from the given text that are present in the provided\n",
+    "        aspect dictionary.\n",
+    "\n",
+    "        Args:\n",
+    "            text (str): The review text to analyze.\n",
+    "            aspect_dictionary (list): A list of valid, known aspects for the\n",
+    "                                      product category.\n",
+    "\n",
+    "        Returns:\n",
+    "            list: A list of aspects that were both found in the text and are\n",
+    "                  present in the aspect dictionary.\n",
+    "        \"\"\"\n",
+    "        if not text or not aspect_dictionary:\n",
+    "            return []\n",
+    "\n",
+    "        # 1. Extract all nouns from the text using the POS model\n",
+    "        model_outputs = self.pipeline(text)\n",
+    "        noun_tags = {'NOUN', 'PROPN'}\n",
+    "        extracted_nouns = {\n",
+    "            output['word'].lower() for output in model_outputs\n",
+    "            if output['entity_group'] in noun_tags\n",
+    "        }\n",
+    "\n",
+    "        # 2. Filter the extracted nouns against the provided dictionary\n",
+    "        # We find the intersection between the two sets.\n",
+    "        valid_aspects = {aspect.lower() for aspect in aspect_dictionary}\n",
+    "\n",
+    "        final_aspects = list(extracted_nouns.intersection(valid_aspects))\n",
+    "\n",
+    "        return final_aspects\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6fc21c8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- Configuration ---\n",
+    "# --- IMPORTANT: UPDATE THIS PATH ---\n",
+    "# You need to provide the path to the best checkpoint file that was saved\n",
+    "# during the training of your sentiment model.\n",
+    "SENTIMENT_CHECKPOINT_PATH = \"checkpoints/sentiment-binary-best-checkpoint.ckpt\"\n",
+    "\n",
+    "# --- Pre-defined Aspect Dictionaries for Different Product Categories ---\n",
+    "ASPECT_DICTIONARIES = {\n",
+    "    \"Phone\": ['camera', 'battery', 'battery life', 'screen', 'performance', 'price', 'design'],\n",
+    "    \"Coffee Maker\": ['ease of use', 'design', 'noise level', 'coffee quality', 'brew time', 'cleaning'],\n",
+    "    \"Book\": ['plot', 'characters', 'writing style', 'pacing', 'ending'],\n",
+    "    \"Default\": ['quality', 'price', 'service', 'design', 'features'] # A fallback list\n",
+    "}\n",
+    "\n",
+    "def main():\n",
+    "    \"\"\"\n",
+    "    Main function to run the command-line review analysis tool.\n",
+    "    \"\"\"\n",
+    "    # --- 1. Load All Models ---\n",
+    "    print(\"--- Initializing all models ---\")\n",
+    "    sentiment_classifier, summarizer, aspect_analyzer, aspect_extractor = None, None, None, None\n",
+    "    try:\n",
+    "        summarizer = ReviewSummarizer(force_cpu=True)\n",
+    "        aspect_analyzer = AspectAnalyzer(force_cpu=True)\n",
+    "        aspect_extractor = AspectExtractor(force_cpu=True)\n",
+    "\n",
+    "        if not os.path.exists(SENTIMENT_CHECKPOINT_PATH):\n",
+    "            print(\"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\")\n",
+    "            print(\"!!! WARNING: Sentiment checkpoint path not found or not set.         !!!\")\n",
+    "            print(f\"!!! Please update the 'SENTIMENT_CHECKPOINT_PATH' variable in main.py\")\n",
+    "            print(\"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\")\n",
+    "        else:\n",
+    "            sentiment_classifier = FineTunedSentimentClassifier(\n",
+    "                checkpoint_path=SENTIMENT_CHECKPOINT_PATH, force_cpu=True\n",
+    "            )\n",
+    "        print(\"\\n--- All models loaded successfully ---\\n\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"An error occurred during model initialization: {e}\")\n",
+    "        return\n",
+    "\n",
+    "    # --- 2. Interactive Loop ---\n",
+    "    while True:\n",
+    "        print(\"\\n==================================================\")\n",
+    "        print(\"          Product Review Analysis Tool          \")\n",
+    "        print(\"==================================================\")\n",
+    "\n",
+    "        # Get user input\n",
+    "        review_text = input(\"Enter the product review text (or type 'quit' to exit):\\n> \")\n",
+    "        if review_text.lower() == 'quit':\n",
+    "            break\n",
+    "\n",
+    "        print(\"\\nAvailable Product Categories:\")\n",
+    "        for i, category in enumerate(ASPECT_DICTIONARIES.keys(), 1):\n",
+    "            print(f\"{i}. {category}\")\n",
+    "\n",
+    "        category_choice = input(f\"Select a product category (1-{len(ASPECT_DICTIONARIES)}):\\n> \")\n",
+    "        try:\n",
+    "            category_idx = int(category_choice) - 1\n",
+    "            product_category = list(ASPECT_DICTIONARIES.keys())[category_idx]\n",
+    "        except (ValueError, IndexError):\n",
+    "            print(\"Invalid choice. Using 'Default' category.\")\n",
+    "            product_category = \"Default\"\n",
+    "\n",
+    "        # --- 3. Run Analysis ---\n",
+    "        print(\"\\n--- Analyzing Review... ---\")\n",
+    "\n",
+    "        # a. Overall Sentiment\n",
+    "        sentiment_result = sentiment_classifier.classify(review_text)\n",
+    "\n",
+    "        # b. Summary\n",
+    "        summary_result = summarizer.summarize(review_text)\n",
+    "\n",
+    "        # c. Aspect Extraction and Analysis\n",
+    "        aspect_dictionary = ASPECT_DICTIONARIES.get(product_category)\n",
+    "        extracted_aspects = aspect_extractor.extract(review_text, aspect_dictionary)\n",
+    "        aspect_results = None\n",
+    "        if extracted_aspects:\n",
+    "            aspect_results = aspect_analyzer.analyze(review_text, extracted_aspects)\n",
+    "\n",
+    "        # --- 4. Display Results ---\n",
+    "        print(\"\\n-------------------- ANALYSIS RESULTS --------------------\")\n",
+    "        print(f\"\\n[ Overall Sentiment ]\")\n",
+    "        print(f\"  - Sentiment: {sentiment_result['label']} (Score: {sentiment_result['score']:.2f})\")\n",
+    "\n",
+    "        print(f\"\\n[ Generated Summary ]\")\n",
+    "        print(f\"  - {summary_result}\")\n",
+    "\n",
+    "        print(f\"\\n[ Detected Aspect Sentiments ]\")\n",
+    "        if aspect_results:\n",
+    "            for aspect, result in aspect_results.items():\n",
+    "                print(f\"  - {aspect.title()}: {result['sentiment']} (Score: {result['score']:.2f})\")\n",
+    "        else:\n",
+    "            print(\"  - No relevant aspects from the dictionary were detected in the review.\")\n",
+    "        print(\"----------------------------------------------------------\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71257428",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- Run the workflow ---\n",
+    "main()"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 langchain==0.3.27
 langchain-community==0.3.31
 gradio==5.49.1
@@ -13,4 +14,17 @@ datasets==4.0.0
 numpy==2.0.2
 accelerate==1.11.0
 aiohttp==3.13.1
-huggingface-hub==0.35.3
+huggingface-hub==0.35.3
+=======
+torch==2.8.0
+transformers==4.56.1
+pytorch-lightning==2.5.5
+torchmetrics==1.8.2
+sentencepiece==0.2.1
+pandas==2.2.2
+scikit-learn==1.6.1
+gradio==5.44.1
+matplotlib==3.10.0
+seaborn==0.13.2
+wordcloud==1.9.4
+>>>>>>> e6de3c4338f79386345fa6e4bba5b0666ad808da

scripts/app.py

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 # app.py
 
 import gradio as gr
@@ -277,4 +278,166 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 # --- Launch Command ---
 if __name__ == "__main__":
     chat_memory.clear() # Clear memory each time app starts
-    demo.launch(debug=True)
+    demo.launch(debug=True)
+=======
+import gradio as gr
+import os
+import torch
+import pandas as pd
+import re
+
+# --- IMPORTANT ---
+# This script assumes you have a 'models.py' file in the same directory
+# containing the definitions for all model and inference classes.
+try:
+    from models import (
+        ReviewSummarizer,
+        AspectAnalyzer,
+        AspectExtractor,
+        FineTunedSentimentClassifier
+    )
+except ImportError:
+    print("CRITICAL ERROR: Make sure 'models.py' exists and contains the required classes.")
+    # Define dummy classes if imports fail, so Gradio can at least launch with an error message.
+    class ReviewSummarizer: pass
+    class AspectAnalyzer: pass
+    class AspectExtractor: pass
+    class FineTunedSentimentClassifier: pass
+
+# --- Configuration ---
+# --- IMPORTANT: UPDATE THIS PATH ---
+# You need to provide the path to the best checkpoint file that was saved
+# during the training of your sentiment model.
+SENTIMENT_CHECKPOINT_PATH = "checkpoints/sentiment-binary-best-checkpoint.ckpt" # <-- CHANGE THIS
+
+# --- Pre-defined Aspect Dictionaries for Different Product Categories ---
+ASPECT_DICTIONARIES = {
+    "Phone": ['camera', 'battery', 'battery life', 'screen', 'performance', 'price', 'design'],
+    "Coffee Maker": ['ease of use', 'design', 'noise level', 'coffee quality', 'brew time', 'cleaning'],
+    "Book": ['plot', 'characters', 'writing style', 'pacing', 'ending'],
+    "Default": ['quality', 'price', 'service', 'design', 'features'] # A fallback list
+}
+
+
+# --- 1. Load All Models (Global Objects) ---
+print("--- Initializing all models for the Gradio App ---")
+sentiment_classifier, summarizer, aspect_analyzer, aspect_extractor = None, None, None, None
+try:
+    summarizer = ReviewSummarizer(force_cpu=True)
+    aspect_analyzer = AspectAnalyzer(force_cpu=True)
+    aspect_extractor = AspectExtractor(force_cpu=True)
+
+    if not os.path.exists(SENTIMENT_CHECKPOINT_PATH):
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        print("!!! WARNING: Sentiment checkpoint path not found or not set.         !!!")
+        print(f"!!! Please update the 'SENTIMENT_CHECKPOINT_PATH' variable in app.py")
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+    else:
+        sentiment_classifier = FineTunedSentimentClassifier(
+            checkpoint_path=SENTIMENT_CHECKPOINT_PATH, force_cpu=True
+        )
+    print("\n--- All models loaded successfully ---\n")
+except Exception as e:
+    print(f"An error occurred during model initialization: {e}")
+
+
+# --- 2. Define the Core Analysis Function ---
+def analyze_review(review_text, product_category):
+    if not review_text:
+        return {"ERROR": "Please enter a review."}, "", None
+
+    # --- a. Overall Sentiment Analysis ---
+    if sentiment_classifier:
+        sentiment_result = sentiment_classifier.classify(review_text)
+        sentiment_output = {
+            sentiment_result['label']: f"{sentiment_result['score']:.2f}"
+        }
+    else:
+        sentiment_output = {"ERROR": "Fine-tuned model not loaded. Check path."}
+
+    # --- b. Review Summarization ---
+    if summarizer:
+        summary_output = summarizer.summarize(review_text)
+    else:
+        summary_output = "ERROR: Summarizer model not loaded."
+
+    # --- c. Dynamic Aspect Extraction & Analysis ---
+    aspect_df = None
+    if aspect_extractor and aspect_analyzer:
+        aspect_dictionary = ASPECT_DICTIONARIES.get(product_category, ASPECT_DICTIONARIES["Default"])
+        extracted_aspects = aspect_extractor.extract(review_text, aspect_dictionary=aspect_dictionary)
+
+        if extracted_aspects:
+            aspect_results = aspect_analyzer.analyze(review_text, extracted_aspects)
+            aspect_df = pd.DataFrame([
+                {'Aspect': aspect, 'Sentiment': result['sentiment'], 'Score': f"{result['score']:.2f}"}
+                for aspect, result in aspect_results.items()
+            ])
+
+    return sentiment_output, summary_output, aspect_df
+
+
+# --- 3. Build the Gradio Interface ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🛍️ ReviewSense: Product Review Analysis Engine")
+    gr.Markdown(
+        "Enter a product review and select the product category. The tool will automatically "
+        "detect relevant features and provide an overall sentiment score, a summary, and a "
+        "breakdown of sentiment towards each feature."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            review_input = gr.Textbox(
+                lines=10,
+                label="Enter Product Review Here",
+                placeholder="e.g., The camera is amazing, but the battery life is terrible..."
+            )
+            category_input = gr.Dropdown(
+                choices=list(ASPECT_DICTIONARIES.keys()),
+                label="Select Product Category",
+                value="Phone"
+            )
+            analyze_button = gr.Button("Analyze Review", variant="primary")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### Overall Sentiment")
+            sentiment_output = gr.Label()
+
+            gr.Markdown("### Generated Summary")
+            summary_output = gr.Textbox(lines=5, label="Summary", interactive=False)
+
+            gr.Markdown("### Detected Aspect Sentiments")
+            aspect_output = gr.DataFrame(headers=["Aspect", "Sentiment", "Score"], label="Aspects", interactive=False)
+
+    # Connect the button to the function
+    analyze_button.click(
+        fn=analyze_review,
+        inputs=[review_input, category_input],
+        outputs=[sentiment_output, summary_output, aspect_output]
+    )
+
+    gr.Examples(
+        examples=[
+            [
+                "The camera on this phone is incredible, the pictures are professional quality. However, the battery life is a total disaster, it barely lasts half a day with light use. The screen is bright and responsive, which I love.",
+                "Phone"
+            ],
+            [
+                "I am absolutely in love with this coffee maker! It's incredibly easy to use, brews a perfect cup every single time, and the design looks fantastic on my countertop. It's also surprisingly quiet.",
+                "Coffee Maker"
+            ],
+            [
+                "An amazing story with characters that felt so real. The plot had me hooked from the first page, though I felt the ending was a bit rushed.",
+                "Book"
+            ]
+        ],
+        inputs=[review_input, category_input]
+    )
+
+
+# --- 4. Launch the App ---
+if __name__ == "__main__":
+    print("Launching Gradio App...")
+    demo.launch()
+>>>>>>> e6de3c4338f79386345fa6e4bba5b0666ad808da

scripts/data_prepare.py

@@ -0,0 +1,263 @@
+import pytorch_lightning as pl
+from torch.utils.data import DataLoader, Dataset
+from transformers import AutoTokenizer
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import torch
+import os
+
+def explore_and_preprocess_reviews(
+    train_path='data/train.csv', 
+    test_path='data/test.csv',
+    output_dir='data'
+):
+    """
+    Loads the Amazon Sentiment Analysis dataset (https://www.kaggle.com/datasets/kritanjalijain/amazon-reviews)
+    (you need to extract the train/test splits from the zip file in the data folder),
+    performs basic EDA, and preprocesses it for model training.
+
+    Args:
+        train_path (str): Path to the training CSV file.
+        test_path (str): Path to the testing CSV file.
+        output_dir (str): Directory to save the processed file.
+    """
+    # --- 1. Load Data ---
+    # This dataset typically comes without headers. We'll assign them.
+    # Column 1: Sentiment (1 = Negative, 2 = Positive)
+    # Column 2: Title
+    # Column 3: Review Text
+    print(f"Loading data from '{train_path}' and '{test_path}'...")
+    try:
+        col_names = ['sentiment_orig', 'title', 'review']
+        train_df = pd.read_csv(train_path, header=None, names=col_names)
+        test_df = pd.read_csv(test_path, header=None, names=col_names)
+        
+        # Combine for unified EDA and preprocessing
+        df = pd.concat([train_df, test_df], ignore_index=True)
+
+    except FileNotFoundError:
+        print(f"\nERROR: Make sure '{train_path}' and '{test_path}' are in the specified directory.")
+        print("This script is designed for the 'Amazon Reviews for Sentiment Analysis' dataset from Kaggle.")
+        return
+
+    df.dropna(inplace=True)
+
+    # --- 2. Preprocessing ---
+    print("\n--- Preprocessing Data for Sentiment Analysis ---")
+
+    # a) Create new sentiment labels (0 = Negative, 1 = Positive)
+    # This dataset is binary, not three-class like the previous one.
+    df['sentiment'] = df['sentiment_orig'].apply(lambda x: 0 if x == 1 else 1)
+
+    # b) Combine title and review body
+    df['full_text'] = df['title'].astype(str) + ". " + df['review'].astype(str)
+
+    # c) Select and rename columns
+    processed_df = df[['full_text', 'sentiment']].copy()
+
+    # --- 4. Save Processed Data ---
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, 'reviews_processed.csv')
+    processed_df.to_csv(output_path, index=False)
+    print(f"\nSaved {len(processed_df)} processed reviews to '{output_path}'")
+
+class ReviewDataset(Dataset):
+    """
+    Custom PyTorch Dataset for Amazon Reviews.
+
+    This class takes a pandas DataFrame of review data, a tokenizer, and a max
+    token length, and prepares it for use in a PyTorch model. It handles the
+    tokenization of the text and the formatting of the labels for each item.
+
+    Attributes:
+        tokenizer: The Hugging Face tokenizer to use for processing text.
+        data (pd.DataFrame): The DataFrame containing the review data.
+        max_token_len (int): The maximum sequence length for the tokenizer.
+    """
+    def __init__(self, data: pd.DataFrame, tokenizer, max_token_len: int):
+        """
+        Initializes the ReviewDataset.
+
+        Args:
+            data (pd.DataFrame): The input DataFrame containing 'full_text' and
+                                 'sentiment' columns.
+            tokenizer: The pre-trained tokenizer instance.
+            max_token_len (int): The maximum length for tokenized sequences.
+        """
+        self.tokenizer = tokenizer
+        self.data = data
+        self.max_token_len = max_token_len
+
+    def __len__(self):
+        """
+        Returns the total number of samples in the dataset.
+        """
+        return len(self.data)
+
+    def __getitem__(self, index: int):
+        """
+        Retrieves one sample from the dataset at the specified index.
+
+        This method handles the tokenization of a single review text, including
+        padding and truncation, and formats the output into a dictionary of
+        tensors ready for the model.
+
+        Args:
+            index (int): The index of the data sample to retrieve.
+
+        Returns:
+            dict: A dictionary containing the tokenized inputs and the label,
+                  with the following keys:
+                  - 'input_ids': The token IDs of the review text.
+                  - 'attention_mask': The attention mask for the review text.
+                  - 'labels': The sentiment label as a tensor.
+        """
+        data_row = self.data.iloc[index]
+        text = str(data_row.full_text)
+        labels = data_row.sentiment
+
+        encoding = self.tokenizer.encode_plus(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_token_len,
+            return_token_type_ids=False,
+            padding="max_length",
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt',
+        )
+
+        return dict(
+            input_ids=encoding["input_ids"].flatten(),
+            attention_mask=encoding["attention_mask"].flatten(),
+            labels=torch.tensor(labels, dtype=torch.long)
+        )
+
+class ReviewDataModule(pl.LightningDataModule):
+    """
+    PyTorch Lightning DataModule to handle the Amazon Reviews dataset.
+
+    This class encapsulates all the steps needed to process the data:
+    loading, splitting, and creating PyTorch DataLoaders for training,
+    validation, and testing. It allows for using a smaller random sample of the
+    full dataset for faster experimentation.
+
+    Attributes:
+        data_path (str): Path to the processed CSV file.
+        batch_size (int): The size of each data batch.
+        max_token_len (int): The maximum sequence length for the tokenizer.
+        tokenizer: The Hugging Face tokenizer instance.
+        num_workers (int): The number of CPU cores to use for data loading.
+        sample_size (int, optional): The number of samples to use. If None,
+                                     the full dataset is used.
+    """
+    def __init__(self, data_path: str, batch_size: int = 16, max_token_len: int = 256, model_name='distilbert-base-uncased', num_workers: int = 0, sample_size: int = None):
+        """
+        Initializes the ReviewDataModule.
+
+        Args:
+            data_path (str): The path to the processed CSV data file.
+            batch_size (int): The number of samples per batch.
+            max_token_len (int): Maximum length of tokenized sequences.
+            model_name (str): The name of the pre-trained model to use for the tokenizer.
+            num_workers (int): Number of subprocesses to use for data loading.
+            sample_size (int, optional): If specified, a random sample of this
+                                         size will be used from the dataset.
+                                         Defaults to None, which uses the full dataset.
+        """
+        super().__init__()
+        self.data_path = data_path
+        self.batch_size = batch_size
+        self.max_token_len = max_token_len
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.num_workers = num_workers
+        self.sample_size = sample_size
+        self.train_df = None
+        self.val_df = None
+        self.test_df = None
+
+    def setup(self, stage=None):
+        """
+        Loads and splits the data for training, validation, and testing.
+
+        This method is called by PyTorch Lightning. It reads the CSV, handles
+        missing values, optionally takes a random sample, and performs a
+        stratified train-validation-test split. The indices of the resulting
+        DataFrames are reset to prevent potential KeyErrors during data loading.
+        """
+        df = pd.read_csv(self.data_path)
+        df.dropna(inplace=True)
+
+        # If a sample size is provided, sample the dataframe
+        if self.sample_size:
+            print(f"Using a sample of {self.sample_size} reviews.")
+            df = df.sample(n=self.sample_size, random_state=42)
+
+        # Stratified split to maintain label distribution
+        train_val_df, self.test_df = train_test_split(df, test_size=0.1, random_state=42, stratify=df.sentiment)
+        self.train_df, self.val_df = train_test_split(train_val_df, test_size=0.1, random_state=42, stratify=train_val_df.sentiment)
+
+        # Reset indices to prevent KeyErrors
+        self.train_df = self.train_df.reset_index(drop=True)
+        self.val_df = self.val_df.reset_index(drop=True)
+        self.test_df = self.test_df.reset_index(drop=True)
+
+        print(f"Size of training set: {len(self.train_df)}")
+        print(f"Size of validation set: {len(self.val_df)}")
+        print(f"Size of test set: {len(self.test_df)}")
+
+    def train_dataloader(self):
+        """Returns the DataLoader for the training set."""
+        return DataLoader(
+            ReviewDataset(self.train_df, self.tokenizer, self.max_token_len),
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=self.num_workers
+        )
+
+    def val_dataloader(self):
+        """Returns the DataLoader for the validation set."""
+        return DataLoader(
+            ReviewDataset(self.val_df, self.tokenizer, self.max_token__len),
+            batch_size=self.batch_size,
+            num_workers=self.num_workers
+        )
+
+    def test_dataloader(self):
+        """Returns the DataLoader for the test set."""
+        return DataLoader(
+            ReviewDataset(self.test_df, self.tokenizer, self.max_token_len),
+            batch_size=self.batch_size,
+            num_workers=self.num_workers
+        )
+        
+if __name__ == "__main__":
+    
+    #--- Step 1: Preprocess the Reviews Dataset ---
+    print("\n--- Preprocessing started ---")
+    explore_and_preprocess_reviews()
+    print("\n--- Preprocessing finished ---")
+    # --- Configuration ---
+    data_path = "data/reviews_processed.csv"
+    BATCH_SIZE = 64
+    MAX_TOKEN_LEN = 256
+    
+    print("Initializing ReviewDataModule...")
+    review_datamodule = ReviewDataModule(
+        data_path=data_path,
+        batch_size=BATCH_SIZE,
+        max_token_len=MAX_TOKEN_LEN,
+        model_name='distilbert-base-uncased',
+        sample_size=100000 # Pass the sample size to the datamodule
+    )
+    review_datamodule.setup()
+
+    # Fetch one batch from the training dataloader to inspect its contents
+    print("\n--- Fetching one batch from the training dataloader ---")
+    train_batch = next(iter(review_datamodule.train_dataloader()))
+    
+    print("\n--- Example Batch ---")
+    print(f"Input IDs shape: {train_batch['input_ids'].shape}")
+    print(f"Attention Mask shape: {train_batch['attention_mask'].shape}")
+    print(f"Labels: {train_batch['labels']}")
+    print(f"Labels shape: {train_batch['labels'].shape}")

scripts/main.py

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 # main.py
 
 import torch
@@ -209,4 +210,115 @@ if __name__ == "__main__":
                 break
         print("\n--- Chat session ended. ---")
 
-    print("\n--- Local Execution Finished ---")
+    print("\n--- Local Execution Finished ---")
+=======
+import os
+import torch
+import pandas as pd
+
+try:
+    from data_prepare import ReviewDataset, ReviewDataModule
+    from models import SentimentClassifier, ReviewSummarizer, AspectAnalyzer, FineTunedSentimentClassifier, AspectExtractor
+except ImportError:
+    print("CRITICAL ERROR: Make sure 'review_summarizer.py', 'aspect_extractor.py', and 'sentiment_classifier_model.py' are in the same directory.")
+    exit()
+
+# --- Configuration ---
+# --- IMPORTANT: UPDATE THIS PATH ---
+# You need to provide the path to the best checkpoint file that was saved
+# during the training of your sentiment model.
+SENTIMENT_CHECKPOINT_PATH = "checkpoints/sentiment-binary-best-checkpoint.ckpt"
+
+# --- Pre-defined Aspect Dictionaries for Different Product Categories ---
+ASPECT_DICTIONARIES = {
+    "Phone": ['camera', 'battery', 'battery life', 'screen', 'performance', 'price', 'design'],
+    "Coffee Maker": ['ease of use', 'design', 'noise level', 'coffee quality', 'brew time', 'cleaning'],
+    "Book": ['plot', 'characters', 'writing style', 'pacing', 'ending'],
+    "Default": ['quality', 'price', 'service', 'design', 'features'] # A fallback list
+}
+
+def main():
+    """
+    Main function to run the command-line review analysis tool.
+    """
+    # --- 1. Load All Models ---
+    print("--- Initializing all models ---")
+    sentiment_classifier, summarizer, aspect_analyzer, aspect_extractor = None, None, None, None
+    try:
+        summarizer = ReviewSummarizer(force_cpu=True)
+        aspect_analyzer = AspectAnalyzer(force_cpu=True)
+        aspect_extractor = AspectExtractor(force_cpu=True)
+
+        if not os.path.exists(SENTIMENT_CHECKPOINT_PATH):
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!! WARNING: Sentiment checkpoint path not found or not set.         !!!")
+            print(f"!!! Please update the 'SENTIMENT_CHECKPOINT_PATH' variable in main.py")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        else:
+            sentiment_classifier = FineTunedSentimentClassifier(
+                checkpoint_path=SENTIMENT_CHECKPOINT_PATH, force_cpu=True
+            )
+        print("\n--- All models loaded successfully ---\n")
+    except Exception as e:
+        print(f"An error occurred during model initialization: {e}")
+        return
+
+    # --- 2. Interactive Loop ---
+    while True:
+        print("\n==================================================")
+        print("          Product Review Analysis Tool          ")
+        print("==================================================")
+
+        # Get user input
+        review_text = input("Enter the product review text (or type 'quit' to exit):\n> ")
+        if review_text.lower() == 'quit':
+            break
+
+        print("\nAvailable Product Categories:")
+        for i, category in enumerate(ASPECT_DICTIONARIES.keys(), 1):
+            print(f"{i}. {category}")
+
+        category_choice = input(f"Select a product category (1-{len(ASPECT_DICTIONARIES)}):\n> ")
+        try:
+            category_idx = int(category_choice) - 1
+            product_category = list(ASPECT_DICTIONARIES.keys())[category_idx]
+        except (ValueError, IndexError):
+            print("Invalid choice. Using 'Default' category.")
+            product_category = "Default"
+
+        # --- 3. Run Analysis ---
+        print("\n--- Analyzing Review... ---")
+
+        # a. Overall Sentiment
+        sentiment_result = sentiment_classifier.classify(review_text)
+
+        # b. Summary
+        summary_result = summarizer.summarize(review_text)
+
+        # c. Aspect Extraction and Analysis
+        aspect_dictionary = ASPECT_DICTIONARIES.get(product_category)
+        extracted_aspects = aspect_extractor.extract(review_text, aspect_dictionary)
+        aspect_results = None
+        if extracted_aspects:
+            aspect_results = aspect_analyzer.analyze(review_text, extracted_aspects)
+
+        # --- 4. Display Results ---
+        print("\n-------------------- ANALYSIS RESULTS --------------------")
+        print(f"\n[ Overall Sentiment ]")
+        print(f"  - Sentiment: {sentiment_result['label']} (Score: {sentiment_result['score']:.2f})")
+
+        print(f"\n[ Generated Summary ]")
+        print(f"  - {summary_result}")
+
+        print(f"\n[ Detected Aspect Sentiments ]")
+        if aspect_results:
+            for aspect, result in aspect_results.items():
+                print(f"  - {aspect.title()}: {result['sentiment']} (Score: {result['score']:.2f})")
+        else:
+            print("  - No relevant aspects from the dictionary were detected in the review.")
+        print("----------------------------------------------------------")
+
+
+if __name__ == "__main__":
+    main()
+>>>>>>> e6de3c4338f79386345fa6e4bba5b0666ad808da

scripts/models.py

@@ -0,0 +1,256 @@
+import pytorch_lightning as pl
+from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup, AutoConfig
+from torch.optim import AdamW
+import torch
+from torchmetrics.functional import accuracy
+from transformers import T5ForConditionalGeneration, T5Tokenizer, AutoTokenizer, pipeline
+
+class SentimentClassifier(pl.LightningModule):
+    """
+    PyTorch Lightning module for the sentiment classification model.
+    """
+    def __init__(self, model_name='distilbert-base-uncased', n_classes=2, learning_rate=2e-5, n_warmup_steps=0, n_training_steps=0, dropout_prob=0.2): # Added dropout
+        super().__init__()
+        self.save_hyperparameters()
+
+        # Configure dropout
+        config = AutoConfig.from_pretrained(model_name)
+        config.hidden_dropout_prob = dropout_prob
+        config.attention_probs_dropout_prob = dropout_prob
+        config.num_labels = n_classes
+
+        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, config=config)
+
+    def forward(self, input_ids, attention_mask, labels=None):
+        return self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            labels=labels
+        )
+
+    def training_step(self, batch, batch_idx):
+        output = self.forward(**batch)
+        self.log("train_loss", output.loss, prog_bar=True, logger=True)
+        return output.loss
+
+    def validation_step(self, batch, batch_idx):
+        output = self.forward(**batch)
+        preds = torch.argmax(output.logits, dim=1)
+        val_acc = accuracy(preds, batch['labels'], task='binary')
+        self.log("val_loss", output.loss, prog_bar=True, logger=True)
+        self.log("val_accuracy", val_acc, prog_bar=True, logger=True)
+        return output.loss
+
+    def test_step(self, batch, batch_idx):
+        output = self.forward(**batch)
+        preds = torch.argmax(output.logits, dim=1)
+        test_acc = accuracy(preds, batch['labels'], task='binary')
+        self.log("test_accuracy", test_acc)
+        return test_acc
+
+    def predict_step(self, batch, batch_idx, dataloader_idx=0):
+        output = self.forward(input_ids=batch['input_ids'], attention_mask=batch['attention_mask'])
+        return torch.argmax(output.logits, dim=1)
+
+    def configure_optimizers(self):
+        optimizer = AdamW(self.parameters(), lr=self.hparams.learning_rate, weight_decay=0.01)
+        scheduler = get_linear_schedule_with_warmup(
+            optimizer,
+            num_warmup_steps=self.hparams.n_warmup_steps,
+            num_training_steps=self.hparams.n_training_steps
+        )
+        return dict(optimizer=optimizer, lr_scheduler=dict(scheduler=scheduler, interval='step'))
+
+class ReviewSummarizer:
+    """
+    A class to handle the summarization of product reviews using a pre-trained T5 model.
+    """
+    def __init__(self, model_name='t5-small'):
+        """
+        Initializes the summarizer with a pre-trained T5 model and tokenizer.
+
+        Args:
+            model_name (str): The name of the pre-trained T5 model to use.
+        """
+        print(f"Loading summarization model: {model_name}...")
+        self.model_name = model_name
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+        # Load the tokenizer and model from Hugging Face
+        self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
+        self.model = T5ForConditionalGeneration.from_pretrained(self.model_name).to(self.device)
+        print("Summarization model loaded successfully.")
+
+    def summarize(self, text: str, max_length: int = 50, min_length: int = 10) -> str:
+        """
+        Generates a summary for a given text.
+
+        Args:
+            text (str): The review text to summarize.
+            max_length (int): The maximum length of the generated summary.
+            min_length (int): The minimum length of the generated summary.
+
+        Returns:
+            str: The generated summary.
+        """
+        if not text or not isinstance(text, str):
+            return ""
+
+        # T5 models require a prefix for the task. For summarization, it's "summarize: "
+        preprocess_text = f"summarize: {text.strip()}"
+
+        # Tokenize the input text
+        tokenized_text = self.tokenizer.encode(preprocess_text, return_tensors="pt").to(self.device)
+
+        # Generate the summary
+        summary_ids = self.model.generate(
+            tokenized_text,
+            max_length=max_length,
+            min_length=min_length,
+            length_penalty=2.0,
+            num_beams=4,
+            early_stopping=True
+        )
+
+        # Decode the summary and return it
+        summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+        return summary
+
+class AspectAnalyzer:
+    """
+    A class to handle Aspect-Based Sentiment Analysis (ABSA) using a pre-trained model.
+    """
+    # Changed to a different, currently valid lightweight model for ABSA.
+    def __init__(self, model_name='yangheng/deberta-v3-base-absa-v1.1', force_cpu=False):
+        """
+        Initializes the ABSA pipeline with a pre-trained model.
+
+        Args:
+            model_name (str): The name of the pre-trained ABSA model.
+            force_cpu (bool): If True, forces the model to run on the CPU.
+        """
+        print(f"Loading Aspect-Based Sentiment Analysis model: {model_name}...")
+        self.model_name = model_name
+
+        if force_cpu:
+            self.device = -1 # Use -1 for CPU in pipeline
+            print("Forcing ABSA model to run on CPU.")
+        else:
+            self.device = 0 if torch.cuda.is_available() else -1
+
+        print(f"Using device: {self.device} (0 for GPU, -1 for CPU)")
+
+        self.absa_pipeline = pipeline(
+            "text-classification",
+            model=self.model_name,
+            tokenizer=self.model_name,
+            device=self.device
+        )
+        print("ABSA model loaded successfully.")
+
+    def analyze(self, text: str, aspects: list) -> dict:
+        """
+        Analyzes the sentiment towards a list of aspects within a given text.
+        """
+        if not text or not isinstance(text, str) or not aspects:
+            return {}
+
+        # The model expects the review and aspect separated by a special token.
+        # Note: Different ABSA models might expect different input formats.
+        # This format is common but may need adjustment for other models.
+        inputs = [f"{text} [SEP] {aspect}" for aspect in aspects]
+        results = self.absa_pipeline(inputs)
+
+        # Process results into a user-friendly dictionary
+        aspect_sentiments = {}
+        for aspect, result in zip(aspects, results):
+            aspect_sentiments[aspect] = {'sentiment': result['label'], 'score': result['score']}
+
+        return aspect_sentiments
+
+class FineTunedSentimentClassifier:
+    """
+    This class handles loading the fine-tuned checkpoint and making predictions.
+    """
+    def __init__(self, checkpoint_path, model_name='distilbert-base-uncased', force_cpu=False):
+        self.device = 'cpu' if force_cpu else ('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Loading fine-tuned sentiment model from checkpoint: {checkpoint_path}...")
+        print(f"Using device: {self.device}")
+
+        self.model = SentimentClassifier.load_from_checkpoint(checkpoint_path, map_location=self.device)
+        self.model.to(self.device)
+        self.model.eval() # Set model to evaluation mode
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.labels = ['NEGATIVE', 'POSITIVE']
+        print("Fine-tuned sentiment model loaded successfully.")
+
+    def classify(self, text: str) -> dict:
+        encoding = self.tokenizer.encode_plus(
+            text, add_special_tokens=True, max_length=128,
+            return_token_type_ids=False, padding="max_length",
+            truncation=True, return_attention_mask=True, return_tensors='pt',
+        )
+        input_ids = encoding["input_ids"].to(self.device)
+        attention_mask = encoding["attention_mask"].to(self.device)
+        with torch.no_grad():
+            outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
+        logits = outputs.logits
+        probabilities = torch.softmax(logits, dim=1)
+        prediction_idx = torch.argmax(probabilities, dim=1).item()
+        return {'label': self.labels[prediction_idx], 'score': probabilities[0][prediction_idx].item()}
+
+class AspectExtractor:
+    """
+    This class uses a Part-of-Speech (POS) tagging model to first extract all
+    potential aspect terms (nouns) from a review text. It then filters these
+    nouns against a pre-defined dictionary of valid aspects for a given
+    product category to return only the relevant features.
+    """
+    def __init__(self, model_name="vblagoje/bert-english-uncased-finetuned-pos", force_cpu=False):
+        self.model_name = model_name
+        self.device = 'cpu' if force_cpu else ('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Loading Part-of-Speech (POS) tagging model: {self.model_name}...")
+        print(f"Using device: {self.device}")
+
+        self.pipeline = pipeline(
+            "token-classification",
+            model=self.model_name,
+            device=-1 if self.device == 'cpu' else 0,
+            aggregation_strategy="simple"
+        )
+        print("POS tagging model loaded successfully.")
+
+    def extract(self, text: str, aspect_dictionary: list) -> list:
+        """
+        Extracts aspects from the given text that are present in the provided
+        aspect dictionary.
+
+        Args:
+            text (str): The review text to analyze.
+            aspect_dictionary (list): A list of valid, known aspects for the
+                                      product category.
+
+        Returns:
+            list: A list of aspects that were both found in the text and are
+                  present in the aspect dictionary.
+        """
+        if not text or not aspect_dictionary:
+            return []
+
+        # 1. Extract all nouns from the text using the POS model
+        model_outputs = self.pipeline(text)
+        noun_tags = {'NOUN', 'PROPN'}
+        extracted_nouns = {
+            output['word'].lower() for output in model_outputs
+            if output['entity_group'] in noun_tags
+        }
+
+        # 2. Filter the extracted nouns against the provided dictionary
+        # We find the intersection between the two sets.
+        valid_aspects = {aspect.lower() for aspect in aspect_dictionary}
+
+        final_aspects = list(extracted_nouns.intersection(valid_aspects))
+
+        return final_aspects
+    

scripts/train_distilbet.py

@@ -0,0 +1,101 @@
+import pytorch_lightning as pl
+from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
+from pytorch_lightning.loggers import TensorBoardLogger
+import torch
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+from data_prepare import ReviewDataModule, ReviewDataset
+from models import SentimentClassifier
+
+def train_sentiment_model(data_path='data/reviews_processed.csv', model_name='distilbert-base-uncased', n_epochs=5, sample_size: int = None):
+    """
+    Main function to train the sentiment analysis model on the Amazon Reviews dataset.
+
+    Args:
+        data_path (str): Path to the processed data file.
+        model_name (str): Name of the transformer model to use.
+        n_epochs (int): Maximum number of epochs for training.
+        sample_size (int, optional): The number of reviews to use for training.
+                                     If None, the full dataset is used.
+    """
+    # --- 1. Hyperparameters ---
+    BATCH_SIZE = 64
+    MAX_TOKEN_LEN = 256
+    LEARNING_RATE = 2e-5
+    N_CLASSES = 2  # Negative, Positive
+
+    # --- 2. Initialize DataModule ---
+    print("Initializing ReviewDataModule...")
+    review_datamodule = ReviewDataModule(
+        data_path=data_path,
+        batch_size=BATCH_SIZE,
+        max_token_len=MAX_TOKEN_LEN,
+        model_name=model_name,
+        sample_size=sample_size # Pass the sample size to the datamodule
+    )
+    review_datamodule.setup()
+
+    n_training_steps = len(review_datamodule.train_dataloader()) * n_epochs
+    n_warmup_steps = int(n_training_steps * 0.1)
+
+    # --- 3. Initialize Model ---
+    print("Initializing SentimentClassifier model...")
+    model = SentimentClassifier(
+        model_name=model_name,
+        n_classes=N_CLASSES,
+        learning_rate=LEARNING_RATE,
+        n_warmup_steps=n_warmup_steps,
+        n_training_steps=n_training_steps
+    )
+
+    # --- 4. Configure Training Callbacks ---
+    checkpoint_callback = ModelCheckpoint(
+        dirpath="checkpoints",
+        filename="sentiment-binary-best-checkpoint",
+        save_top_k=1,
+        verbose=True,
+        monitor="val_loss",
+        mode="min"
+    )
+    logger = TensorBoardLogger("lightning_logs", name="sentiment-classifier-binary")
+    early_stopping_callback = EarlyStopping(monitor='val_loss', patience=2)
+
+    # --- 5. Initialize Trainer ---
+    print("Initializing PyTorch Lightning Trainer...")
+    trainer = pl.Trainer(
+        logger=logger,
+        callbacks=[checkpoint_callback, early_stopping_callback],
+        max_epochs=n_epochs,
+        accelerator='gpu' if torch.cuda.is_available() else 'cpu',
+        devices=1,
+    )
+
+    # --- 6. Start Training ---
+    print(f"Starting training with {model_name} for up to {n_epochs} epochs...")
+    trainer.fit(model, review_datamodule)
+
+    # --- 7. Evaluate on Test Set and Generate Confusion Matrix ---
+    print("\nTraining complete. Evaluating on the test set...")
+    trainer.test(model, datamodule=review_datamodule)
+
+    predictions = trainer.predict(model, datamodule=review_datamodule)
+    if predictions:
+        all_preds = torch.cat(predictions).cpu().numpy()
+        true_labels = review_datamodule.test_df.sentiment.to_numpy()
+        target_names = ['Negative', 'Positive'] # Updated labels
+
+        cm = confusion_matrix(true_labels, all_preds)
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='YlGnBu',
+                    xticklabels=target_names, yticklabels=target_names)
+        plt.title('Confusion Matrix for Sentiment Analysis')
+        plt.xlabel('Predicted Label')
+        plt.ylabel('True Label')
+        plt.show()
+
+
+        
+if __name__ == "__main__":
+    data_path = "data/reviews_processed.csv"
+    train_sentiment_model(data_path=data_path, sample_size=100000)

scripts/train_naive_bayes.py

@@ -0,0 +1,118 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split, ParameterGrid, StratifiedKFold
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+import seaborn as sns
+import matplotlib.pyplot as plt
+from tqdm.notebook import tqdm
+import os
+
+def train_baseline_sentiment_model(data_path='data/reviews_processed.csv', grid_search=True, nb__alpha=0.1, tfidf__max_df=0.75, tfidf__ngram_range=(1, 2), sample_size: int = 50000):
+    """
+    Trains and evaluates a Multinomial Naive Bayes model for sentiment analysis.
+    Can optionally perform a grid search.
+
+    Args:
+        data_path (str): Path to the processed reviews CSV file.
+        grid_search (bool): If True, performs a grid search.
+        nb__alpha (float): Alpha for MultinomialNB.
+        tfidf__max_df (float): max_df for TfidfVectorizer.
+        tfidf__ngram_range (tuple): ngram_range for TfidfVectorizer.
+        sample_size (int, optional): Number of reviews to use. If None, uses all.
+    """
+    # --- 1. Load Data ---
+    print(f"Loading data from '{data_path}'...")
+    if not os.path.exists(data_path):
+        print(f"\nERROR: '{data_path}' not found. Please run the EDA script first!")
+        return
+        
+    df = pd.read_csv(data_path)
+    df.dropna(inplace=True)
+
+    # --- 2. Sample Data ---
+    if sample_size:
+        print(f"Using a sample of {sample_size} reviews for training the baseline model.")
+        df = df.sample(n=sample_size, random_state=42)
+
+    # --- 3. Train-Test Split ---
+    print("Splitting data into training and testing sets...")
+    X_train, X_test, y_train, y_test = train_test_split(
+        df['full_text'],
+        df['sentiment'],
+        test_size=0.2,
+        random_state=42,
+        stratify=df['sentiment']
+    )
+
+    # --- 4. Create a Pipeline ---
+    pipeline = Pipeline([
+        ('tfidf', TfidfVectorizer(stop_words='english')),
+        ('nb', MultinomialNB()),
+    ])
+
+    best_params = None
+
+    if grid_search:
+        # --- 5a. Perform Grid Search ---
+        print("Performing Grid Search to find the best hyperparameters...")
+        parameters = {
+            'tfidf__ngram_range': [(1, 1), (1, 2)],
+            'tfidf__max_df': [0.5, 0.75, 1.0],
+            'nb__alpha': [0.1, 0.5, 1.0],
+        }
+        param_grid = list(ParameterGrid(parameters))
+        best_score = -1
+
+        for params in tqdm(param_grid, desc="Grid Search Progress"):
+            pipeline.set_params(**params)
+            pipeline.fit(X_train, y_train)
+            score = pipeline.score(X_test, y_test)
+            if score > best_score:
+                best_score = score
+                best_params = params
+        
+        print(f"\nBest score on test set: {best_score:.4f}")
+        print("Best parameters found:")
+        print(best_params)
+
+    else:
+        # --- 5b. Use provided hyperparameters ---
+        print("Skipping grid search and using provided hyperparameters...")
+        best_params = {
+            'nb__alpha': nb__alpha,
+            'tfidf__max_df': tfidf__max_df,
+            'tfidf__ngram_range': tfidf__ngram_range
+        }
+
+    # --- 6. Train the Final Model ---
+    print("\nTraining final model...")
+    best_model = pipeline.set_params(**best_params)
+    best_model.fit(X_train, y_train)
+    print("Model training complete.")
+
+    # --- 7. Evaluate the Best Model ---
+    print("\n--- Model Evaluation ---")
+    y_pred = best_model.predict(X_test)
+    
+    accuracy = accuracy_score(y_test, y_pred)
+    target_names = ['Negative', 'Positive']
+    
+    print(f"Accuracy: {accuracy:.4f}")
+    print("\nClassification Report:")
+    print(classification_report(y_test, y_pred, target_names=target_names))
+    
+    print("Confusion Matrix:")
+    cm = confusion_matrix(y_test, y_pred)
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Greens', 
+                xticklabels=target_names, yticklabels=target_names)
+    plt.title('Confusion Matrix for Naive Bayes on Amazon Reviews')
+    plt.xlabel('Predicted Label')
+    plt.ylabel('True Label')
+    plt.show()
+    
+if __name__ == "__main__":
+    train_baseline_sentiment_model(sample_size=150000, grid_search=False)