Códigos Fuente de Python

Aula_28_Recordatorio_Mayo.py
************************************

Bien, dada una matriz, con 8 característica, y 20 muestras.
Como la siguiente:

[[1.234 0.567 2.345 1.890 0.123 3.456 2.345 1.234]
[0.987 1.234 1.890 0.345 2.567 0.890 1.234 2.345]
[3.456 1.890 0.567 2.345 1.234 0.890 2.567 1.890]
[2.567 1.890 0.123 1.234 2.345 0.567 1.890 3.456]
[0.890 1.890 2.345 0.567 1.234 3.456 0.890 1.234]
[1.890 2.345 1.234 0.567 2.345 0.123 1.234 0.567]
[1.234 2.345 0.567 1.890 0.123 2.567 0.890 1.234]
[2.345 1.890 3.456 0.890 1.234 0.567 1.890 2.567]
[0.567 1.234 1.890 0.567 1.234 0.890 2.345 0.123]
[0.890 1.890 0.123 1.234 0.567 3.456 1.234 1.890]
[1.890 0.567 1.234 0.890 2.567 1.234 2.345 0.567]
[1.234 2.567 0.890 1.890 0.123 1.890 0.567 1.234]
[0.567 1.234 2.345 1.890 0.567 2.345 1.234 0.890]
[1.890 0.123 1.234 0.567 2.345 1.890 0.567 1.234]
[0.890 1.234 0.567 1.890 1.234 2.345 3.456 0.890]
[1.234 0.567 2.345 0.890 2.345 1.234 0.567 1.890]
[2.567 1.890 0.890 1.234 0.567 1.890 2.345 0.123]
[0.567 2.345 1.234 0.567 1.890 0.123 1.890 0.567]
[1.234 1.890 0.567 3.456 2.567 1.234 0.890 1.234]
[0.567 2.345 1.234 0.890 1.890 0.567 1.234 2.567]]


Planteamos una red neuronal sin utilizar ni keras ni tensorflow. Que entrena la red con esos valores, de 8 características, y 20 muestras o ejemplos.
Y que haga una prediccion de salida de la caracteristica correspondientes, a esta muestra dada:[1.345 2.890 0.456 1.890 12.234 10.567 1.890 12.567].

El ejercicio, tendría básicamente estos pasos:

1-Definición de funciones de activación y pérdida:
*******************************************************
Se define la función de activación ReLU (relu) y su derivada (relu_derivative).
ReLU es una función de activación comúnmente utilizada en redes neuronales debido a su simplicidad y buen desempeño en muchas tareas.
Se define la función de pérdida de error cuadrático medio (mean_squared_error).
Esta función calcula la diferencia cuadrática media entre las predicciones y las etiquetas verdaderas.

2-Implementación de la red neuronal:
*****************************************
Se crea una clase NeuralNetwork que representa una red neuronal de dos capas (una capa oculta y una capa de salida).
En el método __init__, se inicializan los pesos y sesgos de la red neuronal de manera aleatoria.
En el método forward, se realiza la propagación hacia adelante, calculando las salidas de la red neuronal.
En el método backward, se realiza la retropropagación del error, calculando los gradientes de los pesos y sesgos y actualizándolos utilizando el algoritmo de descenso de gradiente.
El método train entrena la red neuronal utilizando los datos de entrada y las etiquetas verdaderas durante un número específico de épocas.
El método predict realiza predicciones utilizando la red neuronal entrenada.

3-Entrenamiento de la red neuronal:
********************************
Se definen los datos de entrada (X_train) y las etiquetas verdaderas (y_train).
Los datos se normalizan dividiéndolos por su máximo valor para asegurar que estén en el rango [0, 1].
Se crea una instancia de la red neuronal con el tamaño de entrada, tamaño oculto y tamaño de salida dados.
La red neuronal se entrena utilizando los datos de entrenamiento durante 10000 épocas con una tasa de aprendizaje de 0.01.

4-Predicción:
*****************
Se define un nuevo conjunto de datos de entrada (X_new) para realizar una predicción.
Los datos de entrada se normalizan de la misma manera que los datos de entrenamiento.
Se realiza una predicción utilizando la red neuronal entrenada.
El resultado de la predicción se desnormaliza multiplicándolo por el máximo valor de las etiquetas verdaderas.
Se muestra el resultado de la predicción.

Según vemos su desarrollo podemos decir, que este ejercicio muestra cómo implementar una red neuronal básica desde cero en Python sin utilizar bibliotecas como Keras o TensorFlow. La red neuronal se entrena utilizando el algoritmo de retropropagación y se prueba haciendo una predicción sobre nuevos datos de entrada.

El alumno podrá interactuar con el ejercicio, modificando parametros como
valores de entrada, caracteristicas y muestras, para su mejor comprensión.



UNA SALIDA DEL EJERCICIO, PODRÍA SER LA SIGUIENTE:
****************************************************************************
Epoch 0, Loss: 11.7756050562224
Epoch 1000, Loss: 0.012417106163412383
Epoch 2000, Loss: 0.004855440981664029
Epoch 3000, Loss: 0.002804630823301262
Epoch 4000, Loss: 0.0019105925868362645
Epoch 5000, Loss: 0.0013765944597636112
Epoch 6000, Loss: 0.0010168157428455883
Epoch 7000, Loss: 0.0007730551039343544
Epoch 8000, Loss: 0.0006225694864747496
Epoch 9000, Loss: 0.0005176777148262488
Predicción de salida: [[-0.55685326 -0.9034264 -1.02152184 0.87943007 0.40507882 1.91684935
0.28005875 2.23286946]]
[Finished in 701ms]

***********************************************************************
El ejercicio fue realizado bajo plataforma linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime text.
Ejecución:
python3 Aula_28_Recordatorio_Mayo.py
***********************************************************************

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.

Programa para mostrar el precio de cierre, apertura, máximo y mínimo de las acciones de un activo para un determinado periodo de tiempo. También incluye representación de 'bandas de bollinger' y la media movil de 20 sesiones. Para mostrar la gráfica correspondiente a la información deseada, hacer click en el botón 'SHOW GRAPH'. Para cualquier duda u observación, utilicen la sección de comentarios.

El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.

Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

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.

PRIMERA IMAGEN.
*********************


SEGUNDA IMAGEN.
***********************



RESULTADO DE LA SUMA DE LAS IMAGENES.
*******************************************************


********************************************************************************************************
*******************************************************************************************************
Propongo el ejercicio:AULA-38_Fusión_Imagenes.py. Como continuación del último propuesto.
En este caso, para perfeccionar el trabajo con imagenes a través de su recorrido mediante indices,
pretendemos adiccionar dos imagenes llamadas x.jpg, e, y.jpg, y ver el reusltado.
Para este trabajo deberemos tener cargadas en nuestro sistema, las librerías, o módulos
correspondientes, en nuestro caso:

import keras
from keras.layers import Dense
import cv2
import matplotlib.pyplot as plt
import os


Por otro lado necesitaremos tener actualizado la librería numpy,
para lo que podemos utilizar este comando bajo consola de Linux:

pip install --upgrade tensorflow numpy

--------------------------------------------------------------------------
El ejercicio, basicamente requiere estos pasos.
***********************************************
1-Imporación, como se ha indicado anteriormente, de las librerias necesarias.

2-En mi caso, mi ordenador no sosporta CUDA, mi tarjeta gráfica no es del tipo Nvidea.
por lo que le indico al programa que utilice mi CPU.

3- Cargamos las imagenes.

4-Obtener las dimensiones de ambas imágenes.

5-Si las dimensiones no son iguales, redimensionar la imagen y.
a las mismas dimensiones que x.

6-Declaramos una función que utilizando un bucle anidado,
sumará las dos imagenes.

7-Mostramos el array de la imagen resultante.

8-Declaramos otra funcion para ver la imagen.

9- Llamamos a la función y mostramos la imagen.

--------------------------------------------------------------------------------
********************************************************************************
Este ejercicio ha sido realizado bajo una plataforma Linux,
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.

Ejecución del ejercicio bajo consola Linux:
python3 AULA-38_Fusión_Imagenes.py

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

Aula_28_Aplicar_Relu.py
*****************************
Este ejercicio que proponemos es sumamente sencillo. No por ello es importante dentro del desarrollo de redes neuronales.
Lo hacemos con el fin de aplicar una funcion Relu auna imagen, en un proceso usual dentro de las redes neuronales.

Indiquemos brevemente lo que es una funcion RELU.
---------------------------------------------------------------------
La función ReLU (Rectified Linear Unit) es una función de activación comúnmente utilizada en redes neuronales
y otras técnicas de aprendizaje automático. Se define matemáticamente de la siguiente manera:

f(x)={ 0,x
si x≤0
si x>0
​O en otras palabras, de forma más sencilla,
la función ReLU devuelve 0 para todos los valores de entrada que son negativos o iguales a cero,
y devuelve el mismo valor de entrada para valores positivos.

En el contexto de redes neuronales, la función ReLU se utiliza típicamente como función de activación
en las capas ocultas debido a su simplicidad y eficiencia computacional. Permite la introducción
de no linealidades en el modelo, lo que ayuda a que la red neuronal pueda aprender
representaciones más complejas de los datos de entrada.
*************************************************************************************************
En este ejercicio pretendemos aplicar esta función a una imagen dimensionada previamente.

Pasamos a explicar el mismo con poco de detalle.
1-Importa las bibliotecas necesarias:
numpy para el procesamiento numérico y matplotlib.pyplot para visualizar la imagen.

import numpy as np
import matplotlib.pyplot as plt
-------------------------------------------------------------------------
2-Definimos una función llamada apply_relu que toma
una imagen como entrada y aplica la función ReLU a cada píxel de la imagen.

def apply_relu(imagen):
alto, ancho, canales = imagen.shape
imagen_relu = np.zeros_like(imagen)
for i in range(alto):
for j in range(ancho):
for k in range(canales):
imagen_relu[i, j, k] = max(0, imagen[i, j, k])
return imagen_relu
-----------------------------------------------------------------------------------------
3- Carga la imagen desde un archivo. En este caso, la ruta del archivo es
/home/margarito/python/imagen.jpg.
En vuestro caso deberéis modificar esta ruta con la situación del archivo imagen.
imagen = plt.imread('/home/margarito/python/imagen.jpg')
-----------------------------------------------------------------------------------------

4-Obtiene las dimensiones de la imagen (alto y ancho) utilizando la función shape.

alto, ancho, _ = imagen.shape
----------------------------------------------------------------------------------
5-Muestra la imagen original utilizando plt.imshow.

plt.imshow(imagen)
plt.title('Imagen Original')
plt.axis('off')
plt.show()
-----------------------------------------------------------------------------------
6-Aplica la función ReLU a la imagen cargada utilizando la función apply_relu definida anteriormente

imagen_relu = apply_relu(imagen)
---------------------------------------------------------------------------------------
7-Muestra la imagen después de aplicar la función ReLU utilizando plt.imshow.
plt.imshow(imagen_relu)
plt.title('Imagen aplicando la función ReLU')
plt.axis('off')
plt.show()
*************************************************************************************

Como se puede comprobar apenas existe una modificación visible, entre las dos
imagenes, antes y después de aplicar la función Relu.
Esto puede ser debido a que los valores negativos son escasos en el array 2D de la imagen.
********************************************************************************************************
---------------------------------------------------------------------------------------------------
Este ejercicio fue ejecutado en una plataforma Linux, Ubuntu 20.04.6 LTS.
Editado con Sublime Text.

Para que su funcionamiento y ejecucion sea correcto
se deberá de tener instalado en vuestro sistema
la versión numpy-1.24.4.
Es conveniente hacer este comando en consola, para actualizarlo:

pip install --upgrade numpy
************************************************************************
Ejecución del ejercicio en linea bajo consola:
python3 Aula_28_Aplicar_Relu.py
-----------------------------------------------------------------------

Programa para buscar archivos mediante expresiones regulares.
COMANDOS:
cbd <dir> cambia el directorio base.
sch <string> realiza búsqueda por el sistema de carpetas a partir de la carpeta base.
cl realiza limpieza de pantalla.
help muestra lista de comandos.
q finaliza programa.

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

******************************************************************************************************************
Como hay alguna duda del tratamiento de imagenes Minist, a través de llamadas a
índices. Propongo este sencillo ejercicio para el Aula-28, con el fin de comprender el proceso irecorrido a través de indices para poder visualizar imágenes Minist, así como tambien entender las particularidades de este tipo de Arrays.
********************************************************************************
Paso a describir, de forma sencilla, las lineas de código del ejercicio Aula_28-Tratamiento-Indices.py

from keras.datasets import mnist
--------------------------------


Aquí estamos importando el conjunto de datos MNIST desde la biblioteca Keras. MNIST es un conjunto de datos popular utilizado para entrenar modelos de redes neuronales convolucionales (CNN) en tareas de reconocimiento de dígitos escritos a mano.

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-----------------------------------------------------------------------------
Esta línea carga los datos MNIST en cuatro variables: train_images y train_labels contienen las imágenes y las etiquetas correspondientes utilizadas para entrenar el modelo, mientras que test_images y test_labels contienen las imágenes y las etiquetas utilizadas para evaluar el rendimiento del modelo después del entrenamiento.

print(train_images.ndim)
print(train_images.dtype)
------------------------
Estas líneas imprimen la dimensionalidad y el tipo de datos de las imágenes de entrenamiento. train_images.ndim devuelve la cantidad de dimensiones (generalmente 3: altura, ancho y canal de color) y train_images.dtype devuelve el tipo de datos de los píxeles en las imágenes (generalmente uint8, que representa enteros sin signo de 8 bits).

digit = train_images[4888]
--------------------------
Esto selecciona una imagen específica del conjunto de datos de entrenamiento. Aquí, digit es una variable que contiene la imagen correspondiente al índice 4888 del conjunto de datos de entrenamiento.

plt.imshow(digit, cmap=plt.cm.binary)
plt.show()
------------------------------------
Estas líneas muestran la imagen seleccionada utilizando Matplotlib. plt.imshow() muestra la imagen y plt.show() muestra la ventana emergente con la imagen.

for i in range(10, 11):
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.show()
---------------------------------------------------

Este bucle muestra una sola imagen del conjunto de datos de entrenamiento. En este caso, se muestra la imagen con índice 10 (es decir, la undécima imagen) utilizando las mismas funciones de visualización de Matplotlib que se mencionaron anteriormente.

def visualizar_imagenes(mnits, indices):
...
---------------------------------------
Aquí se define una función llamada visualizar_imagenes que acepta dos argumentos: mnits, que son las imágenes que se van a visualizar, y indices, que son los índices de las imágenes que se desean visualizar.

indices_a_visualizar = [0, 100, 200, 300, 400, 500, 600, 700]
visualizar_imagenes(train_images, indices_a_visualizar)
-----------------------------------------------------------------
Finalmente, se crea una lista de índices de imágenes que se desean visualizar y se llama a la función visualizar_imagenes para mostrar esas imágenes específicas del conjunto de datos de entrenamiento.

********************************************************************
Este ejercicio fue ralizado bajo plataforma linux, concretamente con:
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
Cargado Python3.
El sistema debe tener cargado para su importación:
from keras.datasets import mnist
import matplotlib.pyplot as plt
*************************************************
Ejecucion del programa bajo consola linux.
python3 Aula_28-Tratamiento-Indices.py