"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"RandomForestClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n"
]
}
],
"source": [
"\n",
"# Example DataFrame\n",
"df = pd.DataFrame({\n",
" 'feature1': [1, 2, 3, 4, 5],\n",
" 'feature2': [5, 4, 3, 2, 1],\n",
" 'classification': [0, 1, 0, 1, 0]\n",
"})\n",
"\n",
"# Split into features (X) and target (y)\n",
"X = df.drop('classification', axis=1) # Features\n",
"y = df['classification'] # Target\n",
"\n",
"# Check shapes before splitting\n",
"print(\"X shape:\", X.shape)\n",
"print(\"y shape:\", y.shape)\n",
"\n",
"# Perform the data split\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42, stratify=y)\n",
"\n",
"# Check shapes after splitting\n",
"print(\"X_train shape:\", X_train.shape)\n",
"print(\"y_train shape:\", y_train.shape)\n",
"print(\"X_test shape:\", X_test.shape)\n",
"print(\"y_test shape:\", y_test.shape)\n",
"\n",
"# Train the Random Forest Classifier\n",
"rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)\n",
"rf_classifier.fit(X_train, y_train)\n",
"\n",
"# Make predictions\n",
"y_pred = rf_classifier.predict(X_test)\n",
"\n",
"# Assuming evaluate_model function is defined\n",
"evaluation_results = evaluate_model('RandomForestClassifier', y_test, y_pred)\n",
"\n",
"# Print evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value)\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 281,
"id": "4db05e37-b845-42ee-9d73-dcad9b0243fc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"X shape: (5, 2)\n",
"y shape: (5,)\n",
"X_train shape: (3, 2)\n",
"y_train shape: (3,)\n",
"X_test shape: (2, 2)\n",
"y_test shape: (2,)\n",
"Model Name: \n",
"LogisticRegression\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n"
]
}
],
"source": [
"\n",
"\n",
"# Example DataFrame\n",
"df = pd.DataFrame({\n",
" 'feature1': [1, 2, 3, 4, 5],\n",
" 'feature2': [5, 4, 3, 2, 1],\n",
" 'classification': [0, 1, 0, 1, 0]\n",
"})\n",
"\n",
"# Split into features (X) and target (y)\n",
"X = df.drop('classification', axis=1) # Features\n",
"y = df['classification'] # Target\n",
"\n",
"# Check shapes before splitting\n",
"print(\"X shape:\", X.shape)\n",
"print(\"y shape:\", y.shape)\n",
"\n",
"# Perform the data split\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42, stratify=y)\n",
"\n",
"# Check shapes after splitting\n",
"print(\"X_train shape:\", X_train.shape)\n",
"print(\"y_train shape:\", y_train.shape)\n",
"print(\"X_test shape:\", X_test.shape)\n",
"print(\"y_test shape:\", y_test.shape)\n",
"\n",
"# Train the Logistic Regression model\n",
"LR = LogisticRegression(random_state=42)\n",
"LR.fit(X_train, y_train)\n",
"\n",
"# Make predictions\n",
"y_pred = LR.predict(X_test)\n",
"\n",
"# Define the evaluation function\n",
"def evaluate_model(model_name, y_test, y_pred):\n",
" accuracy = accuracy_score(y_test, y_pred)\n",
" precision = precision_score(y_test, y_pred, average='weighted')\n",
" recall = recall_score(y_test, y_pred, average='weighted')\n",
" f1 = f1_score(y_test, y_pred, average='weighted')\n",
" cm = confusion_matrix(y_test, y_pred)\n",
" report = classification_report(y_test, y_pred)\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",
" 'Confusion Matrix': cm\n",
" }\n",
" return metrics\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(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 282,
"id": "a65c24c1-0df3-4010-ade6-89babf0c670d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"X shape: (5, 2)\n",
"y shape: (5,)\n",
"X_train shape: (3, 2)\n",
"y_train shape: (3,)\n",
"X_test shape: (2, 2)\n",
"y_test shape: (2,)\n",
"Model Name: \n",
"DecisionTreeClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n"
]
}
],
"source": [
"\n",
"# Example DataFrame\n",
"df = pd.DataFrame({\n",
" 'feature1': [1, 2, 3, 4, 5],\n",
" 'feature2': [5, 4, 3, 2, 1],\n",
" 'classification': [0, 1, 0, 1, 0]\n",
"})\n",
"\n",
"# Split into features (X) and target (y)\n",
"X = df.drop('classification', axis=1) # Features\n",
"y = df['classification'] # Target\n",
"\n",
"# Check shapes before splitting\n",
"print(\"X shape:\", X.shape)\n",
"print(\"y shape:\", y.shape)\n",
"\n",
"# Perform the data split\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42, stratify=y)\n",
"\n",
"# Check shapes after splitting\n",
"print(\"X_train shape:\", X_train.shape)\n",
"print(\"y_train shape:\", y_train.shape)\n",
"print(\"X_test shape:\", X_test.shape)\n",
"print(\"y_test shape:\", y_test.shape)\n",
"\n",
"# Train the Decision Tree Classifier\n",
"dt_classifier = DecisionTreeClassifier(random_state=42)\n",
"dt_classifier.fit(X_train, y_train)\n",
"\n",
"# Make predictions\n",
"y_pred = dt_classifier.predict(X_test)\n",
"\n",
"# Define the evaluation function\n",
"def evaluate_model(model_name, y_test, y_pred):\n",
" accuracy = accuracy_score(y_test, y_pred)\n",
" precision = precision_score(y_test, y_pred, average='weighted')\n",
" recall = recall_score(y_test, y_pred, average='weighted')\n",
" f1 = f1_score(y_test, y_pred, average='weighted')\n",
" cm = confusion_matrix(y_test, y_pred)\n",
" report = classification_report(y_test, y_pred)\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",
" 'Confusion Matrix': cm\n",
" }\n",
" return metrics\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(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 283,
"id": "5831715b-2500-4796-befa-89629a878e24",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"Support Vector Machine\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"SVM = SVC()\n",
"# Train the model\n",
"SVM.fit(X_train, y_train)\n",
"# Make predictions\n",
"y_pred = SVM.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('Support Vector Machine', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 285,
"id": "97961aa1-0a9e-4d6b-a275-e5a37d499e20",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"Support Vector Machine\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"gnb = GaussianNB()\n",
"# Train the model\n",
"gnb.fit(X_train, y_train)\n",
"# Make predictions\n",
"y_pred = gnb.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('Support Vector Machine', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 286,
"id": "f0061762-043b-4231-a128-079cf3cb4a2f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"sklearn.neighbors._classification.KNeighborsClassifier"
]
},
"execution_count": 286,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"KNeighborsClassifier\n"
]
},
{
"cell_type": "code",
"execution_count": 288,
"id": "947f2ca8-391f-41e4-ae89-0dc1cb516747",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"KNeighbors\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"knn = KNeighborsClassifier(n_neighbors=2)\n",
"knn.fit(X_train, y_train)\n",
"# Make predictions\n",
"y_pred = knn.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('KNeighbors', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")"
]
},
{
"cell_type": "code",
"execution_count": 290,
"id": "d96d84d2-7b37-41de-8613-85bb65290ac9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"classification\n",
"0 3\n",
"1 2\n",
"Name: count, dtype: int64"
]
},
"execution_count": 290,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data['classification'].value_counts()\n"
]
},
{
"cell_type": "code",
"execution_count": 292,
"id": "65b7c6d4-49b6-4a10-8b8f-225f8c4bf10e",
"metadata": {},
"outputs": [],
"source": [
"label_encoders = {}\n",
"for column in data.select_dtypes(include=['object']).columns:\n",
" le = LabelEncoder()\n",
" data[column] = le.fit_transform(data[column])\n",
" label_encoders[column] = le"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "04ceb48d-43c9-4257-8056-a6858aa83255",
"metadata": {},
"outputs": [],
"source": [
"X = data.drop('classification', axis=1).values # Replace 'classification' with you\n",
"y = data['classification'].values\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f6e2a147-a718-49d3-a2c7-95cd822ee813",
"metadata": {},
"outputs": [],
"source": [
"# Split data into training and testing sets\n",
"X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.30, random_state=42, stratify=y)\n"
]
},
{
"cell_type": "code",
"execution_count": 295,
"id": "85672975-ace1-4509-9b86-8dcec59ad6e3",
"metadata": {},
"outputs": [
{
"ename": "IndentationError",
"evalue": "unexpected indent (13719421.py, line 15)",
"output_type": "error",
"traceback": [
"\u001b[1;36m Cell \u001b[1;32mIn[295], line 15\u001b[1;36m\u001b[0m\n\u001b[1;33m metrics = {\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
]
}
],
"source": [
"def evaluate_model(model_name, y_true, y_pred):\n",
"\n",
" # Calculate metrics\n",
" accuracy = accuracy_score(y_true, y_pred)\n",
" precision = precision_score(y_true, y_pred, average='weighted')\n",
" recall = recall_score(y_true, y_pred, average='weighted')\n",
" f1 = f1_score(y_true, y_pred, average='weighted')\n",
" cm = confusion_matrix(y_true, y_pred)\n",
"\n",
" # Create a report\n",
"report = classification_report(y_true, y_pred)\n",
"\n",
"\n",
" # Output results\n",
" metrics = {\n",
" 'Model Name': model_name,\n",
" 'Accuracy': accuracy,\n",
" 'Precision': precision,\n",
" 'Recall': recall,\n",
" 'F1 Score': f1,\n",
"\n",
" 'Classification Report': report\n",
" }\n",
" # Plot Confusion Matrix\n",
" plt.figure(figsize=(4, 4))\n",
" sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False,\n",
" xticklabels=np.unique(y_true), yticklabels=np.unique(y_true))\n",
" plt.title(f'Confusion Matrix for {model_name}')\n",
" plt.xlabel('Predicted Label')\n",
" plt.ylabel('True Label')\n",
" plt.show()\n",
"\n",
" return metrics\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 307,
"id": "498e3800-e00e-4435-9037-4d08abfb2980",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"RandomForestClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}\n"
]
}
],
"source": [
"# Define the Random Forest Classifier\n",
"rf_classifier = RandomForestClassifier(random_state=42)\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'n_estimators': [100, 200, 300],\n",
" 'max_depth': [None, 10, 20, 30],\n",
" 'min_samples_split': [2, 5, 10],\n",
" 'min_samples_leaf': [1, 2, 4]\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=rf_classifier, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_rf_classifier = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_rf_classifier.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('RandomForestClassifier', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best parameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)"
]
},
{
"cell_type": "code",
"execution_count": 310,
"id": "0d3c601c-805a-4d1f-a60b-2cf5308e3005",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"LogisticRegression\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'C': 0.01, 'max_iter': 100, 'solver': 'liblinear'}\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py:540: FitFailedWarning: \n",
"24 fits failed out of a total of 48.\n",
"The score on these train-test partitions for these parameters will be set to nan.\n",
"If these failures are not expected, you can try to debug them by setting error_score='raise'.\n",
"\n",
"Below are more details about the failures:\n",
"--------------------------------------------------------------------------------\n",
"12 fits failed with the following error:\n",
"Traceback (most recent call last):\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py\", line 888, in _fit_and_score\n",
" estimator.fit(X_train, y_train, **fit_params)\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\base.py\", line 1473, in wrapper\n",
" return fit_method(estimator, *args, **kwargs)\n",
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py\", line 1276, in fit\n",
" self.coef_, self.intercept_, self.n_iter_ = _fit_liblinear(\n",
" ^^^^^^^^^^^^^^^\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\svm\\_base.py\", line 1173, in _fit_liblinear\n",
" raise ValueError(\n",
"ValueError: This solver needs samples of at least 2 classes in the data, but the data contains only one class: np.int64(0)\n",
"\n",
"--------------------------------------------------------------------------------\n",
"12 fits failed with the following error:\n",
"Traceback (most recent call last):\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py\", line 888, in _fit_and_score\n",
" estimator.fit(X_train, y_train, **fit_params)\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\base.py\", line 1473, in wrapper\n",
" return fit_method(estimator, *args, **kwargs)\n",
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py\", line 1301, in fit\n",
" raise ValueError(\n",
"ValueError: This solver needs samples of at least 2 classes in the data, but the data contains only one class: np.int64(0)\n",
"\n",
" warnings.warn(some_fits_failed_message, FitFailedWarning)\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:1103: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan]\n",
" warnings.warn(\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"# Define the Logistic Regression model\n",
"LR = LogisticRegression(random_state=42)\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'C': [0.01, 0.1, 1, 10], # Regularization strength\n",
" 'solver': ['liblinear', 'lbfgs'], # Solver type\n",
" 'max_iter': [100, 200, 300] # Maximum iterations for convergence\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=LR, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_LR = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_LR.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('LogisticRegression', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best hyperparameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)\n"
]
},
{
"cell_type": "code",
"execution_count": 315,
"id": "f5105324-624d-47bf-94fb-1603e09d015d",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"DecisionTreeClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'criterion': 'gini', 'max_depth': None, 'max_features': None, 'min_samples_leaf': 1, 'min_samples_split': 2}\n"
]
}
],
"source": [
"# Define the Decision Tree model\n",
"DT = DecisionTreeClassifier(random_state=42)\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'criterion': ['gini', 'entropy'], # The function to measure the qual\n",
" 'max_depth': [None, 10, 20, 30], # The maximum depth of the tree\n",
" 'min_samples_split': [2, 5, 10], # The minimum number of samples r\n",
" 'min_samples_leaf': [1, 2, 4], # The minimum number of samples r\n",
" 'max_features': [None, 'sqrt', 'log2'] # The number of features to consid\n",
"}\n",
"\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=DT, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_DT = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_DT.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('DecisionTreeClassifier', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best hyperparameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)"
]
},
{
"cell_type": "code",
"execution_count": 318,
"id": "3407e79b-266f-43dc-8655-21b5667e31a2",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"Support Vector Machine\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'C': 0.01, 'class_weight': None, 'degree': 3, 'gamma': 'scale', 'kernel': 'linear'}\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py:540: FitFailedWarning: \n",
"144 fits failed out of a total of 288.\n",
"The score on these train-test partitions for these parameters will be set to nan.\n",
"If these failures are not expected, you can try to debug them by setting error_score='raise'.\n",
"\n",
"Below are more details about the failures:\n",
"--------------------------------------------------------------------------------\n",
"144 fits failed with the following error:\n",
"Traceback (most recent call last):\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py\", line 888, in _fit_and_score\n",
" estimator.fit(X_train, y_train, **fit_params)\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\base.py\", line 1473, in wrapper\n",
" return fit_method(estimator, *args, **kwargs)\n",
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\svm\\_base.py\", line 199, in fit\n",
" y = self._validate_targets(y)\n",
" ^^^^^^^^^^^^^^^^^^^^^^^^^\n",
" File \"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\svm\\_base.py\", line 742, in _validate_targets\n",
" raise ValueError(\n",
"ValueError: The number of classes has to be greater than one; got 1 class\n",
"\n",
" warnings.warn(some_fits_failed_message, FitFailedWarning)\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:1103: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
" nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan]\n",
" warnings.warn(\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"# Define the Support Vector Machine model\n",
"SVM = SVC(random_state=42)\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'C': [0.01, 0.1, 1, 10], # Regularization parameter\n",
" 'kernel': ['linear', 'rbf', 'poly'], # Kernel type\n",
" 'gamma': ['scale', 'auto'], # Kernel coefficient for 'rbf', 'poly',\n",
" 'degree': [3, 4, 5], # Degree of the polynomial kernel funct\n",
" 'class_weight': [None, 'balanced'] # Weighing classes in the decision func\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=SVM, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_SVM = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_SVM.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('Support Vector Machine', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{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"
]
},
{
"cell_type": "code",
"execution_count": 320,
"id": "7ac59437-d172-4572-a26a-a81cfcc35dbe",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"Gaussian Naive Bayes\n",
"Accuracy: 0.5000\n",
"Precision: 0.2500\n",
"Recall: 0.5000\n",
"F1 Score: 0.3333\n",
" precision recall f1-score support\n",
"\n",
" 0 0.50 1.00 0.67 1\n",
" 1 0.00 0.00 0.00 1\n",
"\n",
" accuracy 0.50 2\n",
" macro avg 0.25 0.50 0.33 2\n",
"weighted avg 0.25 0.50 0.33 2\n",
"\n",
"Confusion Matrix: \n",
"[[1 0]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'var_smoothing': 1e-09}\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
" _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
]
}
],
"source": [
"# Define the Gaussian Naive Bayes model\n",
"gnb = GaussianNB()\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'var_smoothing': [1e-9, 1e-8, 1e-7, 1e-6] # Smoothing parameter\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=gnb, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_gnb = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_gnb.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('Gaussian Naive Bayes', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best hyperparameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)"
]
},
{
"cell_type": "code",
"execution_count": 322,
"id": "b54c79b9-70b1-4135-98c1-89ac54915de6",
"metadata": {
"collapsed": true,
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"K-Nearest Neighbors\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'algorithm': 'auto', 'metric': 'euclidean', 'n_neighbors': 1, 'weights': 'uniform'}\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:1103: UserWarning: One or more of the test scores are non-finite: [0.75 0.75 nan nan nan nan nan nan nan nan 0.75 0.75 nan nan\n",
" nan nan nan nan nan nan 0.75 0.75 nan nan nan nan nan nan\n",
" nan nan 0.75 0.75 nan nan nan nan nan nan nan nan 0.75 0.75\n",
" nan nan nan nan nan nan nan nan 0.75 0.75 nan nan nan nan\n",
" nan nan nan nan 0.75 0.75 nan nan nan nan nan nan nan nan\n",
" 0.75 0.75 nan nan nan nan nan nan nan nan]\n",
" warnings.warn(\n"
]
}
],
"source": [
"# Define the K-Nearest Neighbors model\n",
"knn = KNeighborsClassifier()\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'n_neighbors': [1, 3, 5, 7, 9], # Number of neighbors to use\n",
" 'weights': ['uniform', 'distance'], # Weight function used in prediction\n",
" 'metric': ['euclidean', 'manhattan'], # Distance metric\n",
" 'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute'] # Algorithm to compute\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=knn, param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train, y_train)\n",
"# Get the best estimator from grid search\n",
"best_knn = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_knn.predict(X_test)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('K-Nearest Neighbors', y_test, y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" if key == 'Classification Report':\n",
" print(value) # Print report separately for better readability\n",
" else:\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best hyperparameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "71829461-ce7b-4e2d-8b92-ea02ab1b136e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 323,
"id": "07051929-b04a-48ad-841e-cb211922ca26",
"metadata": {},
"outputs": [],
"source": [
"X = data.drop('classification', axis=1)\n",
"y = data['classification']"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "09ca2d30-4eff-40ed-b461-fc04db07ed69",
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
"test_size=0.2, random_state=42)\n"
]
},
{
"cell_type": "code",
"execution_count": 333,
"id": "364304e7-3575-4216-aa33-340510c5860f",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\feature_selection\\_univariate_selection.py:776: UserWarning: k=11 is greater than n_features=2. All the features will be returned.\n",
" warnings.warn(\n"
]
}
],
"source": [
"select_feature = SelectKBest(chi2,k=11).fit(X_train, y_train)\n"
]
},
{
"cell_type": "code",
"execution_count": 334,
"id": "dc969182-8add-4f8d-b990-c5f119b6d23c",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
feature1
\n",
"
feature2
\n",
"
classification
\n",
"
Feature
\n",
"
Score
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
1.0
\n",
"
5.0
\n",
"
0.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
1
\n",
"
2.0
\n",
"
4.0
\n",
"
1.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
2
\n",
"
3.0
\n",
"
3.0
\n",
"
0.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
3
\n",
"
4.0
\n",
"
2.0
\n",
"
1.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
4
\n",
"
5.0
\n",
"
1.0
\n",
"
0.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
0
\n",
"
NaN
\n",
"
NaN
\n",
"
NaN
\n",
"
feature1
\n",
"
1.0
\n",
"
\n",
"
\n",
"
1
\n",
"
NaN
\n",
"
NaN
\n",
"
NaN
\n",
"
feature2
\n",
"
0.8
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" feature1 feature2 classification Feature Score\n",
"0 1.0 5.0 0.0 NaN NaN\n",
"1 2.0 4.0 1.0 NaN NaN\n",
"2 3.0 3.0 0.0 NaN NaN\n",
"3 4.0 2.0 1.0 NaN NaN\n",
"4 5.0 1.0 0.0 NaN NaN\n",
"0 NaN NaN NaN feature1 1.0\n",
"1 NaN NaN NaN feature2 0.8"
]
},
"execution_count": 334,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\n",
"df = pd.DataFrame([])\n",
"data._append(pd.DataFrame({'Feature': X.columns, 'Score': select_feature .scores_}))"
]
},
{
"cell_type": "code",
"execution_count": 332,
"id": "6c894206-7da6-4a2d-8b12-b4939e3ce3e2",
"metadata": {},
"outputs": [],
"source": [
"X_train_selected = select_feature.transform(X_train)\n",
"X_test_selected = select_feature.transform(X_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3222a7cb-fe01-4ece-9832-153dc29860e1",
"metadata": {},
"outputs": [],
"source": [
"def evaluate_model(model_name, y_true, y_pred):\n",
"\n",
" # Calculate metrics\n",
" accuracy = accuracy_score(y_true, y_pred)\n",
" precision = precision_score(y_true, y_pred, average='weighted')\n",
" recall = recall_score(y_true, y_pred, average='weighted')\n",
" f1 = f1_score(y_true, y_pred, average='weighted')\n",
" # Output results\n",
" metrics = {\n",
" 'Model Name': model_name,\n",
" 'Accuracy': accuracy,\n",
" 'Precision': precision,\n",
" 'Recall': recall,\n",
" 'F1 Score': f1,\n",
"\n",
"\n",
" }\n",
"\n",
" return metrics"
]
},
{
"cell_type": "code",
"execution_count": 344,
"id": "859e1f16-1c8f-4df5-87fb-bd8f39efe4f9",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"RandomForestClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
"Classification Report: \n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}\n"
]
}
],
"source": [
"from sklearn.ensemble import RandomForestClassifier\n",
"from sklearn.model_selection import GridSearchCV\n",
"from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix\n",
"\n",
"# Ensure X_train_selected, y_train, X_test_selected, y_test are already defined\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",
" 'min_samples_split': [2, 5, 10],\n",
" 'min_samples_leaf': [1, 2, 4]\n",
"}\n",
"\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=rf_classifier,\n",
" param_grid=param_grid, \n",
" cv=2, \n",
" scoring='accuracy', \n",
" n_jobs=-1)\n",
"\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train_selected, 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_selected)\n",
"\n",
"# Define the evaluation function\n",
"def evaluate_model(model_name, y_test, y_pred):\n",
" accuracy = accuracy_score(y_test, y_pred)\n",
" precision = precision_score(y_test, y_pred, average='weighted')\n",
" recall = recall_score(y_test, y_pred, average='weighted')\n",
" f1 = f1_score(y_test, y_pred, average='weighted')\n",
" cm = confusion_matrix(y_test, y_pred)\n",
" report = classification_report(y_test, y_pred)\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",
" 'Confusion Matrix': cm\n",
" }\n",
" return metrics\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",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{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"
]
},
{
"cell_type": "code",
"execution_count": 345,
"id": "83cee6c1-f08a-4a4c-b7e3-98689747e22d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Selected Features (RFE): [0 1]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\feature_selection\\_rfe.py:291: UserWarning: Found n_features_to_select=8 > n_features=2. There will be no feature selection and all features will be kept.\n",
" warnings.warn(\n"
]
}
],
"source": [
"from sklearn.feature_selection import RFE\n",
"clf_rf_2 = RandomForestClassifier(random_state=43)\n",
"X_train_selected_rfe = rfe_selector.fit_transform(X_train, y_train)\n",
"X_test_selected_rfe = rfe_selector.transform(X_test)\n",
"# Get the selected feature indices\n",
"selected_features = rfe_selector.get_support(indices=True)\n",
"print(\"Selected Features (RFE):\", selected_features)\n"
]
},
{
"cell_type": "code",
"execution_count": 351,
"id": "cb4aca11-a38b-43a6-a958-76b170d0c755",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\HP\\anaconda3\\envs\\Finalproject\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=2.\n",
" warnings.warn(\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model Name: \n",
"RandomForestClassifier\n",
"Accuracy: 0.0000\n",
"Precision: 0.0000\n",
"Recall: 0.0000\n",
"F1 Score: 0.0000\n",
"Classification Report: \n",
" precision recall f1-score support\n",
"\n",
" 0 0.00 0.00 0.00 1.0\n",
" 1 0.00 0.00 0.00 1.0\n",
"\n",
" accuracy 0.00 2.0\n",
" macro avg 0.00 0.00 0.00 2.0\n",
"weighted avg 0.00 0.00 0.00 2.0\n",
"\n",
"Confusion Matrix: \n",
"[[0 1]\n",
" [1 0]]\n",
"\n",
"Best hyperparameters found by GridSearchCV:\n",
"{'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}\n"
]
}
],
"source": [
"# Define the Random Forest Classifier\n",
"rf_classifier = RandomForestClassifier(random_state=42)\n",
"# Define the hyperparameters for grid search\n",
"param_grid = {\n",
" 'n_estimators': [100, 200, 300],\n",
" 'max_depth': [None, 10, 20, 30],\n",
" 'min_samples_split': [2, 5, 10],\n",
" 'min_samples_leaf': [1, 2, 4]\n",
"}\n",
"# Initialize GridSearchCV\n",
"grid_search = GridSearchCV(estimator=rf_classifier,\n",
"param_grid=param_grid, cv=2, scoring='accuracy', n_jobs=-1)\n",
"# Fit the grid search to the data\n",
"grid_search.fit(X_train_selected_rfe, y_train)\n",
"# Get the best estimator from grid search\n",
"best_rf_classifier = grid_search.best_estimator_\n",
"# Make predictions using the best model\n",
"y_pred = best_rf_classifier.predict(X_test_selected_rfe)\n",
"# Evaluate the model\n",
"evaluation_results = evaluate_model('RandomForestClassifier', y_test,\n",
"y_pred)\n",
"# Print the evaluation results\n",
"for key, value in evaluation_results.items():\n",
" print(f\"{key}: {value:.4f}\" if isinstance(value, float) else f\"{key}: \\n{value}\")\n",
"# Print the best parameters found by grid search\n",
"print(\"\\nBest hyperparameters found by GridSearchCV:\")\n",
"print(grid_search.best_params_)\n"
]
},
{
"cell_type": "code",
"execution_count": 352,
"id": "c0c008df-2525-4d69-acb9-38c58a217ce8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"X_train shape: (70, 5)\n",
"X_test shape: (30, 5)\n",
"y_train shape: (70,)\n",
"y_test shape: (30,)\n"
]
}
],
"source": [
"\n",
"\n",
"\n",
"\n",
"\n",
"# Example data\n",
"X = np.random.rand(100, 5) # 100 samples, 5 features\n",
"y = np.random.randint(0, 2, size=100) # Binary classification labels (0 or 1)\n",
"\n",
"# Split data into training and testing sets\n",
"X_train, X_test, y_train, y_test = train_test_split(\n",
" X, y, test_size=0.30, random_state=42, stratify=y\n",
")\n",
"\n",
"# Verify the shapes of the splits\n",
"print(\"X_train shape:\", X_train.shape)\n",
"print(\"X_test shape:\", X_test.shape)\n",
"print(\"y_train shape:\", y_train.shape)\n",
"print(\"y_test shape:\", y_test.shape)\n",
"\n",
"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 63,
"id": "48a98aa5-1fdf-4907-bc88-0d40cd6b3bb2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(569, 30)"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_df.shape"
]
},
{
"cell_type": "code",
"execution_count": 68,
"id": "18560721-f1a0-465b-b805-73a5b82d203f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(455, 30) (455,) (114, 30) (114,)\n"
]
}
],
"source": [
"X_train,X_test,Y_train,Y_test = train_test_split(X_df,Y_df,train_size = 0.8)\n",
"print(X_train.shape, Y_train.shape, X_test.shape, Y_test.shape)"
]
},
{
"cell_type": "code",
"execution_count": 69,
"id": "e1f527c2-0939-4f17-8b48-1d41e6c2f262",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.