onnx-ruby 0.1.0

data/examples/classification.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Run an ONNX classification model
+#
+# With tokenizer (text input):
+#   gem install onnx-ruby tokenizers
+#   ruby classification.rb intent_model.onnx bert-base-uncased
+#
+# With raw features:
+#   ruby classification.rb classifier.onnx
+
+require "onnx_ruby"
+
+model_path = ARGV[0] || "classifier.onnx"
+tokenizer_name = ARGV[1]
+abort "Usage: ruby classification.rb <model.onnx> [tokenizer_name]" unless File.exist?(model_path)
+
+labels = %w[greeting farewell question command]
+
+if tokenizer_name
+  classifier = OnnxRuby::Classifier.new(model_path,
+                                        tokenizer: tokenizer_name,
+                                        labels: labels)
+  result = classifier.predict("Hello there!")
+  puts "Prediction: #{result[:label]} (score: #{result[:score].round(4)})"
+else
+  classifier = OnnxRuby::Classifier.new(model_path, labels: labels)
+
+  # Use raw feature vector
+  features = Array.new(8) { rand(-1.0..1.0) }
+  result = classifier.predict(features)
+  puts "Prediction: #{result[:label]} (score: #{result[:score].round(4)})"
+  puts "All scores: #{result[:scores].map { |s| s.round(4) }}"
+end

data/examples/embedding.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Run an ONNX embedding model
+#
+# With tokenizer (text input):
+#   gem install onnx-ruby tokenizers
+#   ruby embedding.rb all-MiniLM-L6-v2.onnx sentence-transformers/all-MiniLM-L6-v2
+#
+# With raw token IDs:
+#   ruby embedding.rb all-MiniLM-L6-v2.onnx
+
+require "onnx_ruby"
+
+model_path = ARGV[0] || "all-MiniLM-L6-v2.onnx"
+tokenizer_name = ARGV[1]
+abort "Usage: ruby embedding.rb <model.onnx> [tokenizer_name]" unless File.exist?(model_path)
+
+if tokenizer_name
+  embedder = OnnxRuby::Embedder.new(model_path, tokenizer: tokenizer_name)
+  embedding = embedder.embed("Hello world")
+  puts "Embedding (#{embedding.length} dims): #{embedding.take(5).map { |v| v.round(4) }}..."
+
+  batch = embedder.embed_batch(["Hello", "World", "Ruby is great"])
+  puts "Batch: #{batch.length} embeddings of #{batch.first.length} dims"
+else
+  embedder = OnnxRuby::Embedder.new(model_path)
+
+  # Use pre-tokenized input
+  result = embedder.embed({
+    "input_ids" => [101, 2023, 2003, 1037, 3231, 102],
+    "attention_mask" => [1, 1, 1, 1, 1, 1]
+  })
+  puts "Embedding (#{result.length} dims): #{result.take(5).map { |v| v.round(4) }}..."
+end

