siglip2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 68ada5506440969bdf35a88d2cfbd21e0b9fc3b8ebce65939b5d6f4d0630c66f
+  data.tar.gz: bd1df33b7d429de31464466e8c8de36205febc54a75124bafce6761f769053c4
+SHA512:
+  metadata.gz: 8aca7baf91b51fe000817053a23068cbc26594ea2a69e1e1d0f1fd8978babe02eec9fe7ff38edeb51df9dc43764c2be70c191787a3ffed3f5103963419a8d220
+  data.tar.gz: f0caa17a32ce58ef6f4acdcb3b51e67bfa7cde86b0c0a5a548fb30d0e2ca30ff7c533638af32449219fe5ce0b5556d1feaf79a756ebd4801ad163bbb2d5b9678

data/.mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "3.3.10"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Krzysztof Hasiński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,203 @@
+# SigLIP2-rb
+
+[![CI](https://github.com/khasinski/siglip2-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/khasinski/siglip2-rb/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/siglip2.svg)](https://rubygems.org/gems/siglip2)
+
+Ruby implementation of Google's SigLIP2 (Sigmoid Loss for Language Image Pre-Training 2) for creating text and image embeddings. Uses ONNX models from HuggingFace [onnx-community](https://huggingface.co/onnx-community).
+
+## What is this for?
+
+SigLIP2 creates numerical representations (embeddings) of images and text in the same vector space. This means you can directly compare text with images using cosine similarity.
+
+**Common use cases:**
+
+- **Image search** - find images matching a text query without manual tagging
+- **Content moderation** - detect unwanted content by comparing against text descriptions ("violence", "nudity", etc.)
+- **Image clustering** - group similar images by comparing their embeddings
+- **Duplicate detection** - find near-duplicate images in large collections
+- **Auto-tagging** - assign labels to images by finding best matching text descriptions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'siglip2'
+```
+
+Or install directly:
+
+```bash
+gem install siglip2
+```
+
+### Requirements
+
+- Ruby >= 3.0.0
+- ImageMagick (for image processing)
+
+## Usage
+
+### Ruby API
+
+```ruby
+require 'siglip2'
+
+# Create model with default settings (base-patch16-224)
+model = Siglip2::Model.new
+
+# Or specify a different model and quantization
+model = Siglip2::Model.new(
+  model_name: "large-patch16-256",
+  quantization: "int8"
+)
+
+# Encode text
+text_embedding = model.encode_text("a photo of a cat")
+
+# Encode image
+image_embedding = model.encode_image("cat.jpg")
+
+# Calculate similarity
+score = model.similarity("a photo of a cat", "cat.jpg")
+puts "Similarity: #{score}"
+
+# Batch similarity
+texts = ["a cat", "a dog", "a car"]
+images = ["image1.jpg", "image2.jpg"]
+scores = model.batch_similarity(texts, images)
+```
+
+### CLI Tools
+
+#### Embed text
+
+```bash
+siglip2-embed-text "a photo of a cat"
+siglip2-embed-text -m large-patch16-256 "a photo of a cat"
+siglip2-embed-text -q int8 "a photo of a cat"
+siglip2-embed-text -f csv "a photo of a cat"
+```
+
+#### Embed image
+
+```bash
+siglip2-embed-image cat.jpg
+siglip2-embed-image -m large-patch16-256 cat.jpg
+siglip2-embed-image -q int8 cat.jpg
+```
+
+#### Calculate similarity
+
+```bash
+siglip2-similarity "a photo of a cat" cat.jpg
+```
+
+#### List available models
+
+```bash
+siglip2-embed-text -l
+```
+
+#### List quantization options
+
+```bash
+siglip2-embed-text -L
+```
+
+## Use Case Examples
+
+### Image Search
+
+```ruby
+model = Siglip2::Model.new
+
+# Pre-compute embeddings for all images (store in database)
+image_embeddings = images.map { |path| [path, model.encode_image(path)] }
+
+# Search by text query
+query_embedding = model.encode_text("sunset over mountains")
+results = image_embeddings
+  .map { |path, emb| [path, dot_product(query_embedding, emb)] }
+  .sort_by { |_, score| -score }
+  .first(10)
+```
+
+### Content Moderation
+
+```ruby
+model = Siglip2::Model.new
+
+# Define unwanted content categories
+categories = ["violence", "gore", "nudity", "drugs"]
+category_embeddings = categories.map { |c| model.encode_text(c) }
+
+# Check uploaded image
+image_emb = model.encode_image(uploaded_file)
+scores = category_embeddings.map { |ce| dot_product(image_emb, ce) }
+
+if scores.max > 0.25  # threshold
+  flag_for_review(uploaded_file)
+end
+```
+
+### Auto-tagging
+
+```ruby
+model = Siglip2::Model.new
+
+tags = ["cat", "dog", "car", "landscape", "portrait", "food"]
+tag_embeddings = tags.map { |t| [t, model.encode_text("a photo of #{t}")] }
+
+image_emb = model.encode_image("photo.jpg")
+matched_tags = tag_embeddings
+  .map { |tag, emb| [tag, dot_product(image_emb, emb)] }
+  .select { |_, score| score > 0.2 }
+  .map(&:first)
+# => ["cat"]
+```
+
+## Available Models
+
+| Model | Image Size | Description |
+|-------|------------|-------------|
+| `base-patch16-224` | 224x224 | Default, smallest |
+| `base-patch16-256` | 256x256 | |
+| `base-patch16-384` | 384x384 | |
+| `base-patch16-512` | 512x512 | |
+| `base-patch32-256` | 256x256 | Larger patch size |
+| `base-patch16-naflex` | 224x224 | Flexible resolution |
+| `large-patch16-256` | 256x256 | Larger model |
+| `large-patch16-384` | 384x384 | |
+| `large-patch16-512` | 512x512 | |
+| `giant-opt-patch16-256` | 256x256 | Optimized giant |
+| `giant-opt-patch16-384` | 384x384 | |
+| `so400m-patch14-224` | 224x224 | 400M parameters |
+| `so400m-patch14-384` | 384x384 | |
+| `so400m-patch16-256` | 256x256 | |
+| `so400m-patch16-384` | 384x384 | |
+| `so400m-patch16-512` | 512x512 | |
+
+## Quantization Options
+
+| Option | Description |
+|--------|-------------|
+| `fp32` | Full precision (default) |
+| `fp16` | Half precision |
+| `int8` | 8-bit integer |
+| `uint8` | Unsigned 8-bit integer |
+| `q4` | 4-bit quantization |
+| `q4f16` | 4-bit with fp16 |
+| `bnb4` | BitsAndBytes 4-bit |
+
+## Model Storage
+
+Models are automatically downloaded on first use and stored in `~/.siglip2_models/`. You can change this location:
+
+```ruby
+Siglip2.models_dir = "/path/to/models"
+```
+
+## License
+
+MIT License

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/siglip2-embed-image

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "siglip2"
+require "optparse"
+require "json"
+
+options = {
+  model: Siglip2::DEFAULT_MODEL,
+  quantization: Siglip2::DEFAULT_QUANTIZATION,
+  format: "json"
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: siglip2-embed-image [options] IMAGE_PATH"
+
+  opts.on("-m", "--model MODEL", "Model name (default: #{Siglip2::DEFAULT_MODEL})") do |m|
+    options[:model] = m
+  end
+
+  opts.on("-q", "--quantization QUANT", "Quantization (default: #{Siglip2::DEFAULT_QUANTIZATION})") do |q|
+    options[:quantization] = q
+  end
+
+  opts.on("-f", "--format FORMAT", "Output format: json, csv (default: json)") do |f|
+    options[:format] = f
+  end
+
+  opts.on("-l", "--list-models", "List available models") do
+    puts "Available models:"
+    Siglip2.list_models.each { |m| puts "  #{m}" }
+    exit
+  end
+
+  opts.on("-L", "--list-quantizations", "List available quantizations") do
+    puts "Available quantizations:"
+    Siglip2.list_quantizations.each { |q| puts "  #{q}" }
+    exit
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+if ARGV.empty?
+  puts parser
+  exit 1
+end
+
+image_path = ARGV[0]
+
+unless File.exist?(image_path)
+  warn "Error: Image file not found: #{image_path}"
+  exit 1
+end
+
+begin
+  model = Siglip2::Model.new(model_name: options[:model], quantization: options[:quantization])
+  embedding = model.encode_image(image_path)
+
+  case options[:format]
+  when "json"
+    puts JSON.generate(embedding)
+  when "csv"
+    puts embedding.join(",")
+  else
+    puts JSON.generate(embedding)
+  end
+rescue Siglip2::Error => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/exe/siglip2-embed-text

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "siglip2"
+require "optparse"
+require "json"
+
+options = {
+  model: Siglip2::DEFAULT_MODEL,
+  quantization: Siglip2::DEFAULT_QUANTIZATION,
+  format: "json"
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: siglip2-embed-text [options] TEXT"
+
+  opts.on("-m", "--model MODEL", "Model name (default: #{Siglip2::DEFAULT_MODEL})") do |m|
+    options[:model] = m
+  end
+
+  opts.on("-q", "--quantization QUANT", "Quantization (default: #{Siglip2::DEFAULT_QUANTIZATION})") do |q|
+    options[:quantization] = q
+  end
+
+  opts.on("-f", "--format FORMAT", "Output format: json, csv (default: json)") do |f|
+    options[:format] = f
+  end
+
+  opts.on("-l", "--list-models", "List available models") do
+    puts "Available models:"
+    Siglip2.list_models.each { |m| puts "  #{m}" }
+    exit
+  end
+
+  opts.on("-L", "--list-quantizations", "List available quantizations") do
+    puts "Available quantizations:"
+    Siglip2.list_quantizations.each { |q| puts "  #{q}" }
+    exit
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+if ARGV.empty?
+  puts parser
+  exit 1
+end
+
+text = ARGV.join(" ")
+
+begin
+  model = Siglip2::Model.new(model_name: options[:model], quantization: options[:quantization])
+  embedding = model.encode_text(text)
+
+  case options[:format]
+  when "json"
+    puts JSON.generate(embedding)
+  when "csv"
+    puts embedding.join(",")
+  else
+    puts JSON.generate(embedding)
+  end
+rescue Siglip2::Error => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/exe/siglip2-similarity

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "siglip2"
+require "optparse"
+require "json"
+
+options = {
+  model: Siglip2::DEFAULT_MODEL,
+  quantization: Siglip2::DEFAULT_QUANTIZATION
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: siglip2-similarity [options] TEXT IMAGE_PATH"
+
+  opts.on("-m", "--model MODEL", "Model name (default: #{Siglip2::DEFAULT_MODEL})") do |m|
+    options[:model] = m
+  end
+
+  opts.on("-q", "--quantization QUANT", "Quantization (default: #{Siglip2::DEFAULT_QUANTIZATION})") do |q|
+    options[:quantization] = q
+  end
+
+  opts.on("-l", "--list-models", "List available models") do
+    puts "Available models:"
+    Siglip2.list_models.each { |m| puts "  #{m}" }
+    exit
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+if ARGV.length < 2
+  puts parser
+  exit 1
+end
+
+text = ARGV[0]
+image_path = ARGV[1]
+
+unless File.exist?(image_path)
+  warn "Error: Image file not found: #{image_path}"
+  exit 1
+end
+
+begin
+  model = Siglip2::Model.new(model_name: options[:model], quantization: options[:quantization])
+  score = model.similarity(text, image_path)
+
+  puts "Similarity score: #{score}"
+rescue Siglip2::Error => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/lib/siglip2/image_preprocessor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "mini_magick"
+require "numo/narray"
+
+module Siglip2
+  class ImagePreprocessor
+    # SigLIP2 normalization constants
+    # From preprocessor_config.json: mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]
+    MEAN = [0.5, 0.5, 0.5].freeze
+    STD = [0.5, 0.5, 0.5].freeze
+
+    attr_reader :size
+
+    def initialize(size: 224)
+      @size = size
+    end
+
+    def preprocess(image_path)
+      image = load_and_resize(image_path)
+      tensor = image_to_tensor(image)
+      tensor = normalize(tensor)
+      add_batch_dimension(tensor)
+    end
+
+    private
+
+    def load_and_resize(image_path)
+      image = MiniMagick::Image.open(image_path)
+      image.format("png")
+      image.resize("#{@size}x#{@size}!")
+      image.colorspace("sRGB")
+      image
+    end
+
+    def image_to_tensor(image)
+      # Get raw pixel data as RGB
+      pixels = image.get_pixels
+
+      # Convert to Numo::SFloat array
+      # Shape: [height, width, 3]
+      height = pixels.length
+      width = pixels[0].length
+
+      flat_pixels = pixels.flatten.map(&:to_f)
+      tensor = Numo::SFloat.cast(flat_pixels)
+      tensor = tensor.reshape(height, width, 3)
+
+      # Rescale from [0, 255] to [0, 1]
+      tensor = tensor / 255.0
+
+      # Transpose from [H, W, C] to [C, H, W]
+      tensor = tensor.transpose(2, 0, 1)
+
+      tensor
+    end
+
+    def normalize(tensor)
+      # Apply normalization: (x - mean) / std
+      # For SigLIP2: (x - 0.5) / 0.5 = 2x - 1, maps [0,1] to [-1,1]
+      result = Numo::SFloat.zeros(tensor.shape)
+
+      3.times do |c|
+        result[c, true, true] = (tensor[c, true, true] - MEAN[c]) / STD[c]
+      end
+
+      result
+    end
+
+    def add_batch_dimension(tensor)
+      # Convert to nested Ruby arrays with batch dimension
+      # Shape: [1, 3, height, width]
+      [tensor.to_a]
+    end
+  end
+end

data/lib/siglip2/model.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "onnxruntime"
+require "tokenizers"
+
+module Siglip2
+  class Model
+    attr_reader :model_name, :quantization, :model_path
+
+    # Image sizes for each model variant
+    IMAGE_SIZES = {
+      "base-patch16-224" => 224,
+      "base-patch16-256" => 256,
+      "base-patch16-384" => 384,
+      "base-patch16-512" => 512,
+      "base-patch32-256" => 256,
+      "base-patch16-naflex" => 224,
+      "large-patch16-256" => 256,
+      "large-patch16-384" => 384,
+      "large-patch16-512" => 512,
+      "giant-opt-patch16-256" => 256,
+      "giant-opt-patch16-384" => 384,
+      "so400m-patch14-224" => 224,
+      "so400m-patch14-384" => 384,
+      "so400m-patch16-256" => 256,
+      "so400m-patch16-384" => 384,
+      "so400m-patch16-512" => 512
+    }.freeze
+
+    def initialize(model_name: Siglip2::DEFAULT_MODEL, quantization: Siglip2::DEFAULT_QUANTIZATION)
+      @model_name = model_name
+      @quantization = quantization
+      @model_path = Siglip2.model_path(model_name, quantization: quantization)
+
+      unless Siglip2.models_exist?(model_name, quantization: quantization)
+        Siglip2.download_models(model_name, quantization: quantization)
+      end
+
+      @image_size = IMAGE_SIZES[model_name] || 224
+      @image_preprocessor = ImagePreprocessor.new(size: @image_size)
+    end
+
+    def encode_text(text)
+      input_ids = tokenize(text)
+
+      output = text_model.predict({ "input_ids" => input_ids })
+
+      # Extract pooler_output embeddings
+      embeddings = output["pooler_output"].flatten
+      normalize_embeddings(embeddings)
+    end
+
+    def encode_image(image_path)
+      pixel_values = @image_preprocessor.preprocess(image_path)
+
+      output = vision_model.predict({ "pixel_values" => pixel_values })
+
+      # Extract pooler_output embeddings
+      embeddings = output["pooler_output"].flatten
+      normalize_embeddings(embeddings)
+    end
+
+    def similarity(text, image_path)
+      text_embedding = encode_text(text)
+      image_embedding = encode_image(image_path)
+
+      dot_product(text_embedding, image_embedding)
+    end
+
+    def batch_similarity(texts, image_paths)
+      text_embeddings = texts.map { |t| encode_text(t) }
+      image_embeddings = image_paths.map { |p| encode_image(p) }
+
+      text_embeddings.map do |te|
+        image_embeddings.map { |ie| dot_product(te, ie) }
+      end
+    end
+
+    private
+
+    def tokenizer
+      @tokenizer ||= Tokenizers.from_file(File.join(@model_path, "tokenizer.json"))
+    end
+
+    def text_model
+      @text_model ||= OnnxRuntime::Model.new(File.join(@model_path, "text_model.onnx"))
+    end
+
+    def vision_model
+      @vision_model ||= OnnxRuntime::Model.new(File.join(@model_path, "vision_model.onnx"))
+    end
+
+    def tokenize(text)
+      # SigLIP2 uses Gemma tokenizer - lowercase text
+      processed_text = text.downcase
+
+      encoding = tokenizer.encode(processed_text)
+      input_ids = encoding.ids
+
+      # Truncate or pad to max_length (64 is typical for SigLIP2)
+      max_length = 64
+      if input_ids.length > max_length
+        input_ids = input_ids[0...max_length]
+      elsif input_ids.length < max_length
+        padding_length = max_length - input_ids.length
+        input_ids += Array.new(padding_length, 0)  # 0 is pad token
+      end
+
+      # Return as 2D array (batch size = 1) with int64 type
+      [input_ids]
+    end
+
+    def normalize_embeddings(embeddings)
+      norm = Math.sqrt(embeddings.map { |x| x * x }.sum)
+      return embeddings if norm == 0
+
+      embeddings.map { |x| x / norm }
+    end
+
+    def dot_product(a, b)
+      a.zip(b).map { |x, y| x * y }.sum
+    end
+  end
+end

data/lib/siglip2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Siglip2
+  VERSION = "1.0.0"
+end

data/lib/siglip2.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "siglip2/version"
+require_relative "siglip2/model"
+require_relative "siglip2/image_preprocessor"
+
+require "net/http"
+require "uri"
+require "fileutils"
+
+module Siglip2
+  class Error < StandardError; end
+
+  # Available models from onnx-community on HuggingFace
+  AVAILABLE_MODELS = {
+    # Base models
+    "base-patch16-224" => "onnx-community/siglip2-base-patch16-224-ONNX",
+    "base-patch16-256" => "onnx-community/siglip2-base-patch16-256-ONNX",
+    "base-patch16-384" => "onnx-community/siglip2-base-patch16-384-ONNX",
+    "base-patch16-512" => "onnx-community/siglip2-base-patch16-512-ONNX",
+    "base-patch32-256" => "onnx-community/siglip2-base-patch32-256-ONNX",
+    "base-patch16-naflex" => "onnx-community/siglip2-base-patch16-naflex-ONNX",
+
+    # Large models
+    "large-patch16-256" => "onnx-community/siglip2-large-patch16-256-ONNX",
+    "large-patch16-384" => "onnx-community/siglip2-large-patch16-384-ONNX",
+    "large-patch16-512" => "onnx-community/siglip2-large-patch16-512-ONNX",
+
+    # Giant optimized models
+    "giant-opt-patch16-256" => "onnx-community/siglip2-giant-opt-patch16-256-ONNX",
+    "giant-opt-patch16-384" => "onnx-community/siglip2-giant-opt-patch16-384-ONNX",
+
+    # SO400M models
+    "so400m-patch14-224" => "onnx-community/siglip2-so400m-patch14-224-ONNX",
+    "so400m-patch14-384" => "onnx-community/siglip2-so400m-patch14-384-ONNX",
+    "so400m-patch16-256" => "onnx-community/siglip2-so400m-patch16-256-ONNX",
+    "so400m-patch16-384" => "onnx-community/siglip2-so400m-patch16-384-ONNX",
+    "so400m-patch16-512" => "onnx-community/siglip2-so400m-patch16-512-ONNX"
+  }.freeze
+
+  DEFAULT_MODEL = "base-patch16-224"
+
+  # Model quantization options
+  QUANTIZATION_OPTIONS = %w[
+    fp32
+    fp16
+    int8
+    uint8
+    q4
+    q4f16
+    bnb4
+  ].freeze
+
+  DEFAULT_QUANTIZATION = "fp32"
+
+  class << self
+    def models_dir
+      @models_dir ||= File.join(Dir.home, ".siglip2_models")
+    end
+
+    def models_dir=(path)
+      @models_dir = path
+    end
+
+    def model_path(model_name, quantization: DEFAULT_QUANTIZATION)
+      raise Error, "Unknown model: #{model_name}" unless AVAILABLE_MODELS.key?(model_name)
+      raise Error, "Unknown quantization: #{quantization}" unless QUANTIZATION_OPTIONS.include?(quantization)
+
+      File.join(models_dir, model_name, quantization)
+    end
+
+    def models_exist?(model_name, quantization: DEFAULT_QUANTIZATION)
+      path = model_path(model_name, quantization: quantization)
+      File.exist?(File.join(path, "vision_model.onnx")) &&
+        File.exist?(File.join(path, "text_model.onnx")) &&
+        File.exist?(File.join(path, "tokenizer.json"))
+    end
+
+    def download_models(model_name, quantization: DEFAULT_QUANTIZATION)
+      raise Error, "Unknown model: #{model_name}" unless AVAILABLE_MODELS.key?(model_name)
+
+      repo = AVAILABLE_MODELS[model_name]
+      path = model_path(model_name, quantization: quantization)
+      FileUtils.mkdir_p(path)
+
+      # Determine file suffix based on quantization
+      suffix = quantization_suffix(quantization)
+
+      files = {
+        "vision_model.onnx" => "onnx/vision_model#{suffix}.onnx",
+        "text_model.onnx" => "onnx/text_model#{suffix}.onnx",
+        "tokenizer.json" => "tokenizer.json"
+      }
+
+      files.each do |local_name, remote_path|
+        local_path = File.join(path, local_name)
+        next if File.exist?(local_path)
+
+        url = "https://huggingface.co/#{repo}/resolve/main/#{remote_path}"
+        puts "Downloading #{local_name} from #{url}..."
+        download_file(url, local_path)
+      end
+    end
+
+    def list_models
+      AVAILABLE_MODELS.keys
+    end
+
+    def list_quantizations
+      QUANTIZATION_OPTIONS
+    end
+
+    private
+
+    def quantization_suffix(quantization)
+      case quantization
+      when "fp32" then ""
+      when "fp16" then "_fp16"
+      when "int8" then "_int8"
+      when "uint8" then "_uint8"
+      when "q4" then "_q4"
+      when "q4f16" then "_q4f16"
+      when "bnb4" then "_bnb4"
+      else ""
+      end
+    end
+
+    def download_file(url, path, redirect_limit = 10)
+      raise Error, "Too many HTTP redirects" if redirect_limit == 0
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = 300
+
+      request = Net::HTTP::Get.new(uri)
+
+      http.request(request) do |response|
+        case response
+        when Net::HTTPSuccess
+          File.open(path, "wb") do |file|
+            response.read_body do |chunk|
+              file.write(chunk)
+            end
+          end
+        when Net::HTTPRedirection
+          download_file(response["location"], path, redirect_limit - 1)
+        else
+          raise Error, "Failed to download #{url}: #{response.code} #{response.message}"
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: siglip2
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Krzysztof Hasiński
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: onnxruntime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: tokenizers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Ruby implementation of Google's SigLIP2 model for creating text and image
+  embeddings. Uses ONNX models from HuggingFace onnx-community.
+email:
+- krzysztof.hasinski@gmail.com
+executables:
+- siglip2-embed-image
+- siglip2-embed-text
+- siglip2-similarity
+extensions: []
+extra_rdoc_files: []
+files:
+- ".mise.toml"
+- LICENSE
+- README.md
+- Rakefile
+- exe/siglip2-embed-image
+- exe/siglip2-embed-text
+- exe/siglip2-similarity
+- lib/siglip2.rb
+- lib/siglip2/image_preprocessor.rb
+- lib/siglip2/model.rb
+- lib/siglip2/version.rb
+homepage: https://github.com/khasinski/siglip2-rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/khasinski/siglip2-rb
+  changelog_uri: https://github.com/khasinski/siglip2-rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Google SigLIP2 embeddings using ONNX models
+test_files: []