grydra 1.0.0 → 2.0.1

data/lib/grydra/utils/examples.rb

@@ -0,0 +1,183 @@
+module GRYDRA
+  module Utils
+    module Examples
+      # Suggest network structure
+      def self.suggest_structure(inputs, outputs = 1)
+        hidden = [(inputs + outputs) * 2, (inputs + outputs)].uniq
+        [[inputs, *hidden, outputs]]
+      end
+
+      # Test all normalization methods
+      def self.test_all_normalizations(inputs, outputs, structures)
+        %i[max zscore].each do |type|
+          puts "\n🧪 Testing normalization: #{type}"
+          network = Networks::EasyNetwork.new(false)
+          network.train_numerical(inputs, outputs, structures, 0.1, 5000, type)
+          puts "  ✓ Training completed with #{type} normalization"
+        end
+      end
+
+      # Generate example code
+      def self.generate_example(num_example, filename = 'example', extension = 'rb', path = Dir.pwd)
+        content = get_example_content(num_example)
+        
+        unless content
+          puts "\e[1;35m⚠️  Available examples are from 1 to 12\e[0m"
+          return
+        end
+
+        File.write(File.join(path, "#{filename}.#{extension}"), content)
+        puts "✅ Example generated and saved to \e[33m#{File.join(path, filename)}.#{extension}\e[0m"
+      end
+
+      private
+
+      def self.get_example_content(num)
+        examples = {
+          1 => example_1_basic_training,
+          2 => example_2_load_and_predict,
+          3 => example_3_xor_problem,
+          4 => example_4_temperature_conversion,
+          5 => example_5_zscore_normalization,
+          6 => example_6_weight_prediction,
+          7 => example_7_advanced_weight,
+          8 => example_8_load_model,
+          9 => example_9_product_pricing,
+          10 => example_10_cross_validation,
+          11 => example_11_text_processing,
+          12 => example_12_classification_metrics
+        }
+        examples[num]
+      end
+
+      def self.example_1_basic_training
+        <<~RUBY
+          require 'grydra'
+          
+          # Training data
+          training_data = [
+            { name: "Company 1", num_employees: 5, is_new: false, site: true, label: 0 },
+            { name: "Company 2", num_employees: 4, is_new: true, site: false, label: 0 },
+            { name: "Company 3", num_employees: 4, is_new: false, site: false, label: 1 },
+            { name: "Company 4", num_employees: 20, is_new: false, site: false, label: 1 },
+            { name: "Company 5", num_employees: 60, is_new: false, site: false, label: 1 }
+          ]
+          
+          # Create and train model
+          model = GRYDRA::Networks::EasyNetwork.new(true, true)
+          model.configure_adam_optimizer(0.001, 0.9, 0.999)
+          
+          model.train_hashes(
+            training_data,
+            [:num_employees, :is_new, :site],
+            :label,
+            [[3, 4, 1]],
+            0.05,
+            12000,
+            :max,
+            lambda_l2: 0.001,
+            dropout: true,
+            dropout_rate: 0.3
+          )
+          
+          # Save model
+          GRYDRA::Utils::Persistence.save_model(model, "company_model")
+          puts "✅ Training completed!"
+        RUBY
+      end
+
+      def self.example_2_load_and_predict
+        <<~RUBY
+          require 'grydra'
+          
+          # Load model
+          model = GRYDRA::Utils::Persistence.load_model("company_model")
+          
+          # New data
+          new_data = [
+            { name: "New Company A", num_employees: 12, is_new: true, site: true },
+            { name: "New Company B", num_employees: 50, is_new: false, site: false }
+          ]
+          
+          # Predict
+          predictions = model.predict_hashes(new_data, [:num_employees, :is_new, :site])
+          
+          new_data.each_with_index do |company, i|
+            prediction = predictions[i].first.round(3)
+            label = prediction >= 0.5 ? 'Label 1 (Yes)' : 'Label 0 (No)'
+            puts "Company: \#{company[:name]} → Prediction: \#{prediction} (\#{label})"
+          end
+        RUBY
+      end
+
+      def self.example_3_xor_problem
+        <<~RUBY
+          require 'grydra'
+          
+          # XOR problem
+          network = GRYDRA::Networks::MainNetwork.new(true)
+          network.add_subnet([2, 3, 1], [:tanh, :tanh])
+          network.add_subnet([2, 4, 1], [:sigmoid, :sigmoid])
+          
+          inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
+          outputs = [[0], [1], [1], [0]]
+          
+          network.train_subnets(
+            [
+              {input: inputs, output: outputs},
+              {input: inputs, output: outputs}
+            ],
+            0.9,
+            6000,
+            batch_size: 1,
+            patience: 100,
+            decay: 0.995
+          )
+          
+          puts "\\n📊 XOR Evaluation:"
+          inputs.each do |input|
+            output = network.combine_results(input)
+            puts "Input: \#{input} => Output: \#{output.map { |v| v.round(3) }}"
+          end
+        RUBY
+      end
+
+      # Add more examples as needed...
+      def self.example_4_temperature_conversion
+        "# Temperature conversion example - See documentation"
+      end
+
+      def self.example_5_zscore_normalization
+        "# Z-score normalization example - See documentation"
+      end
+
+      def self.example_6_weight_prediction
+        "# Weight prediction example - See documentation"
+      end
+
+      def self.example_7_advanced_weight
+        "# Advanced weight prediction - See documentation"
+      end
+
+      def self.example_8_load_model
+        "# Load and use saved model - See documentation"
+      end
+
+      def self.example_9_product_pricing
+        "# Product pricing example - See documentation"
+      end
+
+      def self.example_10_cross_validation
+        "# Cross-validation example - See documentation"
+      end
+
+      def self.example_11_text_processing
+        "# Text processing with TF-IDF - See documentation"
+      end
+
+      def self.example_12_classification_metrics
+        "# Classification metrics example - See documentation"
+      end
+    end
+  end
+end

