Spotify Music Data Analysis Project in R

What makes a song popular? Well, in this Spotify Music Data Analysis project using R, we will analyze some real Spotify music data to decode the musical DNA behind various hit songs. 

We will peek into over 2,000 tracks, examining features like energy, danceability, valence, and acousticness through statistical analysis and compelling visualizations.

This blog will explain every step from data cleaning to building a Random Forest model that achieves 76% accuracy in predicting song popularity. You'll learn essential data science skills, including correlation analysis, feature engineering, and machine learning.

Upskill Yourself With The Top 25+ R Projects for Beginners to Boost Your Data Science Skills in 2025

What Should You Know Before Starting the Spotify Music Data Analysis Project?

Before starting the Spotify Music Data Analysis project in R, it’s important to know some key concepts and skills. These will help you use the dataset and identify relevant patterns:

Crack the Code to an opportunity rich Data Science Career!

Master AI, ML, and Generative AI with upGrad’s premier programs, 100% online, industry-ready, and designed for tomorrow’s tech leaders.

• Master’s Degree in Artificial Intelligence and Data Science From OPJGU
• Executive Diploma in Data Science and AI from IIITB
• Generative AI Foundations Certificate Program

Time, Effort & Skills: What You Need Before Getting Started

This music data analysis project requires the following:

Read This: Benefits of Learning R: Why It’s Essential for Data Science

What Powers the Analysis: Tools, Models, and R Packages

To run this music data analysis project, we need certain tools, models, and R libraries, which are listed in the table below.

Steps and Code Explanation For Voice Data Analysis in R

To start working with this music data analysis project, we need to run the code in R, which will be discussed below. The code will be run in R, and this section will break down each step with the code for your understanding.

Step 1: Configure Google Colab for R Programming

To begin working with R in Google Colab, you'll first need to switch the notebook's runtime from Python to R. This setup allows you to run R code seamlessly within the Colab environment.

Steps to switch to R:

1. Open a new notebook in Google Colab
2. Click on Runtime in the top menu
3. Select Change runtime type
4. In the "Language" dropdown, choose R
5. Click Save

Step 2: Install and Load Essential R Libraries

Before starting the analysis of the data, we need to install and load all the required R packages. This step ensures that the environment is ready for data cleaning, visualization, and modeling. The code for this step is:

# Installing required packages (run once)
# These are like tools we need for our analysis
install.packages(c("dplyr", "ggplot2", "readr", "corrplot",
                   "plotly", "GGally", "caret", "viridis",
                   "reshape2", "knitr"))

# Loading libraries (run every time you start)
# Think of this as opening your toolbox
library(dplyr)      # For data manipulation - like Excel functions
library(ggplot2)    # For creating beautiful charts
library(readr)      # For reading CSV files
library(corrplot)   # For correlation plots
library(plotly)     # For interactive charts
library(GGally)     # For advanced plotting
library(caret)      # For machine learning
library(viridis)    # For beautiful color schemes
library(reshape2)   # For data reshaping
library(knitr)      # For nice table formatting

# Let's confirm everything loaded successfully
print("SpotiTunes Analytics Setup Complete!")

The code will give the output and confirm the installation and loading of the packages and libraries.

Here’s Something For You: The Ultimate R Cheat Sheet for Data Science Enthusiasts

Step 3: Upload and Load the Spotify Dataset

As the setup is now ready, it's time to upload the dataset and load it into R. This step allows us to begin exploring and analyzing the contents of the Spotify music data. The code used in this process is:

Upload your CSV file to Colab first, then read it
# In Colab, click the file icon on the left, then upload your Spotify data.csv

# Reading the dataset
# This loads your Spotify data into R's memory
spotify_data <- read_csv("Spotify data.csv")

# Let's take our first look at the data
print("Dataset loaded successfully!")
print(paste("Number of songs:", nrow(spotify_data)))
print(paste("Number of features:", ncol(spotify_data)))

