red-candle 1.8.0.pre3-aarch64-linux → 1.8.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 865001ec06d59694ce61a2652c37d9dfd9abc6610ecc051baf96fd21f6f76c1c
-  data.tar.gz: a59715d4c4ef6b2a1385d4f523c0a3f719df0c2b59dcaefa6a851f6bc46e9a5a
+  metadata.gz: d5e21bb0c8bd8b2ee1742ce7f1d4ba4105fe8472345e5173f001abeb899d2097
+  data.tar.gz: 291bef82a1050bb76bd848feb38902a603b4ecb3cfa507a61320dcb2bbeee18c
 SHA512:
-  metadata.gz: e8c15a64e5976f7cc26b0890f209e3a93e4e1cca3d84cc8d90b1af7b32daf6f3db39e8e3d9e2c53824619bec5c8263edc7e9ef2d92c7332fbbf64f685ae227df
-  data.tar.gz: 3da3837bf1f309655130015196f03ca7fafeb44f34b2cdd8cb76046e16e76a11de2556168b2c8a61acac1841c90d661f2757384009aef2c3c37cf80ffe5abd16
+  metadata.gz: 58aee435bf605260b6a71a9458fec999ebae00c60d5105d4d2be3fa1fd532a5c9d990b980e69dffcba3ecd20a63dd463dfca65bd4d468d188206bdf6010d95fc
+  data.tar.gz: d653d24ceb94edf532e1562f5dffa28ab13fb614577ae7f88ac024d5bcd356ea6c6aa7e67d1f71b91a7d13debb570be051b2fc33d5575099b86b029f9c75947e

data/README.md

@@ -107,6 +107,10 @@ device = Candle::Device.cpu     # or Candle::Device.metal, Candle::Device.cuda
 model = Candle::EmbeddingModel.from_pretrained("jinaai/jina-embeddings-v2-base-en", device: device)
 embedding = model.embedding("Hi there!")
 
+# Cap input length (in tokens) to cut memory; longer inputs are truncated.
+# JinaBERT otherwise reserves ~3.2 GB for its full 8192-token context.
+model = Candle::EmbeddingModel.from_pretrained(max_length: 512)
+
 # Reranker also supports device selection
 reranker = Candle::Reranker.from_pretrained("cross-encoder/ms-marco-MiniLM-L-12-v2", device: device)
 results = reranker.rerank("query", ["doc1", "doc2", "doc3"])

data/Rakefile

@@ -2,7 +2,16 @@
 
 require "bundler/gem_tasks"
 require "rake/extensiontask"
-require "rspec/core/rake_task"
+
+# rspec is a dev-only dependency. The rb-sys-dock cross-compile container installs
+# the RUNTIME bundle only, so this require is absent there — guard it so the Rakefile
+# (and therefore the `native:<platform>` cross tasks) still loads in a build-only env.
+begin
+  require "rspec/core/rake_task"
+  RSPEC_AVAILABLE = true
+rescue LoadError
+  RSPEC_AVAILABLE = false
+end
 
 task default: :spec
 
@@ -90,18 +99,28 @@ desc "Run Rust tests with coverage (alias)"
 task "coverage:rust" => "rust:coverage:html"
 
 # RSpec tasks
-desc "Run RSpec tests"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = "--format progress"
+if RSPEC_AVAILABLE
+  desc "Run RSpec tests"
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = "--format progress"
+  end
+else
+  desc "spec (rspec unavailable here)"
+  task(:spec) { abort "rspec is a dev dependency — not available in this environment" }
 end
 
 # Add compile as a dependency for spec task
 task spec: :compile
 
 namespace :spec do
-  desc "Run RSpec tests with all devices"
-  RSpec::Core::RakeTask.new(:device) do |t|
-    t.rspec_opts = "--format documentation --tag device"
+  if RSPEC_AVAILABLE
+    desc "Run RSpec tests with all devices"
+    RSpec::Core::RakeTask.new(:device) do |t|
+      t.rspec_opts = "--format documentation --tag device"
+    end
+  else
+    desc "spec:device (rspec unavailable here)"
+    task(:device) { abort "rspec is a dev dependency — not available in this environment" }
   end
   
   desc "Run RSpec tests with coverage"

