Mostrar los tags: go

El siguiente código muestra un grid en pantalla por el que se puede desplazar usando los botones de dirección:

Botón de dirección derecha: Desplazamiento hacia la derecha.
Botón de dirección izquierdo: Desplazamiento a la izquierda.
Botón de dirección superior: Desplazamiento hacia adelante.
Botón de dirección inferior: Desplazamiento hacia atrás.
Botones 'o', 'p', 'k' y 'l': Desplazamientos en diagonal.

A partir de dos números enteros positivos genera una terna pitagórica.
Genera un gráfico del triángulo rectángulo situando los valores de la terna pitagórica.

Nueva versión del Juego de la Serpiente, en la que se ha incluido sonido y 3 archivos de audio (incluidos en la carpeta). Para usar el programa adecuadamente, simplemente hay que descomprimir la carpeta en la que se encuentra.
BOTONES:
Mover serpiente: Botónes de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.

Versión, con caracteres ASCII del popular "Juego de la Serpiente" que incorpora una pantalla de opciones. El control de la serpiente se efectúa mediante las teclas de dirección del teclado. También puede pausarse la partida, presionando la barra espaciadora y una función para salir de partida, mediante la tecla "q".

Utilizar Google Colab junto con Google Drive es una excelente manera de ejecutar y colaborar en proyectos de aprendizaje profundo sin preocuparte por la capacidad de procesamiento y almacenamiento.
Aquí explicamos paso a paso para utilizar Google Colab y Google Drive para generar un modelo de red neuronal convolucional (CNN):
**********************************************************************************************************************************
Paso 1: Preparar tus datos en Google Drive
Crea una carpeta en Google Drive:
Abre Google Drive y crea una carpeta para tu proyecto. Puedes organizar tus datos, cuadernos de Jupyter y modelos en esta carpeta.

Sube tus datos:
Sube tus datos al directorio creado. Pueden ser conjuntos de entrenamiento, validación y prueba en carpetas separadas. Asegúrate de que tus datos estén organizados de manera adecuada.
****************************************************************************************************************************************
Paso 2: Conectar Google Colab a Google Drive
Abre un nuevo cuaderno de Colab:
Abre Google Colab (https://colab.research.google.com/) y crea un nuevo cuaderno de Jupyter.

Monta Google Drive:
Ejecuta el siguiente código en una celda para montar tu Google Drive en Colab. Esto te pedirá autorización y generará un código que debes ingresar.

from google.colab import drive
drive.mount('/content/drive')

Sigue las instrucciones para autorizar y copia el código de autorización en el cuadro de texto de la celda.

*************************************************************************************************************************************
Accede a tus datos:
Después de montar Google Drive, puedes acceder a tu carpeta del proyecto utilizando la ruta /content/drive/MyDrive/:

project_folder = '/content/drive/MyDrive/TuCarpetaDeProyecto'

*******************************************************************************************************

Paso 3: Cargar y Preprocesar Datos
Carga y preprocesa tus datos:
Utiliza las bibliotecas de Python para cargar y preprocesar tus datos. Por ejemplo, si estás trabajando con imágenes en el conjunto de datos CIFAR-10:

import pickle
import numpy as np
from tensorflow.keras.utils import to_categorical

# Cargar datos desde Google Drive
with open(project_folder + '/data/cifar10_data.pkl', 'rb') as file:
data = pickle.load(file)

# Preprocesar datos
x_train, y_train, x_test, y_test = data['train_images'], data['train_labels'], data['test_images'], data['test_labels']
x_train = x_train / 255.0
x_test = x_test / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

*************************************************************************************************************

Paso 4: Construir y Entrenar el Modelo CNN
Definir el modelo CNN:
Construye tu modelo de CNN utilizando TensorFlow y Keras. Aquí hay un ejemplo simple:

from tensorflow.keras import layers, models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

****************************************************************************************************************

Compilar y entrenar el modelo:
Compila y entrena tu modelo utilizando los datos cargados:

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

********************************************************************************************************************

Paso 5: Guardar el Modelo en Google Drive
Guardar el modelo:
Después de entrenar el modelo, guárdalo en tu carpeta de Google Drive:

model.save(project_folder + '/modelo_cnn.h5')

***************************************************************************************************************

Paso 6: Descargar el Modelo (opcional)
Descargar el modelo:
Si lo prefieres, puedes descargar el modelo entrenado desde Google Drive:

from google.colab import files
files.download(project_folder + '/modelo_cnn.h5')

*****************************************************************************************************************

Estos pasos deberían ayudarte a ejecutar un proyecto de CNN en Google Colab utilizando Google Drive para almacenar tus datos y modelos. Asegúrate de adaptar el código según tus necesidades específicas y estructura de datos.


------------------------------------------------------------------------------------------------------------------------------------
**************************************************************************************************************************************************************************************************************************************
SALIDA CONSOLA PROCESO DE EJECUCIÓN DEL EJERCICIO EN GOOGLE COLAB.
*****************************************************************************************************

Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170498071/170498071 [==============================] - 12s 0us/step
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 30, 30, 32) 896

max_pooling2d (MaxPooling2 (None, 15, 15, 32) 0
D)

conv2d_1 (Conv2D) (None, 13, 13, 64) 18496

max_pooling2d_1 (MaxPoolin (None, 6, 6, 64) 0
g2D)

conv2d_2 (Conv2D) (None, 4, 4, 64) 36928

flatten (Flatten) (None, 1024) 0

dense (Dense) (None, 64) 65600

dense_1 (Dense) (None, 10) 650

=================================================================
Total params: 122570 (478.79 KB)
Trainable params: 122570 (478.79 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Epoch 1/10
1563/1563 [==============================] - 187s 119ms/step - loss: 1.7111 - accuracy: 0.3684 - val_loss: 1.3924 - val_accuracy: 0.4950
Epoch 2/10
1563/1563 [==============================] - 186s 119ms/step - loss: 1.4381 - accuracy: 0.4798 - val_loss: 1.2347 - val_accuracy: 0.5591
Epoch 3/10
1563/1563 [==============================] - 188s 120ms/step - loss: 1.3287 - accuracy: 0.5234 - val_loss: 1.1421 - val_accuracy: 0.5922
Epoch 4/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.2549 - accuracy: 0.5513 - val_loss: 1.1387 - val_accuracy: 0.5944
Epoch 5/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.1964 - accuracy: 0.5732 - val_loss: 1.0895 - val_accuracy: 0.6132
Epoch 6/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1545 - accuracy: 0.5881 - val_loss: 1.1042 - val_accuracy: 0.6162
Epoch 7/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1209 - accuracy: 0.6025 - val_loss: 1.0378 - val_accuracy: 0.6406
Epoch 8/10
1563/1563 [==============================] - 179s 115ms/step - loss: 1.0897 - accuracy: 0.6128 - val_loss: 0.9644 - val_accuracy: 0.6558
Epoch 9/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0678 - accuracy: 0.6223 - val_loss: 0.9507 - val_accuracy: 0.6730
Epoch 10/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0431 - accuracy: 0.6308 - val_loss: 0.8898 - val_accuracy: 0.6875
/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.
saving_api.save_model(

Nueva versión del juego de la serpiente con caracteres ASCII. Esta versión se diferencia de las dos anteriores (que pueden verse en mi lista de códigos) en que se acompaña de un archivo (de nombre "hiScore") que irá almacenando de modo permanente, la puntuación máxima alcanzada por el jugador.

BOTONES:
Mover serpiente: Botones de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida en curso: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.

Juego de tetris en pantalla grafica (modo 13), se maneja con las teclas de dirección y escape, para cambiar nivel + y -.

MiniRuleta es un juego de Ruleta para android desarrollado en Java usando el Android Studio.

La carpeta de descarga Incluye, el codigo fuente, los assets y los archivos ejecutables.

El juego al inicial empieza el premio total en 0.

- Al darle click o tap al boton GIRAR RULETA se gira la ruleta
- La ruleta es una imagen hecha con diferentes valores
- Cuando termina de girar la ruleta y el jugador gana el premio que esta marcado con la flecha
- El premio que gana el jugador en cada giro de la ruleta se va sumando en un PREMIO TOTAL
- El premio total se muestra en la parte de abajo de la aplicacion.

Se les agradece a todos el FeedBack y les puedo ayudar a crear su propia ruleta si me envian la rueda en formato PNG en relacion aspecto 1:1.

Mas Informacion: https://evilnapsis.com/2023/01/28/miniruleta-juego-de-ruleta-para-android-codigo-fuente/

********************************************************************
Ad augusta per angusta
**********************************************************************

Hilario Iglesias Martínez
/////////////////////////
Programa a ejecutar con GOOGLE COLAB.
************************************
Google Colab es un sistema de inteligencia artificial creado por Google. Se trata de un sistema que permite, aparte de otras cosas, el funcionamiento como IDE de forma que puedes interactuar en un entorno de programación Python, y su ejecución y prueba en linea.

Para poder utilizarlo, deberás darte de alta, con una referencia de correo en gmail.
Es indudable su potencia en los entornos de Inteligencia artificial. Tiene grandes prestaciones gráficas al utilizar los módulos TensorFlow -de google-y la biblioteca escrita en Python -en código abierto- llamada Keras, capaz de ejecutarse sobre TensorFlow.
**********************************************************************************
La red de ejmplo que planteamos aquí, es un sistema neuronal en modo Sequential, que indica que es un tipo de modelo de redes neuronales artificiales en el cual las capas se apilan de manera secuencial, una encima de la otra. Es el enfoque más básico y comúnmente utilizado en el aprendizaje profundo (deep learning) con la biblioteca de Python llamada Keras.

La creación de un modelo Sequential en Keras sigue los siguientes pasos generales:
con la siguiente linea de código.
from tensorflow.keras.models import Sequential


En Keras, el modo Sequential permite construir modelos de redes neuronales de forma secuencial, donde cada capa se agrega secuencialmente una tras otra. Cada capa se conecta a la siguiente en el flujo de información, pasando la salida de una capa como entrada a la siguiente.



***************************************************************************************************

El programa que pongo a continuación está realizado en en Python3, en un entorno Linux, Ubuntu 20.04.6 LTS. Se supone que por defecto ya tienes instalada esta versión de python.
----------------------------------------------------------------------------------
Deberás tener cargado el ejecutor de carga pip. La forma de instalarlo es la siguiente:
sudo apt update
sudo apt install python3-pip
----------------------------------------------------------------------------------
Una vez que lo tengas instalado ya podrás instalar también los modulos necesarios para Google Colab, de la siguiente forma:

pip install tensorflow
pip install keras

Dado que en el encabezado del programa nos encontramos estos módulos:

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

También deberemos comprobar que están cargados.
*************************************************************************
BASICAMENTE ESTA ES LA EXPLICACIÓN DEL PROGRAMA.
****************************************************
Este programa utiliza TensorFlow y Keras para crear y entrenar un modelo de red neuronal que predice la conversión de temperatura de Celsius a Fahrenheit. Aquí tienes una explicación paso a paso del programa:

Importa las bibliotecas necesarias:

numpy para manejar matrices y operaciones numéricas.
matplotlib.pyplot para visualizar los resultados.
Sequential de keras.models para crear un modelo de red neuronal secuencial.
Dense de keras.layers para agregar capas densamente conectadas a la red.
Crea los datos de entrada:

Define dos arrays de NumPy: Celsius y Fahrenheit, que contienen los pares de valores de temperatura para el entrenamiento del modelo.
Crea la red neuronal:

Inicializa un modelo secuencial llamado model.
Agrega tres capas densamente conectadas a la red:
La primera capa tiene 20 neuronas, utiliza la función de activación ReLU y espera un solo valor de entrada (input_dim=1).
La segunda capa tiene 10 neuronas y también utiliza la función de activación ReLU.
La tercera capa tiene una sola neurona y utiliza la función de activación lineal.
Compila el modelo:

Utiliza el optimizador Adam y la función de pérdida de error cuadrático medio (mean_squared_error).
Entrena el modelo:

Utiliza el método fit para entrenar el modelo con los datos de entrada Celsius y Fahrenheit.
Se especifican 20,000 rondas o vueltas de de entrenamiento -- con este dato se puede jugar empezando por valores más pequeños y viendo como va aumentando el aprendizaje-- y se establece verbose=0 para no mostrar la salida de entrenamiento durante el proceso.
Evalúa el modelo:

Utiliza el método evaluate para calcular la pérdida del modelo en los datos de entrada Celsius y Fahrenheit.
Imprime la pérdida del modelo.

Visualiza los resultados:

Grafica los datos de entrenamiento (Celsius y Fahrenheit) como puntos ('o').
Grafica las predicciones del modelo utilizando model.predict(Celsius) y una línea ('-').
Agrega etiquetas de los ejes y una leyenda para identificar los datos de entrenamiento y las predicciones del modelo.
Realiza una predicción:

Utiliza el modelo entrenado para predecir la temperatura en Fahrenheit para un valor de Celsius de 80.
Imprime la predicción resultante.
En resumen, este programa entrena un modelo de red neuronal para predecir la conversión de temperatura de Celsius a Fahrenheit y muestra los resultados a través de una visualización gráfica.

****************************************************************************
Si quieres puedes experimentar con el programa.
Busca en google -google Colab-
Informate del mismo, estudialo un poco, quizás lo encuentres apasionante.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EXPLICACIÓN PORMENORIZADA DE LAS LINEAS DE CÓDIGO
***********************************************************************************************************

"""
Importamos los módulos necesarios.
---------------------------------
import numpy as np ** Este Modulo permite trabajar con Arrays
import matplotlib.pyplot as plt **Este módulo permite trabajar con graficos
from keras.models import Sequential **Nos permite trabajar con redes secuenciales.
from keras.layers import Dense **"Dense" es un término utilizado para
referirse a una capa densamente conectada
o completamente conectada en una red neuronal.
"""

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

"""
Creamos la entrada de datos por medio de los arrays.
Les llamamos a las entradas Celsius y ahrenheit.
"""

Celsius = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
Fahrenheit = np.array([32, 50, 68, 86, 104, 122, 140, 158, 176, 194])

"""
Creamos la red neural.
---------------------
El modelo será de tipo secuencial, llamando a esa función.
en el módulo keras.models.

Dense(20): Esto indica que queremos agregar una capa densa con 20 neuronas.
Cada neurona en esta capa estará conectada a todas las
neuronas de la capa anterior y de la capa siguiente.

input_dim=1: Este argumento especifica la dimensión de la entrada a la capa.
En este caso, se indica que la capa recibirá una entrada unidimensional.
Esto significa que se espera una entrada de un solo valor.

activation='relu': Aquí se especifica la función de activación
que se utilizará en cada neurona de la capa. En este caso, se utiliza
la función de activación "ReLU" (Rectified Linear Unit).
La función ReLU es una función no lineal que se utiliza
comúnmente en redes neuronales y es conocida
por su capacidad para introducir no linearidad en el modelo.
*****************************************************************
ReLU(x) = max(0, x)
La función de activación ReLU (Rectified Linear Unit)
es una función no lineal ampliamente utilizada en
redes neuronales. La función ReLU se define de la siguiente manera:
para cualquier valor de entrada x, la función ReLU
devuelve 0 si x es negativo y x mismo si x es no negativo.

La función ReLU es popular en el campo del aprendizaje
profundo debido a sus propiedades deseables.
Algunas de las razones por las que se utiliza la función ReLU son:

No linealidad: La función ReLU introduce no linealidad
en la red neuronal, lo que permite que el modelo aprenda
relaciones no lineales entre las características de entrada.
Esto es esencial para capturar patrones complejos en los datos.

Eficiencia computacional: La función ReLU es computacionalmente
eficiente de calcular en comparación con funciones más complejas,
como la función sigmoide o la tangente hiperbólica.
Esto puede ser beneficioso, especialmente en redes neuronales profundas con muchas capas.

Evita el desvanecimiento del gradiente: En el entrenamiento de redes neuronales,
el desvanecimiento del gradiente puede ser un problema cuando las
derivadas de las funciones de activación son muy pequeñas.
La función ReLU evita este problema ya que tiene una derivada constante de 1 para x > 0, lo
que permite que los gradientes fluyan sin decaer rápidamente.

Sin embargo, una limitación de la función ReLU es que
no es diferenciable en x = 0.
Esto puede hacer que el entrenamiento sea más difícil
en algunos casos, especialmente cuando se utilizan
técnicas de optimización basadas en gradientes.
Para abordar este problema, se pueden utilizar variantes
suaves de la función ReLU, como la función Leaky ReLU o la función ReLU paramétrica,
que permiten cierto flujo de gradiente incluso para valores negativos de x.
****************************************************************
model.add(Dense(1, activation='linear'))

En una red neuronal, la función de activación 'linear'
(lineal) significa que no se aplica ninguna función de activación no lineal a
la salida de una capa específica.

Cuando se utiliza una función de activación lineal,
la salida de una neurona o capa simplemente se
calcula como una combinación lineal de las
entradas sin ninguna transformación no lineal
aplicada. Esto significa que la salida es
proporcionalmente igual a la suma ponderada de las entradas.

"""

model = Sequential()
model.add(Dense(20, input_dim=1, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='linear'))


# Compilación del modelo
"""
En la compilación de un modelo de red neuronal, se especifican tres aspectos clave:

Función de pérdida (loss function): La función de pérdida define cómo se calcula
la discrepancia entre las salidas predichas por el modelo y las salidas reales o
etiquetas del conjunto de datos. El objetivo del entrenamiento es minimizar
esta función de pérdida. La elección de la función de pérdida depende del
tipo de problema que se esté abordando, como regresión,
clasificación binaria o clasificación multiclase.

Optimizador: El optimizador determina cómo se ajustan
los pesos y los sesgos de la red neuronal durante el
entrenamiento para minimizar la función de pérdida.
El optimizador utiliza algoritmos como el descenso de
gradiente estocástico (SGD) o algoritmos más avanzados
como Adam o RMSprop. Cada optimizador tiene sus propias
configuraciones y parámetros adicionales que se pueden
ajustar según sea necesario.

Métricas:
Las métricas se utilizan para evaluar el
rendimiento del modelo durante el entrenamiento
y la evaluación. Estas métricas proporcionan
información adicional sobre la precisión,
el error o cualquier otra medida relevante.
Algunas métricas comunes incluyen la precisión (accuracy)
para problemas de clasificación y el error cuadrático
medio (mean squared error) para problemas de regresión.

Después de configurar estos aspectos,
el modelo está listo para ser entrenado utilizando
los datos de entrenamiento proporcionados. Durante el
entrenamiento, el modelo utilizará la función de
pérdida y el optimizador para ajustar los pesos y
los sesgos de las capas de la red neuronal con el
objetivo de minimizar la pérdida y mejorar el
rendimiento en función de las métricas establecidas.


"""
model.compile(optimizer='adam', loss='mean_squared_error')

#Entrenamiento del modelo
"""[
El "entrenamiento del modelo" en una red neuronal se refiere
al proceso de ajustar los pesos y los sesgos de la red neuronal
utilizando un conjunto de datos de entrenamiento con el objetivo
de aprender patrones y relaciones en
los datos. Durante el entrenamiento, el modelo se expone
repetidamente a los ejemplos de entrenamiento,
calcula las salidas correspondientes y actualiza los parámetros
internos en función de la diferencia entre las salidas predichas y las salidas reales.

El entrenamiento de un modelo de red neuronal implica los siguientes pasos generales:

Inicialización de pesos: Los pesos y los sesgos de la red neuronal
se inicializan de forma aleatoria o mediante algún enfoque
específico, como la inicialización de Xavier o He.

Paso hacia adelante (Forward pass): Los datos de entrenamiento se propagan
a través de la red neuronal en una dirección, desde la capa de entrada
hasta la capa de salida. Las salidas se calculan mediante una
combinación lineal de los pesos y los sesgos, seguidos de
la aplicación de funciones de activación no lineales en cada capa.

Cálculo de la función de pérdida: Se compara la salida predicha
por el modelo con la salida real correspondiente del conjunto de
datos de entrenamiento utilizando una función de pérdida.
La función de pérdida mide qué tan bien se está desempeñando
el modelo en la tarea específica y proporciona una medida de
la discrepancia entre las salidas predichas y las salidas reales.

Retropropagación (Backpropagation):
El algoritmo de retropropagación se utiliza para calcular
las contribuciones relativas de cada peso y sesgo en la
función de pérdida. Se propaga el gradiente del error
hacia atrás a través de la red neuronal,
calculando las derivadas parciales de la función de
pérdida con respecto a cada peso y sesgo.
Estas derivadas se utilizan para actualizar
los pesos y sesgos mediante un proceso llamado optimización.

Optimización de los parámetros: Los pesos
y sesgos se actualizan utilizando un algoritmo
de optimización, como el descenso de gradiente
estocástico (SGD), Adam o RMSprop.
Estos algoritmos ajustan los parámetros de la
red neuronal en la dirección que reduce
la función de pérdida, utilizando la información
del gradiente calculada durante la retropropagación.

Repetición: Los pasos 2-5 se repiten para varios
ejemplos de entrenamiento hasta que se alcance un
criterio de detención, como un número máximo de iteraciones
(épocas) o una mejora aceptable en el rendimiento del modelo.

El proceso de entrenamiento busca encontrar
los valores óptimos para los pesos y sesgos de la
red neuronal que minimicen la función de pérdida, y
permitan que el modelo haga predicciones precisas en
datos no vistos. Una vez que el modelo está entrenado,
se puede utilizar para hacer predicciones en nuevos
ejemplos o para realizar otras tareas relacionadas con la inferencia.


"""
model.fit(Celsius, Fahrenheit, epochs=20000, verbose=0)

# Evaluación de el modelo
loss = model.evaluate(Celsius, Fahrenheit)
print('Loss:', loss)

# TRAZAR RESULTADOS.
"""
"Trazar los resultados" en una red neuronal se refiere a visualizar
o representar gráficamente los resultados obtenidos durante el entrenamiento o
la evaluación del modelo. La visualización de los resultados puede proporcionar
información importante sobre el rendimiento y el comportamiento del modelo,
así como ayudar a identificar posibles problemas o mejoras.

Aquí hay algunos tipos comunes de trazado de resultados en una red neuronal:

Gráficas de pérdida (Loss plots): Se representan gráficamente las curvas
de pérdida a lo largo de las épocas durante el entrenamiento. Esto muestra
cómo disminuye la pérdida a medida que el modelo se entrena y proporciona
información sobre la convergencia y la estabilidad del modelo.

Gráficas de métricas de rendimiento: Si se han definido métricas
de rendimiento adicionales, como la precisión o el error, se
pueden trazar para evaluar el rendimiento del modelo durante
el entrenamiento o la evaluación. Esto ayuda a comprender
cómo el rendimiento del modelo evoluciona a medida que se realiza el entrenamiento.

Visualización de predicciones: Se pueden trazar las predicciones
del modelo junto con las etiquetas reales para un conjunto de
datos de evaluación o pruebas. Esto permite comparar
visualmente las predicciones del modelo con los valores
reales y evaluar qué tan cerca están.

Mapas de calor (Heatmaps): En el caso de problemas de clasificación,
especialmente en clasificación de imágenes, se pueden utilizar mapas
de calor para visualizar las regiones de la imagen que el modelo
considera más importantes para tomar una decisión de clasificación.
Estos mapas de calor resaltan las áreas de la imagen que
tienen un mayor impacto en las predicciones del modelo.

Representaciones de características (Feature representations):
En redes neuronales convolucionales, se pueden trazar las
representaciones aprendidas en diferentes capas de la red
para visualizar cómo las características se transforman a
medida que se profundiza en la red. Esto puede ayudar a
entender qué tipo de características o patrones la red
está aprendiendo a reconocer.

La visualización de los resultados en una red
neuronal puede proporcionar una comprensión más
profunda del rendimiento del modelo y ayudar en el
análisis y la mejora del mismo. Además, los gráficos y
visualizaciones pueden ser útiles para comunicar los
resultados a otras personas de manera más intuitiva.

"""

plt.plot(Celsius, Fahrenheit, 'o')
plt.plot(Celsius, model.predict(Celsius), '-')
plt.xlabel('Celsius')
plt.ylabel('Fahrenheit')
plt.legend(['Training data', 'Linear regression'], loc='best')
plt.show()
celsius_value = 100
fahrenheit_prediction = model.predict(np.array([80]))
print('Prediccion para Hilario:', fahrenheit_prediction[0])
#Fórmula habitual de cálculo por un algoritmo con esta formula
#(80 °C × 9 / 5) + 32 = 176 °F