grx-tensor 0.1.0

data/lib/grx/tensor.rb

@@ -0,0 +1,623 @@
+# frozen_string_literal: true
+
+module GRX
+  class Tensor
+    attr_reader   :storage, :shape, :strides, :offset
+    attr_accessor :grad, :requires_grad, :backward_fn
+
+    def initialize(storage, shape, strides: nil, offset: 0, requires_grad: false)
+      @storage       = storage
+      @shape         = shape
+      @offset        = offset
+      @strides       = strides || _calc_strides(shape)
+      @requires_grad = requires_grad
+      @grad          = nil
+      @backward_fn   = nil
+      @_grafo_hijos  = []
+    end
+
+    # ----------------------------------------------------------------
+    # FACTORIES
+    # ----------------------------------------------------------------
+
+    def self.create(array_valores, shape, requires_grad: false)
+      new(Storage.new(array_valores), shape, requires_grad: requires_grad)
+    end
+
+    def self.zeros(shape, requires_grad: false)
+      create(Array.new(shape.reduce(1,:*), 0.0), shape, requires_grad: requires_grad)
+    end
+
+    def self.ones(shape, requires_grad: false)
+      create(Array.new(shape.reduce(1,:*), 1.0), shape, requires_grad: requires_grad)
+    end
+
+    def self.zeros_like(t, requires_grad: false)
+      zeros(t.shape, requires_grad: requires_grad)
+    end
+
+    def self.ones_like(t, requires_grad: false)
+      ones(t.shape, requires_grad: requires_grad)
+    end
+
+    # Inicialización Xavier uniform (para capas lineales con tanh/sigmoid)
+    def self.xavier_uniform(shape, requires_grad: false)
+      fan_in, fan_out = shape[-2] || 1, shape[-1] || 1
+      n = shape.reduce(1, :*)
+      s = _alloc_raw(n)
+      CAPI.grx_init_xavier_uniform(s.ptr, n, fan_in, fan_out) if CAPI::LOADED
+      new(s, shape, requires_grad: requires_grad)
+    end
+
+    # Inicialización He normal (para capas con ReLU)
+    def self.he_normal(shape, requires_grad: false)
+      # fan_in = número de entradas = último dim o penúltimo si es 2D
+      fan_in = shape.size >= 2 ? shape[-1] : shape[0]
+      n = shape.reduce(1, :*)
+      s = _alloc_raw(n)
+      CAPI.grx_init_he_normal(s.ptr, n, fan_in) if CAPI::LOADED
+      new(s, shape, requires_grad: requires_grad)
+    end
+
+    # ----------------------------------------------------------------
+    # OPERACIONES ARITMÉTICAS (con autograd)
+    # ----------------------------------------------------------------
+
+    def +(other)
+      case other
+      when Tensor
+        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        r = Tensor.new(_binop(:grx_add, other), @shape)
+        if requires_grad || other.requires_grad
+          r.requires_grad = true
+          r._grafo_hijos.push(self, other)
+          r.backward_fn = ->(g) {
+            agregar_gradiente(g)       if requires_grad
+            other.agregar_gradiente(g) if other.requires_grad
+          }
+        end
+        r
+      when Numeric
+        add_scalar(other.to_f)
+      else
+        raise TypeError, "No se puede sumar Tensor con #{other.class}"
+      end
+    end
+
+    def -(other)
+      case other
+      when Tensor
+        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        r = Tensor.new(_binop(:grx_sub, other), @shape)
+        if requires_grad || other.requires_grad
+          r.requires_grad = true
+          r._grafo_hijos.push(self, other)
+          r.backward_fn = ->(g) {
+            agregar_gradiente(g)              if requires_grad
+            other.agregar_gradiente(g.negate) if other.requires_grad
+          }
+        end
+        r
+      when Numeric
+        add_scalar(-other.to_f)
+      else
+        raise TypeError, "No se puede restar Tensor con #{other.class}"
+      end
+    end
+
+    def *(other)
+      case other
+      when Tensor
+        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        r = Tensor.new(_binop(:grx_mul, other), @shape)
+        if requires_grad || other.requires_grad
+          r.requires_grad = true
+          a, b = self, other
+          r._grafo_hijos.push(a, b)
+          r.backward_fn = ->(g) {
+            a.agregar_gradiente(g * b) if a.requires_grad
+            b.agregar_gradiente(g * a) if b.requires_grad
+          }
+        end
+        r
+      when Numeric
+        scale(other.to_f)
+      else
+        raise TypeError, "No se puede multiplicar Tensor con #{other.class}"
+      end
+    end
+
+    def /(other)
+      case other
+      when Tensor
+        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        r = Tensor.new(_binop(:grx_div, other), @shape)
+        if requires_grad || other.requires_grad
+          r.requires_grad = true
+          a, b = self, other
+          r._grafo_hijos.push(a, b)
+          r.backward_fn = ->(g) {
+            # d(a/b)/da = 1/b,  d(a/b)/db = -a/b^2
+            a.agregar_gradiente(g / b)                    if a.requires_grad
+            b.agregar_gradiente((g * a).negate / (b * b)) if b.requires_grad
+          }
+        end
+        r
+      when Numeric
+        scale(1.0 / other.to_f)
+      else
+        raise TypeError, "No se puede dividir Tensor con #{other.class}"
+      end
+    end
+
+    def -@
+      negate
+    end
+
+    # ----------------------------------------------------------------
+    # OPERACIONES ESCALARES
+    # ----------------------------------------------------------------
+
+    def scale(s)
+      _unary_c(:grx_scale, s) { |v| v * s }
+    end
+
+    def add_scalar(s)
+      _unary_c(:grx_add_scalar, s) { |v| v + s }
+    end
+
+    def negate
+      _unary_c(:grx_negate) { |v| -v }
+    end
+
+    # ----------------------------------------------------------------
+    # MATEMÁTICAS ELEMENT-WISE (con autograd)
+    # ----------------------------------------------------------------
+
+    def abs
+      r = _unary_c(:grx_abs) { |v| v.abs }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) {
+          # d|x|/dx = sign(x)
+          sign = Tensor.create(src.to_a.map { |v| v >= 0 ? 1.0 : -1.0 }, src.shape)
+          src.agregar_gradiente(g * sign)
+        }
+      end
+      r
+    end
+
+    def sqrt
+      r = _unary_c(:grx_sqrt) { |v| Math.sqrt(v) }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        res = r; src = self
+        r.backward_fn = ->(g) {
+          # d(sqrt(x))/dx = 1 / (2*sqrt(x))
+          src.agregar_gradiente(g / (res.scale(2.0)))
+        }
+      end
+      r
+    end
+
+    def square
+      r = _unary_c(:grx_square) { |v| v * v }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) { src.agregar_gradiente(g * src.scale(2.0)) }
+      end
+      r
+    end
+
+    def log
+      r = _unary_c(:grx_log) { |v| Math.log(v) }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) { src.agregar_gradiente(g / src) }
+      end
+      r
+    end
+
+    def exp
+      r = _unary_c(:grx_exp) { |v| Math.exp(v) }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        res = r; src = self
+        r.backward_fn = ->(g) { src.agregar_gradiente(g * res) }
+      end
+      r
+    end
+
+    def pow(e)
+      r = _unary_c(:grx_pow, e.to_f) { |v| v ** e }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) {
+          src.agregar_gradiente(g * src.pow(e - 1).scale(e.to_f))
+        }
+      end
+      r
+    end
+
+    def clip(lo, hi)
+      out = _alloc_storage(numel)
+      if CAPI::LOADED
+        CAPI.grx_clip(@storage.ptr, lo.to_f, hi.to_f, out.ptr, numel)
+      else
+        data = to_a.map { |v| v < lo ? lo : (v > hi ? hi : v) }
+        return Tensor.create(data, @shape)
+      end
+      Tensor.new(out, @shape)
+    end
+
+    # ----------------------------------------------------------------
+    # REDUCCIONES (retornan Float o Tensor escalar)
+    # ----------------------------------------------------------------
+
+    def sum
+      if CAPI::LOADED
+        CAPI.grx_sum(@storage.ptr, numel)
+      else
+        to_a.sum
+      end
+    end
+
+    def mean
+      if CAPI::LOADED
+        CAPI.grx_mean(@storage.ptr, numel)
+      else
+        to_a.sum.to_f / numel
+      end
+    end
+
+    def max
+      if CAPI::LOADED
+        CAPI.grx_max(@storage.ptr, numel)
+      else
+        to_a.max
+      end
+    end
+
+    def min
+      if CAPI::LOADED
+        CAPI.grx_min(@storage.ptr, numel)
+      else
+        to_a.min
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # ÁLGEBRA LINEAL
+    # ----------------------------------------------------------------
+
+    def dot(other)
+      raise ShapeError, "dot requiere mismo shape" if @shape != other.shape
+      if CAPI::LOADED
+        CAPI.grx_dot(@storage.ptr, other.storage.ptr, numel)
+      else
+        to_a.zip(other.to_a).sum { |a, b| a * b }
+      end
+    end
+
+    def matmul(other)
+      raise DimensionError, "matmul requiere tensores 2D" unless @shape.size == 2 && other.shape.size == 2
+      m, k = @shape; k2, n = other.shape
+      raise ShapeError, "Dimensiones incompatibles: #{@shape} × #{other.shape}" if k != k2
+      out = _alloc_storage(m * n)
+      if CAPI::LOADED
+        CAPI.grx_matmul(@storage.ptr, other.storage.ptr, out.ptr, m, k, n)
+      else
+        result = Array.new(m * n, 0.0)
+        m.times { |i| k.times { |kk| aik = @storage.read(i*k+kk)
+          n.times { |j| result[i*n+j] += aik * other.storage.read(kk*n+j) } } }
+        return Tensor.create(result, [m, n])
+      end
+      r = Tensor.new(out, [m, n])
+      if requires_grad || other.requires_grad
+        r.requires_grad = true
+        a, b = self, other
+        r._grafo_hijos.push(a, b)
+        r.backward_fn = ->(g) {
+          # dL/dA = dL/dC × B^T,  dL/dB = A^T × dL/dC
+          # Usamos _matmul_no_grad y _transpose_view para no crear nodos en el grafo
+          a.agregar_gradiente(g._matmul_no_grad(b._transpose_view)) if a.requires_grad
+          b.agregar_gradiente(a._transpose_view._matmul_no_grad(g)) if b.requires_grad
+        }
+      end
+      r
+    end
+
+    # ----------------------------------------------------------------
+    # ACTIVACIONES (con autograd)
+    # ----------------------------------------------------------------
+
+    def relu
+      r = _unary_c(:grx_relu) { |v| v > 0 ? v : 0.0 }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) {
+          mask = Tensor.create(src.to_a.map { |v| v > 0 ? 1.0 : 0.0 }, src.shape)
+          src.agregar_gradiente(g * mask)
+        }
+      end
+      r
+    end
+
+    def leaky_relu(alpha = 0.01)
+      r = _unary_c(:grx_leaky_relu, alpha.to_f) { |v| v > 0 ? v : alpha * v }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) {
+          mask = Tensor.create(src.to_a.map { |v| v > 0 ? 1.0 : alpha }, src.shape)
+          src.agregar_gradiente(g * mask)
+        }
+      end
+      r
+    end
+
+    def tanh
+      r = _unary_c(:grx_tanh_act) { |v| Math.tanh(v) }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        res = r; src = self
+        r.backward_fn = ->(g) {
+          # d(tanh)/dx = 1 - tanh(x)^2
+          src.agregar_gradiente(g * (Tensor.ones_like(res) - res.square))
+        }
+      end
+      r
+    end
+
+    def sigmoid
+      r = _unary_c(:grx_sigmoid) { |v| 1.0 / (1.0 + Math.exp(-v)) }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        res = r; src = self
+        r.backward_fn = ->(g) {
+          # d(sigmoid)/dx = sigmoid * (1 - sigmoid)
+          src.agregar_gradiente(g * res * (Tensor.ones_like(res) - res))
+        }
+      end
+      r
+    end
+
+    def softmax
+      r = _unary_c(:grx_softmax) do
+        vals = to_a; max_v = vals.max
+        exps = vals.map { |v| Math.exp(v - max_v) }; s = exps.sum
+        exps.map { |e| e / s }
+      end
+      r
+    end
+
+    # ----------------------------------------------------------------
+    # AUTOGRAD
+    # ----------------------------------------------------------------
+
+    def agregar_gradiente(g)
+      @grad = @grad.nil? ? g : @grad + g
+    end
+
+    def backward(grad_inicial = nil)
+      if grad_inicial.nil? && @grad.nil?
+        agregar_gradiente(Tensor.ones(@shape))
+      elsif !grad_inicial.nil?
+        agregar_gradiente(grad_inicial)
+      end
+
+      # Orden topológico via DFS iterativo post-order (evita stack overflow en grafos profundos)
+      orden     = []
+      visitados = {}
+      stack     = [[self, false]]
+
+      until stack.empty?
+        nodo, procesado = stack.pop
+        if procesado
+          orden << nodo unless visitados[nodo.object_id]
+          visitados[nodo.object_id] = true
+        else
+          next if visitados[nodo.object_id]
+          stack.push([nodo, true])
+          nodo._grafo_hijos.each { |h| stack.push([h, false]) unless visitados[h.object_id] }
+        end
+      end
+
+      # orden ya está en post-order → reverse = raíz primero, hojas al final
+      orden.reverse_each do |nodo|
+        next unless nodo.grad && nodo.backward_fn
+        nodo.backward_fn.call(nodo.grad)
+        nodo.backward_fn = nil
+      end
+    end
+
+    def zero_grad!
+      @grad = nil
+      @_grafo_hijos = []
+      @backward_fn = nil
+    end
+
+    def _grafo_hijos
+      @_grafo_hijos
+    end
+
+    # ----------------------------------------------------------------
+    # GEOMETRÍA (zero-copy)
+    # ----------------------------------------------------------------
+
+    def get(*coords)
+      @storage.read(_calc_flat_index(coords))
+    end
+
+    def reshape(nueva_forma)
+      raise ArgumentError, "Reshape incompatible" if numel != nueva_forma.reduce(1,:*)
+      Tensor.new(@storage, nueva_forma, offset: @offset, requires_grad: @requires_grad)
+    end
+
+    def transpose
+      raise DimensionError, "transpose solo soporta 2D" if @shape.size != 2
+      t = Tensor.new(@storage, [@shape[1], @shape[0]],
+                 strides: [@strides[1], @strides[0]],
+                 offset: @offset, requires_grad: @requires_grad)
+      if @requires_grad
+        t._grafo_hijos << self
+        src = self
+        t.backward_fn = ->(g) {
+          src.agregar_gradiente(g._transpose_view)
+        }
+      end
+      t
+    end
+
+    # Transpose sin autograd — solo para uso interno en backward
+    def _transpose_view
+      raise DimensionError, "transpose solo soporta 2D" if @shape.size != 2
+      Tensor.new(@storage, [@shape[1], @shape[0]],
+                 strides: [@strides[1], @strides[0]],
+                 offset: @offset, requires_grad: false)
+    end
+
+    # Matmul sin autograd — para uso interno en backward_fn
+    def _matmul_no_grad(other)
+      raise DimensionError, "matmul requiere tensores 2D" unless @shape.size == 2 && other.shape.size == 2
+      m, k = @shape; k2, n = other.shape
+      raise ShapeError, "Dimensiones incompatibles" if k != k2
+      out = _alloc_storage(m * n)
+      if CAPI::LOADED
+        CAPI.grx_matmul(@storage.ptr, other.storage.ptr, out.ptr, m, k, n)
+      else
+        result = Array.new(m * n, 0.0)
+        m.times { |i| k.times { |kk| aik = @storage.read(i*k+kk)
+          n.times { |j| result[i*n+j] += aik * other.storage.read(kk*n+j) } } }
+        return Tensor.new(Storage.new(result), [m, n])
+      end
+      Tensor.new(out, [m, n])
+    end
+
+    def flatten
+      reshape([numel])
+    end
+
+    # ----------------------------------------------------------------
+    # UTILIDADES
+    # ----------------------------------------------------------------
+
+    def numel
+      @shape.reduce(1, :*)
+    end
+
+    def to_a
+      # Si los strides son contiguos (tensor normal, reshape), leemos el buffer directo.
+      # Si no (transpose, vistas con strides custom), recorremos con strides.
+      if _contiguous?
+        @storage.to_ruby_array
+      else
+        _collect_elements(@shape, @strides, @offset)
+      end
+    end
+
+    private
+
+    # Un tensor es contiguo si sus strides coinciden con los strides row-major estándar
+    def _contiguous?
+      expected = _calc_strides(@shape)
+      @strides == expected && @offset == 0
+    end
+
+    def _collect_elements(shape, strides, offset)
+      if shape.size == 1
+        Array.new(shape[0]) { |i| @storage.read(offset + i * strides[0]) }
+      else
+        Array.new(shape[0]) { |i|
+          _collect_elements(shape[1..], strides[1..], offset + i * strides[0])
+        }.flatten
+      end
+    end
+
+    public
+
+    def item
+      raise "item() solo para tensores de 1 elemento" if numel != 1
+      to_a[0]
+    end
+
+    def to_s
+      "#<GRX::Tensor shape=#{@shape} data=#{to_a}>"
+    end
+    alias inspect to_s
+
+    # ----------------------------------------------------------------
+    # PRIVADO
+    # ----------------------------------------------------------------
+
+    private
+
+    def _alloc_storage(n)
+      self.class._alloc_raw(n)
+    end
+
+    def self._alloc_raw(n)
+      if CAPI::LOADED
+        ptr = CAPI.grx_alloc(n)
+        raise StorageError, "grx_alloc OOM" if ptr.null?
+        s = Storage.allocate
+        s.instance_variable_set(:@size, n)
+        s.instance_variable_set(:@ptr,  ptr)
+        ObjectSpace.define_finalizer(s, Storage.make_finalizer(ptr))
+        s
+      else
+        Storage.new(Array.new(n, 0.0))
+      end
+    end
+
+    # Operación binaria element-wise: llama a CAPI o fallback Ruby
+    def _binop(op, other)
+      out = _alloc_storage(numel)
+      if CAPI::LOADED
+        CAPI.public_send(op, @storage.ptr, other.storage.ptr, out.ptr, numel)
+      else
+        rb = { grx_add: :+, grx_sub: :-, grx_mul: :*, grx_div: :/ }[op]
+        data = (0...numel).map { |i|
+          @storage.read(@offset + i).public_send(rb, other.storage.read(other.offset + i))
+        }
+        return Storage.new(data)
+      end
+      out
+    end
+
+    # Operación unaria: llama a CAPI con args opcionales o fallback con bloque
+    # Si el bloque acepta un elemento (arity == 1) → map element-wise
+    # Si el bloque no acepta argumentos (arity == 0) → lo llama una vez (para softmax, etc.)
+    def _unary_c(op, *args, &fallback)
+      out = _alloc_storage(numel)
+      if CAPI::LOADED
+        CAPI.public_send(op, @storage.ptr, *args, out.ptr, numel)
+      else
+        vals = if fallback
+          fallback.arity == 0 ? fallback.call : to_a.map(&fallback)
+        else
+          to_a
+        end
+        return Tensor.create(vals, @shape)
+      end
+      Tensor.new(out, @shape)
+    end
+
+    def _calc_flat_index(coords)
+      idx = @offset
+      coords.each_with_index { |c, i| idx += c * @strides[i] }
+      idx
+    end
+
+    def _calc_strides(shape)
+      s = 1; saltos = []
+      shape.reverse_each { |d| saltos.unshift(s); s *= d }
+      saltos
+    end
+  end
+end

data/lib/grx/version.rb

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

data/lib/grx.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# =====================================================================
+# GRX — Framework de tensores con autograd y núcleo C+SIMD
+# require "grx"
+# =====================================================================
+
+require_relative "grx/version"
+require_relative "grx/errors"
+require_relative "grx/c_api"
+require_relative "grx/storage"
+require_relative "grx/tensor"
+require_relative "grx/nn"
+require_relative "grx/optim"
+require_relative "grx/loss"
+
+module GRX
+  # Acceso rápido
+  def self.tensor(data, shape, requires_grad: false)
+    Tensor.create(data, shape, requires_grad: requires_grad)
+  end
+
+  def self.zeros(shape, requires_grad: false)
+    Tensor.zeros(shape, requires_grad: requires_grad)
+  end
+
+  def self.ones(shape, requires_grad: false)
+    Tensor.ones(shape, requires_grad: requires_grad)
+  end
+
+  def self.rand(shape, requires_grad: false)
+    n = shape.reduce(1, :*)
+    Tensor.create(Array.new(n) { ::Kernel.rand }, shape, requires_grad: requires_grad)
+  end
+
+  def self.randn(shape, requires_grad: false)
+    # Box-Muller desde Ruby (el C lo hace más rápido vía he_normal)
+    n = shape.reduce(1, :*)
+    data = []
+    (n / 2.0).ceil.times do
+      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)
+    end
+    Tensor.create(data.first(n), shape, requires_grad: requires_grad)
+  end
+end