data/lib/grydra/utils/persistence.rb

@@ -0,0 +1,94 @@
+module GRYDRA
+  module Utils
+    module Persistence
+      # Save model to file
+      def self.save_model(model, name, path = Dir.pwd, vocabulary = nil)
+        file_path = File.join(path, "#{name}.net")
+        File.open(file_path, 'wb') { |f| Marshal.dump(model, f) }
+        puts "Model saved to '#{file_path}'"
+
+        save_vocabulary(vocabulary, name, path) if vocabulary
+      end
+
+      # Load model from file
+      def self.load_model(name, path = Dir.pwd)
+        model = nil
+        file_path = File.join(path, "#{name}.net")
+        File.open(file_path, 'rb') { |f| model = Marshal.load(f) }
+        model
+      end
+
+      # Save vocabulary to file
+      def self.save_vocabulary(vocabulary, name, path = Dir.pwd)
+        file_path = File.join(path, "#{name}_vocab.bin")
+        File.open(file_path, 'wb') { |f| Marshal.dump(vocabulary, f) }
+        puts "Vocabulary saved to '#{file_path}'"
+      end
+
+      # Load vocabulary from file
+      def self.load_vocabulary(name, path = Dir.pwd)
+        vocabulary = nil
+        file_path = File.join(path, "#{name}_vocab.bin")
+        File.open(file_path, 'rb') { |f| vocabulary = Marshal.load(f) }
+        vocabulary
+      end
+
+      # Validate model
+      def self.validate_model(model)
+        if model.nil?
+          puts "ERROR: model is nil"
+          false
+        elsif model.is_a?(Networks::EasyNetwork) || model.is_a?(Networks::MainNetwork)
+          puts "Valid model of type #{model.class}"
+          true
+        else
+          puts "WARNING: The loaded model is not a known instance (#{model.class})"
+          false
+        end
+      end
+
+      # Summary of model
+      def self.summary_model(model, input_test: nil)
+        puts "\nModel Summary:"
+        puts "=" * 60
+
+        model = model.network if model.respond_to?(:network) && model.network.respond_to?(:subnets)
+
+        if model.respond_to?(:subnets)
+          total_params = 0
+          
+          model.subnets.each_with_index do |subnet, i|
+            puts "\nSubnet ##{i + 1}:"
+            structure = subnet.layers.map { |l| l.neurons.size }
+            hidden_activations = subnet.layers[0...-1].map(&:activation)
+            output_function = subnet.layers.last.activation
+
+            subnet_params = subnet.layers.sum do |layer|
+              layer.neurons.sum { |n| n.weights.size + 1 }
+            end
+            total_params += subnet_params
+
+            puts "  Structure: #{structure.inspect}"
+            puts "  Hidden activations: #{hidden_activations.inspect}"
+            puts "  Output activation: #{output_function.inspect}"
+            puts "  Parameters: #{subnet_params}"
+
+            if input_test
+              begin
+                output = subnet.calculate_outputs(input_test)
+                puts "  Test output: #{output.map { |v| v.round(4) }.inspect}"
+              rescue StandardError => e
+                puts "  Error calculating output: #{e.message}"
+              end
+            end
+          end
+          
+          puts "\n" + "=" * 60
+          puts "Total parameters: #{total_params}"
+        else
+          validate_model(model)
+        end
+      end
+    end
+  end
+end

data/lib/grydra/utils/visualization.rb

@@ -0,0 +1,105 @@
+module GRYDRA
+  module Utils
+    module Visualization
+      # Plot error graph
+      def self.plot_error(errors, print_every: 5, bar_width: 40, delta_min: 0.001)
+        max_error = errors.max
+        first_error = errors.first
+
+        puts "\nTraining Error History"
+        puts '=' * (bar_width + 40)
+
+        last_printed = nil
+        errors.each_with_index do |error, i|
+          epoch = i + 1
+          next unless epoch == 1 || epoch == errors.size || epoch % print_every == 0
+
+          if last_printed && (last_printed - error).abs < delta_min && epoch != errors.size
+            next
+          end
+
+          bar_length = [(bar_width * error / max_error).round, 1].max
+          bar = '=' * bar_length
+          improvement_pct = ((first_error - error) / first_error.to_f) * 100
+          improvement_str = improvement_pct >= 0 ? "+#{improvement_pct.round(2)}%" : "#{improvement_pct.round(2)}%"
+
+          puts "Epoch #{epoch.to_s.ljust(4)} | #{bar.ljust(bar_width)} | Error: #{error.round(6)} | Improvement: #{improvement_str}"
+          last_printed = error
+        end
+
+        puts '=' * (bar_width + 40)
+        puts "Initial error: #{first_error.round(6)}, Final error: #{errors.last.round(6)}"
+        improvement = ((first_error - errors.last) / first_error * 100).round(2)
+        puts "Total improvement: #{improvement}%\n"
+      end
+
+      # Plot architecture in ASCII
+      def self.plot_architecture_ascii(model)
+        puts "\nNetwork Architecture:"
+        puts '=' * 60
+
+        if model.respond_to?(:subnets)
+          model.subnets.each_with_index do |subnet, idx|
+            puts "\n  Subnet #{idx + 1}:"
+            plot_individual_network(subnet)
+          end
+        else
+          plot_individual_network(model)
+        end
+
+        puts '=' * 60
+      end
+
+      def self.plot_individual_network(network)
+        network.layers.each_with_index do |layer, i|
+          neurons = layer.neurons.size
+          activation = layer.activation || :linear
+          params = layer.neurons.sum { |n| n.weights.size + 1 }
+
+          symbols = if neurons <= 10
+                      'O' * neurons
+                    else
+                      'O' * 8 + "... (#{neurons} neurons)"
+                    end
+
+          puts "  Layer #{i + 1}: #{symbols}"
+          puts "           Neurons: #{neurons}, Activation: #{activation}, Parameters: #{params}"
+          puts "           |" unless i == network.layers.size - 1
+          puts "           v" unless i == network.layers.size - 1
+        end
+      end
+
+      # Analyze gradients
+      def self.analyze_gradients(model)
+        gradients = []
+
+        if model.respond_to?(:layers)
+          model.layers.each do |layer|
+            layer.neurons.each do |neuron|
+              gradients << neuron.delta.abs if neuron.delta
+            end
+          end
+        elsif model.respond_to?(:subnets)
+          model.subnets.each do |subnet|
+            subnet.layers.each do |layer|
+              layer.neurons.each do |neuron|
+                gradients << neuron.delta.abs if neuron.delta
+              end
+            end
+          end
+        end
+
+        return { message: 'No gradients to analyze' } if gradients.empty?
+
+        average = gradients.sum / gradients.size.to_f
+        {
+          average: average,
+          maximum: gradients.max,
+          minimum: gradients.min,
+          deviation: Math.sqrt(gradients.map { |g| (g - average)**2 }.sum / gradients.size.to_f),
+          total_parameters: gradients.size
+        }
+      end
+    end
+  end
+end

