red-candle 0.0.5 → 1.0.0.pre.1

data/lib/candle/build_info.rb

@@ -0,0 +1,66 @@
+module Candle
+  module BuildInfo
+    def self.display_cuda_info
+      info = Candle.build_info
+      
+      # Only display CUDA info if running in development or if CANDLE_VERBOSE is set
+      return unless ENV['CANDLE_VERBOSE'] || ENV['CANDLE_DEBUG'] || $DEBUG
+      
+      if info["cuda_available"] == false
+        # Check if CUDA could be available on the system
+        cuda_potentially_available = ENV['CUDA_ROOT'] || ENV['CUDA_PATH'] || 
+                                   File.exist?('/usr/local/cuda') || File.exist?('/opt/cuda')
+        
+        if cuda_potentially_available
+          warn "=" * 80
+          warn "Red Candle: CUDA detected on system but not enabled in build."
+          warn "To enable CUDA support (experimental), reinstall with:"
+          warn "  CANDLE_ENABLE_CUDA=1 gem install red-candle"
+          warn "=" * 80
+        end
+      end
+    end
+    
+    def self.cuda_available?
+      Candle.build_info["cuda_available"]
+    end
+
+    def self.metal_available?
+      Candle.build_info["metal_available"]
+    end
+
+    def self.mkl_available?
+      Candle.build_info["mkl_available"]
+    end
+
+    def self.accelerate_available?
+      Candle.build_info["accelerate_available"]
+    end
+
+    def self.cudnn_available?
+      Candle.build_info["cudnn_available"]
+    end
+
+    def self.summary
+      info = Candle.build_info
+      
+      available_backends = []
+      available_backends << "Metal" if info["metal_available"]
+      available_backends << "CUDA" if info["cuda_available"]
+      available_backends << "CPU"
+      
+      {
+        default_device: info["default_device"],
+        available_backends: available_backends,
+        cuda_available: info["cuda_available"],
+        metal_available: info["metal_available"],
+        mkl_available: info["mkl_available"],
+        accelerate_available: info["accelerate_available"],
+        cudnn_available: info["cudnn_available"]
+      }
+    end
+  end
+end
+
+# Display CUDA info on load
+Candle::BuildInfo.display_cuda_info

data/lib/candle/device_utils.rb

@@ -0,0 +1,20 @@
+module Candle
+  module DeviceUtils
+    # Get the best available device (Metal > CUDA > CPU)
+    def self.best_device
+      # Try devices in order of preference
+      begin
+        # Try Metal first (for Mac users)
+        Device.metal
+      rescue
+        begin
+          # Try CUDA next (for NVIDIA GPU users)
+          Device.cuda
+        rescue
+          # Fall back to CPU
+          Device.cpu
+        end
+      end
+    end
+  end
+end

data/lib/candle/embedding_model.rb

@@ -0,0 +1,32 @@
+module Candle
+  class EmbeddingModel
+    # Default model path for Jina BERT embedding model
+    DEFAULT_MODEL_PATH = "jinaai/jina-embeddings-v2-base-en"
+    
+    # Default tokenizer path that works well with the default model
+    DEFAULT_TOKENIZER_PATH = "sentence-transformers/all-MiniLM-L6-v2"
+    
+    # Default embedding model type
+    DEFAULT_EMBEDDING_MODEL_TYPE = "jina_bert"
+    
+    # Constructor for creating a new EmbeddingModel with optional parameters
+    # @param model_path [String, nil] The path to the model on Hugging Face
+    # @param tokenizer_path [String, nil] The path to the tokenizer on Hugging Face
+    # @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)
+    def self.new(model_path: DEFAULT_MODEL_PATH,
+      tokenizer_path: DEFAULT_TOKENIZER_PATH,
+      device: Candle::Device.cpu,
+      model_type: DEFAULT_EMBEDDING_MODEL_TYPE,
+      embedding_size: nil)
+      _create(model_path, tokenizer_path, device, model_type, embedding_size)
+    end
+    # Returns the embedding for a string using the specified pooling method.
+    # @param str [String] The input text
+    # @param pooling_method [String] Pooling method: "pooled", "pooled_normalized", or "cls". Default: "pooled_normalized"
+    def embedding(str, pooling_method: "pooled_normalized")
+      _embedding(str, pooling_method)
+    end
+  end
+end

data/lib/candle/embedding_model_type.rb

