grydra 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e449d883a411813be922b8336a3e8044d33c36cbecc7590472cf98ba83d7bd24
-  data.tar.gz: d95118b578b70a82f539153a203be2afb11be345fc5bf317d010ea476b43225c
+  metadata.gz: 6c7c8176630e8f46bc755437bf28829564123d4c7b2c352a789abc257bd625f2
+  data.tar.gz: c69e061a5b621989d15e7163878cd9302939a69043b4a4f228adbba41ba20563
 SHA512:
-  metadata.gz: 83d5f6bad1790e03bd60cf59f061c4e1c3b23eef6dbd4e7a04d475b1262c9543a1cbea0188f6d84fde6de04e927142ef8f5d1f220784e12d7416ad002c06caab
-  data.tar.gz: 64b5c314cb50f51cc0c01ac6763c2a643442be772b96acbeed26f0c5cb3b54248452c31f4549e06008aa070fc53a9ac07217834b6fd93a6dd3e3b8aa9b1f27ec
+  metadata.gz: 034f93c0e54bf6f2209b20efdcb4d0e0670cca1634808b3dab4b8563adb7ec82d071a0e0dea0939a7b00f6b8f3cdd66ee3a6f6b960920a0a8b8950195b1dbc8b
+  data.tar.gz: 807c70832d2d0abd31b402dd51b9b28031360ea1ae89cbba2c6b6f68ccc86fc13cd1a7b9acc3a997c6b1fd94e7af18e0e1906328363574681764f6b31f56356e

data/lib/gr/core.rb

@@ -538,7 +538,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 impriam el umbral de error
+        red = GR::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)
@@ -576,7 +576,7 @@ module GR
           {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 = GR::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
     },
@@ -695,4 +695,356 @@ module GR
     end
     print "\e[0m"
   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__))
+    case num_ejemplo
+    when 1
+      contenido = <<-RUBY
+require 'grydra'
+
+
+# Datos de entrenamiento
+datos_entrenamiento = [
+  { nombre: "Empresa 1", numero_empleados: 5, es_nuevo: false, sitio: true, etiqueta: 0 },
+  { nombre: "Empresa 2", numero_empleados: 4, es_nuevo: true, sitio: false, etiqueta: 0 },
+  { nombre: "Empresa 3", numero_empleados: 4, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 4", numero_empleados: 20, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 5", numero_empleados: 60, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 6", numero_empleados: 90, es_nuevo: false, sitio: false, etiqueta: 0 },
+  { nombre: "Empresa 7", numero_empleados: 33, es_nuevo: true, sitio: false, etiqueta: 0 },
+  { nombre: "Empresa 8", numero_empleados: 33, es_nuevo: false, sitio: true, etiqueta: 0 },
+  { nombre: "Empresa 9", numero_empleados: 15, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 10", numero_empleados: 40, es_nuevo: false, sitio: true, etiqueta: 0 },
+  { nombre: "Empresa 11", numero_empleados: 3, es_nuevo: false, sitio: false, etiqueta: 0 },
+  { nombre: "Empresa 12", numero_empleados: 66, es_nuevo: false, sitio: true, etiqueta: 0 },
+  { nombre: "Empresa 13", numero_empleados: 15, es_nuevo: true, sitio: false, etiqueta: 0 },
+  { nombre: "Empresa 13", numero_empleados: 10, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 13", numero_empleados: 33, es_nuevo: false, sitio: false, etiqueta: 1 },
+  { nombre: "Empresa 13", numero_empleados: 8, es_nuevo: false, sitio: false, etiqueta: 1 },
+]
+
+# Creamos el modelo
+modelo = GR::FacilRed.new(true)  # true para que imprima el error cada 1000 épocas
+
+# Entrenamos directamente usando datos tipo hash
+modelo.entrenar_hashes(
+  datos_entrenamiento,
+  [:numero_empleados, :es_nuevo, :sitio], # claves a usar como entrada
+  :etiqueta,                             # clave de salida
+  [[3, 4, 1]],                           # estructura de subred: 3 entradas → capa oculta de 4 → 1 salida
+  0.05,                                  # tasa de aprendizaje
+  12000                                  # épocas
+)
+
+
+# Guardamos el modelo entrenado
+GR.guardar_modelo(modelo, "modelo_empresas")
+
+puts "Entrenamiento completado y modelo guardado exitosamente." #Mensaje de depuración para comprobar la ejecución adecuada 
+        RUBY
+    when 2
+      contenido = <<-RUBY
+require 'grydra'
+modelo = nil
+modelo = GR.cargar_modelo("modelo_empresas")
+
+# Nuevos datos de empresas a evaluar
+nuevos_datos = [
+  { nombre: "Nueva Empresa A", numero_empleados: 12, es_nuevo: true, sitio: true },
+  { nombre: "Nueva Empresa B", numero_empleados: 50, es_nuevo: false, sitio: false },
+  { nombre: "Nueva Empresa C", numero_empleados: 7, es_nuevo: false, sitio: false },
+  { nombre: "Nueva Empresa D", numero_empleados: 22, es_nuevo: true, sitio: true }
+]
+
+# Hacemos predicciones
+predicciones = modelo.predecir_hashes(nuevos_datos, [:numero_empleados, :es_nuevo, :sitio])
+
+# Mostrar resultados
+nuevos_datos.each_with_index do |empresa, i|
+  prediccion = predicciones[i].first.round(3)
+  puts "Empresa: \#{empresa[:nombre]} → Predicción: \#{prediccion} (\#{prediccion >= 0.5 ? 'Etiqueta 1 (Sí)' : 'Etiqueta 0 (No)'})"
+end
+      RUBY
+    
+    when 3
+      contenido = <<-RUBY
+require 'grydra'
+
+# Crear red principal
+red = GR::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])
+red.agregar_subred([2, 4, 1], [:sigmoid, :sigmoid])
+
+# Datos XOR
+entradas = [
+  [0, 0],
+  [0, 1],
+  [1, 0],
+  [1, 1]
+]
+
+salidas = [
+  [0],
+  [1],
+  [1],
+  [0]
+]
+
+
+# Entrenamiento
+epocas = 6000
+tasa_aprendizaje = 0.9
+
+red.entrenar_subredes(
+  [
+    {entrada: entradas, salida: salidas},
+    {entrada: entradas, salida: salidas},
+  ],
+  tasa_aprendizaje, 
+  epocas,
+  batch_size: 1, #Número de datos con los que va a entrenar al mismo tiempo
+  paciencia: 100, #Si los resultados no mejoran en (n cantidad) de epocas, entonces pasa 
+  decay: 0.995 #Número por el cual multiplica 
+)
+
+# Evaluación
+puts "\\nEvaluación XOR:"
+entradas.each do |entrada|
+  salida = red.combinar_resultados(entrada)
+  puts "Entrada: \#{entrada} => Salida: \#{salida.map { |v| v.round(3)  }}" #>0.5 en este caso seria 1 
+end
+      RUBY
+    when 4
+      contenido = <<-RUBY
+require 'grydra'
+
+# Datos originales (temperatura Celsius y Fahrenheit)
+datos_in = [[0], [10], [20], [30], [40], [50], [-10], [-20], [100], [-30], [-5], [-40]]
+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}
+
+# Normalizar datos
+datos_in_no = GR.normalizar_varios(datos_in, max_in, :max)
+datos_ou_no = GR.normalizar_varios(datos_ou, max_ou, :max)
+
+# Crear red principal
+red_principal = GR::RedPrincipal.new
+
+# Agregar subredes
+red_principal.agregar_subred([1, 4, 1], [:sigmoid, :tanh])
+red_principal.agregar_subred([1, 3, 1], [:relu, :tanh])
+red_principal.agregar_subred([1, 2, 1], [:tanh, :tanh])
+
+puts "Entrenando subredes..."
+red_principal.entrenar_subredes(
+  [
+    { entrada: datos_in_no, salida: datos_ou_no },
+    { entrada: datos_in_no, salida: datos_ou_no },
+    { entrada: datos_in_no, salida: datos_ou_no }
+  ],
+  0.2,    # tasa aprendizaje
+  25000,   # épocas
+  batch_size: 5,
+  paciencia: 500,
+  decay: 0.995
+)
+
+puts "\\nIngrese los grados Celsius separados por espacio:"
+print "<< "
+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)
+
+puts "\\nResultados combinados:"
+entrada_usuario_no.each_with_index do |entrada_norm, i|
+  prediccion_norm = red_principal.combinar_resultados(entrada_norm)
+  prediccion = [prediccion_norm[0] * max_ou[0]]  
+  puts "\#{entrada_usuario[i]} °C : \#{prediccion[0].round(2)} °F"
+end
+      RUBY
+    when 5
+      contenido = <<-RUBY
+require 'grydra'
+=begin
+NOTA IMPORTANTE:
+Si se usa la normalización con zscore, debemos ser mas minusiosos y lo recomendable 
+es bajar y subir constantmente la tasa de aprendizaje, pues con zscore una vez llegando
+a los resultados esperados se mantendra por ese margen. La tasa se puede bajar y subir 
+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
+
+# Datos originales (temperatura Celsius y Fahrenheit)
+datos_in = [[0], [10], [20], [30], [40], [50], [-10], [-20], [100], [-30], [-5], [-40]]
+datos_out = [[32], [50], [68], [86], [104], [122], [14], [-4], [212], [-22], [23], [-40]]
+
+# Definir estructuras de subredes (capas ocultas)
+estructuras = [
+  [2, 4, 1],  # capa oculta con 4 neuronas, salida 1
+  [1, 3, 1],  # otra subred, 3 neuronas capa oculta
+  [2, 7, 1]   # y otra más pequeña
+]
+
+puts "Entrenando red..."
+red.entrenar_numericos(datos_in, datos_out, estructuras, 0.5, 30000, :zscore) 
+#red.entrenar_numericos(datos_in, datos_out, estructuras, 0.5, 30000, :max)
+
+puts "\nIngrese los grados Celsius separados por espacio:"
+print "<< "
+entrada_usuario = gets.chomp.split.map(&:to_f).map { |v| [v] }
+
+predicciones = red.predecir_numericos(entrada_usuario, :zscore)
+#predicciones = red.predecir_numericos(entrada_usuario, :max) 
+
+puts "\\nResultados:"
+entrada_usuario.each_with_index do |entrada, i|
+  f = predicciones[i][0]
+  puts "\#{entrada[0]} °C : \#{f.round(2)} °F"
+end
+      RUBY
+    when 6
+      contenido = <<-RUBY
+require 'grydra'
+
+# Crear datos de entrada y salida
+datos_entrada = [
+  [170, 25],
+  [160, 30],
+  [180, 22],
+  [150, 28],
+  [175, 24]
+]
+
+# Peso correspondiente a cada persona (kg)
+datos_salida = [
+  [65],
+  [60],
+  [75],
+  [55],
+  [70]
+]
+
+# Definir estructuras de las subredes
+# Cada subred tiene: 2 entradas → 3 neuronas ocultas → 1 salida
+estructuras = [
+  [3, 1],
+  [4, 1]
+]
+
+# Crear red usando la interfaz fácil
+red = GR::FacilRed.new(true)  # true para que imprima error por época
+
+# Entrenar la red
+red.entrenar_numericos(
+  datos_entrada,
+  datos_salida,
+  estructuras,
+  0.05,        # tasa de aprendizaje
+  15000,       # épocas
+  :max         # tipo de normalización
+)
+
+# Predecir para un nuevo individuo
+nuevos_datos = [[172, 26]]
+
+predicciones = red.predecir_numericos(nuevos_datos, :max)
+
+puts "\\nResultado:"
+puts "Altura: \#{nuevos_datos[0][0]}, Edad: \#{nuevos_datos[0][1]} ⇒ Peso estimado: \#{predicciones[0][0].round(2)} kg"
+      RUBY
+    when 7
+      contenido = <<-RUBY
+require 'grydra'
+
+# Datos de entrenamiento: [altura (cm), edad (años)]
+datos_entrada = [
+  [170, 25],
+  [160, 30],
+  [180, 22],
+  [175, 28],
+  [165, 35],
+  [155, 40],
+  [185, 20]
+]
+
+# Peso real en kg
+datos_salida = [
+  [65],
+  [60],
+  [75],
+  [70],
+  [62],
+  [58],
+  [80]
+]
+
+# Estructuras para las subredes: capas ocultas y salida
+estructuras = [
+  [4, 1],   
+  [3, 1],
+  [6, 1],
+  [2, 1]
+]
+
+# Crear red Fácil
+red = GR::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
+
+estructuras.each do |estructura|
+  # Definimos activaciones: ocultas con :tanh, salida con :sigmoid
+  activaciones = Array.new(estructura.size - 1, :tanh) + [:sigmoid]
+  red.red.agregar_subred([datos_entrada.first.size, *estructura], activaciones)
+end
+
+# Normalización :max (fácil de desnormalizar)
+red.entrenar_numericos(datos_entrada, datos_salida, estructuras, 0.01, 10000, :max)
+
+# Nueva muestra para predecir: altura=172 cm, edad=26 años
+nuevos_datos = [[172, 26]]
+
+# Hacemos predicción (normalizada internamente)
+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")
+      RUBY
+    when 8
+      contenido = <<-RUBY
+# predecir.rb
+require 'grydra'
+
+# Cargar el modelo previamente guardado
+modelo = GR.cargar_modelo("peso_promedio")
+
+# Datos de entrada para predecir: altura=172 cm, edad=26 años
+nuevos_datos = [[172, 26]]
+
+# Normalización que usaste (puede ser :max o :zscore, según entrenaste)
+normalizacion = :max
+
+# Realizar predicción
+predicciones = modelo.predecir_numericos(nuevos_datos, normalizacion)
+
+puts "Predicción peso (kg) para altura \#{nuevos_datos[0][0]} cm y edad \#{nuevos_datos[0][1]} años:"
+puts predicciones.map { |p| p[0].round(2) }
+      RUBY
+    end
+    File.write("#{nombre_archivo}.#{extension}", contenido)
+    puts "Ejemplo generado y guardado en \e[33m#{path}/#{nombre_archivo}\e[0m"
+  end
 end
+

data/lib/gr/version.rb

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

metadata

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