---
title: "Rubyで機械学習を始める方法｜Rumale 2.2の実行例とONNX・LLM連携【2026年10月】"
url: "https://www.issoh.co.jp/tech/details/5810/"
published: 2025-03-13
updated: 2026-10-30
categories: ["Ruby"]
publisher: "株式会社一創"
---

# Rubyで機械学習を始める方法｜Rumale 2.2の実行例とONNX・LLM連携【2026年10月】

Rubyでも機械学習はできます。分類・回帰・クラスタリングはRumale、表形式データの精度勝負はLightGBMとXGBoost、Pythonで学習したモデルの推論はONNX Runtime、生成AIはruby\_llmが受け持ちます。本記事では2026年10月30日にRuby 4.0.6（macOS・Intel）で各gemを入れ、iris（150行）などで掲載コードを実行しました（APIキーが要るruby\_llmと、LibTorchの準備が要るtorch.rbは未実行）。載せている正解率や出力はその結果です。

## まとめ：Rubyで機械学習を始めるときの結論

- **古典的な機械学習はRumale 2.2.0**。`gem install rumale`で本体と18個のサブgem（ほかにnumo-narray-altなどの依存gem）が入り、scikit-learnに近い`fit`／`predict`で書けます。
- **Rumaleの線形SVCは正則化の既定値に注意**。今回のirisの分割では、標準化なし・既定値で正解率0.6667、標準化して`reg_param: 0.001`にすると0.8889でした。
- **表形式データはLightGBMかXGBoost**。gem名は`lightgbm`と`xgb`で、ネイティブライブラリが同梱されています。
- **Pythonで学習したモデルはONNX経由で使えます**。scikit-learnの確率をRubyのONNX Runtimeで6桁まで同じ値に再現できました。ただしonnxruntime gem 0.11.0以降、Intel Macではbrewでの別途導入が必要です。
- **深層学習のtorch.rbはLibTorchの用意が前提**で、Windowsは非対応です。モデル開発そのものはPythonに任せる方が早く進みます。
- **NMatrix・Daru・langchainrbは新規に選ばない**。最終リリースはそれぞれ2017年・2020年・2025年5月です。

## Rubyで機械学習をやるべき場面とPythonに任せる場面

Rubyの機械学習は「RailsなどのRubyアプリの中で予測を動かす」用途で力を発揮します。データの前処理から学習・推論までを1プロセスで回せるため、Pythonの推論サーバーを別に立てずに済みます。

### Rubyで完結させてよい処理

- 数千〜数万行の表データで分類・回帰を学習し、Railsのリクエスト内で推論する（Rumale・LightGBM・eps）
- Pythonで学習済みのモデルを、本番のRubyアプリで推論だけする（ONNX Runtime）
- LLMのAPIを呼ぶ、文章を埋め込みベクトルにして類似検索する（ruby\_llm・Informers・Neighbor）

逆に、論文の新しいモデルを再現する、GPUで大規模に学習する、Jupyterで試行錯誤しながら分析する、といった作業はPythonで行う方が確実です。Rubyのgemは主要アルゴリズムを押さえていますが、最新手法の実装やサンプルの量ではPythonのエコシステムに追いつきません。迷ったら「学習はPython、推論をRubyに載せる」という分担から始めると、どちらの資産も捨てずに済みます。

### scikit-learnとRumaleの対応関係

Rumaleはscikit-learnを手本にしたAPIを持ち、クラス名もほぼ対応しています。scikit-learn自体の使い方は[Scikit-learnとは？読み方・できること・使い方を実行例で解説](/tech/details/3133/)で扱っています。

| 処理        | scikit-learn           | Rumale 2.2.0                           |
| --------- | ---------------------- | -------------------------------------- |
| ロジスティック回帰 | LogisticRegression     | LinearModel::LogisticRegression        |
| 線形SVM     | LinearSVC              | LinearModel::SVC                       |
| ランダムフォレスト | RandomForestClassifier | Ensemble::RandomForestClassifier       |
| k近傍法      | KNeighborsClassifier   | NearestNeighbors::KNeighborsClassifier |
| k-means   | KMeans                 | Clustering::KMeans                     |
| 標準化       | StandardScaler         | Preprocessing::StandardScaler          |
| パイプライン    | Pipeline               | Pipeline::Pipeline                     |
| 正則化の強さ    | C（大きいほど弱い）             | reg\_param（大きいほど強い）                    |

