grnexus 1.0.2

data/lib/grnexus_normalization.rb

@@ -0,0 +1,319 @@
+require 'ffi'
+require 'rbconfig'
+
+module GRNEXUSNormalization
+  extend FFI::Library
+
+  # Detectar sistema operativo y cargar biblioteca apropiada
+  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', 'normalization.dll')
+    when /darwin/
+      File.join(script_dir, '..', 'exports', 'Mac', 'normalization.dylib')
+    when /linux/
+      File.join(script_dir, '..', 'exports', 'Linux', 'normalization.so')
+    else
+      raise "Sistema operativo no soportado: #{os}"
+    end
+  end
+
+  # Cargar biblioteca compartida
+  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 firmas de funciones
+  FUNCTIONS = {
+    'Softmax' => [:Softmax, [:pointer, :pointer, :bool, :size_t], :int],
+    'LogSoftmax' => [:LogSoftmax, [:pointer, :pointer, :bool, :size_t], :int],
+    'Sparsemax' => [:Sparsemax, [:pointer, :pointer, :bool, :size_t], :int],
+    'TsallisSoftmax' => [:TsallisSoftmax, [:pointer, :pointer, :bool, :size_t, :double], :int],
+  }
+
+  # Adjuntar funciones a la biblioteca
+  FUNCTIONS.each do |name, (func, args, ret)|
+    attach_function func, args, ret
+  end
+
+  # Función auxiliar para aplanar arrays y determinar dimensiones
+  def self.flatten_array(lst)
+    # Si no es un array, retornar como array de un elemento
+    return [lst], [] unless lst.is_a?(Array)
+
+    # Verificar si es un array 1D
+    if lst.none? { |item| item.is_a?(Array) }
+      return lst, [lst.length]
+    end
+
+    # Verificar si es un array 2D
+    if lst.all? { |item| item.is_a?(Array) && item.none? { |x| x.is_a?(Array) } }
+      flat = []
+      lst.each { |row| flat.concat(row) }
+      return flat, [lst.length, lst[0]&.length || 0]
+    end
+
+    # Verificar si es un array 3D
+    if lst.all? { |item| item.is_a?(Array) }
+      if lst.all? { |item| item.all? { |row| row.is_a?(Array) } }
+        flat = []
+        dim0 = lst.length
+        dim1 = lst[0]&.length || 0
+        dim2 = lst[0]&.[](0)&.length || 0
+        lst.each do |matrix|
+          matrix.each { |row| flat.concat(row) }
+        end
+        return flat, [dim0, dim1, dim2]
+      end
+    end
+
+    # Fallback: aplanar recursivamente
+    flat = []
+    recursive_flatten = lambda do |l|
+      l.each do |item|
+        if item.is_a?(Array)
+          recursive_flatten.call(item)
+        else
+          flat << item
+        end
+      end
+    end
+    recursive_flatten.call(lst)
+    [flat, [flat.length]]
+  end
+
+  # Función para crear GRNexusData
+  def self.create_grnexus_data(array_or_scalar)
+    values, dims = flatten_array(array_or_scalar)
+    size = values.length
+
+    # Crear 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
+
+    # Establecer dimensiones
+    if dims.empty?
+      struct_instance[:dims][0] = 1
+      struct_instance[:dims][1] = 0
+      struct_instance[:dims][2] = 0
+    elsif dims.length == 1
+      struct_instance[:dims][0] = dims[0]
+      struct_instance[:dims][1] = 0
+      struct_instance[:dims][2] = 0
+    elsif dims.length == 2
+      struct_instance[:dims][0] = dims[0]
+      struct_instance[:dims][1] = dims[1]
+      struct_instance[:dims][2] = 0
+    elsif dims.length >= 3
+      struct_instance[:dims][0] = dims[0]
+      struct_instance[:dims][1] = dims[1]
+      struct_instance[:dims][2] = dims[2]
+    end
+
+    [data, buffer, dims]
+  end
+
+  # Función para crear GRNexusData de salida
+  def self.create_output_grnexus_data(size)
+    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(buffer, size)
+    buffer.read_array_of_double(size)
+  end
+
+  # Clase base de normalización
+  class NormalizationLayer
+    def normalize(data, derivative: false)
+      raise NotImplementedError, "Debes implementar el método de normalización"
+    end
+
+    def call(data, derivative: false)
+      normalize(data, derivative: derivative)
+    end
+  end
+
+  class BaseNormalization < NormalizationLayer
+    protected
+
+    def execute_normalization(func_name, input_values, derivative: false, **kwargs)
+      # Guardar forma original para remodelar la salida
+      original_shape = nil
+      if input_values.is_a?(Array)
+        # Detectar forma
+        if input_values[0].is_a?(Array)
+          if input_values[0][0].is_a?(Array)
+            # Array 3D
+            original_shape = [input_values.length, input_values[0].length, input_values[0][0].length]
+          else
+            # Array 2D
+            original_shape = [input_values.length, input_values[0].length]
+          end
+        end
+      end
+
+      input_data, input_buffer, dims = GRNEXUSNormalization.create_grnexus_data(input_values)
+      input_struct = GRNEXUSNormalization::GRNexusData.new(input_data)
+      output_size = input_struct[:size]
+      output_data, output_buffer = GRNEXUSNormalization.create_output_grnexus_data(output_size)
+
+      args = [input_data, output_data, derivative]
+
+      # Agregar parámetro axis
+      axis = kwargs[:axis] || output_size  # Usar size como axis "global" por defecto
+
+      # Manejar axis negativo (indexación estilo Python)
+      if axis < 0
+        if original_shape
+          axis = original_shape.length + axis
+        else
+          axis = 0
+        end
+      end
+
+      args << axis
+
+      # Agregar argumentos específicos de la función
+      if func_name == :TsallisSoftmax
+        args << (kwargs[:q] || 1.0)
+      end
+
+      # Llamar a la función C
+      result = GRNEXUSNormalization.send(func_name, *args)
+
+      if result != 0
+        raise "Función #{func_name} falló con código: #{result}"
+      end
+
+      # Obtener resultado plano
+      flat_result = output_buffer.read_array_of_double(output_size)
+
+      # Remodelar si es necesario
+      if original_shape
+        if original_shape.length == 2
+          # Remodelar a 2D
+          reshaped = []
+          idx = 0
+          original_shape[0].times do
+            row = []
+            original_shape[1].times do
+              row << flat_result[idx]
+              idx += 1
+            end
+            reshaped << row
+          end
+          return reshaped
+        elsif original_shape.length == 3
+          # Remodelar a 3D
+          reshaped = []
+          idx = 0
+          original_shape[0].times do
+            matrix = []
+            original_shape[1].times do
+              row = []
+              original_shape[2].times do
+                row << flat_result[idx]
+                idx += 1
+              end
+              matrix << row
+            end
+            reshaped << matrix
+          end
+          return reshaped
+        end
+      end
+
+      flat_result
+    ensure
+      # FFI::MemoryPointer se libera automáticamente con GC
+    end
+  end
+
+  # Clases de capas de normalización
+  class Softmax < BaseNormalization
+    def initialize(axis: -1)
+      @axis = axis
+    end
+
+    def normalize(data, derivative: false)
+      execute_normalization(:Softmax, data, derivative: derivative, axis: @axis)
+    end
+
+    def call(data, derivative: false)
+      normalize(data, derivative: derivative)
+    end
+  end
+
+  class LogSoftmax < BaseNormalization
+    def initialize(axis: -1)
+      @axis = axis
+    end
+
+    def normalize(data, derivative: false)
+      execute_normalization(:LogSoftmax, data, derivative: derivative, axis: @axis)
+    end
+
+    def call(data, derivative: false)
+      normalize(data, derivative: derivative)
+    end
+  end
+
+  class Sparsemax < BaseNormalization
+    def initialize(axis: -1)
+      @axis = axis
+    end
+
+    def normalize(data, derivative: false)
+      execute_normalization(:Sparsemax, data, derivative: derivative, axis: @axis)
+    end
+
+    def call(data, derivative: false)
+      normalize(data, derivative: derivative)
+    end
+  end
+
+  class TsallisSoftmax < BaseNormalization
+    def initialize(axis: -1, q: 1.0)
+      @axis = axis
+      @q = q
+    end
+
+    def normalize(data, derivative: false)
+      execute_normalization(:TsallisSoftmax, data, derivative: derivative, axis: @axis, q: @q)
+    end
+
+    def call(data, derivative: false)
+      normalize(data, derivative: derivative)
+    end
+  end
+end