grydra 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e449d883a411813be922b8336a3e8044d33c36cbecc7590472cf98ba83d7bd24
+  data.tar.gz: d95118b578b70a82f539153a203be2afb11be345fc5bf317d010ea476b43225c
+SHA512:
+  metadata.gz: 83d5f6bad1790e03bd60cf59f061c4e1c3b23eef6dbd4e7a04d475b1262c9543a1cbea0188f6d84fde6de04e927142ef8f5d1f220784e12d7416ad002c06caab
+  data.tar.gz: 64b5c314cb50f51cc0c01ac6763c2a643442be772b96acbeed26f0c5cb3b54248452c31f4549e06008aa070fc53a9ac07217834b6fd93a6dd3e3b8aa9b1f27ec

data/lib/gr/core.rb

@@ -0,0 +1,698 @@
+module GR
+  require 'set'
+
+  ### FUNCIONES DE ACTIVACIÓN ###
+  def self.tanh(x)
+    Math.tanh(x)
+  end
+
+  def self.derivada_tanh(x)
+    1 - tanh(x)**2
+  end
+
+  def self.relu(x)
+    x > 0 ? x : 0
+  end
+
+  def self.derivada_relu(x)
+    x > 0 ? 1 : 0
+  end
+
+  def self.sigmoid(x)
+    1.0 / (1.0 + Math.exp(-x))
+  end
+
+  def self.derivada_sigmoid(x)
+    s = sigmoid(x)
+    s * (1 - s)
+  end
+
+  def self.softmax(vector)
+    max = vector.max
+    exps = vector.map { |v| Math.exp(v - max) }
+    sum = exps.sum
+    exps.map { |v| v / sum }
+  end
+
+  ### INICIALIZACIÓN XAVIER ###
+  def self.xavier_init(num_inputs)
+    limit = Math.sqrt(6.0 / num_inputs)
+    rand * 2 * limit - limit
+  end
+
+  ### NORMALIZACIÓN Z-SCORE ###
+  def self.normalizar_zscore(datos)
+    n = datos.size
+    medias = datos.first.size.times.map { |i| datos.map { |fila| fila[i] }.sum.to_f / n }
+    desviaciones = datos.first.size.times.map do |i|
+      m = medias[i]
+      Math.sqrt(datos.map { |fila| (fila[i] - m)**2 }.sum.to_f / n)
+    end
+    normalizados = datos.map do |fila|
+      fila.each_with_index.map { |valor, i| desviaciones[i] != 0 ? (valor - medias[i]) / desviaciones[i] : 0 }
+    end
+    return normalizados, medias, desviaciones
+  end
+
+  def self.desnormalizar_zscore(normalizados, medias, desviaciones)
+    normalizados.map do |fila|
+      fila.each_with_index.map { |valor, i| valor * desviaciones[i] + medias[i] }
+    end
+  end
+
+  ### MÉTRICAS DE EVALUACIÓN ###
+  def self.mse(predicciones, reales)
+    n = predicciones.size
+    sum = predicciones.zip(reales).map { |p, r| (p - r)**2 }.sum
+    sum / n.to_f
+  end
+
+  def self.mae(predicciones, reales)
+    n = predicciones.size
+    sum = predicciones.zip(reales).map { |p, r| (p - r).abs }.sum
+    sum / n.to_f
+  end
+
+  def self.precision(tp, fp)
+    tp.to_f / (tp + fp)
+  end
+
+  def self.recall(tp, fn)
+    tp.to_f / (tp + fn)
+  end
+
+  def self.f1(precision, recall)
+    2 * (precision * recall) / (precision + recall)
+  end
+
+  ### CLASE NEURONA ###
+  class Neurona
+    attr_accessor :pesos, :sesgo, :salida, :delta
+
+    def initialize(entradas, activacion=:tanh)
+      raise ArgumentError, "El número de entradas debe ser un entero positivo" unless entradas.is_a?(Integer) && entradas > 0
+      @pesos = Array.new(entradas) { GR.xavier_init(entradas) }
+      @sesgo = GR.xavier_init(entradas)
+      @salida = 0
+      @delta = 0
+      @activacion = activacion
+      @suma = 0
+    end
+
+    def calcular_salida(entradas)
+      raise ArgumentError, "Las entradas deben ser un array de números" unless entradas.is_a?(Array) && entradas.all? { |e| e.is_a?(Numeric) }
+      if @pesos.size != entradas.size
+        raise "Error: entradas (#{entradas.size}) no coinciden con pesos (#{@pesos.size})"
+      end
+      @suma = @pesos.zip(entradas).map { |peso, entrada| peso * entrada }.sum + @sesgo
+      @salida = case @activacion
+                when :tanh then GR.tanh(@suma)
+                when :relu then GR.relu(@suma)
+                when :sigmoid then GR.sigmoid(@suma)
+                else @suma
+                end
+      @salida
+    end
+
+    def derivada_activacion
+      case @activacion
+      when :tanh then GR.derivada_tanh(@salida)
+      when :relu then GR.derivada_relu(@salida)
+      when :sigmoid then GR.derivada_sigmoid(@suma)
+      else 1
+      end
+    end
+  end
+
+  ### CLASE CAPA BASE ###
+  class Capa
+    def calcular_salidas(entradas)
+      raise NotImplementedError, "Implementar en subclase"
+    end
+  end
+
+  ### CLASE CAPA DENSE ###
+  class CapaDensa < Capa
+    attr_accessor :neuronas, :activacion
+
+    def initialize(numero_neuronas, entradas_por_neurona, activacion=:tanh)
+      @activacion = activacion
+      @neuronas = Array.new(numero_neuronas) { Neurona.new(entradas_por_neurona, activacion) }
+    end
+
+    def calcular_salidas(entradas)
+      @neuronas.map { |neurona| neurona.calcular_salida(entradas) }
+    end
+  end
+
+  ### CLASE RED NEURONAL ###
+  class RedNeuronal
+    attr_accessor :capas
+
+    def initialize(estructura, imprimir_epocas = false, activaciones = nil)
+      @imprimir_epocas = imprimir_epocas
+      @capas = []
+      activaciones ||= Array.new(estructura.size - 1, :tanh)
+      estructura.each_cons(2).with_index do |(entradas, salidas), i|
+        @capas << CapaDensa.new(salidas, entradas, activaciones[i])
+      end
+    end
+
+    def calcular_salidas(entradas)
+      raise ArgumentError, "Entradas deben ser array de números" unless entradas.is_a?(Array) && entradas.all? { |e| e.is_a?(Numeric) }
+      @capas.inject(entradas) { |salidas, capa| capa.calcular_salidas(salidas) }
+    end
+
+    # Entrenamiento con mini-batch, early stopping, decay learning rate
+    def entrenar(datos_entrada, datos_salida, tasa_aprendizaje, epocas, umbral_error = nil, batch_size: 1, paciencia: 5, decay: 0.95)
+      mejor_error = Float::INFINITY
+      contador_paciencia = 0
+
+      epocas.times do |epoca|
+        error_total = 0
+
+        # Shuffle datos
+        indices = (0...datos_entrada.size).to_a.shuffle
+        datos_entrada = indices.map { |i| datos_entrada[i] }
+        datos_salida = indices.map { |i| datos_salida[i] }
+
+        datos_entrada.each_slice(batch_size).with_index do |batch_entradas, batch_idx|
+          batch_salidas_reales = datos_salida[batch_idx*batch_size, batch_size]
+
+          batch_entradas.zip(batch_salidas_reales).each do |entrada, salida_real|
+            salidas = calcular_salidas(entrada)
+            errores = salidas.zip(salida_real).map { |salida, real| real - salida }
+            error_total += errores.map { |e| e**2 }.sum / errores.size
+
+            # Capa salida
+            @capas.last.neuronas.each_with_index do |neurona, i|
+              neurona.delta = errores[i] * neurona.derivada_activacion
+            end
+
+            # Backpropagation capas ocultas
+            (@capas.size - 2).downto(0) do |i|
+              @capas[i].neuronas.each_with_index do |neurona, j|
+                sum_deltas = @capas[i + 1].neuronas.sum { |n| n.pesos[j] * n.delta }
+                neurona.delta = sum_deltas * neurona.derivada_activacion
+              end
+            end
+
+            # Actualización pesos y sesgo
+            @capas.each_with_index do |capa, idx|
+              entradas_capa = idx.zero? ? entrada : @capas[idx - 1].neuronas.map(&:salida)
+              capa.neuronas.each do |neurona|
+                neurona.pesos.each_with_index do |peso, i|
+                  neurona.pesos[i] += tasa_aprendizaje * neurona.delta * entradas_capa[i]
+                end
+                neurona.sesgo += tasa_aprendizaje * neurona.delta
+              end
+            end
+          end
+        end
+
+        if umbral_error && error_total < umbral_error
+          puts "Error umbral alcanzado en época #{epoca+1}: #{error_total}"
+          break
+        end
+
+        if error_total < mejor_error
+          mejor_error = error_total
+          contador_paciencia = 0
+        else
+          contador_paciencia += 1
+          if contador_paciencia >= paciencia
+            puts "Early stopping en época #{epoca+1}, error no mejora desde hace #{paciencia} épocas."
+            break
+          end
+        end
+
+        tasa_aprendizaje *= decay
+
+        puts "Época #{epoca+1}, Error total: #{error_total.round(6)}, tasa_aprendizaje: #{tasa_aprendizaje.round(6)}" if @imprimir_epocas
+      end
+    end
+
+    def info_red
+      puts "Red neuronal con #{@capas.size} capas:"
+      @capas.each_with_index do |capa, i|
+        puts " Capa #{i+1}: #{capa.neuronas.size} neuronas, activación: #{capa.activacion}"
+        capa.neuronas.each_with_index do |neurona, j|
+          puts "  Neurona #{j+1}: Pesos=#{neurona.pesos.map { |p| p.round(3) }}, Sesgo=#{neurona.sesgo.round(3)}"
+        end
+      end
+    end
+
+    # Exportar a DOT para Graphviz
+    def exportar_graphviz(nombre_archivo = "red_neuronal.dot")
+      File.open(nombre_archivo, "w") do |f|
+        f.puts "digraph RedNeuronal {"
+        @capas.each_with_index do |capa, i|
+          capa.neuronas.each_with_index do |neurona, j|
+            nodo = "C#{i}_N#{j}"
+            f.puts "  #{nodo} [label=\"N#{j+1}\"];"
+            if i < @capas.size - 1
+              @capas[i+1].neuronas.each_with_index do |sig_neurona, k|
+                peso = sig_neurona.pesos[j].round(3)
+                f.puts "  #{nodo} -> C#{i+1}_N#{k} [label=\"#{peso}\"];"
+              end
+            end
+          end
+        end
+        f.puts "}"
+      end
+      puts "Red exportada a #{nombre_archivo} (Graphviz DOT)"
+    end
+  end
+
+  ### RED PRINCIPAL ###
+  class RedPrincipal
+    attr_accessor :subredes
+
+    def initialize(imprimir_epocas = false)
+      @subredes = []
+      @imprimir_epocas = imprimir_epocas
+    end
+
+    def agregar_subred(estructura, activaciones=nil)
+      @subredes << RedNeuronal.new(estructura, @imprimir_epocas, activaciones)
+    end
+
+    def entrenar_subredes(datos, tasa_aprendizaje, epocas, **opts)
+      datos.each_with_index do |datos_subred, index|
+        puts "Entrenando Subred #{index + 1}..."
+        @subredes[index].entrenar(datos_subred[:entrada], datos_subred[:salida], tasa_aprendizaje, epocas, **opts)
+      end
+    end
+
+    def combinar_resultados(entrada_principal)
+      salidas_subredes = @subredes.map { |subred| subred.calcular_salidas(entrada_principal) }
+      salidas_subredes.transpose.map { |salidas| salidas.sum / salidas.size }
+    end
+  end
+
+  ### GUARDAR Y CARGAR MODELO Y VOCABULARIO ###
+  def self.guardar_modelo(modelo, nombre, path = File.dirname(__FILE__), vocabulario=nil)
+    File.open("#{nombre}.red", "wb") { |f| Marshal.dump(modelo, f) }
+    puts "\e[33mModelo guardado en '#{path}'\e[0m"
+    if vocabulario
+      guardar_vocabulario(vocabulario, nombre, path)
+    end
+  end
+
+  def self.cargar_modelo(nombre, path = File.dirname(__FILE__))
+    modelo = nil
+    File.open("#{nombre}.red", "rb") { |f| modelo = Marshal.load(f) }
+    modelo
+  end
+
+  def self.guardar_vocabulario(vocabulario, nombre, path = File.dirname(__FILE__))
+    File.open("#{nombre}_vocab.bin", "wb") { |f| Marshal.dump(vocabulario, f) }
+    puts "\e[33mVocabulario guardado en '#{path}'\e[0m"
+  end
+
+  def self.cargar_vocabulario(nombre, path = File.dirname(__FILE__))
+    vocabulario = nil
+    File.open("#{nombre}_vocab.bin", "rb") { |f| vocabulario = Marshal.load(f) }
+    vocabulario
+  end
+
+  ### PREPROCESAMIENTO ACTUALIZADO ###
+  def self.normalizar_varios(datos, maximos, metodo=:max)
+    case metodo
+    when :max
+      datos.map do |fila|
+        fila.each_with_index.map { |valor, idx| valor.to_f / maximos[idx] }
+      end
+    when :zscore
+      medias = maximos[:medias]
+      desviaciones = maximos[:desviaciones]
+      datos.map do |fila|
+        fila.each_with_index.map do |valor, idx|
+          desviaciones[idx] != 0 ? (valor.to_f - medias[idx]) / desviaciones[idx] : 0
+        end
+      end
+    else
+      raise "Método de normalización desconocido"
+    end
+  end
+
+  def self.calcular_maximos(datos, metodo=:max)
+    if metodo == :max
+      maximos = {}
+      datos.first.size.times do |i|
+        maximos[i] = datos.map { |fila| fila[i] }.max.to_f
+      end
+      maximos
+    elsif metodo == :zscore
+      medias = []
+      desviaciones = []
+      n = datos.size
+
+      medias = datos.first.size.times.map do |i|
+        datos.map { |fila| fila[i] }.sum.to_f / n
+      end
+
+      desviaciones = datos.first.size.times.map do |i|
+        m = medias[i]
+        Math.sqrt(datos.map { |fila| (fila[i] - m)**2 }.sum.to_f / n)
+      end
+      { medias: medias, desviaciones: desviaciones }
+    else
+      raise "Método desconocido para calcular máximos"
+    end
+  end
+
+  ### FUNCIONES DE TEXTO ###
+  def self.crear_vocabulario(textos)
+    textos.map(&:split).flatten.map(&:downcase).uniq
+  end
+
+  def self.vectorizar_texto(texto, vocabulario)
+    vector = Array.new(vocabulario.size, 0)
+    palabras = texto.downcase.split
+    palabras.each do |palabra|
+      indice = vocabulario.index(palabra)
+      vector[indice] = 1 if indice
+    end
+    vector
+  end
+
+  def self.normalizar_con_vocabulario(datos, vocabulario)
+    max_valor = vocabulario.size
+    datos.map { |vector| vector.map { |v| v.to_f / max_valor } }
+  end
+
+  ### CLASE FacilRed (sin cambios, solo agregando opción normalización zscore y activaciones) ###
+  class FacilRed
+    attr_accessor :red, :vocabulario, :max_valores, :max_valores_salida
+
+    def initialize(imprimir_epocas = false)
+      @red = GR::RedPrincipal.new(imprimir_epocas)
+      @vocabulario = nil
+      @max_valores = {}
+      @max_valores_salida = {}
+    end
+
+    # --------- Para datos tipo hash ---------
+    def entrenar_hashes(datos_hash, claves_entrada, clave_etiqueta, estructuras, tasa, epocas, normalizacion=:max)
+      @red.subredes.clear  # limpiar subredes previas
+
+      entradas = datos_hash.map do |item|
+        claves_entrada.map do |clave|
+          valor = item[clave]
+          valor == true ? 1.0 : valor == false ? 0.0 : valor.to_f
+        end
+      end
+
+      @max_valores = GR.calcular_maximos(entradas, normalizacion)
+
+      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+
+      etiquetas = datos_hash.map { |item| [item[clave_etiqueta].to_f] }
+
+      @max_valores_salida = GR.calcular_maximos(etiquetas, normalizacion)
+      etiquetas_no = GR.normalizar_varios(etiquetas, @max_valores_salida, normalizacion)
+
+      estructuras.each do |estructura|
+        @red.agregar_subred([claves_entrada.size, *estructura])
+      end
+
+      datos_para_subredes = estructuras.map do |_|
+        { entrada: datos_normalizados, salida: etiquetas_no }
+      end
+
+      @red.entrenar_subredes(datos_para_subredes, tasa, epocas)
+    end
+
+    def predecir_hashes(nuevos_hashes, claves_entrada, normalizacion=:max)
+      entradas = nuevos_hashes.map do |item|
+        claves_entrada.map do |clave|
+          valor = item[clave]
+          valor == true ? 1.0 : valor == false ? 0.0 : valor.to_f
+        end
+      end
+
+      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+
+      datos_normalizados.map do |entrada|
+        pred_norm = @red.combinar_resultados(entrada)
+        if normalizacion == :zscore && @max_valores_salida.is_a?(Hash)
+          pred_norm.map.with_index do |val, idx|
+            val * @max_valores_salida[:desviaciones][idx] + @max_valores_salida[:medias][idx]
+          end
+        else
+          pred_norm.map.with_index { |val, idx| val * @max_valores_salida[idx] }
+        end
+      end
+    end
+
+
+    # --------- Para datos numéricos ---------
+    def entrenar_numericos(datos_entrada, datos_salida, estructuras, tasa, epocas, normalizacion=:max)
+      @red.subredes.clear  # limpiar subredes previas
+
+      @max_valores = GR.calcular_maximos(datos_entrada, normalizacion)
+      @max_valores_salida = GR.calcular_maximos(datos_salida, normalizacion)
+
+      datos_entrada_no = GR.normalizar_varios(datos_entrada, @max_valores, normalizacion)
+      datos_salida_no = GR.normalizar_varios(datos_salida, @max_valores_salida, normalizacion)
+
+      estructuras.each do |estructura|
+        @red.agregar_subred([datos_entrada.first.size, *estructura])
+      end
+
+      datos_para_subredes = estructuras.map do |_|
+        { entrada: datos_entrada_no, salida: datos_salida_no }
+      end
+
+      @red.entrenar_subredes(datos_para_subredes, tasa, epocas)
+    end
+
+    def predecir_numericos(nuevos_datos, normalizacion=:max)
+      datos_normalizados = GR.normalizar_varios(nuevos_datos, @max_valores, normalizacion)
+      datos_normalizados.map do |entrada|
+        pred_norm = @red.combinar_resultados(entrada)
+        if normalizacion == :zscore && @max_valores_salida.is_a?(Hash)
+          pred_norm.map.with_index do |val, idx|
+            val * @max_valores_salida[:desviaciones][idx] + @max_valores_salida[:medias][idx]
+          end
+        else
+          pred_norm.map.with_index { |val, idx| val * @max_valores_salida[idx] }
+        end
+      end
+    end
+
+    # --------- Para texto ---------
+    def entrenar_texto(textos, etiquetas, estructuras, tasa, epocas, normalizacion=:max)
+      @red.subredes.clear  # limpiar subredes previas
+
+      @vocabulario = GR.crear_vocabulario(textos)
+      entradas = textos.map { |texto| GR.vectorizar_texto(texto, @vocabulario) }
+      @max_valores = { 0 => @vocabulario.size } # Solo tamaño vocabulario para texto
+
+      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+
+      @max_valores_salida = GR.calcular_maximos(etiquetas, normalizacion)
+      etiquetas_no = GR.normalizar_varios(etiquetas, @max_valores_salida, normalizacion)
+
+      estructuras.each do |estructura|
+        @red.agregar_subred([@vocabulario.size, *estructura])
+      end
+
+      datos_para_subredes = estructuras.map do |_|
+        { entrada: datos_normalizados, salida: etiquetas_no }
+      end
+
+      @red.entrenar_subredes(datos_para_subredes, tasa, epocas)
+    end
+
+    def predecir_texto(nuevos_textos, normalizacion=:max)
+      entradas = nuevos_textos.map { |texto| GR.vectorizar_texto(texto, @vocabulario) }
+      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+
+      datos_normalizados.map do |entrada|
+        pred_norm = @red.combinar_resultados(entrada)
+        if normalizacion == :zscore && @max_valores_salida.is_a?(Hash)
+          pred_norm.map.with_index do |val, idx|
+            val * @max_valores_salida[:desviaciones][idx] + @max_valores_salida[:medias][idx]
+          end
+        else
+          pred_norm.map.with_index { |val, idx| val * @max_valores_salida[idx] }
+        end
+      end
+    end
+  end
+  DESCRIPCIONES_METODOS = {
+    # RedPrincipal
+    'RedPrincipal.agregar_subred' => {
+      descripcion: "Agrega una subred a la red principal con la estructura dada. La estructura define el número de neuronas por capa (incluyendo entradas).",
+      ejemplo: <<~EX
+        red = GR::RedPrincipal.new
+        red.agregar_subred([2, 4, 1]) # 2 entradas, 4 neuronas capa oculta, 1 salida
+      EX
+    }, #34,36
+    'RedPrincipal.entrenar_subredes' => {
+      descripcion: "Entrena todas las subredes usando los datos de entrada y salida, con tasa de aprendizaje, épocas y opciones como paciencia para early stopping.",
+      ejemplo: <<~EX 
+        datos = [
+          {entrada: [[0.1, 0.2]], salida: [[0.3]]},
+          {entrada: [[0.5, 0.6]], salida: [[0.7]]}
+        ]
+        red = GR::RedPrincipal.new(true) <-- (true) es para que impriam el umbral de error
+        red.agregar_subred([2, 3, 1])
+        red.agregar_subred([2, 2, 1])
+        red.entrenar_subredes(datos, 0.01, 1000, paciencia: 5)
+      EX
+    },
+    'RedPrincipal.combinar_resultados' => {
+      descripcion: 'Promedia las salidas de todas las subredes para una entrada dada, generando la predicción final.',
+      ejemplo: <<~EX
+        resultado = red.combinar_resultados([0.2, 0.8]) 
+      EX
+    },
+
+    # FacilRed (interfaz más sencilla)
+    'FacilRed.entrenar_numericos' => {
+      descripcion: 'Entrena la red con datos numéricos (arrays de números) para entrada y salida. Normaliza, crea subredes y entrena.',
+      ejemplo: <<~EX
+        datos_entrada = [[170, 25], [160, 30], [180, 22]]
+        datos_salida = [[65], [60], [75]]
+        estructuras = [[4, 1], [3, 1]]
+        red = GR::FacilRed.new(true)
+        red.entrenar_numericos(datos_entrada, datos_salida, estructuras, 0.05, 15000, :max)
+      EX
+    },
+    'FacilRed.predecir_numericos' => {
+      descripcion: 'Predice valores con nuevos datos numéricos normalizados igual que el entrenamiento.',
+      ejemplo: <<~EX
+        nuevos_datos = [[172, 26]]
+        predicciones = red.predecir_numericos(nuevos_datos, :max)
+      EX
+    },
+    'FacilRed.entrenar_hashes' => {
+      descripcion: 'Entrena la red con datos de entrada en formato hash, especificando las claves a usar y la clave para la etiqueta.',
+      ejemplo: <<~EX
+        datos_hash = [
+          {altura: 170, edad: 25, peso: 65},
+          {altura: 160, edad: 30, peso: 60}
+        ]
+        red = GR::FacilRed.new(true) <-- (true) es para que impriam el umbral de error
+        red.entrenar_hashes(datos_hash, [:altura, :edad], :peso, [[4, 1]], 0.05, 15000, :max)
+      EX
+    },
+    'FacilRed.predecir_hashes' => {
+      descripcion: 'Predice usando datos hash con las claves especificadas para entrada.',
+      ejemplo: <<~EX
+        nuevos_hashes = [{altura: 172, edad: 26}]
+        predicciones = red.predecir_hashes(nuevos_hashes, [:altura, :edad], :max)
+      EX
+    },
+    'FacilRed.entrenar_texto' => {
+      descripcion: 'Entrena la red con textos y etiquetas numéricas, creando un vocabulario para vectorizar textos.',
+      ejemplo: <<~EX
+        textos = ["hola mundo", "buen día"]
+        etiquetas = [[1], [0]]
+        estructuras = [[5, 1]]
+        red = GR::FacilRed.new(true)
+        red.entrenar_texto(textos, etiquetas, estructuras, 0.01, 5000)
+      EX
+    },
+    'FacilRed.predecir_texto' => {
+      descripcion: 'Predice con nuevos textos, vectorizando según el vocabulario aprendido.',
+      ejemplo: <<~EX
+        nuevos_textos = ["hola"]
+        predicciones = red.predecir_texto(nuevos_textos)
+      EX
+    },
+
+    # Guardar y cargar modelos y vocabularios
+    'GR.guardar_modelo' => {
+      descripcion: 'Guarda el modelo entrenado en un archivo binario para poder cargarlo después. Opcionalmente guarda también el vocabulario.',
+      ejemplo: <<~EX
+        GR.guardar_modelo(modelo, "mi_modelo", "./modelos", vocabulario) El path por defecto es la carpeta donde se este ejecunatdo
+      EX
+    },
+    'GR.cargar_modelo' => {
+      descripcion: 'Carga un modelo guardado desde un archivo binario para usarlo sin entrenar de nuevo.',
+      ejemplo: <<~EX
+        modelo = GR.cargar_modelo("mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecunatdo
+      EX
+    },
+    'GR.guardar_vocabulario' => {
+      descripcion: 'Guarda el vocabulario en un archivo binario para su posterior carga.',
+      ejemplo: <<~EX
+        GR.guardar_vocabulario(vocabulario, "mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecunatdo
+      EX
+    },
+    'GR.cargar_vocabulario' => {
+      descripcion: 'Carga el vocabulario desde un archivo binario guardado.',
+      ejemplo: <<~EX
+        vocabulario = GR.cargar_vocabulario("mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecunatdo
+      EX
+    },
+
+    # Normalización y preprocesamiento
+    'GR.normalizar_varios' => {
+      descripcion: 'Normaliza un conjunto de datos según el método especificado (:max o :zscore).',
+      ejemplo: <<~EX
+        maximos = GR.calcular_maximos(datos, :max)
+        datos_norm = GR.normalizar_varios(datos, maximos, :max)
+      EX
+    },
+    'GR.calcular_maximos' => {
+      descripcion: 'Calcula valores máximos o medias y desviaciones según el método para normalizar datos.',
+      ejemplo: <<~EX
+        maximos = GR.calcular_maximos(datos, :max)
+        estadisticas = GR.calcular_maximos(datos, :zscore)
+      EX
+    },
+
+    # Funciones de texto
+    'GR.crear_vocabulario' => {
+      descripcion: 'Crea un vocabulario único a partir de una lista de textos, separando palabras.',
+      ejemplo: <<~EX
+        textos = ["hola mundo", "buen día"]
+        vocabulario = GR.crear_vocabulario(textos)
+      EX
+    },
+    'GR.vectorizar_texto' => {
+      descripcion: 'Convierte un texto en un vector binario basado en la presencia de palabras en el vocabulario.',
+      ejemplo: <<~EX
+        vector = GR.vectorizar_texto("hola mundo", vocabulario)
+      EX
+    },
+    'GR.normalizar_con_vocabulario' => {
+      descripcion: 'Normaliza vectores generados con el vocabulario dividiendo entre el tamaño del vocabulario.',
+      ejemplo: <<~EX
+        vectores_norm = GR.normalizar_con_vocabulario(vectores, vocabulario)
+      EX
+    }
+  }
+
+  # Función para mostrar descripción y ejemplo de método dado clase y método (strings)
+  def self.describe_metodo(clase, metodo)
+    clave = "#{clase}.#{metodo}"
+    info = DESCRIPCIONES_METODOS[clave]
+    if info
+      puts "\e[1;3;5;41;37mDescripción de #{clave}:"
+      puts info[:descripcion]
+      puts "\nEjemplo de uso:"
+      puts "#{info[:ejemplo]}\e[0m"
+    else
+      puts "\e[31;1mNo se encontró descripción para el método '#{clave}'"
+      puts "\e[31mAsegúrate de usar el nombre exacto de clase y método (como strings)"
+      puts "\e[36mPuedes llamar el metodo para verificar: listar_metodos_disponibles\e[0m"
+    end
+  end
+
+  # Función que lista todos los métodos públicos documentados en DESCRIPCIONES_METODOS
+  def self.listar_metodos_disponibles
+    puts "\e[1;3;5;41;37mMétodos públicos documentados:"
+    grouped = DESCRIPCIONES_METODOS.keys.group_by { |k| k.split('.').first }
+    grouped.each do |clase, metodos|
+      puts "  #{clase}:"
+      metodos.each { |m| puts "    - #{m.split('.').last}" }
+    end
+    print "\e[0m"
+  end
+end

data/lib/gr/version.rb

@@ -0,0 +1,3 @@
+module Gr
+  VERSION = "0.1.2"
+end

data/lib/grydra.rb

@@ -0,0 +1,2 @@
+require "gr/version"
+require "gr/core"  

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: grydra
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Razo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Implementación de redes neuronales con clases para neuronas y poder crear
+  redes neuronales, con diferentes metodos de activacion como Tanh, Relu y Sigmoid
+email:
+- garabatoangelopolis@email.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gr/core.rb
+- lib/gr/version.rb
+- lib/grydra.rb
+homepage: https://rubygems.org/gems/gr
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Librería para redes neuronales en Ruby
+test_files: []