最後の行が移植時のつまずきどころです。詳しくは後述の「reg\_paramと標準化」の章で、実測値とソースコードの根拠を示します。

## 用途別のRuby機械学習ライブラリと最新版

2026年10月30日にRubyGems APIで確かめた各gemの最新版です。用途ごとの候補と、その最新版・公開日を並べています。

| 用途          | gem名            | 最新版    | 公開日        |
| ----------- | --------------- | ------ | ---------- |
| 数値配列        | numo-narray-alt | 0.12.0 | 2026-10-20 |
| データフレーム     | rover-df        | 1.1.0  | 2026-08-15 |
| 古典的な機械学習    | rumale          | 2.2.0  | 2026-07-05 |
| 勾配ブースティング   | lightgbm        | 0.5.0  | 2026-07-18 |
| 勾配ブースティング   | xgb             | 0.12.1 | 2026-08-05 |
| 深層学習        | torch-rb        | 0.27.0 | 2026-10-28 |
| 学習済みモデルの推論  | onnxruntime     | 0.11.8 | 2026-10-09 |
| Pythonの呼び出し | pycall          | 1.5.4  | 2026-10-16 |
| Railsでの予測   | eps             | 0.7.0  | 2026-04-15 |
| 埋め込み・推論     | informers       | 1.3.0  | 2026-04-15 |
| LLMのAPI     | ruby\_llm       | 2.1.1  | 2026-10-11 |
| ベクトル検索      | neighbor        | 1.2.0  | 2026-06-05 |

XGBoostのgem名は`xgb`です。RubyGemsにある`xgboost`という名前のgemは2018年4月の0.2.1で止まった別物なので、取り違えないようにしてください。gemの入れ方やGemfileでの版の固定は[gemとBundlerの使い方｜Bundler 4系で変わったコマンドとGemfileの書き方](/tech/details/4221/)にまとめています。

### NMatrix・Daruなどの旧ライブラリの代替候補

古い入門記事でよく紹介される次のgemは、更新が止まっています。この記事では、Rumaleとの配列互換性と新規環境での導入を優先し、以下の代替候補を勧めます。

- **NMatrix**（SciRubyの行列ライブラリ）：最終版0.2.4は2017年12月。行列計算はnumo-narray-altで代替します。
- **Daru**（データフレーム）：最終版0.3は2020年5月。Roverで代替します。
- **numo-narray**（本家）：最終版0.9.2.1は2022年8月。Rumale作者によるフォークのnumo-narray-altが`Numo::`の名前空間のまま後を継ぎました。
- **red-chainer**（深層学習）：最終版0.4.1は2019年4月。torch.rbで代替します。

numo-narrayからの移行は依存関係にも表れています。[RumaleのREADME](https://github.com/yoshoku/rumale/blob/main/README.md)は「Since v2.0.0, Rumale uses Numo::NArray Alternative instead of Numo::NArray as a dependency.」と明記しており、rover-df 1.1.0もnumo-narray-altに依存しています。本家と派生を同じ環境に入れると衝突するため、`gem install numo-narray`を別に実行しないでください。

## Rumaleによる分類・クラスタリングの実行例

RumaleはRubyで古典的な機械学習を書くときの第一候補です。サポートベクターマシン・ロジスティック回帰・決定木・k-means・主成分分析などを同じ書き方で扱えます。

### Rumaleのインストールと依存gem

```
gem install rumale rover-df
```

`rumale`はメタgemで、実体は`rumale-core`・`rumale-linear_model`・`rumale-tree`など18個のサブgemに分かれています（[CHANGELOG](https://github.com/yoshoku/rumale/blob/main/CHANGELOG.md)によると0.24.0で分割）。2026年10月30日に実行すると、numo-narray-altは最新の0.12.0ではなく0.11.3が入りました。Rumale 2.2.0の依存条件が「0.12.0未満」だからです。

Ruby 4.0では、計測によく使う`benchmark`がdefault gemからbundled gemに移りました（[Ruby 4.0.0のNEWS](https://github.com/ruby/ruby/blob/v4.0.0/NEWS.md)）。Rubyと一緒にインストールはされますが、Bundler配下で動かすスクリプトではGemfileに`gem "benchmark"`を書かないと読み込めません。gemの置き場を分けた検証環境では「benchmark is not part of the default gems since Ruby 4.0.0」と警告が出てLoadErrorになりました。Rumaleが依存する`csv`（Ruby 3.4でbundled gem化）は依存として自動で入ります。Ruby本体の版ごとの変更は[Rubyの最新バージョンは4.0.7｜4.1.0-preview1の変更点・3系との違い・サポート期限（2026年10月）](/tech/details/10592/)で追っています。

### RoverのCSV読み込みとRumaleの分類例

irisのCSV（4特徴量・3品種・150行）を読み、7対3に分けてロジスティック回帰で学習します。CSVは[seaborn-dataのiris.csv](https://github.com/mwaskom/seaborn-data/blob/master/iris.csv)を、列順（sepal\_length・sepal\_width・petal\_length・petal\_width・species）と行順を変えずに`iris.csv`として保存したものです。`stratify: true`で品種の比率を保ったまま分割しています。

```
require "rumale"
require "rover"

df = Rover.read_csv("iris.csv")
labels = df[:species].uniq.to_a.sort
y = Numo::Int32.cast(df[:species].to_a.map { |s| labels.index(s) })
x = Numo::DFloat.cast(df.except(:species).to_a.map(&:values))

x_train, x_test, y_train, y_test = Rumale::ModelSelection.train_test_split(
  x, y, test_size: 0.3, stratify: true, random_seed: 1
)

model = Rumale::LinearModel::LogisticRegression.new
model.fit(x_train, y_train)
p Rumale::EvaluationMeasure::Accuracy.new.score(y_test, model.predict(x_test))
# => 0.9333333333333333
```

同じ分割で他のモデルも既定値のまま学習させた結果が次の表です。テストは45行なので、1行の差が2.2ポイントになります。この規模では順位の差を手法の優劣と読まないでください。

| モデル（既定値）                      | テスト正解率 |
| ----------------------------- | ------ |
| Rumale LogisticRegression     | 0.9333 |
| XGBoost Classifier（xgb）       | 0.9333 |
| Rumale KNeighborsClassifier   | 0.9111 |
| LightGBM Classifier           | 0.9111 |
| Rumale RandomForestClassifier | 0.8889 |
| Rumale SVC（線形）                | 0.6667 |

### reg\_paramと標準化で精度が変わる落とし穴

線形SVCだけが0.6667と低いのは、モデルが弱いからではなく既定の正則化が強すぎるためです。Rumale 2.2.0のソースを読むと、SVCの損失関数は「`0.5 * reg_param * w.dot(w)`＋二乗ヒンジ損失の**件数での平均**」です。一方LogisticRegressionは損失を**合計**しています。平均を取るぶんSVCは正則化項が相対的に重くなり、学習105件ではscikit-learnのLinearSVCでいう`C`がおよそ0.01の状態になります。

| 条件                       | SVC    | LogisticRegression |
| ------------------------ | ------ | ------------------ |
| 標準化なし・reg\_param 1.0（既定） | 0.6667 | 0.9333             |
| 標準化あり・reg\_param 1.0     | 0.7556 | 0.8889             |
| 標準化あり・reg\_param 0.1     | 0.8000 | 0.9111             |
| 標準化あり・reg\_param 0.01    | 0.8667 | 0.9333             |
| 標準化あり・reg\_param 0.001   | 0.8889 | 0.9333             |

scikit-learnのコードを移植するときは、`C=1.0`を`reg_param: 1.0`にそのまま置き換えないでください。向きが逆（Cは大きいほど弱い）なうえ、SVCでは学習件数によって効き方も変わります。線形モデルは`StandardScaler`で標準化し、`reg_param`を0.1・0.01・0.001と振って交差検証で選ぶのが安全です。標準化だけでLogisticRegressionの精度が下がったのも、同じ`reg_param`のまま特徴量の尺度が変わり、正則化の効き方が変わったためです。

### パイプラインの交差検証とMarshalによる保存

標準化とモデルを`Pipeline`にまとめておくと、学習時と推論時で前処理がずれる事故を防げます。5分割の層化交差検証で評価し、最後に全データで学習したパイプラインを保存します。

```
pipe = Rumale::Pipeline::Pipeline.new(steps: {
  scaler: Rumale::Preprocessing::StandardScaler.new,
  clf: Rumale::LinearModel::SVC.new(reg_param: 0.001)
})
kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5, shuffle: true, random_seed: 1)
cv = Rumale::ModelSelection::CrossValidation.new(estimator: pipe, splitter: kf)
scores = cv.perform(x, y)[:test_score]
p scores.sum / scores.size   # => 0.9400000000000001

pipe.fit(x, y)
File.binwrite("model.dat", Marshal.dump(pipe))
loaded = Marshal.load(File.binread("model.dat"))
p loaded.predict(Numo::DFloat[[5.9, 3.0, 5.1, 1.8]]).to_a   # => [2]
```

RumaleのモデルはRubyの`Marshal`でそのまま保存・復元できます。標準化とロジスティック回帰のパイプラインを同じ方法で保存すると617バイトで、復元後の予測は保存前と完全に一致しました。バッチで学習した`model.dat`をRailsの起動時に読み込めば、リクエストのたびに学習し直す必要はありません。ただし`Marshal.load`は信頼できないファイルに使うと任意のオブジェクトを生成できてしまうため、自分で作ったファイル以外は読み込まないでください。

教師なし学習も同じ書き方です。`Rumale::Clustering::KMeans.new(n_clusters: 3, random_seed: 1).fit_predict(x)`でirisを3つに分けると、正解の品種との一致度（調整ランド指数）は標準化なしで0.429でした。

## 表形式データ向けLightGBM・XGBoostの実行例

表形式データで精度を詰めるなら、勾配ブースティングのLightGBMかXGBoostです。どちらのgemもAndrew Kane氏の作で、`vendor`ディレクトリにmacOS・Linux・Windows向けのネイティブライブラリが同梱されています。`gem install lightgbm xgb`で導入できますが、MacではLightGBM用に`brew install libomp`でOpenMPも導入してください。Rubyの配列をそのまま渡せます。

```
require "lightgbm"
require "xgb"

x = df.except(:species).to_a.map(&:values)
y = df[:species].to_a.map { |s| labels.index(s) }

lgb = LightGBM::Classifier.new(n_estimators: 100, verbosity: -1)
lgb.fit(x, y)
p lgb.predict([[5.9, 3.0, 5.1, 1.8]])   # => [2]

xgb = XGBoost::Classifier.new(n_estimators: 100)
xgb.fit(x, y)
p xgb.feature_importances.map { |v| v.round(3) }
# => [0.009, 0.017, 0.68, 0.295]
```

特徴量の重要度は花弁の長さ（3番目）が0.68で突出しました。低レベルAPIの`XGBoost.train`も使えますが、今回の4行・二値分類の検証では、既定の設定で予測が`[0.5]`のまま変わりませんでした。既定の`min_child_weight`を満たす分岐が作れず、葉が1つだけの木になったためです。動作確認は数十行以上のデータで行ってください。XGBoost・LightGBM・CatBoostの違いと実測比較は[GBDTとは？勾配ブースティング決定木の仕組みと主要4実装の実測比較【2026年版】](/tech/details/5871/)で解説しています。

## torch.rbで深層学習をするときの前提条件

RubyでニューラルネットワークをPyTorchと同じ書き方で組むならtorch.rbです。2026年10月28日公開の0.27.0は、PyTorchのC++ライブラリであるLibTorch 2.15.0に対応しています。[torch.rbのREADME](https://github.com/ankane/torch.rb/blob/master/README.md)によると、導入には次の前提があります。

- LibTorchを先にダウンロードし、`bundle config set build.torch-rb --with-torch-dir=...`で場所を指定する
- 配布ビルドが案内されているのはMacのarm64とLinuxのx86-64だけ。ほかの環境ではLibTorchをソースからビルドする
- 拡張のコンパイルに5〜10分かかる。Windowsは非対応
- GPUはLinuxのCUDAと、Apple siliconのMPSに対応

本記事の検証機はIntel Macで、LibTorchのソースビルドが必要になるため実行していません。Rumaleのモデルとtorch.rbのネットワークを同じ`fit`／`predict`で扱いたい場合は、Rumale作者によるrumale-torch（0.4.0）があります。新しいモデル構造を試す、GPUで長時間学習する、といった作業はPyTorch本体の方が情報もサンプルも揃っています。PyTorch側の概要は[PyTorchとは？読み方・できること・TensorFlowとの違いと入れ方【2.14対応】](/tech/details/1315/)を参照してください。

## Python学習済みモデルのRubyへの組み込み

Pythonの資産をRubyで使う方法は2つあります。モデルをONNX形式に書き出してRubyだけで推論する方法と、PyCallでPythonそのものを呼ぶ方法です。本番に載せるなら、Pythonの実行環境を持ち込まずに済むONNXを先に検討してください。

### ONNX Runtimeによるscikit-learnモデルの推論

scikit-learn 1.6.1で標準化とロジスティック回帰のパイプラインを学習し、skl2onnx 1.20.0でONNXに変換しました。分類器のオプションで`zipmap`を切ると、確率が扱いやすい2次元配列で出てきます。

```
# Python側：学習済みパイプラインをONNXへ書き出す
from skl2onnx import to_onnx
# modelは学習済みのscikit-learn Pipeline、Xは学習時と同じ列順のfloat32配列
onx = to_onnx(model, X[:1], target_opset=17,
              options={id(model.steps[-1][1]): {"zipmap": False}})
open("model.onnx", "wb").write(onx.SerializeToString())
```

```
# Ruby側：ONNX Runtimeで推論する
require "onnxruntime"

model = OnnxRuntime::Model.new("model.onnx")
p model.inputs
# => [{name: "X", type: "tensor(float)", shape: [-1, 4]}]
p model.predict({ "X" => [[5.9, 3.0, 5.1, 1.8]] })
# => {"label" => [2], "probabilities" => [[0.0030532856471836567, 0.293649822473526, 0.703296959400177]]}
```

Python側の`predict_proba`は\[0.003053, 0.29365, 0.703297\]で、小数6桁まで一致しました。入力名はskl2onnxの既定で`X`になるため、推測で`input`などと書かず`model.inputs`で確かめてください。`zipmap`を切らずに変換したモデルでは、確率が`[{0 => 0.003..., 1 => 0.293..., 2 => 0.703...}]`というハッシュの配列で返りました。

Intel Macでは注意があります。[onnxruntime gemのCHANGELOG](https://github.com/ankane/onnxruntime-ruby/blob/master/CHANGELOG.md)には0.11.0（2026-02-22）で「Dropped shared library for Mac x86-64 (no longer provided by upstream)」とあり、0.11.8を入れただけでは「ONNX Runtime not found. Run \`brew install onnxruntime\`」で止まりました。`brew install onnxruntime`で共有ライブラリを入れるか、ライブラリを同梱していた0.10.2（ONNX Runtime 1.23.0）に固定します。上の出力は0.10.2で得たものです。CHANGELOGで同梱をやめたと書かれているのはMac x86-64だけで、Apple siliconやLinux向けの0.11.8（ONNX Runtime 1.31.0）は従来どおりgemだけで使えます。ONNXの変換やopsetの考え方は[ONNXとは？読み方・.onnxファイルの中身・変換とONNX Runtimeでの推論【onnx 1.23／ORT 1.31対応】](/tech/details/7528/)で詳しく扱っています。

### PyCallによるscikit-learnの直接呼び出し

ONNXに変換できない処理（pandasでの集計や、変換器が対応していないモデル）はPyCallでPythonを呼びます。[PyCallのREADME](https://github.com/red-data-tools/pycall.rb/blob/master/README.md)はPython 3.7以上に対応するとしています。

```
# PYTHON=.venv/bin/python ruby predict.rb のように使うPythonを指定して実行する
require "pycall/import"
include PyCall::Import

pyimport "sklearn.linear_model", as: "lm"
model = lm.LogisticRegression.new
model.fit([[0], [1], [2], [3]], [0, 0, 1, 1])
p model.predict([[2]]).tolist.to_a   # => [1]
```

つまずきやすい点が2つありました。1つは、使うPythonの指定です。PyCallのREADMEには「When PYTHON is not specified, pycall.rb tries to use python3 first」とあり、環境変数`PYTHON`が無いとPATH上の`python3`が選ばれます。今回の環境ではscikit-learnの入っていないPython 3.9.6が選ばれ、ModuleNotFoundErrorになりました。もう1つは、戻り値がnumpy配列のPythonオブジェクトである点です。`model.predict([[2]]).to_a`と書くとNoMethodErrorになり、`.tolist.to_a`でRubyの配列に変換する必要がありました。

## Railsアプリに予測を組み込むならeps

epsはハッシュの配列を渡すだけで回帰・分類のモデルを作れるgemです。[epsのREADME](https://github.com/ankane/eps/blob/master/README.md)によると既定のアルゴリズムはLightGBMで、文字列の列はカテゴリ、数値の列は数値の特徴量として扱われます。Railsでは`app/ml_models`ディレクトリに学習処理を置く構成が推奨されており、既存テーブルから小さな需要予測やスコアリングを足す用途に向いています。Macでは`brew install libomp`でOpenMPを入れておく必要があります。

```
require "eps"
require "rover"

rows = Rover.read_csv("iris.csv").to_a.map { |r| r.transform_keys(&:to_sym) }
train = rows.each_with_index.reject { |_, i| (i % 3).zero? }.map(&:first)

model = Eps::Model.new(train, target: :species)
p model.predict(sepal_length: 5.9, sepal_width: 3.0, petal_length: 5.1, petal_width: 1.8)
# => "virginica"

File.write("model.pmml", model.to_pmml)
restored = Eps::Model.load_pmml(File.read("model.pmml"))
```

3行に1行を検証用に残すと、50行の正解率は0.96でした。`model.summary`は特徴量の重要度も出力します。保存形式はPMMLで、この例では約1.9MBになりました。読み戻したモデルも同じ`"virginica"`を返します。Railsのモデルクラスの中にこの推論を書くと肥大化しやすいので、予測を担うサービスオブジェクトを分けて置くと保守しやすくなります。

## Rubyによる生成AI・LLMの組み込み

Rubyで扱うAIには、モデルの学習だけでなく、LLMのAPI呼び出しや社内文書検索といった生成AIの組み込みもあります。LLM連携のgemを選ぶ際は公開版と対応機能を確認してください。langchainrbは0.19.5（2025-05-01）を最後にリリースが止まっています。

### ruby\_llmによる複数LLMの共通API呼び出し

ruby\_llmは、OpenAI・Anthropic・Gemini・Ollamaなど複数のプロバイダを1つのAPIで扱えるgemです。[公式サイト](https://rubyllm.com/)は安定版2.1系で19プロバイダへの対応を掲げており、Railsでの会話履歴の保存、ツール呼び出し、構造化出力、埋め込みまで揃っています。次のコードは公式のGetting Startedに沿った最小構成です。APIキーが必要なため、本記事では実行していません。

```
require "ruby_llm"

RubyLLM.configure do |config|
  config.openai_api_key = ENV.fetch("OPENAI_API_KEY")
end

chat = RubyLLM.chat
response = chat.ask "Rubyで機械学習をする利点を3行で"
puts response.content
```

### Informersの埋め込み生成とNeighborの類似検索

文章をベクトルにする処理は、外部APIを使わずRubyの中でも実行できます。Informers 1.3.0はHugging FaceのONNX形式のモデルを読み込み、埋め込みや分類のパイプラインを提供します。多言語対応の`Xenova/multilingual-e5-small`で日本語の3文と質問文を384次元のベクトルにし、内積で近さを比べました。

```
require "informers"

model = Informers.pipeline("embedding", "Xenova/multilingual-e5-small")
docs = ["passage: Rubyで機械学習モデルを学習する方法",
        "passage: Railsアプリに推論APIを組み込む手順",
        "passage: 今日の天気は晴れです"]
q = model.("query: Rubyで機械学習を始めたい")
model.(docs).each { |v| p v.zip(q).sum { |a, b| a * b }.round(4) }
# => 0.9233 / 0.8681 / 0.7881
```

質問に近い順に並び、無関係な天気の文が最も低くなりました。出力ベクトルは長さ1に正規化されているため、内積がそのままコサイン類似度です。初回はモデルのダウンロードを含めて読み込みに43.8秒かかり、`~/.cache/informers`に約467MBが保存されました。2回目以降、4文の変換は0.078秒です。InformersはONNX Runtimeの上で動くので、Intel Macでは前章と同じくonnxruntime gemの版に注意してください。

作ったベクトルを保存して近いものを探すのが[Neighbor](https://github.com/ankane/neighbor/blob/master/README.md)です。ActiveRecordのモデルに`has_neighbors`を足すだけで、PostgreSQLのpgvector、MariaDB 11.8以上、MySQL 9.7以上（検索にはHeatWaveが必要）、SQLiteのベクトル列を検索できます。埋め込みとベクトル検索を組み合わせれば、Railsアプリの中で社内文書を検索してLLMに渡すRAGの構成になります。RAGの全体像は[RAGとは？仕組みとLLM・ファインチューニングとの違い・企業での導入例を解説](/column/details/12919/)で整理しています。既存のRailsシステムに予測やLLMの機能を足す開発は、[生成AI開発・AI受託開発](/service/ai/development/)でも承っています。

## よくある質問

### Rubyは機械学習に向いていますか？

Rubyアプリの中で予測を動かす用途には向いています。Rumale・LightGBM・ONNX Runtimeで学習から推論までを1プロセスで回せます。研究やGPUでの大規模な学習、探索的なデータ分析はPythonの方が向いています。

### scikit-learnの代わりになるRubyのライブラリはありますか？

Rumaleが最も近い存在です。クラス名やfit・predictの書き方はscikit-learnに倣っています。ただし正則化の`reg_param`は`C`と向きが逆で、SVCでは学習件数によって効き方も変わるため、値をそのまま移さないでください。

### Rubyで深層学習（ディープラーニング）はできますか？

torch.rbでできます。0.27.0はLibTorch 2.15.0に対応し、CUDAとApple siliconのMPSも使えます。LibTorchの事前準備と5〜10分のコンパイルが必要で、Windowsには対応していません。

### DaruやNMatrix、SciRubyのgemはまだ使えますか？

新規には勧めません。NMatrixは2017年、Daruは2020年が最終リリースです。行列計算はnumo-narray-alt、データフレームはRoverに置き換えてください。

### RubyでChatGPTなどの生成AIを使うには？

ruby\_llmを使うと、OpenAIやAnthropicなど複数のLLMを同じ書き方で呼べます。社内文書の検索と組み合わせるなら、Informersで埋め込みを作りNeighborで類似検索する構成がRubyだけで組めます。

## 関連記事

- [Scikit-learnとは？読み方・できること・使い方を実行例で解説](/tech/details/3133/)
- [GBDTとは？勾配ブースティング決定木の仕組みと主要4実装の実測比較【2026年版】](/tech/details/5871/)
- [ONNXとは？読み方・.onnxファイルの中身・変換とONNX Runtimeでの推論【onnx 1.23／ORT 1.31対応】](/tech/details/7528/)
- [PyTorchとは？読み方・できること・TensorFlowとの違いと入れ方【2.14対応】](/tech/details/1315/)
- [Rubyの最新バージョンは4.0.7｜4.1.0-preview1の変更点・3系との違い・サポート期限（2026年10月）](/tech/details/10592/)

---

出典: [Rubyで機械学習を始める方法｜Rumale 2.2の実行例とONNX・LLM連携【2026年10月】](<https://www.issoh.co.jp/tech/details/5810/>)（株式会社一創）