Machine Learning Powered Naughty List: A Festive Tale of Leaping Rivers | R bloggers

Introduction

Ho ho ho! 🎅 The holidays are here and at Jumping Rivers we decorate the halls with dates, not just tinsel. While elves are busy checking their lists twice, we thought: why not take something with us magic of machine learning to Christmas? After all, what’s more festive than combining predictive models with candy canes, cookies and a dash of office mischief?

This blog is your ticket to a code-driven journey as we discover who’s been naughty, who’s nice, and who’s floating naughty in between.

We’ll guide you step by step through the process: gathering the team data, coming up with the most festive features, training our ML model, and revealing the results with a cheeky, festive twist. So grab a mug of cocoa, put on your favorite Christmas stockings and let’s dive into the Jumping Rivers ML-Powered Naughty List adventure!

Note: All data, labels and results in this post are completely fictional and randomly generated for festive fun.

Step 1: Data collection and team introduction

Our first step was to collect our dataset. We used the Jumping Rivers team as participants, assigning playful, holiday-themed features to reflect their potential “naughty” traits. Here’s a quick, festive overview in side-by-side table format:

Each participant is assigned four playful characteristics that represent holiday mischief:

• Ate too many cookies 🍪
• Forgot to send Christmas cards 💌
• Sung out of tune during Christmas carols 🎶
• Gift wrapping disasters 🎁

Every name on this list now has a chance to win the ultimate festive title: Naughty, Nice, or Mildly Mischievous. Rumor has it that Santa’s Intern Elf has already claimed the top spot for cookie mischief, while Rudolph keeps the dashboards spotless and Frosty the Snow Analyst maintains a perfectly balanced winter score.

Step 2: Feature engineering

For ML purposes, names were numerically coded. This is not meaningful in a real ML context, but serves as a demonstration of preprocessing. Modeling features include:

• Name (encoded)
• Ate too many cookies
• Forgot to send Christmas cards
• Sung out of tune
• Gift wrapping disasters

Step 3: Model training

We chose a Random Forest classifier in R for its simplicity and interpretability. The model was trained on the dataset to predict the ‘naughty’ label based on the four behavioral traits and the encoded name. Although the dataset is small and playful, this demonstrates a good ML workflow: data collection, preprocessing, model training, prediction.

library(tidyverse)
library(randomForest)
library(ggplot2)

The first thing we need to do is set up a vector containing the team members, along with some Christmas temps Santa’s Intern Elf, Rudolph the Data Reindeer, and Frosty the Snow Analyst.

# Team members
team = c(
 "Esther Gillespie",
 "Colin Gillespie",
 "Sebastian Mellor",
 "Martin Smith",
 "Richard Brown",
 "Shane Halloran",
 "Mitchell Oliver",
 "Keith Newman",
 "Russ Hyde",
 "Gigi Kenneth",
 "Pedro Silva",
 "Carolyn Wilson",
 "Myles Mitchell",
 "Theo Roe",
 "Tim Brock",
 "Osheen MacOscar",
 "Emily Wales",
 "Amieroh Abrahams",
 "Deborah Washington",
 "Susan Smith",
 "Santa's Intern Elf",
 "Rudolph the Data Reindeer",
 "Frosty the Snow Analyst"
)

Now we have the team members we want random generate some values ​​for the model features.

# Randomly generate playful 'naughty traits'
set.seed(51)
df = tibble(
 name = team,
 ate_too_many_cookies = sample(0:1, length(team), replace = TRUE),
 forgot_to_send_cards = sample(0:1, length(team), replace = TRUE),
 sang_off_key = sample(0:1, length(team), replace = TRUE),
 wrapping_disaster = sample(0:1, length(team), replace = TRUE),
 naughty = sample(0:1, length(team), replace = TRUE)
)


# Encode names as numeric
df$name_encoded = as.numeric(factor(df$name))

Next on the list is to set up a vector of features we want to use, and then train the model. We can then use the model to predict our fictional naughtiness score for each team member! We see that Theo is at the top of the list, closely followed by Osheen.

features = c(
 "name_encoded",
 "ate_too_many_cookies",
 "forgot_to_send_cards",
 "sang_off_key",
 "wrapping_disaster"
)


# Train Random Forest
rf_model = randomForest(x = df[, features],
 y = as.factor(df$naughty),
 ntree = 100)


# Predict naughtiness
df$predicted_naughty = predict(rf_model, df[, features])
df$naughtiness_score = predict(rf_model, df[, features],
 type = "prob")[, 2]


# Create the Naughty List
naughty_list = df %>%
 arrange(desc(naughtiness_score)) %>%
 select(name, naughtiness_score, predicted_naughty)

print(naughty_list)

## # A tibble: 23 × 3
## name naughtiness_score predicted_naughty
##   
## 1 Theo Roe 0.76 1
## 2 Osheen MacOscar 0.74 1
## 3 Myles Mitchell 0.72 1
## 4 Esther Gillespie 0.68 1
## 5 Deborah Washington 0.66 1
## 6 Tim Brock 0.59 1
## 7 Amieroh Abrahams 0.55 1
## 8 Santa's Intern Elf 0.48 0
## 9 Carolyn Wilson 0.38 0
## 10 Susan Smith 0.2 0
## # ℹ 13 more rows

The last thing to do is visualize our results with
{ggplot2}:

# Fun bar plot
ggplot(naughty_list,
 aes(x = reorder(name, naughtiness_score),
 y = naughtiness_score,
 fill = as.factor(predicted_naughty))) +
 geom_col() +
 coord_flip() +
 scale_fill_manual(values = c("0" = "forestgreen",
 "1" = "darkred"),
 labels = c("Nice", "Naughty")) +
 labs(title = "🎅 Jumping Rivers ML-powered Naughty List 🎄",
 x = "Team Member",
 y = "Naughtiness Score",
 fill = "Status",
 alt = "Jumping Rivers Naughty List") +
 theme_minimal(base_family = "outfit")

Step 4: Analysis and notes

After generating predictions, we can interpret the naughty list. The highest naughty scores indicate which participants are the most naughty according to our playful model.

Observations from this analysis include:

• Cookie Enthusiasts: Participants with multiple cookie violations scored higher.
• Gift wrapping chaos: Those whose gifts resembled abstract art contributed to higher scores.
• Musical mishaps: Deviant carolers were flagged as naughty.
• Forgotten Cards: Small errors in festive correspondence saw some move up the naughty rankings.

Special mentions:

• Unsurprisingly, Theo tops the naughty list.
• Santa’s Intern Elf did well and above all remained nice.
• Shane had the best score and I’m sure Santa will be very nice to him this year!

This analysis provides both a technical demonstration of the ML workflow and a fun story that will engage readers this holiday season.

Step 5: Conclusion

This project shows how machine learning can be used in creative ways beyond traditional business use cases. By combining features with a good ML workflow, we’ve created a light-hearted, festive story fit for a blog, while also reinforcing good practices in data collection, preprocessing, modeling and visualization.

Ultimately, the Jumping Rivers ML-Powered Naughty List is a celebration of data science, team culture, and holiday fun. Whether you’re naughty or nice, we hope this inspires creative applications of ML in festive contexts.

For updates and revisions to this article, see the original post

Related