red-candle 1.1.2 → 1.2.1

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

@@ -6,7 +6,7 @@ use crate::ruby::{
     utils::{actual_dim, actual_index},
 };
 use crate::ruby::{DType, Device, Result};
-use ::candle_core::{DType as CoreDType, Tensor as CoreTensor};
+use ::candle_core::{DType as CoreDType, Tensor as CoreTensor, Device as CoreDevice, DeviceLocation};
 
 #[derive(Clone, Debug)]
 #[magnus::wrap(class = "Candle::Tensor", free_immediately, size)]
@@ -21,30 +21,108 @@ impl std::ops::Deref for Tensor {
     }
 }
 
+// Helper functions for tensor operations
+impl Tensor {
+    /// Check if device is Metal
+    fn is_metal_device(device: &CoreDevice) -> bool {
+        matches!(device.location(), DeviceLocation::Metal { .. })
+    }
+    
+    /// Convert tensor to target dtype, handling Metal limitations
+    fn safe_to_dtype(&self, target_dtype: CoreDType) -> Result<CoreTensor> {
+        if Self::is_metal_device(self.0.device()) && self.0.dtype() != target_dtype {
+            // Move to CPU first to avoid Metal conversion limitations
+            self.0
+                .to_device(&CoreDevice::Cpu)
+                .map_err(wrap_candle_err)?
+                .to_dtype(target_dtype)
+                .map_err(wrap_candle_err)
+        } else {
+            // Direct conversion for CPU or when dtype matches
+            self.0
+                .to_dtype(target_dtype)
+                .map_err(wrap_candle_err)
+        }
+    }
+}
+
 impl Tensor {
     pub fn new(array: magnus::RArray, dtype: Option<magnus::Symbol>, device: Option<Device>) -> Result<Self> {
         let dtype = dtype
             .map(|dtype| DType::from_rbobject(dtype))
             .unwrap_or(Ok(DType(CoreDType::F32)))?;
-        let device = device.unwrap_or(Device::Cpu).as_device()?;
-        // FIXME: Do not use `to_f64` here.
-        let array = array
-            .into_iter()
-            .map(|v| magnus::Float::try_convert(v).map(|v| v.to_f64()))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(Self(
-            CoreTensor::new(array.as_slice(), &device)
-                .map_err(wrap_candle_err)?
-                .to_dtype(dtype.0)
-                .map_err(wrap_candle_err)?,
-        ))
+        let device = device.unwrap_or(Device::best()).as_device()?;
+        
+        // Create tensor based on target dtype to avoid conversion issues on Metal
+        let tensor = match dtype.0 {
+            CoreDType::F32 => {
+                // Convert to f32 directly to avoid F64->F32 conversion on Metal
+                let array: Vec<f32> = array
+                    .into_iter()
+                    .map(|v| magnus::Float::try_convert(v).map(|v| v.to_f64() as f32))
+                    .collect::<Result<Vec<_>>>()?;
+                let len = array.len();
+                CoreTensor::from_vec(array, len, &device).map_err(wrap_candle_err)?
+            }
+            CoreDType::F64 => {
+                let array: Vec<f64> = array
+                    .into_iter()
+                    .map(|v| magnus::Float::try_convert(v).map(|v| v.to_f64()))
+                    .collect::<Result<Vec<_>>>()?;
+                let len = array.len();
+                CoreTensor::from_vec(array, len, &device).map_err(wrap_candle_err)?
+            }
+            CoreDType::I64 => {
+                // Convert to i64 directly to avoid conversion issues on Metal
+                let array: Vec<i64> = array
+                    .into_iter()
+                    .map(|v| {
+                        // Try integer first, then float
+                        if let Ok(i) = <i64>::try_convert(v) {
+                            Ok(i)
+                        } else if let Ok(f) = magnus::Float::try_convert(v) {
+                            Ok(f.to_f64() as i64)
+                        } else {
+                            Err(magnus::Error::new(
+                                magnus::exception::type_error(),
+                                "Cannot convert to i64"
+                            ))
+                        }
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                let len = array.len();
+                CoreTensor::from_vec(array, len, &device).map_err(wrap_candle_err)?
+            }
+            _ => {
+                // For other dtypes, create on CPU first if on Metal, then convert
+                let cpu_device = CoreDevice::Cpu;
+                let use_cpu = Self::is_metal_device(&device);
+                let target_device = if use_cpu { &cpu_device } else { &device };
+                
+                let array: Vec<f64> = array
+                    .into_iter()
+                    .map(|v| magnus::Float::try_convert(v).map(|v| v.to_f64()))
+                    .collect::<Result<Vec<_>>>()?;
+                let tensor = CoreTensor::new(array.as_slice(), target_device)
+                    .map_err(wrap_candle_err)?
+                    .to_dtype(dtype.0)
+                    .map_err(wrap_candle_err)?;
+                
+                // Move to target device if needed
+                if use_cpu {
+                    tensor.to_device(&device).map_err(wrap_candle_err)?
+                } else {
+                    tensor
+                }
+            }
+        };
+        
+        Ok(Self(tensor))
     }
 
     pub fn values(&self) -> Result<Vec<f64>> {
-        let values = self
-            .0
-            .to_dtype(CoreDType::F64)
-            .map_err(wrap_candle_err)?
+        let tensor = self.safe_to_dtype(CoreDType::F64)?;
+        let values = tensor
             .flatten_all()
             .map_err(wrap_candle_err)?
             .to_vec1()
@@ -92,11 +170,8 @@ impl Tensor {
             }
             _ => {
                 // For other dtypes, convert to F64 first
-                let val: f64 = self.0
-                    .to_dtype(CoreDType::F64)
-                    .map_err(wrap_candle_err)?
-                    .to_vec0()
-                    .map_err(wrap_candle_err)?;
+                let tensor = self.safe_to_dtype(CoreDType::F64)?;
+                let val: f64 = tensor.to_vec0().map_err(wrap_candle_err)?;
                 Ok(val)
             }
         }
@@ -541,7 +616,7 @@ impl Tensor {
     /// Creates a new tensor with random values.
     /// &RETURNS&: Tensor
     pub fn rand(shape: Vec<usize>, device: Option<Device>) -> Result<Self> {
-        let device = device.unwrap_or(Device::Cpu).as_device()?;
+        let device = device.unwrap_or(Device::best()).as_device()?;
         Ok(Self(
             CoreTensor::rand(0f32, 1f32, shape, &device).map_err(wrap_candle_err)?,
         ))
@@ -550,7 +625,7 @@ impl Tensor {
     /// Creates a new tensor with random values from a normal distribution.
     /// &RETURNS&: Tensor
     pub fn randn(shape: Vec<usize>, device: Option<Device>) -> Result<Self> {
-        let device = device.unwrap_or(Device::Cpu).as_device()?;
+        let device = device.unwrap_or(Device::best()).as_device()?;
         Ok(Self(
             CoreTensor::randn(0f32, 1f32, shape, &device).map_err(wrap_candle_err)?,
         ))
@@ -559,7 +634,7 @@ impl Tensor {
     /// Creates a new tensor filled with ones.
     /// &RETURNS&: Tensor
     pub fn ones(shape: Vec<usize>, device: Option<Device>) -> Result<Self> {
-        let device = device.unwrap_or(Device::Cpu).as_device()?;
+        let device = device.unwrap_or(Device::best()).as_device()?;
         Ok(Self(
             CoreTensor::ones(shape, CoreDType::F32, &device).map_err(wrap_candle_err)?,
         ))
@@ -567,7 +642,7 @@ impl Tensor {
     /// Creates a new tensor filled with zeros.
     /// &RETURNS&: Tensor
     pub fn zeros(shape: Vec<usize>, device: Option<Device>) -> Result<Self> {
-        let device = device.unwrap_or(Device::Cpu).as_device()?;
+        let device = device.unwrap_or(Device::best()).as_device()?;
         Ok(Self(
             CoreTensor::zeros(shape, CoreDType::F32, &device).map_err(wrap_candle_err)?,
         ))

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

@@ -105,8 +105,8 @@ impl Tokenizer {
         }
         
         let hash = RHash::new();
-        hash.aset("ids", RArray::from_vec(token_ids.into_iter().map(|id| id as i64).collect()))?;
-        hash.aset("tokens", RArray::from_vec(tokens))?;
+        hash.aset(magnus::Symbol::new("ids"), RArray::from_vec(token_ids.into_iter().map(|id| id as i64).collect()))?;
+        hash.aset(magnus::Symbol::new("tokens"), RArray::from_vec(tokens))?;
         
         Ok(hash)
     }
@@ -236,9 +236,65 @@ impl Tokenizer {
         Ok(hash)
     }
 
+    /// Get tokenizer options as a hash
+    pub fn options(&self) -> Result<RHash> {
+        let hash = RHash::new();
+        
+        // Get vocab size
+        hash.aset("vocab_size", self.vocab_size(Some(true)))?;
+        hash.aset("vocab_size_base", self.vocab_size(Some(false)))?;
+        
+        // Get special tokens info
+        let special_tokens = self.get_special_tokens()?;
+        hash.aset("special_tokens", special_tokens)?;
+        
+        // Get padding/truncation info if available
+        let inner_tokenizer = self.0.inner();
+        
+        // Check if padding is enabled
+        if let Some(_padding) = inner_tokenizer.get_padding() {
+            let padding_info = RHash::new();
+            padding_info.aset("enabled", true)?;
+            // Note: We can't easily extract all padding params from the tokenizers library
+            // but we can indicate it's enabled
+            hash.aset("padding", padding_info)?;
+        }
+        
+        // Check if truncation is enabled  
+        if let Some(truncation) = inner_tokenizer.get_truncation() {
+            let truncation_info = RHash::new();
+            truncation_info.aset("enabled", true)?;
+            truncation_info.aset("max_length", truncation.max_length)?;
+            hash.aset("truncation", truncation_info)?;
+        }
+        
+        Ok(hash)
+    }
+
     /// String representation
     pub fn inspect(&self) -> String {
-        format!("#<Candle::Tokenizer vocab_size={}>", self.vocab_size(Some(true)))
+        let vocab_size = self.vocab_size(Some(true));
+        let special_tokens = self.get_special_tokens()
+            .ok()
+            .map(|h| h.len())
+            .unwrap_or(0);
+        
+        let mut parts = vec![format!("#<Candle::Tokenizer vocab_size={}", vocab_size)];
+        
+        if special_tokens > 0 {
+            parts.push(format!("special_tokens={}", special_tokens));
+        }
+        
+        // Check for padding/truncation
+        let inner_tokenizer = self.0.inner();
+        if inner_tokenizer.get_padding().is_some() {
+            parts.push("padding=enabled".to_string());
+        }
+        if let Some(truncation) = inner_tokenizer.get_truncation() {
+            parts.push(format!("truncation={}", truncation.max_length));
+        }
+        
+        parts.join(" ") + ">"
     }
 }
 
@@ -262,6 +318,7 @@ pub fn init(rb_candle: RModule) -> Result<()> {
     tokenizer_class.define_method("with_padding", method!(Tokenizer::with_padding, 1))?;
     tokenizer_class.define_method("with_truncation", method!(Tokenizer::with_truncation, 1))?;
     tokenizer_class.define_method("get_special_tokens", method!(Tokenizer::get_special_tokens, 0))?;
+    tokenizer_class.define_method("options", method!(Tokenizer::options, 0))?;
     tokenizer_class.define_method("inspect", method!(Tokenizer::inspect, 0))?;
     tokenizer_class.define_method("to_s", method!(Tokenizer::inspect, 0))?;
     

data/lib/candle/device_utils.rb

@@ -1,22 +1,10 @@
 module Candle
   module DeviceUtils
+    # @deprecated Use {Candle::Device.best} instead
     # 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
-        # :nocov:
-        begin
-          # Try CUDA next (for NVIDIA GPU users)
-          Device.cuda
-        rescue
-          # Fall back to CPU
-          Device.cpu
-        end
-        # :nocov:
-      end
+      warn "[DEPRECATION] `DeviceUtils.best_device` is deprecated. Please use `Device.best` instead."
+      Device.best
     end
   end
 end

data/lib/candle/embedding_model.rb

@@ -9,7 +9,36 @@ module Candle
     # Default embedding model type
     DEFAULT_EMBEDDING_MODEL_TYPE = "jina_bert"
     
+    # Load a pre-trained embedding model from HuggingFace
+    # @param model_id [String] HuggingFace model ID (defaults to jinaai/jina-embeddings-v2-base-en)
+    # @param device [Candle::Device] The device to use for computation (defaults to best available)
+    # @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)
+    # @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)
+      # Auto-detect model type based on model_id if not provided
+      if model_type.nil?
+        model_type = case model_id.downcase
+        when /jina/
+          "jina_bert"
+        when /distilbert/
+          "distilbert"
+        when /minilm/
+          "minilm"
+        else
+          "standard_bert"
+        end
+      end
+      
+      # 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)
+    end
+    
     # Constructor for creating a new EmbeddingModel with optional parameters
+    # @deprecated Use {.from_pretrained} instead
     # @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
@@ -17,9 +46,10 @@ module Candle
     # @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,
+      device: Candle::Device.best,
       model_type: DEFAULT_EMBEDDING_MODEL_TYPE,
       embedding_size: nil)
+      $stderr.puts "[DEPRECATION] `EmbeddingModel.new` is deprecated. Please use `EmbeddingModel.from_pretrained` instead."
       _create(model_path, tokenizer_path, device, model_type, embedding_size)
     end
     # Returns the embedding for a string using the specified pooling method.
@@ -28,5 +58,18 @@ module Candle
     def embedding(str, pooling_method: "pooled_normalized")
       _embedding(str, pooling_method)
     end
+    
+    # Improved inspect method
+    def inspect
+      opts = options rescue {}
+      
+      parts = ["#<Candle::EmbeddingModel"]
+      parts << "model=#{opts["model_id"] || "unknown"}"
+      parts << "type=#{opts["model_type"]}" if opts["model_type"]
+      parts << "device=#{opts["device"] || "unknown"}"
+      parts << "size=#{opts["embedding_size"]}" if opts["embedding_size"]
+      
+      parts.join(" ") + ">"
+    end
   end
 end

data/lib/candle/llm.rb

@@ -189,6 +189,45 @@ module Candle
       prompt = apply_chat_template(messages)
       generate_stream(prompt, **options, &block)
     end
+    
+    # Inspect method for debugging and exploration
+    def inspect
+      opts = options rescue {}
+      
+      # Extract key information
+      model_type = opts["model_type"] || "Unknown"
+      device = opts["device"] || self.device.to_s rescue "unknown"
+      
+      # Build the inspect string
+      parts = ["#<Candle::LLM"]
+      
+      # Add base model or model_id
+      if opts["base_model"]
+        parts << "model=#{opts["base_model"]}"
+      elsif opts["model_id"]
+        parts << "model=#{opts["model_id"]}"
+      elsif respond_to?(:model_id)
+        parts << "model=#{model_id}"
+      end
+      
+      # Add GGUF file if present
+      if opts["gguf_file"]
+        parts << "gguf=#{opts["gguf_file"]}"
+      end
+      
+      # Add device
+      parts << "device=#{device}"
+      
+      # Add model type
+      parts << "type=#{model_type}"
+      
+      # Add architecture for GGUF models
+      if opts["architecture"]
+        parts << "arch=#{opts["architecture"]}"
+      end
+      
+      parts.join(" ") + ">"
+    end
 
     def generate(prompt, config: GenerationConfig.balanced, reset_cache: true)
       begin
@@ -206,7 +245,7 @@ module Candle
       end
     end
 
-    def self.from_pretrained(model_id, device: Candle::Device.cpu, gguf_file: nil, tokenizer: nil)
+    def self.from_pretrained(model_id, device: Candle::Device.best, gguf_file: nil, tokenizer: nil)
       model_str = if gguf_file
         "#{model_id}@#{gguf_file}"
       else
@@ -393,5 +432,28 @@ module Candle
       }
       new(defaults.merge(opts))
     end
+    
+    # Inspect method for debugging and exploration
+    def inspect
+      opts = options rescue {}
+      
+      parts = ["#<Candle::GenerationConfig"]
+      
+      # Add key configuration parameters
+      parts << "temp=#{opts["temperature"]}" if opts["temperature"]
+      parts << "max=#{opts["max_length"]}" if opts["max_length"]
+      parts << "top_p=#{opts["top_p"]}" if opts["top_p"]
+      parts << "top_k=#{opts["top_k"]}" if opts["top_k"]
+      parts << "seed=#{opts["seed"]}" if opts["seed"]
+      
+      # Add flags
+      flags = []
+      flags << "debug" if opts["debug_tokens"]
+      flags << "constraint" if opts["has_constraint"]
+      flags << "stop_on_match" if opts["stop_on_match"]
+      parts << "flags=[#{flags.join(",")}]" if flags.any?
+      
+      parts.join(" ") + ">"
+    end
   end
 end

data/lib/candle/ner.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# Pattern validation available but not forced
+# require_relative 'pattern_validator'  # Uncomment if needed
+
 module Candle
   # Named Entity Recognition (NER) for token classification
   #
@@ -30,10 +33,10 @@ module Candle
       # Load a pre-trained NER model from HuggingFace
       #
       # @param model_id [String] HuggingFace model ID (e.g., "dslim/bert-base-NER")
-      # @param device [Device, nil] Device to run on (defaults to best available)
+      # @param device [Device] Device to run on (defaults to best available)
       # @param tokenizer [String, nil] Tokenizer model ID to use (defaults to same as model_id)
       # @return [NER] NER instance
-      def from_pretrained(model_id, device: nil, tokenizer: nil)
+      def from_pretrained(model_id, device: Candle::Device.best, tokenizer: nil)
         new(model_id, device, tokenizer)
       end
       
@@ -112,7 +115,7 @@ module Candle
     # @return [Array<Hash>] Filtered entities of the specified type
     def extract_entity_type(text, entity_type, confidence_threshold: 0.9)
       entities = extract_entities(text, confidence_threshold: confidence_threshold)
-      entities.select { |e| e["label"] == entity_type.upcase }
+      entities.select { |e| e[:label] == entity_type.upcase }
     end
     
     # Analyze text and return both entities and token predictions
@@ -137,12 +140,12 @@ module Candle
       return text if entities.empty?
       
       # Sort by start position (reverse for easier insertion)
-      entities.sort_by! { |e| -e["start"] }
+      entities.sort_by! { |e| -e[:start] }
       
       result = text.dup
       entities.each do |entity|
-        label = "[#{entity['label']}:#{entity['confidence'].round(2)}]"
-        result.insert(entity["end"], label)
+        label = "[#{entity[:label]}:#{entity[:confidence].round(2)}]"
+        result.insert(entity[:end], label)
       end
       
       result
@@ -152,7 +155,19 @@ module Candle
     #
     # @return [String] Model description
     def inspect
-      "#<Candle::NER #{model_info}>"
+      opts = options rescue {}
+      
+      parts = ["#<Candle::NER"]
+      parts << "model=#{opts["model_id"] || "unknown"}"
+      parts << "device=#{opts["device"] || "unknown"}"
+      parts << "labels=#{opts["num_labels"]}" if opts["num_labels"]
+      
+      if opts["entity_types"] && !opts["entity_types"].empty?
+        types = opts["entity_types"].sort.join(",")
+        parts << "types=#{types}"
+      end
+      
+      parts.join(" ") + ">"
     end
     
     alias to_s inspect
@@ -177,6 +192,14 @@ module Candle
     def recognize(text, tokenizer = nil)
       entities = []
       
+      # Limit text length to prevent ReDoS on very long strings
+      # This is especially important for Ruby < 3.2
+      max_length = 1_000_000  # 1MB of text
+      if text.length > max_length
+        warn "PatternEntityRecognizer: Text truncated from #{text.length} to #{max_length} chars for safety"
+        text = text[0...max_length]
+      end
+      
       @patterns.each do |pattern|
         regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern)
         
@@ -186,12 +209,12 @@ module Candle
           match_end = $~.offset(0)[1]
           
           entities << {
-            "text" => match_text,
-            "label" => @entity_type,
-            "start" => match_start,
-            "end" => match_end,
-            "confidence" => 1.0,
-            "source" => "pattern"
+            text: match_text,
+            label: @entity_type,
+            start: match_start,
+            end: match_end,
+            confidence: 1.0,
+            source: "pattern"
           }
         end
       end
@@ -242,12 +265,12 @@ module Candle
           
           if word_boundary?(prev_char) && word_boundary?(next_char)
             entities << {
-              "text" => text[idx, pattern.length],
-              "label" => @entity_type,
-              "start" => idx,
-              "end" => idx + pattern.length,
-              "confidence" => 1.0,
-              "source" => "gazetteer"
+              text: text[idx, pattern.length],
+              label: @entity_type,
+              start: idx,
+              end: idx + pattern.length,
+              confidence: 1.0,
+              source: "gazetteer"
             }
           end
           
@@ -327,19 +350,19 @@ module Candle
     
     def merge_entities(entities)
       # Sort by start position and confidence (descending)
-      sorted = entities.sort_by { |e| [e["start"], -e["confidence"]] }
+      sorted = entities.sort_by { |e| [e[:start], -e[:confidence]] }
       
       merged = []
       sorted.each do |entity|
         # Check if entity overlaps with any already merged
         overlaps = merged.any? do |existing|
-          entity["start"] < existing["end"] && entity["end"] > existing["start"]
+          entity[:start] < existing[:end] && entity[:end] > existing[:start]
         end
         
         merged << entity unless overlaps
       end
       
-      merged.sort_by { |e| e["start"] }
+      merged.sort_by { |e| e[:start] }
     end
   end
 end

data/lib/candle/reranker.rb

@@ -3,10 +3,20 @@ module Candle
     # Default model path for cross-encoder/ms-marco-MiniLM-L-12-v2
     DEFAULT_MODEL_PATH = "cross-encoder/ms-marco-MiniLM-L-12-v2"
     
+    # Load a pre-trained reranker model from HuggingFace
+    # @param model_id [String] HuggingFace model ID (defaults to cross-encoder/ms-marco-MiniLM-L-12-v2)
+    # @param device [Candle::Device] The device to use for computation (defaults to best available)
+    # @return [Reranker] A new Reranker instance
+    def self.from_pretrained(model_id = DEFAULT_MODEL_PATH, device: Candle::Device.best)
+      _create(model_id, device)
+    end
+    
     # Constructor for creating a new Reranker with optional parameters
+    # @deprecated Use {.from_pretrained} instead
     # @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)
+    def self.new(model_path: DEFAULT_MODEL_PATH, device: Candle::Device.best)
+      $stderr.puts "[DEPRECATION] `Reranker.new` is deprecated. Please use `Reranker.from_pretrained` instead."
       _create(model_path, device)
     end
 
@@ -20,5 +30,14 @@ module Candle
         { doc_id: doc_id, score: score, text: doc }
       }
     end
+    
+    # Improved inspect method
+    def inspect
+      opts = options rescue {}
+      parts = ["#<Candle::Reranker"]
+      parts << "model=#{opts["model_id"] || "unknown"}"
+      parts << "device=#{opts["device"] || "unknown"}"
+      parts.join(" ") + ">"
+    end
   end
 end

data/lib/candle/tensor.rb

@@ -51,6 +51,21 @@ module Candle
       to_f.to_i
     end
     
+    # Improved inspect method showing shape, dtype, and device
+    def inspect
+      shape_str = shape.join("x")
+      
+      parts = ["#<Candle::Tensor"]
+      parts << "shape=#{shape_str}"
+      parts << "dtype=#{dtype}"
+      parts << "device=#{device}"
+      
+      # Add element count for clarity
+      parts << "elements=#{elem_count}"
+      
+      parts.join(" ") + ">"
+    end
+    
     
     # Override class methods to support keyword arguments for device
     class << self

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.1.2"
+  VERSION = "1.2.1"
 end
 # :nocov: