In this tutorial, we’ll be using machine learning to predict and map out crime in San Francisco. We’ll be working with a dataset from Kaggle that contains information on 39 different types of crimes, including everything from vehicle theft to drug offenses. Using Python and the powerful Scikit-Learn library, we’ll train a classification model using the XGboost algorithm to predict 39 types of crimes based on when and where it occurred. We’ll then use the Plotly library to visualize the results on a map of the city, highlighting areas with higher rates of certain crimes. This type of prediction and mapping is similar to what the San Francisco Police Department uses in their practice of predictive policing, where they allocate resources to at-risk areas in an effort to prevent crime.
As we embark on this thrilling journey, we’ll start by downloading and preprocessing the San Francisco crime data. Next, we’ll channel the data to train two distinct classification models. The first model will utilize a standard Random Forest Classifier, while the second will leverage the exceptional XGBoost package. We’ll experiment with various models that boast different hyperparameters. Ultimately, we’ll visualize our predictions on a striking SF crime map and assess the performance of our diverse models. So, buckle up and let’s dive into the exhilarating world of crime prediction and mapping!
What is Predictive Policing?
The use case we are looking at in this article falls into predictive policing. Predictive policing uses data, algorithms, and other technological tools to predict where and when crimes are likely to occur. The goal of predictive policing is to help law enforcement agencies better allocate their resources and focus their efforts on areas where crime is likely to happen, with the ultimate goal of reducing crime and improving public safety. This approach to policing is based on the idea that by using data and other tools to identify patterns and trends, law enforcement agencies can better anticipate where crimes are likely to occur and take steps to prevent them from happening.
The benefits of predictive policing include the ability to allocate law enforcement resources better, the potential to reduce crime and improve public safety, and the ability to identify trends and patterns that may not be immediately obvious to law enforcement officers. Additionally, by using data and other tools to anticipate where crimes are likely to occur, law enforcement agencies can take proactive steps to prevent those crimes from happening, which can save time and money.
Creating a Crime Map for Predictive Policing using XGBoost in Python
In this practical tutorial, we’ll construct an XGBoost multi-label classifier to predict crime types in San Francisco. Urban crime, such as in San Francisco, is a dynamic and multifaceted issue that can dramatically vary based on location, time, and other factors. Our aim is to develop a predictive algorithm capable of forecasting specific crime types based on a given location and time parameters. The end product is an interactive San Francisco crime map providing a snapshot of crime hotspots throughout the city.
Law enforcement agencies, like the San Francisco Police Department, use similar maps for strategic resource allocation to curb crime rates effectively. Additionally, this SF crime map will underscore crime clusters – areas notorious for particular types of crime incidents. By the end of this tutorial, you’ll have a deeper understanding of using machine learning in practical scenarios and aiding real-world decision-making.
The code is available on the GitHub repository.
Prerequisites
Before starting the Python coding part, ensure that you have set up your Python 3 environment and required packages. If you don’t have an environment, follow this tutorial to set up the Anaconda environment.
Also, make sure you install all required packages. In this tutorial, we will be working with the following standard packages:
- pandas
- NumPy
- matplotlib
- Seaborn
In addition, we will be using XGBoost (‘xgboost’) and the machine learning library scikit-learn.
You can install packages using console commands:
- pip install <package name>
- conda install <package name> (if you are using the anaconda packet manager)
Step #1 Load the Data
We begin by downloading the San Francisco crime challenge data on kaggle.com. Once you have downloaded the dataset, place the CSV files (train.csv) into your Python working folder.
The dataset was collected by the SFO police department between 2003 and 2015. According to the data description from the SF crime challenge, the dataset contains the following variables:
- Dates: timestamp of the crime incident
- Category: Category of the crime incident (only in train.csv) that we will use as the target variable
- Descript: detailed description of the crime incident (only in train.csv)
- DayOfWeek: the day of the week
- PdDistrict: the name of the Police Department District
- Resolution: how the crime incident was resolved (only in train.csv)
- Address: the approximate street address of the crime incident
- X: Longitude
- Y: Latitude
The next step is to load the data into a dataframe. Then we use the head() command to print the first five lines and ensure you can see the data.
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
from xgboost import XGBClassifier
import plotly.express as px
# The Data is part of the Kaggle Competition: https://www.kaggle.com/c/sf-crime/data
df_base = pd.read_csv("data/crime/sf-crime/train.csv")
print(df_base.describe())
df_base.head()X Y count 878049.000000 878049.000000 mean -122.422616 37.771020 std 0.030354 0.456893 min -122.513642 37.707879 25% -122.432952 37.752427 50% -122.416420 37.775421 75% -122.406959 37.784369 max -120.500000 90.000000
Dates Category Descript DayOfWeek PdDistrict Resolution Address X Y 0 2015-05-13 23:53:00 WARRANTS WARRANT ARREST Wednesday NORTHERN ARREST, OAK ST / ... -122.425892 37.774599 1 2015-05-13 23:53:00 OTHER ... TRAFFIC ... Wednesday NORTHERN ARREST, OAK ST / ... -122.425892 37.774599 2 2015-05-13 23:33:00 OTHER ... TRAFFIC ... Wednesday NORTHERN ARREST, VANNESS AV... ST -122.424363 37.800414 3 2015-05-13 23:30:00 LARCENY/THEFT GRAND THEFT... Wednesday NORTHERN NONE 1500 Block... ST -122.426995 37.800873 4 2015-05-13 23:30:00 LARCENY/THEFT GRAND THEFT ... Wednesday PARK NONE 100 Block... ST -122.438738 37.771541
If the data was loaded correctly, you should see the first five records of the dataframe, as shown above.
Step #2 Explore the Data
At the beginning of a new project, we usually don’t understand the data well and need to acquire that understanding. Therefore, next, we will explore the data and familiarize ourselves with its characteristics.
The following examples will help us better understand our data’s characteristics. For example, you can use whisker charts and a correlation matrix to understand better the correlation between variables, such as between weekdays and prediction categories. Feel free to create more charts.
2.1 Prediction Labels
Running the code below shows a bar plot of the prediction labels. The plot shows the frequency in which the class labels occur in the data.
# print the value counts of the categories plt.figure(figsize=(15,5)) ax = sns.countplot(x = df_base['Category'], orient='v', order = df_base['Category'].value_counts().index) ax.set_xticklabels(ax.get_xticklabels(),rotation = 90)
As shown above, our class labels are highly imbalanced, affecting model accuracy. When we evaluate the performance of our model, we need to consider this.
2.2 When a Crime Occured – Considering Dates and Time
We assume that when a crime occurs impacts the type of crime. For this reason, we look at how crimes distribute across different days of the week and times of the day. First, we look at crime numbers per weekday.
# Print Crime Counts per Weekday plt.figure(figsize=(6,3)) ax = sns.countplot(y = df_base['DayOfWeek'], orient='h', order = df_base['DayOfWeek'].value_counts().index) ax.set_xticklabels(ax.get_xticklabels(),rotation = 90)
Fewer crimes happen on Sundays, and most are on Fridays. So it seems that even criminals like to have a weekend. For the sake of clarity, we thereby limit the categories. Let’s take a look at the time when certain crimes are reported.
# Convert the time to minutes
df_base['Hour_Min'] = pd.to_datetime(df_base['Dates']).dt.hour + pd.to_datetime(df_base['Dates']).dt.minute / 60
# Print Crime Counts per Time and Category
df_base_filtered = df_base[df_base['Category'].isin([
'PROSTITUTION',
'VEHICLE THEFT',
'DRUG/NARCOTIC',
'WARRENTS',
'BURGLERY',
'FRAUD',
'ASSAULT',
'LARCENY/THEFT',
'VANDALISM'])]
plt.figure(figsize=(16,10))
ax = sns.displot(x = 'Hour_Min', hue="Category", data = df_base_filtered, kind="kde", height=8, aspect=1.5)
In addition, the time when a crime happens affects the likelihood of certain types. For example, we can see that FRAUD rarely occurs at night and usually during the day. We can see that criminals often go to work in the afternoon and at midnight. On the other hand, certain crimes, such as VEHICLE THEFT, mainly occur at night and late afternoon but less often in the morning.
If you want to gain an overview of additional features, you can use the pair plot function. Because our dataset is large, we reduce the computation time by plotting 1/100 of the data.
sns.pairplot(data = df_base_filtered[0::100], height=4, aspect=1.5, hue='Category')
2.3 Where a Crime Occured – Considering Address
Next, we look at the address information, from which we can often extract additional information. We do this by printing some sample address values.
# Extracting information from the streetnames
for i in df_base['Address'][0:10]:
print(i)OAK ST / LAGUNA ST OAK ST / LAGUNA ST VANNESS AV / GREENWICH ST 1500 Block of LOMBARD ST 100 Block of BRODERICK ST 0 Block of TEDDY AV AVALON AV / PERU AV KIRKWOOD AV / DONAHUE ST 600 Block of 47TH AV JEFFERSON ST / LEAVENWORTH ST
The street names alone are not so helpful. However, the address data does provide additional information. For example, it tells us whether the location is a street intersection or not. In addition, it contains the type of street. This information is valuable because now we can extract parts of the text and use them as separate features.
We could do a lot more, but we’ve got a good enough idea of the data.
Step #3 Data Preprocessing
Probably the most exciting and important aspect of model development is feature engineering. Compared to model parameterization, the right features can often achieve more significant leaps in performance.
3.1 Remarks on Data Preprocessing for XGBoost
When preprocessing the data, it is helpful to know which algorithms to use because some algorithms are picky about the shape of the data. We will prepare the data to train a gradient-boosting model (XGBoost). This algorithm uses a random forest ensemble, which can only handle integer and Boolean values, but no categorical data. Therefore we need to encode our values. We also need to map the categorical labels to integer values.
We don’t need to scale the continuous feature variables because gradient boosting and decision trees, generally, are not sensitive to variables that have different scales.
3.2 Feature Engineering
Based on the data exploration that we have done in the previous section, we create three feature types:
- Date & Time: When a crime happens is essential. For example, when there is a lot of traffic on the street, there is a higher likelihood of traffic-related crimes. For example, when it is Saturday, more people will usually come to the nightlife district, which attracts certain crimes, e.g., drug-related. Therefore, we will create different features for the time, the day, the month, and the year.
- Address: As mentioned, we will extract additional features from the address column. First, we create different features for the street type (for example, ST, AV, WY, TR, DR). In addition, we check whether the address contains the word “Block.” In addition, we will let our model know whether the address is a street crossing.
- Latitude & Longitude: We will transform the latitude and longitude values into polar coordinates. We will also remove some outliers from the dataset whose latitude is far off the grid. Above all, this will make it easier for our model to make sense of the location.
Considering these features, the primary input to our crime-type prediction model is the information on when and where a crime occurs.
# Processing Function for Features
def cart2polar(x, y):
dist = np.sqrt(x**2 + y**2)
phi = np.arctan2(y, x)
return dist, phi
def preprocessFeatures(dfx):
# Time Feature Engineering
df = pd.get_dummies(dfx[['DayOfWeek' , 'PdDistrict']])
df['Hour_Min'] = pd.to_datetime(dfx['Dates']).dt.hour + pd.to_datetime(dfx['Dates']).dt.minute / 60
# We add a feature that contains the expontential time
df['Hour_Min_Exp'] = np.exp(df['Hour_Min'])
df['Day'] = pd.to_datetime(dfx['Dates']).dt.day
df['Month'] = pd.to_datetime(dfx['Dates']).dt.month
df['Year'] = pd.to_datetime(dfx['Dates']).dt.year
month_one_hot_encoded = pd.get_dummies(pd.to_datetime(dfx['Dates']).dt.month, prefix='Month')
df = pd.concat([df, month_one_hot_encoded], axis=1, join="inner")
# Convert Carthesian Coordinates to Polar Coordinates
df[['X', 'Y']] = dfx[['X', 'Y']] # we maintain the original coordindates as additional features
df['dist'], df['phi'] = cart2polar(dfx['X'], dfx['Y'])
# Extracting Street Types
df['Is_ST'] = dfx['Address'].str.contains(" ST", case=True)
df['Is_AV'] = dfx['Address'].str.contains(" AV", case=True)
df['Is_WY'] = dfx['Address'].str.contains(" WY", case=True)
df['Is_TR'] = dfx['Address'].str.contains(" TR", case=True)
df['Is_DR'] = dfx['Address'].str.contains(" DR", case=True)
df['Is_Block'] = dfx['Address'].str.contains(" Block", case=True)
df['Is_crossing'] = dfx['Address'].str.contains(" / ", case=True)
return df
# Processing Function for Labels
def encodeLabels(dfx):
df = pd.DataFrame (columns = [])
factor = pd.factorize(dfx['Category'])
return factor
# Remove Outliers by Longitude
df_cleaned = df_base[df_base['Y']<70]
# Encode Labels as Integer
factor = encodeLabels(df_cleaned)
y_df = factor[0]
labels = list(factor[1])
# for val, i in enumerate(labels):
# print(val, i)We could also try to further improve our features by using additional data sources, such as weather data. However, there is no guarantee that this will improve the model results, and it did not in the case of criminal records. Therefore, we have omitted this part.
Step #4 Visualize Crime Types on a Map of San Francisco
Next, we create a San Francisco crime map using the cartesian coordinates indicating where a crime has occurred. First, we only plot the data without a geographical map. Later we will use these spatial data to create a dot plot and overlay it with a map of San Francisco. Visualizing the crime types on a map helps us understand how crime types distribute across the city.
4.1 Plot Crime Types using a Scatter Plot
Next, we want to gain an overview of possible spatial patterns and hotspots. We expect to see streets and neighborhoods where certain crimes are more common than in the more expensive areas of the city. In addition, we expect to see places in the city where certain crime types occur relatively rarely. To gain an overview of the crime distribution in San Francisco, we use a scatter plot to display the crime coordinates on a blank chart.
Running the code below creates the crime map of San Francisco with all crime types. Depending on the speed of your machine, the creation of the map may take several minutes.
# Plot Criminal Activities by Lat and Long
df_filtered = df_cleaned.sample(frac=0.05)
#df_filtered = df_cleaned[df_cleaned['Category'].isin(['PROSTITUTION', 'VEHICLE THEFT', 'FRAUD'])].sample(frac=0.05) # to filter
groups = df_filtered.groupby('Category')
fig, ax = plt.subplots(sharex=False, figsize=(20, 12))
ax.margins(0.05) # Optional, just adds 5% padding to the autoscaling
for name, group in groups:
ax.plot(group['X'], group['Y'], marker='.', linestyle='', label=name, alpha=0.9)
ax.legend()
plt.show()
The plot shows that certain streets in San Francisco are more prone to specific crime types than others. It is also clear that there are certain crime hotspots in the city, especially in the center. We can also see that few crimes are reported in public park areas.
4.2 Create a Crime Map of San Francisco using Plotly
Next, we will create a San Francisco crime map using the Plotly Python library. Because the plugin can handle a limited amount of data simultaneously, we will reduce our data to a fraction of 1% and a few selected crime types.
Running the code below opens a _map.html file in your browser that displays the SF crime map. The result is a zoomable geographic map of San Francisco that shows how the selected crime types distribute across the city.
# 4.2 Create a Crime Map of San Francisco using Plotly
# Limit the data to a fraction and selected categories
df_filtered = df_cleaned.sample(frac=0.01)
fig = px.scatter_mapbox(df_filtered, lat="Y", lon="X", hover_name="Category", color='Category', hover_data=["Y", "X"], zoom=12, height=800)
fig.update_layout(mapbox_style="open-street-map")
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
fig.show()
The SF crime map shows different types of crimes, including prostitution, vehicle theft, and fraud. The interactive map allows you to change zoom levels and filter the type of crime displayed on the map. For example, if you filter DRUG/NARCOTIC-related crimes, you can see that these crimes mainly occur in the city center near the financial district and the nightlife area.
Step #5 Split the Data
Before training our predictive model, we will split our data into separate datasets for training and testing. For this purpose, we use the train_test_split function of scikit-learn and configure a split ratio of 70%. Then we output the data, which we employ in the next step to train and validate a model.
# Create train_df & test_df x_df = preprocessFeatures(df_cleaned).copy() # Split the data into x_train and y_train data sets x_train, x_test, y_train, y_test = train_test_split(x_df, y_df, train_size=0.7, random_state=0) x_train
DayOfWeek_Friday DayOfWeek_Monday DayOfWeek_Saturday DayOfWeek_Sunday DayOfWeek_Thursday DayOfWeek_Tuesday DayOfWeek_Wednesday PdDistrict_BAYVIEW PdDistrict_CENTRAL PdDistrict_INGLESIDE ... Y dist phi Is_ST Is_AV Is_WY Is_TR Is_DR Is_Block Is_crossing 276998 0 0 0 0 0 1 0 0 0 0 ... 37.785023 128.110900 2.842200 True False False False False True False 81579 0 0 0 0 0 1 0 0 0 0 ... 37.748470 128.185052 2.842677 False True False False False True False 206676 0 0 0 1 0 0 0 0 0 0 ... 37.762744 128.113657 2.842389 True False False False False True False 732006 0 0 0 0 0 0 1 0 0 0 ... 37.784140 128.109653 2.842204 True False False False False False True 796194 1 0 0 0 0 0 0 0 0 0 ... 37.791333 128.125982 2.842185 True False False False False True False 5 rows × 45 columns
Step #6 Train a Random Forest Classifier
We can train the predictive models now that we have prepared the data. We train a basic model based on the Random Forest algorithm in the first step. The Random Forest is a robust algorithm that can handle regression and classification problems. One of our recent articles provides more information on Random Forests and how you can find the optimal configuration of their hyperparameters. In this tutorial, we use the Random Forest to establish a baseline against which we can measure the performance of our XGboost model. We, therefore, use the Random Forest with a simple parameter configuration without tuning the hyperparameters.
# Train a single random forest classifier - parameters are a best guess clf = RandomForestClassifier(max_depth=100, random_state=0, n_estimators = 200) clf.fit(x_train, y_train.ravel()) y_pred = clf.predict(x_test) results_log = classification_report(y_test, y_pred) print(results_log)
Output exceeds the size limit. Open the full output data in a text editor
precision recall f1-score support
0 0.15 0.10 0.12 12657
1 0.29 0.35 0.32 37898
2 0.38 0.63 0.47 52237
3 0.46 0.40 0.43 16136
4 0.16 0.08 0.10 13426
5 0.25 0.21 0.23 27798
6 0.10 0.04 0.06 6850
7 0.23 0.22 0.23 23087
8 0.19 0.12 0.15 2586
9 0.20 0.13 0.15 10942
10 0.08 0.03 0.05 9559
11 0.00 0.00 0.00 1300
12 0.20 0.10 0.14 3200
13 0.37 0.43 0.40 16282
14 0.02 0.02 0.02 1350
15 0.01 0.00 0.00 2912
16 0.05 0.03 0.04 2217
17 0.61 0.52 0.56 7865
18 0.11 0.06 0.08 4954
19 0.04 0.03 0.03 723
20 0.28 0.19 0.23 581
21 0.05 0.02 0.03 708
22 0.25 0.13 0.17 1333
...
accuracy 0.31 263395
macro avg 0.15 0.12 0.13 263395
weighted avg 0.28 0.31 0.28 263395The baseline model is a random forest classifier with 31% percent accuracy on the test dataset.
Step #7 Train an XGBoost Classifier
Now that we have a baseline model, we can train our gradient boosting classifier using the XGBoost package. We expect this model to perform better than the baseline.
7.1 About Gradient Boosting
XGBoost is an implementation of a gradient-boosting algorithm that uses a decision-tree-based ensemble machine learning algorithm. The algorithm searches for an optimal ensemble of trees. In this process, the algorithm iteratively adds trees to the model or removes them to reduce the prediction error of the previous tree constellation. The algorithm repeats these steps until it can make no further improvements. Thus, training does not optimize the model against the predictions but the previous model’s residuals (prediction errors).
But XGBoost does more! It is an extreme version of gradient boosting that uses additional optimization techniques to achieve the best result with minimal effort. In contrast to the random decision forest, the XGBoost classification algorithm determines an optimal number of trees in the training process. We do not have to specify this number in advance.
A disadvantage of XGBoost is that it tends to overfit the data. Therefore, testing against unseen data is essential. This tutorial will test only against a single test sample for simplicity, but using cross-validation would be a better choice.
7.2 Train the XGBoost Classifier
Various Gradient Boosting Algorithms are available for Python, including one from scikit-learn. However, scikit-learn does not support multi-threading, which makes the training process slower than necessary. For this reason, we will use the gradient boosting classifier from the XGBoost package.
# Configure the XGBoost model
param = {'booster': 'gbtree',
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor',
'max_depth': 140,
'eta': 0.3,
'objective': '{multi:softmax}',
'eval_metric': 'mlogloss',
'num_round': 30,
'feature_selector ': 'cyclic'
}
xgb_clf = XGBClassifier(param)
xgb_clf.fit(x_train, y_train.ravel())
score = xgb_clf.score(x_test, y_test.ravel())
print(score)
# Create predictions on the test dataset
y_pred = xgb_clf.predict(x_test)
# Print a classification report
results_log = classification_report(y_test, y_pred)
print(results_log)Output exceeds the size limit. Open the full output data in a text editor
0.30852142219859907
precision recall f1-score support
0 0.17 0.01 0.02 12657
1 0.30 0.42 0.35 37898
2 0.33 0.72 0.46 52237
3 0.31 0.27 0.29 16136
4 0.21 0.03 0.05 13426
5 0.24 0.18 0.21 27798
6 0.17 0.01 0.01 6850
7 0.21 0.19 0.20 23087
8 0.26 0.01 0.02 2586
9 0.22 0.08 0.12 10942
10 0.13 0.00 0.00 9559
11 0.07 0.00 0.01 1300
12 0.20 0.08 0.11 3200
13 0.34 0.43 0.38 16282
14 0.00 0.00 0.00 1350
15 0.12 0.00 0.01 2912
16 0.15 0.02 0.03 2217
17 0.57 0.34 0.43 7865
18 0.19 0.03 0.05 4954
19 0.00 0.00 0.00 723
20 0.50 0.24 0.32 581
21 0.10 0.01 0.01 708
...
accuracy 0.31 263395
macro avg 0.18 0.11 0.11 263395
weighted avg 0.27 0.31 0.25 263395
Now that we have trained our classification model, let’s see how it performs. For this purpose, we will generate predictions (y_pred) on the test dataset (x_test). Afterward, we use the predictions and the valid values (y_test) to create a classification report.
Our model achieves an accuracy score of 31%. At first hand, this might not look so good, but considering that we have 39 categories and only sparse information available, this performance is quite impressive.
Step #8 Measure Model Performance
So how well does our XGboost model perform? To measure the performance of our model, we create a confusion matrix that visualizes the performance of the XGboost classifier. If you want to learn more about measuring the performance of classification models, check out this tutorial on measuring classification performance.
Running the code below creates the confusion matrix that shows the number of correct and false predictions for each crime category.
# Print a multi-Class Confusion Matrix
cnf_matrix = confusion_matrix(y_test.reshape(-1), y_pred)
df_cm = pd.DataFrame(cnf_matrix, columns=np.unique(y_test), index = np.unique(y_test))
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
plt.figure(figsize = (16,12))
plt.tight_layout()
sns.set(font_scale=1.4) #for label size
sns.heatmap(df_cm, cbar=True, cmap= "inferno", annot=False, fmt='.0f' #, annot_kws={"size": 13}
)
The confusion matrix shows that our model frequently predicts crime category two and neglects the other crime types. The reason is the uneven distribution of crime types in the training data. As a result, when we evaluate the model, we need to pay attention to the importance of the different crime types. For example, we might train the model to predict certain crime types accurately, although this might come at a lower accuracy when predicting other crime types. However, such optimizations depend on the technical context and the goals one wants to achieve with the prediction model.
Summary
This tutorial has presented the machine learning use case “Predictive Policing” and showed how to implement it in Python. We have trained an XGBoost model that predicts crime types in San Francisco based on the information on when and where specific crimes have occurred. We also illustrated our data on an interactive crime map of San Francisco with the Plotly Python library. The Crime Map is an intuitive way of visualizing crime in a city and highlighting particular hotspots. Finally, we have used the prediction model to make test predictions and evaluate the model performance against other algorithms, such as a classic Random Decision Forest. The XGBoost model achieves a prediction accuracy of about 31%—a respectable performance, considering that the prediction problem involves 39 crime classes.
We hope this tutorial was helpful. If you have any questions or suggestions on what we could improve, feel free to post them in the comments. We appreciate your feedback.
Sources and Further Reading
Looking for more esciting map vizualizations? Consider the relataly tutorial on visualizing COVID-19 data on geographic heatmaps using GeoPandas.
The links above to Amazon are affiliate links. By buying through these links, you support the Relataly.com blog and help to cover the hosting costs. Using the links does not affect the price.
