hair_dryer_text_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from textblob import TextBlob\n",
    "from keras.optimizers import Adam\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.optimizers import Adam\n",
    "from keras.regularizers import l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load and Prepare Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('Problem_C_Data/hair_dryer.tsv', sep='\\t')\n",
    "\n",
    "data['review_body'] = data['review_body'].fillna('').astype(str).str.lower()\n",
    "\n",
    "data['sentiment'] = data['review_body'].apply(lambda x: TextBlob(x).sentiment.polarity)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text Vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf = TfidfVectorizer(max_features=1000)\n",
    "tfidf_features = tfidf.fit_transform(data['review_body']).toarray()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Engineering and Dataset Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.concat([pd.DataFrame(tfidf_features), data[['sentiment', 'helpful_votes', 'total_votes']]], axis=1)\n",
    "y = data['star_rating'].apply(lambda x: 1 if x > 3 else 0)  # Binary classification for simplicity\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build and Train the Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\16057\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python310\\site-packages\\keras\\engine\\data_adapter.py:1696: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  return t[start:end]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "202/202 [==============================] - 3s 10ms/step - loss: 2.5309 - accuracy: 0.7593 - val_loss: 1.0088 - val_accuracy: 0.8103\n",
      "Epoch 2/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.7336 - accuracy: 0.8580 - val_loss: 0.7321 - val_accuracy: 0.7875\n",
      "Epoch 3/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.4810 - accuracy: 0.8827 - val_loss: 0.5384 - val_accuracy: 0.8303\n",
      "Epoch 4/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.4040 - accuracy: 0.8963 - val_loss: 0.4941 - val_accuracy: 0.8377\n",
      "Epoch 5/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.3380 - accuracy: 0.9113 - val_loss: 0.4934 - val_accuracy: 0.8233\n",
      "Epoch 6/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2989 - accuracy: 0.9262 - val_loss: 0.5484 - val_accuracy: 0.8298\n",
      "Epoch 7/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2823 - accuracy: 0.9360 - val_loss: 0.4519 - val_accuracy: 0.8624\n",
      "Epoch 8/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2739 - accuracy: 0.9439 - val_loss: 0.4846 - val_accuracy: 0.8559\n",
      "Epoch 9/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2414 - accuracy: 0.9541 - val_loss: 0.4696 - val_accuracy: 0.8550\n",
      "Epoch 10/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2240 - accuracy: 0.9656 - val_loss: 0.4597 - val_accuracy: 0.8670\n",
      "Epoch 11/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2120 - accuracy: 0.9719 - val_loss: 0.5843 - val_accuracy: 0.8182\n",
      "Epoch 12/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2199 - accuracy: 0.9732 - val_loss: 0.6016 - val_accuracy: 0.8331\n",
      "Epoch 13/15\n",
      "202/202 [==============================] - 2s 11ms/step - loss: 0.1906 - accuracy: 0.9786 - val_loss: 0.4947 - val_accuracy: 0.8550\n",
      "Epoch 14/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.2004 - accuracy: 0.9761 - val_loss: 0.5129 - val_accuracy: 0.8642\n",
      "Epoch 15/15\n",
      "202/202 [==============================] - 2s 10ms/step - loss: 0.1957 - accuracy: 0.9798 - val_loss: 0.4831 - val_accuracy: 0.8642\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x179ffddaaa0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_classes = np.unique(y_train)\n",
    "class_weights = compute_class_weight('balanced', classes=unique_classes, y=y_train)\n",
    "\n",
    "class_weight_dict = {}\n",
    "\n",
    "for cls, weight in zip(unique_classes, class_weights):\n",
    "    class_weight_dict[cls] = weight  \n",
    "\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Dense(1024, input_dim=X_train.shape[1], activation='relu'))\n",
    "model.add(Dropout(0.3)) \n",
    "model.add(Dense(512, activation='relu', kernel_regularizer=l2(0.01)))  \n",
    "model.add(Dropout(0.3)) \n",
    "model.add(Dense(256, activation='relu', kernel_regularizer=l2(0.01))) \n",
    "model.add(Dropout(0.3))  \n",
    "model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.01)))\n",
    "\n",
    "\n",
    "optimizer = Adam(learning_rate=0.001)\n",
    "model.compile(loss='binary_crossentropy', optimizer=Adam(), metrics=['accuracy'])\n",
    "\n",
    "model.fit(X_train, y_train, epochs=15, batch_size=32, class_weight=class_weight_dict, validation_split=0.25)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90/90 [==============================] - 0s 3ms/step\n",
      "Neural Network Accuracy: 0.8790097629009763\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.74      0.71      0.72       639\n",
      "           1       0.92      0.93      0.92      2229\n",
      "\n",
      "    accuracy                           0.88      2868\n",
      "   macro avg       0.83      0.82      0.82      2868\n",
      "weighted avg       0.88      0.88      0.88      2868\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_pred_nn = (model.predict(X_test) > 0.5).astype(int)\n",
    "\n",
    "# Evaluating the model\n",
    "print(\"Neural Network Accuracy:\", accuracy_score(y_test, y_pred_nn))\n",
    "print(classification_report(y_test, y_pred_nn))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(y_test, y_pred_nn)\n",
    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n",
    "plt.xlabel('Predicted Label')\n",
    "plt.ylabel('True Label')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}