From 8dc776e023cdab604335ce11930698d23a0397c0 Mon Sep 17 00:00:00 2001 From: AyeshaK <124094029+Arrowhorse@users.noreply.github.com> Date: Mon, 20 Oct 2025 09:46:04 -0400 Subject: [PATCH] Add Chicago Crime Data Analysis notebook --- Chicago Crime Data Analysis.ipynb | 522 ++++++++++++++++++++++++++++++ 1 file changed, 522 insertions(+) create mode 100644 Chicago Crime Data Analysis.ipynb diff --git a/Chicago Crime Data Analysis.ipynb b/Chicago Crime Data Analysis.ipynb new file mode 100644 index 0000000..1895222 --- /dev/null +++ b/Chicago Crime Data Analysis.ipynb @@ -0,0 +1,522 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d4061a35-58cc-4116-bd50-39149059348d", + "metadata": {}, + "outputs": [], + "source": [ + "# Data I'm usimg:\n", + "# City of Chicago's Public Crime Data: https://data.cityofchicago.org/Public-Safety/Crimes-2001-to-Present/ijzp-q8t2/about_data\n", + "# There are about 8.34 million records from 2001 to last week. The report is updated every day. \n", + "\n", + "# Variables: ID, Case Number, Date, Block, IUCR (The Illinois Uniform Crime Reporting code), Primary Type, Description, Location Description, Arrest\n", + "# Variables Cont: Domestic, Beat, District, Ward, Community Area, FBI Code, X Coordinate, Y Coordinate, Year, Updated On, Latitude, Longitude, Location\n", + "# Types: Number, Text, Floating Timestamp, Checkbox\n", + "\n", + "# Data Preparation: Removed irrelevant columns and columns with missing or null values.\n", + "# Data Prep Part 2: Converted Date to datetime for later analysis and saved time features for trend analysis\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import time\n", + "\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.tree import DecisionTreeClassifier, plot_tree\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import SVC\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, ConfusionMatrixDisplay\n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.metrics import silhouette_score\n", + "from yellowbrick.cluster import KElbowVisualizer\n", + "from sklearn.decomposition import PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3568c835-7e2d-4a36-a0ff-953c63dfcef5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 8335148 entries, 0 to 8335147\n", + "Data columns (total 22 columns):\n", + " # Column Dtype \n", + "--- ------ ----- \n", + " 0 ID int64 \n", + " 1 Case Number object \n", + " 2 Date object \n", + " 3 Block object \n", + " 4 IUCR object \n", + " 5 Primary Type object \n", + " 6 Description object \n", + " 7 Location Description object \n", + " 8 Arrest bool \n", + " 9 Domestic bool \n", + " 10 Beat int64 \n", + " 11 District float64\n", + " 12 Ward float64\n", + " 13 Community Area float64\n", + " 14 FBI Code object \n", + " 15 X Coordinate float64\n", + " 16 Y Coordinate float64\n", + " 17 Year int64 \n", + " 18 Updated On object \n", + " 19 Latitude float64\n", + " 20 Longitude float64\n", + " 21 Location object \n", + "dtypes: bool(2), float64(7), int64(3), object(10)\n", + "memory usage: 1.3+ GB\n" + ] + } + ], + "source": [ + "df = pd.read_csv(\"C:/Users/Ayesh/Downloads/chicago_crime.csv\")\n", + "\n", + "df.shape\n", + "df.head()\n", + "df.columns\n", + "df.info()\n", + "df.describe(include='all')\n", + "\n", + "df.isnull().sum()\n", + "\n", + "df = df[['Date', 'Primary Type', 'Location Description', 'Arrest', 'Community Area', 'Latitude', 'Longitude']]\n", + "\n", + "df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n", + "df = df.dropna(subset=['Primary Type', 'Date', 'Community Area', 'Latitude', 'Longitude'])\n", + "\n", + "df['Hour'] = df['Date'].dt.hour\n", + "df['DayOfWeek'] = df['Date'].dt.day_name()\n", + "df['Month'] = df['Date'].dt.month\n", + "df['Year'] = df['Date'].dt.year" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "42330976-5d59-4c96-8df8-f1f3e38954e1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Ayesh\\AppData\\Local\\Temp\\ipykernel_6484\\1729047733.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=top_crimes.values, y=top_crimes.index, palette=\"magma\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot top 10 highest types of crime\n", + "df.head()\n", + "top_crimes = df['Primary Type'].value_counts().head(10)\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(x=top_crimes.values, y=top_crimes.index, palette=\"magma\")\n", + "plt.title(\"Top 10 Most Common Crimes in Chicago\")\n", + "plt.xlabel(\"Number of Reports\")\n", + "plt.ylabel(\"Crime Type\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "top5 = ['Theft', 'Battery', 'Criminal Damage', 'Narcotics', 'Assault']\n", + "df = df[df['Primary Type'].isin(top5)]\n", + "\n", + "# Results of plot: \n", + "# The top 10 most common crime types are: Theft, Battery, Criminal Damage, Narcotics, Assault, Other Offense, Burglary, \n", + "# Motor Vehicle Theft, Deceptive Practice, and Robbery. I'm only keeping the top 5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ca5c4a11-b4df-4b02-bfcd-7e60ca494e85", + "metadata": {}, + "outputs": [], + "source": [ + "df['Hour'] = df['Date'].dt.hour\n", + "df['DayOfWeek'] = df['Date'].dt.day_name()\n", + "df['Month'] = df['Date'].dt.month\n", + "\n", + "# Define season\n", + "def get_season(month):\n", + " if month in [12, 1, 2]:\n", + " return 'Winter'\n", + " elif month in [3, 4, 5]:\n", + " return 'Spring'\n", + " elif month in [6, 7, 8]:\n", + " return 'Summer'\n", + " else:\n", + " return 'Fall'\n", + "df['Season'] = df['Month'].apply(get_season)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5f205cd6-948d-4813-b940-deb1c9ede721", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.countplot(data=df, x='Hour', palette='coolwarm')\n", + "plt.title(\"Crime Frequency by Hour\")\n", + "plt.show()\n", + "\n", + "sns.countplot(data=df, x='DayOfWeek', order=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday'], palette='pastel')\n", + "plt.title(\"Crime Frequency by Day of Week\")\n", + "plt.xticks(rotation=45)\n", + "plt.show()\n", + "\n", + "sns.countplot(data=df, x='Season', palette='Set2')\n", + "plt.title(\"Crime Frequency by Season\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cad0760d-91df-4dc0-8356-3f41f3ad4722", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "With n_samples=0, test_size=0.2 and train_size=None, the resulting train set will be empty. Adjust any of the aforementioned parameters.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 18\u001b[39m\n\u001b[32m 15\u001b[39m X = df[features]\n\u001b[32m 16\u001b[39m y = df[\u001b[33m'\u001b[39m\u001b[33mCrime_Code\u001b[39m\u001b[33m'\u001b[39m]\n\u001b[32m---> \u001b[39m\u001b[32m18\u001b[39m X_train, X_test, y_train, y_test = \u001b[43mtrain_test_split\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m42\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstratify\u001b[49m\u001b[43m=\u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 20\u001b[39m scaler = StandardScaler()\n\u001b[32m 21\u001b[39m X_train = scaler.fit_transform(X_train)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Roaming\\Python\\Python313\\site-packages\\sklearn\\utils\\_param_validation.py:218\u001b[39m, in \u001b[36mvalidate_params..decorator..wrapper\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 212\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 213\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[32m 214\u001b[39m skip_parameter_validation=(\n\u001b[32m 215\u001b[39m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[32m 216\u001b[39m )\n\u001b[32m 217\u001b[39m ):\n\u001b[32m--> \u001b[39m\u001b[32m218\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 219\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m InvalidParameterError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m 220\u001b[39m \u001b[38;5;66;03m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[32m 221\u001b[39m \u001b[38;5;66;03m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[32m 222\u001b[39m \u001b[38;5;66;03m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[32m 223\u001b[39m \u001b[38;5;66;03m# message to avoid confusion.\u001b[39;00m\n\u001b[32m 224\u001b[39m msg = re.sub(\n\u001b[32m 225\u001b[39m \u001b[33mr\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[33m\\\u001b[39m\u001b[33mw+ must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 226\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc.\u001b[34m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 227\u001b[39m \u001b[38;5;28mstr\u001b[39m(e),\n\u001b[32m 228\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Roaming\\Python\\Python313\\site-packages\\sklearn\\model_selection\\_split.py:2919\u001b[39m, in \u001b[36mtrain_test_split\u001b[39m\u001b[34m(test_size, train_size, random_state, shuffle, stratify, *arrays)\u001b[39m\n\u001b[32m 2916\u001b[39m arrays = indexable(*arrays)\n\u001b[32m 2918\u001b[39m n_samples = _num_samples(arrays[\u001b[32m0\u001b[39m])\n\u001b[32m-> \u001b[39m\u001b[32m2919\u001b[39m n_train, n_test = \u001b[43m_validate_shuffle_split\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2920\u001b[39m \u001b[43m \u001b[49m\u001b[43mn_samples\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdefault_test_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.25\u001b[39;49m\n\u001b[32m 2921\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2923\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m shuffle \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n\u001b[32m 2924\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m stratify \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Roaming\\Python\\Python313\\site-packages\\sklearn\\model_selection\\_split.py:2499\u001b[39m, in \u001b[36m_validate_shuffle_split\u001b[39m\u001b[34m(n_samples, test_size, train_size, default_test_size)\u001b[39m\n\u001b[32m 2496\u001b[39m n_train, n_test = \u001b[38;5;28mint\u001b[39m(n_train), \u001b[38;5;28mint\u001b[39m(n_test)\n\u001b[32m 2498\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m n_train == \u001b[32m0\u001b[39m:\n\u001b[32m-> \u001b[39m\u001b[32m2499\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 2500\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mWith n_samples=\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m, test_size=\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m and train_size=\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m, the \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 2501\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mresulting train set will be empty. Adjust any of the \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 2502\u001b[39m \u001b[33m\"\u001b[39m\u001b[33maforementioned parameters.\u001b[39m\u001b[33m\"\u001b[39m.format(n_samples, test_size, train_size)\n\u001b[32m 2503\u001b[39m )\n\u001b[32m 2505\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m n_train, n_test\n", + "\u001b[31mValueError\u001b[39m: With n_samples=0, test_size=0.2 and train_size=None, the resulting train set will be empty. Adjust any of the aforementioned parameters." + ] + } + ], + "source": [ + "df['Crime_Code'] = df['Primary Type'].replace({\n", + " 'Theft': 0,\n", + " 'Battery': 1,\n", + " 'Criminal Damage': 2,\n", + " 'Narcotics': 3,\n", + " 'Assault': 4\n", + "})\n", + "\n", + "# Encode input features \n", + "df['DayOfWeek_Code'] = df['DayOfWeek'].astype('category').cat.codes\n", + "df['Season_Code'] = df['Season'].astype('category').cat.codes\n", + "\n", + "# Define X and y \n", + "features = ['Hour', 'DayOfWeek_Code', 'Season_Code', 'Community Area', 'Latitude', 'Longitude']\n", + "X = df[features]\n", + "y = df['Crime_Code']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2, stratify=y)\n", + "\n", + "scaler = StandardScaler()\n", + "X_train = scaler.fit_transform(X_train)\n", + "X_test = scaler.transform(X_test)\n", + "\n", + "# Train Decision Tree model\n", + "clf = DecisionTreeClassifier(max_depth=None, random_state=42)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "# Predict and evaluate\n", + "y_pred = clf.predict(X_test)\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "print(\"Confusion Matrix:\\n\", conf_matrix)\n", + "\n", + "print(\"\\nClassification Report:\\n\", classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc67ca2b-2d92-470a-8fa7-805c4048321b", + "metadata": {}, + "outputs": [], + "source": [ + "print(X_train.shape)\n", + "print(X_test.shape)\n", + "\n", + "# Step 3: Grid search like in demo\n", + "start = time.time()\n", + "\n", + "svc = SVC(random_state=2021)\n", + "\n", + "param_grid = [\n", + " {'kernel': ['linear'], 'C': [0.1, 1, 10, 100, 1000]},\n", + " {'kernel': ['poly'], 'degree': [2, 3, 5], 'C': [0.1, 1, 10, 100, 1000]},\n", + " {'kernel': ['rbf'], 'gamma': ['auto', 'scale'], 'C': [0.1, 1, 10, 100, 1000]},\n", + " {'kernel': ['sigmoid'], 'gamma': ['auto', 'scale'], 'C': [0.1, 1, 10, 100, 1000]},\n", + "]\n", + "\n", + "scores = ['precision', 'recall']\n", + "\n", + "for score in scores:\n", + " print(f'# Tuning hyper-parameters for {score}\\n')\n", + "\n", + " CV_svc = GridSearchCV(\n", + " estimator=svc,\n", + " param_grid=param_grid,\n", + " scoring=f'{score}_macro',\n", + " cv=10,\n", + " verbose=1,\n", + " n_jobs=-1\n", + " )\n", + " CV_svc.fit(X_train, y_train.values.ravel())\n", + "\n", + " print(\"Best parameters set found on development set:\\n\")\n", + " print(CV_svc.best_params_)\n", + " print(\"\\nGrid scores on development set:\\n\")\n", + " means = CV_svc.cv_results_['mean_test_score']\n", + " stds = CV_svc.cv_results_['std_test_score']\n", + "\n", + " for mean, std, params in zip(means, stds, CV_svc.cv_results_['params']):\n", + " print(f\"{mean:.3f} (+/-{std * 2:.03f}) for {params}\")\n", + " print()\n", + "\n", + " print(\"Detailed classification report:\\n\")\n", + " y_true, y_pred = y_test, CV_svc.predict(X_test)\n", + " print(classification_report(y_true, y_pred))\n", + " print()\n", + "\n", + "print(\"Total time:\", round(time.time() - start, 2), \"seconds\")\n", + "\n", + "# Fitting the best model and evaluate on test set like in demo\n", + "best_svc = CV_svc.best_estimator_\n", + "best_svc.fit(X_train, y_train.values.ravel())\n", + "\n", + "y_test_pred = best_svc.predict(X_test)\n", + "\n", + "# Step 5: Printing \n", + "print(confusion_matrix(y_test, y_test_pred))\n", + "print(classification_report(y_test, y_test_pred))\n", + "\n", + "# Plotting\n", + "ConfusionMatrixDisplay.from_estimator(best_svc, X_test, y_test)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9b48024-a5cf-40bd-a4bb-4d48a7505965", + "metadata": {}, + "outputs": [], + "source": [ + "scaler = StandardScaler()\n", + "X_scaled = scaler.fit_transform(X)\n", + "X_scaled_df = pd.DataFrame(X_scaled, columns=features)\n", + "\n", + "pca = PCA(random_state=2021, n_components=None)\n", + "pca.fit(X_scaled_df)\n", + "X_pca = pca.transform(X_scaled_df)\n", + "\n", + "exp_var_ratio = pca.explained_variance_ratio_\n", + "\n", + "def explained_variance_ratio_plot(exp_var_ratio):\n", + " x_axis = range(1, len(exp_var_ratio)+1)\n", + " plt.bar(x_axis, exp_var_ratio, align='center', label='Individual EVR')\n", + " plt.step(x_axis, np.cumsum(exp_var_ratio), where='mid', color='red', label='Cumulative EVR')\n", + " plt.ylim(0, 1.1)\n", + " plt.xticks(x_axis)\n", + " plt.xlabel('Principal Components')\n", + " plt.ylabel('Explained Variance Ratio')\n", + " plt.grid()\n", + " plt.legend()\n", + " plt.title(\"Explained Variance by Principal Component\")\n", + " plt.show()\n", + "\n", + "explained_variance_ratio_plot(exp_var_ratio)\n", + "\n", + "num_pc = 5\n", + "loadings = pca.components_\n", + "pc_list = [\"PC\"+str(i) for i in list(range(1, num_pc+1))]\n", + "\n", + "loadings_df = pd.DataFrame(loadings, columns=features, index=pc_list)\n", + "sns.heatmap(loadings_df.T, annot=True, cmap='Spectral')\n", + "plt.title(\"PCA Component Loadings (Crime Features)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99d7770e-168a-46e9-a63f-d1705300fc97", + "metadata": {}, + "outputs": [], + "source": [ + "df_pc12 = scores_df[['PC1', 'PC2']]\n", + "state_st = StandardScaler().fit_transform(df_pc12)\n", + "\n", + "scores = []\n", + "cluster_results = {}\n", + "\n", + "kmeans = KMeans()\n", + "\n", + "for n in range(2, 14):\n", + " kmeans.set_params(n_clusters=n)\n", + " labels = kmeans.fit_predict(state_st)\n", + " cluster_results[n] = labels\n", + " score = silhouette_score(state_st, labels)\n", + " scores.append(score)\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.title(\"Silhouette Score for Crime Clusters (PC1 & PC2)\")\n", + "plt.xlabel(\"Number of Clusters\")\n", + "plt.ylabel(\"Silhouette Score\")\n", + "plt.plot(range(2, 14), scores, marker='s')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e28dc33d-2b85-408a-b3bc-7869a150e870", + "metadata": {}, + "outputs": [], + "source": [ + "kmeans = KMeans()\n", + "elbow = KElbowVisualizer(kmeans, k=(2, 20))\n", + "elbow.fit(state_st)\n", + "elbow.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4bbc76f-65f8-4937-9524-08da082113d2", + "metadata": {}, + "outputs": [], + "source": [ + "kmeans = KMeans(n_clusters=5, random_state=42)\n", + "labels = kmeans.fit_predict(state_st)\n", + "\n", + "scores_df['cluster'] = labels + 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "762ce5e6-7d03-40e4-94fd-d016b04ae441", + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(state_st[:, 0], state_st[:, 1], c=labels, cmap=\"viridis\", s=50)\n", + "plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],\n", + " c=\"red\", s=200, alpha=0.8, label=\"Centroids\")\n", + "plt.title(\"K-Means Clusters (Crime PCA)\")\n", + "plt.xlabel(\"PC1\")\n", + "plt.ylabel(\"PC2\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17b2e9a1-d5f7-49f5-b274-fc949e3a8de3", + "metadata": {}, + "outputs": [], + "source": [ + "cluster_summary = scores_df.groupby('cluster')[['PC1', 'PC2']].mean()\n", + "print(cluster_summary)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5113bea6-4e93-4f54-9cae-d0a1f4f05dce", + "metadata": {}, + "outputs": [], + "source": [ + "# Academic Integrity Statement: I did not use artificial intelligence to help me with this assignment, and I am aware that if I did, \n", + "# I would have to provide the link to the transcript of the session. \n", + "# Also I submitted a downloaded version of the code. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}