Introduction

Ruby is not the default language in machine learning, but it is fully capable for many practical models, especially for education, prototyping, and small production tasks. The ecosystem is smaller than Python, so tool choice and workflow design matter more. This guide shows a pragmatic Ruby ML stack and runnable examples for common algorithms.

Core Topic Sections

Pick a realistic Ruby ML toolchain

A practical setup for Ruby machine learning usually includes:

1. numo-narray for numerical arrays.
2. rumale for algorithms and model APIs.
3. daru for tabular data handling when needed.

Install core gems:

gem install numo-narray rumale daru

For reproducibility, keep versions in Gemfile and commit Gemfile.lock.

Linear regression example

Linear regression predicts a continuous value from numeric features. In Ruby, Rumale::LinearModel::LinearRegression gives a clean API similar to scikit-learn style workflows.

1require 'numo/narray'
2require 'rumale'
3
4x = Numo::DFloat[
5  [1.0, 2.0],
6  [2.0, 1.0],
7  [3.0, 4.0],
8  [4.0, 3.0],
9  [5.0, 5.0]
10]
11
12y = Numo::DFloat[5.0, 5.5, 10.5, 11.0, 14.5]
13
14model = Rumale::LinearModel::LinearRegression.new
15model.fit(x, y)
16
17x_test = Numo::DFloat[[6.0, 5.0], [2.5, 2.5]]
18pred = model.predict(x_test)
19
20puts "Predictions: #{pred.to_a}"

This pattern is suitable for baseline modeling and feature sanity checks.

Classification with logistic regression

For binary classification, logistic regression is often the first model to try because it is fast, interpretable, and easy to debug.

1require 'numo/narray'
2require 'rumale'
3
4x = Numo::DFloat[
5  [1.0, 1.0],
6  [1.2, 0.8],
7  [3.0, 3.2],
8  [3.2, 2.8],
9  [0.8, 1.1],
10  [2.9, 3.1]
11]
12
13y = Numo::Int32[0, 0, 1, 1, 0, 1]
14
15clf = Rumale::LinearModel::LogisticRegression.new(max_iter: 200)
16clf.fit(x, y)
17
18probs = clf.predict_proba(Numo::DFloat[[1.1, 0.9], [3.1, 3.0]])
19labels = clf.predict(Numo::DFloat[[1.1, 0.9], [3.1, 3.0]])
20
21puts "Probabilities: #{probs.to_a}"
22puts "Labels: #{labels.to_a}"

For imbalanced classes, evaluate precision and recall, not only accuracy.

Tree-based methods for nonlinear patterns

Decision trees and ensemble methods capture nonlinear relationships with little feature scaling effort. Rumale offers tree models that are easy to start with.

1require 'numo/narray'
2require 'rumale'
3
4x = Numo::DFloat[
5  [1.0, 10.0],
6  [2.0, 20.0],
7  [3.0, 15.0],
8  [8.0, 80.0],
9  [9.0, 90.0],
10  [10.0, 85.0]
11]
12
13y = Numo::Int32[0, 0, 0, 1, 1, 1]
14
15tree = Rumale::Tree::DecisionTreeClassifier.new(max_depth: 3, random_seed: 7)
16tree.fit(x, y)
17
18pred = tree.predict(Numo::DFloat[[2.5, 18.0], [9.5, 87.0]])
19puts pred.to_a

Trees can overfit quickly, so cap depth and validate with held-out data.

Model evaluation workflow

A lightweight evaluation loop should include:

1. Train and validation split.
2. One baseline model.
3. One stronger model.
4. Metric report and confusion matrix.

Even in Ruby prototypes, this discipline prevents misleading conclusions from tiny samples.

Data preprocessing in Ruby

Ruby does not hide preprocessing complexity. You still need consistent handling for:

1. Missing values.
2. Categorical encoding.
3. Feature scaling.
4. Train and test leakage prevention.

Many teams preprocess in SQL or Python and use Ruby for inference-facing app integration. That hybrid approach is often practical when the product backend is Ruby on Rails.

When Ruby is a good ML choice

Ruby works well when:

1. Model complexity is moderate.
2. Team already has strong Ruby expertise.
3. Integration into Rails services matters more than cutting-edge research tooling.

For very large deep learning workloads, Python ecosystems are still broader, but Ruby can still orchestrate pipeline steps and consume exported models.

Common Pitfalls

• Treating Ruby ML projects like Python clones without adapting to ecosystem differences.
• Skipping train and validation separation on small datasets.
• Forgetting feature scaling for linear models and distance-based methods.
• Overfitting tree models by allowing deep unrestricted growth.
• Shipping prototypes without version-pinning gems and model artifacts.

Summary

• Ruby supports practical machine learning with numo-narray, rumale, and related gems.
• Linear and logistic regression are strong starting points for many use cases.
• Tree models handle nonlinear data but require overfitting control.
• Reliable evaluation and preprocessing matter more than language choice.
• Ruby is a strong option when product integration and team skill align.