+
Nigerian Music scraped from Spotify - an
+analysis
+
Clustering is a type of Unsupervised
+Learning that presumes that a dataset is unlabelled or that its
+inputs are not matched with predefined outputs. It uses various
+algorithms to sort through unlabeled data and provide groupings
+according to patterns it discerns in the data.
+
Pre-lecture
+quiz
+
+
Introduction
+
Clustering
+is very useful for data exploration. Let’s see if it can help discover
+trends and patterns in the way Nigerian audiences consume music.
+
+✅ Take a minute to think about the uses of clustering. In real life,
+clustering happens whenever you have a pile of laundry and need to sort
+out your family members’ clothes 🧦👕👖🩲. In data science, clustering
+happens when trying to analyze a user’s preferences, or determine the
+characteristics of any unlabeled dataset. Clustering, in a way, helps
+make sense of chaos, like a sock drawer.
+
+
In a professional setting, clustering can be used to determine things
+like market segmentation, determining what age groups buy what items,
+for example. Another use would be anomaly detection, perhaps to detect
+fraud from a dataset of credit card transactions. Or you might use
+clustering to determine tumors in a batch of medical scans.
+
✅ Think a minute about how you might have encountered clustering ‘in
+the wild’, in a banking, e-commerce, or business setting.
+
+🎓 Interestingly, cluster analysis originated in the fields of
+Anthropology and Psychology in the 1930s. Can you imagine how it might
+have been used?
+
+
Alternately, you could use it for grouping search results - by
+shopping links, images, or reviews, for example. Clustering is useful
+when you have a large dataset that you want to reduce and on which you
+want to perform more granular analysis, so the technique can be used to
+learn about data before other models are constructed.
+
✅ Once your data is organized in clusters, you assign it a cluster
+Id, and this technique can be useful when preserving a dataset’s
+privacy; you can instead refer to a data point by its cluster id, rather
+than by more revealing identifiable data. Can you think of other reasons
+why you’d refer to a cluster Id rather than other elements of the
+cluster to identify it?
+
+
+
Getting started with clustering
+
+🎓 How we create clusters has a lot to do with how we gather up the
+data points into groups. Let’s unpack some vocabulary:
+🎓 ‘Transductive’
+vs. ‘inductive’
+Transductive inference is derived from observed training cases that
+map to specific test cases. Inductive inference is derived from training
+cases that map to general rules which are only then applied to test
+cases.
+An example: Imagine you have a dataset that is only partially
+labelled. Some things are ‘records’, some ‘cds’, and some are blank.
+Your job is to provide labels for the blanks. If you choose an inductive
+approach, you’d train a model looking for ‘records’ and ‘cds’, and apply
+those labels to your unlabeled data. This approach will have trouble
+classifying things that are actually ‘cassettes’. A transductive
+approach, on the other hand, handles this unknown data more effectively
+as it works to group similar items together and then applies a label to
+a group. In this case, clusters might reflect ‘round musical things’ and
+‘square musical things’.
+🎓 ‘Non-flat’
+vs. ‘flat’ geometry
+Derived from mathematical terminology, non-flat vs. flat geometry
+refers to the measure of distances between points by either ‘flat’ (Euclidean) or
+‘non-flat’ (non-Euclidean) geometrical methods.
+‘Flat’ in this context refers to Euclidean geometry (parts of which
+are taught as ‘plane’ geometry), and non-flat refers to non-Euclidean
+geometry. What does geometry have to do with machine learning? Well, as
+two fields that are rooted in mathematics, there must be a common way to
+measure distances between points in clusters, and that can be done in a
+‘flat’ or ‘non-flat’ way, depending on the nature of the data. Euclidean
+distances are measured as the length of a line segment between two
+points. Non-Euclidean
+distances are measured along a curve. If your data, visualized,
+seems to not exist on a plane, you might need to use a specialized
+algorithm to handle it.
+
+
+
+
Infographic by Dasani Madipalli
+
+
+🎓 ‘Distances’
+Clusters are defined by their distance matrix, e.g. the distances
+between points. This distance can be measured a few ways. Euclidean
+clusters are defined by the average of the point values, and contain a
+‘centroid’ or center point. Distances are thus measured by the distance
+to that centroid. Non-Euclidean distances refer to ‘clustroids’, the
+point closest to other points. Clustroids in turn can be defined in
+various ways.
+🎓 ‘Constrained’
+Constrained
+Clustering introduces ‘semi-supervised’ learning into this
+unsupervised method. The relationships between points are flagged as
+‘cannot link’ or ‘must-link’ so some rules are forced on the
+dataset.
+An example: If an algorithm is set free on a batch of unlabelled or
+semi-labelled data, the clusters it produces may be of poor quality. In
+the example above, the clusters might group ‘round music things’ and
+‘square music things’ and ‘triangular things’ and ‘cookies’. If given
+some constraints, or rules to follow (“the item must be made of
+plastic”, “the item needs to be able to produce music”) this can help
+‘constrain’ the algorithm to make better choices.
+🎓 ‘Density’
+Data that is ‘noisy’ is considered to be ‘dense’. The distances
+between points in each of its clusters may prove, on examination, to be
+more or less dense, or ‘crowded’ and thus this data needs to be analyzed
+with the appropriate clustering method. This
+article demonstrates the difference between using K-Means clustering
+vs. HDBSCAN algorithms to explore a noisy dataset with uneven cluster
+density.
+
+
Deepen your understanding of clustering techniques in this Learn
+module
+
+
+
Clustering algorithms
+
There are over 100 clustering algorithms, and their use depends on
+the nature of the data at hand. Let’s discuss some of the major
+ones:
+
+- Hierarchical clustering. If an object is classified
+by its proximity to a nearby object, rather than to one farther away,
+clusters are formed based on their members’ distance to and from other
+objects. Hierarchical clustering is characterized by repeatedly
+combining two clusters.
+
+
+
+
Infographic by Dasani Madipalli
+
+
+Centroid clustering. This popular algorithm
+requires the choice of ‘k’, or the number of clusters to form, after
+which the algorithm determines the center point of a cluster and gathers
+data around that point. K-means
+clustering is a popular version of centroid clustering which
+separates a data set into pre-defined K groups. The center is determined
+by the nearest mean, thus the name. The squared distance from the
+cluster is minimized.
Distribution-based clustering. Based in
+statistical modeling, distribution-based clustering centers on
+determining the probability that a data point belongs to a cluster, and
+assigning it accordingly. Gaussian mixture methods belong to this
+type.
Density-based clustering. Data points are
+assigned to clusters based on their density, or their grouping around
+each other. Data points far from the group are considered outliers or
+noise. DBSCAN, Mean-shift and OPTICS belong to this type of
+clustering.
Grid-based clustering. For multi-dimensional
+datasets, a grid is created and the data is divided amongst the grid’s
+cells, thereby creating clusters.
+
The best way to learn about clustering is to try it for yourself, so
+that’s what you’ll do in this exercise.
+
We’ll require some packages to knock-off this module. You can have
+them installed as:
+install.packages(c('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork'))
+
Alternatively, the script below checks whether you have the packages
+required to complete this module and installs them for you in case some
+are missing.
+
suppressWarnings(if(!require("pacman")) install.packages("pacman"))
+
## Loading required package: pacman
+
pacman::p_load('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork')
+
##
+## The downloaded binary packages are in
+## /var/folders/c9/r3f6t3kj3wv9jrh50g63hp1r0000gn/T//RtmplRAI5s/downloaded_packages
+
##
+## summarytools installed
+
## Warning in pacman::p_load("tidyverse", "tidymodels", "DataExplorer", "summarytools", : Failed to install/load:
+## summarytools
+
knitr::opts_chunk$set(warning = F, message = F)
+
+
+
Exercise - cluster your data
+
Clustering as a technique is greatly aided by proper visualization,
+so let’s get started by visualizing our music data. This exercise will
+help us decide which of the methods of clustering we should most
+effectively use for the nature of this data.
+
Let’s hit the ground running by importing the data.
+
# Load the core tidyverse and make it available in your current R session
+library(tidyverse)
+
+# Import the data into a tibble
+df <- read_csv(file = "https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/5-Clustering/data/nigerian-songs.csv")
+
+# View the first 5 rows of the data set
+df %>%
+ slice_head(n = 5)
+
+
+
+
Sometimes, we may want some little more information on our data. We
+can have a look at the data and its structure
+by using the glimpse()
+function:
+
# Glimpse into the data set
+df %>%
+ glimpse()
+
## Rows: 530
+## Columns: 16
+## $ name <chr> "Sparky", "shuga rush", "LITT!", "Confident / Feeling…
+## $ album <chr> "Mandy & The Jungle", "EVERYTHING YOU HEARD IS TRUE",…
+## $ artist <chr> "Cruel Santino", "Odunsi (The Engine)", "AYLØ", "Lady…
+## $ artist_top_genre <chr> "alternative r&b", "afropop", "indie r&b", "nigerian …
+## $ release_date <dbl> 2019, 2020, 2018, 2019, 2018, 2020, 2018, 2018, 2019,…
+## $ length <dbl> 144000, 89488, 207758, 175135, 152049, 184800, 202648…
+## $ popularity <dbl> 48, 30, 40, 14, 25, 26, 29, 27, 36, 30, 33, 35, 46, 2…
+## $ danceability <dbl> 0.666, 0.710, 0.836, 0.894, 0.702, 0.803, 0.818, 0.80…
+## $ acousticness <dbl> 0.8510, 0.0822, 0.2720, 0.7980, 0.1160, 0.1270, 0.452…
+## $ energy <dbl> 0.420, 0.683, 0.564, 0.611, 0.833, 0.525, 0.587, 0.30…
+## $ instrumentalness <dbl> 5.34e-01, 1.69e-04, 5.37e-04, 1.87e-04, 9.10e-01, 6.6…
+## $ liveness <dbl> 0.1100, 0.1010, 0.1100, 0.0964, 0.3480, 0.1290, 0.590…
+## $ loudness <dbl> -6.699, -5.640, -7.127, -4.961, -6.044, -10.034, -9.8…
+## $ speechiness <dbl> 0.0829, 0.3600, 0.0424, 0.1130, 0.0447, 0.1970, 0.199…
+## $ tempo <dbl> 133.015, 129.993, 130.005, 111.087, 105.115, 100.103,…
+## $ time_signature <dbl> 5, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4,…
+
Good job!💪
+
We can observe that glimpse() will give you the total
+number of rows (observations) and columns (variables), then, the first
+few entries of each variable in a row after the variable name. In
+addition, the data type of the variable is given immediately
+after each variable’s name inside < >.
+
DataExplorer::introduce() can summarize this information
+neatly:
+
# Describe basic information for our data
+df %>%
+ introduce()
+
+
+
+
# A visual display of the same
+df %>%
+ plot_intro()
+
+
Awesome! We have just learnt that our data has no missing values.
+
While we are at it, we can explore common central tendency statistics
+(e.g mean
+and median) and
+measures of dispersion (e.g standard
+deviation) using summarytools::descr()
+
# Describe common statistics
+df %>% descr(stats = "common")
+
+
Let’s look at the general values of the data. Note that popularity
+can be 0, which show songs that have no ranking. We’ll
+remove those shortly.
+
+🤔 If we are working with clustering, an unsupervised method that
+does not require labeled data, why are we showing this data with labels?
+In the data exploration phase, they come in handy, but they are not
+necessary for the clustering algorithms to work.
+
+
+
1. Explore popular genres
+
Let’s go ahead and find out the most popular genres 🎶 by making a
+count of the instances it appears.
+
# Popular genres
+top_genres <- df %>%
+ count(artist_top_genre, sort = TRUE) %>%
+# Encode to categorical and reorder the according to count
+ mutate(artist_top_genre = factor(artist_top_genre) %>% fct_inorder())
+
+# Print the top genres
+top_genres
+
+
+
+
That went well! They say a picture is worth a thousand rows of a data
+frame (actually nobody ever says that 😅). But you get the gist of it,
+right?
+
One way to visualize categorical data (character or factor variables)
+is using barplots. Let’s make a barplot of the top 10 genres:
+
# Change the default gray theme
+theme_set(theme_light())
+
+# Visualize popular genres
+top_genres %>%
+ slice(1:10) %>%
+ ggplot(mapping = aes(x = artist_top_genre, y = n,
+ fill = artist_top_genre)) +
+ geom_col(alpha = 0.8) +
+ paletteer::scale_fill_paletteer_d("rcartocolor::Vivid") +
+ ggtitle("Top genres") +
+ theme(plot.title = element_text(hjust = 0.5),
+ # Rotates the X markers (so we can read them)
+ axis.text.x = element_text(angle = 90))
+
+
Now it’s way easier to identify that we have missing
+genres 🧐!
+
+A good visualisation will show you things that you did not expect, or
+raise new questions about the data - Hadley Wickham and Garrett
+Grolemund, R For Data
+Science
+
+
Note, when the top genre is described as Missing, that
+means that Spotify did not classify it, so let’s get rid of it.
+
# Visualize popular genres
+top_genres %>%
+ filter(artist_top_genre != "Missing") %>%
+ slice(1:10) %>%
+ ggplot(mapping = aes(x = artist_top_genre, y = n,
+ fill = artist_top_genre)) +
+ geom_col(alpha = 0.8) +
+ paletteer::scale_fill_paletteer_d("rcartocolor::Vivid") +
+ ggtitle("Top genres") +
+ theme(plot.title = element_text(hjust = 0.5),
+ # Rotates the X markers (so we can read them)
+ axis.text.x = element_text(angle = 90))
+
+
From the little data exploration, we learn that the top three genres
+dominate this dataset. Let’s concentrate on afro dancehall,
+afropop, and nigerian pop, additionally filter
+the dataset to remove anything with a 0 popularity value (meaning it was
+not classified with a popularity in the dataset and can be considered
+noise for our purposes):
+
nigerian_songs <- df %>%
+ # Concentrate on top 3 genres
+ filter(artist_top_genre %in% c("afro dancehall", "afropop","nigerian pop")) %>%
+ # Remove unclassified observations
+ filter(popularity != 0)
+
+
+
+# Visualize popular genres
+nigerian_songs %>%
+ count(artist_top_genre) %>%
+ ggplot(mapping = aes(x = artist_top_genre, y = n,
+ fill = artist_top_genre)) +
+ geom_col(alpha = 0.8) +
+ paletteer::scale_fill_paletteer_d("ggsci::category10_d3") +
+ ggtitle("Top genres") +
+ theme(plot.title = element_text(hjust = 0.5))
+
+
Let’s see whether there is any apparent linear relationship among the
+numerical variables in our data set. This relationship is quantified
+mathematically by the correlation
+statistic.
+
The correlation statistic is a value between -1 and 1 that indicates
+the strength of a relationship. Values above 0 indicate a
+positive correlation (high values of one variable tend to
+coincide with high values of the other), while values below 0 indicate a
+negative correlation (high values of one variable tend to
+coincide with low values of the other).
+
# Narrow down to numeric variables and fid correlation
+corr_mat <- nigerian_songs %>%
+ select(where(is.numeric)) %>%
+ cor()
+
+# Visualize correlation matrix
+corrplot(corr_mat, order = 'AOE', col = c('white', 'black'), bg = 'gold2')
+
+
The data is not strongly correlated except between
+energy and loudness, which makes sense, given
+that loud music is usually pretty energetic. Popularity has
+a correspondence to release date, which also makes sense,
+as more recent songs are probably more popular. Length and energy seem
+to have a correlation too.
+
It will be interesting to see what a clustering algorithm can make of
+this data!
+
+🎓 Note that correlation does not imply causation! We have proof of
+correlation but no proof of causation. An amusing web site
+has some visuals that emphasize this point.
+
+
+
+
2. Explore data distribution
+
Let’s ask some more subtle questions. Are the genres significantly
+different in the perception of their danceability, based on their
+popularity? Let’s examine our top three genres data distribution for
+popularity and danceability along a given x and y axis using density
+plots.
+
# Perform 2D kernel density estimation
+density_estimate_2d <- nigerian_songs %>%
+ ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre)) +
+ geom_density_2d(bins = 5, size = 1) +
+ paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry") +
+ xlim(-20, 80) +
+ ylim(0, 1.2)
+
+# Density plot based on the popularity
+density_estimate_pop <- nigerian_songs %>%
+ ggplot(mapping = aes(x = popularity, fill = artist_top_genre, color = artist_top_genre)) +
+ geom_density(size = 1, alpha = 0.5) +
+ paletteer::scale_fill_paletteer_d("RSkittleBrewer::wildberry") +
+ paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry") +
+ theme(legend.position = "none")
+
+# Density plot based on the danceability
+density_estimate_dance <- nigerian_songs %>%
+ ggplot(mapping = aes(x = danceability, fill = artist_top_genre, color = artist_top_genre)) +
+ geom_density(size = 1, alpha = 0.5) +
+ paletteer::scale_fill_paletteer_d("RSkittleBrewer::wildberry") +
+ paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry")
+
+
+# Patch everything together
+library(patchwork)
+density_estimate_2d / (density_estimate_pop + density_estimate_dance)
+
+
We see that there are concentric circles that line up, regardless of
+genre. Could it be that Nigerian tastes converge at a certain level of
+danceability for this genre?
+
In general, the three genres align in terms of their popularity and
+danceability. Determining clusters in this loosely-aligned data will be
+a challenge. Let’s see whether a scatter plot can support this.
+
# A scatter plot of popularity and danceability
+scatter_plot <- nigerian_songs %>%
+ ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre, shape = artist_top_genre)) +
+ geom_point(size = 2, alpha = 0.8) +
+ paletteer::scale_color_paletteer_d("futurevisions::mars")
+
+# Add a touch of interactivity
+ggplotly(scatter_plot)
+
+
+
A scatterplot of the same axes shows a similar pattern of
+convergence.
+
In general, for clustering, you can use scatterplots to show clusters
+of data, so mastering this type of visualization is very useful. In the
+next lesson, we will take this filtered data and use k-means clustering
+to discover groups in this data that see to overlap in interesting
+ways.
+
+
---
title: 'Introduction to clustering: Clean, prep and visualize your data'
output:
  html_document:
    df_print: paged
    theme: flatly
    highlight: breezedark
    toc: yes
    toc_float: yes
    code_download: yes