# Display first few rows to understand our data
head(spotify_data)

After the successful execution, the code will give us the output as:

The above table gives us an idea of what the data looks like.

What’s Hidden in Your Data? Find out with our free Clustering Unsupervised Learning course. Learn K-Means, uncover clusters, and explore patterns like a data pro. Join now.

Step 4: Explore and Understand the Dataset

Before starting our analysis or modeling, it's important to check the dataset. This step will help us understand the structure, identify missing values, and get familiar with the available features. The code for this step is:

Getting to know our dataset better
# This is like getting familiar with a new playlist

# Basic information about the dataset
str(spotify_data)  # Shows data types and structure
summary(spotify_data)  # Shows statistical summaries

# Check for missing values
# Missing data can affect our analysis
missing_values <- colSums(is.na(spotify_data))
print("Missing values in each column:")
print(missing_values)

# Let's look at the column names to understand what we have
print("Our musical features:")
print(colnames(spotify_data))

The output for this code is: 

The above output shows that:

• The dataset has 2,017 songs and 17 features, including both audio metrics and song metadata.
• No missing values were detected, which means that the data is clean.
• Features include acousticness, energy, tempo, valence, song_title, and artist.

Also Read: R vs Python Data Science: The Difference

Step 5: Clean and Enrich the Data

Before analysis, we need to remove duplicates and create new categorical variables for better insight. This step makes the dataset easier to interpret and visualize. Here is the code:

# Cleaning our data - like tuning instruments before a concert

# Remove any duplicate songs
spotify_clean <- spotify_data %>%
  distinct(song_title, artist, .keep_all = TRUE)

print(paste("Removed", nrow(spotify_data) - nrow(spotify_clean), "duplicate songs"))

# Create a popularity category for easier analysis
# Target = 1 means popular, Target = 0 means less popular
spotify_clean <- spotify_clean %>%
  mutate(
    popularity_label = ifelse(target == 1, "Popular", "Less Popular"),
    # Create energy level categories
    energy_level = case_when(
      energy < 0.3 ~ "Low Energy",
      energy < 0.7 ~ "Medium Energy",
      TRUE ~ "High Energy"
    ),
    # Create danceability categories
    dance_level = case_when(
      danceability < 0.3 ~ "Not Danceable",
      danceability < 0.7 ~ "Moderately Danceable",
      TRUE ~ "Very Danceable"
    )
  )

print("Data cleaning complete!")

The output for the above code is:

This means:

• 35 duplicate songs were removed from the dataset.
• New columns like popularity_label, energy_level, and dance_level were successfully added.
• The data is now cleaned and categorized for easier analysis.

Step 6: Analyze Song Popularity Trends

In this step, we will check how popular and less popular songs differ in terms of key musical features. We also visualize the overall distribution of popularity in the dataset. The code for this section is:

# Let's explore our musical universe!

# 1. Basic statistics about popular vs less popular songs
popularity_summary <- spotify_clean %>%
  group_by(popularity_label) %>%
  summarise(
    count = n(),
    avg_energy = round(mean(energy), 3),
    avg_danceability = round(mean(danceability), 3),
    avg_valence = round(mean(valence), 3),
    avg_loudness = round(mean(loudness), 3)
  )

print("Popularity Analysis:")
knitr::kable(popularity_summary)

# 2. Distribution of song popularity
ggplot(spotify_clean, aes(x = popularity_label)) +
  geom_bar(fill = c("#FF6B35", "#004E64"), alpha = 0.8) +
  labs(title = "Distribution of Song Popularity",
       subtitle = "How many popular vs less popular songs do we have?",
       x = "Popularity Category",
       y = "Number of Songs") +
  theme_minimal() +
  theme(plot.title = element_text(size = 16, hjust = 0.5),
        plot.subtitle = element_text(hjust = 0.5))

The output for this section will be as follows:

[1] " Popularity Analysis:"

The above code also gives us a graph:

This output shows:

• Balanced classes: Popular (993) vs Less Popular (989), great for modeling without heavy rebalancing.
• “Feel‑good” bias: Popular songs have higher danceability, energy, and valence (all slightly higher), suggesting they’re more upbeat and danceable.
• Loudness isn’t the driver: Popular tracks are actually a bit quieter on average (−7.31 dB vs −6.81 dB), so being louder doesn’t map directly to popularity here.

Here’s Something You Should Know: Data Preprocessing in Machine Learning: 11 Key Steps You Must Know!

Step 7: Visualize the Sound of Popularity

This step gives us more insights into how energy, danceability, valence, and tempo vary across popular and less popular songs. Visualizations help us uncover subtle patterns and trends in musical features. The code for this step is:

# Let's visualize the musical DNA of popular songs!

# 1. Energy vs Danceability scatter plot
p1 <- ggplot(spotify_clean, aes(x = energy, y = danceability, color = popularity_label)) +
  geom_point(alpha = 0.6, size = 2) +
  scale_color_manual(values = c("#FF6B35", "#004E64")) +
  labs(title = "🕺 Energy vs Danceability",
       subtitle = "Do popular songs have more energy and danceability?",
       x = "Energy Level",
       y = "Danceability",
       color = "Popularity") +
  theme_minimal()

print(p1)

# 2. Valence (Musical Happiness) distribution
p2 <- ggplot(spotify_clean, aes(x = valence, fill = popularity_label)) +
  geom_histogram(alpha = 0.7, bins = 30, position = "identity") +
  scale_fill_manual(values = c("#FF6B35", "#004E64")) +
  labs(title = "Musical Happiness Distribution",
       subtitle = "Are popular songs happier?",
       x = "Valence (0 = Sad, 1 = Happy)",
       y = "Number of Songs",
       fill = "Popularity") +
  theme_minimal()

print(p2)

# 3. Tempo analysis
p3 <- ggplot(spotify_clean, aes(x = popularity_label, y = tempo, fill = popularity_label)) +
  geom_boxplot(alpha = 0.7) +
  scale_fill_manual(values = c("#FF6B35", "#004E64")) +
  labs(title = "Tempo Comparison",
       subtitle = "Is there an optimal tempo for popularity?",
       x = "Popularity Category",
       y = "Tempo (BPM)",
       fill = "Popularity") +
  theme_minimal()

print(p3)

The above code will give us three graphs, each showing different characteristics:

This graph shows:

• Popular songs generally cluster in high energy and high danceability zones.
• Less popular tracks are more spread out across low-to-mid ranges.
• There's a visible positive trend; more energy often aligns with more danceability.

This graph shows:

• Popular songs lean more toward the higher valence (happier) end of the scale.
• Less popular songs show more spread across low-to-mid valence, suggesting a mix of moods.
• Happier songs are slightly more likely to be popular.

This graph shows:

• Both groups show similar median tempos, around 120–125 BPM.
• Popular songs have more tempo outliers, showing variety.
• There’s no clear “optimal” tempo, but both fall in the danceable BPM range.

You Can’t Miss This: What’s Special About Machine Learning?

Step 8: Measure Relationships with a Correlation Matrix

In this step, we quantify how musical features move together and which ones line up most with popularity (target). We’ll build and plot a correlation matrix, then list the features most (positively/negatively) associated with popularity.

# Let's find relationships between musical features

# Select numerical features for correlation
numerical_features <- spotify_clean %>%
  select(acousticness, danceability, energy, instrumentalness,
         liveness, loudness, speechiness, tempo, valence, target)

# Create correlation matrix
correlation_matrix <- cor(numerical_features)

# Visualize correlations
corrplot(correlation_matrix,
         method = "color",
         type = "upper",
         tl.cex = 0.8,
         tl.col = "black",
         title = "Musical Features Correlation Matrix",
         mar = c(0,0,2,0))

# Find strongest correlations with popularity (target)
target_correlations <- correlation_matrix[,"target"] %>%
  sort(decreasing = TRUE)

print("Features most correlated with popularity:")
print(round(target_correlations, 3))

The output of the above code is:

[1] "Features most correlated with popularity:"

The graph of this outcome is:

The above graph explains that:

• Popularity (target) has only weak correlations with all features; nothing alone strongly predicts it.
• Energy ↔ Loudness are strongly positively correlated, while acousticness is strongly negative with both (louder, energetic songs are less acoustic).
• Danceability and valence show a moderate positive link; happier songs tend to be more danceable.

Master the art of data analysis with our free Introduction to Data Analysis using Excel course. Learn pivot tables, formulas, and visualization techniques that top analysts swear by. Enroll now and make Excel your superpower!

Step 9: Build Deeper Insights with Rich Visuals

This step focuses on advanced, storytelling-style visualizations to highlight differences in song features and reveal which artists have the most consistent hit rate. Here’s the code:

# Create beautiful, insightful visualizations

# 1. Multi-feature comparison using violin plots
features_long <- spotify_clean %>%
  select(popularity_label, energy, danceability, valence, acousticness) %>%
  reshape2::melt(id.vars = "popularity_label")

ggplot(features_long, aes(x = popularity_label, y = value, fill = popularity_label)) +
  geom_violin(alpha = 0.7) +
  facet_wrap(~variable, scales = "free_y") +
  scale_fill_manual(values = c("#FF6B35", "#004E64")) +
  labs(title = "Musical Feature Comparison",
       subtitle = "How do different features vary between popular and less popular songs?",
       x = "Popularity Category",
       y = "Feature Value",
       fill = "Popularity") +
  theme_minimal() +
  theme(strip.text = element_text(size = 12, face = "bold"))

# 2. Top artists analysis
top_artists <- spotify_clean %>%
  group_by(artist) %>%
  summarise(
    total_songs = n(),
    popular_songs = sum(target),
    popularity_rate = round(popular_songs / total_songs * 100, 1)
  ) %>%
  filter(total_songs >= 3) %>%  # Artists with at least 3 songs
  arrange(desc(popularity_rate)) %>%
  head(10)

ggplot(top_artists, aes(x = reorder(artist, popularity_rate), y = popularity_rate)) +
  geom_col(fill = "#004E64", alpha = 0.8) +
  coord_flip() +
  labs(title = "Top 10 Artists by Success Rate",
       subtitle = "Artists with highest percentage of popular songs (min 3 songs)",
       x = "Artist",
       y = "Success Rate (%)") +
  theme_minimal()

The above code will give us two graphs that explain the following:

The above graph shows that:

• Popular songs tend to have higher energy, danceability, and valence compared to less popular ones.
• Acousticness is generally lower in popular songs, suggesting a preference for more produced or electronic sounds.
• These patterns highlight the musical qualities that may contribute to a track's popularity.

The above graph shows that:

• All listed artists have a 100% success rate, meaning every one of their songs in the dataset is marked as popular.
• Artists like Blood Orange, A$AP Rocky, and Beach House consistently released tracks that performed well.
• Only artists with at least 3 songs were considered to ensure meaningful success rates.

Join the Fundamentals of Deep Learning and Neural Networks free course to master neural networks, model training, and real-world AI applications. Learn from experts and earn a free certification. Start your deep learning journey today!

Step 10: Train a Logistic Regression to Predict Popularity

Here we split the data into train/test sets, fit a logistic regression using key audio features, evaluate its accuracy, and inspect which features are most statistically significant. The code for this section is:

# Let's build a simple model to predict song popularity!

# Prepare data for modeling
set.seed(123)  # For reproducible results

