Códigos Fuente de Python

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

Repaso-matplotlib-Aula-38-uranio-235.py
------------------------------------------------------
Con la idea de repasar la librería matplotlib, propongo este sencillo ejercicio de la representación aleatoria de un átomo de Uranio-235.
El ejercicio es de ejecución sencilla, y puede el alunno jugar con sus datos de entrada.
La librería matplotlib, es de uso habitual en todos los programas graficados, incluidos
los de inteligencia artificial.
----------------------------------------------------------------------------------------
Vamos a dar una pequeña descripción de Física cuántica, con el fin de entender este desarrollo.
********************************************************************************************
En la física cuántica, la idea de electrones orbitando alrededor del núcleo en trayectorias definidas, como planetas alrededor del sol, es incorrecta y ha sido reemplazada por un modelo más complejo y preciso.

En el modelo cuántico, los electrones no tienen órbitas definidas. En cambio, se describen mediante funciones de onda, que son soluciones a la ecuación de Schrödinger. Estas funciones de onda no nos dicen la trayectoria exacta de un electrón, sino la probabilidad de encontrar un electrón en una determinada región del espacio alrededor del núcleo. Esta región donde es más probable encontrar al electrón se llama "orbital".

Los orbitales tienen diferentes formas y tamaños, y cada uno corresponde a un nivel de energía específico. Los orbitales son esféricos, los p tienen forma de mancuerna, los d y f son más complejos. La densidad de probabilidad, que es la interpretación de la función de onda, nos da una "nube electrónica" donde la densidad de esta nube es mayor en las regiones donde es más probable encontrar al electrón.

En resumen:

Modelo Cuántico: En lugar de órbitas definidas, los electrones existen en "nubes de probabilidad" llamadas orbitales.
Funciones de Onda: Describen la probabilidad de encontrar un electrón en una determinada región del espacio.
Orbitales: Las diferentes formas (s, p, d, f) corresponden a diferentes distribuciones de probabilidad y niveles de energía.
Así que, efectivamente, los electrones están en un estado de movimiento continuo y no podemos determinar su posición exacta, sino solo la probabilidad de encontrarlo en un lugar determinado en un momento dado.


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

Podemos crear una visualización simple utilizando la biblioteca matplotlib en Python para representar el núcleo atómico y una nube de electrones en movimiento aleatorio. A continuación, os presento el código Repaso-matplotlib-Aula-38-uranio-235.py
para crear esta simulación:

Este código hace lo siguiente:

Configuración inicial: Define el número de electrones y el límite del espacio donde se moverán.
Posiciones iniciales: Genera posiciones iniciales aleatorias para los electrones dentro de un cubo centrado en el núcleo.
Gráfico: Configura el gráfico 3D utilizando matplotlib.
Núcleo y electrones: Dibuja el núcleo en el centro y los electrones en sus posiciones iniciales.
Función de actualización: Mueve los electrones aleatoriamente en cada fotograma, asegurándose de que permanezcan dentro de los límites definidos.
Animación: Utiliza FuncAnimation de matplotlib para animar el movimiento de los electrones.
Este es un modelo simplificado y no representa fielmente la mecánica cuántica, pero da una buena visualización de un núcleo y una nube de electrones moviéndose aleatoriamente alrededor
de él.

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

Umbral de órbita extrema: Se define una variable umbral_extremo que establece el límite a partir del cual consideramos que un electrón está en la órbita extrema.
Función de actualización:
Se calcula la distancia de cada electrón al núcleo usando np.linalg.norm.
Se separan los electrones en dos grupos: normales y extremos, según la distancia calculada.
Se limpian y vuelven a dibujar todos los elementos del gráfico en cada fotograma.
Se plotean los electrones normales en azul y los extremos en rosa.
Esto resaltará los electrones que están a punto de salirse de la órbita con un color rosa en la animación.

********************************************************************************************
Realizado en Linux, ubuntu.
Ejecución.
python3 Repaso-matplotlib-Aula-38-uranio-235.py

Aplicación para codificar y decodificar mensajes de texto en imágenes.

