{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "gpuType": "T4" }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" }, "accelerator": "GPU" }, "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "id": "Mr-qP30dSW0d" }, "outputs": [], "source": [ "# ==========================================\n", "# Imports for NLP classification in Colab\n", "# ==========================================\n", "\n", "# Core\n", "import numpy as np\n", "import pandas as pd\n", "\n", "# Visualization\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "# Feature extraction (Bag-of-Words)\n", "from sklearn.feature_extraction.text import CountVectorizer\n", "# Optional: TF-IDF\n", "#\n", "from sklearn.feature_extraction.text import TfidfVectorizer\n", "\n", "# Preprocessing & Model Selection\n", "from sklearn.model_selection import train_test_split, GridSearchCV\n", "from sklearn.preprocessing import StandardScaler, LabelEncoder\n", "\n", "# Models\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.svm import SVC\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.neighbors import KNeighborsClassifier\n", "\n", "# Metrics\n", "from sklearn.metrics import (\n", " confusion_matrix, accuracy_score, precision_score, recall_score,\n", " f1_score, classification_report\n", ")\n", "\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from sklearn.model_selection import GridSearchCV\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import classification_report\n", "from sklearn.feature_extraction.text import CountVectorizer\n", "\n" ] }, { "cell_type": "code", "source": [ "from google.colab import drive\n", "drive.mount('/content/drive')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "i7yVyccNeDq_", "outputId": "8d2ae16c-d61a-480e-fc83-baa71d4b7aea" }, "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Mounted at /content/drive\n" ] } ] }, { "cell_type": "code", "source": [ "# قراءة داتا السنتمنت من My Drive\n", "dataset_path = \"/content/drive/MyDrive/AI/DATASET/unbalanceddataset.csv\"\n", "\n", "import os\n", "if os.path.exists(dataset_path):\n", " df = pd.read_csv(dataset_path,encoding=\"ISO-8859-1\")\n", " display(df.head())\n", "else:\n", " print(f\"❌ Error: File not found at {dataset_path}\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 206 }, "id": "WKcgTT5Smbn0", "outputId": "daab6306-ee20-432b-c296-59e945364eb0" }, "execution_count": 3, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ " text sentiment\n", "0 Java Concurrency in Practice is probably the b... positive\n", "1 haha aww hun i bet you are more creative tha... positive\n", "2 _pickle lol, thank you very much Hope you`re h... positive\n", "3 Out for an evening on the town with jeremy. Sa... negative\n", "4 - just took over the #1 Most Endorsed spot on... positive" ], "text/html": [ "\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
textsentiment
0Java Concurrency in Practice is probably the b...positive
1haha aww hun i bet you are more creative tha...positive
2_pickle lol, thank you very much Hope you`re h...positive
3Out for an evening on the town with jeremy. Sa...negative
4- just took over the #1 Most Endorsed spot on...positive
\n", "
\n", "
\n", "\n", "
\n", " \n", "\n", " \n", "\n", " \n", "
\n", "\n", "\n", "
\n", " \n", "\n", "\n", "\n", " \n", "
\n", "\n", "
\n", "
\n" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "dataframe", "summary": "{\n \"name\": \" print(f\\\"\\u274c Error: File not found at {dataset_path}\\\")\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"text\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 5,\n \"samples\": [\n \" haha aww hun i bet you are more creative than me\",\n \" - just took over the #1 Most Endorsed spot on twindexx.com - thanks to the endorsement by \",\n \"_pickle lol, thank you very much Hope you`re having a great day!\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"sentiment\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"negative\",\n \"positive\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" } }, "metadata": {} } ] }, { "cell_type": "code", "source": [ "df['sentiment'].value_counts()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 178 }, "id": "LdkJXhT4obUq", "outputId": "3b359e61-208d-49f3-de34-db59d3b4b56d" }, "execution_count": 4, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "sentiment\n", "positive 2000\n", "negative 600\n", "Name: count, dtype: int64" ], "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
count
sentiment
positive2000
negative600
\n", "

" ] }, "metadata": {}, "execution_count": 4 } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# Text Preprocessing (English)\n", "# ==============================\n", "import re\n", "import math\n", "import nltk\n", "from nltk.corpus import stopwords\n", "from nltk.stem import PorterStemmer\n", "from nltk.tokenize import word_tokenize\n", "\n", "# تحميل الموارد اللازمة لـ NLTK (مرة واحدة)\n", "nltk.download('punkt', quiet=True)\n", "nltk.download('stopwords', quiet=True)\n", "\n", "# مكوّنات المعالجة\n", "stemmer = PorterStemmer()\n", "stop_words = set(stopwords.words('english'))\n", "\n", "# تعابير منتظمة مُسبقة التجهيز\n", "URL_RE = re.compile(r'(https?://\\S+|www\\.\\S+)', re.IGNORECASE)\n", "HTML_RE = re.compile(r'<[^>]+>')\n", "NON_ALPHA_RE = re.compile(r'[^a-z\\s]')\n", "\n", "def preprocess_text(text: str) -> str:\n", " \"\"\"\n", " خط الأنابيب:\n", " 1) تحويل لحروف صغيرة\n", " 2) إزالة الروابط\n", " 3) إزالة وسمات HTML\n", " 4) إزالة الأرقام/الرموز والإبقاء على الحروف الإنجليزية فقط\n", " 5) تقطيع الكلمات\n", " 6) إزالة كلمات الوقف\n", " 7) عمل Stemming\n", " 8) إعادة بناء النص\n", " \"\"\"\n", " # التعامل مع القيم الفارغة/غير النصية\n", " if text is None or (isinstance(text, float) and math.isnan(text)):\n", " return \"\"\n", " if not isinstance(text, str):\n", " text = str(text)\n", "\n", " # 1) lower\n", " text = text.lower()\n", " # 2) remove URLs\n", " text = URL_RE.sub('', text)\n", " # 3) remove HTML tags\n", " text = HTML_RE.sub('', text)\n", " # 4) keep letters/spaces only\n", " text = NON_ALPHA_RE.sub(' ', text)\n", "\n", " # 5) tokenize\n", " tokens = word_tokenize(text)\n", " # 6) remove stopwords\n", " tokens = [t for t in tokens if t not in stop_words and len(t) > 1]\n", " # 7) stemming\n", " tokens = [stemmer.stem(t) for t in tokens]\n", " # 8) rejoin\n", " clean_text = ' '.join(tokens)\n", " return clean_text\n", "\n", "# مثال استخدام (اختياري):\n", "# df['clean_text'] = df['text'].map(preprocess_text)\n" ], "metadata": { "id": "nsJviPjXpf6R" }, "execution_count": 5, "outputs": [] }, { "cell_type": "code", "source": [ "# Fix NLTK LookupError: download required data\n", "import nltk\n", "\n", "paths = {\n", " \"punkt\": \"tokenizers/punkt\",\n", " \"punkt_tab\": \"tokenizers/punkt_tab\",\n", " \"stopwords\": \"corpora/stopwords\"\n", "}\n", "\n", "for pkg, path in paths.items():\n", " try:\n", " nltk.data.find(path)\n", " except LookupError:\n", " nltk.download(pkg, quiet=True)\n", "\n", "# جرّب الآن\n", "df['clean_text'] = df['text'].apply(preprocess_text)\n", "df = df.dropna()\n", "df['clean_text'].head()\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 241 }, "id": "poanfmVOtsPX", "outputId": "93c71028-e788-47da-8c48-01168f031761" }, "execution_count": 7, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0 java concurr practic probabl best java book ev...\n", "1 haha aww hun bet creativ\n", "2 pickl lol thank much hope great day\n", "3 even town jeremi sad carri come\n", "4 took endors spot twindexx com thank endors\n", "Name: clean_text, dtype: object" ], "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
clean_text
0java concurr practic probabl best java book ev...
1haha aww hun bet creativ
2pickl lol thank much hope great day
3even town jeremi sad carri come
4took endors spot twindexx com thank endors
\n", "

" ] }, "metadata": {}, "execution_count": 7 } ] }, { "cell_type": "code", "source": [ "X = df['clean_text'].values\n", "y = df['sentiment'].values" ], "metadata": { "id": "8J3dv8Jdoho0" }, "execution_count": 8, "outputs": [] }, { "cell_type": "code", "source": [ "vectorizer = CountVectorizer()\n", "X = vectorizer.fit_transform(X)" ], "metadata": { "id": "3OzsELUOuIAV" }, "execution_count": 9, "outputs": [] }, { "cell_type": "code", "source": [ "# Split data into training and testing sets (stratified)\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X, y,\n", " test_size=0.30,\n", " random_state=42,\n", " stratify=y\n", ")\n" ], "metadata": { "id": "eJCeihiZurOz" }, "execution_count": 10, "outputs": [] }, { "cell_type": "code", "source": [ "def evaluate_model(model_name, y_true, y_pred):\n", " \"\"\"Compute metrics and plot confusion matrix.\"\"\"\n", " # --- Metrics ---\n", " accuracy = accuracy_score(y_true, y_pred)\n", " precision = precision_score(y_true, y_pred, average='weighted', zero_division=0)\n", " recall = recall_score(y_true, y_pred, average='weighted', zero_division=0)\n", " f1 = f1_score(y_true, y_pred, average='weighted', zero_division=0)\n", "\n", " # Ensure all labels appear in the confusion matrix\n", " labels = np.unique(np.concatenate([y_true, y_pred]))\n", " cm = confusion_matrix(y_true, y_pred, labels=labels)\n", "\n", " # Text report\n", " report = classification_report(y_true, y_pred, zero_division=0)\n", "\n", " metrics = {\n", " \"Model Name\": model_name,\n", " \"Accuracy\": accuracy,\n", " \"Precision\": precision,\n", " \"Recall\": recall,\n", " \"F1 Score\": f1,\n", " \"Classification Report\": report,\n", " }\n", "\n", " # --- Plot Confusion Matrix ---\n", " plt.figure(figsize=(4, 4))\n", " sns.heatmap(\n", " cm, annot=True, fmt='d', cmap='Blues', cbar=False,\n", " xticklabels=labels, yticklabels=labels\n", " )\n", " plt.title(f'Confusion Matrix — {model_name}')\n", " plt.xlabel('Predicted Label')\n", " plt.ylabel('True Label')\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " return metrics\n" ], "metadata": { "id": "XYIRR-gavL-p" }, "execution_count": 11, "outputs": [] }, { "cell_type": "code", "source": [ "# ==============================\n", "# Random Forest + GridSearchCV\n", "# ==============================\n", "\n", "# Define the Random Forest Classifier\n", "rf_classifier = RandomForestClassifier(random_state=42)\n", "\n", "# Define the hyperparameters for grid search\n", "param_grid = {\n", " \"n_estimators\": [100, 200, 300],\n", " \"max_depth\": [None, 10, 20, 30],\n", "}\n", "\n", "# Initialize GridSearchCV\n", "grid_search = GridSearchCV(\n", " estimator=rf_classifier,\n", " param_grid=param_grid,\n", " cv=5,\n", " scoring=\"accuracy\",\n", " n_jobs=-1,\n", " refit=True\n", ")\n", "\n", "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Get the best estimator from grid search\n", "best_rf_classifier = grid_search.best_estimator_\n", "\n", "# Make predictions using the best model\n", "y_pred = best_rf_classifier.predict(X_test)\n", "\n", "# Evaluate the model\n", "evaluation_results = evaluate_model(\"RandomForestClassifier\", y_test, y_pred)\n", "\n", "# Print the evaluation results\n", "for key, value in evaluation_results.items():\n", " if key == \"Classification Report\":\n", " print(\"\\nClassification Report:\\n\")\n", " print(value) # Print report separately for better readability\n", " else:\n", " print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: {value}\")\n", "\n", "# Print the best parameters found by grid search\n", "print(\"\\nBest hyperparameters found by GridSearchCV:\")\n", "print(grid_search.best_params_)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 754 }, "id": "EOaK13AHvOko", "outputId": "532b03ef-a75a-4fda-ae21-14b3f0407540" }, "execution_count": 12, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Model Name: RandomForestClassifier\n", "Accuracy: 0.8590\n", "Precision: 0.8617\n", "Recall: 0.8590\n", "F1 Score: 0.8410\n", "\n", "Classification Report:\n", "\n", " precision recall f1-score support\n", "\n", " negative 0.88 0.45 0.60 180\n", " positive 0.86 0.98 0.91 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.87 0.72 0.76 780\n", "weighted avg 0.86 0.86 0.84 780\n", "\n", "\n", "Best hyperparameters found by GridSearchCV:\n", "{'max_depth': None, 'n_estimators': 300}\n" ] } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# Logistic Regression + GridSearchCV\n", "# ==============================\n", "\n", "# Define the Logistic Regression model\n", "LR = LogisticRegression(random_state=42, max_iter=1000)\n", "\n", "# Define the hyperparameters for grid search\n", "param_grid = {\n", " \"solver\": [\"liblinear\", \"saga\"], # solvers that support sparse input\n", " # \"C\": [0.1, 1.0, 3.0, 10.0], # (اختياري) قوة الانتظام\n", " # \"class_weight\": [None, \"balanced\"] # (اختياري) للتعامل مع عدم التوازن\n", "}\n", "\n", "# Initialize GridSearchCV\n", "grid_search = GridSearchCV(\n", " estimator=LR,\n", " param_grid=param_grid,\n", " cv=5,\n", " scoring=\"accuracy\",\n", " n_jobs=-1,\n", " refit=True\n", ")\n", "\n", "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Get the best estimator from grid search\n", "best_LR = grid_search.best_estimator_\n", "\n", "# Make predictions using the best model\n", "y_pred = best_LR.predict(X_test)\n", "\n", "# Evaluate the model\n", "evaluation_results = evaluate_model(\"LogisticRegression\", y_test, y_pred)\n", "\n", "# Print the evaluation results\n", "for key, value in evaluation_results.items():\n", " if key == \"Classification Report\":\n", " print(\"\\nClassification Report:\\n\")\n", " print(value)\n", " else:\n", " print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: {value}\")\n", "\n", "# Print the best hyperparameters found by grid search\n", "print(\"\\nBest hyperparameters found by GridSearchCV:\")\n", "print(grid_search.best_params_)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 754 }, "id": "k87YhGz8wV4e", "outputId": "41d10619-bb09-41c2-8b0c-fd29142a4df5" }, "execution_count": 13, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Model Name: LogisticRegression\n", "Accuracy: 0.8615\n", "Precision: 0.8614\n", "Recall: 0.8615\n", "F1 Score: 0.8461\n", "\n", "Classification Report:\n", "\n", " precision recall f1-score support\n", "\n", " negative 0.86 0.48 0.61 180\n", " positive 0.86 0.98 0.92 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.86 0.73 0.76 780\n", "weighted avg 0.86 0.86 0.85 780\n", "\n", "\n", "Best hyperparameters found by GridSearchCV:\n", "{'solver': 'liblinear'}\n" ] } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# Decision Tree + GridSearchCV\n", "# ==============================\n", "\n", "# Define the Decision Tree model\n", "DT = DecisionTreeClassifier(random_state=42)\n", "\n", "# Define the hyperparameters for grid search\n", "param_grid = {\n", " \"criterion\": [\"gini\", \"entropy\"], # split quality function\n", " \"max_depth\": [None, 10, 20, 30], # tree depth\n", " # اختياري للتعامل مع عدم التوازن/التقليم:\n", " # \"class_weight\": [None, \"balanced\"],\n", " # \"min_samples_split\": [2, 5, 10],\n", " # \"min_samples_leaf\": [1, 2, 5],\n", "}\n", "\n", "# Initialize GridSearchCV\n", "grid_search = GridSearchCV(\n", " estimator=DT,\n", " param_grid=param_grid,\n", " cv=5,\n", " scoring=\"accuracy\",\n", " n_jobs=-1,\n", " refit=True\n", ")\n", "\n", "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Get the best estimator from grid search\n", "best_DT = grid_search.best_estimator_\n", "\n", "# Make predictions using the best model\n", "y_pred = best_DT.predict(X_test)\n", "\n", "# Evaluate the model\n", "evaluation_results = evaluate_model(\"DecisionTreeClassifier\", y_test, y_pred)\n", "\n", "# Print the evaluation results\n", "for key, value in evaluation_results.items():\n", " if key == \"Classification Report\":\n", " print(\"\\nClassification Report:\\n\")\n", " print(value)\n", " else:\n", " print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: {value}\")\n", "\n", "# Print the best hyperparameters found by grid search\n", "print(\"\\nBest hyperparameters found by GridSearchCV:\")\n", "print(grid_search.best_params_)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 754 }, "id": "QAFJWf3dx2YU", "outputId": "27959c23-b332-4048-9da7-2fb5b2683fe8" }, "execution_count": 14, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Model Name: DecisionTreeClassifier\n", "Accuracy: 0.8141\n", "Precision: 0.7977\n", "Recall: 0.8141\n", "F1 Score: 0.7937\n", "\n", "Classification Report:\n", "\n", " precision recall f1-score support\n", "\n", " negative 0.67 0.38 0.48 180\n", " positive 0.84 0.94 0.89 600\n", "\n", " accuracy 0.81 780\n", " macro avg 0.75 0.66 0.69 780\n", "weighted avg 0.80 0.81 0.79 780\n", "\n", "\n", "Best hyperparameters found by GridSearchCV:\n", "{'criterion': 'gini', 'max_depth': 20}\n" ] } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# SVM (SVC) + GridSearchCV\n", "# ==============================\n", "\n", "# Define the SVM model\n", "SVM = SVC(random_state=42)\n", "\n", "# Define the hyperparameters for grid search\n", "param_grid = {\n", " \"kernel\": [\"linear\", \"rbf\", \"poly\"], # Kernel type\n", " # (اختياري) وسّع البحث:\n", " # \"C\": [0.1, 1.0, 3.0, 10.0],\n", " # \"gamma\": [\"scale\", \"auto\"],\n", " # \"class_weight\": [None, \"balanced\"],\n", "}\n", "\n", "# Initialize GridSearchCV\n", "grid_search = GridSearchCV(\n", " estimator=SVM,\n", " param_grid=param_grid,\n", " cv=5,\n", " scoring=\"accuracy\",\n", " n_jobs=-1,\n", " refit=True\n", ")\n", "\n", "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Get the best estimator from grid search\n", "best_SVM = grid_search.best_estimator_\n", "\n", "# Make predictions using the best model\n", "y_pred = best_SVM.predict(X_test)\n", "\n", "# Evaluate the model\n", "evaluation_results = evaluate_model(\"Support Vector Machine\", y_test, y_pred)\n", "\n", "# Print the evaluation results\n", "for key, value in evaluation_results.items():\n", " if key == \"Classification Report\":\n", " print(\"\\nClassification Report:\\n\")\n", " print(value) # Print report separately for better readability\n", " else:\n", " print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: {value}\")\n", "\n", "# Print the best hyperparameters found by grid search\n", "print(\"\\nBest hyperparameters found by GridSearchCV:\")\n", "print(grid_search.best_params_)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 754 }, "id": "7TuF7cZQyESo", "outputId": "d0a7b506-9152-4f3e-f1a1-6cb5c5dedb9d" }, "execution_count": 15, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Model Name: Support Vector Machine\n", "Accuracy: 0.8615\n", "Precision: 0.8554\n", "Recall: 0.8615\n", "F1 Score: 0.8562\n", "\n", "Classification Report:\n", "\n", " precision recall f1-score support\n", "\n", " negative 0.75 0.61 0.67 180\n", " positive 0.89 0.94 0.91 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.82 0.77 0.79 780\n", "weighted avg 0.86 0.86 0.86 780\n", "\n", "\n", "Best hyperparameters found by GridSearchCV:\n", "{'kernel': 'linear'}\n" ] } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# K-Nearest Neighbors + GridSearchCV\n", "# ==============================\n", "\n", "# Define the K-Nearest Neighbors model\n", "knn = KNeighborsClassifier(n_jobs=-1)\n", "\n", "# Define the hyperparameters for grid search\n", "param_grid = {\n", " \"n_neighbors\": [1, 3, 5, 7, 9],\n", " \"weights\": [\"uniform\", \"distance\"],\n", " \"metric\": [\"euclidean\", \"manhattan\"], # (للنصوص، brute مناسب للمسافات هذه)\n", " \"algorithm\": [\"auto\", \"brute\"] # تجنّب ball_tree/kd_tree لأنها لا تعمل مع sparse\n", " # ملاحظة: بإمكانك تجربة \"cosine\" مع metric وتثبيت algorithm=\"brute\"\n", "}\n", "\n", "# Initialize GridSearchCV\n", "grid_search = GridSearchCV(\n", " estimator=knn,\n", " param_grid=param_grid,\n", " cv=5,\n", " scoring=\"accuracy\",\n", " n_jobs=-1,\n", " refit=True\n", ")\n", "\n", "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Get the best estimator from grid search\n", "best_knn = grid_search.best_estimator_\n", "\n", "# Make predictions using the best model\n", "y_pred = best_knn.predict(X_test)\n", "\n", "# Evaluate the model\n", "evaluation_results = evaluate_model(\"K-Nearest Neighbors\", y_test, y_pred)\n", "\n", "# Print the evaluation results\n", "for key, value in evaluation_results.items():\n", " if key == \"Classification Report\":\n", " print(\"\\nClassification Report:\\n\")\n", " print(value)\n", " else:\n", " print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: {value}\")\n", "\n", "# Print the best hyperparameters found by grid search\n", "print(\"\\nBest hyperparameters found by GridSearchCV:\")\n", "print(grid_search.best_params_)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 754 }, "id": "RSpbuKUryhIO", "outputId": "3eeb8c56-16c4-4053-d56d-d7c7e4fead05" }, "execution_count": 16, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Model Name: K-Nearest Neighbors\n", "Accuracy: 0.8218\n", "Precision: 0.8102\n", "Recall: 0.8218\n", "F1 Score: 0.7972\n", "\n", "Classification Report:\n", "\n", " precision recall f1-score support\n", "\n", " negative 0.74 0.36 0.48 180\n", " positive 0.83 0.96 0.89 600\n", "\n", " accuracy 0.82 780\n", " macro avg 0.78 0.66 0.69 780\n", "weighted avg 0.81 0.82 0.80 780\n", "\n", "\n", "Best hyperparameters found by GridSearchCV:\n", "{'algorithm': 'auto', 'metric': 'euclidean', 'n_neighbors': 5, 'weights': 'uniform'}\n" ] } ] }, { "cell_type": "code", "source": [ "# ==============================\n", "# Compare trained models' results\n", "# ==============================\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report\n", "\n", "# Models variables\n", "candidates = [\n", " (\"RandomForestClassifier\", \"best_rf_classifier\"),\n", " (\"LogisticRegression\", \"best_LR\"),\n", " (\"DecisionTreeClassifier\", \"best_DT\"),\n", " (\"Support Vector Machine\", \"best_SVM\"),\n", " (\"K-Nearest Neighbors\", \"best_knn\"),\n", "]\n", "\n", "results = []\n", "reports = {}\n", "\n", "for name, var in candidates:\n", " if var in globals():\n", " model = globals()[var]\n", " try:\n", " y_pred = model.predict(X_test)\n", " acc = accuracy_score(y_test, y_pred)\n", " prec = precision_score(y_test, y_pred, average='weighted', zero_division=0)\n", " rec = recall_score(y_test, y_pred, average='weighted', zero_division=0)\n", " f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0)\n", "\n", " results.append({\n", " \"Model\": name,\n", " \"Accuracy\": acc,\n", " \"Precision\": prec,\n", " \"Recall\": rec,\n", " \"F1\": f1\n", " })\n", " reports[name] = classification_report(y_test, y_pred, zero_division=0)\n", "\n", " except Exception as e:\n", " print(f\"⚠️ Skipping {name}: {e}\")\n", "\n", "# comparisons\n", "df_results = pd.DataFrame(results)\n", "if not df_results.empty:\n", " df_results = df_results.sort_values(by=\"F1\", ascending=False).reset_index(drop=True)\n", " display(df_results.style.format({\"Accuracy\": \"{:.4f}\", \"Precision\": \"{:.4f}\", \"Recall\": \"{:.4f}\", \"F1\": \"{:.4f}\"}))\n", "\n", " ax = df_results.set_index(\"Model\")[[\"Accuracy\", \"Precision\", \"Recall\", \"F1\"]].plot(\n", " kind=\"bar\", figsize=(9, 5), rot=0\n", " )\n", " ax.set_title(\"Model Comparison (Test Set)\")\n", " ax.set_ylim(0, 1.0)\n", " ax.set_ylabel(\"Score\")\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " # reports for each\n", " for name, rep in reports.items():\n", " print(f\"\\n=== {name} — Classification Report ===\\n{rep}\")\n", "else:\n", " print(\"لم يتم العثور على موديلات للمقارنة. تأكد من تشغيل خلايا التدريب لكل موديل.\")\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "idMnaXHYzeGC", "outputId": "029bf342-9184-4067-bb06-ef3f69d67af1" }, "execution_count": 17, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 ModelAccuracyPrecisionRecallF1
0Support Vector Machine0.86150.85540.86150.8562
1LogisticRegression0.86150.86140.86150.8461
2RandomForestClassifier0.85900.86170.85900.8410
3K-Nearest Neighbors0.82180.81020.82180.7972
4DecisionTreeClassifier0.81410.79770.81410.7937
\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "=== RandomForestClassifier — Classification Report ===\n", " precision recall f1-score support\n", "\n", " negative 0.88 0.45 0.60 180\n", " positive 0.86 0.98 0.91 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.87 0.72 0.76 780\n", "weighted avg 0.86 0.86 0.84 780\n", "\n", "\n", "=== LogisticRegression — Classification Report ===\n", " precision recall f1-score support\n", "\n", " negative 0.86 0.48 0.61 180\n", " positive 0.86 0.98 0.92 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.86 0.73 0.76 780\n", "weighted avg 0.86 0.86 0.85 780\n", "\n", "\n", "=== DecisionTreeClassifier — Classification Report ===\n", " precision recall f1-score support\n", "\n", " negative 0.67 0.38 0.48 180\n", " positive 0.84 0.94 0.89 600\n", "\n", " accuracy 0.81 780\n", " macro avg 0.75 0.66 0.69 780\n", "weighted avg 0.80 0.81 0.79 780\n", "\n", "\n", "=== Support Vector Machine — Classification Report ===\n", " precision recall f1-score support\n", "\n", " negative 0.75 0.61 0.67 180\n", " positive 0.89 0.94 0.91 600\n", "\n", " accuracy 0.86 780\n", " macro avg 0.82 0.77 0.79 780\n", "weighted avg 0.86 0.86 0.86 780\n", "\n", "\n", "=== K-Nearest Neighbors — Classification Report ===\n", " precision recall f1-score support\n", "\n", " negative 0.74 0.36 0.48 180\n", " positive 0.83 0.96 0.89 600\n", "\n", " accuracy 0.82 780\n", " macro avg 0.78 0.66 0.69 780\n", "weighted avg 0.81 0.82 0.80 780\n", "\n" ] } ] } ] }