data/lib/grydra/version.rb

@@ -0,0 +1,3 @@
+module GRYDRA
+  VERSION = "2.0.1"
+end

data/lib/grydra.rb

@@ -1,2 +1,162 @@
-require "gr/version"
-require "gr/core"  
+# frozen_string_literal: true
+
+require 'set'
+
+# GRYDRA - Complete Neural Network Library for Ruby
+module GRYDRA
+  # Core modules
+  require 'grydra/version'
+  require 'grydra/activations'
+  require 'grydra/initializers'
+  require 'grydra/regularization'
+  require 'grydra/normalization'
+  require 'grydra/metrics'
+  require 'grydra/optimizers'
+  require 'grydra/losses'
+  require 'grydra/callbacks'
+  
+  # Layers
+  require 'grydra/layers/base'
+  require 'grydra/layers/dense'
+  require 'grydra/layers/conv'
+  require 'grydra/layers/lstm'
+  
+  # Networks
+  require 'grydra/networks/neuron'
+  require 'grydra/networks/neural_network'
+  require 'grydra/networks/main_network'
+  require 'grydra/networks/easy_network'
+  
+  # Preprocessing
+  require 'grydra/preprocessing/data'
+  require 'grydra/preprocessing/text'
+  require 'grydra/preprocessing/pca'
+  
+  # Training
+  require 'grydra/training/cross_validation'
+  require 'grydra/training/hyperparameter_search'
+  
+  # Utils
+  require 'grydra/utils/visualization'
+  require 'grydra/utils/persistence'
+  require 'grydra/utils/examples'
+  require 'grydra/documentation'
+
+  # Backward compatibility aliases
+  class << self
+    # Activation functions
+    def tanh(x) = Activations.tanh(x)
+    def derivative_tanh(x) = Activations.derivative_tanh(x)
+    def relu(x) = Activations.relu(x)
+    def derivative_relu(x) = Activations.derivative_relu(x)
+    def sigmoid(x) = Activations.sigmoid(x)
+    def derivative_sigmoid(x) = Activations.derivative_sigmoid(x)
+    def softmax(vector) = Activations.softmax(vector)
+    def leaky_relu(x, alpha = 0.01) = Activations.leaky_relu(x, alpha)
+    def derivative_leaky_relu(x, alpha = 0.01) = Activations.derivative_leaky_relu(x, alpha)
+    def swish(x) = Activations.swish(x)
+    def derivative_swish(x) = Activations.derivative_swish(x)
+    def gelu(x) = Activations.gelu(x)
+    def derivative_gelu(x) = Activations.derivative_gelu(x)
+
+    # Regularization
+    def apply_dropout(outputs, dropout_rate = 0.5, training = true)
+      Regularization.apply_dropout(outputs, dropout_rate, training)
+    end
+    def l1_regularization(weights, lambda_l1) = Regularization.l1_regularization(weights, lambda_l1)
+    def l2_regularization(weights, lambda_l2) = Regularization.l2_regularization(weights, lambda_l2)
+
+    # Initializers
+    def xavier_init(num_inputs) = Initializers.xavier_init(num_inputs)
+    def he_init(num_inputs) = Initializers.he_init(num_inputs)
+
+    # Normalization
+    def zscore_normalize(data) = Normalization.zscore_normalize(data)
+    def zscore_denormalize(normalized, means, std_devs) = Normalization.zscore_denormalize(normalized, means, std_devs)
+    def min_max_normalize(data, min_val = 0, max_val = 1) = Normalization.min_max_normalize(data, min_val, max_val)
+    def normalize_multiple(data, max_values, method = :max) = Normalization.normalize_multiple(data, max_values, method)
+    def calculate_max_values(data, method = :max) = Normalization.calculate_max_values(data, method)
+
+    # Metrics
+    def mse(predictions, actuals) = Metrics.mse(predictions, actuals)
+    def mae(predictions, actuals) = Metrics.mae(predictions, actuals)
+    def precision(tp, fp) = Metrics.precision(tp, fp)
+    def recall(tp, fn) = Metrics.recall(tp, fn)
+    def f1(precision, recall) = Metrics.f1(precision, recall)
+    def confusion_matrix(predictions, actuals, threshold = 0.5) = Metrics.confusion_matrix(predictions, actuals, threshold)
+    def auc_roc(predictions, actuals) = Metrics.auc_roc(predictions, actuals)
+    def accuracy(predictions, actuals, threshold = 0.5) = Metrics.accuracy(predictions, actuals, threshold)
+
+    # Preprocessing
+    def split_data(data_x, data_y, training_ratio = 0.8, seed = nil)
+      Preprocessing::Data.split_data(data_x, data_y, training_ratio, seed)
+    end
+    def generate_synthetic_data(n_samples, n_features, noise = 0.1, seed = nil)
+      Preprocessing::Data.generate_synthetic_data(n_samples, n_features, noise, seed)
+    end
+    def convert_hashes_to_vectors(array_hashes, keys)
+      Preprocessing::Data.convert_hashes_to_vectors(array_hashes, keys)
+    end
+    def pca(data, components = 2) = Preprocessing::PCA.pca(data, components)
+
+    # Text preprocessing
+    def create_vocabulary(texts) = Preprocessing::Text.create_vocabulary(texts)
+    def create_advanced_vocabulary(texts, min_frequency = 1, max_words = nil)
+      Preprocessing::Text.create_advanced_vocabulary(texts, min_frequency, max_words)
+    end
+    def vectorize_text(text, vocabulary) = Preprocessing::Text.vectorize_text(text, vocabulary)
+    def vectorize_text_tfidf(text, vocabulary, corpus_frequencies)
+      Preprocessing::Text.vectorize_text_tfidf(text, vocabulary, corpus_frequencies)
+    end
+    def normalize_with_vocabulary(data, vocabulary) = Preprocessing::Text.normalize_with_vocabulary(data, vocabulary)
+
+    # Training
+    def cross_validation(data_input, data_output, k_folds = 5, &block)
+      Training::CrossValidation.cross_validation(data_input, data_output, k_folds, &block)
+    end
+    def hyperparameter_search(data_x, data_y, param_grid, &block)
+      Training::HyperparameterSearch.hyperparameter_search(data_x, data_y, param_grid, &block)
+    end
+
+    # Visualization
+    def plot_error(errors, print_every = 5, bar_width = 40, delta_min = 0.001)
+      Utils::Visualization.plot_error(errors, print_every, bar_width, delta_min)
+    end
+    def plot_architecture_ascii(model) = Utils::Visualization.plot_architecture_ascii(model)
+    def analyze_gradients(model) = Utils::Visualization.analyze_gradients(model)
+
+    # Persistence
+    def save_model(model, name, path = Dir.pwd, vocabulary = nil)
+      Utils::Persistence.save_model(model, name, path, vocabulary)
+    end
+    def load_model(name, path = Dir.pwd) = Utils::Persistence.load_model(name, path)
+    def save_vocabulary(vocabulary, name, path = Dir.pwd)
+      Utils::Persistence.save_vocabulary(vocabulary, name, path)
+    end
+    def load_vocabulary(name, path = Dir.pwd) = Utils::Persistence.load_vocabulary(name, path)
+    def validate_model(model) = Utils::Persistence.validate_model(model)
+    def summary_model(model, input_test = nil) = Utils::Persistence.summary_model(model, input_test)
+
+    # Examples and documentation
+    def suggest_structure(inputs, outputs = 1) = Utils::Examples.suggest_structure(inputs, outputs)
+    def test_all_normalizations(inputs, outputs, structures)
+      Utils::Examples.test_all_normalizations(inputs, outputs, structures)
+    end
+    def generate_example(num_example, filename = 'example', extension = 'rb', path = Dir.pwd)
+      Utils::Examples.generate_example(num_example, filename, extension, path)
+    end
+    def describe_method(class_name, method_name) = Documentation.describe_method(class_name, method_name)
+    def list_methods_available = Documentation.list_methods_available
+  end
+
+  # Legacy class aliases for backward compatibility
+  AdamOptimizer = Optimizers::Adam
+  Neuron = Networks::Neuron
+  Layer = Layers::Base
+  DenseLayer = Layers::Dense
+  ConvLayer = Layers::Conv
+  LSTMLayer = Layers::LSTM
+  NeuralNetwork = Networks::NeuralNetwork
+  MainNetwork = Networks::MainNetwork
+  EasyNetwork = Networks::EasyNetwork
+end