data/examples/real_world_demo.rb

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Real-world proof of concept: Semantic search with all-MiniLM-L6-v2
+#
+# This demo:
+# 1. Loads a real HuggingFace sentence-transformers model (86MB)
+# 2. Tokenizes English text with the tokenizers gem
+# 3. Generates 384-dimensional embeddings
+# 4. Performs cosine similarity search
+#
+# Prerequisites:
+#   gem install tokenizers
+
+require_relative "../lib/onnx_ruby"
+require "tokenizers"
+require "benchmark"
+
+MODEL_PATH = File.join(__dir__, "models", "all-MiniLM-L6-v2.onnx")
+TOKENIZER_ID = "sentence-transformers/all-MiniLM-L6-v2"
+
+unless File.exist?(MODEL_PATH)
+  abort "Model not found. Download it first:\n" \
+        "  curl -fSL https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx " \
+        "-o examples/models/all-MiniLM-L6-v2.onnx"
+end
+
+# --- Setup ---
+
+puts "Loading tokenizer..."
+tokenizer = Tokenizers::Tokenizer.from_pretrained(TOKENIZER_ID)
+
+puts "Loading ONNX model..."
+embedder = OnnxRuby::Embedder.new(MODEL_PATH, tokenizer: tokenizer, normalize: true)
+
+puts "Model inputs:  #{embedder.session.inputs.map { |i| "#{i[:name]} #{i[:type]} #{i[:shape]}" }.join(", ")}"
+puts "Model outputs: #{embedder.session.outputs.map { |o| "#{o[:name]} #{o[:type]} #{o[:shape]}" }.join(", ")}"
+puts
+
+# --- Document corpus ---
+
+documents = [
+  "Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.",
+  "Python is widely used in data science and machine learning applications.",
+  "ONNX Runtime is a cross-platform inference engine for machine learning models.",
+  "Rails is a web application framework written in Ruby.",
+  "Vector databases store and search high-dimensional embeddings efficiently.",
+  "The weather in Tokyo is warm and humid during summer.",
+  "PostgreSQL is a powerful open source relational database system.",
+  "Transformers have revolutionized natural language processing since 2017.",
+  "Docker containers package applications with their dependencies for consistent deployment.",
+  "The quick brown fox jumps over the lazy dog.",
+  "Semantic search understands the meaning of queries, not just keywords.",
+  "GPUs accelerate matrix operations used in deep learning training.",
+]
+
+# --- Generate embeddings ---
+
+puts "Generating embeddings for #{documents.length} documents..."
+doc_embeddings = nil
+time = Benchmark.realtime do
+  doc_embeddings = embedder.embed_batch(documents)
+end
+puts "  Done in #{(time * 1000).round(1)}ms (#{(time / documents.length * 1000).round(1)}ms per document)"
+puts "  Embedding dimensions: #{doc_embeddings.first.length}"
+puts
+
+# --- Cosine similarity search ---
+
+def cosine_similarity(a, b)
+  dot = a.zip(b).sum { |x, y| x * y }
+  norm_a = Math.sqrt(a.sum { |x| x * x })
+  norm_b = Math.sqrt(b.sum { |x| x * x })
+  dot / (norm_a * norm_b)
+end
+
+queries = [
+  "How do I build a web app with Ruby?",
+  "What is the best way to run ML models locally?",
+  "Tell me about database systems",
+  "Natural language understanding",
+]
+
+queries.each do |query|
+  puts "Query: \"#{query}\""
+
+  query_embedding = embedder.embed(query)
+
+  results = documents.each_with_index.map do |doc, i|
+    { document: doc, score: cosine_similarity(query_embedding, doc_embeddings[i]), index: i }
+  end.sort_by { |r| -r[:score] }
+
+  results.first(3).each_with_index do |r, rank|
+    puts "  #{rank + 1}. [#{r[:score].round(4)}] #{r[:document]}"
+  end
+  puts
+end
+
+# --- Classifier demo ---
+
+puts "=== Classifier Demo ==="
+classifier = OnnxRuby::Classifier.new(
+  File.join(__dir__, "..", "test", "models", "classifier.onnx"),
+  labels: %w[greeting farewell question command]
+)
+
+# Use embeddings as features (truncated to 8 dims to match test model)
+test_sentences = ["Hello there!", "What is Ruby?", "Goodbye!", "Run the tests"]
+test_sentences.each do |sentence|
+  emb = embedder.embed(sentence)
+  pred = classifier.predict(emb.first(8))  # our test classifier expects 8 features
+  puts "  \"#{sentence}\" -> #{pred[:label]} (#{(pred[:score] * 100).round(1)}%)"
+end
+puts
+
+# --- Session Pool demo ---
+
+puts "=== Concurrent Inference with SessionPool ==="
+pool = OnnxRuby::SessionPool.new(MODEL_PATH, size: 3)
+
+sentences = [
+  "Machine learning is transforming software",
+  "Ruby gems make code reusable",
+  "ONNX is an open format for ML models",
+  "Concurrent processing improves throughput",
+  "Embeddings capture semantic meaning",
+  "Thread safety matters in production",
+]
+
+results = []
+mutex = Mutex.new
+time = Benchmark.realtime do
+  threads = sentences.map do |sentence|
+    Thread.new do
+      encoding = tokenizer.encode(sentence)
+      ids = encoding.ids
+      mask = encoding.attention_mask
+
+      r = pool.run({
+        "input_ids" => [ids],
+        "attention_mask" => [mask],
+        "token_type_ids" => [Array.new(ids.length, 0)]
+      })
+
+      embedding = r.values.first[0]
+      mutex.synchronize { results << { sentence: sentence, dims: embedding.length } }
+    end
+  end
+  threads.each(&:join)
+end
+
+puts "  #{results.length} sentences embedded concurrently in #{(time * 1000).round(1)}ms"
+puts "  Pool size: #{pool.size} sessions created (max: 3)"
+results.each { |r| puts "    #{r[:sentence]} -> #{r[:dims]}d" }
+puts
+
+# --- Lazy loading demo ---
+
+puts "=== Lazy Loading Demo ==="
+lazy = OnnxRuby::LazySession.new(MODEL_PATH)
+puts "  Before first call: loaded=#{lazy.loaded?}"
+lazy.run({
+  "input_ids" => [[101, 2023, 2003, 1037, 3231, 102]],
+  "attention_mask" => [[1, 1, 1, 1, 1, 1]],
+  "token_type_ids" => [[0, 0, 0, 0, 0, 0]]
+})
+puts "  After first call:  loaded=#{lazy.loaded?}"
+puts
+
+puts "=== All real-world demos completed successfully! ==="

