README.md

In tidylearn: A Unified Tidy Interface to R's Machine Learning Ecosystem

tidylearn

Machine Learning for Tidynauts

Overview

tidylearn provides a unified tidyverse-compatible interface to R's machine learning ecosystem. It wraps proven packages like glmnet, randomForest, xgboost, e1071, cluster, and dbscan - you get the reliability of established implementations with the convenience of a consistent, tidy API.

What tidylearn does:

• Provides one consistent interface (tl_model()) to 20+ ML algorithms
• Returns tidy tibbles instead of varied output formats
• Offers unified ggplot2-based visualization across all methods
• Enables pipe-friendly workflows with %>%
• Orchestrates complex workflows combining multiple techniques

What tidylearn is NOT:

• A reimplementation of ML algorithms (uses established packages under the hood)
• A replacement for the underlying packages (you can access the raw model via model$fit)

Why tidylearn?

Each ML package in R has its own API, output format, and conventions. tidylearn provides a translation layer so you can:

| Without tidylearn | With tidylearn | | ------------------------------------- | ----------------------- | | Learn different APIs for each package | One API for everything | | Write custom code to extract results | Consistent tibble output | | Create different plots for each model | Unified visualization | | Manage package-specific quirks | Focus on your analysis |

The underlying algorithms are unchanged - tidylearn simply makes them easier to use together.

Installation

# Install from CRAN
install.packages("tidylearn")

# Or install development version from GitHub
# devtools::install_github("ces0491/tidylearn")

Quick Start

Unified Interface

A single tl_model() function dispatches to the appropriate underlying package:

library(tidylearn)

# Classification -> uses randomForest::randomForest()
model <- tl_model(iris, Species ~ ., method = "forest")

# Regression -> uses stats::lm()
model <- tl_model(mtcars, mpg ~ wt + hp, method = "linear")

# Regularization -> uses glmnet::glmnet()
model <- tl_model(mtcars, mpg ~ ., method = "lasso")

# Clustering -> uses stats::kmeans()
model <- tl_model(iris[,1:4], method = "kmeans", k = 3)

# PCA -> uses stats::prcomp()
model <- tl_model(iris[,1:4], method = "pca")

Tidy Output

All results come back as tibbles, ready for dplyr and ggplot2:

# Predictions as tibbles
predictions <- predict(model, new_data = test_data)

# Metrics as tibbles
metrics <- tl_evaluate(model, test_data)

# Easy to pipe
model %>%
  predict(test_data) %>%
  bind_cols(test_data) %>%
  ggplot(aes(x = actual, y = prediction)) +
  geom_point()

Access the Underlying Model

You always have access to the raw model from the underlying package:

model <- tl_model(iris, Species ~ ., method = "forest")

# Access the randomForest object directly
model$fit  # This is the randomForest::randomForest() result

# Use package-specific functions if needed
randomForest::varImpPlot(model$fit)

Wrapped Packages

tidylearn provides a unified interface to these established R packages:

Supervised Learning

| Method | Underlying Package | Function Called | | -------- | ------------------- | ----------------- | | "linear" | stats | lm() | | "polynomial" | stats | lm() with poly() | | "logistic" | stats | glm(..., family = binomial) | | "ridge", "lasso", "elastic_net" | glmnet | glmnet() | | "tree" | rpart | rpart() | | "forest" | randomForest | randomForest() | | "boost" | gbm | gbm() | | "xgboost" | xgboost | xgb.train() | | "svm" | e1071 | svm() | | "nn" | nnet | nnet() | | "deep" | keras | keras_model_sequential() |

Unsupervised Learning

| Method | Underlying Package | Function Called | |--------|-------------------|-----------------| | "pca" | stats | prcomp() | | "mds" | stats, MASS, smacof | cmdscale(), isoMDS(), etc. | | "kmeans" | stats | kmeans() | | "pam" | cluster | pam() | | "clara" | cluster | clara() | | "hclust" | stats | hclust() | | "dbscan" | dbscan | dbscan() |

Integration Workflows

Beyond wrapping individual packages, tidylearn provides orchestration functions that combine multiple techniques:

Dimensionality Reduction + Supervised Learning

# Reduce dimensions before classification
reduced <- tl_reduce_dimensions(iris, response = "Species",
                                method = "pca", n_components = 3)
model <- tl_model(reduced$data, Species ~ ., method = "logistic")

Cluster-Based Feature Engineering

# Add cluster membership as a feature
enriched <- tl_add_cluster_features(data, response = "target",
                                    method = "kmeans", k = 3)
model <- tl_model(enriched, target ~ ., method = "forest")

Semi-Supervised Learning

# Use clustering to propagate labels to unlabeled data
model <- tl_semisupervised(data, target ~ .,
                          labeled_indices = labeled_idx,
                          cluster_method = "kmeans")

AutoML

# Automatically try multiple approaches
result <- tl_auto_ml(data, target ~ .,
                    time_budget = 300)
result$leaderboard

Unified Visualization

Consistent ggplot2-based plotting regardless of model type:

# Generic plot method works for all model types
plot(forest_model)       # Automatic visualization based on model type
plot(linear_model)       # Diagnostic plots for regression
plot(pca_result)         # Variance explained for PCA

# Specialized plotting functions for unsupervised learning
plot_clusters(clustering_result, cluster_col = "cluster")
plot_variance_explained(pca_result$fit$variance_explained)

# Interactive dashboard for detailed exploration
tl_dashboard(model, test_data)

Philosophy

tidylearn is built on these principles:

1. Transparency: The underlying packages do the real work. tidylearn makes them easier to use together without hiding what's happening.

2. Consistency: One interface, tidy output, unified visualization - across all methods.

3. Accessibility: Focus on your analysis, not on learning different package APIs.

4. Interoperability: Results work seamlessly with dplyr, ggplot2, and the broader tidyverse.

Documentation

# View package help
?tidylearn

# Explore main functions
?tl_model
?tl_evaluate
?tl_auto_ml

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see LICENSE for details.

Author

Cesaire Tobias ([e-mail])

Acknowledgments

tidylearn is a wrapper that builds upon the excellent work of many R package authors. The actual algorithms are implemented in:

• stats (base R): lm, glm, prcomp, kmeans, hclust, cmdscale
• glmnet: Ridge, LASSO, and elastic net regularization
• randomForest: Random forest implementation
• xgboost: Gradient boosting
• gbm: Gradient boosting machines
• e1071: Support vector machines
• nnet: Neural networks
• rpart: Decision trees
• cluster: PAM, CLARA clustering
• dbscan: Density-based clustering
• MASS: Sammon mapping, isoMDS
• smacof: SMACOF MDS algorithm
• keras/tensorflow: Deep learning (optional)

Thank you to all the package maintainers whose work makes tidylearn possible.

tidylearn documentation built on Feb. 6, 2026, 5:07 p.m.