grx-tensor 0.1.0 → 0.2.1

data/lib/grx/utils.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GRX
+  module Utils
+    # ================================================================
+    # clip_grad_norm! — Clips gradients of parameter collection so their
+    # combined L2 norm does not exceed max_norm.
+    # Prevents exploding gradient problems during deep network training.
+    # ================================================================
+    def self.clip_grad_norm!(parameters, max_norm)
+      max_norm = max_norm.to_f
+      total_norm_sq = 0.0
+      parameters.each do |p|
+        next unless p.grad
+        total_norm_sq += p.grad.square.to_a.sum
+      end
+      total_norm = Math.sqrt(total_norm_sq)
+      clip_coef = max_norm / (total_norm + 1e-6)
+      if clip_coef < 1.0
+        parameters.each do |p|
+          next unless p.grad
+          p.grad = p.grad.scale(clip_coef)
+        end
+      end
+      total_norm
+    end
+
+    # ================================================================
+    # one_hot — Generates a 2D One-Hot encoded Tensor from class indices
+    # ================================================================
+    def self.one_hot(indices, num_classes: nil, requires_grad: false)
+      ids = indices.is_a?(Tensor) ? indices.to_a.map(&:to_i) : Array(indices).map(&:to_i)
+      c = num_classes || (ids.empty? ? 0 : ids.max + 1)
+      n = ids.size
+      matrix_data = Array.new(n * c, 0.0)
+      ids.each_with_index do |class_id, row|
+        raise IndexError, "Class index #{class_id} out of bounds [0, #{c})" if class_id < 0 || class_id >= c
+        matrix_data[row * c + class_id] = 1.0
+      end
+      Tensor.create(matrix_data, [n, c], requires_grad: requires_grad)
+    end
+  end
+end

data/lib/grx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GRX
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/grx.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # =====================================================================
-# GRX — Framework de tensores con autograd y núcleo C+SIMD
+# GRX — Tensor framework with autograd and C+SIMD compute core
 # require "grx"
 # =====================================================================
 
@@ -10,12 +10,15 @@ require_relative "grx/errors"
 require_relative "grx/c_api"
 require_relative "grx/storage"
 require_relative "grx/tensor"
+require_relative "grx/serialization"
 require_relative "grx/nn"
 require_relative "grx/optim"
 require_relative "grx/loss"
+require_relative "grx/data"
+require_relative "grx/utils"
 
 module GRX
-  # Acceso rápido
+  # Quick factory helpers
   def self.tensor(data, shape, requires_grad: false)
     Tensor.create(data, shape, requires_grad: requires_grad)
   end
@@ -34,16 +37,29 @@ module GRX
   end
 
   def self.randn(shape, requires_grad: false)
-    # Box-Muller desde Ruby (el C lo hace más rápido vía he_normal)
+    # Box-Muller from Ruby (C backend executes faster via he_normal)
     n = shape.reduce(1, :*)
     data = []
     (n / 2.0).ceil.times do
-      u1 = ::Kernel.rand; u1 = ::Kernel.rand while u1 < 1e-15
+      u1 = ::Kernel.rand
+      u1 = ::Kernel.rand while u1 < 1e-15
       u2 = ::Kernel.rand
       r  = Math.sqrt(-2.0 * Math.log(u1))
-      data << r * Math.cos(2 * Math::PI * u2)
-      data << r * Math.sin(2 * Math::PI * u2)
+      data << (r * Math.cos(2 * Math::PI * u2))
+      data << (r * Math.sin(2 * Math::PI * u2))
     end
     Tensor.create(data.first(n), shape, requires_grad: requires_grad)
   end
+
+  def self.c_loaded?
+    CAPI::LOADED
+  end
+
+  def self.mode
+    CAPI::LOADED ? :c : :ruby
+  end
+
+  def self.simd_mode
+    CAPI.simd_mode
+  end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: grx-tensor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
-- Angel Gabriel Garcia Razo
+- Razo
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -67,8 +67,9 @@ dependencies:
         version: '2.0'
 description: |
   GRX brings PyTorch-style tensor operations to Ruby. Every arithmetic op,