data/examples/with_zvec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Full RAG pipeline with onnx-ruby + zvec-ruby
+#
+# Prerequisites:
+#   gem install onnx-ruby zvec-ruby tokenizers
+#   Download or export an ONNX embedding model
+
+require "onnx_ruby"
+
+begin
+  require "zvec"
+rescue LoadError
+  abort "This example requires zvec-ruby: gem install zvec-ruby"
+end
+
+MODEL_PATH = ARGV[0] || "all-MiniLM-L6-v2.onnx"
+TOKENIZER = ARGV[1] || "sentence-transformers/all-MiniLM-L6-v2"
+
+unless File.exist?(MODEL_PATH)
+  abort "Usage: ruby with_zvec.rb <embedding_model.onnx> [tokenizer_name]"
+end
+
+# 1. Create embedder
+embedder = OnnxRuby::Embedder.new(MODEL_PATH, tokenizer: TOKENIZER)
+
+# 2. Create vector store
+dim = embedder.session.outputs.first[:shape].last
+store = Zvec::Store.new(dimensions: dim)
+
+# 3. Index some documents
+documents = [
+  "Ruby is a dynamic programming language",
+  "ONNX Runtime provides high-performance inference",
+  "Vector databases enable semantic search",
+  "Machine learning models can run locally",
+  "Rails is a web application framework"
+]
+
+embeddings = embedder.embed_batch(documents)
+documents.each_with_index do |doc, i|
+  store.add(embeddings[i], metadata: { text: doc, id: i })
+end
+
+# 4. Query
+query = "How to run ML models?"
+query_embedding = embedder.embed(query)
+results = store.search(query_embedding, k: 3)
+
+puts "Query: #{query}\n\n"
+results.each_with_index do |result, i|
+  puts "#{i + 1}. (score: #{result[:score].round(4)}) #{result[:metadata][:text]}"
+end

data/ext/onnx_ruby/extconf.rb

@@ -0,0 +1,75 @@
+require "mkmf-rice"
+require "fileutils"
+require "tmpdir"
+
+ORT_VERSION = "1.24.3"
+
+def detect_platform
+  os = RbConfig::CONFIG["host_os"]
+  cpu = RbConfig::CONFIG["host_cpu"]
+
+  case os
+  when /darwin/
+    cpu =~ /arm64|aarch64/ ? "osx-arm64" : "osx-x86_64"
+  when /linux/
+    cpu =~ /aarch64|arm64/ ? "linux-aarch64" : "linux-x64"
+  else
+    abort "Unsupported OS: #{os}"
+  end
+end
+
+def download_onnxruntime(dest_dir)
+  platform = detect_platform
+  filename = "onnxruntime-#{platform}-#{ORT_VERSION}.tgz"
+  url = "https://github.com/microsoft/onnxruntime/releases/download/v#{ORT_VERSION}/#{filename}"
+  tmp_file = File.join(Dir.tmpdir, filename)
+
+  unless File.exist?(tmp_file)
+    puts "Downloading ONNX Runtime v#{ORT_VERSION} for #{platform}..."
+    system("curl", "-fSL", url, "-o", tmp_file) or
+      abort "Failed to download ONNX Runtime from #{url}"
+  end
+
+  FileUtils.mkdir_p(dest_dir)
+  puts "Extracting to #{dest_dir}..."
+  system("tar", "xzf", tmp_file, "-C", dest_dir, "--strip-components=1") or
+    abort "Failed to extract ONNX Runtime"
+
+  dest_dir
+end
+
+# Find ONNX Runtime
+ort_dir = ENV["ONNX_RUNTIME_DIR"]
+
+unless ort_dir
+  # Check for bundled copy
+  bundled_dir = File.join(__dir__, "onnxruntime")
+  if File.exist?(File.join(bundled_dir, "include", "onnxruntime_cxx_api.h"))
+    ort_dir = bundled_dir
+  else
+    ort_dir = download_onnxruntime(bundled_dir)
+  end
+end
+
+ort_include = File.join(ort_dir, "include")
+ort_lib = File.join(ort_dir, "lib")
+
+abort "Cannot find ONNX Runtime headers in #{ort_include}" unless File.exist?(File.join(ort_include, "onnxruntime_cxx_api.h"))
+
+$INCFLAGS << " -I#{ort_include}"
+$LDFLAGS << " -L#{ort_lib}"
+$libs << " -lonnxruntime"
+
+# Set rpath so the shared library can be found at runtime
+case RbConfig::CONFIG["host_os"]
+when /darwin/
+  $LDFLAGS << " -Wl,-rpath,#{ort_lib}"
+when /linux/
+  $LDFLAGS << " -Wl,-rpath,#{ort_lib}"
+end
+
+$CXXFLAGS = ($CXXFLAGS || "") + " -std=c++17"
+
+have_header("onnxruntime_cxx_api.h") or abort "Cannot find onnxruntime_cxx_api.h"
+
+create_makefile("onnx_ruby/onnx_ruby_ext")