grydra 0.1.4 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37dd8b10192bf544515650cdfa80a827412a157cab145b7fade5f83bacfa1b62
-  data.tar.gz: f6732dd3b23cdde33299c5507fd25899266d768aceb057f495306edfe727bf3a
+  metadata.gz: 38aaecb86df2c74c04d634e4591f60332b56cf66054cc5b2a3fd9061c9d50908
+  data.tar.gz: 2616015ee7528c6d3b19af4f01bcc101134aa741ea4599b22df2dbe83308c8f1
 SHA512:
-  metadata.gz: 506d94b9db23945c3dbf28bb8b7cfd26bb0aff454cd6e2ebdf1cdddfc88751ce2dd25bbd72960cf79f8ca63b88eb31f7195c2be6fec886a987d16b4baa52cc20
-  data.tar.gz: 1a229b7c8d7d59f68418e953a99e75852dc4156fd9cb70ea874943a2dbfbf7601e4e2e54ce09e85325f16d6496fd3462e0facf71a9c3c99966485c7582ebd48a
+  metadata.gz: a169a960e53bc33a2686ca1657b65c30a1b19a273d190c5e9100dce109f9ddba50a2c6d35c0883a026bb476e4c91768002b7b53f44f33b5a27cfe01850b5e925
+  data.tar.gz: 27668728857d9ad96f7d375b022c0f39f51fcf0cbb4e7daf145036029d34d052fbe51b669264a332caaac692ac134310193b44c2ea199c533321139156fabd50

data/lib/gr/core.rb

@@ -1,4 +1,4 @@
-module GR
+module GRYDRA
   require 'set'
 
   ### FUNCIONES DE ACTIVACIÓN ###
@@ -91,8 +91,8 @@ module GR
 
     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)
+      @pesos = Array.new(entradas) { GRYDRA.xavier_init(entradas) }
+      @sesgo = GRYDRA.xavier_init(entradas)
       @salida = 0
       @delta = 0
       @activacion = activacion
@@ -106,9 +106,9 @@ module GR
       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)
+                when :tanh then GRYDRA.tanh(@suma)
+                when :relu then GRYDRA.relu(@suma)
+                when :sigmoid then GRYDRA.sigmoid(@suma)
                 else @suma
                 end
       @salida
@@ -116,9 +116,9 @@ module GR
 
     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)
+      when :tanh then GRYDRA.derivada_tanh(@salida)
+      when :relu then GRYDRA.derivada_relu(@salida)
+      when :sigmoid then GRYDRA.derivada_sigmoid(@suma)
       else 1
       end
     end
@@ -291,31 +291,44 @@ module GR
   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"
+  def self.guardar_modelo(modelo, nombre, path = Dir.pwd, vocabulario = nil)
+    ruta_archivo = File.join(path, "#{nombre}.red")
+
+    # Abre el archivo en modo escritura binaria y guarda el objeto serializado
+    File.open(ruta_archivo, "wb") { |f| Marshal.dump(modelo, f) }
+
+    puts "\e[33mModelo guardado en '#{ruta_archivo}'\e[0m"
+
+    # Si se pasa vocabulario, se delega guardarlo en otra función
     if vocabulario
       guardar_vocabulario(vocabulario, nombre, path)
     end
   end
 
-  def self.cargar_modelo(nombre, path = File.dirname(__FILE__))
+
+  def self.cargar_modelo(nombre, path = Dir.pwd)
     modelo = nil
-    File.open("#{nombre}.red", "rb") { |f| modelo = Marshal.load(f) }
+    ruta_archivo = File.join(path, "#{nombre}.red")
+    File.open(ruta_archivo, "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"
+
+  def self.guardar_vocabulario(vocabulario, nombre, path = Dir.pwd)
+    ruta_archivo = File.join(path, "#{nombre}_vocab.bin")
+    File.open(ruta_archivo, "wb") { |f| Marshal.dump(vocabulario, f) }
+    puts "\e[33mVocabulario guardado en '#{ruta_archivo}'\e[0m"
   end
 
-  def self.cargar_vocabulario(nombre, path = File.dirname(__FILE__))
+
+  def self.cargar_vocabulario(nombre, path = Dir.pwd)
     vocabulario = nil
-    File.open("#{nombre}_vocab.bin", "rb") { |f| vocabulario = Marshal.load(f) }
+    ruta_archivo = File.join(path, "#{nombre}_vocab.bin")
+    File.open(ruta_archivo, "rb") { |f| vocabulario = Marshal.load(f) }
     vocabulario
   end
 
+
   ### PREPROCESAMIENTO ACTUALIZADO ###
   def self.normalizar_varios(datos, maximos, metodo=:max)
     case metodo
@@ -387,7 +400,7 @@ module GR
     attr_accessor :red, :vocabulario, :max_valores, :max_valores_salida
 
     def initialize(imprimir_epocas = false)
-      @red = GR::RedPrincipal.new(imprimir_epocas)
+      @red = GRYDRA::RedPrincipal.new(imprimir_epocas)
       @vocabulario = nil
       @max_valores = {}
       @max_valores_salida = {}
@@ -404,14 +417,14 @@ module GR
         end
       end
 
-      @max_valores = GR.calcular_maximos(entradas, normalizacion)
+      @max_valores = GRYDRA.calcular_maximos(entradas, normalizacion)
 
-      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+      datos_normalizados = GRYDRA.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)
+      @max_valores_salida = GRYDRA.calcular_maximos(etiquetas, normalizacion)
+      etiquetas_no = GRYDRA.normalizar_varios(etiquetas, @max_valores_salida, normalizacion)
 
       estructuras.each do |estructura|
         @red.agregar_subred([claves_entrada.size, *estructura])
@@ -432,7 +445,7 @@ module GR
         end
       end
 
-      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+      datos_normalizados = GRYDRA.normalizar_varios(entradas, @max_valores, normalizacion)
 
       datos_normalizados.map do |entrada|
         pred_norm = @red.combinar_resultados(entrada)
@@ -451,11 +464,11 @@ module GR
     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)
+      @max_valores = GRYDRA.calcular_maximos(datos_entrada, normalizacion)
+      @max_valores_salida = GRYDRA.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)
+      datos_entrada_no = GRYDRA.normalizar_varios(datos_entrada, @max_valores, normalizacion)
+      datos_salida_no = GRYDRA.normalizar_varios(datos_salida, @max_valores_salida, normalizacion)
 
       estructuras.each do |estructura|
         @red.agregar_subred([datos_entrada.first.size, *estructura])
@@ -469,7 +482,7 @@ module GR
     end
 
     def predecir_numericos(nuevos_datos, normalizacion=:max)
-      datos_normalizados = GR.normalizar_varios(nuevos_datos, @max_valores, normalizacion)
+      datos_normalizados = GRYDRA.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)
@@ -486,14 +499,14 @@ module GR
     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) }
+      @vocabulario = GRYDRA.crear_vocabulario(textos)
+      entradas = textos.map { |texto| GRYDRA.vectorizar_texto(texto, @vocabulario) }
       @max_valores = { 0 => @vocabulario.size } # Solo tamaño vocabulario para texto
 
-      datos_normalizados = GR.normalizar_varios(entradas, @max_valores, normalizacion)
+      datos_normalizados = GRYDRA.normalizar_varios(entradas, @max_valores, normalizacion)
 
-      @max_valores_salida = GR.calcular_maximos(etiquetas, normalizacion)
-      etiquetas_no = GR.normalizar_varios(etiquetas, @max_valores_salida, normalizacion)
+      @max_valores_salida = GRYDRA.calcular_maximos(etiquetas, normalizacion)
+      etiquetas_no = GRYDRA.normalizar_varios(etiquetas, @max_valores_salida, normalizacion)
 
       estructuras.each do |estructura|
         @red.agregar_subred([@vocabulario.size, *estructura])
@@ -507,8 +520,8 @@ module GR
     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)
+      entradas = nuevos_textos.map { |texto| GRYDRA.vectorizar_texto(texto, @vocabulario) }
+      datos_normalizados = GRYDRA.normalizar_varios(entradas, @max_valores, normalizacion)
 
       datos_normalizados.map do |entrada|
         pred_norm = @red.combinar_resultados(entrada)
@@ -527,7 +540,7 @@ module GR
     '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 = GRYDRA::RedPrincipal.new
         red.agregar_subred([2, 4, 1]) # 2 entradas, 4 neuronas capa oculta, 1 salida
       EX
     }, #34,36
@@ -538,7 +551,7 @@ module GR
           {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 imprima el umbral de error
+        red = GRYDRA::RedPrincipal.new(true) <-- (true) es para que imprima 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)
@@ -558,7 +571,7 @@ module GR
         datos_entrada = [[170, 25], [160, 30], [180, 22]]
         datos_salida = [[65], [60], [75]]
         estructuras = [[4, 1], [3, 1]]
-        red = GR::FacilRed.new(true)
+        red = GRYDRA::FacilRed.new(true)
         red.entrenar_numericos(datos_entrada, datos_salida, estructuras, 0.05, 15000, :max)
       EX
     },
@@ -576,7 +589,7 @@ module GR
           {altura: 170, edad: 25, peso: 65},
           {altura: 160, edad: 30, peso: 60}
         ]
-        red = GR::FacilRed.new(true) <-- (true) es para que imprima el umbral de error
+        red = GRYDRA::FacilRed.new(true) <-- (true) es para que imprima el umbral de error
         red.entrenar_hashes(datos_hash, [:altura, :edad], :peso, [[4, 1]], 0.05, 15000, :max)
       EX
     },
@@ -593,7 +606,7 @@ module GR
         textos = ["hola mundo", "buen día"]
         etiquetas = [[1], [0]]
         estructuras = [[5, 1]]
-        red = GR::FacilRed.new(true)
+        red = GRYDRA::FacilRed.new(true)
         red.entrenar_texto(textos, etiquetas, estructuras, 0.01, 5000)
       EX
     },
@@ -606,71 +619,71 @@ module GR
     },
 
     # Guardar y cargar modelos y vocabularios
-    'GR.guardar_modelo' => {
+    'GRYDRA.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
+        GRYDRA.guardar_modelo(modelo, "mi_modelo", "./modelos", vocabulario) El path por defecto es la carpeta donde se este ejecutando
       EX
     },
-    'GR.cargar_modelo' => {
+    'GRYDRA.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
+        modelo = GRYDRA.cargar_modelo("mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecutando
       EX
     },
-    'GR.guardar_vocabulario' => {
+    'GRYDRA.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
+        GRYDRA.guardar_vocabulario(vocabulario, "mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecutando
       EX
     },
-    'GR.cargar_vocabulario' => {
+    'GRYDRA.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
+        vocabulario = GRYDRA.cargar_vocabulario("mi_modelo", "./modelos") El path por defecto es la carpeta donde se este ejecutando
       EX
     },
 
     # Normalización y preprocesamiento
-    'GR.normalizar_varios' => {
+    'GRYDRA.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)
+        maximos = GRYDRA.calcular_maximos(datos, :max)
+        datos_norm = GRYDRA.normalizar_varios(datos, maximos, :max)
       EX
     },
-    'GR.calcular_maximos' => {
+    'GRYDRA.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)
+        maximos = GRYDRA.calcular_maximos(datos, :max)
+        estadisticas = GRYDRA.calcular_maximos(datos, :zscore)
       EX
     },
 
     # Funciones de texto
-    'GR.crear_vocabulario' => {
+    'GRYDRA.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)
+        vocabulario = GRYDRA.crear_vocabulario(textos)
       EX
     },
-    'GR.vectorizar_texto' => {
+    'GRYDRA.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)
+        vector = GRYDRA.vectorizar_texto("hola mundo", vocabulario)
       EX
     },
-    'GR.normalizar_con_vocabulario' => {
+    'GRYDRA.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)
+        vectores_norm = GRYDRA.normalizar_con_vocabulario(vectores, vocabulario)
       EX
     },
-    'GR.generar_ejemplo' => {
+    'GRYDRA.generar_ejemplo' => {
       descripcion: 'Genera un ejemplo con código funcioanl con la libreria, con ejemplos del 1 al 9.',
       ejemplo: <<~EX
-        GR.generar_ejemplo(1)
+        GRYDRA.generar_ejemplo(1)
       EX
     }
   }
@@ -703,7 +716,7 @@ module GR
   end
 
   #Función para generar ejemplos de uso con la libreria
-  def self.generar_ejemplo(num_ejemplo, nombre_archivo = "ejemplo", extension = "rb", path = File.dirname(__FILE__))
+  def self.generar_ejemplo(num_ejemplo, nombre_archivo = "ejemplo", extension = "rb", path = Dir.pwd)
     case num_ejemplo
     when 1
       contenido = <<-RUBY
@@ -731,7 +744,7 @@ datos_entrenamiento = [
 ]
 
 # Creamos el modelo
-modelo = GR::FacilRed.new(true)  # true para que imprima el error cada 1000 épocas
+modelo = GRYDRA::FacilRed.new(true)  # true para que imprima el error cada 1000 épocas
 
 # Entrenamos directamente usando datos tipo hash
 modelo.entrenar_hashes(
@@ -745,7 +758,7 @@ modelo.entrenar_hashes(
 
 
 # Guardamos el modelo entrenado
-GR.guardar_modelo(modelo, "modelo_empresas")
+GRYDRA.guardar_modelo(modelo, "modelo_empresas")
 
 puts "Entrenamiento completado y modelo guardado exitosamente." #Mensaje de depuración para comprobar la ejecución adecuada 
         RUBY
@@ -753,7 +766,7 @@ puts "Entrenamiento completado y modelo guardado exitosamente." #Mensaje de depu
       contenido = <<-RUBY
 require 'grydra'
 modelo = nil
-modelo = GR.cargar_modelo("modelo_empresas")
+modelo = GRYDRA.cargar_modelo("modelo_empresas")
 
 # Nuevos datos de empresas a evaluar
 nuevos_datos = [
@@ -778,7 +791,7 @@ end
 require 'grydra'
 
 # Crear red principal
-red = GR::RedPrincipal.new #Sin el true, simplemente no se imprimen las epocas
+red = GRYDRA::RedPrincipal.new #Sin el true, simplemente no se imprimen las epocas
 
 # Agregar una subred con estructura [2 entradas, 2 ocultas, 1 salida]
 red.agregar_subred([2, 3, 1], [:tanh, :tanh])
@@ -832,15 +845,15 @@ datos_in = [[0], [10], [20], [30], [40], [50], [-10], [-20], [100], [-30], [-5],
 datos_ou = [[32], [50], [68], [86], [104], [122], [14], [-4], [212], [-22], [23], [-40]]
 
 # Encontrar valores máximos para normalizar (método :max)
-max_in = GR.calcular_maximos(datos_in, :max)  # {0 => valor}
-max_ou = GR.calcular_maximos(datos_ou, :max)  # {0 => valor}
+max_in = GRYDRA.calcular_maximos(datos_in, :max)  # {0 => valor}
+max_ou = GRYDRA.calcular_maximos(datos_ou, :max)  # {0 => valor}
 
 # Normalizar datos
-datos_in_no = GR.normalizar_varios(datos_in, max_in, :max)
-datos_ou_no = GR.normalizar_varios(datos_ou, max_ou, :max)
+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 = GR::RedPrincipal.new
+red_principal = GRYDRA::RedPrincipal.new
 
 # Agregar subredes
 red_principal.agregar_subred([1, 4, 1], [:sigmoid, :tanh])
@@ -867,7 +880,7 @@ entrada_usuario = gets.chomp.split.map(&:to_f)
 
 # Normalizar entradas
 entrada_usuario_no = entrada_usuario.map { |e| [e] }
-entrada_usuario_no = GR.normalizar_varios(entrada_usuario_no, max_in, :max)
+entrada_usuario_no = GRYDRA.normalizar_varios(entrada_usuario_no, max_in, :max)
 
 puts "\\nResultados combinados:"
 entrada_usuario_no.each_with_index do |entrada_norm, i|
@@ -888,7 +901,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 = GR::FacilRed.new(true)  # true para imprimir las épocas y errores
+red = GRYDRA::FacilRed.new(true)  # true para imprimir las épocas y errores
 
 # Datos originales (temperatura Celsius y Fahrenheit)
 datos_in = [[0], [10], [20], [30], [40], [50], [-10], [-20], [100], [-30], [-5], [-40]]
@@ -948,7 +961,7 @@ estructuras = [
 ]
 
 # Crear red usando la interfaz fácil
-red = GR::FacilRed.new(true)  # true para que imprima error por época
+red = GRYDRA::FacilRed.new(true)  # true para que imprima error por época
 
 # Entrenar la red
 red.entrenar_numericos(
@@ -1003,7 +1016,7 @@ estructuras = [
 ]
 
 # Crear red Fácil
-red = GR::FacilRed.new # true para ver el progreso de entrenamiento
+red = GRYDRA::FacilRed.new # true para ver el progreso de entrenamiento
 
 # 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
@@ -1026,7 +1039,7 @@ predicciones = red.predecir_numericos(nuevos_datos, :max)
 # Las predicciones ya están desnormalizadas por FacilRed, solo redondeamos
 puts "Predicción peso (kg) para altura \#{nuevos_datos[0][0]} cm y edad \#{nuevos_datos[0][1]} años:"
 print predicciones.map { |p| p[0].round(2) }
-GR.guardar_modelo(red, "peso_promedio")
+GRYDRA.guardar_modelo(red, "peso_promedio")
       RUBY
     when 8
       contenido = <<-RUBY
@@ -1034,7 +1047,7 @@ GR.guardar_modelo(red, "peso_promedio")
 require 'grydra'
 
 # Cargar el modelo previamente guardado
-modelo = GR.cargar_modelo("peso_promedio")
+modelo = GRYDRA.cargar_modelo("peso_promedio")
 
 # Datos de entrada para predecir: altura=172 cm, edad=26 años
 nuevos_datos = [[172, 26]]
@@ -1082,14 +1095,14 @@ datos_salida = [
 ]
 
 #Normalziación de datos (dato común --> Dato vectorial)
-max_en = GR.calcular_maximos(datos_entrada, :max) #Usaremos la normalizacion con max, aunque se puede con zscore
-max_sal = GR.calcular_maximos(datos_salida, :max)
+max_en = GRYDRA.calcular_maximos(datos_entrada, :max) #Usaremos la normalizacion con max, aunque se puede con zscore
+max_sal = GRYDRA.calcular_maximos(datos_salida, :max)
 
-datos_en_no = GR.normalizar_varios(datos_entrada, max_en, :max) #Por defecto usa max, entonces es opcional usar el :max
-datos_sal_no = GR.normalizar_varios(datos_salida, max_sal)
+datos_en_no = GRYDRA.normalizar_varios(datos_entrada, max_en, :max) #Por defecto usa max, entonces es opcional usar el :max
+datos_sal_no = GRYDRA.normalizar_varios(datos_salida, max_sal)
 
 #Creamos la red
-red = GR::RedPrincipal.new
+red = GRYDRA::RedPrincipal.new
 
 #Necesitamos agregar subredes a nuestra red
 red.agregar_subred([2, 4, 1], [:relu, :tanh]) 
@@ -1114,7 +1127,7 @@ puts "Introduce los nuevos valores para predecir el precio del producto ej: (12
 
 valores = gets.chomp.strip.split.map(&:to_f)
 
-entrada_nor = GR.normalizar_varios([valores], max_en, :max)[0]
+entrada_nor = GRYDRA.normalizar_varios([valores], max_en, :max)[0]
 prediccion = red.combinar_resultados(entrada_nor)
 prediccion_desnorm = prediccion[0] * max_sal[0]
 puts "Precio aproximado en dolares es de $\#{prediccion_desnorm.round(2)}"
@@ -1122,9 +1135,9 @@ puts "Precio aproximado en dolares es de $\#{prediccion_desnorm.round(2)}"
     else 
       puts "\e[1;35mLos ejemplos posibles son del 1 al 9\e[0m"
     end
-    if num_ejemplo <= 9 && num_ejemplo >= 1
-      File.write("#{nombre_archivo}.#{extension}", contenido)
-      puts "Ejemplo generado y guardado en \e[33m#{path}/#{nombre_archivo}\e[0m" 
+    if num_ejemplo.between?(1, 9)
+      File.write(File.join(path, "#{nombre_archivo}.#{extension}"), contenido)
+      puts "Ejemplo generado y guardado en \e[33m#{File.join(path, nombre_archivo)}\e[0m"
     end
   end
 end

data/lib/gr/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grydra
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.8
 platform: ruby
 authors:
 - Razo
@@ -38,7 +38,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Librería para redes neuronales en Ruby
 test_files: []