diff --git a/PULL_REQUEST_TEMPLATE.md b/PULL_REQUEST_TEMPLATE.md index 4b4d87f..769c437 100644 --- a/PULL_REQUEST_TEMPLATE.md +++ b/PULL_REQUEST_TEMPLATE.md @@ -8,17 +8,15 @@ Closes # ## Task Summary -Provide a brief overview of your implementation. - -- What did you implement? -- What approach did you follow? +- **What did you implement?** Implemented an unsupervised anomaly detection system using the Isolation Forest algorithm to flag anomalous shuttle flights. +- **What approach did you follow?** Followed an experimental approach: established a baseline with default parameters, analyzed the see-saw trade-off between Precision and Recall by adjusting strictness parameters, tested feature scaling, and ultimately executed an automated Grid Search to locate the optimal safety configuration. --- ## Dataset - [ ] Mammography -- [ ] Shuttle +- [x] Shuttle Dataset Source: @@ -26,27 +24,22 @@ Dataset Source: ## Preprocessing -Describe any preprocessing performed. - -Examples: -- Missing value handling -- Feature scaling -- Encoding -- Feature selection +- There were no missing values in the dataset. +- **Feature Scaling Evaluation:** We integrated data standardization using `StandardScaler` to evaluate the model's sensitivity to feature magnitudes. The experiments successfully validated that the Isolation Forest algorithm is inherently scale-invariant. Because the model relies on recursive, axis-aligned isolation trees rather than geometric distance metrics, scaling preserves the exact relative separation paths of the anomalies. This is an exceptional characteristic for our pipeline, as it proves the model achieves peak predictive performance with reduced preprocessing overhead. --- ## Model Configuration -List the important hyperparameters used. +*(For best "Safety-First" model)* | Hyperparameter | Value | |---------------|-------| -| n_estimators | | -| contamination | | -| max_samples | | -| max_features | | -| random_state | | +| n_estimators | 100 | +| contamination | 0.50 | +| max_samples | 256 | +| max_features | 1.0 | +| random_state | 42 | --- @@ -54,44 +47,39 @@ List the important hyperparameters used. | Metric | Value | |--------|-------| -| Precision | | -| Recall | | -| F1-score | | -| ROC-AUC (Optional) | | +| Precision | 0.40 | +| Recall | 0.94 | +| F1-score | 0.56 | + --- ## Visualizations -Attach **at least 2 plots** from your analysis. +**Confusion Matrix — Best Safety Model** -Examples: -- PCA visualization -- Anomaly score distribution -- Confusion Matrix -- Correlation heatmap -- Feature distributions -- Hyperparameter comparison -- Precision/Recall/F1 comparison +![Confusion Matrix](./confusion_matrix.png) + +**Impact of Contamination Threshold on Anomaly Recall** + +![Hyperparameter Impact](./hyperparameter_impact.png) --- ## Key Observations -Briefly summarize: - -- What worked well? -- Which hyperparameter had the biggest impact? -- Any interesting findings? -- Challenges faced (if any) +- **What worked well?** Increasing the `contamination` parameter significantly expanded the classification envelope, maximizing our Recall to 0.94 (catching 94% of shuttle system anomalies). +- **Which hyperparameter had the biggest impact?** `contamination` had the absolute biggest impact on shifting the see-saw balance between precision and recall. +- **Any interesting findings?** Increasing `n_estimators` beyond 200–300 resulted in diminishing returns and minor score degradation due to algorithmic plateauing. Furthermore, setting `contamination` too high combined with tiny sample sizes caused "swamping," where normal data points overwhelmed the trees' ability to isolate actual anomalies. +- **Challenges faced:** Overcoming short-term memory clears when switching kernel environments in VS Code, requiring structured notebook tracking. --- ## Checklist -- [ ] Code runs successfully -- [ ] Notebook (`.ipynb`) included -- [ ] Code is well-commented -- [ ] README/documentation updated -- [ ] At least **2 plots** included -- [ ] PR is linked to the corresponding issue \ No newline at end of file +- [x] Code runs successfully +- [x] Notebook (`.ipynb`) included +- [x] Code is well-commented +- [x] README/documentation updated +- [x] At least **2 plots** included +- [x] PR is linked to the corresponding issue diff --git a/README.md b/README.md index 6ffbc84..ac64b59 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,118 @@ -# CogniOS – Tasks +DIFFERENT CASES USED +1- +iso_forest = IsolationForest( +contamination =0.4, +max_samples = 256, +random_state=42, +max_features = 1.0 , +n_estimators = 120) -This branch contains tasks designed to help contributors learn the concepts and technologies used in CogniOS before contributing to the main project. +Classification Report: + precision recall f1-score support -## Workflow + -1 0.45 0.84 0.59 12414 + 1 0.94 0.72 0.82 45586 -1. Check your assigned GitHub issue. -2. Create a new branch from `Tasks`. -3. Complete the assigned task. -4. Open a Pull Request **to the `Tasks` branch**. -5. Mention `Closes #` in your PR description. +2- +iso_forest = IsolationForest( +contamination =0.4, +max_samples = 400, +random_state=42, +max_features = 1.0 , +n_estimators = 200) -Please follow the repository's Pull Request template while submitting your solution. +Classification Report: + precision recall f1-score support -Happy learning! \ No newline at end of file + -1 0.43 0.81 0.56 12414 + 1 0.93 0.71 0.81 45586 + + +3-(using standard values) +iso_forest = IsolationForest( +contamination =0.4, +max_samples = 256, +random_state=42, +max_features = 1.0 , +n_estimators = 100) + +Classification Report: + precision recall f1-score support + + -1 0.46 0.86 0.60 12414 + 1 0.95 0.73 0.82 45586 + + + 4-(assuming most amount of contamination) + (most recall obtained) + iso_forest = IsolationForest( +contamination =0.5, +max_samples = 256, +random_state=42, +max_features = 1.0 , +n_estimators = 100) + +Classification Report: + precision recall f1-score support + + -1 0.40 0.94 0.56 12414 + 1 0.97 0.62 0.76 45586 + +5 - (actual amount of contamination) +iso_forest = IsolationForest( +contamination =0.21, +max_samples = 256, +random_state=42, +max_features = 1.0 , +n_estimators = 100) + +Classification Report: + precision recall f1-score support + + -1 0.54 0.53 0.54 12414 + 1 0.87 0.88 0.88 45586 + + +6 - (inc no of trres anfd reducing samples ) + +iso_forest = IsolationForest( +contamination =0.5, +max_samples = 100, +random_state=42, +max_features = 1.0 , +n_estimators = 400) + +Classification Report: + precision recall f1-score support + + -1 0.37 0.86 0.52 12414 + 1 0.94 0.60 0.73 45586 + +7- + +iso_forest = IsolationForest( +contamination =0.5, +max_samples = 50, +random_state=42, +max_features = 1.0 , +n_estimators = 290) + + precision recall f1-score support + + -1 0.38 0.89 0.53 12414 + 1 0.95 0.61 0.74 45586 + + +8 -- +contamination =0.5, +max_samples = 50, +random_state=42, +max_features = 1.0 , +n_estimators = 400) + +Classification Report: + precision recall f1-score support + + -1 0.38 0.88 0.53 12414 + 1 0.95 0.60 0.74 45586 + diff --git a/images/confusion_matrix.png b/images/confusion_matrix.png new file mode 100644 index 0000000..e939218 Binary files /dev/null and b/images/confusion_matrix.png differ diff --git a/images/hyperparameter_impact.png b/images/hyperparameter_impact.png new file mode 100644 index 0000000..28d4182 Binary files /dev/null and b/images/hyperparameter_impact.png differ diff --git a/notebooks/notebook.ipynb b/notebooks/notebook.ipynb new file mode 100644 index 0000000..f8e3329 --- /dev/null +++ b/notebooks/notebook.ipynb @@ -0,0 +1,825 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "cb920b2a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fetching dataset from OpenML... (this might take a few seconds)\n", + "Data successfully loaded!\n", + "Dataset shape: (58000, 9)\n" + ] + } + ], + "source": [ + "# Bypass the Mac SSL certificate verification error\n", + "import ssl\n", + "ssl._create_default_https_context = ssl._create_unverified_context\n", + "\n", + "import pandas as pd\n", + "from sklearn.datasets import fetch_openml\n", + "\n", + "# Fetching the Shuttle dataset from OpenML\n", + "print(\"Fetching dataset from OpenML... (this might take a few seconds)\")\n", + "shuttle_data = fetch_openml(name='shuttle', version=1, as_frame=True, parser='auto')\n", + "\n", + "#features (X), target labels (y)\n", + "X = shuttle_data.frame.drop('class', axis=1) \n", + "y = shuttle_data.frame['class'] \n", + "\n", + "print(\"Data successfully loaded!\")\n", + "print(f\"Dataset shape: {X.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9f5bcb6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing values in each column:\n", + "A1 0\n", + "A2 0\n", + "A3 0\n", + "A4 0\n", + "A5 0\n", + "A6 0\n", + "A7 0\n", + "A8 0\n", + "A9 0\n", + "dtype: int64\n", + "\n", + "Target label distribution:\n", + "class\n", + "1 45586\n", + "4 8903\n", + "5 3267\n", + "3 171\n", + "2 50\n", + "7 13\n", + "6 10\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# 1. Check for missing values in our features\n", + "print(\"Missing values in each column:\")\n", + "print(X.isnull().sum())\n", + "\n", + "# 2. Check the distribution of our labels (how many of each class exist)\n", + "print(\"\\nTarget label distribution:\")\n", + "print(y.value_counts())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ae40b7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Old labels:\n", + " class\n", + "1 45586\n", + "4 8903\n", + "5 3267\n", + "Name: count, dtype: int64\n", + "\n", + "New binary labels (1 = Normal, -1 = Anomaly):\n", + "class\n", + " 1 45586\n", + "-1 12414\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "#for cross checking our output \n", + "# Create a new target label list (y_binary) , If the original class is '1', we keep it as 1 (Normal)\n", + "# #If it is anything else, we label it as -1 (Anomaly)\n", + "y_binary = y.apply(lambda val: 1 if val == '1' else -1)\n", + "\n", + "print(\"Old labels:\\n\", y.value_counts().head(3)) # Showing just a few old ones\n", + "print(\"\\nNew binary labels (1 = Normal, -1 = Anomaly):\")\n", + "print(y_binary.value_counts())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2ded58e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building and training the Isolation Forest model...\n", + "Model training and predictions complete!\n" + ] + } + ], + "source": [ + "from sklearn.ensemble import IsolationForest\n", + "\n", + "# 1. Create the Isolation Forest model\n", + "# 'contamination' = anamolous data\n", + "# here, 21% contamination\n", + "print(\"Building and training the Isolation Forest model...\")\n", + "iso_forest = IsolationForest(\n", + "contamination =0.5,\n", + "max_samples = 256, \n", + "random_state=42,\n", + "max_features = 1.0 , \n", + "n_estimators = 100)\n", + "\n", + "# Training the model ONLY on the raw features (X), hiding the answers\n", + "iso_forest.fit(X)\n", + "\n", + "predictions = iso_forest.predict(X)\n", + "\n", + "print(\"Model training and predictions complete!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81ae63eb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scaling the features...\n", + "Running Experiment 3 (With Feature Scaling)...\n", + "\n", + "Classification Report (With Feature Scaling):\n", + " precision recall f1-score support\n", + "\n", + " -1 0.40 0.94 0.56 12414\n", + " 1 0.97 0.62 0.76 45586\n", + "\n", + " accuracy 0.69 58000\n", + " macro avg 0.69 0.78 0.66 58000\n", + "weighted avg 0.85 0.69 0.71 58000\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# applying scalar\n", + "print(\"Scaling the features...\")\n", + "scaler = StandardScaler()\n", + "\n", + "# Transform the raw data (X) into scaled data (X_scaled)\n", + "X_scaled = scaler.fit_transform(X)\n", + "\n", + "# Run the model but with X_scaled\n", + "print(\"Running Experiment 3 (With Feature Scaling)...\")\n", + "iso_scaled = IsolationForest(n_estimators=100, contamination=0.50, random_state=42)\n", + "iso_scaled.fit(X_scaled)\n", + "\n", + "# Get predictions using the scaled data\n", + "predictions_scaled = iso_scaled.predict(X_scaled)\n", + "\n", + "# Print the report\n", + "print(\"\\nClassification Report (With Feature Scaling):\")\n", + "print(classification_report(y_binary, predictions_scaled))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c03cb573", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting automated Grid Search... This might take a moment.\n", + "Grid Search Complete! Here are your results sorted by highest Recall:\n" + ] + }, + { + "data": { + "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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ContaminationMax SamplesTrees (n_estimators)Anomaly PrecisionAnomaly RecallAnomaly F1-Score
00.502561000.400.940.56
10.502562000.390.910.54
20.502563000.380.890.54
30.50503000.380.890.53
40.50502000.380.890.53
50.501001000.380.880.53
60.50501000.380.880.53
70.501002000.370.860.51
80.402561000.460.860.60
90.501003000.360.850.51
100.402562000.440.830.58
110.402563000.440.810.57
120.40502000.430.800.56
130.401001000.430.800.55
140.40503000.430.800.56
150.40501000.430.800.55
160.401002000.420.780.54
170.401003000.420.780.54
180.302561000.510.710.59
190.302562000.500.700.58
200.301001000.500.700.58
210.30501000.500.700.58
220.302563000.500.700.58
230.30503000.500.700.58
240.30502000.490.690.57
250.301003000.490.690.57
260.301002000.490.680.57
270.21503000.600.590.60
280.21502000.590.580.58
290.21501000.600.580.59
300.211003000.580.570.57
310.211001000.580.570.57
320.211002000.570.560.56
330.212563000.560.550.56
340.212562000.560.550.55
350.212561000.540.530.54
\n", + "
" + ], + "text/plain": [ + " Contamination Max Samples Trees (n_estimators) Anomaly Precision \\\n", + "0 0.50 256 100 0.40 \n", + "1 0.50 256 200 0.39 \n", + "2 0.50 256 300 0.38 \n", + "3 0.50 50 300 0.38 \n", + "4 0.50 50 200 0.38 \n", + "5 0.50 100 100 0.38 \n", + "6 0.50 50 100 0.38 \n", + "7 0.50 100 200 0.37 \n", + "8 0.40 256 100 0.46 \n", + "9 0.50 100 300 0.36 \n", + "10 0.40 256 200 0.44 \n", + "11 0.40 256 300 0.44 \n", + "12 0.40 50 200 0.43 \n", + "13 0.40 100 100 0.43 \n", + "14 0.40 50 300 0.43 \n", + "15 0.40 50 100 0.43 \n", + "16 0.40 100 200 0.42 \n", + "17 0.40 100 300 0.42 \n", + "18 0.30 256 100 0.51 \n", + "19 0.30 256 200 0.50 \n", + "20 0.30 100 100 0.50 \n", + "21 0.30 50 100 0.50 \n", + "22 0.30 256 300 0.50 \n", + "23 0.30 50 300 0.50 \n", + "24 0.30 50 200 0.49 \n", + "25 0.30 100 300 0.49 \n", + "26 0.30 100 200 0.49 \n", + "27 0.21 50 300 0.60 \n", + "28 0.21 50 200 0.59 \n", + "29 0.21 50 100 0.60 \n", + "30 0.21 100 300 0.58 \n", + "31 0.21 100 100 0.58 \n", + "32 0.21 100 200 0.57 \n", + "33 0.21 256 300 0.56 \n", + "34 0.21 256 200 0.56 \n", + "35 0.21 256 100 0.54 \n", + "\n", + " Anomaly Recall Anomaly F1-Score \n", + "0 0.94 0.56 \n", + "1 0.91 0.54 \n", + "2 0.89 0.54 \n", + "3 0.89 0.53 \n", + "4 0.89 0.53 \n", + "5 0.88 0.53 \n", + "6 0.88 0.53 \n", + "7 0.86 0.51 \n", + "8 0.86 0.60 \n", + "9 0.85 0.51 \n", + "10 0.83 0.58 \n", + "11 0.81 0.57 \n", + "12 0.80 0.56 \n", + "13 0.80 0.55 \n", + "14 0.80 0.56 \n", + "15 0.80 0.55 \n", + "16 0.78 0.54 \n", + "17 0.78 0.54 \n", + "18 0.71 0.59 \n", + "19 0.70 0.58 \n", + "20 0.70 0.58 \n", + "21 0.70 0.58 \n", + "22 0.70 0.58 \n", + "23 0.70 0.58 \n", + "24 0.69 0.57 \n", + "25 0.69 0.57 \n", + "26 0.68 0.57 \n", + "27 0.59 0.60 \n", + "28 0.58 0.58 \n", + "29 0.58 0.59 \n", + "30 0.57 0.57 \n", + "31 0.57 0.57 \n", + "32 0.56 0.56 \n", + "33 0.55 0.56 \n", + "34 0.55 0.55 \n", + "35 0.53 0.54 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn.ensemble import IsolationForest\n", + "from sklearn.metrics import precision_score, recall_score, f1_score\n", + "\n", + "# 1. Define the grid of hyperparameter values you want to test\n", + "contaminations = [0.21, 0.30, 0.40, 0.50]\n", + "max_samples_list = [50, 100, 256]\n", + "n_estimators_list = [100, 200, 300]\n", + "\n", + "# Create an empty list to store the results of each experiment\n", + "results_log = []\n", + "\n", + "print(\"Starting automated Grid Search... This might take a moment.\")\n", + "\n", + "# 2. The Nested Loops: This will try every possible combination automatically\n", + "for cont in contaminations:\n", + " for samples in max_samples_list:\n", + " for trees in n_estimators_list:\n", + " \n", + " # Initialize the model with the current combination of dials\n", + " model = IsolationForest(\n", + " contamination=cont,\n", + " max_samples=samples,\n", + " n_estimators=trees,\n", + " random_state=42\n", + " )\n", + " \n", + " # Train and predict\n", + " model.fit(X)\n", + " preds = model.predict(X)\n", + " \n", + " # Automatically extract the exact scores for the Anomaly class (-1)\n", + " # pos_label=-1 tells scikit-learn that -1 is our target success metric\n", + " prec = precision_score(y_binary, preds, pos_label=-1)\n", + " rec = recall_score(y_binary, preds, pos_label=-1)\n", + " f1 = f1_score(y_binary, preds, pos_label=-1)\n", + " \n", + " # Save these results into a dictionary\n", + " results_log.append({\n", + " 'Contamination': cont,\n", + " 'Max Samples': samples,\n", + " 'Trees (n_estimators)': trees,\n", + " 'Anomaly Precision': round(prec, 2),\n", + " 'Anomaly Recall': round(rec, 2),\n", + " 'Anomaly F1-Score': round(f1, 2)\n", + " })\n", + "\n", + "# summary table\n", + "df_results = pd.DataFrame(results_log)\n", + "\n", + "# Sorting the table so the highest Recall scores are at the very top\n", + "df_results = df_results.sort_values(by='Anomaly Recall', ascending=False).reset_index(drop=True)\n", + "\n", + "print(\"Grid Search Complete! Here are your results sorted by highest Recall:\")\n", + "display(df_results)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dbd883f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/91/gp_cg6c55wngxsffgnqvhy_40000gn/T/ipykernel_5884/3998824268.py:22: FutureWarning: \n", + "\n", + "The `ci` parameter is deprecated. Use `errorbar=None` for the same effect.\n", + "\n", + " sns.lineplot(data=df_results, x='Contamination', y='Anomaly Recall', marker='o', ci=None)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", + "\n", + "best_model = IsolationForest(contamination=0.5, max_samples=256, n_estimators=100, random_state=42)\n", + "best_model.fit(X)\n", + "best_preds = best_model.predict(X)\n", + "\n", + "# --- PLOT 1: Confusion Matrix ---\n", + "plt.figure(figsize=(6, 5))\n", + "cm = confusion_matrix(y_binary, best_preds, labels=[1, -1])\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Normal (1)', 'Anomaly (-1)'])\n", + "disp.plot(cmap='Blues', values_format='d')\n", + "plt.title(\"Confusion Matrix: Best Safety Model\")\n", + "plt.savefig(\"confusion_matrix.png\")\n", + "plt.show()\n", + "\n", + "# --- PLOT 2: Hyperparameter Impact (Contamination vs Recall) ---\n", + "# This uses the df_results DataFrame from your automated grid search loop!\n", + "plt.figure(figsize=(8, 5))\n", + "sns.lineplot(data=df_results, x='Contamination', y='Anomaly Recall', marker='o', ci=None)\n", + "plt.title(\"Impact of Contamination Threshold on Anomaly Recall\")\n", + "plt.xlabel(\"Contamination Rate Factor\")\n", + "plt.ylabel(\"Recall Score (Higher = Caught More)\")\n", + "plt.grid(True)\n", + "plt.savefig(\"hyperparameter_impact.png\") # Saves the image to your VS Code folder\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40874553", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..619913c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +pandas +numpy +scikit-learn +matplotlib +seaborn +ipykernel \ No newline at end of file