# Split data into training and testing sets
train_index <- createDataPartition(spotify_clean$target, p = 0.8, list = FALSE)
train_data <- spotify_clean[train_index, ]
test_data <- spotify_clean[-train_index, ]

print(paste("Training songs:", nrow(train_data)))
print(paste("Testing songs:", nrow(test_data)))

# Select features for our model
model_features <- c("acousticness", "danceability", "energy", "instrumentalness",
                   "liveness", "loudness", "speechiness", "tempo", "valence")

# Build a simple logistic regression model
model <- glm(target ~ .,
             data = train_data[, c("target", model_features)],
             family = "binomial")

# Make predictions
predictions <- predict(model, test_data, type = "response")
predicted_classes <- ifelse(predictions > 0.5, 1, 0)

# Calculate accuracy
accuracy <- mean(predicted_classes == test_data$target)
print(paste("Model Accuracy:", round(accuracy * 100, 2), "%"))

# Feature importance
feature_importance <- summary(model)$coefficients[,4]  # p-values
important_features <- sort(feature_importance[2:length(feature_importance)])
print("Most important features (lowest p-values):")
print(round(important_features, 4))

The output for this section is as follows:

[1] "Training songs: 1586"

[1] "Testing songs: 396"

[1] "Model Accuracy: 64.14 %"

[1] "Most important features (lowest p-values):"

Model Summary:

• Accuracy: The model predicts song popularity with 64.14% accuracy, a decent baseline for logistic regression.
• Top predictive features (based on lowest p-values):
  • Speechiness, instrumentalness, loudness, and acousticness are strongly significant (p-value ≈ 0).
  • Valence is also significant; it reflects musical positivity.
  • Liveness seems not useful (high p-value ≈ 0.64).

Level Up. Here’s Something For You: Also read: Data Science Project Ideas for Beginners | Python IDEs for Data Science and Machine Learning

Step 11: Upgrade Your Model with Random Forest

Now that we’ve tested a basic logistic regression, in this step, we will build a more powerful model. The Random Forest algorithm handles complex relationships and feature interactions better, which often leads to higher accuracy. Here’s the code:

# Install if not already installed
if (!require(randomForest)) install.packages("randomForest")
library(randomForest)

# Train a Random Forest model
set.seed(123)
rf_model <- randomForest(as.factor(target) ~ .,
                        data = train_data[, c("target", model_features)],
                        ntree = 100,
                        importance = TRUE)

# Make predictions
rf_predictions <- predict(rf_model, test_data, type = "prob")[,2]
rf_classes <- ifelse(rf_predictions > 0.5, 1, 0)

# Accuracy of the Random Forest model
rf_accuracy <- mean(rf_classes == test_data$target)
print(paste("Random Forest Accuracy:", round(rf_accuracy * 100, 2), "%"))

# Feature importance scores
importance(rf_model)

The output for this section is:

The Random Forest propels the accuracy to 76.01%, which is a solid gain over the logistic regression’s 64.14%, and it tells us which musical traits matter most.

Key takeaways:

• Accuracy ↑: 76.01% vs 64.14% (logistic). Random Forest captures non‑linear relationships better.
• Most influential features: Instrumentalness, loudness, speechiness, danceability (highest MeanDecreaseGini / MeanDecreaseAccuracy).
• Weaker signals: Liveness and tempo contribute the least to predictions here.

Conclusion

In this Spotify Music Data Analysis project, we used R in Google Colab to look into what makes a song popular by analyzing audio features such as energy, danceability, loudness, and speechiness. After cleaning and visualizing the dataset, we trained two models: a Logistic Regression and a more powerful Random Forest classifier.

The Random Forest model outperformed Logistic Regression with an accuracy of 76.01%, as compared to 64.14%, identifying instrumentalness, loudness, and speechiness as key predictors of popularity.

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles

Colab Link:
https://colab.research.google.com/drive/17HoemeiOPtDJgoWqNVtxOia5jRxX5fEl#scrollTo=06bFYquyv76C