data/ext/candle/src/ruby/embedding_model.rs

@@ -72,10 +72,11 @@ pub struct EmbeddingModelInner {
     model: Option<EmbeddingModelVariant>,
     tokenizer: Option<TokenizerWrapper>,
     embedding_size: Option<usize>,
+    max_length: Option<usize>,
 }
 
 impl EmbeddingModel {
-    pub fn new(model_id: Option<String>, tokenizer: Option<String>, device: Option<Device>, model_type: Option<String>, embedding_size: Option<usize>) -> Result<Self> {
+    pub fn new(model_id: Option<String>, tokenizer: Option<String>, device: Option<Device>, model_type: Option<String>, embedding_size: Option<usize>, max_length: Option<usize>) -> Result<Self> {
         let device = device.unwrap_or(Device::best()).as_device()?;
         let model_type = model_type
             .and_then(|mt| EmbeddingModelType::from_string(&mt))
@@ -86,14 +87,15 @@ impl EmbeddingModel {
             tokenizer_id: tokenizer.clone(),
             model_type: Some(model_type),
             model: match model_id.as_ref() {
-                Some(id) => Some(Self::build_embedding_model(id, device, model_type, embedding_size)?),
+                Some(id) => Some(Self::build_embedding_model(id, device, model_type, embedding_size, max_length)?),
                 None => None
             },
             tokenizer: match tokenizer {
-                Some(tid) => Some(Self::build_tokenizer(tid)?),
+                Some(tid) => Some(Self::build_tokenizer(tid, max_length)?),
                 None => None
             },
             embedding_size,
+            max_length,
         }))
     }
 
@@ -177,7 +179,7 @@ impl EmbeddingModel {
         }
     }
 
