grnexus 1.0.2

data/lib/grnexus.rb

@@ -0,0 +1,743 @@
+require 'grnexus_core'
+require 'grnexus_layers'
+require 'grnexus_activations'
+require 'grnexus_normalization'
+require 'grnexus_numeric_proccessing'
+require 'grnexus_text_proccessing'
+require 'grnexus_callbacks'
+require 'grnexus_machine_learning'
+require 'json'
+require 'time'
+require 'zlib'
+
+module GRNexus
+  class NeuralNetwork
+    attr_accessor :layers, :loss_function, :optimizer, :learning_rate, :history, :name
+    
+    def initialize(loss: 'mse', optimizer: 'sgd', learning_rate: 0.01, name: 'model')
+      @layers = []
+      @loss_function = loss
+      @optimizer = optimizer
+      @learning_rate = learning_rate
+      @name = name
+      @history = { loss: [], accuracy: [], val_loss: [], val_accuracy: [], lr: [] }
+      @optimizer_state = {}
+      @callbacks = []
+      @stop_training = false
+    end
+    
+    def add(layer)
+      @layers << layer
+    end
+    
+    def compile(loss: nil, optimizer: nil, learning_rate: nil, metrics: [])
+      @loss_function = loss if loss
+      @optimizer = optimizer if optimizer
+      @learning_rate = learning_rate if learning_rate
+      @metrics = metrics
+    end
+    
+    def forward(input, training: true)
+      output = input
+      @layers.each do |layer|
+        if layer.is_a?(GRNEXUSLayer::DropoutLayer) || layer.is_a?(GRNEXUSLayer::BatchNormLayer)
+          output = layer.forward(output, training: training)
+        else
+          output = layer.forward(output)
+        end
+      end
+      output
+    end
+    
+    def backward(gradient)
+      grad = gradient
+      @layers.reverse.each do |layer|
+        if layer.trainable?
+          grad = layer.backward(grad, @learning_rate)
+        else
+          grad = layer.backward(grad)
+        end
+      end
+      grad
+    end
+    
+    def train(x_train, y_train, epochs: 10, batch_size: 32, verbose: true, 
+              validation_data: nil, callbacks: [], shuffle: true)
+      @callbacks = callbacks
+      @stop_training = false
+      
+      num_samples = x_train.length
+      num_batches = (num_samples.to_f / batch_size).ceil
+      
+      # Validation data
+      x_val, y_val = validation_data if validation_data
+      
+      # Callbacks - on_train_begin
+      callback_logs = { epochs: epochs, steps: num_batches, model: self }
+      @callbacks.each { |cb| cb.on_train_begin(callback_logs) }
+      
+      epochs.times do |epoch|
+        break if @stop_training
+        
+        # Callbacks - on_epoch_begin
+        epoch_logs = { epoch: epoch, model: self }
+        @callbacks.each { |cb| cb.on_epoch_begin(epoch, epoch_logs) }
+        
+        epoch_loss = 0.0
+        correct = 0
+        total = 0
+        
+        # Shuffle data
+        indices = shuffle ? (0...num_samples).to_a.shuffle : (0...num_samples).to_a
+        
+        num_batches.times do |batch_idx|
+          batch_start = batch_idx * batch_size
+          batch_end = [batch_start + batch_size, num_samples].min
+          batch_indices = indices[batch_start...batch_end]
+          
+          x_batch = batch_indices.map { |i| x_train[i] }
+          y_batch = batch_indices.map { |i| y_train[i] }
+          
+          # Callbacks - on_batch_begin
+          batch_logs = { batch: batch_idx, size: batch_indices.length }
+          @callbacks.each { |cb| cb.on_batch_begin(batch_idx, batch_logs) }
+          
+          # Forward pass
+          predictions = forward(x_batch, training: true)
+          
+          # Calculate loss
+          loss = calculate_loss(predictions, y_batch)
+          epoch_loss += loss
+          
+          # Calculate accuracy (for classification)
+          if @loss_function == 'cross_entropy'
+            correct += calculate_accuracy(predictions, y_batch)
+            total += batch_indices.length
+          end
+          
+          # Backward pass
+          gradient = calculate_gradient(predictions, y_batch)
+          backward(gradient)
+          
+          # Callbacks - on_batch_end
+          batch_logs[:loss] = loss
+          @callbacks.each { |cb| cb.on_batch_end(batch_idx, batch_logs) }
+        end
+        
+        avg_loss = epoch_loss / num_batches
+        @history[:loss] << avg_loss
+        @history[:lr] << @learning_rate
+        
+        # Calculate validation metrics if validation data provided
+        if validation_data
+          val_results = evaluate(x_val, y_val)
+          @history[:val_loss] << val_results[:loss]
+          @history[:val_accuracy] << val_results[:accuracy] if val_results[:accuracy]
+        end
+        
+        # Prepare epoch end logs
+        epoch_end_logs = {
+          epoch: epoch,
+          loss: avg_loss,
+          lr: @learning_rate,
+          model: self
+        }
+        
+        if @loss_function == 'cross_entropy'
+          accuracy = (correct.to_f / total * 100).round(2)
+          @history[:accuracy] << accuracy
+          epoch_end_logs[:accuracy] = accuracy
+        end
+        
+        if validation_data
+          epoch_end_logs[:val_loss] = @history[:val_loss].last
+          epoch_end_logs[:val_accuracy] = @history[:val_accuracy].last if @history[:val_accuracy].any?
+        end
+        
+        # Callbacks - on_epoch_end
+        @callbacks.each { |cb| cb.on_epoch_end(epoch, epoch_end_logs) }
+        
+        # Check for early stopping
+        @callbacks.each do |cb|
+          if cb.respond_to?(:stop_training?) && cb.stop_training?
+            @stop_training = true
+            break
+          end
+        end
+        
+        # Verbose output
+        if verbose
+          output_str = "Epoch #{epoch + 1}/#{epochs} - Loss: #{avg_loss.round(6)}"
+          output_str += " - Accuracy: #{accuracy}%" if @loss_function == 'cross_entropy'
+          output_str += " - Val Loss: #{@history[:val_loss].last.round(6)}" if validation_data
+          output_str += " - Val Accuracy: #{@history[:val_accuracy].last}%" if validation_data && @history[:val_accuracy].any?
+          output_str += " - LR: #{@learning_rate}" if @callbacks.any? { |cb| cb.is_a?(GRNEXUSCallbacks::LearningRateScheduler) || cb.is_a?(GRNEXUSCallbacks::ReduceLROnPlateau) }
+          puts output_str
+        end
+      end
+      
+      # Callbacks - on_train_end
+      @callbacks.each { |cb| cb.on_train_end({ model: self }) }
+      
+      @history
+    end
+    
+    def predict(input)
+      forward(input, training: false)
+    end
+    
+    def evaluate(x_test, y_test)
+      predictions = predict(x_test)
+      loss = calculate_loss(predictions, y_test)
+      
+      result = { loss: loss }
+      
+      if @loss_function == 'cross_entropy'
+        correct = calculate_accuracy(predictions, y_test)
+        accuracy = (correct.to_f / y_test.length * 100).round(2)
+        result[:accuracy] = accuracy
+      end
+      
+      result
+    end
+    
+    def save(filepath)
+      # Expandir ruta para manejar rutas relativas y absolutas
+      expanded_path = File.expand_path(filepath)
+      
+      # Crear directorio si no existe
+      dir = File.dirname(expanded_path)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      
+      model_data = {
+        version: '2.0',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        name: @name,
+        created_at: Time.now.iso8601,
+        architecture: serialize_architecture,
+        loss_function: @loss_function,
+        optimizer: @optimizer,
+        learning_rate: @learning_rate,
+        history: @history,
+        metadata: {
+          total_params: count_params[:total],
+          trainable_params: count_params[:trainable],
+          layers_count: @layers.length
+        }
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      
+      File.open(expanded_path, 'wb') do |file|
+        file.write(compressed_data)
+      end
+      
+      puts "Model saved to #{expanded_path}"
+    end
+    
+    def self.load(filepath)
+      # Expandir ruta para manejar rutas relativas y absolutas
+      expanded_path = File.expand_path(filepath)
+      
+      unless File.exist?(expanded_path)
+        raise "Model file not found: #{expanded_path}"
+      end
+      
+      compressed_data = File.read(expanded_path, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      # Verificar compatibilidad
+      version = model_data['version'] || '1.0'
+      framework = model_data['framework'] || 'GRNexus'
+      source_lang = model_data['language'] || 'Unknown'
+      
+      puts "Loading model: #{framework} v#{version} (created in #{source_lang})"
+      
+      model = NeuralNetwork.new(
+        loss: model_data['loss_function'],
+        optimizer: model_data['optimizer'],
+        learning_rate: model_data['learning_rate'],
+        name: model_data['name'] || 'model'
+      )
+      
+      model.deserialize_architecture(model_data['architecture'])
+      
+      # Convertir history keys de strings a symbols si es necesario
+      if model_data['history'].is_a?(Hash)
+        model.history = model_data['history'].transform_keys(&:to_sym)
+      else
+        model.history = model_data['history']
+      end
+      
+      puts "Model loaded from #{expanded_path}"
+      if model_data['metadata']
+        puts "  Total params: #{model_data['metadata']['total_params']}"
+        puts "  Layers: #{model_data['metadata']['layers_count']}"
+      end
+      model
+    end
+    
+    def summary(line_length: 80)
+      puts "\n" + "=" * line_length
+      puts "Model: #{@name}"
+      puts "=" * line_length
+      puts "#{' ' * 20}Output Shape#{' ' * 10}Param #"
+      puts "-" * line_length
+      
+      total_params = 0
+      trainable_params = 0
+      
+      @layers.each_with_index do |layer, idx|
+        layer_name = layer.class.name.split('::').last
+        layer_name = "#{layer_name} (#{layer.activation.class.name.split('::').last})" if layer.respond_to?(:activation) && layer.activation
+        
+        # Calculate output shape
+        output_shape = get_layer_output_shape(layer, idx)
+        
+        # Calculate parameters
+        params = count_layer_params(layer)
+        total_params += params
+        trainable_params += params if layer.trainable?
+        
+        # Format output
+        layer_info = "#{layer_name} (#{idx + 1})"
+        layer_info = layer_info.ljust(30)
+        layer_info += output_shape.ljust(25)
+        layer_info += params.to_s
+        
+        puts layer_info
+      end
+      
+      puts "=" * line_length
+      puts "Total params: #{total_params}"
+      puts "Trainable params: #{trainable_params}"
+      puts "Non-trainable params: #{total_params - trainable_params}"
+      puts "=" * line_length + "\n"
+    end
+    
+    def to_json_architecture
+      {
+        name: @name,
+        layers: @layers.map.with_index do |layer, idx|
+          {
+            index: idx,
+            type: layer.class.name,
+            config: layer_config(layer),
+            trainable: layer.trainable?
+          }
+        end
+      }.to_json
+    end
+    
+    def self.inspect_model(filepath)
+      """Inspecciona un modelo guardado sin cargarlo completamente"""
+      # Expandir ruta para manejar rutas relativas y absolutas
+      expanded_path = File.expand_path(filepath)
+      
+      unless File.exist?(expanded_path)
+        puts "Error: Model file not found: #{expanded_path}"
+        return
+      end
+      
+      compressed_data = File.read(expanded_path, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      puts "\n" + "=" * 80
+      puts "MODEL INSPECTION: #{filepath}"
+      puts "=" * 80
+      puts "Framework: #{model_data['framework'] || 'GRNexus'}"
+      puts "Version: #{model_data['version'] || '1.0'}"
+      puts "Language: #{model_data['language'] || 'Unknown'}"
+      puts "Name: #{model_data['name']}"
+      puts "Created: #{model_data['created_at']}"
+      puts "Loss Function: #{model_data['loss_function']}"
+      puts "Optimizer: #{model_data['optimizer']}"
+      puts "Learning Rate: #{model_data['learning_rate']}"
+      
+      if model_data['metadata']
+        puts "\nMetadata:"
+        puts "  Total Parameters: #{model_data['metadata']['total_params']}"
+        puts "  Trainable Parameters: #{model_data['metadata']['trainable_params']}"
+        puts "  Layers Count: #{model_data['metadata']['layers_count']}"
+      end
+      
+      puts "\nArchitecture:"
+      puts "-" * 80
+      model_data['architecture'].each_with_index do |layer_data, idx|
+        layer_type = layer_data['type'].split('::').last
+        puts "  Layer #{idx + 1}: #{layer_type}"
+        if layer_data['units']
+          puts "    Units: #{layer_data['units']}"
+        end
+        if layer_data['activation']
+          puts "    Activation: #{layer_data['activation'].split('::').last}"
+        end
+        puts "    Trainable: #{layer_data['trainable']}"
+      end
+      
+      if model_data['history'] && model_data['history']['loss']
+        puts "\nTraining History:"
+        puts "  Epochs trained: #{model_data['history']['loss'].length}"
+        puts "  Final loss: #{model_data['history']['loss'].last.round(6)}"
+        if model_data['history']['accuracy'] && model_data['history']['accuracy'].any?
+          puts "  Final accuracy: #{model_data['history']['accuracy'].last.round(2)}%"
+        end
+      end
+      
+      puts "=" * 80 + "\n"
+    end
+    
+    def plot_history(metrics: ['loss', 'accuracy'])
+      # Text-based plotting
+      puts "\n" + "=" * 80
+      puts "Training History"
+      puts "=" * 80
+      
+      metrics.each do |metric|
+        next unless @history[metric.to_sym]&.any?
+        
+        puts "\n#{metric.capitalize}:"
+        values = @history[metric.to_sym]
+        min_val = values.min
+        max_val = values.max
+        range = max_val - min_val
+        
+        values.each_with_index do |val, epoch|
+          normalized = range > 0 ? ((val - min_val) / range * 50).to_i : 25
+          bar = '█' * normalized
+          puts "Epoch #{epoch + 1}: #{bar} #{val.round(4)}"
+        end
+      end
+      
+      puts "=" * 80 + "\n"
+    end
+    
+    def count_params
+      total = 0
+      trainable = 0
+      
+      @layers.each do |layer|
+        params = count_layer_params(layer)
+        total += params
+        trainable += params if layer.trainable?
+      end
+      
+      { total: total, trainable: trainable, non_trainable: total - trainable }
+    end
+    
+    def deserialize_architecture(architecture_data)
+      architecture_data.each do |layer_data|
+        # Manejar nombres de Python (lib.grnexus_layers.DenseLayer) y Ruby (GRNEXUSLayer::DenseLayer)
+        layer_type = layer_data['type']
+        
+        # Extraer el nombre de la clase sin el módulo/namespace
+        # Python: "lib.grnexus_layers.DenseLayer" -> "DenseLayer"
+        # Ruby: "GRNEXUSLayer::DenseLayer" -> "DenseLayer"
+        if layer_type.include?('.')
+          # Formato Python
+          layer_class_name = layer_type.split('.').last
+        else
+          # Formato Ruby
+          layer_class_name = layer_type.split('::').last
+        end
+        
+        begin
+          layer_class = GRNEXUSLayer.const_get(layer_class_name)
+        rescue NameError
+          puts "Warning: Could not find layer class #{layer_class_name}, skipping"
+          next
+        end
+        
+        # Reconstruct layer based on type
+        layer = case layer_class_name
+        when 'DenseLayer'
+          # Manejar activación de Python o Ruby
+          activation = nil
+          if layer_data['activation']
+            activation_str = layer_data['activation']
+            
+            # Extraer nombre de activación
+            # Python: "lib.grnexus_activations.ReLU" -> "ReLU"
+            # Ruby: "GRNEXUSActivations::ReLU" -> "ReLU"
+            if activation_str.include?('.')
+              activation_name = activation_str.split('.').last
+            else
+              activation_name = activation_str.split('::').last
+            end
+            
+            begin
+              # Intentar primero en GRNEXUSActivations
+              activation = GRNEXUSActivations.const_get(activation_name).new
+            rescue NameError
+              # Intentar en GRNEXUSNormalization
+              begin
+                activation = GRNEXUSNormalization.const_get(activation_name).new
+              rescue NameError
+                puts "Warning: Could not find activation #{activation_name}"
+                activation = nil
+              end
+            end
+          end
+          
+          l = layer_class.new(
+            units: layer_data['units'],
+            input_dim: layer_data['input_dim'],
+            activation: activation
+          )
+          l.weights = layer_data['weights'] if layer_data['weights']
+          l.biases = layer_data['biases'] if layer_data['biases']
+          l
+        when 'ActivationLayer'
+          activation_str = layer_data['activation']
+          
+          # Extraer nombre de activación
+          if activation_str.include?('.')
+            activation_name = activation_str.split('.').last
+          else
+            activation_name = activation_str.split('::').last
+          end
+          
+          activation = GRNEXUSActivations.const_get(activation_name).new rescue nil
+          layer_class.new(activation)
+        when 'DropoutLayer'
+          layer_class.new(rate: layer_data['rate'] || 0.5)
+        when 'BatchNormLayer'
+          l = layer_class.new(
+            epsilon: layer_data['epsilon'] || 1e-5,
+            momentum: layer_data['momentum'] || 0.1
+          )
+          l.gamma = layer_data['gamma'] || 1.0
+          l.beta = layer_data['beta'] || 0.0
+          # CRITICAL: Restore running statistics for BatchNorm inference
+          if layer_data['running_mean'] && layer_data['running_var']
+            l.instance_variable_set(:@running_mean, layer_data['running_mean'])
+            l.instance_variable_set(:@running_var, layer_data['running_var'])
+          else
+            # Inicializar running stats si no existen en el archivo
+            l.instance_variable_set(:@running_mean, nil)
+            l.instance_variable_set(:@running_var, nil)
+          end
+          l
+        else
+          # For other layers, try to instantiate with default parameters
+          layer_class.new
+        end
+        
+        @layers << layer
+      end
+    end
+    
+    private
+    
+    def calculate_loss(predictions, targets)
+      case @loss_function
+      when 'mse'
+        mse_loss(predictions, targets)
+      when 'cross_entropy'
+        cross_entropy_loss(predictions, targets)
+      else
+        raise "Unknown loss function: #{@loss_function}"
+      end
+    end
+    
+    def calculate_gradient(predictions, targets)
+      case @loss_function
+      when 'mse'
+        mse_gradient(predictions, targets)
+      when 'cross_entropy'
+        cross_entropy_gradient(predictions, targets)
+      else
+        raise "Unknown loss function: #{@loss_function}"
+      end
+    end
+    
+    def mse_loss(predictions, targets)
+      total_loss = 0.0
+      predictions.each_with_index do |pred, i|
+        target = targets[i]
+        pred.each_with_index do |p, j|
+          diff = p - target[j]
+          total_loss += diff * diff
+        end
+      end
+      total_loss / (predictions.length * predictions[0].length)
+    end
+    
+    def mse_gradient(predictions, targets)
+      gradients = []
+      predictions.each_with_index do |pred, i|
+        target = targets[i]
+        grad = pred.each_with_index.map do |p, j|
+          2.0 * (p - target[j]) / (predictions.length * predictions[0].length)
+        end
+        gradients << grad
+      end
+      gradients
+    end
+    
+    def cross_entropy_loss(predictions, targets)
+      total_loss = 0.0
+      epsilon = 1e-15
+      
+      predictions.each_with_index do |pred, i|
+        target = targets[i]
+        pred.each_with_index do |p, j|
+          # Handle NaN and Infinity
+          p = 0.5 if p.nan? || p.infinite?
+          
+          # Clip to prevent log(0)
+          p_clipped = [[p, epsilon].max, 1.0 - epsilon].min
+          
+          # Only calculate if target is non-zero
+          if target[j] > 0
+            log_val = Math.log(p_clipped)
+            total_loss -= target[j] * log_val unless log_val.nan?
+          end
+        end
+      end
+      
+      total_loss / predictions.length
+    end
+    
+    def cross_entropy_gradient(predictions, targets)
+      gradients = []
+      predictions.each_with_index do |pred, i|
+        target = targets[i]
+        grad = pred.each_with_index.map { |p, j| p - target[j] }
+        gradients << grad
+      end
+      gradients
+    end
+    
+    def calculate_accuracy(predictions, targets)
+      correct = 0
+      predictions.each_with_index do |pred, i|
+        # Handle NaN values in predictions
+        valid_pred = pred.map { |v| v.nan? || v.infinite? ? 0.0 : v }
+        
+        # Find max indices safely
+        pred_class = valid_pred.each_with_index.max_by { |val, _| val }[1]
+        true_class = targets[i].each_with_index.max_by { |val, _| val }[1]
+        
+        correct += 1 if pred_class == true_class
+      end
+      correct
+    end
+    
+    def clean_nan(value)
+      case value
+      when Array
+        value.map { |v| clean_nan(v) }
+      when Float
+        value.nan? || value.infinite? ? 0.0 : value
+      else
+        value
+      end
+    end
+    
+    def serialize_architecture
+      @layers.map do |layer|
+        layer_data = {
+          type: layer.class.name,
+          trainable: layer.trainable?
+        }
+        
+        # Serialize layer-specific parameters
+        if layer.respond_to?(:weights) && layer.weights
+          layer_data[:weights] = clean_nan(layer.weights)
+        end
+        
+        if layer.respond_to?(:biases) && layer.biases
+          layer_data[:biases] = clean_nan(layer.biases)
+        end
+        
+        if layer.respond_to?(:units)
+          layer_data[:units] = layer.units
+          layer_data[:input_dim] = layer.input_dim if layer.respond_to?(:input_dim)
+        end
+        
+        if layer.respond_to?(:activation) && layer.activation
+          layer_data[:activation] = layer.activation.class.name
+        end
+        
+        if layer.respond_to?(:rate)
+          layer_data[:rate] = layer.rate
+        end
+        
+        if layer.respond_to?(:epsilon)
+          layer_data[:epsilon] = layer.epsilon
+          layer_data[:momentum] = layer.momentum
+          layer_data[:gamma] = layer.gamma
+          layer_data[:beta] = layer.beta
+          # CRITICAL: Save running statistics for BatchNorm inference
+          if layer.instance_variable_defined?(:@running_mean)
+            layer_data[:running_mean] = clean_nan(layer.instance_variable_get(:@running_mean))
+            layer_data[:running_var] = clean_nan(layer.instance_variable_get(:@running_var))
+          end
+        end
+        
+        layer_data
+      end
+    end
+    
+    def count_layer_params(layer)
+      params = 0
+      
+      if layer.respond_to?(:weights) && layer.weights
+        params += layer.weights.flatten.length
+      end
+      
+      if layer.respond_to?(:biases) && layer.biases
+        params += layer.biases.length
+      end
+      
+      if layer.respond_to?(:gamma)
+        params += 2  # gamma and beta
+      end
+      
+      params
+    end
+    
+    def get_layer_output_shape(layer, idx)
+      if layer.respond_to?(:units)
+        "(None, #{layer.units})"
+      elsif layer.respond_to?(:filters)
+        "(None, ?, ?, #{layer.filters})"
+      elsif layer.is_a?(GRNEXUSLayer::DropoutLayer) || layer.is_a?(GRNEXUSLayer::BatchNormLayer)
+        # Dropout y BatchNorm mantienen la misma forma que la última capa con units
+        # Buscar hacia atrás la última capa con units
+        (idx - 1).downto(0) do |i|
+          if @layers[i].respond_to?(:units)
+            return "(None, #{@layers[i].units})"
+          end
+        end
+        "(None, ?)"
+      else
+        "(None, ?)"
+      end
+    end
+    
+    def layer_config(layer)
+      config = {}
+      
+      if layer.respond_to?(:units)
+        config[:units] = layer.units
+        config[:input_dim] = layer.input_dim if layer.respond_to?(:input_dim)
+      end
+      
+      if layer.respond_to?(:activation) && layer.activation
+        config[:activation] = layer.activation.class.name
+      end
+      
+      if layer.respond_to?(:rate)
+        config[:rate] = layer.rate
+      end
+      
+      config
+    end
+  end
+end