@@ -0,0 +1,31 @@
+module Candle
+  # Enum for the supported embedding model types
+  module EmbeddingModelType
+    # Jina Bert embedding models (e.g., jina-embeddings-v2-base-en)
+    JINA_BERT = "jina_bert"
+    
+    # Standard BERT embedding models (e.g., bert-base-uncased)
+    STANDARD_BERT = "standard_bert"
+    
+    # MiniLM embedding models (e.g., all-MiniLM-L6-v2)
+    MINILM = "minilm"
+    
+    # DistilBERT models which can be used for embeddings
+    DISTILBERT = "distilbert"
+    
+    # Returns a list of all supported model types
+    def self.all
+      [JINA_BERT, STANDARD_BERT, DISTILBERT, MINILM]
+    end
+    
+    # Returns suggested model paths for each model type
+    def self.suggested_model_paths
+      {
+        JINA_BERT => "jinaai/jina-embeddings-v2-base-en",
+        STANDARD_BERT => "scientistcom/BiomedNLP-BiomedBERT-base-uncased-abstract-fulltext",
+        MINILM => "sentence-transformers/all-MiniLM-L6-v2",
+        DISTILBERT => "scientistcom/distilbert-base-uncased-finetuned-sst-2-english",
+      }
+    end
+  end
+end

data/lib/candle/llm.rb

@@ -0,0 +1,107 @@
+module Candle
+  class LLM
+    # Simple chat interface for instruction models
+    def chat(messages, **options)
+      prompt = format_messages(messages)
+      generate(prompt, **options)
+    end
+
+    # Streaming chat interface
+    def chat_stream(messages, **options, &block)
+      prompt = format_messages(messages)
+      generate_stream(prompt, **options, &block)
+    end
+
+    def generate(prompt, config: GenerationConfig.balanced, reset_cache: true)
+      begin
+        _generate(prompt, config)
+      ensure
+        clear_cache if reset_cache
+      end
+    end
+
+    def generate_stream(prompt, config: GenerationConfig.balanced, reset_cache: true, &block)
+      begin
+        _generate_stream(prompt, config, &block)
+      ensure
+        clear_cache if reset_cache
+      end
+    end
+
+    def self.from_pretrained(model_id, device: Candle::Device.cpu)
+      _from_pretrained(model_id, device)
+    end
+
+    private
+
+    # Format messages into a prompt string
+    # This is a simple implementation - model-specific formatting should be added
+    def format_messages(messages)
+      formatted = messages.map do |msg|
+        case msg[:role]
+        when "system"
+          "System: #{msg[:content]}"
+        when "user"
+          "User: #{msg[:content]}"
+        when "assistant"
+          "Assistant: #{msg[:content]}"
+        else
+          msg[:content]
+        end
+      end.join("\n\n")
+      
+      # Add a prompt for the assistant to respond
+      formatted + "\n\nAssistant:"
+    end
+  end
+
+  class GenerationConfig
+    # Convenience method to create config with overrides
+    def with(**overrides)
+      current_config = {
+        max_length: max_length,
+        temperature: temperature,
+        top_p: top_p,
+        top_k: top_k,
+        repetition_penalty: repetition_penalty,
+        seed: seed,
+        stop_sequences: stop_sequences,
+        include_prompt: include_prompt
+      }.compact
+      
+      self.class.new(current_config.merge(overrides))
+    end
+
+    # Create a deterministic configuration (temperature = 0, fixed seed)
+    def self.deterministic(**opts)
+      defaults = {
+        temperature: 0.0,
+        top_p: nil,
+        top_k: 1,
+        seed: 42
+      }
+      new(defaults.merge(opts))
+    end
+
+    # Create a creative configuration (higher temperature, random seed)
+    def self.creative(**opts)
+      defaults = {
+        temperature: 1.0,
+        top_p: 0.95,
+        top_k: 50,
+        repetition_penalty: 1.2
+      }
+      new(defaults.merge(opts))
+    end
+
+    # Create a balanced configuration (moderate temperature, random seed)
+    def self.balanced(**opts)
+      defaults = {
+        temperature: 0.7,
+        top_p: 0.9,
+        top_k: 40
+      }
+      new(defaults.merge(opts))
+    end
+  end
+end

data/lib/candle/reranker.rb

