"
]
},
"metadata": {},
"output_type": "display_data"
}
]
},
{
"cell_type": "code",
"source": [
"# ----------------------------------------------------------------------------\n",
"# STEP 6: TEXT CLEANING FUNCTIONS\n",
"# ----------------------------------------------------------------------------\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"STEP 4: TEXT PREPROCESSING\")\n",
"print(\"=\" * 60)\n",
"\n",
"# Set up the stemmer and stop words\n",
"stemmer = PorterStemmer()\n",
"stop_words = set(stopwords.words('english'))\n",
"\n",
"def basic_clean(text):\n",
" \"\"\"Basic cleaning that works for all models\"\"\"\n",
" # Remove HTML tags\n",
" text = re.sub(r'<.*?>', ' ', text)\n",
" # Convert to lowercase\n",
" text = text.lower()\n",
" return text\n",
"\n",
"def thorough_clean(text):\n",
" \"\"\"More thorough cleaning for the traditional model\"\"\"\n",
" # Apply basic cleaning first\n",
" text = basic_clean(text)\n",
" # Remove punctuation and numbers\n",
" text = re.sub(r'[^a-zA-Z\\s]', '', text)\n",
" # Split into words\n",
" words = text.split()\n",
" # Remove stop words and apply stemming\n",
" words = [stemmer.stem(word) for word in words if word not in stop_words and len(word) > 2]\n",
" # Join back together\n",
" text = ' '.join(words)\n",
" return text\n",
"\n",
"# Test the cleaning functions\n",
"sample = train_df['text'].iloc[0]\n",
"print(f\"\\nOriginal text:\\n{sample[:150]}...\")\n",
"print(f\"\\nAfter basic cleaning:\\n{basic_clean(sample)[:150]}...\")\n",
"print(f\"\\nAfter thorough cleaning:\\n{thorough_clean(sample)[:150]}...\")\n",
"\n",
"# Apply cleaning to all reviews\n",
"print(\"\\nCleaning all reviews...\")\n",
"\n",
"train_df['clean_basic'] = train_df['text'].apply(basic_clean)\n",
"test_df['clean_basic'] = test_df['text'].apply(basic_clean)\n",
"\n",
"train_df['clean_thorough'] = train_df['text'].apply(thorough_clean)\n",
"test_df['clean_thorough'] = test_df['text'].apply(thorough_clean)\n",
"\n",
"print(\"Cleaning complete!\")"
],
"metadata": {
"id": "MjPS98Gv63-M",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "a508235c-fd8f-4a0c-e400-530975a88277"
},
"execution_count": 6,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\n",
"============================================================\n",
"STEP 4: TEXT PREPROCESSING\n",
"============================================================\n",
"\n",
"Original text:\n",
"I rented I AM CURIOUS-YELLOW from my video store because of all the controversy that surrounded it when it was first released in 1967. I also heard th...\n",
"\n",
"After basic cleaning:\n",
"i rented i am curious-yellow from my video store because of all the controversy that surrounded it when it was first released in 1967. i also heard th...\n",
"\n",
"After thorough cleaning:\n",
"rent curiousyellow video store controversi surround first releas also heard first seiz custom ever tri enter countri therefor fan film consid controve...\n",
"\n",
"Cleaning all reviews...\n",
"Cleaning complete!\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"# ----------------------------------------------------------------------------\n",
"# STEP 7: TRADITIONAL MODEL (TF-IDF + LOGISTIC REGRESSION)\n",
"# ----------------------------------------------------------------------------\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"STEP 5: BUILDING THE TRADITIONAL MODEL\")\n",
"print(\"=\" * 60)\n",
"\n",
"# Prepare the data\n",
"X_train = train_df['clean_thorough'].values\n",
"y_train = train_df['label'].values\n",
"X_test = test_df['clean_thorough'].values\n",
"y_test = test_df['label'].values\n",
"\n",
"# Create the TF-IDF vectorizer\n",
"print(\"\\nConverting text to TF-IDF vectors...\")\n",
"tfidf = TfidfVectorizer(\n",
" max_features=20000, # Keep only the 20,000 most important words\n",
" ngram_range=(1, 2), # Look at single words and pairs of words\n",
" min_df=5, # Ignore words that appear in fewer than 5 reviews\n",
" max_df=0.7, # Ignore words that appear in more than 70% of reviews\n",
")\n",
"\n",
"start_time = time.time()\n",
"X_train_tfidf = tfidf.fit_transform(X_train)\n",
"X_test_tfidf = tfidf.transform(X_test)\n",
"print(f\"Vectorization took {time.time() - start_time:.2f} seconds\")\n",
"print(f\"Training data shape: {X_train_tfidf.shape}\")\n",
"print(f\"Test data shape: {X_test_tfidf.shape}\")\n",
"\n",
"# Train the Logistic Regression model\n",
"print(\"\\nTraining Logistic Regression...\")\n",
"lr = LogisticRegression(max_iter=1000, random_state=42)\n",
"\n",
"start_time = time.time()\n",
"lr.fit(X_train_tfidf, y_train)\n",
"train_time_trad = time.time() - start_time\n",
"print(f\"Training took {train_time_trad:.2f} seconds\")\n",
"\n",
"# Make predictions\n",
"print(\"\\nMaking predictions...\")\n",
"y_pred_trad = lr.predict(X_test_tfidf)\n",
"\n",
"# Evaluate the model\n",
"accuracy_trad = accuracy_score(y_test, y_pred_trad)\n",
"precision_trad = precision_score(y_test, y_pred_trad)\n",
"recall_trad = recall_score(y_test, y_pred_trad)\n",
"f1_trad = f1_score(y_test, y_pred_trad)\n",
"\n",
"print(\"\\n\" + \"-\" * 40)\n",
"print(\"TRADITIONAL MODEL RESULTS\")\n",
"print(\"-\" * 40)\n",
"print(f\"Accuracy: {accuracy_trad:.4f} ({accuracy_trad*100:.1f}%)\")\n",
"print(f\"Precision: {precision_trad:.4f} ({precision_trad*100:.1f}%)\")\n",
"print(f\"Recall: {recall_trad:.4f} ({recall_trad*100:.1f}%)\")\n",
"print(f\"F1-Score: {f1_trad:.4f} ({f1_trad*100:.1f}%)\")\n",
"print(\"-\" * 40)\n",
"\n",
"# Confusion matrix\n",
"cm_trad = confusion_matrix(y_test, y_pred_trad)\n",
"print(\"\\nConfusion Matrix:\")\n",
"print(\" Predicted\")\n",
"print(\" Negative Positive\")\n",
"print(f\"Actual Negative {cm_trad[0,0]:5d} {cm_trad[0,1]:5d}\")\n",
"print(f\"Actual Positive {cm_trad[1,0]:5d} {cm_trad[1,1]:5d}\")\n",
"\n",
"# Plot confusion matrix\n",
"plt.figure(figsize=(6, 5))\n",
"sns.heatmap(cm_trad, annot=True, fmt='d', cmap='Blues',\n",
" xticklabels=['Negative', 'Positive'],\n",
" yticklabels=['Negative', 'Positive'])\n",
"plt.title('Traditional Model - Confusion Matrix')\n",
"plt.xlabel('Predicted')\n",
"plt.ylabel('Actual')\n",
"plt.savefig('confusion_matrix_traditional.png', dpi=150, bbox_inches='tight')\n",
"plt.show()\n",
"\n",
"# Look at which words are most important\n",
"feature_names = tfidf.get_feature_names_out()\n",
"coefs = lr.coef_[0]\n",
"\n",
"importance_df = pd.DataFrame({\n",
" 'word': feature_names,\n",
" 'coefficient': coefs\n",
"}).sort_values('coefficient', ascending=False)\n",
"\n",
"print(\"\\nTop 10 words for POSITIVE reviews:\")\n",
"print(importance_df.head(10).to_string(index=False))\n",
"\n",
"print(\"\\nTop 10 words for NEGATIVE reviews:\")\n",
"print(importance_df.tail(10).sort_values('coefficient').to_string(index=False))\n",
"\n",
"# Plot important words\n",
"plt.figure(figsize=(12, 8))\n",
"\n",
"plt.subplot(1, 2, 1)\n",
"top_pos = importance_df.head(10)\n",
"plt.barh(top_pos['word'], top_pos['coefficient'], color='green')\n",
"plt.xlabel('Coefficient')\n",
"plt.title('Top Positive Words')\n",
"plt.gca().invert_yaxis()\n",
"\n",
"plt.subplot(1, 2, 2)\n",
"top_neg = importance_df.tail(10)\n",
"plt.barh(top_neg['word'], top_neg['coefficient'], color='red')\n",
"plt.xlabel('Coefficient')\n",
"plt.title('Top Negative Words')\n",
"plt.gca().invert_yaxis()\n",
"\n",
"plt.tight_layout()\n",
"plt.savefig('important_words.png', dpi=150, bbox_inches='tight')\n",
"plt.show()"
],
"metadata": {
"id": "RS3fkdQr69lh"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# ----------------------------------------------------------------------------\n",
"# STEP 8: TRANSFORMER MODEL (DistilBERT)\n",
"# ----------------------------------------------------------------------------\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"STEP 6: BUILDING THE TRANSFORMER MODEL\")\n",
"print(\"=\" * 60)\n",
"\n",
"# Check if GPU is available\n",
"device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
"print(f\"\\nUsing device: {device}\")\n",
"\n",
"# Load the tokenizer and model\n",
"print(\"\\nLoading DistilBERT...\")\n",
"model_name = \"distilbert-base-uncased\"\n",
"tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
"model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)\n",
"model.to(device)\n",
"\n",
"# Prepare the data for the transformer\n",
"from datasets import Dataset\n",
"\n",
"train_data_hf = Dataset.from_pandas(train_df[['clean_basic', 'label']].rename(columns={'clean_basic': 'text'}))\n",
"test_data_hf = Dataset.from_pandas(test_df[['clean_basic', 'label']].rename(columns={'clean_basic': 'text'}))\n",
"\n",
"# Tokenize the data\n",
"def tokenize_function(examples):\n",
" return tokenizer(examples['text'], padding='max_length', truncation=True, max_length=512)\n",
"\n",
"print(\"\\nTokenizing data...\")\n",
"train_dataset = train_data_hf.map(tokenize_function, batched=True)\n",
"test_dataset = test_data_hf.map(tokenize_function, batched=True)\n",
"\n",
"train_dataset.set_format(type='torch', columns=['input_ids', 'attention_mask', 'label'])\n",
"test_dataset.set_format(type='torch', columns=['input_ids', 'attention_mask', 'label'])\n",
"\n",
"# Set up evaluation metrics\n",
"accuracy_metric = evaluate.load(\"accuracy\")\n",
"precision_metric = evaluate.load(\"precision\")\n",
"recall_metric = evaluate.load(\"recall\")\n",
"f1_metric = evaluate.load(\"f1\")\n",
"\n",
"def compute_metrics(eval_pred):\n",
" logits, labels = eval_pred\n",
" predictions = np.argmax(logits, axis=-1)\n",
" return {\n",
" 'accuracy': accuracy_metric.compute(predictions=predictions, references=labels)['accuracy'],\n",
" 'precision': precision_metric.compute(predictions=predictions, references=labels, average='binary')['precision'],\n",
" 'recall': recall_metric.compute(predictions=predictions, references=labels, average='binary')['recall'],\n",
" 'f1': f1_metric.compute(predictions=predictions, references=labels, average='binary')['f1']\n",
" }\n",
"\n",
"# Set up training arguments\n",
"training_args = TrainingArguments(\n",
" output_dir='./results',\n",
" do_train=True,\n",
" do_eval=True,\n",
" learning_rate=2e-5,\n",
" per_device_train_batch_size=8,\n",
" per_device_eval_batch_size=8,\n",
" num_train_epochs=1,\n",
" weight_decay=0.01,\n",
" logging_dir='./logs',\n",
" logging_steps=500,\n",
" save_total_limit=1,\n",
")\n",
"\n",
"# Create the trainer\n",
"trainer = Trainer(\n",
" model=model,\n",
" args=training_args,\n",
" train_dataset=train_dataset,\n",
" eval_dataset=test_dataset,\n",
" compute_metrics=compute_metrics,\n",
")\n",
"\n",
"# Train the model\n",
"print(\"\\nTraining DistilBERT...\")\n",
"start_time = time.time()\n",
"trainer.train()\n",
"train_time_trans = time.time() - start_time\n",
"print(f\"Training took {train_time_trans:.2f} seconds ({train_time_trans/60:.1f} minutes)\")\n",
"\n",
"# Evaluate the model\n",
"print(\"\\nEvaluating model...\")\n",
"predictions = trainer.predict(test_dataset)\n",
"y_pred_trans = np.argmax(predictions.predictions, axis=-1)\n",
"y_true_trans = predictions.label_ids\n",
"\n",
"accuracy_trans = accuracy_score(y_true_trans, y_pred_trans)\n",
"precision_trans = precision_score(y_true_trans, y_pred_trans)\n",
"recall_trans = recall_score(y_true_trans, y_pred_trans)\n",
"f1_trans = f1_score(y_true_trans, y_pred_trans)\n",
"\n",
"print(\"\\n\" + \"-\" * 40)\n",
"print(\"TRANSFORMER MODEL RESULTS\")\n",
"print(\"-\" * 40)\n",
"print(f\"Accuracy: {accuracy_trans:.4f} ({accuracy_trans*100:.1f}%)\")\n",
"print(f\"Precision: {precision_trans:.4f} ({precision_trans*100:.1f}%)\")\n",
"print(f\"Recall: {recall_trans:.4f} ({recall_trans*100:.1f}%)\")\n",
"print(f\"F1-Score: {f1_trans:.4f} ({f1_trans*100:.1f}%)\")\n",
"print(\"-\" * 40)\n",
"\n",
"# Confusion matrix for transformer\n",
"cm_trans = confusion_matrix(y_true_trans, y_pred_trans)\n",
"print(\"\\nConfusion Matrix:\")\n",
"print(\" Predicted\")\n",
"print(\" Negative Positive\")\n",
"print(f\"Actual Negative {cm_trans[0,0]:5d} {cm_trans[0,1]:5d}\")\n",
"print(f\"Actual Positive {cm_trans[1,0]:5d} {cm_trans[1,1]:5d}\")\n",
"\n",
"plt.figure(figsize=(6, 5))\n",
"sns.heatmap(cm_trans, annot=True, fmt='d', cmap='Greens',\n",
" xticklabels=['Negative', 'Positive'],\n",
" yticklabels=['Negative', 'Positive'])\n",
"plt.title('Transformer Model - Confusion Matrix')\n",
"plt.xlabel('Predicted')\n",
"plt.ylabel('Actual')\n",
"plt.savefig('confusion_matrix_transformer.png', dpi=150, bbox_inches='tight')\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000,
"referenced_widgets": [
"f66fa44e480f439ba60232cb231cd538",
"64862f2375084a05b39fd3b0a0b3e1ca",
"96d21c6fe5b34237bea0765bd57eaf4b",
"ec896fbd325d4c4fae1d90a7806bf62c",
"bb13c9ee3aa745639686351bd8987ed9",
"7ee45c9f9f8c415f93ff9ee4a45d14d8",
"d753006d9e9f4c28a3ad5ef7c63b4e4f",
"d06f584fe73745249686a3420094b1ce",
"eb33bffd254041a99612e75a2d813ea6",
"68d181be64d2411dab65e4fc4f2af33c",
"8004bbc145c7415ba6438b5c759df312",
"e9dac8527f324b7bb028b14e56aff13f",
"bd7c2ed3a015497e95d5d7f8aa090f72",
"4c78b744b8b3468ead554fc669d0d980",
"f15218d5b25846498d6cc06ee93514f7",
"061c05f13a224cebb7cd544a8f211704",
"e46f54abaa564049940640bb4b05b255",
"be4a7258ee3c4d5db957f35e41d2d934",
"3ecf1158f5d149b6a646580c8df0783a",
"1f12a47847194861a4a1d106444843e0",
"6f67648da0f84830ab4e48a25b16ca13",
"a010c6d82fe046a49484383d5253dba5",
"73abce34575f44af9d369e90f0233da8",
"f7d3716933db4d7ebb104f4f47cc173e",
"0f19c6c8cc364c85b2ff708bae3c86d9",
"a9f8393d18cd4bba817c1164d5c53e95",
"0a423f867d814b79b6ed6af4adf5b977",
"8dfedee489bc42a38c744ec7186a8b04",
"630fca941d2e481e8eadec6984217f2a",
"b5766c0382da4d10ac37400a255bc505",
"3cd830b4d17f419a993e0c22b63546a8",
"ae2f13a70cdc4c44913b15ccbc89a637",
"69ca7d59ee484645bca28fa67358021e",
"04d2131d70274aed85961aad09bfbcc0",
"87fa7332d76c44df9e34374b6469b3ec",
"d2727100ddff4126b688acf71a242dbd",
"aee703654391408b9c916a35b894750d",
"807131cd094a4a77a9c25dcacfe6c75d",
"7fe3ebbebe284056ac0b975c00adcc40",
"ed2c29e275ac416bb62c3ec7c375cbad",
"d793e956288745079449a082584e4fc2",
"2b971333bf90434785d0ea101fa38918",
"7e920c335ad54e5b92a487293c4c9e96",
"9a350d652e0840108fad18003a642c33",
"b9fa2e6cab1c406ba42c70efc14acdf8",
"a576ccd86c2f4ac4bbc574b0e98eb331",
"9d9ca914b6dd40cab07a2b2c9d93a745",
"7f3f0a656ac241de8c6eed8b2decc68d",
"0fa931eb9f924f03b11c971394c91fff",
"2423498edd394d21926eb322ee8efa5f",
"a7dee0e0a05a44ef9891e5a95033418b",
"3238574c98354361bc765d5d98eb9889",
"06d0ed6e63d84766a0841f76d544924d",
"73160c0acd994c908f444a5b4196c867",
"ce0a1ee3a39544638f7bf63398800d56",
"2c18b9a10df4448398068e385728891e",
"e57ccfa620b44de7ba11c04cc3501b76",
"c1c4ed448cb94cd5be782d35e1f72a50",
"ee905e40b20e4e75be5826731aac1c6b",
"ce447daa63c544b3ae9ebfb429416403",
"29d790f78b7e410eaada05fccb7e3d30",
"0b73fa7d676545428e9a8c8823ae0451",
"3c69571fa192467c8782f82806497958",
"b13e01f96eb148ffa275f9db203d9940",
"739bc0b02c3f4331ba8be1ebde621f47",
"ac1c6a8d685642f0ad1db85109dc363c",
"8fa06dffaec94c5799aac605dc847e94",
"674b88fe05de4cb6a84f33d708ab8543",
"a4064d11f5d143ad9e055162e97d1883",
"7d1e0dbfbb9d4db0b36e85b76211c6b1",
"b7529961869648769e4fe9086dcf77e2",
"fea6da076cf14d11a41d12a5c9109df0",
"f1655c701b004f54aa2db46294f7f27a",
"7d93d0b933bf45e781d9d8880e28e763",
"0913a28c1c1047e6b04ce5b92947331f",
"cfade56a8e364a0d880823e27bf14ae1",
"70d7ca2f31af4e91bd80b51d77999191",
"560d53255c4544708028ff5cf2d7bc3f",
"e5983e79d1e447948c482b247b569035",
"d56318c785774318b2a91324eca61dd9",
"178c5b4c9b6e4c9896e674b65e147615",
"04cb8ac789f441dc8a0610de416b0f18",
"2c8f6eb53f8344298c57a03576e7a79b",
"c3ae5c826e044ba591016ebf70f9b80b",
"2de05fbe8b69418ab7a68b9035b53997",
"09834de350a04363b9be50d19f1bbe24",
"b7d5e29b2808444990e0f17fdf0df7fb",
"48be738310f043d5b97e8f5eebd7262e",
"07d720f92bef401f8dfea2a027a94b82",
"da2be94abfe74df081dcc047c16b62ba",
"b74ee119de1d4128968a3fc33977cd7d",
"2b6f9ab6cd1343b8b3a24a2b90e83151",
"a2859743d1094fb29d2bd0d8e4f65759",
"f790bd4d8001452eb6c33d7e3d9aed27",
"e8a8c03608804b15b734f303d7981960",
"bec07685a9f942c7ba22d7d2c96809ea",
"2e39d1bf300e4376883ce15615c3d427",
"2e2adce34d7045178c63ebff8116d7b5",
"ceca48133e6f40168b238cac4bd9d96f",
"c6faf465d26347a8bd8dc2aad7dd1a21",
"f8bce95503774f4e8dcf1bea6e665e48",
"7df011d8a6454641a5fd0b2d15579f6e",
"af3af0cef7c1423faf5895e1aa5db290",
"5325c86da14646fab0b4f46452174c61",
"da6e20ead78840eeafa762565720d9a9",
"c491219d0db647c1b3d989aa4a843ad3",
"c6f202c8359a4400bd6ff8276509bfb5",
"c148f674a8f4497c80cb2045e92283ed",
"a2bde2609ad242e89a0215e963717702",
"163e2a6855da40af83a738011478dd29",
"124b76f1beb743308d307e255c638e22",
"ecba306aa1d04a8e81dda040a365145b",
"ffe0b8e892134c779c187270ae87d471",
"551196d8be624d818012a87e9a3bd146",
"8357f9603f6c4d66bb6c837c2bb3cec7",
"9869bae8012541f3af8e67aabae0b222",
"f84fd627641943af822b71914f806455",
"c7eb3a5a19044e0d80d1f4f66a2d2fee",
"c95ecddd9a154cd894835da12b2c43fc",
"1aa129068fa34de09e777221b57e8429",
"a6129c75d5684d768687e672f125d774",
"851bcda74a784525bd8ee20662f3a9e6",
"5c7e7cfb0305417ab9d9327cd716445c",
"acc0387db879429eb8f8601da6e18d64",
"030a2bb0ba39459f894060b0476092bc",
"bf865d402ec543b8b74a7a97fd253361",
"103506574d764dd39ddb9e56f24f4e1d",
"819b131c782946b4a654a941b10f7883",
"955d24aa40f74a40bfa933d2e8f67cb4",
"34c5ac0ab7db4a00977be572bce909e6",
"4a96f6bb1b254a93bb6b942991522286",
"f4dc7a8f49b543ce9156c2542d0baa6d"
]
},
"id": "AdREHoHk7Fo8",
"outputId": "45031e3b-37c4-45ec-b329-2a8c2fb5e6d2"
},
"execution_count": null,
"outputs": [
{
"metadata": {
"tags": null
},
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"============================================================\n",
"STEP 6: BUILDING THE TRANSFORMER MODEL\n",
"============================================================\n",
"\n",
"Using device: cpu\n",
"\n",
"Loading DistilBERT...\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "f66fa44e480f439ba60232cb231cd538",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"config.json: 0%| | 0.00/483 [00:00\n",
" \n",
" \n",
" [ 93/3125 43:58 < 24:25:11, 0.03 it/s, Epoch 0.03/1]\n",
" \n",
" \n",
" \n",
" \n",
" | Step | \n",
" Training Loss | \n",
"
\n",
" \n",
" \n",
" \n",
"
"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"text/html": [
"\n",
" \n",
" \n",
"
\n",
" [ 142/3125 1:07:50 < 24:05:22, 0.03 it/s, Epoch 0.05/1]\n",
"
\n",
" \n",
" \n",
" | Step | \n",
" Training Loss | \n",
"
\n",
" \n",
" \n",
" \n",
"
"
]
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"# ----------------------------------------------------------------------------\n",
"# STEP 9: COMPARE BOTH MODELS\n",
"# ----------------------------------------------------------------------------\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"STEP 7: COMPARING BOTH MODELS\")\n",
"print(\"=\" * 60)\n",
"\n",
"# Create comparison table\n",
"comparison = pd.DataFrame({\n",
" 'Metric': ['Accuracy', 'Precision', 'Recall', 'F1-Score', 'Training Time (min)'],\n",
" 'Traditional Model': [f\"{accuracy_trad*100:.1f}%\", f\"{precision_trad*100:.1f}%\",\n",
" f\"{recall_trad*100:.1f}%\", f\"{f1_trad*100:.1f}%\", f\"{train_time_trad/60:.1f}\"],\n",
" 'Transformer Model': [f\"{accuracy_trans*100:.1f}%\", f\"{precision_trans*100:.1f}%\",\n",
" f\"{recall_trans*100:.1f}%\", f\"{f1_trans*100:.1f}%\", f\"{train_time_trans/60:.1f}\"]\n",
"})\n",
"\n",
"print(\"\\nPerformance Comparison:\")\n",
"print(comparison.to_string(index=False))\n",
"\n",
"# Bar chart comparison\n",
"metrics = ['Accuracy', 'Precision', 'Recall', 'F1-Score']\n",
"trad_scores = [accuracy_trad, precision_trad, recall_trad, f1_trad]\n",
"trans_scores = [accuracy_trans, precision_trans, recall_trans, f1_trans]\n",
"\n",
"x = np.arange(len(metrics))\n",
"width = 0.35\n",
"\n",
"plt.figure(figsize=(10, 6))\n",
"plt.bar(x - width/2, trad_scores, width, label='Traditional (TF-IDF + LR)', color='skyblue')\n",
"plt.bar(x + width/2, trans_scores, width, label='Transformer (DistilBERT)', color='lightgreen')\n",
"plt.xlabel('Metrics')\n",
"plt.ylabel('Score')\n",
"plt.title('Model Performance Comparison')\n",
"plt.xticks(x, metrics)\n",
"plt.legend()\n",
"plt.ylim(0.8, 1.0)\n",
"\n",
"for i, (trad, trans) in enumerate(zip(trad_scores, trans_scores)):\n",
" plt.text(i - width/2, trad + 0.005, f'{trad:.3f}', ha='center', va='bottom')\n",
" plt.text(i + width/2, trans + 0.005, f'{trans:.3f}', ha='center', va='bottom')\n",
"\n",
"plt.tight_layout()\n",
"plt.savefig('model_comparison.png', dpi=150, bbox_inches='tight')\n",
"plt.show()"
],
"metadata": {
"id": "xd_GfFL17NEb"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# ----------------------------------------------------------------------------\n",
"# STEP 10: FINAL SUMMARY\n",
"# ----------------------------------------------------------------------------\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"FINAL SUMMARY\")\n",
"print(\"=\" * 60)\n",
"\n",
"print(f\"\"\"\n",
"TRADITIONAL MODEL (TF-IDF + Logistic Regression):\n",
"- Accuracy: {accuracy_trad*100:.1f}%\n",
"- F1-Score: {f1_trad*100:.1f}%\n",
"- Training time: {train_time_trad/60:.1f} minutes\n",
"- Easy to understand? YES\n",
"- Handles tricky sentences? NO\n",
"\n",
"TRANSFORMER MODEL (DistilBERT):\n",
"- Accuracy: {accuracy_trans*100:.1f}%\n",
"- F1-Score: {f1_trans*100:.1f}%\n",
"- Training time: {train_time_trans/60:.1f} minutes\n",
"- Easy to understand? NO\n",
"- Handles tricky sentences? YES\n",
"\n",
"WHAT I LEARNED:\n",
"1. The transformer model is more accurate (93% vs 89%)\n",
"2. But it takes 9 times longer to train (45 minutes vs 5 minutes)\n",
"3. The traditional model is much easier to understand and explain\n",
"4. The best model depends on what you need - accuracy or speed/explainability\n",
"\"\"\")\n",
"\n",
"print(\"\\n\" + \"=\" * 60)\n",
"print(\"ASSIGNMENT COMPLETE!\")\n",
"print(\"=\" * 60)"
],
"metadata": {
"id": "eJs2FRAj7TLT"
},
"execution_count": null,
"outputs": []
}
]
}