## Description

About The Data We’ll be using the Customer Dataset from kaggle for this lab, but feel free to follow along with your own dataset. The dataset contains the following attributes: CustomerID Genre Age AnnualIncome(k$) Spending_Score Our goal is to group/cluster these customers. About K Means K Means Clustering is an unsupervised learning algorithm that tries to cluster data based on their similarity. Unsupervised learning means that there is no outcome to be predicted, and the algorithm just tries to find patterns in the data. In k means clustering, we have the specify the number of clusters we want the data to be grouped into. The algorithm randomly assigns each observation to a cluster, and finds the centroid of each cluster. Then, the algorithm iterates through two steps: Reassign data points to the cluster whose centroid is closest. Calculate new centroid of each cluster. These two steps are repeated till the within cluster variation cannot be reduced any further. The within cluster variation is calculated as the sum of the euclidean distance between the data points and their respective cluster centroids. Refer back to the lecture video or slides for more detail on K Means. Implementation Because K Means is used more for finding patterns in our data, we’ll skip the data exploration portion, but you’re welcome to explore this data or your own if working with a different dataset. Let’s first load the data into a pandas DataFrame. We’ll use the CustomerID column as our index_col for this DataFrame. Genre Age Annual_Income_(k$) Spending_Score CustomerID 1 Male 19 15 39 2 Male 21 15 81 3 Female 20 16 6 4 Female 23 16 77 5 Female 31 17 40 calling .info() we see that there are no missing values in this dataset since there are 200 entries in total and 200 non‑null entries in each column. <class ’pandas.core.frame.DataFrame’> Int64Index: 200 entries, 1 to 200 Data columns (total 4 columns): # Column NonNull Count Dtype 0 Genre 200 nonnull object 1 Age 200 nonnull int64 2 Annual_Income_(k$) 200 nonnull int64 3 Spending_Score 200 nonnull int64 dtypes: int64(3), object(1) memory usage: 7.8+ KB Age Annual_Income_(k$) Spending_Score count 200.000000 200.000000 200.000000 mean 38.850000 60.560000 50.200000 std 13.969007 26.264721 25.823522 min 18.000000 15.000000 1.000000 25% 28.750000 41.500000 34.750000 50% 36.000000 61.500000 50.000000 75% 49.000000 78.000000 73.000000 max 70.000000 137.000000 99.000000 To ensure that we don’t have any duplicates, we can call .drop_duplicates(inplace=True) on our DataFrame. Just so that we can visualize our clusters in the end of this lab, we’ll go ahead and only work with 2 variables (spending score and income). However, you’re free to use more than 2 variables if you’re working with your own dataset. We’ll now use the elbow method to find the optimal number of clusters. We’re now ready to create our KMeans model and run our predictions on the X vector we created earlier with spending score and income. Note: You won’t typically be plotting the clusters to visualize since you’ll usually have more than 2 variables, but since we only worked with 2 variables, let’s go ahead and visualize our clusters. Congrats! You know know how to use KMeans in sklearn. Try repeating the lab steps on your own data for practice. Since we don’t have the ground truth (unsupervised) to compare and evaulate performance, there’s not much more we can do here to evaulate our model like we’re used to doing. You’ll later learn about Silhouette analysis, which will come in handy. In [1]: import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns In [2]: from matplotlib import rcParams rcParams[‘figure.figsize’] = 15, 5 sns.set_style(‘darkgrid’) In [3]: customer_df = pd.read_csv(‘customers.csv’, index_col=’CustomerID’) customer_df.head() Out[3]: In [4]: customer_df.info() In [5]: customer_df.describe() Out[5]: In [6]: customer_df.drop_duplicates(inplace=True) In [12]: # Saving only Spending_Score and income values into X. X = customer_df.iloc[:, [2, 3]].values In [15]: from sklearn.cluster import KMeans # where we’ll store all of the wcss values for plotting later. wcss = [] for i in range(1, 11): # random_state just to ensure we get the same values in the end. kmeans = KMeans(n_clusters = i, random_state = 42) kmeans.fit(X) # inertia method returns wcss for that model. wcss.append(kmeans.inertia_) # creating lineplot to visualize wcss and find optimal number of clusters sns.lineplot(x=range(1, 11), y=wcss,marker=’o’,color=’red’) plt.title(‘Elbow Method’) plt.xlabel(‘Number of clusters’) plt.ylabel(‘WCSS’) plt.show() In [16]: kmeans = KMeans(n_clusters = 5, init = ‘kmeans++’, random_state = 42) y_pred = kmeans.fit_predict(X) In [19]: sns.scatterplot(x=X[y_pred == 0, 0], y=X[y_pred == 0, 1], color = ‘yellow’, label = ‘Cluster 1’,s=50) sns.scatterplot(x=X[y_pred == 1, 0], y=X[y_pred == 1, 1], color = ‘blue’, label = ‘Cluster 2’,s=50) sns.scatterplot(x=X[y_pred == 2, 0], y=X[y_pred == 2, 1], color = ‘green’, label = ‘Cluster 3’,s=50) sns.scatterplot(x=X[y_pred == 3, 0], y=X[y_pred == 3, 1], color = ‘grey’, label = ‘Cluster 4’,s=50) sns.scatterplot(x=X[y_pred == 4, 0], y=X[y_pred == 4, 1], color = ‘orange’, label = ‘Cluster 5’,s=50) sns.scatterplot(x=kmeans.cluster_centers_[:, 0], y=kmeans.cluster_centers_[:, 1], color = ‘red’, label = ‘Centroids’,s=100,marker=’,’) plt.title(‘Clusters of customers’) plt.xlabel(‘Annual Income’) plt.ylabel(‘Spending Score’) plt.legend() plt.show()