Mostrar los tags: li

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

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

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

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

El programa muestra información relativa al precio máximo, mínimo, de apertura y cierre de un activo financiero (estos se irán almacenando en el archivo "symbols" que se generará al ejecutar el programa por primera vez) y para un periodo de tiempo. También muestra los gráficos relativos a las medias móviles exponenciales de 50 y 200 sesiones.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

Sencillo_Concep_Pixel_Aula_28.py
**********************




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

Con este sencillo y diminuto ejercicio, tratamos de explicar algunas dudas conceptuales sobre el tratamiento y comprensión
del funcionamiento de los pixeles. Aula 28.
-----------------------------------------------------------------------------------------------------------------------

Definición de los valores del píxel:
------------------------------------------------
Se especifican los valores de los canales rojo, verde y azul del píxel. En este caso, son [88, 15, 108].

Visualización de la imagen sin normalización:
---------------------------------------------------------------
Se crea una imagen de 1x1 píxeles con los valores de los canales y se muestra directamente. La escala de colores refleja los valores originales sin ajustes.

Normalización de los valores de los canales:
--------------------------------------------------------------
Se normalizan los valores de los canales dividiéndolos por 255.0. Este paso es común en procesamiento de imágenes para asegurarse de que los valores estén en el rango [0, 1].

Visualización de la imagen normalizada:
--------------------------------------------------------
Se crea una nueva imagen con los valores normalizados y se muestra. La escala de colores ahora refleja los valores ajustados al rango [0, 1].

Impresión de la matriz normalizada:
--------------------------------------------------
La matriz normalizada se imprime en la consola. Esto muestra cómo los valores de los canales se han ajustado a la escala [0, 1].

En resumen, el código realiza dos visualizaciones de un píxel: una con los valores de los canales originales y otra después de normalizar esos valores para asegurarse de que estén en un rango comprensible para la visualización de colores.

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



***********************************************************************************************
Realizado en Plataforma Linux. Ubuntu 20.04.6 LTS
Editado con Sublime text.
Ejecución:python3 Sencillo_Concep_Pixel_Aula_28.py
************************************************************************************************

Aula_68_EP_IA.py
************************************************************************
Proponemos este nuevo ejercicio prosiguiendo con el aprendizaje sobre convoluciones y max pooling, en el tratamiento de una imagen en OpenCV.
Esquemáticamente este ejercicio implementas varios conceptos importantes:

*Carga de la imagen con cv2
*Conversión a escala de grises
*Definición de un kernel de convolución 3x3
*Aplicación de múltiples convoluciones en loops (8 iteraciones)
*Reducción del tamaño de la imagen con max pooling después de cada convolución
*Impresión de los valores de píxeles resultantes
*Visualización de la imagen original vs la imagen procesada
*Adicionalmente, la función que imprime los valores de pixeles con sus índices es muy útil para inspeccionar los cambios paso a paso después de cada iteración.

La salida debe mostrar efectivamente cómo se suaviza y resalta el contraste en la imagen resultado, después de aplicar las capas de convolución y pooling.

En resumen, el código trata de ser sencillo y didáctico, para mostrar el efecto que tiene aplicar una CNN sobre imágenes. En este caso con 8 convoluciones.

El ejercicio permite modificar parametros para observar nuevos valores y matices en la imagen.

El siguiente paso sería, en otro ejercicio, la aplanación de los valores obtenidos para pasar y entregarlos a una red neuronal con capas Completamente Conectadas (Densas):

Esto quiere decir que después de las capas de convolución y agrupación, la red puede incluir capas completamente conectadas. En estas capas, todas las neuronas están conectadas entre sí, para optener el resultado final que pretendemos en el modelo que vayamos a crear.

Eso tendrá cabida, como dije, en un próximo ejercicio.

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

El ahorcado o Hangman es un mini juego clásico en el cual se debe adivinar la palabra, desarrollado en lenguaje kotlin, a modo de practica, Obviamente es una primera versión, se puede mejorar, compartiré el codigo fuente que esta en mi GitHub por si quieren descargar el codigo y modificarlo a su gusto





Codigo Fuente

https://github.com/x-cevh-x/ElAhorcadoKotlin

DesGraMul_Aula_B_228_15_oct_Github.ipynb

Este ejercicio trata de realizar un descenso de gradiente múltiple en un contexto de gráficos 3D a partir de un punto (x, y) específico. El descenso de gradiente múltiple es una técnica de optimización utilizada para encontrar los mínimos locales o globales de una función multivariable.

Aquí hay una descripción general de cómo puedes abordar este problema:

Función Objetivo: Primero, necesitas tener una función objetivo que desees optimizar en el contexto 3D. Supongamos que tienes una función f(x, y) que deseas minimizar.

Derivadas Parciales: Calcula las derivadas parciales de la función con respecto a x y a y. Estas derivadas parciales te dirán cómo cambia la función cuando modificas x e y.

Punto Inicial: Comienza en un punto (x0, y0) dado. Este será tu punto de inicio.

Tasa de Aprendizaje: Define una tasa de aprendizaje (alfa), que es un valor pequeño que controla cuánto debes moverte en cada iteración del descenso de gradiente. La elección de alfa es crucial y puede requerir ajustes.

Iteraciones: Itera a través de las siguientes fórmulas hasta que converjas a un mínimo:

Nuevo x: x1 = x0 - alfa * (∂f/∂x)
Nuevo y: y1 = y0 - alfa * (∂f/∂y)

Condición de Parada: Puedes definir una condición de parada, como un número máximo de iteraciones o un umbral de convergencia (por ejemplo, cuando las derivadas parciales son muy cercanas a cero).

Resultados: Al final de las iteraciones, obtendrás los valores de (x, y) que minimizan la función en el contexto 3D.

Es importante recordar que el éxito del descenso de gradiente depende de la elección adecuada de la tasa de aprendizaje, la función objetivo y las condiciones iniciales. Además, en problemas 3D más complejos, es posible que desees considerar algoritmos de optimización más avanzados, como el descenso de gradiente estocástico o métodos de optimización de segundo orden.

Este es un enfoque general para el descenso de gradiente múltiple en un contexto 3D. Los detalles pueden variar según la función objetivo y las necesidades específicas de tu aplicación.