---

## **Nigerian Music scraped from Spotify - an analysis**

Clustering is a type of [Unsupervised Learning](https://wikipedia.org/wiki/Unsupervised_learning) that presumes that a dataset is unlabelled or that its inputs are not matched with predefined outputs. It uses various algorithms to sort through unlabeled data and provide groupings according to patterns it discerns in the data.

[**Pre-lecture quiz**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/27/)

### **Introduction**

[Clustering](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124) is very useful for data exploration. Let's see if it can help discover trends and patterns in the way Nigerian audiences consume music.

> ✅ Take a minute to think about the uses of clustering. In real life, clustering happens whenever you have a pile of laundry and need to sort out your family members' clothes 🧦👕👖🩲. In data science, clustering happens when trying to analyze a user's preferences, or determine the characteristics of any unlabeled dataset. Clustering, in a way, helps make sense of chaos, like a sock drawer.

In a professional setting, clustering can be used to determine things like market segmentation, determining what age groups buy what items, for example. Another use would be anomaly detection, perhaps to detect fraud from a dataset of credit card transactions. Or you might use clustering to determine tumors in a batch of medical scans.

✅ Think a minute about how you might have encountered clustering 'in the wild', in a banking, e-commerce, or business setting.

> 🎓 Interestingly, cluster analysis originated in the fields of Anthropology and Psychology in the 1930s. Can you imagine how it might have been used?

Alternately, you could use it for grouping search results - by shopping links, images, or reviews, for example. Clustering is useful when you have a large dataset that you want to reduce and on which you want to perform more granular analysis, so the technique can be used to learn about data before other models are constructed.

✅ Once your data is organized in clusters, you assign it a cluster Id, and this technique can be useful when preserving a dataset's privacy; you can instead refer to a data point by its cluster id, rather than by more revealing identifiable data. Can you think of other reasons why you'd refer to a cluster Id rather than other elements of the cluster to identify it?

### Getting started with clustering

> 🎓 How we create clusters has a lot to do with how we gather up the data points into groups. Let's unpack some vocabulary:
>
> 🎓 ['Transductive' vs. 'inductive'](https://wikipedia.org/wiki/Transduction_(machine_learning))
>
> Transductive inference is derived from observed training cases that map to specific test cases. Inductive inference is derived from training cases that map to general rules which are only then applied to test cases.
>
> An example: Imagine you have a dataset that is only partially labelled. Some things are 'records', some 'cds', and some are blank. Your job is to provide labels for the blanks. If you choose an inductive approach, you'd train a model looking for 'records' and 'cds', and apply those labels to your unlabeled data. This approach will have trouble classifying things that are actually 'cassettes'. A transductive approach, on the other hand, handles this unknown data more effectively as it works to group similar items together and then applies a label to a group. In this case, clusters might reflect 'round musical things' and 'square musical things'.
>
> 🎓 ['Non-flat' vs. 'flat' geometry](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)
>
> Derived from mathematical terminology, non-flat vs. flat geometry refers to the measure of distances between points by either 'flat' ([Euclidean](https://wikipedia.org/wiki/Euclidean_geometry)) or 'non-flat' (non-Euclidean) geometrical methods.
>
> 'Flat' in this context refers to Euclidean geometry (parts of which are taught as 'plane' geometry), and non-flat refers to non-Euclidean geometry. What does geometry have to do with machine learning? Well, as two fields that are rooted in mathematics, there must be a common way to measure distances between points in clusters, and that can be done in a 'flat' or 'non-flat' way, depending on the nature of the data. [Euclidean distances](https://wikipedia.org/wiki/Euclidean_distance) are measured as the length of a line segment between two points. [Non-Euclidean distances](https://wikipedia.org/wiki/Non-Euclidean_geometry) are measured along a curve. If your data, visualized, seems to not exist on a plane, you might need to use a specialized algorithm to handle it.

![Infographic by Dasani Madipalli](../../images/flat-nonflat.png){width="500"}

> 🎓 ['Distances'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)
>
> Clusters are defined by their distance matrix, e.g. the distances between points. This distance can be measured a few ways. Euclidean clusters are defined by the average of the point values, and contain a 'centroid' or center point. Distances are thus measured by the distance to that centroid. Non-Euclidean distances refer to 'clustroids', the point closest to other points. Clustroids in turn can be defined in various ways.
>
> 🎓 ['Constrained'](https://wikipedia.org/wiki/Constrained_clustering)
>
> [Constrained Clustering](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf) introduces 'semi-supervised' learning into this unsupervised method. The relationships between points are flagged as 'cannot link' or 'must-link' so some rules are forced on the dataset.
>
> An example: If an algorithm is set free on a batch of unlabelled or semi-labelled data, the clusters it produces may be of poor quality. In the example above, the clusters might group 'round music things' and 'square music things' and 'triangular things' and 'cookies'. If given some constraints, or rules to follow ("the item must be made of plastic", "the item needs to be able to produce music") this can help 'constrain' the algorithm to make better choices.
>
> 🎓 'Density'
>
> Data that is 'noisy' is considered to be 'dense'. The distances between points in each of its clusters may prove, on examination, to be more or less dense, or 'crowded' and thus this data needs to be analyzed with the appropriate clustering method. [This article](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html) demonstrates the difference between using K-Means clustering vs. HDBSCAN algorithms to explore a noisy dataset with uneven cluster density.

Deepen your understanding of clustering techniques in this [Learn module](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott)

### **Clustering algorithms**

There are over 100 clustering algorithms, and their use depends on the nature of the data at hand. Let's discuss some of the major ones:

-   **Hierarchical clustering**. If an object is classified by its proximity to a nearby object, rather than to one farther away, clusters are formed based on their members' distance to and from other objects. Hierarchical clustering is characterized by repeatedly combining two clusters.

![Infographic by Dasani Madipalli](../../images/hierarchical.png){width="500"}

-   **Centroid clustering**. This popular algorithm requires the choice of 'k', or the number of clusters to form, after which the algorithm determines the center point of a cluster and gathers data around that point. [K-means clustering](https://wikipedia.org/wiki/K-means_clustering) is a popular version of centroid clustering which separates a data set into pre-defined K groups. The center is determined by the nearest mean, thus the name. The squared distance from the cluster is minimized.![Infographic by Dasani Madipalli](../../images/centroid.png){width="500"}

-   **Distribution-based clustering**. Based in statistical modeling, distribution-based clustering centers on determining the probability that a data point belongs to a cluster, and assigning it accordingly. Gaussian mixture methods belong to this type.

-   **Density-based clustering**. Data points are assigned to clusters based on their density, or their grouping around each other. Data points far from the group are considered outliers or noise. DBSCAN, Mean-shift and OPTICS belong to this type of clustering.

-   **Grid-based clustering**. For multi-dimensional datasets, a grid is created and the data is divided amongst the grid's cells, thereby creating clusters.

The best way to learn about clustering is to try it for yourself, so that's what you'll do in this exercise.

We'll require some packages to knock-off this module. You can have them installed as: `install.packages(c('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork'))`

Alternatively, the script below checks whether you have the packages required to complete this module and installs them for you in case some are missing.

```{r}
suppressWarnings(if(!require("pacman")) install.packages("pacman"))

pacman::p_load('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork')
```

```{r setup}
knitr::opts_chunk$set(warning = F, message = F)

```

## Exercise - cluster your data

Clustering as a technique is greatly aided by proper visualization, so let's get started by visualizing our music data. This exercise will help us decide which of the methods of clustering we should most effectively use for the nature of this data.

Let's hit the ground running by importing the data.

```{r}
# Load the core tidyverse and make it available in your current R session
library(tidyverse)

# Import the data into a tibble
df <- read_csv(file = "https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/5-Clustering/data/nigerian-songs.csv")

# View the first 5 rows of the data set
df %>% 
  slice_head(n = 5)

```

Sometimes, we may want some little more information on our data. We can have a look at the `data` and `its structure` by using the [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) function:

```{r}
# Glimpse into the data set
df %>% 
  glimpse()
```

Good job!💪

We can observe that `glimpse()` will give you the total number of rows (observations) and columns (variables), then, the first few entries of each variable in a row after the variable name. In addition, the *data type* of the variable is given immediately after each variable's name inside `< >`.

`DataExplorer::introduce()` can summarize this information neatly:

```{r DataExplorer}
# Describe basic information for our data
df %>% 
  introduce()

# A visual display of the same
df %>% 
  plot_intro()

```

Awesome! We have just learnt that our data has no missing values.

While we are at it, we can explore common central tendency statistics (e.g [mean](https://en.wikipedia.org/wiki/Arithmetic_mean) and [median](https://en.wikipedia.org/wiki/Median)) and measures of dispersion (e.g [standard deviation](https://en.wikipedia.org/wiki/Standard_deviation)) using `summarytools::descr()`

```
# Describe common statistics
df %>% descr(stats = "common")

```

Let's look at the general values of the data. Note that popularity can be `0`, which show songs that have no ranking. We'll remove those shortly.

> 🤔 If we are working with clustering, an unsupervised method that does not require labeled data, why are we showing this data with labels? In the data exploration phase, they come in handy, but they are not necessary for the clustering algorithms to work.

### 1. Explore popular genres

Let's go ahead and find out the most popular genres 🎶 by making a count of the instances it appears.

```{r count_genres}
# Popular genres
top_genres <- df %>% 
  count(artist_top_genre, sort = TRUE) %>% 
# Encode to categorical and reorder the according to count
  mutate(artist_top_genre = factor(artist_top_genre) %>% fct_inorder())

# Print the top genres
top_genres

```

That went well! They say a picture is worth a thousand rows of a data frame (actually nobody ever says that 😅). But you get the gist of it, right?

One way to visualize categorical data (character or factor variables) is using barplots. Let's make a barplot of the top 10 genres:

```{r bar_plot_genre}
# Change the default gray theme
theme_set(theme_light())

# Visualize popular genres
top_genres %>%
  slice(1:10) %>% 
  ggplot(mapping = aes(x = artist_top_genre, y = n,
                       fill = artist_top_genre)) +
  geom_col(alpha = 0.8) +
  paletteer::scale_fill_paletteer_d("rcartocolor::Vivid") +
  ggtitle("Top genres") +
  theme(plot.title = element_text(hjust = 0.5),
        # Rotates the X markers (so we can read them)
    axis.text.x = element_text(angle = 90))
```

Now it's way easier to identify that we have `missing` genres 🧐!

> A good visualisation will show you things that you did not expect, or raise new questions about the data - Hadley Wickham and Garrett Grolemund, [R For Data Science](https://r4ds.had.co.nz/introduction.html)

Note, when the top genre is described as `Missing`, that means that Spotify did not classify it, so let's get rid of it.

```{r remove_missing}
# Visualize popular genres
top_genres %>%
  filter(artist_top_genre != "Missing") %>% 
  slice(1:10) %>% 
  ggplot(mapping = aes(x = artist_top_genre, y = n,
                       fill = artist_top_genre)) +
  geom_col(alpha = 0.8) +
  paletteer::scale_fill_paletteer_d("rcartocolor::Vivid") +
  ggtitle("Top genres") +
  theme(plot.title = element_text(hjust = 0.5),
        # Rotates the X markers (so we can read them)
    axis.text.x = element_text(angle = 90))
```

From the little data exploration, we learn that the top three genres dominate this dataset. Let's concentrate on `afro dancehall`, `afropop`, and `nigerian pop`, additionally filter the dataset to remove anything with a 0 popularity value (meaning it was not classified with a popularity in the dataset and can be considered noise for our purposes):

```{r new_dataset}
nigerian_songs <- df %>% 
  # Concentrate on top 3 genres
  filter(artist_top_genre %in% c("afro dancehall", "afropop","nigerian pop")) %>% 
  # Remove unclassified observations
  filter(popularity != 0)



# Visualize popular genres
nigerian_songs %>%
  count(artist_top_genre) %>%
  ggplot(mapping = aes(x = artist_top_genre, y = n,
                       fill = artist_top_genre)) +
  geom_col(alpha = 0.8) +
  paletteer::scale_fill_paletteer_d("ggsci::category10_d3") +
  ggtitle("Top genres") +
  theme(plot.title = element_text(hjust = 0.5))
```

Let's see whether there is any apparent linear relationship among the numerical variables in our data set. This relationship is quantified mathematically by the [correlation statistic](https://en.wikipedia.org/wiki/Correlation).

The correlation statistic is a value between -1 and 1 that indicates the strength of a relationship. Values above 0 indicate a *positive* correlation (high values of one variable tend to coincide with high values of the other), while values below 0 indicate a *negative* correlation (high values of one variable tend to coincide with low values of the other).

```{r correlation}
# Narrow down to numeric variables and fid correlation
corr_mat <- nigerian_songs %>% 
  select(where(is.numeric)) %>% 
  cor()

# Visualize correlation matrix
corrplot(corr_mat, order = 'AOE', col = c('white', 'black'), bg = 'gold2')  
```

The data is not strongly correlated except between `energy` and `loudness`, which makes sense, given that loud music is usually pretty energetic. `Popularity` has a correspondence to `release date`, which also makes sense, as more recent songs are probably more popular. Length and energy seem to have a correlation too.

It will be interesting to see what a clustering algorithm can make of this data!

> 🎓 Note that correlation does not imply causation! We have proof of correlation but no proof of causation. An [amusing web site](https://tylervigen.com/spurious-correlations) has some visuals that emphasize this point.

### 2. Explore data distribution

Let's ask some more subtle questions. Are the genres significantly different in the perception of their danceability, based on their popularity? Let's examine our top three genres data distribution for popularity and danceability along a given x and y axis using [density plots](https://www.khanacademy.org/math/ap-statistics/density-curves-normal-distribution-ap/density-curves/v/density-curves).

```{r}
# Perform 2D kernel density estimation
density_estimate_2d <- nigerian_songs %>% 
  ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre)) +
  geom_density_2d(bins = 5, size = 1) +
  paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry") +
  xlim(-20, 80) +
  ylim(0, 1.2)

# Density plot based on the popularity
density_estimate_pop <- nigerian_songs %>% 
  ggplot(mapping = aes(x = popularity, fill = artist_top_genre, color = artist_top_genre)) +
  geom_density(size = 1, alpha = 0.5) +
  paletteer::scale_fill_paletteer_d("RSkittleBrewer::wildberry") +
  paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry") +
  theme(legend.position = "none")

# Density plot based on the danceability
density_estimate_dance <- nigerian_songs %>% 
  ggplot(mapping = aes(x = danceability, fill = artist_top_genre, color = artist_top_genre)) +
  geom_density(size = 1, alpha = 0.5) +
  paletteer::scale_fill_paletteer_d("RSkittleBrewer::wildberry") +
  paletteer::scale_color_paletteer_d("RSkittleBrewer::wildberry")


# Patch everything together
library(patchwork)
density_estimate_2d / (density_estimate_pop + density_estimate_dance)
```

We see that there are concentric circles that line up, regardless of genre. Could it be that Nigerian tastes converge at a certain level of danceability for this genre?

In general, the three genres align in terms of their popularity and danceability. Determining clusters in this loosely-aligned data will be a challenge. Let's see whether a scatter plot can support this.

```{r scatter_plot}
# A scatter plot of popularity and danceability
scatter_plot <- nigerian_songs %>% 
  ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre, shape = artist_top_genre)) +
  geom_point(size = 2, alpha = 0.8) +
  paletteer::scale_color_paletteer_d("futurevisions::mars")

# Add a touch of interactivity
ggplotly(scatter_plot)
```

A scatterplot of the same axes shows a similar pattern of convergence.

In general, for clustering, you can use scatterplots to show clusters of data, so mastering this type of visualization is very useful. In the next lesson, we will take this filtered data and use k-means clustering to discover groups in this data that see to overlap in interesting ways.

## **🚀 Challenge**

In preparation for the next lesson, make a chart about the various clustering algorithms you might discover and use in a production environment. What kinds of problems is the clustering trying to address?

## [**Post-lecture quiz**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/28/)

## **Review & Self Study**

Before you apply clustering algorithms, as we have learned, it's a good idea to understand the nature of your dataset. Read more on this topic [here](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)

Deepen your understanding of clustering techniques:

-   [Train and Evaluate Clustering Models using Tidymodels and friends](https://rpubs.com/eR_ic/clustering)

-   Bradley Boehmke & Brandon Greenwell, [*Hands-On Machine Learning with R*](https://bradleyboehmke.github.io/HOML/)*.*

## **Assignment**

[Research other visualizations for clustering](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/assignment.md)

## THANK YOU TO:

[Jen Looper](https://www.twitter.com/jenlooper) for creating the original Python version of this module ♥️

[`Dasani Madipalli`](https://twitter.com/dasani_decoded) for creating the amazing illustrations that make machine learning concepts more interpretable and easier to understand.

Happy Learning,

[Eric](https://twitter.com/ericntay), Gold Microsoft Learn Student Ambassador.
