grx-tensor 0.1.0

data/lib/grx/optim.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module GRX
+  module Optim
+    # ================================================================
+    # SGD — Stochastic Gradient Descent (con momentum opcional)
+    # ================================================================
+    class SGD
+      def initialize(params, lr: 0.01, momentum: 0.0, weight_decay: 0.0)
+        @params       = params
+        @lr           = lr
+        @momentum     = momentum
+        @weight_decay = weight_decay
+        # Buffer de velocidad para momentum
+        @velocity = params.map { |p| Tensor.zeros_like(p) }
+      end
+
+      def step
+        @params.each_with_index do |param, i|
+          next unless param.grad
+
+          grad = param.grad
+
+          # L2 regularización (weight decay)
+          if @weight_decay > 0
+            grad = grad + param.scale(@weight_decay)
+          end
+
+          if @momentum > 0
+            # v = momentum*v + grad
+            @velocity[i] = @velocity[i].scale(@momentum) + grad
+            grad = @velocity[i]
+          end
+
+          if CAPI::LOADED
+            CAPI.grx_sgd_step(param.storage.ptr, grad.storage.ptr, @lr, param.numel)
+          else
+            # Fallback Ruby
+            param_data = param.to_a
+            grad_data  = grad.to_a
+            param_data.each_with_index { |v, j| param_data[j] = v - @lr * grad_data[j] }
+            param.storage.instance_variable_set(:@data, param_data)
+          end
+        end
+      end
+
+      def zero_grad
+        @params.each(&:zero_grad!)
+      end
+    end
+
+    # ================================================================
+    # Adam — Adaptive Moment Estimation (Kingma & Ba, 2015)
+    # El optimizador estándar para redes neuronales profundas.
+    # ================================================================
+    class Adam
+      def initialize(params, lr: 0.001, beta1: 0.9, beta2: 0.999,
+                     epsilon: 1e-8, weight_decay: 0.0)
+        @params       = params
+        @lr           = lr
+        @beta1        = beta1
+        @beta2        = beta2
+        @epsilon      = epsilon
+        @weight_decay = weight_decay
+        @t            = 0  # paso actual
+
+        # Momentos de primer y segundo orden (inicializados en cero)
+        @m = params.map { |p| Tensor.zeros_like(p) }
+        @v = params.map { |p| Tensor.zeros_like(p) }
+      end
+
+      def step
+        @t += 1
+        beta1t = @beta1 ** @t  # beta1^t para corrección de bias
+        beta2t = @beta2 ** @t
+
+        @params.each_with_index do |param, i|
+          next unless param.grad
+
+          grad = param.grad
+
+          if @weight_decay > 0
+            grad = grad + param.scale(@weight_decay)
+          end
+
+          if CAPI::LOADED
+            CAPI.grx_adam_step(
+              param.storage.ptr,
+              @m[i].storage.ptr,
+              @v[i].storage.ptr,
+              grad.storage.ptr,
+              @lr, @beta1, @beta2, @epsilon,
+              beta1t, beta2t,
+              param.numel
+            )
+          else
+            # Fallback Ruby puro
+            p_data = param.to_a
+            m_data = @m[i].to_a
+            v_data = @v[i].to_a
+            g_data = grad.to_a
+            p_data.each_with_index do |_, j|
+              m_data[j] = @beta1 * m_data[j] + (1 - @beta1) * g_data[j]
+              v_data[j] = @beta2 * v_data[j] + (1 - @beta2) * g_data[j] ** 2
+              mh = m_data[j] / (1 - beta1t)
+              vh = v_data[j] / (1 - beta2t)
+              p_data[j] -= @lr * mh / (Math.sqrt(vh) + @epsilon)
+            end
+            param.storage.instance_variable_set(:@data, p_data)
+            @m[i].storage.instance_variable_set(:@data, m_data)
+            @v[i].storage.instance_variable_set(:@data, v_data)
+          end
+        end
+      end
+
+      def zero_grad
+        @params.each(&:zero_grad!)
+      end
+    end
+  end
+end

data/lib/grx/storage.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module GRX
+  # ===================================================================
+  # Storage — Buffer de memoria nativa
+  #
+  # Cuando CAPI está cargado:
+  #   @ptr  → Fiddle::Pointer a un bloque de doubles alineado a 32 bytes
+  #           reservado con grx_alloc() (malloc alineado en C).
+  #           Los datos viven en el heap de C, NO en el GC de Ruby.
+  #
+  # Cuando CAPI NO está cargado (fallback):
+  #   @data → Array de Ruby normal (lento pero siempre correcto).
+  #
+  # La separación entre los dos modos es transparente para Tensor.
+  # ===================================================================
+  class Storage
+    attr_reader :size
+
+    # ptr expuesto para que CAPI pueda leerlo directamente
+    attr_reader :ptr
+
+    def initialize(array_plano)
+      @size = array_plano.size
+
+      if CAPI::LOADED
+        # --- MODO RÁPIDO: memoria C alineada ---
+        # grx_alloc devuelve un double* alineado a 32 bytes
+        @ptr = CAPI.grx_alloc(@size)
+        raise StorageError, "grx_alloc falló (OOM)" if @ptr.null?
+
+        # Empaquetamos el Array de Ruby en el buffer C como doubles (little-endian)
+        # Array#pack("d*") → String binaria de IEEE 754 doubles
+        bytes = array_plano.pack("d*")
+        @ptr[0, bytes.bytesize] = bytes
+
+        # Registramos un finalizer para liberar la memoria C cuando el objeto
+        # Ruby sea recolectado por el GC. Usamos ObjectSpace para evitar
+        # que el closure capture self (lo que impediría la recolección).
+        ptr_to_free = @ptr
+        ObjectSpace.define_finalizer(self, self.class.make_finalizer(ptr_to_free))
+      else
+        # --- MODO FALLBACK: Array de Ruby ---
+        @data = array_plano.map(&:to_f)
+        @ptr  = nil
+      end
+    end
+
+    def self.make_finalizer(ptr)
+      proc { CAPI.grx_free(ptr) }
+    end
+
+    # ------------------------------------------------------------------
+    # Lectura / escritura — usadas solo en modo fallback y por get()
+    # Las operaciones masivas (add, mul, etc.) van directo por @ptr en C.
+    # ------------------------------------------------------------------
+    def read(indice)
+      if CAPI::LOADED
+        # Leemos 8 bytes desde el offset correcto y los desempaquetamos como double
+        @ptr[indice * 8, 8].unpack1("d")
+      else
+        @data[indice]
+      end
+    end
+
+    def write(indice, valor)
+      if CAPI::LOADED
+        @ptr[indice * 8, 8] = [valor.to_f].pack("d")
+      else
+        @data[indice] = valor.to_f
+      end
+    end
+
+    # Vuelca todo el buffer a un Array de Ruby (para to_a, inspect, tests)
+    def to_ruby_array
+      if CAPI::LOADED
+        @ptr[0, @size * 8].unpack("d#{@size}")
+      else
+        @data.dup
+      end
+    end
+  end
+end