grydra 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38aaecb86df2c74c04d634e4591f60332b56cf66054cc5b2a3fd9061c9d50908
-  data.tar.gz: 2616015ee7528c6d3b19af4f01bcc101134aa741ea4599b22df2dbe83308c8f1
+  metadata.gz: 1dd2702f2b578f025ffbfd0976838d42d7b63ac47bd218dfe43575139fbc3915
+  data.tar.gz: e93a2abc28eb742ea275dd33a089204ec0eb81ddd49d4dc6d4bcf6ea86f1c4db
 SHA512:
-  metadata.gz: a169a960e53bc33a2686ca1657b65c30a1b19a273d190c5e9100dce109f9ddba50a2c6d35c0883a026bb476e4c91768002b7b53f44f33b5a27cfe01850b5e925
-  data.tar.gz: 27668728857d9ad96f7d375b022c0f39f51fcf0cbb4e7daf145036029d34d052fbe51b669264a332caaac692ac134310193b44c2ea199c533321139156fabd50
+  metadata.gz: 0cd0cadf389f66840cdabcbc1bd98bbf333d9abcbff6e87f062833c5bb948a276f50871e9e76d2fa661e8b0ea90f7e049e288ab90c0fce442fc0aae6ac72f866
+  data.tar.gz: 3107d188445bf80c541aebaa34cb993203486b69be58dc74c7e9b852debbd91cb0948ed9c567467971f58288c8e002a78af94650e799aa5a1db115cbc7c5a7c5

data/lib/gr/core.rb

@@ -143,15 +143,18 @@ module GRYDRA
     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)
+    def initialize(estructura, imprimir_epocas = false, graficar = false, activaciones = nil)
       @imprimir_epocas = imprimir_epocas
+      @graficar = graficar
       @capas = []
+      @hitorial_error = []
       activaciones ||= Array.new(estructura.size - 1, :tanh)
       estructura.each_cons(2).with_index do |(entradas, salidas), i|
         @capas << CapaDensa.new(salidas, entradas, activaciones[i])
@@ -164,7 +167,7 @@ module GRYDRA
     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)
+    def entrenar(datos_entrada, datos_salida, tasa_aprendizaje, epocas, umbral_error = nil, batch_size: 1, paciencia: 50, decay: 0.95)
       mejor_error = Float::INFINITY
       contador_paciencia = 0
 
@@ -228,8 +231,12 @@ module GRYDRA
 
         tasa_aprendizaje *= decay
 
+        @hitorial_error << error_total if @graficar
+
         puts "Época #{epoca+1}, Error total: #{error_total.round(6)}, tasa_aprendizaje: #{tasa_aprendizaje.round(6)}" if @imprimir_epocas
+        
       end
+      GRYDRA.graficar_error(@hitorial_error) if @graficar
     end
 
     def info_red
@@ -268,13 +275,14 @@ module GRYDRA
   class RedPrincipal
     attr_accessor :subredes
 
-    def initialize(imprimir_epocas = false)
+    def initialize(imprimir_epocas = false, graficar = false)
       @subredes = []
       @imprimir_epocas = imprimir_epocas
+      @graficar = graficar
     end
 
     def agregar_subred(estructura, activaciones=nil)
-      @subredes << RedNeuronal.new(estructura, @imprimir_epocas, activaciones)
+      @subredes << RedNeuronal.new(estructura, @imprimir_epocas, @graficar, activaciones)
     end
 
     def entrenar_subredes(datos, tasa_aprendizaje, epocas, **opts)
@@ -399,8 +407,8 @@ module GRYDRA
   class FacilRed
     attr_accessor :red, :vocabulario, :max_valores, :max_valores_salida
 
-    def initialize(imprimir_epocas = false)
-      @red = GRYDRA::RedPrincipal.new(imprimir_epocas)
+    def initialize(imprimir_epocas = false, graficar = false)
+      @red = GRYDRA::RedPrincipal.new(imprimir_epocas, graficar)
       @vocabulario = nil
       @max_valores = {}
       @max_valores_salida = {}
@@ -617,7 +625,12 @@ module GRYDRA
         predicciones = red.predecir_texto(nuevos_textos)
       EX
     },
-
+    'GRYDRA.describe_metodo' => {
+      descripcion: 'Muestra ejemplo de instancia de una clase o metodo.',
+      ejemplo: <<~EX
+        GRYDRA.describe_metodo("GRYDRA", "guardar_modelo")
+      EX
+    },
     # Guardar y cargar modelos y vocabularios
     'GRYDRA.guardar_modelo' => {
       descripcion: 'Guarda el modelo entrenado en un archivo binario para poder cargarlo después. Opcionalmente guarda también el vocabulario.',
@@ -681,10 +694,47 @@ module GRYDRA
       EX
     },
     'GRYDRA.generar_ejemplo' => {
-      descripcion: 'Genera un ejemplo con código funcioanl con la libreria, con ejemplos del 1 al 9.',
+      descripcion: 'Genera un ejemplo de código funcional con la libreria, con ejemplos del 1 al 9.',
       ejemplo: <<~EX
         GRYDRA.generar_ejemplo(1)
       EX
+    },
+    'GRYDRA.sugerir_estructura' => {
+      descripcion: 'Sugiere automáticamente una posible estructura de red neuronal según la cantidad de entradas y salidas.',
+      ejemplo: <<~EX
+        estructura_sugerida = GRYDRA.sugerir_estructura(3, 1) Se pasan las entradas y salidas en numeros y te regresa una estructura que podras usar. 
+      EX
+    },
+    'GRYDRA.convertir_hashes_a_vectores' => {
+      descripcion: 'Convierte un arreglo de hashes (tipo JSON) a arreglos numéricos para entrenar.',
+      ejemplo: <<~EX
+        datos = [
+          { nombre: "A", edad: 20, vip: true },
+          { nombre: "B", edad: 30, vip: false }
+        ]
+        datos_vectores = GRYDRA.convertir_hashes_a_vectores(datos, [:edad, :vip])
+      EX
+    },
+    'GRYDRA.resumen_modelo' => {
+      descripcion: 'Muestra por consola las subredes, sus estructuras y funciones de activación de un modelo cargado.',
+      ejemplo: <<~EX
+        GRYDRA.resumen_modelo(modelo)
+      EX
+    },
+    'GRYDRA.validar_modelo' => {
+      descripcion: 'Verifica si un "modelo" es de verdad un modelo compatible.',
+      ejemplo: <<~EX
+        GRYDRA.validar_modelo(modelo)
+      EX
+    },
+    'GRYDRA.probar_todas_normalizaciones' =>{
+      descripcion: 'Prueba entrenamiento con :max y :zscore y muestra el error final con cada una.',
+      ejemplo: <<~EX
+        entradas = [[1], [2], [3]]
+        salidas = [[2], [4], [6]]
+        estructura = [[1, 3, 1]]
+        GRYDRA.probar_todas_normalizaciones(entradas, salidas, estructura)
+      EX
     }
   }
 
@@ -693,7 +743,7 @@ module GRYDRA
     clave = "#{clase}.#{metodo}"
     info = DESCRIPCIONES_METODOS[clave]
     if info
-      puts "\e[1;3;5;41;37mDescripción de #{clave}:"
+      puts "\e[1;3;5;37mDescripción de #{clave}:"
       puts info[:descripcion]
       puts "\nEjemplo de uso:"
       puts "#{info[:ejemplo]}\e[0m"
@@ -706,7 +756,7 @@ module GRYDRA
 
   # 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:"
+    puts "\e[1;3;5;37mMétodos públicos documentados:"
     grouped = DESCRIPCIONES_METODOS.keys.group_by { |k| k.split('.').first }
     grouped.each do |clase, metodos|
       puts "  #{clase}:"
@@ -744,7 +794,7 @@ datos_entrenamiento = [
 ]
 
 # Creamos el modelo
-modelo = GRYDRA::FacilRed.new(true)  # true para que imprima el error cada 1000 épocas
+modelo = GRYDRA::FacilRed.new(true, true)  # true para que imprima el error cada 1000 épocas y otro true para graficar
 
 # Entrenamos directamente usando datos tipo hash
 modelo.entrenar_hashes(
@@ -791,7 +841,7 @@ end
 require 'grydra'
 
 # Crear red principal
-red = GRYDRA::RedPrincipal.new #Sin el true, simplemente no se imprimen las epocas
+red = GRYDRA::RedPrincipal.new #Sin parametros, simplemente no se imprimen las epocas ni se grafica
 
 # Agregar una subred con estructura [2 entradas, 2 ocultas, 1 salida]
 red.agregar_subred([2, 3, 1], [:tanh, :tanh])
@@ -853,7 +903,7 @@ datos_in_no = GRYDRA.normalizar_varios(datos_in, max_in, :max)
 datos_ou_no = GRYDRA.normalizar_varios(datos_ou, max_ou, :max)
 
 # Crear red principal
-red_principal = GRYDRA::RedPrincipal.new
+red_principal = GRYDRA::RedPrincipal.new(false, true) #No imprime errores, pero si grafica
 
 # Agregar subredes
 red_principal.agregar_subred([1, 4, 1], [:sigmoid, :tanh])
@@ -901,7 +951,7 @@ tanto como uno quiera, ejemplo:
 0.003, 0.3, 0.9, 0.2, 0.223, 0.00008
 =end
 # Crear instancia de la clase FacilRed
-red = GRYDRA::FacilRed.new(true)  # true para imprimir las épocas y errores
+red = GRYDRA::FacilRed.new(true, true)  # true para imprimir las épocas y otro true para graficar
 
 # Datos originales (temperatura Celsius y Fahrenheit)
 datos_in = [[0], [10], [20], [30], [40], [50], [-10], [-20], [100], [-30], [-5], [-40]]
@@ -961,7 +1011,7 @@ estructuras = [
 ]
 
 # Crear red usando la interfaz fácil
-red = GRYDRA::FacilRed.new(true)  # true para que imprima error por época
+red = GRYDRA::FacilRed.new(true)  # true para que imprima solamente error por época
 
 # Entrenar la red
 red.entrenar_numericos(
@@ -1016,7 +1066,7 @@ estructuras = [
 ]
 
 # Crear red Fácil
-red = GRYDRA::FacilRed.new # true para ver el progreso de entrenamiento
+red = GRYDRA::FacilRed.new(true, true) # true para ver el progreso de entrenamiento y otro true para graficar
 
 # Vamos a asignar activación 'sigmoid' en la última capa para limitar la salida entre 0 y 1
 # Ajustamos internamente en el método agregar_subred
@@ -1140,5 +1190,103 @@ puts "Precio aproximado en dolares es de $\#{prediccion_desnorm.round(2)}"
       puts "Ejemplo generado y guardado en \e[33m#{File.join(path, nombre_archivo)}\e[0m"
     end
   end
-end
 
+  def self.sugerir_estructura(entradas, salidas = 1)
+    ocultas = [(entradas + salidas) * 2, (entradas + salidas)].uniq
+    [[entradas, *ocultas, salidas]]
+  end
+
+  def self.graficar_error(errores, imprimir_cada = 5, ancho_barra = 40, delta_min = 0.001)
+    max_error = errores.max
+    primer_error = errores.first
+
+    puts "\nGráfica de error por época"
+    puts "-" * (ancho_barra + 40)
+
+    ultima_impresa = nil
+
+    errores.each_with_index do |error, i|
+      epoca = i + 1
+      next unless epoca == 1 || epoca == errores.size || epoca % imprimir_cada == 0
+
+      if ultima_impresa && (ultima_impresa - error).abs < delta_min && epoca != errores.size
+        # Si la diferencia con la última impresa es menor al delta, saltamos
+        next
+      end
+
+      largo_barra = [(ancho_barra * error / max_error).round, 1].max
+      barra = "=" * largo_barra
+      mejora_pct = ((primer_error - error) / primer_error.to_f) * 100
+      mejora_str = mejora_pct >= 0 ? "+#{mejora_pct.round(2)}%" : "#{mejora_pct.round(2)}%"
+
+      puts "Época #{epoca.to_s.ljust(4)} | #{barra.ljust(ancho_barra)} | Error: #{error.round(6)} | Mejora: #{mejora_str}"
+
+      ultima_impresa = error
+    end
+
+    puts "-" * (ancho_barra + 40)
+    puts "Error inicial: #{primer_error.round(6)}, Error final: #{errores.last.round(6)}\n\n"
+  end
+
+  def self.convertir_hashes_a_vectores(array_hashes, claves)
+    array_hashes.map do |hash|
+      claves.map { |k| hash[k] ? (hash[k] == true ? 1.0 : hash[k] == false ? 0.0 : hash[k].to_f) : 0.0 }
+    end
+  end
+
+  def self.resumen_modelo(modelo, entrada_prueba = nil)
+    puts "\n\e[1;36mResumen del modelo:\e[0m"
+
+    # Por si es un envoltorio tipo FacilRed
+    if modelo.respond_to?(:red) && modelo.red.respond_to?(:subredes)
+      modelo = modelo.red
+    end
+
+    if modelo.respond_to?(:subredes)
+      modelo.subredes.each_with_index do |subred, i|
+        puts "\n Subred ##{i + 1}:"
+
+        estructura = subred.capas.map { |c| c.neuronas.size }
+        activaciones_ocultas = subred.capas[0...-1].map(&:activacion)
+        funcion_salida = subred.capas.last.activacion
+
+        puts "  - Estructura: #{estructura.inspect}"
+        puts "  - Activaciones ocultas: #{activaciones_ocultas.inspect}"
+        puts "  - Función de salida: #{funcion_salida.inspect}"
+
+        if entrada_prueba
+          begin
+            salida = subred.calcular_salidas(entrada_prueba)
+            puts "  - Salida numérica con entrada #{entrada_prueba.inspect}: #{salida.inspect}"
+          rescue => e
+            puts "  - Error al calcular salida: #{e.message}"
+          end
+        end
+      end
+    else
+      GRYDRA.validar_modelo(modelo)
+    end
+  end
+
+
+
+  def self.probar_todas_normalizaciones(entradas, salidas, estructuras)
+    [:max, :zscore].each do |tipo|
+      puts "\nProbando normalización: #{tipo}"
+      red = GRYDRA::FacilRed.new(false)
+      error_final = red.entrenar_numericos(entradas, salidas, estructuras, 0.1, 5000, tipo)
+      puts " Error final: #{error_final}"
+    end
+  end
+
+  def self.validar_modelo(modelo)
+    if modelo.nil?
+      puts "\e[31mError: modelo es nil\e[0m"
+    elsif modelo.is_a?(GRYDRA::FacilRed) || modelo.is_a?(GRYDRA::RedPrincipal)
+      puts "\e[32mModelo válido de tipo #{modelo.class}\e[0m"
+    else
+      puts "\e[33mAdvertencia: El modelo cargado no es una instancia conocida (#{modelo.class})\e[0m"
+    end
+  end
+
+end

data/lib/gr/version.rb

@@ -1,3 +1,3 @@
 module GR
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grydra
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Razo