grx-tensor 0.1.0

data/ext/windows/Makefile.mingw

@@ -0,0 +1,50 @@
+# =============================================================
+# Makefile.mingw — Windows (MinGW-w64 / MSYS2)
+#
+# Compila grx_core.c DIRECTAMENTE en lib/grx/ (sin archivo intermedio).
+# El único .dll vive en lib/grx/grx_core.dll
+#
+# Requisitos:
+#   MSYS2: pacman -S mingw-w64-x86_64-gcc
+#
+# Uso:
+#   make -f Makefile.mingw          → compila
+#   make -f Makefile.mingw clean    → elimina el .dll de lib/grx/
+# =============================================================
+
+CC      = x86_64-w64-mingw32-gcc
+CFLAGS  = -O3 -march=native -ffast-math -funroll-loops \
+          -Wall -Wextra -std=c11
+LDFLAGS = -lm
+SRC_DIR = ../grx
+SRC     = $(SRC_DIR)/grx_core.c
+HEADER  = $(SRC_DIR)/grx_core.h
+
+# Destino final — directamente en lib/grx/
+OUT_DIR = ../../lib/grx
+LIB     = grx_core.dll
+TARGET  = $(OUT_DIR)/$(LIB)
+
+# __declspec(dllexport) ya está en el header vía GRX_API
+SHARED  = -shared -Wl,--out-implib,$(OUT_DIR)/libgrx_core.a
+
+AVX2_TEST := $(shell echo 'int main(){}' | $(CC) -mavx2 -mfma -x c - -o NUL 2>&1)
+ifeq ($(AVX2_TEST),)
+    CFLAGS += -mavx2 -mfma
+    $(info [GRX] AVX2 + FMA habilitados)
+else
+    $(info [GRX] Sin AVX2 — modo escalar)
+endif
+
+.PHONY: all clean
+
+all: $(TARGET)
+
+$(TARGET): $(SRC) $(HEADER)
+	mkdir -p $(OUT_DIR)
+	$(CC) $(CFLAGS) $(SHARED) $(SRC) -o $(TARGET) $(LDFLAGS)
+	@echo [GRX] Compilado → $(TARGET)
+
+clean:
+	rm -f "$(TARGET)" "$(OUT_DIR)/libgrx_core.a" 2>/dev/null || true
+	@echo [GRX] Limpiado: $(TARGET)

data/grx-tensor.gemspec

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "lib/grx/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "grx-tensor"
+  spec.version       = GRX::VERSION
+  spec.authors       = ["Angel Gabriel Garcia Razo"]
+  spec.email         = ["garabatoangelopolis@gmail.com"]
+
+  spec.summary       = "Tensor framework for Ruby with autograd and a C+SIMD compute core"
+  spec.description   = <<~DESC
+    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.
+
+    Features: autograd, SGD/Adam optimizers, Linear/Sequential/Dropout/BatchNorm
+    layers, MSE/BCE/CrossEntropy loss functions, Xavier and He weight init.
+    Cross-platform: .so on Linux, .dylib on macOS, .dll on Windows.
+  DESC
+
+  spec.homepage      = "https://github.com/Gabo-Razo/grx-tensor"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata = {
+    "homepage_uri"    => spec.homepage,
+    "changelog_uri"   => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    "bug_tracker_uri" => "#{spec.homepage}/issues"
+  }
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "ext/grx/**/*.{c,h,rb}",
+    "ext/unix/Makefile",
+    "ext/windows/Makefile.mingw",
+    "*.gemspec",
+    "README.md",
+    "LICENSE.txt",
+    "CHANGELOG.md"
+  ]
+
+  spec.require_paths = ["lib"]
+
+  # rake-compiler compiles ext/grx/extconf.rb on `gem install`
+  spec.extensions = ["ext/grx/extconf.rb"]
+
+  spec.post_install_message = <<~MSG
+
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      GRX-Tensor #{GRX::VERSION} installed
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+    Compile the C extension to enable AVX2+FMA SIMD:
+
+      Linux / macOS:  make -C ext/unix
+      Windows:        make -C ext/windows -f Makefile.mingw
+
+    Without it, GRX runs in pure Ruby fallback mode (slower but correct).
+
+    Quick start:
+
+      require "grx"
+
+      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
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  MSG
+
+  spec.add_development_dependency "rake",          "~> 13.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.2"
+  spec.add_development_dependency "minitest",      "~> 5.0"
+  spec.add_development_dependency "bundler",       "~> 2.0"
+end

data/lib/grx/c_api.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require "fiddle/import"
+
+module GRX
+  module CAPI
+    extend Fiddle::Importer
+
+    LIB_NAME = case RUBY_PLATFORM
+               when /mingw|mswin|windows/i then "grx_core.dll"
+               when /darwin/i              then "libgrx_core.dylib"
+               else                             "libgrx_core.so"
+               end
+
+    # rake-compiler siempre genera el archivo como "grx_core.so" / "grx_core.bundle" / "grx_core.dll"
+    # (sin el prefijo "lib"), y lo pone un nivel arriba de lib/grx/
+    RAKE_COMPILER_NAME = case RUBY_PLATFORM
+                         when /mingw|mswin|windows/i then "grx_core.dll"
+                         when /darwin/i              then "grx_core.bundle"
+                         else                             "grx_core.so"
+                         end
+
+    LIB_PATHS = [
+      # 1. make -C ext/unix  →  lib/grx/libgrx_core.so
+      File.expand_path(LIB_NAME, __dir__),
+      # 2. gem install (rake-compiler)  →  lib/grx_core.so  (un nivel arriba)
+      File.expand_path("../#{RAKE_COMPILER_NAME}", __dir__),
+      # 3. gem install en Ruby versioned path  →  lib/ruby/X.X.X/grx_core.so
+      File.expand_path("../../#{RAKE_COMPILER_NAME}", __dir__),
+      # 4. desarrollo local sin instalar
+      File.expand_path("../../ext/grx/#{LIB_NAME}", __dir__),
+    ].freeze
+
+    LOADED = begin
+      path = LIB_PATHS.find { |p| File.exist?(p) }
+      raise Fiddle::DLError, "No se encontró #{LIB_NAME} en #{LIB_PATHS.inspect}" unless path
+      dlload path
+      true
+    rescue Fiddle::DLError => e
+      warn "[GRX] Extensión C no disponible: #{e.message}\n" \
+           "      → Ejecuta: make -C ext/unix install\n" \
+           "      → Corriendo en modo Ruby puro (sin SIMD)."
+      false
+    end
+
+    if LOADED
+      # Memoria
+      extern "double* grx_alloc(size_t)"
+      extern "void    grx_free(double*)"
+
+      # Aritmética element-wise
+      extern "void grx_add       (double*, double*, double*, size_t)"
+      extern "void grx_sub       (double*, double*, double*, size_t)"
+      extern "void grx_mul       (double*, double*, double*, size_t)"
+      extern "void grx_div       (double*, double*, double*, size_t)"
+      extern "void grx_scale     (double*, double,  double*, size_t)"
+      extern "void grx_add_scalar(double*, double,  double*, size_t)"
+      extern "void grx_negate    (double*, double*, size_t)"
+
+      # Matemáticas element-wise
+      extern "void grx_abs   (double*, double*, size_t)"
+      extern "void grx_sqrt  (double*, double*, size_t)"
+      extern "void grx_square(double*, double*, size_t)"
+      extern "void grx_log   (double*, double*, size_t)"
+      extern "void grx_exp   (double*, double*, size_t)"
+      extern "void grx_pow   (double*, double,  double*, size_t)"
+      extern "void grx_clip  (double*, double, double, double*, size_t)"
+
+      # Reducciones
+      extern "double grx_sum (double*, size_t)"
+      extern "double grx_mean(double*, size_t)"
+      extern "double grx_max (double*, size_t)"
+      extern "double grx_min (double*, size_t)"
+
+      # Álgebra lineal
+      extern "double grx_dot    (double*, double*, size_t)"
+      extern "void   grx_matmul (double*, double*, double*, size_t, size_t, size_t)"
+
+      # Activaciones
+      extern "void grx_relu       (double*, double*, size_t)"
+      extern "void grx_leaky_relu (double*, double, double*, size_t)"
+      extern "void grx_tanh_act   (double*, double*, size_t)"
+      extern "void grx_sigmoid    (double*, double*, size_t)"
+      extern "void grx_softmax    (double*, double*, size_t)"
+
+      # Optimizadores
+      extern "void grx_sgd_step (double*, double*, double, size_t)"
+      extern "void grx_adam_step(double*, double*, double*, double*, double, double, double, double, double, double, size_t)"
+
+      # Inicialización de pesos
+      extern "void grx_init_xavier_uniform(double*, size_t, size_t, size_t)"
+      extern "void grx_init_he_normal     (double*, size_t, size_t)"
+    end
+  end
+end

data/lib/grx/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module GRX
+  class Error          < StandardError; end
+  class ShapeError     < Error; end
+  class DimensionError < Error; end
+  class StorageError   < Error; end
+end

data/lib/grx/loss.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GRX
+  module Loss
+    # ================================================================
+    # MSELoss — Mean Squared Error
+    # L = mean((pred - target)^2)   → retorna Float
+    # ================================================================
+    class MSELoss
+      def call(pred, target)
+        raise ShapeError, "Shapes incompatibles" if pred.shape != target.shape
+        (pred - target).square.mean
+      end
+    end
+
+    # ================================================================
+    # MAELoss — Mean Absolute Error
+    # L = mean(|pred - target|)
+    # ================================================================
+    class MAELoss
+      def call(pred, target)
+        raise ShapeError, "Shapes incompatibles" if pred.shape != target.shape
+        (pred - target).abs.mean
+      end
+    end
+
+    # ================================================================
+    # BCELoss — Binary Cross-Entropy
+    # L = -mean(t*log(p) + (1-t)*log(1-p))
+    # pred debe estar en (0,1) — aplica sigmoid antes si usas logits.
+    # ================================================================
+    class BCELoss
+      EPS = 1e-7
+
+      def call(pred, target)
+        raise ShapeError, "Shapes incompatibles" if pred.shape != target.shape
+        p_data = pred.to_a.map { |v| v < EPS ? EPS : (v > 1-EPS ? 1-EPS : v) }
+        t_data = target.to_a
+        total  = p_data.size.to_f
+        loss   = p_data.each_with_index.sum do |p, i|
+          t = t_data[i]
+          -(t * Math.log(p) + (1 - t) * Math.log(1 - p))
+        end
+        loss / total
+      end
+    end
+
+    # ================================================================
+    # CrossEntropyLoss — Softmax + NLL
+    # L = -mean(sum(target * log(softmax(logits))))
+    # ================================================================
+    class CrossEntropyLoss
+      EPS = 1e-7
+
+      def call(logits, target)
+        raise ShapeError, "Shapes incompatibles" if logits.shape != target.shape
+        probs  = logits.softmax.to_a.map { |v| v < EPS ? EPS : v }
+        t_data = target.to_a
+        loss   = probs.each_with_index.sum { |p, i| -t_data[i] * Math.log(p) }
+        loss / probs.size.to_f
+      end
+    end
+
+    # ================================================================
+    # HuberLoss — Smooth L1
+    # ================================================================
+    class HuberLoss
+      def initialize(delta: 1.0)
+        @delta = delta
+      end
+
+      def call(pred, target)
+        raise ShapeError, "Shapes incompatibles" if pred.shape != target.shape
+        d = @delta
+        diffs = (pred - target).abs.to_a
+        loss  = diffs.sum { |v| v <= d ? 0.5 * v * v : d * (v - 0.5 * d) }
+        loss / diffs.size.to_f
+      end
+    end
+  end
+end

data/lib/grx/nn.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module GRX
+  module NN
+    # ================================================================
+    # Module — clase base para todas las capas
+    # ================================================================
+    class Module
+      # Retorna todos los parámetros entrenables (para pasarlos al optimizador)
+      def parameters
+        instance_variables.flat_map do |var|
+          val = instance_variable_get(var)
+          case val
+          when Tensor    then val.requires_grad ? [val] : []
+          when Module    then val.parameters
+          when Array     then val.flat_map { |v|
+            case v
+            when Tensor then v.requires_grad ? [v] : []
+            when Module then v.parameters
+            else []
+            end
+          }
+          else []
+          end
+        end
+      end
+
+      def zero_grad
+        parameters.each(&:zero_grad!)
+      end
+
+      # Subclases implementan forward
+      def call(*args)
+        forward(*args)
+      end
+    end
+
+    # ================================================================
+    # Linear — Capa densa (fully connected)
+    # y = x @ W^T + b
+    # ================================================================
+    class Linear < Module
+      attr_reader :weight, :bias
+
+      def initialize(in_features, out_features, bias: true)
+        @in_features  = in_features
+        @out_features = out_features
+        @use_bias     = bias
+
+        # Pesos: Xavier uniform (bueno para tanh/sigmoid)
+        @weight = Tensor.xavier_uniform([out_features, in_features], requires_grad: true)
+
+        # Bias: ceros
+        @bias = bias ? Tensor.zeros([out_features], requires_grad: true) : nil
+      end
+
+      def forward(x)
+        # x: [batch, in_features]  →  out: [batch, out_features]
+        # out = x @ W^T
+        out = x.matmul(@weight.transpose)
+
+        if @use_bias
+          # Sumamos bias fila por fila.
+          # Repetimos @bias batch_size veces para crear un tensor [batch, out_features]
+          # que comparte el grafo con @bias original.
+          batch_size = x.shape[0]
+          # Tile del bias: concatenamos el mismo tensor bias_size veces
+          # usando operaciones que mantienen el grafo conectado
+          bias_tiled = _tile_bias(@bias, batch_size, @out_features)
+          out + bias_tiled
+        else
+          out
+        end
+      end
+
+      private
+
+      # Crea un tensor [batch, out_features] repitiendo @bias batch veces.
+      # Usa add_scalar(0) para crear un nuevo nodo conectado al bias en el grafo.
+      def _tile_bias(bias, batch_size, out_features)
+        # Construimos el tensor tileado sumando el bias a un tensor de ceros
+        # de la forma correcta. Esto conecta el grafo al bias original.
+        data = Array.new(batch_size) { bias.to_a }.flatten
+        tiled = GRX::Tensor.create(data, [batch_size, out_features])
+        # Conectamos al bias original via suma con ceros — mantiene el grafo
+        zero_row = GRX::Tensor.zeros([batch_size, out_features])
+        result = zero_row + tiled
+        # Registramos manualmente la conexión al bias para backprop
+        if bias.requires_grad
+          result.requires_grad = true
+          result._grafo_hijos << bias
+          b = bias
+          bf = result.backward_fn
+          result.backward_fn = ->(g) {
+            bf&.call(g)
+            # Acumulamos gradiente en bias: suma sobre el batch
+            grad_data = g.to_a.each_slice(out_features).reduce([0.0]*out_features) { |acc, row|
+              acc.zip(row).map { |a, r| a + r }
+            }
+            b.agregar_gradiente(GRX::Tensor.create(grad_data, [out_features]))
+          }
+        end
+        result
+      end
+
+      public
+
+      def to_s
+        "Linear(#{@in_features} → #{@out_features}, bias: #{@use_bias})"
+      end
+    end
+
+    # ================================================================
+    # Sequential — Contenedor de capas en secuencia
+    # ================================================================
+    class Sequential < Module
+      def initialize(*layers)
+        @layers = layers
+      end
+
+      def forward(x)
+        @layers.reduce(x) { |input, layer| layer.call(input) }
+      end
+
+      def parameters
+        @layers.flat_map(&:parameters)
+      end
+
+      def to_s
+        layers_str = @layers.each_with_index.map { |l, i| "  (#{i}): #{l}" }.join("\n")
+        "Sequential(\n#{layers_str}\n)"
+      end
+    end
+
+    # ================================================================
+    # Activaciones como capas (para usar en Sequential)
+    # ================================================================
+    class ReLU < Module
+      def forward(x) = x.relu
+      def to_s = "ReLU()"
+    end
+
+    class LeakyReLU < Module
+      def initialize(alpha = 0.01)
+        @alpha = alpha
+      end
+      def forward(x) = x.leaky_relu(@alpha)
+      def to_s = "LeakyReLU(alpha=#{@alpha})"
+    end
+
+    class Tanh < Module
+      def forward(x) = x.tanh
+      def to_s = "Tanh()"
+    end
+
+    class Sigmoid < Module
+      def forward(x) = x.sigmoid
+      def to_s = "Sigmoid()"
+    end
+
+    class Softmax < Module
+      def forward(x) = x.softmax
+      def to_s = "Softmax()"
+    end
+
+    # ================================================================
+    # Dropout — regularización durante entrenamiento
+    # ================================================================
+    class Dropout < Module
+      def initialize(p = 0.5)
+        @p       = p
+        @training = true
+      end
+
+      def train!;  @training = true;  self; end
+      def eval!;   @training = false; self; end
+
+      def forward(x)
+        return x unless @training && @p > 0
+
+        # Máscara binaria: 1 con prob (1-p), 0 con prob p
+        # Escalamos por 1/(1-p) para mantener la esperanza (inverted dropout)
+        scale = 1.0 / (1.0 - @p)
+        mask_data = x.to_a.map { rand > @p ? scale : 0.0 }
+        mask = Tensor.create(mask_data, x.shape)
+        x * mask
+      end
+
+      def to_s = "Dropout(p=#{@p})"
+    end
+
+    # ================================================================
+    # BatchNorm1d — Normalización por batch
+    # Estabiliza el entrenamiento de redes profundas.
+    # ================================================================
+    class BatchNorm1d < Module
+      def initialize(num_features, epsilon: 1e-5, momentum: 0.1)
+        @num_features = num_features
+        @epsilon      = epsilon
+        @momentum     = momentum
+        @training     = true
+
+        # Parámetros entrenables
+        @gamma = Tensor.ones([num_features],  requires_grad: true)
+        @beta  = Tensor.zeros([num_features], requires_grad: true)
+
+        # Estadísticas corrientes (no entrenables, para inferencia)
+        @running_mean = Tensor.zeros([num_features])
+        @running_var  = Tensor.ones([num_features])
+      end
+
+      def train!; @training = true;  self; end
+      def eval!;  @training = false; self; end
+
+      def forward(x)
+        # x: [batch, num_features]
+        batch_size = x.shape[0]
+
+        if @training
+          # Calculamos media y varianza del batch
+          batch_data = x.to_a
+          means = Array.new(@num_features) do |j|
+            batch_data.each_slice(@num_features).map { |row| row[j] }.sum / batch_size
+          end
+          vars = Array.new(@num_features) do |j|
+            col = batch_data.each_slice(@num_features).map { |row| row[j] }
+            col.sum { |v| (v - means[j]) ** 2 } / batch_size
+          end
+
+          # Actualizamos estadísticas corrientes
+          means.each_with_index do |m, j|
+            rm = @running_mean.to_a; rm[j] = (1 - @momentum) * rm[j] + @momentum * m
+            @running_mean = Tensor.create(rm, [@num_features])
+          end
+          vars.each_with_index do |v, j|
+            rv = @running_var.to_a; rv[j] = (1 - @momentum) * rv[j] + @momentum * v
+            @running_var = Tensor.create(rv, [@num_features])
+          end
+
+          mean_t = Tensor.create(means, [@num_features])
+          var_t  = Tensor.create(vars,  [@num_features])
+        else
+          mean_t = @running_mean
+          var_t  = @running_var
+        end
+
+        # Normalizamos: x_hat = (x - mean) / sqrt(var + eps)
+        # Luego escalamos: y = gamma * x_hat + beta
+        norm_data = x.to_a.each_slice(@num_features).flat_map do |row|
+          row.each_with_index.map do |v, j|
+            x_hat = (v - mean_t.to_a[j]) / Math.sqrt(var_t.to_a[j] + @epsilon)
+            @gamma.to_a[j] * x_hat + @beta.to_a[j]
+          end
+        end
+
+        Tensor.create(norm_data, x.shape)
+      end
+
+      def to_s = "BatchNorm1d(#{@num_features})"
+    end
+  end
+end