-  activation, and optimizer step runs through a native C library compiled
-  with AVX2+FMA SIMD. Ruby is the interface — C does the work.
+  activation, and optimizer step runs through a native C library with
+  dynamic multi-target SIMD dispatch (AVX2+FMA, SSE, and scalar fallback).
+  Ruby is the interface — C does the work.
 
   Features: autograd, SGD/Adam optimizers, Linear/Sequential/Dropout/BatchNorm
   layers, MSE/BCE/CrossEntropy loss functions, Xavier and He weight init.
@@ -81,7 +82,9 @@ extensions:
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- GUIA_PRINCIPIANTES.md
 - LICENSE.txt
+- README.es.md
 - README.md
 - ext/grx/extconf.rb
 - ext/grx/grx_core.c
@@ -91,12 +94,15 @@ files:
 - grx-tensor.gemspec
 - lib/grx.rb
 - lib/grx/c_api.rb
+- lib/grx/data.rb
 - lib/grx/errors.rb
 - lib/grx/loss.rb
 - lib/grx/nn.rb
 - lib/grx/optim.rb
+- lib/grx/serialization.rb
 - lib/grx/storage.rb
 - lib/grx/tensor.rb
+- lib/grx/utils.rb
 - lib/grx/version.rb
 homepage: https://github.com/Gabo-Razo/grx-tensor
 licenses:
@@ -107,36 +113,39 @@ metadata:
   bug_tracker_uri: https://github.com/Gabo-Razo/grx-tensor/issues
 post_install_message: |2+
 
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    GRX-Tensor 0.1.0 installed
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ============================================================
+    GRX-Tensor 0.2.1
+  ============================================================
 
-  Compile the C extension to enable AVX2+FMA SIMD:
+    [ENGLISH]
+    Thank you for choosing and using GRX-Tensor!
 
-    Linux / macOS:  make -C ext/unix
-    Windows:        make -C ext/windows -f Makefile.mingw
+    * Native C acceleration with dynamic SIMD dispatch
+      (AVX2+FMA, SSE, and portable scalar C) is built and
+      configured automatically.
+    * Windows Note: Native C acceleration is supported when
+      using RubyInstaller with DevKit (MSYS2 / MinGW-w64).
+      Standalone pre-compiled Windows binaries are currently
+      in active development.
+    * Documentation, guides, and tutorials:
+      https://github.com/Gabo-Razo/grx-tensor
 
-  Without it, GRX runs in pure Ruby fallback mode (slower but correct).
+    ----------------------------------------------------------
 
-  Quick start:
+    [ESPAÑOL]
+    Muchas gracias por elegir y utilizar GRX-Tensor!
 
-    require "grx"
+    * La aceleracion nativa en C con despacho dinamico SIMD
+      (AVX2+FMA, SSE y C escalar portable) se compila y
+      configura de forma totalmente automatica.
+    * Nota para Windows: La aceleracion nativa esta soportada
+      al utilizar RubyInstaller con DevKit (MSYS2 / MinGW-w64).
+      Los binarios pre-compilados independientes para Windows
+      se encuentran actualmente en desarrollo activo.
+    * Documentacion, guias y tutoriales:
+      https://github.com/Gabo-Razo/grx-tensor
 
-    a = GRX.tensor([1.0, 2.0, 3.0], [3], requires_grad: true)
-    b = GRX.tensor([4.0, 5.0, 6.0], [3], requires_grad: true)
-    c = a + b
-    c.backward
-    puts a.grad.to_a   # [1.0, 1.0, 1.0]
-
-    net = GRX::NN::Sequential.new(
-      GRX::NN::Linear.new(4, 16),
-      GRX::NN::ReLU.new,
-      GRX::NN::Linear.new(16, 1)
-    )
-    opt = GRX::Optim::Adam.new(net.parameters, lr: 0.001)
-
-  Docs: https://github.com/Gabo-Razo/grx-tensor
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ============================================================
 
 rdoc_options: []
 require_paths: