modded_preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2dacd0dc",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2024-04-25T17:38:59.565900Z",
     "iopub.status.busy": "2024-04-25T17:38:59.565613Z",
     "iopub.status.idle": "2024-04-25T17:39:23.716461Z",
     "shell.execute_reply": "2024-04-25T17:39:23.715535Z"
    },
    "papermill": {
     "duration": 24.159228,
     "end_time": "2024-04-25T17:39:23.718742",
     "exception": false,
     "start_time": "2024-04-25T17:38:59.559514",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amazon reviews file: /kaggle/input/amazon-product-reviews/Reviews.csv\n",
      "Google news word to vec file: /kaggle/input/googlenewsvectorsnegative300/GoogleNews-vectors-negative300.bin\n"
     ]
    }
   ],
   "source": [
    "#>> updated 4/1\n",
    "# For viewing and manipulating data\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Importing the necessary libraries\n",
    "import re\n",
    "import math\n",
    "import nltk\n",
    "import spacy\n",
    "import string\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import gensim.downloader as api\n",
    "from gensim.models import KeyedVectors # >> alternative to gensim.downloader\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Getting particular functions from these libraries\n",
    "from scipy import stats\n",
    "from torch import Tensor\n",
    "from sklearn.utils import resample\n",
    "from gensim.models import KeyedVectors\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from torch.utils.data import random_split, DataLoader, TensorDataset, Dataset\n",
    "\n",
    "# Using the NLTK to tokenize the text\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "\n",
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load\n",
    "\n",
    "# Input data files are available in the read-only \"../input/\" directory\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "\n",
    "import os\n",
    "reviews_file = ''\n",
    "w2v_file = ''\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        file_name = os.path.join(dirname, filename)\n",
    "        if file_name.endswith('.csv'): \n",
    "            reviews_file = file_name\n",
    "        elif file_name.endswith('.bin') or ('.gz'):\n",
    "            w2v_file = file_name\n",
    "        else:\n",
    "            print(f'Found unexpected file: {file_name}')\n",
    "                \n",
    "print(f'Amazon reviews file: {reviews_file}')\n",
    "print(f'Google news word to vec file: {w2v_file}') #<< faster than doing api.load\n",
    "            \n",
    "\n",
    "# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n",
    "# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session\n",
    "VERBOSE = True\n",
    "def printv(text):\n",
    "    if VERBOSE: print('VERBOSE:', text)\n",
    "    return\n",
    "\n",
    "def showV(text):\n",
    "    '''unconditional verbose output'''\n",
    "    print('VERBOSE:', text)\n",
    "    return\n",
    "\n",
    "DEV = True\n",
    "def printd(text):\n",
    "    if DEV: print('DEV:', text)\n",
    "    return\n",
    "\n",
    "def showD(text):\n",
    "    '''unconditional DEV output'''\n",
    "    print('VERBOSE:', text)\n",
    "    return\n",
    "\n",
    "showCellCompletion = False\n",
    "def showC(text):\n",
    "    if showCellCompletion:\n",
    "        print('Cell complete:', text)\n",
    "    return\n",
    "\n",
    "import subprocess\n",
    "showNv = True\n",
    "accelerator = True\n",
    "\n",
    "def printNv():\n",
    "    if not showNv or not accelerator: return\n",
    "    mem_usage = subprocess.run(['nvidia-smi'], stdout=subprocess.PIPE)\n",
    "    print(mem_usage.stdout.decode('utf-8'))\n",
    "\n",
    "showMemoryAllocation = True\n",
    "def printM():\n",
    "    if not showMemoryAllocation: return\n",
    "    print(f\"Total allocated memory: {torch.cuda.memory_allocated()} bytes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "676ab693",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:23.729627Z",
     "iopub.status.busy": "2024-04-25T17:39:23.729076Z",
     "iopub.status.idle": "2024-04-25T17:39:24.984521Z",
     "shell.execute_reply": "2024-04-25T17:39:24.983576Z"
    },
    "papermill": {
     "duration": 1.262838,
     "end_time": "2024-04-25T17:39:24.986474",
     "exception": false,
     "start_time": "2024-04-25T17:39:23.723636",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archive:  /usr/share/nltk_data/corpora/wordnet.zip\r\n",
      "   creating: /usr/share/nltk_data/corpora/wordnet/\r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/lexnames  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/data.verb  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/index.adv  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/adv.exc  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/index.verb  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/cntlist.rev  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/data.adj  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/index.adj  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/LICENSE  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/citation.bib  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/noun.exc  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/verb.exc  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/README  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/index.sense  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/data.noun  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/data.adv  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/index.noun  \r\n",
      "  inflating: /usr/share/nltk_data/corpora/wordnet/adj.exc  \r\n"
     ]
    }
   ],
   "source": [
    "## Only run once\n",
    "#>> Seems to need to be rerun after every Kaggle timeout.\n",
    "!unzip /usr/share/nltk_data/corpora/wordnet.zip -d /usr/share/nltk_data/corpora/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ee3f19a8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:24.998210Z",
     "iopub.status.busy": "2024-04-25T17:39:24.997915Z",
     "iopub.status.idle": "2024-04-25T17:39:32.019172Z",
     "shell.execute_reply": "2024-04-25T17:39:32.018171Z"
    },
    "papermill": {
     "duration": 7.02994,
     "end_time": "2024-04-25T17:39:32.021633",
     "exception": false,
     "start_time": "2024-04-25T17:39:24.991693",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VERBOSE: Amazon reviews loaded into Panda\n",
      "VERBOSE: Number of reviews: 568454\n",
      "VERBOSE: Column names -\n",
      " Index(['Id', 'ProductId', 'UserId', 'ProfileName', 'HelpfulnessNumerator',\n",
      "       'HelpfulnessDenominator', 'Score', 'Time', 'Summary', 'Text'],\n",
      "      dtype='object')\n",
      "\n",
      "VERBOSE: First five rows -\n",
      "   Id   ProductId          UserId                      ProfileName  \\\n",
      "0   1  B001E4KFG0  A3SGXH7AUHU8GW                       delmartian   \n",
      "1   2  B00813GRG4  A1D87F6ZCVE5NK                           dll pa   \n",
      "2   3  B000LQOCH0   ABXLMWJIXXAIN  Natalia Corres \"Natalia Corres\"   \n",
      "3   4  B000UA0QIQ  A395BORC6FGVXV                             Karl   \n",
      "4   5  B006K2ZZ7K  A1UQRSCLF8GW1T    Michael D. Bigham \"M. Wassir\"   \n",
      "\n",
      "   HelpfulnessNumerator  HelpfulnessDenominator  Score        Time  \\\n",
      "0                     1                       1      5  1303862400   \n",
      "1                     0                       0      1  1346976000   \n",
      "2                     1                       1      4  1219017600   \n",
      "3                     3                       3      2  1307923200   \n",
      "4                     0                       0      5  1350777600   \n",
      "\n",
      "                 Summary                                               Text  \n",
      "0  Good Quality Dog Food  I have bought several of the Vitality canned d...  \n",
      "1      Not as Advertised  Product arrived labeled as Jumbo Salted Peanut...  \n",
      "2  \"Delight\" says it all  This is a confection that has been around a fe...  \n",
      "3         Cough Medicine  If you are looking for the secret ingredient i...  \n",
      "4            Great taffy  Great taffy at a great price.  There was a wid...  \n"
     ]
    }
   ],
   "source": [
    "# Load data from CSV\n",
    "#>>  3/13 needed to change the path as below\n",
    "# path ='/kaggle/input/Reviews.csv'#\"/kaggle/input/amazon-product-reviews/Reviews.csv\"\n",
    "data = pd.read_csv(reviews_file) # Use pandas to analyze data\n",
    "showD('Amazon reviews loaded into Panda')\n",
    "\n",
    "# print number of rows in our ratings column\n",
    "printv(f'Number of reviews: {len(data[\"Score\"])}')\n",
    "printv(f'Column names -\\n {data.columns}\\n') \n",
    "printv(f'First five rows -\\n{data.head()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7826af60",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:32.033431Z",
     "iopub.status.busy": "2024-04-25T17:39:32.033104Z",
     "iopub.status.idle": "2024-04-25T17:39:32.324468Z",
     "shell.execute_reply": "2024-04-25T17:39:32.323354Z"
    },
    "papermill": {
     "duration": 0.299844,
     "end_time": "2024-04-25T17:39:32.326870",
     "exception": false,
     "start_time": "2024-04-25T17:39:32.027026",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column 'Id' has no empty entries or missing data.\n",
      "Column 'ProductId' has no empty entries or missing data.\n",
      "Column 'UserId' has no empty entries or missing data.\n",
      "Column 'ProfileName' has empty entries or missing data.\n",
      "Column 'HelpfulnessNumerator' has no empty entries or missing data.\n",
      "Column 'HelpfulnessDenominator' has no empty entries or missing data.\n",
      "Column 'Score' has no empty entries or missing data.\n",
      "Column 'Time' has no empty entries or missing data.\n",
      "Column 'Summary' has empty entries or missing data.\n",
      "Column 'Text' has no empty entries or missing data.\n"
     ]
    }
   ],
   "source": [
    "# Check for empty entries or missing data in each column\n",
    "for column in data.columns:\n",
    "    if data[column].isnull().values.any():\n",
    "        print(f\"Column '{column}' has empty entries or missing data.\")\n",
    "    else:\n",
    "        print(f\"Column '{column}' has no empty entries or missing data.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1521443f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:32.339301Z",
     "iopub.status.busy": "2024-04-25T17:39:32.339005Z",
     "iopub.status.idle": "2024-04-25T17:39:32.651672Z",
     "shell.execute_reply": "2024-04-25T17:39:32.650672Z"
    },
    "papermill": {
     "duration": 0.321003,
     "end_time": "2024-04-25T17:39:32.653704",
     "exception": false,
     "start_time": "2024-04-25T17:39:32.332701",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52,268 samples from balanced data with rating 1\n",
      "\n",
      "29,769 samples from balanced data with rating 2\n",
      "\n",
      "42,640 samples from balanced data with rating 3\n",
      "\n",
      "80,655 samples from balanced data with rating 4\n",
      "\n",
      "363,122 samples from balanced data with rating 5\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get count of ratings \n",
    "rating_counts = data['Score'].value_counts()\n",
    "\n",
    "# Sort counts by index ascending\n",
    "rating_counts = rating_counts.sort_index()  \n",
    "\n",
    "# Create bar plot\n",
    "ax = rating_counts.plot(kind = 'bar')\n",
    "\n",
    "ax.set_title(\"Ratings Distribution\")\n",
    "ax.set_xlabel(\"Rating\")\n",
    "ax.set_ylabel(\"Number of Occurrences\")\n",
    "\n",
    "# Fix x-axis tick labels\n",
    "ax.set_xticklabels(ax.get_xticklabels(), rotation = 0) \n",
    "\n",
    "for rating, count in rating_counts.items():\n",
    "        print(f\"{count:,} samples from balanced data with rating {rating}\\n\")\n",
    "\n",
    "plt.show() #<< show the rating in each of the 5 categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "86725102",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:32.667178Z",
     "iopub.status.busy": "2024-04-25T17:39:32.666886Z",
     "iopub.status.idle": "2024-04-25T17:39:33.245573Z",
     "shell.execute_reply": "2024-04-25T17:39:33.244671Z"
    },
    "papermill": {
     "duration": 0.587737,
     "end_time": "2024-04-25T17:39:33.247639",
     "exception": false,
     "start_time": "2024-04-25T17:39:32.659902",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_23/1469423797.py:17: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n",
      "  balanced_data = sorted_data.groupby(sort_column).apply(lambda x: x.sample(n = balanced_data_size))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VERBOSE: The number of reviews equally distributed across all ratings is 140000\n",
      "28,000 samples from balanced data with rating 1\n",
      "\n",
      "28,000 samples from balanced data with rating 2\n",
      "\n",
      "28,000 samples from balanced data with rating 3\n",
      "\n",
      "28,000 samples from balanced data with rating 4\n",
      "\n",
      "28,000 samples from balanced data with rating 5\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "balanced_data_size = 28000 #<< number of reviews in each rating category, tailored for CPU capacity\n",
    "# Specify the column for sorting and balancing\n",
    "sort_column = 'Score'  # This is one the rating column\n",
    "\n",
    "# Sort the data by the rating values\n",
    "sorted_data = data.sort_values(by = sort_column)\n",
    "\n",
    "# Create a balanced dataset with 25,000 samples from each class\n",
    "#balanced_data = sorted_data.groupby(sort_column).apply(lambda x: x.sample(n=25000))\n",
    "\n",
    "#>> DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. \n",
    "#>> This behavior is deprecated, and in a future version of pandas the grouping \n",
    "#>> columns will be excluded from the operation. \n",
    "#>> Either pass `include_groups=False` to exclude the groupings or \n",
    "#>> explicitly select the grouping columns after groupby to silence this warning.\n",
    "#\n",
    "balanced_data = sorted_data.groupby(sort_column).apply(lambda x: x.sample(n = balanced_data_size))\n",
    "\n",
    "#>> Does this mean to reset the row numbers?? ##Columns Numbers\n",
    "balanced_data.reset_index(drop = True, inplace = True)\n",
    "\n",
    "printv(f\"The number of reviews equally distributed across all ratings is {len(balanced_data['Score'])}\")\n",
    "\n",
    "# Get count of ratings\n",
    "rating_counts = balanced_data['Score'].value_counts()\n",
    "\n",
    "# Create bar plot\n",
    "ax = rating_counts.plot(kind='bar')\n",
    "\n",
    "ax.set_title(\"Ratings Distribution After Balancing\")\n",
    "ax.set_xlabel(\"Rating\")\n",
    "ax.set_ylabel(\"Number of Samples\")\n",
    "\n",
    "# Fix x-axis ticks  \n",
    "ax.set_xticklabels(ax.get_xticklabels(), rotation = 0)\n",
    "\n",
    "# Print number of reviews per rating\n",
    "\n",
    "if DEV:\n",
    "    for rating, count in rating_counts.items():\n",
    "        print(f\"{count:,} samples from balanced data with rating {rating}\\n\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d04ba0d1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:39:33.263113Z",
     "iopub.status.busy": "2024-04-25T17:39:33.262575Z",
     "iopub.status.idle": "2024-04-25T17:40:05.589110Z",
     "shell.execute_reply": "2024-04-25T17:40:05.587956Z"
    },
    "papermill": {
     "duration": 32.336897,
     "end_time": "2024-04-25T17:40:05.591593",
     "exception": false,
     "start_time": "2024-04-25T17:39:33.254696",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting symspellpy\r\n",
      "  Downloading symspellpy-6.7.7-py3-none-any.whl.metadata (2.5 kB)\r\n",
      "Collecting editdistpy>=0.1.3 (from symspellpy)\r\n",
      "  Downloading editdistpy-0.1.4.tar.gz (98 kB)\r\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m98.5/98.5 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\r\n",
      "\u001b[?25h  Installing build dependencies ... \u001b[?25l-\b \b\\\b \b|\b \b/\b \b-\b \b\\\b \b|\b \bdone\r\n",
      "\u001b[?25h  Getting requirements to build wheel ... \u001b[?25l-\b \b\\\b \b|\b \bdone\r\n",
      "\u001b[?25h  Preparing metadata (pyproject.toml) ... \u001b[?25l-\b \b\\\b \bdone\r\n",
      "\u001b[?25hDownloading symspellpy-6.7.7-py3-none-any.whl (2.6 MB)\r\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m32.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\r\n",
      "\u001b[?25hBuilding wheels for collected packages: editdistpy\r\n",
      "  Building wheel for editdistpy (pyproject.toml) ... \u001b[?25l-\b \b\\\b \b|\b \b/\b \b-\b \b\\\b \b|\b \bdone\r\n",
      "\u001b[?25h  Created wheel for editdistpy: filename=editdistpy-0.1.4-cp310-cp310-linux_x86_64.whl size=50428 sha256=b6d675400d48cb38049191736f34843edfca4deb121e318ed0769b730ed21553\r\n",
      "  Stored in directory: /root/.cache/pip/wheels/4c/0f/10/c20d67cd765ee5b3666d759a307241bba0663135d6ee1c0072\r\n",
      "Successfully built editdistpy\r\n",
      "Installing collected packages: editdistpy, symspellpy\r\n",
      "Successfully installed editdistpy-0.1.4 symspellpy-6.7.7\r\n"
     ]
    }
   ],
   "source": [
    "!pip install symspellpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e1e7b7ac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:40:05.612744Z",
     "iopub.status.busy": "2024-04-25T17:40:05.612372Z",
     "iopub.status.idle": "2024-04-25T17:40:05.617891Z",
     "shell.execute_reply": "2024-04-25T17:40:05.617130Z"
    },
    "papermill": {
     "duration": 0.018143,
     "end_time": "2024-04-25T17:40:05.619697",
     "exception": false,
     "start_time": "2024-04-25T17:40:05.601554",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "custom_stop_words =['d', 'i', \"it's\", 'll', 'm', 'ma', 'most', 'mustn', \n",
    "\"mustn't\", 'needn', \"needn't\", 'o','re', 's', \"she's\", 'so', 'some', 'such',\n",
    "'t', \"that'll\", 've', 'wasn', \"wasn't\", 'y', 'you', \"you'd\", \"you'll\", \"you're\"\n",
    ", \"you've\", 'yourselves', ' ']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d3446391",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:40:05.639425Z",
     "iopub.status.busy": "2024-04-25T17:40:05.639109Z",
     "iopub.status.idle": "2024-04-25T17:40:05.643842Z",
     "shell.execute_reply": "2024-04-25T17:40:05.643102Z"
    },
    "papermill": {
     "duration": 0.016562,
     "end_time": "2024-04-25T17:40:05.645736",
     "exception": false,
     "start_time": "2024-04-25T17:40:05.629174",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# custom stop words to remove\n",
    "# custom_stop_words =['a', 'about', 'above', 'after',  'all', 'am', 'an', 'and', 'any',\n",
    "# 'are', 'as', 'at', 'be', 'because', 'been', 'before', 'being', 'below',\n",
    "# 'between', 'both', 'but', 'by', 'can',  'd', 'did',\n",
    "#  'do', 'does', 'doing', 'down',\n",
    "# 'during', 'each', 'for', 'from', 'further', 'had', 'has',  'have', 'having',\n",
    "# 'he', 'her', 'here', 'hers', 'herself', 'him', 'himself', 'his', 'how',\n",
    "# 'i', 'if', 'in', 'into', 'is', 'it', \"it's\", 'its',\n",
    "# 'itself', 'just', 'll', 'm', 'ma', 'me',  'more',\n",
    "# 'most', 'mustn', \"mustn't\", 'my', 'myself', 'needn', \"needn't\",\n",
    "# 'nor',  'now', 'o', 'of', 'off', 'on', 'once', 'only', 'or',\n",
    "# 'other', 'our', 'ours', 'ourselves', 'out', 'over', 'own', 're', 's',\n",
    "# 'same',  'she', \"she's\", 'so', 'some', 'such', 't', 'than', 'that',\n",
    "# \"that'll\", 'the', 'their', 'theirs', 'them', 'themselves', 'then',\n",
    "# 'there', 'these', 'they', 'this', 'those', 'through', 'to', 'too',\n",
    "# 'under', 'until', 'up', 've', 'very', 'was', 'wasn', \"wasn't\", 'we',\n",
    "# 'were',  'what', 'when', 'where', 'which', 'while',\n",
    "# 'who', 'whom', 'why', 'will', 'with', 'y', 'you', \"you'd\", \"you'll\", \"you're\", \"you've\", 'your',\n",
    "# 'yours', 'yourself', 'yourselves', ' ']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71dda329",
   "metadata": {
    "papermill": {
     "duration": 0.008987,
     "end_time": "2024-04-25T17:40:05.664069",
     "exception": false,
     "start_time": "2024-04-25T17:40:05.655082",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Around 7 minutes for 5,000 reviews**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0294d914",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T17:40:05.683512Z",
     "iopub.status.busy": "2024-04-25T17:40:05.683209Z",
     "iopub.status.idle": "2024-04-25T21:36:45.749876Z",
     "shell.execute_reply": "2024-04-25T21:36:45.748948Z"
    },
    "papermill": {
     "duration": 14200.089065,
     "end_time": "2024-04-25T21:36:45.762204",
     "exception": false,
     "start_time": "2024-04-25T17:40:05.673139",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokenizer defined, and CleanedReview column created\n"
     ]
    }
   ],
   "source": [
    "import pkg_resources\n",
    "from symspellpy import SymSpell\n",
    "\n",
    "# Load the English tokenizer model from spaCy\n",
    "nlp = spacy.load(\"en_core_web_lg\")\n",
    "\n",
    "# Compile the regular expressions for cleaning text\n",
    "html_tags = re.compile(\"<.*?>\")\n",
    "punct_and_symbols = re.compile(r'[^\\w\\s\\']+')\n",
    "\n",
    "# Initialize and load SymSpell dictionary for word segmentation\n",
    "sym_spell = SymSpell(max_dictionary_edit_distance = 0, prefix_length = 7)\n",
    "dictionary_path = pkg_resources.resource_filename(\n",
    "    \"symspellpy\", \"frequency_dictionary_en_82_765.txt\"\n",
    ")\n",
    "sym_spell.load_dictionary(dictionary_path, term_index = 0, count_index = 1)\n",
    "\n",
    "def tokenizer(text, nlp, sym_spell, custom_stop_words):\n",
    "    \"\"\"\n",
    "    Tokenizes a text string, segments run-on words, and removes stop words.\n",
    "    \n",
    "    text (str): The text string to tokenize.\n",
    "    nlp: The spaCy language model.\n",
    "    sym_spell: The SymSpell object for correcting run-on words.\n",
    "    custom_stop_words (list): A list of custom stop words to remove.\n",
    "\n",
    "    Returns:\n",
    "        list: The tokenized text string.\n",
    "    \"\"\"\n",
    "    # Clean text\n",
    "    text = text.lower()  # Convert text to lowercase\n",
    "    text = html_tags.sub(\"\", text)  # Remove HTML tags\n",
    "    # text = punct_and_symbols.sub(\"\", text)  # Replace punctuation and symbols with space\n",
    "    text = punct_and_symbols.sub(\" \", text)  # Replace punctuation and symbols with space\n",
    "\n",
    "    # Segment text using SymSpell\n",
    "    segmented = sym_spell.word_segmentation(text)\n",
    "    clean_text = segmented.corrected_string\n",
    "    \n",
    "    # Tokenize the text using spaCy\n",
    "    doc = nlp(clean_text)\n",
    "\n",
    "    # Remove stop words and punctuation tokens\n",
    "    tokens = [token.text for token in doc if not token.is_punct \n",
    "              and token.text not in custom_stop_words] \n",
    "\n",
    "    return tokens\n",
    "\n",
    "# Assuming 'balanced_data' is a pandas DataFrame with a column 'Text'\n",
    "# Apply the tokenizer function to the 'Text' column\n",
    "balanced_data['CleanedReview'] = balanced_data['Text'].apply(lambda x: tokenizer(x, nlp, sym_spell, custom_stop_words))\n",
    "\n",
    "# Indicate completion\n",
    "print('Tokenizer defined, and CleanedReview column created')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "50680502",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:36:45.782442Z",
     "iopub.status.busy": "2024-04-25T21:36:45.782094Z",
     "iopub.status.idle": "2024-04-25T21:36:45.789345Z",
     "shell.execute_reply": "2024-04-25T21:36:45.788100Z"
    },
    "papermill": {
     "duration": 0.019596,
     "end_time": "2024-04-25T21:36:45.791415",
     "exception": false,
     "start_time": "2024-04-25T21:36:45.771819",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VERBOSE: specify the columns that will be used to train the classifier\n",
      "My daughter is a strawberry fiend so I thought this would be perfect for her, but she just spits every bite out pretty violently, LOL! I tried it myself in exasperation and it really tasted like a spoonful of strawberry jam. GROSS. \n",
      "\n",
      "['my', 'daughter', 'is', 'a', 'strawberry', 'fiend', 'thought', 'this', 'would', 'be', 'perfect', 'for', 'her', 'but', 'she', 'just', 'spits', 'every', 'bite', 'out', 'pretty', 'violently', 'lol', 'tried', 'it', 'myself', 'in', 'exasperation', 'and', 'it', 'really', 'tasted', 'like', 'a', 'spoonful', 'of', 'strawberry', 'jam', 'gross'] \n",
      "\n",
      "39 \n",
      "\n",
      "(140000,)\n",
      "Includes tune oil, gelatin and vitamins. I would expect organic pea pure to include just peas, but this is not the case. Enough said. Deleting my subscription. \n",
      "\n",
      "['includes', 'tune', 'oil', 'gelatin', 'and', 'vitamins', 'would', 'expect', 'organic', 'pea', 'pure', 'to', 'include', 'just', 'peas', 'but', 'this', 'is', 'not', 'the', 'case', 'enough', 'said', 'deleting', 'my', 'subscription'] \n",
      "\n",
      "26 \n",
      "\n",
      "(140000,)\n",
      "Cute concept, cute name. If you love original peeps, and you love chocolate, Peepsters sounds like a winning combination.<br /><br />Unfortunately, these do not live up to expectations. In fact, they're really not good at all. The marshmallow creme doesn't taste anything like marshmallow. It's got a heavy, thick, sticky texture and an unpleasant, artificial flavor. The chocolate is fairly good quality, but is not tempered correctly so it melts way before you can get it into your mouth. It melts so quickly it will practically slide out of your fingers between the wrapper and your mouth. The one positive note is that Peepsters are so stingy with their creme filling you can barely find any when you bite into them. Which is a good thing, since the filling is cloying and artificial. I love candy, and while I can be a bit of a chocolate snob, I will never pass up or not finish a bite-sized piece of candy. Until now. I couldn't even eat a whole Peepster, which is not even an inch in diameter.<br /><br />Personally, I really don't see Peepsters catching on. Save your easter-basket candy money for Original Peeps or other, more inspired candies. \n",
      "\n",
      "['cute', 'concept', 'cute', 'name', 'if', 'love', 'original', 'peeps', 'and', 'love', 'chocolate', 'peeps', 'ter', 'sounds', 'like', 'a', 'winning', 'combination', 'unfortunately', 'these', 'do', 'not', 'live', 'up', 'to', 'expectations', 'in', 'fact', 'they', \"'re\", 'really', 'not', 'good', 'at', 'all', 'the', 'marshmallow', 'creme', 'does', \"n't\", 'taste', 'anything', 'like', 'marshmallow', 'it', \"'s\", 'got', 'a', 'heavy', 'thick', 'sticky', 'texture', 'and', 'an', 'unpleasant', 'artificial', 'flavor', 'the', 'chocolate', 'is', 'fairly', 'good', 'quality', 'but', 'is', 'not', 'tempered', 'correctly', 'it', 'melts', 'way', 'before', 'can', 'get', 'it', 'into', 'your', 'mouth', 'it', 'melts', 'quickly', 'it', 'will', 'practically', 'slide', 'out', 'of', 'your', 'fingers', 'between', 'the', 'wrapper', 'and', 'your', 'mouth', 'the', 'one', 'positive', 'note', 'is', 'that', 'peeps', 'ter', 'are', 'stingy', 'with', 'their', 'creme', 'filling', 'can', 'barely', 'find', 'any', 'when', 'bite', 'into', 'them', 'which', 'is', 'a', 'good', 'thing', 'since', 'the', 'filling', 'is', 'cloying', 'and', 'artificial', 'love', 'candy', 'and', 'while', 'can', 'be', 'a', 'bit', 'of', 'a', 'chocolate', 'snob', 'will', 'never', 'pass', 'up', 'or', 'not', 'finish', 'a', 'bite', 'sized', 'piece', 'of', 'candy', 'until', 'now', 'could', \"n't\", 'even', 'eat', 'a', 'whole', 'peeps', 'ter', 'which', 'is', 'not', 'even', 'an', 'inch', 'in', 'diameter', 'personally', 'really', 'do', \"n't\", 'see', 'peeps', 'ter', 'scat', 'ching', 'on', 'save', 'your', 'easter', 'basket', 'candy', 'money', 'for', 'original', 'peeps', 'or', 'other', 'more', 'inspired', 'candies'] \n",
      "\n",
      "196 \n",
      "\n",
      "(140000,)\n",
      "It pisses me off seeing pirates booty coming up as a VEGAN item when its obviously not.<br />The seller needs to learn to label/tag their products correctly. \n",
      "\n",
      "['it', 'pisses', 'me', 'off', 'seeing', 'pirates', 'booty', 'coming', 'up', 'as', 'a', 'vegan', 'item', 'when', 'its', 'obviously', 'not', 'the', 'seller', 'needs', 'to', 'learn', 'to', 'label', 'tag', 'their', 'products', 'correctly'] \n",
      "\n",
      "28 \n",
      "\n",
      "(140000,)\n",
      "Cooking directions should be included with the description.  These are \"pan fry only.\"  I thought they could be baked.  I ASSUMED, which was wrong.  I'm giving these to the neighbor. \n",
      "\n",
      "['cooking', 'directions', 'should', 'be', 'included', 'with', 'the', 'description', '  ', 'these', 'are', 'pan', 'fry', 'only', '  ', 'thought', 'they', 'could', 'be', 'baked', '  ', 'assumed', 'which', 'was', 'wrong', '  ', \"'m\", 'giving', 'these', 'to', 'the', 'neigh', 'b', 'or'] \n",
      "\n",
      "34 \n",
      "\n",
      "(140000,)\n"
     ]
    }
   ],
   "source": [
    "# Store the Rating column\n",
    "rating = balanced_data['Score']  \n",
    "\n",
    "# Store the CleanedReview column\n",
    "tokenized_review = balanced_data['CleanedReview']\n",
    "showD(f'specify the columns that will be used to train the classifier')\n",
    "\n",
    "for i in range (5):\n",
    "    print(balanced_data['Text'][i],'\\n')\n",
    "    print(tokenized_review[i], '\\n')\n",
    "    print(len(tokenized_review[i]), '\\n')\n",
    "    print(tokenized_review.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b334c611",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:36:45.811637Z",
     "iopub.status.busy": "2024-04-25T21:36:45.811320Z",
     "iopub.status.idle": "2024-04-25T21:36:46.730094Z",
     "shell.execute_reply": "2024-04-25T21:36:46.729127Z"
    },
    "papermill": {
     "duration": 0.931253,
     "end_time": "2024-04-25T21:36:46.732223",
     "exception": false,
     "start_time": "2024-04-25T21:36:45.800970",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 88.08\n",
      "Median: 63.00\n",
      "Mode: ModeResult(mode=24, count=1981)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def analyze_review_tokens(reviews):\n",
    "    token_counts = [len(review) for review in reviews]\n",
    "\n",
    "    mean = np.mean(token_counts)\n",
    "    median = np.median(token_counts)\n",
    "    mode = stats.mode(token_counts)\n",
    "\n",
    "    print(f\"Mean: {mean:.2f}\")\n",
    "    print(f\"Median: {median:.2f}\")\n",
    "    print(f\"Mode: {mode}\")\n",
    "\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.hist(token_counts, bins=20, edgecolor='black')\n",
    "    plt.xlabel('Number of Tokens')\n",
    "    plt.ylabel('Frequency')\n",
    "    plt.title('Histogram of Token Counts per Review')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "analyze_review_tokens(tokenized_review)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2b21a262",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:36:46.754573Z",
     "iopub.status.busy": "2024-04-25T21:36:46.754060Z",
     "iopub.status.idle": "2024-04-25T21:37:51.449475Z",
     "shell.execute_reply": "2024-04-25T21:37:51.448516Z"
    },
    "papermill": {
     "duration": 64.719885,
     "end_time": "2024-04-25T21:37:51.462615",
     "exception": false,
     "start_time": "2024-04-25T21:36:46.742730",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VERBOSE: KeyedVectors<vector_size=300, 3000000 keys> can map words onto vectors with 300 dimensions\n"
     ]
    }
   ],
   "source": [
    "# >> 3/29/24 Took less than a minute to run without the accelerator.\n",
    "# Load Word2Vec model\n",
    "#w2v = api.load('word2vec-google-news-300')\n",
    "w2v = KeyedVectors.load_word2vec_format (w2v_file, binary=True)\n",
    "\n",
    "# Define the aimum sequence length (adjust as needed)\n",
    "#>> Will increasing max_sequence_length impact performance?\n",
    "max_sequence_length = 100\n",
    "\n",
    "showD(f'{w2v} can map words onto vectors with 300 dimensions')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4a4d668c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:37:51.486742Z",
     "iopub.status.busy": "2024-04-25T21:37:51.486441Z",
     "iopub.status.idle": "2024-04-25T21:37:51.495721Z",
     "shell.execute_reply": "2024-04-25T21:37:51.494720Z"
    },
    "papermill": {
     "duration": 0.023514,
     "end_time": "2024-04-25T21:37:51.497550",
     "exception": false,
     "start_time": "2024-04-25T21:37:51.474036",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA is available!\n",
      "GPU 0: Tesla P100-PCIE-16GB\n"
     ]
    }
   ],
   "source": [
    "# Checks if a CUDA enabled GPU is available and prints out its information\n",
    "if torch.cuda.is_available():\n",
    "    print(\"CUDA is available!\")\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "        \n",
    "    device = torch.device(\"cuda:0\")\n",
    "    accelerator = True\n",
    "\n",
    "else:\n",
    "    accelerator = False\n",
    "    print(\"CUDA is not available.\")\n",
    "    device = torch.device(\"cpu\")\n",
    "    print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d5ebac10",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:37:51.519816Z",
     "iopub.status.busy": "2024-04-25T21:37:51.519552Z",
     "iopub.status.idle": "2024-04-25T21:41:58.959593Z",
     "shell.execute_reply": "2024-04-25T21:41:58.958654Z"
    },
    "papermill": {
     "duration": 247.465483,
     "end_time": "2024-04-25T21:41:58.973343",
     "exception": false,
     "start_time": "2024-04-25T21:37:51.507860",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VERBOSE: Lengths of 100 longest reviews: [3573, 2168, 1981, 1833, 1614, 1565, 1543, 1531, 1508, 1488, 1357, 1349, 1340, 1323, 1303, 1286, 1282, 1281, 1279, 1272, 1262, 1262, 1261, 1251, 1237, 1223, 1223, 1223, 1202, 1202, 1202, 1196, 1195, 1187, 1174, 1172, 1127, 1109, 1104, 1095, 1090, 1083, 1083, 1074, 1066, 1066, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1043, 1035, 1030, 1008, 1008, 1005, 1004, 988, 971, 971, 965, 955, 946, 942, 929, 929, 927, 923, 921, 918, 916, 912, 912, 900, 897, 896, 896, 896, 894, 886, 884, 883, 879, 878, 877, 873, 871, 871, 870, 869, 867, 863, 860, 860, 860, 860, 860]\n",
      "VERBOSE: 7866329 words found with vector representations, 1197017 without\n",
      "VERBOSE: Number of unique words without vector representations: 5649\n",
      "DEV: Sample of words without vector representations\n",
      "DEV: a - 242723\n",
      "DEV: 2011 - 502\n",
      "DEV: 53 - 37\n",
      "DEV: rudolph - 1\n",
      "DEV: keebler - 77\n",
      "DEV: dnana - 2\n",
      "DEV: pizz - 36\n",
      "DEV: 118 - 3\n",
      "DEV: frigg - 11\n",
      "DEV: blum - 2\n",
      "DEV: sier - 5\n",
      "DEV: b002fbd3j2 - 1\n",
      "DEV: theol - 2\n",
      "DEV: e321 - 1\n",
      "DEV: yeowww - 1\n",
      "DEV: colombians - 4\n",
      "DEV: houji - 2\n",
      "DEV: 40ml - 1\n",
      "DEV: yugoslavia - 1\n",
      "DEV: uec - 1\n",
      "DEV: ooooved - 4\n",
      "DEV: frt - 6\n",
      "DEV: 1331447807 - 12\n",
      "DEV: juc - 1\n",
      "DEV: 1932 - 2\n",
      "DEV: lli - 6\n",
      "DEV: taza - 6\n",
      "DEV: 350f - 3\n",
      "DEV: book'c - 1\n",
      "DEV: tmj - 10\n",
      "DEV: snb - 3\n",
      "DEV: 132 - 1\n",
      "DEV: rier - 2\n",
      "DEV: celebes - 2\n",
      "DEV: cameroonian - 1\n",
      "DEV: bcv - 3\n",
      "DEV: 900ml - 2\n",
      "DEV: juu - 1\n",
      "DEV: cuased - 1\n",
      "DEV: 1940s - 3\n",
      "DEV: nery - 1\n",
      "DEV: efe - 2\n",
      "DEV: rbly - 2\n",
      "DEV: 9000 - 2\n",
      "DEV: calhoun - 2\n",
      "DEV: lmma - 1\n",
      "DEV: pemr - 1\n",
      "DEV: mix'n - 2\n",
      "DEV: sble - 1\n",
      "DEV: 71⁄2 - 1\n",
      "DEV: niç - 1\n",
      "DEV: atomics - 2\n",
      "DEV: glyci - 1\n",
      "DEV: 45fl - 1\n",
      "DEV: lunds - 2\n",
      "DEV: 79th - 1\n",
      "DEV: ulph - 1\n",
      "tensor([[-0.0830, -0.0898,  0.1611,  ..., -0.0045,  0.0820,  0.1885],\n",
      "        [ 0.1211,  0.1221,  0.0315,  ...,  0.0205,  0.1250, -0.0923],\n",
      "        [-0.1396,  0.0623, -0.2793,  ...,  0.2041,  0.2354, -0.0510],\n",
      "        ...,\n",
      "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000]])\n"
     ]
    }
   ],
   "source": [
    "#>> 3/29/24 Completed in less than 30 seconds using 1347 as max_sequence_length \n",
    "\n",
    "# Assume you have a list of tokenized review called tokenized_review\n",
    "# Each element in tokenized_review is a list of tokens for a single review\n",
    "\n",
    "lengths = []\n",
    "for review_tokens in tokenized_review:\n",
    "    lengths.append(len(review_tokens))\n",
    "\n",
    "lengths = sorted(lengths)\n",
    "lengths = lengths[-1:0:-1]\n",
    "showD(f'Lengths of 100 longest reviews: {lengths[0:100]}')        \n",
    "\n",
    "max_sequence_length = 100 #<< 3/29/24 1347 was the longest review length in sample\n",
    "\n",
    "# Initialize an empty tensor for padded reviews on the GPU\n",
    "padded_reviews = torch.zeros((len(tokenized_review), max_sequence_length, 300))\n",
    "\n",
    "# Initialize a mask tensor of the same shape as padded_reviews\n",
    "# Set it to False (or 0) initially, representing that all positions are padding\n",
    "# mask = torch.zeros_like(padded_reviews, dtype=torch.bool)\n",
    "\n",
    "# Initialize a mask tensor of the same shape as padded_reviews but with only sequence length\n",
    "mask = torch.zeros((len(tokenized_review), max_sequence_length), dtype=torch.bool)\n",
    "\n",
    "out_words = {}\n",
    "words_in = 0\n",
    "words_out = 0\n",
    "\n",
    "# Now, during the padding and embedding conversion loop, update the mask as well\n",
    "for i, review_tokens in enumerate(tokenized_review):\n",
    "    review_length = min(len(review_tokens), max_sequence_length)\n",
    "    for j in range(review_length):\n",
    "        word = review_tokens[j]\n",
    "        if word in w2v:\n",
    "            words_in += 1\n",
    "            # Use Word2Vec vector if available\n",
    "            padded_reviews[i, j, :] = torch.tensor(w2v[word])\n",
    "            mask[i, j] = True  # Update the mask to indicate the presence of a word\n",
    "        else:\n",
    "            words_out += 1\n",
    "            out_words[word] = out_words.get(word, 0) + 1\n",
    "        # Otherwise, the mask remains False (or 0) for padding\n",
    "\n",
    "# Now you have a mask tensor that you can use later in your processing to ignore padded values\n",
    "# For example, if you want to apply max pooling only on non-padded values, you could use:\n",
    "# review_embeddings = torch.max(padded_reviews * mask.unsqueeze(-1).float(), dim=1)[0]\n",
    "\n",
    "# Ensure the mask is treated as a float for any operations that require it\n",
    "mask = mask.float()\n",
    "\n",
    "# Now you can use this mask tensor to exclude the padding from any subsequent computations\n",
    "\n",
    "printv(f'{words_in} words found with vector representations, {words_out} without')\n",
    "printv(f'Number of unique words without vector representations: {len(out_words)}')\n",
    "printd('Sample of words without vector representations')\n",
    "kwords = list(out_words.keys())\n",
    "for idx in range(0,len(kwords)-1,100):\n",
    "    kword = kwords[idx]\n",
    "    printd(f'{kword} - {out_words[kword]}')\n",
    "# Apply max pooling to aggregate embeddings along the sequence dimension\n",
    "# review_embeddings = torch.max(padded_reviews, dim=1)[0]\n",
    "\n",
    "# Now,review_embeddings contains the aggregated Word2Vec \n",
    "# embeddings for each review on the GPU\n",
    "\n",
    "showC(f\"Created zero-padded, standard length reviews\")\n",
    "\n",
    "print(padded_reviews[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9e4e4d69",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-25T21:41:58.996127Z",
     "iopub.status.busy": "2024-04-25T21:41:58.995812Z",
     "iopub.status.idle": "2024-04-25T21:43:04.527711Z",
     "shell.execute_reply": "2024-04-25T21:43:04.525712Z"
    },
    "papermill": {
     "duration": 65.54613,
     "end_time": "2024-04-25T21:43:04.530235",
     "exception": false,
     "start_time": "2024-04-25T21:41:58.984105",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import h5py\n",
    "\n",
    "text_embeddings_tensors = padded_reviews\n",
    "\n",
    "# Rating labels\n",
    "rating_labels_tensors = torch.tensor(rating.values)\n",
    "\n",
    "# Open the HDF5 file in write mode ('w')\n",
    "with h5py.File('review_data.hdf5', 'w') as hf:\n",
    "\n",
    "    # Create separate datasets for text reviews and ratings within the HDF5 file\n",
    "    hf.create_dataset('text_reviews', data = text_embeddings_tensors.cpu().numpy())\n",
    "    hf.create_dataset('ratings', data = rating_labels_tensors.cpu().numpy())"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "datasetId": 6763,
     "sourceId": 9801,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 1461623,
     "sourceId": 2415872,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30699,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 14650.444899,
   "end_time": "2024-04-25T21:43:07.305027",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2024-04-25T17:38:56.860128",
   "version": "2.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}