La imagen se selecciona mediante el botón "SEARCH".
En el modo "Encode" el texto a ocultar se introduce en el espacio superior. (el programa generará un nuevo archivo de imagen cuyo nombre tendrá el prefijo "encoded_" delante del título del archivo original.
En el modo "Decode" el texto oculto se muestra en el espacio superior.

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


Repositorio en GitHub:
https://github.com/antonioam82/Steganography

Programa para buscar archivos en sistema de carpetas, a partir de un directorio base, mediante el uso de expresiones regulares.


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

Programa para convertir cantidades de moneda a otras divisas (el programa muestra la tasa de cambio y el equivalente en la otra moneda) usando datos actualizados.


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

Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS

***********************************************************************************************************************
Aula_28_repaso_descenso_momentum.py
+++++++++++++++++++++++++++++++++++
Dado que existen numerosas dudas sobre la aplicación de momentúm a un descenso de gradiente.
Vamos a explicar, lo más fácil posible, en que consiste, aunquue se miráis hacía atrás encontrareis
ejercicios en esta WEB, en la que se habla de este tema con ejercicios de ejemplo.

Sí suponéis una función ondulada, sobre dos ejes coordenados, en que el eje y tiene los valores de pérdida, y el eje x tiene los valores de parámetros o entradas. Esta función ondulada tendrá diversos, valores locales mínimos, y un valor, digamos, global mínimo.
Al aplicar un momentum, lo que hacemos es que en estos valles el descenso de gradiente no se relentice, hasta llegar global mínimo.

Bien, vamos a concretar en el siguiente resumen, las particulatidades del momentum.
Luego, plantearemos el sencillo ejercicio: Aula_28_repaso_descenso_momentum.py, para ver su funcionamiento real.

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

El descenso de gradiente con momentum (o SGD con momentum, por sus siglas en inglés) es una variación del algoritmo de descenso de gradiente estocástico (SGD) que se utiliza para entrenar redes neuronales y otros modelos de aprendizaje automático.

El objetivo del descenso de gradiente es encontrar los parámetros óptimos de un modelo que minimicen la función de error.
En el caso de las redes neuronales, la función de error representa la diferencia entre las predicciones del modelo y los datos reales.

El descenso de gradiente funciona iterativamente, ajustando los parámetros del modelo en la dirección del gradiente negativo de la función de error. Esto significa que los parámetros se mueven en la dirección hacía abajo que más reduce el error.
Sin embargo, el descenso de gradiente estándar puede ser sensible al ruido en los datos y puede quedar atrapado en mínimos locales, los valles de los que hablamos anteriormente.

Aquí es donde entra en juego el momentum. El momentum introduce una especie de "memoria" en el algoritmo, lo que le permite tener en cuenta los gradientes anteriores al actualizar los parámetros. Esto ayuda a suavizar las actualizaciones y a evitar
que el algoritmo se quede oscilando o se atasque en mínimos locales.

En términos matemáticos, el momentum se implementa mediante un término adicional en la ecuación de actualización de los parámetros.
Este término es proporcional al gradiente promedio de las iteraciones anteriores y ayuda a impulsar los parámetros en la misma dirección según los cálculos más favorables para un descenso que sea optimizado.

El uso del momentum tiene varias ventajas:

Aumenta la velocidad de convergencia: El momentum puede ayudar a que el algoritmo converja al mínimo global de la función de error más rápidamente.

Reduce las oscilaciones: El momentum ayuda a suavizar las actualizaciones de los parámetros, lo que puede reducir las oscilaciones en la trayectoria del aprendizaje.

Escapa de los mínimos locales: El momentum puede ayudar al algoritmo a escapar de los mínimos locales, que son puntos en los que la función de error es localmente mínima pero no globalmente mínima.

El momentum se controla mediante un hiperparámetro llamado coeficiente de momentum, que suele estar entre 0 y 1. Un valor más alto del coeficiente de momentum da más importancia a los gradientes anteriores y puede aumentar la velocidad de convergencia, pero también puede hacer que el algoritmo sea más sensible al ruido.

En general, el descenso de gradiente con momentum es una técnica poderosa para entrenar redes neuronales y otros modelos de aprendizaje automático.
Es más rápido y más robusto que el descenso de gradiente estándar, y puede ayudar a mejorar el rendimiento general del modelo.
********************************************************************************************************************
Como dijimos anteriormente proponemos ahora el ejercicio:
Aula_28_repaso_descenso_momentum.py, que pasamos a explicar:

1-Lo primero que hacemos es importar las librerías necesarias.

En nuestro caso: Se importan las librerías necesarias: numpy para cálculos numéricos y matplotlib.pyplot para graficar los resultados.

2-Definimos la Función de Pérdida y su Gradiente.

# Función de pérdida (En nuestro caso escogemos un ejemplo simple: f(x) = x^2)
def loss_function(x):
return x**2

# Gradiente o derivada de la función de pérdida
def gradient(x):
return 2*x

3- Ahora definimos los arámetros Iniciales.

x = np.random.randn() # Con el fin de no complicarnos la vida
utilizamos random en una inicialización aleatoria de los valores de x.
learning_rate = 0.1 Esto sería el ratio de aprendizaje.
momentum = 0.9 El coeficiente del momento
velocity = 0 Y lo inicializamos con un valor 0.

4- Almacenamiento de Pérdidas con el fin de poder realizar la gráfica.
losses = [ ]

5- Ahora lo que tenemos que hacer es el bucle de entrenamiento.

Iteraciones de entrenamiento con 200 iteraciones o ciclos.

for i in range(200):
grad = gradient(x)
velocity = momentum * velocity - learning_rate * grad
x += velocity
loss = loss_function(x)
losses.append(loss)
print(f"Iteración {i+1}, x: {x}, Loss: {loss}")

El bucle de entrenamiento se ejecuta durante 200 iteraciones. En cada iteración
Se calcula el gradiente de la función de pérdida en el punto actual
Se actualiza la velocidad usando la fórmula del momentum:
Se actualiza el valor de x, sumándole la velocidad: velocity x += velocity.
Se calcula la pérdida actual usando la función de pérdida.
Se almacena el valor de la pérdida en la lista losses.
Se imprime el número de iteración, el valor de x, conla pérdida correspondiente.


5-Con el fin de hacer más intuitivo el ejercicio graficamos las pérdidas.

plt.plot(losses)
plt.xlabel('Iteración')
plt.ylabel('Pérdida')
plt.title('Descenso de Gradiente con Momentum')
plt.show()

---------------------------------------------------------------------------
--------------------------------------------------------------------------
Para este ejercicio hemos utilizado una plataforma Linux, con Ubuntu 20.04.6 LTS.
Lo hemos editado con Sublite text.
La versión de python es la 3.
Se debe tener cargado para su importación en el sistema, estos módulos:
import numpy as np
import matplotlib.pyplot as plt
*****************************************************
Ejecución bajo consola linux:
python3 Aula_28_repaso_descenso_momentum.py

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

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.

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

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