-    fn build_embedding_model(model_id: &str, device: CoreDevice, model_type: EmbeddingModelType, embedding_size: Option<usize>) -> Result<EmbeddingModelVariant> {
+    fn build_embedding_model(model_id: &str, device: CoreDevice, model_type: EmbeddingModelType, embedding_size: Option<usize>, max_length: Option<usize>) -> Result<EmbeddingModelVariant> {
         use hf_hub::{api::sync::Api, Repo, RepoType};
         let api = Api::new().map_err(wrap_hf_err)?;
         let repo = Repo::new(model_id.to_string(), RepoType::Model);
@@ -194,6 +196,11 @@ impl EmbeddingModel {
                 let final_emb_dim = Self::resolve_embedding_size(Path::new(&model_path), embedding_size)?;
                 let mut config = JinaConfig::v2_base();
                 config.hidden_size = final_emb_dim;
+                // JinaBERT precomputes an ALiBi bias of heads x len x len floats
+                // (3.2 GB at the default 8192), so size it to the inputs we accept.
+                if let Some(max_length) = max_length {
+                    config.max_position_embeddings = max_length;
+                }
                 let vb = unsafe {
                     VarBuilder::from_mmaped_safetensors(&[model_path], CoreDType::F32, &device)
                         .map_err(wrap_candle_err)?
@@ -268,7 +275,7 @@ impl EmbeddingModel {
         }
     }
 
-    fn build_tokenizer(tokenizer_id: String) -> Result<TokenizerWrapper> {
+    fn build_tokenizer(tokenizer_id: String, max_length: Option<usize>) -> Result<TokenizerWrapper> {
         use hf_hub::{api::sync::Api, Repo, RepoType};
         let tokenizer_path = Api::new()
                 .map_err(wrap_hf_err)?
@@ -282,6 +289,10 @@ impl EmbeddingModel {
             .map_err(wrap_std_err)?;
         
         let tokenizer = TokenizerLoader::with_padding(tokenizer, None);
+        let tokenizer = match max_length {
+            Some(max_length) => TokenizerLoader::with_truncation(tokenizer, max_length),
+            None => tokenizer,
+        };
         Ok(TokenizerWrapper::new(tokenizer))
     }
 
@@ -451,6 +462,11 @@ impl EmbeddingModel {
         if let Some(size) = self.0.embedding_size {
             hash.aset("embedding_size", size)?;
         }
+
+        // Add max_length
+        if let Some(max_length) = self.0.max_length {
+            hash.aset("max_length", max_length)?;
+        }
         
         Ok(hash)
     }
@@ -459,7 +475,7 @@ impl EmbeddingModel {
 pub fn init(rb_candle: RModule) -> Result<()> {
     let ruby = Ruby::get().unwrap();
     let rb_embedding_model = rb_candle.define_class("EmbeddingModel", ruby.class_object())?;
-    rb_embedding_model.define_singleton_method("_create", function!(EmbeddingModel::new, 5))?;
+    rb_embedding_model.define_singleton_method("_create", function!(EmbeddingModel::new, 6))?;
     // Expose embedding with an optional pooling_method argument (default: "pooled")
     rb_embedding_model.define_method("_embedding", method!(EmbeddingModel::embedding, 2))?;
     rb_embedding_model.define_method("embeddings", method!(EmbeddingModel::embeddings, 1))?;

data/lib/candle/embedding_model.rb

@@ -15,8 +15,9 @@ module Candle
     # @param tokenizer [String, nil] The tokenizer to use (defaults to using the model's tokenizer)
     # @param model_type [String, nil] The type of embedding model (auto-detected if nil)
     # @param embedding_size [Integer, nil] Override for the embedding size (optional)
+    # @param max_length [Integer, nil] Longest input in tokens; longer inputs are truncated (optional)
     # @return [EmbeddingModel] A new EmbeddingModel instance
-    def self.from_pretrained(model_id = DEFAULT_MODEL_PATH, device: Candle::Device.best, tokenizer: nil, model_type: nil, embedding_size: nil)
+    def self.from_pretrained(model_id = DEFAULT_MODEL_PATH, device: Candle::Device.best, tokenizer: nil, model_type: nil, embedding_size: nil, max_length: nil)
       # Auto-detect model type based on model_id if not provided
       if model_type.nil?
         model_type = case model_id.downcase
@@ -34,7 +35,7 @@ module Candle
       # Use model_id as tokenizer if not specified (usually what you want)
       tokenizer_id = tokenizer || model_id
       
-      _create(model_id, tokenizer_id, device, model_type, embedding_size)
+      _create(model_id, tokenizer_id, device, model_type, embedding_size, max_length)
     end
     
     # Constructor for creating a new EmbeddingModel with optional parameters
@@ -44,13 +45,15 @@ module Candle
     # @param device [Candle::Device, Candle::Device.cpu] The device to use for computation
     # @param model_type [String, nil] The type of embedding model to use
     # @param embedding_size [Integer, nil] Override for the embedding size (optional)
+    # @param max_length [Integer, nil] Longest input in tokens; longer inputs are truncated (optional)
     def self.new(model_path: DEFAULT_MODEL_PATH,
       tokenizer_path: DEFAULT_TOKENIZER_PATH,
       device: Candle::Device.best,
       model_type: DEFAULT_EMBEDDING_MODEL_TYPE,
-      embedding_size: nil)
+      embedding_size: nil,
+      max_length: nil)
       $stderr.puts "[DEPRECATION] `EmbeddingModel.new` is deprecated. Please use `EmbeddingModel.from_pretrained` instead."
-      _create(model_path, tokenizer_path, device, model_type, embedding_size)
+      _create(model_path, tokenizer_path, device, model_type, embedding_size, max_length)
     end
     # Returns the embedding for a string using the specified pooling method.
     # @param str [String] The input text

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.8.0.pre3"
+  VERSION = "1.8.2"
 end
 # :nocov:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.8.0.pre3
+  version: 1.8.2
 platform: aarch64-linux
 authors:
 - Christopher Petersen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-18 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys