grnexus 1.0.2

data/lib/grnexus_activations.rb

@@ -0,0 +1,462 @@
+require 'ffi'
+require 'rbconfig'
+
+module GRNEXUSActivations
+  extend FFI::Library
+
+  # Detectar sistema operativo
+  def self.detect_library
+    script_dir = File.dirname(File.expand_path(__FILE__))
+    os = RbConfig::CONFIG['host_os']
+
+    case os
+    when /mswin|mingw|cygwin/
+      File.join(script_dir,  '..', 'exports', 'Windows', 'activations.dll')
+    when /darwin/
+      File.join(script_dir,  '..', 'exports', 'Mac', 'activations.dylib')
+    when /linux/
+      File.join(script_dir,  '..', 'exports', 'Linux', 'activations.so')
+    else
+      raise "Sistema operativo no soportado: #{os}"
+    end
+  end
+
+  # Cargar biblioteca
+  ffi_lib detect_library
+
+  # Definir estructura GRNexusData
+  class GRNexusData < FFI::Struct
+    layout :data,   :pointer,
+           :type,   :int,
+           :size,   :size_t,
+           :stride, :size_t,
+           :dims,   [:size_t, 3]
+  end
+
+  # Definir funciones disponibles
+  FUNCTIONS = {
+    'Linear' => [:Linear, [:pointer, :pointer, :bool], :int],
+    'Step' => [:Step, [:pointer, :pointer, :bool], :int],
+    'Sigmoid' => [:Sigmoid, [:pointer, :pointer, :bool], :int],
+    'Tanh' => [:Tanh, [:pointer, :pointer, :bool], :int],
+    'ReLU' => [:ReLU, [:pointer, :pointer, :bool], :int],
+    'LeakyReLU' => [:LeakyReLU, [:pointer, :pointer, :bool, :double], :int],
+    'PReLU' => [:PReLU, [:pointer, :pointer, :bool, :pointer], :int],
+    'ELU' => [:ELU, [:pointer, :pointer, :bool, :double], :int],
+    'SELU' => [:SELU, [:pointer, :pointer, :bool], :int],
+    'Softplus' => [:Softplus, [:pointer, :pointer, :bool], :int],
+    'Softsign' => [:Softsign, [:pointer, :pointer, :bool], :int],
+    'HardSigmoid' => [:HardSigmoid, [:pointer, :pointer, :bool], :int],
+    'HardTanh' => [:HardTanh, [:pointer, :pointer, :bool], :int],
+    'ThresholdedReLU' => [:ThresholdedReLU, [:pointer, :pointer, :bool, :double], :int],
+    'GELU' => [:GELU, [:pointer, :pointer, :bool], :int],
+    'Swish' => [:Swish, [:pointer, :pointer, :bool], :int],
+    'Mish' => [:Mish, [:pointer, :pointer, :bool], :int],
+    'LiSHT' => [:LiSHT, [:pointer, :pointer, :bool], :int],
+    'ReLUSquared' => [:ReLUSquared, [:pointer, :pointer, :bool], :int],
+    'SquaredReLU' => [:SquaredReLU, [:pointer, :pointer, :bool], :int],
+    'CELU' => [:CELU, [:pointer, :pointer, :bool, :double], :int],
+    'HardShrink' => [:HardShrink, [:pointer, :pointer, :bool, :double], :int],
+    'SoftShrink' => [:SoftShrink, [:pointer, :pointer, :bool, :double], :int],
+    'TanhShrink' => [:TanhShrink, [:pointer, :pointer, :bool], :int],
+    'ReLU6' => [:ReLU6, [:pointer, :pointer, :bool], :int],
+    'HardSwish' => [:HardSwish, [:pointer, :pointer, :bool], :int],
+    'SiLU' => [:SiLU, [:pointer, :pointer, :bool], :int],
+    'GLU' => [:GLU, [:pointer, :pointer, :bool, :size_t], :int],
+    'BReLU' => [:BReLU, [:pointer, :pointer, :bool], :int],
+    'ARelu' => [:ARelu, [:pointer, :pointer, :bool, :double, :double], :int],
+    'FReLU' => [:FReLU, [:pointer, :pointer, :bool, :double], :int],
+    'Snake' => [:Snake, [:pointer, :pointer, :bool, :double], :int],
+    'SnakeBeta' => [:SnakeBeta, [:pointer, :pointer, :bool, :double, :double], :int],
+    'ISRU' => [:ISRU, [:pointer, :pointer, :bool, :double], :int],
+    'ISRLU' => [:ISRLU, [:pointer, :pointer, :bool, :double], :int],
+    'Maxout' => [:Maxout, [:pointer, :pointer, :bool, :size_t], :int],
+    'Minout' => [:Minout, [:pointer, :pointer, :bool, :size_t], :int],
+  }
+
+  # Adjuntar funciones al módulo
+  FUNCTIONS.each do |name, (func, args, ret)|
+    attach_function func, args, ret
+  end
+
+  # Función para crear GRNexusData
+  def self.create_grnexus_data(array_or_scalar)
+    # Convertir a array si es un número
+    values = array_or_scalar.is_a?(Array) ? array_or_scalar : [array_or_scalar]
+    size = values.length
+    
+    # Crear un buffer con los datos
+    buffer = FFI::MemoryPointer.new(:double, size)
+    buffer.write_array_of_double(values)
+    
+    data = FFI::MemoryPointer.new(GRNexusData.size)
+    struct_instance = GRNexusData.new(data)
+    struct_instance[:data] = buffer
+    struct_instance[:type] = size == 1 ? 0 : 1  # SCALAR=0, ARRAY=1
+    struct_instance[:size] = size
+    struct_instance[:stride] = 1
+    struct_instance[:dims][0] = size
+    struct_instance[:dims][1] = 0
+    struct_instance[:dims][2] = 0
+    
+    [data, buffer]
+  end
+
+  # Función para crear GRNexusData para salida
+  def self.create_output_grnexus_data(size)
+    # Crear un buffer vacío modificable
+    buffer = FFI::MemoryPointer.new(:double, size)
+    
+    data = FFI::MemoryPointer.new(GRNexusData.size)
+    struct_instance = GRNexusData.new(data)
+    struct_instance[:data] = buffer
+    struct_instance[:type] = 1  # ARRAY
+    struct_instance[:size] = size
+    struct_instance[:stride] = 1
+    struct_instance[:dims][0] = size
+    struct_instance[:dims][1] = 0
+    struct_instance[:dims][2] = 0
+    
+    [data, buffer]
+  end
+
+  # Función para leer datos de GRNexusData
+  def self.read_grnexus_data(original_ptr, size)
+    original_ptr.read_array_of_double(size)
+  end
+
+  class ActivationFunction
+    def call(x, derivative: false)
+      raise NotImplementedError, "Debes implementar la función de activación"
+    end
+  end
+
+  class BaseActivation < ActivationFunction
+    protected
+
+    def execute_activation(func_name, input_values, derivative: false, **kwargs)
+      input_data, input_buffer = GRNEXUSActivations.create_grnexus_data(input_values)
+      output_size = input_values.is_a?(Array) ? input_values.length : 1
+      output_data, output_buffer = GRNEXUSActivations.create_output_grnexus_data(output_size)
+
+      args = [input_data, output_data, derivative]
+
+      # Agregar argumentos específicos según la función
+      case func_name
+      when :LeakyReLU, :ELU, :ThresholdedReLU, :CELU, :HardShrink, :SoftShrink, :FReLU, :Snake, :ISRU, :ISRLU
+        args << kwargs[:param1] || 0.01
+      when :PReLU
+        alpha_ptr = FFI::MemoryPointer.new(:double)
+        alpha_ptr.write_double(kwargs[:param1] || 0.01)
+        args << alpha_ptr
+      when :ARelu
+        args << (kwargs[:param1] || 0.01) << (kwargs[:param2] || 1.0)
+      when :SnakeBeta
+        args << (kwargs[:param1] || 1.0) << (kwargs[:param2] || 1.0)
+      when :GLU
+        args << (kwargs[:dim] || 0)
+      when :Maxout, :Minout
+        args << (kwargs[:num_pieces] || 2)
+      end
+
+      # Llamar la función en el módulo GRNEXUSActivations, no en la instancia
+      result = GRNEXUSActivations.send(func_name, *args)
+
+      if result == 0
+        output_buffer.read_array_of_double(output_size)
+      else
+        raise "Función #{func_name} falló con código: #{result}"
+      end
+    ensure
+      # FFI::MemoryPointer se libera automáticamente con GC
+    end
+  end
+
+  class Linear < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Linear, x, derivative: derivative)
+    end
+  end
+
+  class Step < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Step, x, derivative: derivative)
+    end
+  end
+
+  class Sigmoid < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Sigmoid, x, derivative: derivative)
+    end
+  end
+
+  class Tanh < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Tanh, x, derivative: derivative)
+    end
+  end
+
+  class ReLU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:ReLU, x, derivative: derivative)
+    end
+  end
+
+  class LeakyReLU < BaseActivation
+    def initialize(alpha: 0.01)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:LeakyReLU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class PReLU < BaseActivation
+    def initialize(alpha: 0.01)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:PReLU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ELU < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:ELU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class SELU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:SELU, x, derivative: derivative)
+    end
+  end
+
+  class Softplus < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Softplus, x, derivative: derivative)
+    end
+  end
+
+  class Softsign < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Softsign, x, derivative: derivative)
+    end
+  end
+
+  class HardSigmoid < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:HardSigmoid, x, derivative: derivative)
+    end
+  end
+
+  class HardTanh < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:HardTanh, x, derivative: derivative)
+    end
+  end
+
+  class ThresholdedReLU < BaseActivation
+    def initialize(theta: 1.0)
+      @theta = theta
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:ThresholdedReLU, x, derivative: derivative, param1: @theta)
+    end
+  end
+
+  class GELU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:GELU, x, derivative: derivative)
+    end
+  end
+
+  class Swish < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Swish, x, derivative: derivative)
+    end
+  end
+
+  class Mish < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:Mish, x, derivative: derivative)
+    end
+  end
+
+  class LiSHT < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:LiSHT, x, derivative: derivative)
+    end
+  end
+
+  class ReLUSquared < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:ReLUSquared, x, derivative: derivative)
+    end
+  end
+
+  class SquaredReLU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:SquaredReLU, x, derivative: derivative)
+    end
+  end
+
+  class CELU < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:CELU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class HardShrink < BaseActivation
+    def initialize(lambda: 0.5)
+      @lambda = lambda
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:HardShrink, x, derivative: derivative, param1: @lambda)
+    end
+  end
+
+  class SoftShrink < BaseActivation
+    def initialize(lambda: 0.5)
+      @lambda = lambda
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:SoftShrink, x, derivative: derivative, param1: @lambda)
+    end
+  end
+
+  class TanhShrink < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:TanhShrink, x, derivative: derivative)
+    end
+  end
+
+  class ReLU6 < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:ReLU6, x, derivative: derivative)
+    end
+  end
+
+  class HardSwish < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:HardSwish, x, derivative: derivative)
+    end
+  end
+
+  class SiLU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:SiLU, x, derivative: derivative)
+    end
+  end
+
+  class GLU < BaseActivation
+    def initialize(dim: 1)
+      @dim = dim
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:GLU, x, derivative: derivative, dim: @dim)
+    end
+  end
+
+  class BReLU < BaseActivation
+    def call(x, derivative: false)
+      execute_activation(:BReLU, x, derivative: derivative)
+    end
+  end
+
+  class ARelu < BaseActivation
+    def initialize(alpha: 0.0, beta: 1.0)
+      @alpha = alpha
+      @beta = beta
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:ARelu, x, derivative: derivative, param1: @alpha, param2: @beta)
+    end
+  end
+
+  class FReLU < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:FReLU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class Snake < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:Snake, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class SnakeBeta < BaseActivation
+    def initialize(alpha: 1.0, beta: 1.0)
+      @alpha = alpha
+      @beta = beta
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:SnakeBeta, x, derivative: derivative, param1: @alpha, param2: @beta)
+    end
+  end
+
+  class ISRU < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:ISRU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ISRLU < BaseActivation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:ISRLU, x, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class Maxout < BaseActivation
+    def initialize(num_pieces: 2)
+      @num_pieces = num_pieces
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:Maxout, x, derivative: derivative, num_pieces: @num_pieces)
+    end
+  end
+
+  class Minout < BaseActivation
+    def initialize(num_pieces: 2)
+      @num_pieces = num_pieces
+    end
+
+    def call(x, derivative: false)
+      execute_activation(:Minout, x, derivative: derivative, num_pieces: @num_pieces)
+    end
+  end
+end

data/lib/grnexus_callbacks.rb

@@ -0,0 +1,249 @@
+# Callbacks system for training
+module GRNEXUSCallbacks
+  class Callback
+    def on_train_begin(logs = {})
+    end
+    
+    def on_train_end(logs = {})
+    end
+    
+    def on_epoch_begin(epoch, logs = {})
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+    end
+    
+    def on_batch_begin(batch, logs = {})
+    end
+    
+    def on_batch_end(batch, logs = {})
+    end
+  end
+  
+  class EarlyStopping < Callback
+    attr_reader :stopped_epoch
+    
+    def initialize(monitor: 'loss', patience: 10, min_delta: 0.0001, mode: 'min', verbose: true)
+      @monitor = monitor
+      @patience = patience
+      @min_delta = min_delta
+      @mode = mode
+      @verbose = verbose
+      @wait = 0
+      @stopped_epoch = 0
+      @best = mode == 'min' ? Float::INFINITY : -Float::INFINITY
+      @stop_training = false
+    end
+    
+    def on_train_begin(logs = {})
+      @wait = 0
+      @stopped_epoch = 0
+      @best = @mode == 'min' ? Float::INFINITY : -Float::INFINITY
+      @stop_training = false
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+      current = logs[@monitor.to_sym]
+      return unless current
+      
+      if monitor_improved?(current)
+        @best = current
+        @wait = 0
+      else
+        @wait += 1
+        if @wait >= @patience
+          @stopped_epoch = epoch
+          @stop_training = true
+          puts "Early stopping triggered at epoch #{epoch + 1}" if @verbose
+        end
+      end
+    end
+    
+    def stop_training?
+      @stop_training
+    end
+    
+    private
+    
+    def monitor_improved?(current)
+      if @mode == 'min'
+        current < @best - @min_delta
+      else
+        current > @best + @min_delta
+      end
+    end
+  end
+  
+  class ModelCheckpoint < Callback
+    def initialize(filepath:, monitor: 'loss', mode: 'min', save_best_only: true, verbose: true)
+      @filepath = filepath
+      @monitor = monitor
+      @mode = mode
+      @save_best_only = save_best_only
+      @verbose = verbose
+      @best = mode == 'min' ? Float::INFINITY : -Float::INFINITY
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+      current = logs[@monitor.to_sym]
+      return unless current
+      
+      should_save = !@save_best_only || monitor_improved?(current)
+      
+      if should_save
+        @best = current if monitor_improved?(current)
+        filepath = @filepath.gsub('{epoch}', (epoch + 1).to_s)
+        logs[:model].save(filepath)
+        puts "Epoch #{epoch + 1}: #{@monitor} improved to #{current.round(6)}, saving model to #{filepath}" if @verbose
+      end
+    end
+    
+    private
+    
+    def monitor_improved?(current)
+      if @mode == 'min'
+        current < @best
+      else
+        current > @best
+      end
+    end
+  end
+  
+  class LearningRateScheduler < Callback
+    def initialize(schedule:, verbose: true)
+      @schedule = schedule
+      @verbose = verbose
+    end
+    
+    def on_epoch_begin(epoch, logs = {})
+      new_lr = if @schedule.is_a?(Proc)
+        @schedule.call(epoch)
+      elsif @schedule.is_a?(Hash)
+        @schedule[epoch] || logs[:model].learning_rate
+      else
+        logs[:model].learning_rate
+      end
+      
+      logs[:model].learning_rate = new_lr
+      puts "Epoch #{epoch + 1}: Learning rate set to #{new_lr}" if @verbose
+    end
+  end
+  
+  class ReduceLROnPlateau < Callback
+    def initialize(monitor: 'loss', factor: 0.5, patience: 5, min_delta: 0.0001, 
+                   min_lr: 1e-7, mode: 'min', verbose: true)
+      @monitor = monitor
+      @factor = factor
+      @patience = patience
+      @min_delta = min_delta
+      @min_lr = min_lr
+      @mode = mode
+      @verbose = verbose
+      @wait = 0
+      @best = mode == 'min' ? Float::INFINITY : -Float::INFINITY
+    end
+    
+    def on_train_begin(logs = {})
+      @wait = 0
+      @best = @mode == 'min' ? Float::INFINITY : -Float::INFINITY
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+      current = logs[@monitor.to_sym]
+      return unless current
+      
+      if monitor_improved?(current)
+        @best = current
+        @wait = 0
+      else
+        @wait += 1
+        if @wait >= @patience
+          old_lr = logs[:model].learning_rate
+          new_lr = [old_lr * @factor, @min_lr].max
+          
+          if new_lr < old_lr
+            logs[:model].learning_rate = new_lr
+            puts "Epoch #{epoch + 1}: Reducing learning rate from #{old_lr} to #{new_lr}" if @verbose
+            @wait = 0
+          end
+        end
+      end
+    end
+    
+    private
+    
+    def monitor_improved?(current)
+      if @mode == 'min'
+        current < @best - @min_delta
+      else
+        current > @best + @min_delta
+      end
+    end
+  end
+  
+  class CSVLogger < Callback
+    def initialize(filename:, separator: ',', append: false)
+      @filename = filename
+      @separator = separator
+      @append = append
+      @file = nil
+      @keys = nil
+    end
+    
+    def on_train_begin(logs = {})
+      mode = @append ? 'a' : 'w'
+      @file = File.open(@filename, mode)
+      @keys = nil
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+      logs_copy = logs.dup
+      logs_copy.delete(:model)
+      logs_copy[:epoch] = epoch + 1
+      
+      if @keys.nil?
+        @keys = logs_copy.keys
+        @file.puts @keys.join(@separator)
+      end
+      
+      values = @keys.map { |key| logs_copy[key] || '' }
+      @file.puts values.join(@separator)
+      @file.flush
+    end
+    
+    def on_train_end(logs = {})
+      @file.close if @file
+    end
+  end
+  
+  class ProgbarLogger < Callback
+    def initialize(count_mode: 'steps')
+      @count_mode = count_mode
+    end
+    
+    def on_train_begin(logs = {})
+      @epochs = logs[:epochs] || 1
+    end
+    
+    def on_epoch_begin(epoch, logs = {})
+      puts "\nEpoch #{epoch + 1}/#{@epochs}"
+      @seen = 0
+      @total = logs[:steps] || 0
+    end
+    
+    def on_batch_end(batch, logs = {})
+      @seen += 1
+      progress = (@seen.to_f / @total * 100).round(1)
+      bar_length = 30
+      filled = (bar_length * @seen / @total).to_i
+      bar = '=' * filled + '>' + '.' * (bar_length - filled - 1)
+      
+      print "\r#{@seen}/#{@total} [#{bar}] #{progress}%"
+      $stdout.flush
+    end
+    
+    def on_epoch_end(epoch, logs = {})
+      puts ""
+    end
+  end
+end