grnexus 1.0.2

data/lib/grnexus_machine_learning.rb

@@ -0,0 +1,591 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'rbconfig'
+
+module GRNEXUSMachineLearning
+  extend FFI::Library
+
+  # Detect and load appropriate library
+  def self.detect_library
+    script_dir = File.dirname(File.expand_path(__FILE__))
+    case RbConfig::CONFIG['host_os']
+    when /mswin|mingw|cygwin/
+      File.join(script_dir, '..', 'exports', 'Windows', 'machine_learning.dll')
+    when /darwin/
+      File.join(script_dir, '..', 'exports', 'Mac', 'machine_learning.dylib')
+    when /linux/
+      File.join(script_dir, '..', 'exports', 'Linux', 'machine_learning.so')
+    else
+      raise "Sistema operativo no soportado: #{RbConfig::CONFIG['host_os']}"
+    end
+  end
+
+  ffi_lib detect_library
+
+  # Define GRNexusData structure
+  class GRNexusData < FFI::Struct
+    layout :data, :pointer,
+           :type, :int,
+           :size, :size_t,
+           :stride, :size_t,
+           :dims, [:size_t, 3]
+  end
+
+  # Attach C functions
+  attach_function :knn_predict, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr, :int, GRNexusData.ptr], :int
+  attach_function :kmeans_fit, [GRNexusData.ptr, :int, :int, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :kmeans_predict, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :linear_regression_fit, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :linear_regression_predict, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :logistic_regression_fit, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr, :double, :int], :int
+  attach_function :logistic_regression_predict, [GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :naive_bayes_fit, [GRNexusData.ptr, GRNexusData.ptr, :int, GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+  attach_function :naive_bayes_predict, [GRNexusData.ptr, :int, GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr, GRNexusData.ptr], :int
+
+  # Helper method to create GRNexusData from Ruby array
+  def self.create_data(array, dims)
+    data = GRNexusData.new
+    flat_array = array.flatten
+    buffer = FFI::MemoryPointer.new(:double, flat_array.size)
+    buffer.write_array_of_double(flat_array)
+    
+    data[:data] = buffer
+    data[:type] = 3  # GRNEXUS_MATRIX
+    data[:size] = flat_array.size
+    data[:stride] = 1
+    data[:dims][0] = dims[0]
+    data[:dims][1] = dims[1] || 0
+    data[:dims][2] = dims[2] || 0
+    
+    data
+  end
+
+  # K-Nearest Neighbors
+  class KNeighborsClassifier
+    attr_reader :n_neighbors
+
+    def initialize(n_neighbors: 5)
+      @n_neighbors = n_neighbors
+      @x_train = nil
+      @y_train = nil
+    end
+
+    def fit(x, y)
+      @x_train = x
+      @y_train = y
+      self
+    end
+
+    def save(filepath)
+      require 'json'
+      require 'zlib'
+      
+      # Ensure .lnexus extension
+      filepath = filepath.sub(/\.nexus$/, '.lnexus') unless filepath.end_with?('.lnexus')
+      
+      model_data = {
+        model_type: 'KNeighborsClassifier',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        version: '1.0',
+        n_neighbors: @n_neighbors,
+        x_train: @x_train,
+        y_train: @y_train
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      File.write(filepath, compressed_data, mode: 'wb')
+      puts "Model saved to #{filepath}"
+    end
+
+    def self.load(filepath)
+      require 'json'
+      require 'zlib'
+      
+      raise "File not found: #{filepath}" unless File.exist?(filepath)
+      raise "Invalid file format. Expected .lnexus for ML models, got .nexus (Neural Network format)" if filepath.end_with?('.nexus')
+      
+      compressed_data = File.read(filepath, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      raise "Invalid model type. Expected KNeighborsClassifier" unless model_data['model_type'] == 'KNeighborsClassifier'
+      
+      model = new(n_neighbors: model_data['n_neighbors'])
+      model.instance_variable_set(:@x_train, model_data['x_train'])
+      model.instance_variable_set(:@y_train, model_data['y_train'])
+      model
+    end
+
+    def inspect
+      trained = @x_train ? 'trained' : 'not trained'
+      n_samples = @x_train ? @x_train.length : 0
+      n_features = @x_train && @x_train.length > 0 ? @x_train[0].length : 0
+      
+      "#<KNeighborsClassifier n_neighbors=#{@n_neighbors}, status=#{trained}, samples=#{n_samples}, features=#{n_features}>"
+    end
+
+    def predict(x)
+      raise "Model not trained" unless @x_train && @y_train
+      
+      n_samples = x.length
+      n_features = x[0].length
+      n_train = @x_train.length
+      
+      x_train_data = GRNEXUSMachineLearning.create_data(@x_train, [n_train, n_features])
+      y_train_data = GRNEXUSMachineLearning.create_data(@y_train.map { |v| [v] }, [n_train, 1])
+      x_test_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      
+      output_buffer = FFI::MemoryPointer.new(:double, n_samples)
+      output_data = GRNEXUSMachineLearning::GRNexusData.new
+      output_data[:data] = output_buffer
+      output_data[:size] = n_samples
+      output_data[:dims][0] = n_samples
+      output_data[:dims][1] = 1
+      
+      result = GRNEXUSMachineLearning.knn_predict(x_train_data, y_train_data, x_test_data, @n_neighbors, output_data)
+      raise "KNN prediction failed" if result != 0
+      
+      output_buffer.read_array_of_double(n_samples)
+    end
+  end
+
+  # K-Means Clustering
+  class KMeans
+    attr_reader :centroids, :labels, :n_clusters
+
+    def initialize(n_clusters: 3, max_iter: 300)
+      @n_clusters = n_clusters
+      @max_iter = max_iter
+      @centroids = nil
+      @labels = nil
+    end
+
+    def save(filepath)
+      require 'json'
+      require 'zlib'
+      
+      filepath = filepath.sub(/\.nexus$/, '.lnexus') unless filepath.end_with?('.lnexus')
+      
+      model_data = {
+        model_type: 'KMeans',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        version: '1.0',
+        n_clusters: @n_clusters,
+        centroids: @centroids,
+        labels: @labels
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      File.write(filepath, compressed_data, mode: 'wb')
+      puts "Model saved to #{filepath}"
+    end
+
+    def self.load(filepath)
+      require 'json'
+      require 'zlib'
+      
+      raise "File not found: #{filepath}" unless File.exist?(filepath)
+      raise "Invalid file format. Expected .lnexus for ML models, got .nexus (Neural Network format)" if filepath.end_with?('.nexus')
+      
+      compressed_data = File.read(filepath, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      raise "Invalid model type. Expected KMeans" unless model_data['model_type'] == 'KMeans'
+      
+      model = new(n_clusters: model_data['n_clusters'])
+      model.instance_variable_set(:@centroids, model_data['centroids'])
+      model.instance_variable_set(:@labels, model_data['labels'])
+      model
+    end
+
+    def inspect
+      trained = @centroids ? 'trained' : 'not trained'
+      n_features = @centroids && @centroids.length > 0 ? @centroids[0].length : 0
+      
+      "#<KMeans n_clusters=#{@n_clusters}, status=#{trained}, features=#{n_features}>"
+    end
+
+    def fit(x)
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      
+      centroids_buffer = FFI::MemoryPointer.new(:double, @n_clusters * n_features)
+      centroids_data = GRNEXUSMachineLearning::GRNexusData.new
+      centroids_data[:data] = centroids_buffer
+      centroids_data[:size] = @n_clusters * n_features
+      centroids_data[:dims][0] = @n_clusters
+      centroids_data[:dims][1] = n_features
+      
+      labels_buffer = FFI::MemoryPointer.new(:int, n_samples)
+      labels_data = GRNEXUSMachineLearning::GRNexusData.new
+      labels_data[:data] = labels_buffer
+      labels_data[:size] = n_samples
+      labels_data[:dims][0] = n_samples
+      
+      result = GRNEXUSMachineLearning.kmeans_fit(x_data, @n_clusters, @max_iter, centroids_data, labels_data)
+      raise "KMeans fit failed" if result != 0
+      
+      @centroids = centroids_buffer.read_array_of_double(@n_clusters * n_features).each_slice(n_features).to_a
+      @labels = labels_buffer.read_array_of_int(n_samples)
+      
+      self
+    end
+
+    def predict(x)
+      raise "Model not trained" unless @centroids
+      
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      centroids_data = GRNEXUSMachineLearning.create_data(@centroids, [@n_clusters, n_features])
+      
+      labels_buffer = FFI::MemoryPointer.new(:int, n_samples)
+      labels_data = GRNEXUSMachineLearning::GRNexusData.new
+      labels_data[:data] = labels_buffer
+      labels_data[:size] = n_samples
+      labels_data[:dims][0] = n_samples
+      
+      result = GRNEXUSMachineLearning.kmeans_predict(x_data, centroids_data, labels_data)
+      raise "KMeans prediction failed" if result != 0
+      
+      labels_buffer.read_array_of_int(n_samples)
+    end
+  end
+
+  # Linear Regression
+  class LinearRegression
+    attr_reader :weights
+
+    def initialize
+      @weights = nil
+    end
+
+    def save(filepath)
+      require 'json'
+      require 'zlib'
+      
+      filepath = filepath.sub(/\.nexus$/, '.lnexus') unless filepath.end_with?('.lnexus')
+      
+      model_data = {
+        model_type: 'LinearRegression',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        version: '1.0',
+        weights: @weights
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      File.write(filepath, compressed_data, mode: 'wb')
+      puts "Model saved to #{filepath}"
+    end
+
+    def self.load(filepath)
+      require 'json'
+      require 'zlib'
+      
+      raise "File not found: #{filepath}" unless File.exist?(filepath)
+      raise "Invalid file format. Expected .lnexus for ML models, got .nexus (Neural Network format)" if filepath.end_with?('.nexus')
+      
+      compressed_data = File.read(filepath, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      raise "Invalid model type. Expected LinearRegression" unless model_data['model_type'] == 'LinearRegression'
+      
+      model = new
+      model.instance_variable_set(:@weights, model_data['weights'])
+      model
+    end
+
+    def inspect
+      trained = @weights ? 'trained' : 'not trained'
+      n_features = @weights ? @weights.length - 1 : 0
+      
+      "#<LinearRegression status=#{trained}, features=#{n_features}, weights=#{@weights ? @weights.length : 0}>"
+    end
+
+    def fit(x, y)
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      y_data = GRNEXUSMachineLearning.create_data(y.map { |v| [v] }, [n_samples, 1])
+      
+      weights_buffer = FFI::MemoryPointer.new(:double, n_features + 1)
+      weights_data = GRNEXUSMachineLearning::GRNexusData.new
+      weights_data[:data] = weights_buffer
+      weights_data[:size] = n_features + 1
+      weights_data[:dims][0] = n_features + 1
+      
+      result = GRNEXUSMachineLearning.linear_regression_fit(x_data, y_data, weights_data)
+      raise "Linear regression fit failed" if result != 0
+      
+      @weights = weights_buffer.read_array_of_double(n_features + 1)
+      
+      self
+    end
+
+    def predict(x)
+      raise "Model not trained" unless @weights
+      
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      weights_data = GRNEXUSMachineLearning.create_data([@weights], [n_features + 1, 1])
+      
+      output_buffer = FFI::MemoryPointer.new(:double, n_samples)
+      output_data = GRNEXUSMachineLearning::GRNexusData.new
+      output_data[:data] = output_buffer
+      output_data[:size] = n_samples
+      output_data[:dims][0] = n_samples
+      
+      result = GRNEXUSMachineLearning.linear_regression_predict(x_data, weights_data, output_data)
+      raise "Linear regression prediction failed" if result != 0
+      
+      output_buffer.read_array_of_double(n_samples)
+    end
+  end
+
+  # Logistic Regression
+  class LogisticRegression
+    attr_reader :weights, :learning_rate, :max_iter
+
+    def initialize(learning_rate: 0.01, max_iter: 1000)
+      @learning_rate = learning_rate
+      @max_iter = max_iter
+      @weights = nil
+    end
+
+    def save(filepath)
+      require 'json'
+      require 'zlib'
+      
+      filepath = filepath.sub(/\.nexus$/, '.lnexus') unless filepath.end_with?('.lnexus')
+      
+      model_data = {
+        model_type: 'LogisticRegression',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        version: '1.0',
+        learning_rate: @learning_rate,
+        max_iter: @max_iter,
+        weights: @weights
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      File.write(filepath, compressed_data, mode: 'wb')
+      puts "Model saved to #{filepath}"
+    end
+
+    def self.load(filepath)
+      require 'json'
+      require 'zlib'
+      
+      raise "File not found: #{filepath}" unless File.exist?(filepath)
+      raise "Invalid file format. Expected .lnexus for ML models, got .nexus (Neural Network format)" if filepath.end_with?('.nexus')
+      
+      compressed_data = File.read(filepath, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      raise "Invalid model type. Expected LogisticRegression" unless model_data['model_type'] == 'LogisticRegression'
+      
+      model = new(learning_rate: model_data['learning_rate'], max_iter: model_data['max_iter'])
+      model.instance_variable_set(:@weights, model_data['weights'])
+      model
+    end
+
+    def inspect
+      trained = @weights ? 'trained' : 'not trained'
+      n_features = @weights ? @weights.length - 1 : 0
+      
+      "#<LogisticRegression lr=#{@learning_rate}, max_iter=#{@max_iter}, status=#{trained}, features=#{n_features}>"
+    end
+
+    def fit(x, y)
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      y_data = GRNEXUSMachineLearning.create_data(y.map { |v| [v] }, [n_samples, 1])
+      
+      weights_buffer = FFI::MemoryPointer.new(:double, n_features + 1)
+      weights_data = GRNEXUSMachineLearning::GRNexusData.new
+      weights_data[:data] = weights_buffer
+      weights_data[:size] = n_features + 1
+      weights_data[:dims][0] = n_features + 1
+      
+      result = GRNEXUSMachineLearning.logistic_regression_fit(x_data, y_data, weights_data, @learning_rate, @max_iter)
+      raise "Logistic regression fit failed" if result != 0
+      
+      @weights = weights_buffer.read_array_of_double(n_features + 1)
+      
+      self
+    end
+
+    def predict(x)
+      raise "Model not trained" unless @weights
+      
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      weights_data = GRNEXUSMachineLearning.create_data([@weights], [n_features + 1, 1])
+      
+      output_buffer = FFI::MemoryPointer.new(:double, n_samples)
+      output_data = GRNEXUSMachineLearning::GRNexusData.new
+      output_data[:data] = output_buffer
+      output_data[:size] = n_samples
+      output_data[:dims][0] = n_samples
+      
+      result = GRNEXUSMachineLearning.logistic_regression_predict(x_data, weights_data, output_data)
+      raise "Logistic regression prediction failed" if result != 0
+      
+      output_buffer.read_array_of_double(n_samples)
+    end
+
+    def predict_proba(x)
+      predict(x)
+    end
+
+    def predict_class(x)
+      predict(x).map { |prob| prob >= 0.5 ? 1 : 0 }
+    end
+  end
+
+  # Naive Bayes
+  class GaussianNB
+    attr_reader :means, :variances, :priors, :n_classes
+
+    def initialize
+      @means = nil
+      @variances = nil
+      @priors = nil
+      @n_classes = nil
+    end
+
+    def save(filepath)
+      require 'json'
+      require 'zlib'
+      
+      filepath = filepath.sub(/\.nexus$/, '.lnexus') unless filepath.end_with?('.lnexus')
+      
+      model_data = {
+        model_type: 'GaussianNB',
+        framework: 'GRNexus',
+        language: 'Ruby',
+        version: '1.0',
+        n_classes: @n_classes,
+        means: @means,
+        variances: @variances,
+        priors: @priors
+      }
+      
+      json_data = JSON.generate(model_data)
+      compressed_data = Zlib::Deflate.deflate(json_data)
+      File.write(filepath, compressed_data, mode: 'wb')
+      puts "Model saved to #{filepath}"
+    end
+
+    def self.load(filepath)
+      require 'json'
+      require 'zlib'
+      
+      raise "File not found: #{filepath}" unless File.exist?(filepath)
+      raise "Invalid file format. Expected .lnexus for ML models, got .nexus (Neural Network format)" if filepath.end_with?('.nexus')
+      
+      compressed_data = File.read(filepath, mode: 'rb')
+      json_data = Zlib::Inflate.inflate(compressed_data)
+      model_data = JSON.parse(json_data)
+      
+      raise "Invalid model type. Expected GaussianNB" unless model_data['model_type'] == 'GaussianNB'
+      
+      model = new
+      model.instance_variable_set(:@n_classes, model_data['n_classes'])
+      model.instance_variable_set(:@means, model_data['means'])
+      model.instance_variable_set(:@variances, model_data['variances'])
+      model.instance_variable_set(:@priors, model_data['priors'])
+      model
+    end
+
+    def inspect
+      trained = @means ? 'trained' : 'not trained'
+      n_features = @means && @means.length > 0 ? @means[0].length : 0
+      
+      "#<GaussianNB n_classes=#{@n_classes || 0}, status=#{trained}, features=#{n_features}>"
+    end
+
+    def fit(x, y)
+      n_samples = x.length
+      n_features = x[0].length
+      @n_classes = y.max.to_i + 1
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      y_data = GRNEXUSMachineLearning.create_data(y.map { |v| [v] }, [n_samples, 1])
+      
+      means_buffer = FFI::MemoryPointer.new(:double, @n_classes * n_features)
+      means_data = GRNEXUSMachineLearning::GRNexusData.new
+      means_data[:data] = means_buffer
+      means_data[:size] = @n_classes * n_features
+      means_data[:dims][0] = @n_classes
+      means_data[:dims][1] = n_features
+      
+      vars_buffer = FFI::MemoryPointer.new(:double, @n_classes * n_features)
+      vars_data = GRNEXUSMachineLearning::GRNexusData.new
+      vars_data[:data] = vars_buffer
+      vars_data[:size] = @n_classes * n_features
+      vars_data[:dims][0] = @n_classes
+      vars_data[:dims][1] = n_features
+      
+      priors_buffer = FFI::MemoryPointer.new(:double, @n_classes)
+      priors_data = GRNEXUSMachineLearning::GRNexusData.new
+      priors_data[:data] = priors_buffer
+      priors_data[:size] = @n_classes
+      priors_data[:dims][0] = @n_classes
+      
+      result = GRNEXUSMachineLearning.naive_bayes_fit(x_data, y_data, @n_classes, means_data, vars_data, priors_data)
+      raise "Naive Bayes fit failed" if result != 0
+      
+      @means = means_buffer.read_array_of_double(@n_classes * n_features).each_slice(n_features).to_a
+      @variances = vars_buffer.read_array_of_double(@n_classes * n_features).each_slice(n_features).to_a
+      @priors = priors_buffer.read_array_of_double(@n_classes)
+      
+      self
+    end
+
+    def predict(x)
+      raise "Model not trained" unless @means && @variances && @priors
+      
+      n_samples = x.length
+      n_features = x[0].length
+      
+      x_data = GRNEXUSMachineLearning.create_data(x, [n_samples, n_features])
+      means_data = GRNEXUSMachineLearning.create_data(@means, [@n_classes, n_features])
+      vars_data = GRNEXUSMachineLearning.create_data(@variances, [@n_classes, n_features])
+      priors_data = GRNEXUSMachineLearning.create_data([@priors], [@n_classes, 1])
+      
+      output_buffer = FFI::MemoryPointer.new(:double, n_samples)
+      output_data = GRNEXUSMachineLearning::GRNexusData.new
+      output_data[:data] = output_buffer
+      output_data[:size] = n_samples
+      output_data[:dims][0] = n_samples
+      
+      result = GRNEXUSMachineLearning.naive_bayes_predict(x_data, @n_classes, means_data, vars_data, priors_data, output_data)
+      raise "Naive Bayes prediction failed" if result != 0
+      
+      output_buffer.read_array_of_double(n_samples).map(&:to_i)
+    end
+  end
+end