@@ -0,0 +1,24 @@
+module Candle
+  class Reranker
+    # Default model path for cross-encoder/ms-marco-MiniLM-L-12-v2
+    DEFAULT_MODEL_PATH = "cross-encoder/ms-marco-MiniLM-L-12-v2"
+    
+    # Constructor for creating a new Reranker with optional parameters
+    # @param model_path [String, nil] The path to the model on Hugging Face
+    # @param device [Candle::Device, Candle::Device.cpu] The device to use for computation
+    def self.new(model_path: DEFAULT_MODEL_PATH, device: Candle::Device.cpu)
+      _create(model_path, device)
+    end
+
+    # Returns the embedding for a string using the specified pooling method.
+    # @param query [String] The input text
+    # @param documents [Array<String>] The list of documents to compare against
+    # @param pooling_method [String] Pooling method: "pooler", "cls", or "mean". Default: "pooler"
+    # @param apply_sigmoid [Boolean] Whether to apply sigmoid to the scores. Default: true
+    def rerank(query, documents, pooling_method: "pooler", apply_sigmoid: true)
+      rerank_with_options(query, documents, pooling_method, apply_sigmoid).collect { |doc, score, doc_id|
+        { doc_id: doc_id, score: score, text: doc }
+      }
+    end
+  end
+end

data/lib/candle/tensor.rb

@@ -3,15 +3,80 @@ module Candle
     include Enumerable
 
     def each
-      if self.rank == 1
-        self.values.each do |value|
-          yield value
+      case self.rank
+      when 0
+        # Scalar tensor - yield the single value
+        yield self.item
+      when 1
+        # 1D tensor - yield each value
+        # Check if we can use f32 values to avoid conversion
+        if dtype.to_s.downcase == "f32"
+          begin
+            values_f32.each { |value| yield value }
+          rescue NoMethodError
+            # If values_f32 isn't available yet (not recompiled), fall back
+            if device.to_s != "cpu"
+              # Move to CPU to avoid Metal F32->F64 conversion issue
+              to_device(Candle::Device.cpu).values.each { |value| yield value }
+            else
+              values.each { |value| yield value }
+            end
+          end
+        else
+          # For non-F32 dtypes, use regular values
+          values.each { |value| yield value }
         end
       else
+        # Multi-dimensional tensor - yield each sub-tensor
         shape.first.times do |i|
           yield self[i]
         end
       end
     end
+    
+    # Convert scalar tensor to float
+    def to_f
+      if rank == 0
+        # Use item method which handles dtype conversion properly
+        item
+      else
+        raise ArgumentError, "to_f can only be called on scalar tensors (rank 0), but this tensor has rank #{rank}"
+      end
+    end
+    
+    # Convert scalar tensor to integer
+    def to_i
+      to_f.to_i
+    end
+    
+    
+    # Override class methods to support keyword arguments for device
+    class << self
+      alias_method :_original_new, :new
+      alias_method :_original_ones, :ones
+      alias_method :_original_zeros, :zeros
+      alias_method :_original_rand, :rand
+      alias_method :_original_randn, :randn
+      
+      def new(data, dtype = nil, device: nil)
+        _original_new(data, dtype, device)
+      end
+      
+      def ones(shape, device: nil)
+        _original_ones(shape, device)
+      end
+      
+      def zeros(shape, device: nil)
+        _original_zeros(shape, device)
+      end
+      
+      def rand(shape, device: nil)
+        _original_rand(shape, device)
+      end
+      
+      def randn(shape, device: nil)
+        _original_randn(shape, device)
+      end
+    end
   end
 end

data/lib/candle/version.rb

@@ -1,3 +1,3 @@
 module Candle
-  VERSION = "0.0.5"
-end
+  VERSION = "1.0.0.pre.1"
+end

data/lib/candle.rb

@@ -1,2 +1,8 @@
 require_relative "candle/candle"
 require_relative "candle/tensor"
+require_relative "candle/device_utils"
+require_relative "candle/embedding_model_type"
+require_relative "candle/embedding_model"
+require_relative "candle/reranker"
+require_relative "candle/llm"
+require_relative "candle/build_info"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 1.0.0.pre.1
 platform: ruby
 authors:
 - Christopher Petersen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-18 00:00:00.000000000 Z
+date: 2025-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -27,7 +27,7 @@ dependencies:
         version: '0'
 description: huggingface/candle for Ruby
 email:
-- christopher.petersen@gmail.com
+- chris@petersen.io
 - 2xijok@gmail.com
 executables: []
 extensions:
@@ -41,6 +41,12 @@ files:
 - ext/candle/extconf.rb
 - ext/candle/src/lib.rs
 - lib/candle.rb
+- lib/candle/build_info.rb
+- lib/candle/device_utils.rb
+- lib/candle/embedding_model.rb
+- lib/candle/embedding_model_type.rb
+- lib/candle/llm.rb
+- lib/candle/reranker.rb
 - lib/candle/tensor.rb
 - lib/candle/version.rb
 homepage: https://github.com/assaydepot/red-candle