Historial de los últimos códigos añadidos

Listado de los últimos códigos introducidos.
Imágen de perfil
Actualizado

Generador de gifs a partir de video, en línea de comandos.


Python

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 17 de Junio del 2024 por Antonio (76 códigos) (Publicado el 9 de Diciembre del 2022)
9.107 visualizaciones desde el 9 de Diciembre del 2022
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.

mk
Imágen de perfil
Actualizado

Vista 'grid' (demo)


Python

Actualizado el 17 de Junio del 2024 por Antonio (76 códigos) (Publicado el 31 de Julio del 2023)
4.031 visualizaciones desde el 31 de Julio del 2023
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.

grid
Imágen de perfil
Actualizado

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(7)
Actualizado el 17 de Junio del 2024 por Rafael (22 códigos) (Publicado el 21 de Diciembre del 2022)
24.180 visualizaciones desde el 21 de Diciembre del 2022
Cx es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación

Sin-titulo
Imágen de perfil

Orbitales


Python

Publicado el 15 de Junio del 2024 por Hilario (129 códigos)
133 visualizaciones desde el 15 de Junio del 2024
Figure_1

***********************************************************************************************************
-----------------------------------------------------------------------------------------------------------------------------
Proponemos este sencillo código: Aula_28_orbital.py . Con el fin de familiarizarmos con los entornos gráficos de Python.

El código genera gráficos 3D de orbitales atómicos utilizando matplotlib y mpl_toolkits.mplot3d.
Este tipo de visualización es excelente para representar la forma de los orbitales s, p y d en tres dimensiones.

Aquí está el análisis del código y una revisión para asegurarnos de que funcione correctamente:

Importar módulos:

mpl_toolkits.mplot3d se importa para poder crear gráficos 3D.
matplotlib.pyplot se importa como plt para funciones de trazado.
numpy se importa como np para cálculos numéricos.

Crear la figura y los subgráficos:

Se crea una figura (fig) con tamaño de 15x5 pulgadas.
Se crean tres subgráficos (ax1, ax2, ax3) con proyección 3D.

Definir los datos de los orbitales:

Para el orbital s, se utilizan coordenadas esféricas.
Para el orbital p, se utilizan coordenadas que representan la forma lobular.
Para el orbital d, se utilizan coordenadas que representan una forma de doble lóbulo.

Trazar superficies:

Cada subgráfico (ax1, ax2, ax3) utiliza plot_surface para trazar la forma del orbital en el espacio 3D.
Se ajustan los límites de los ejes (set_xlim, set_ylim, set_zlim) para asegurar que todos los gráficos tengan la misma escala y sean comparables.

Configuración de etiquetas y títulos:

Se establecen etiquetas para los ejes (set_xlabel, set_ylabel, set_zlabel) y títulos (set_title) para cada subgráfico.

Mostrar el gráfico:

plt.show() se utiliza al final para mostrar la figura completa con los tres subgráficos.
El código parece estar bien estructurado para visualizar los orbitales s, p y d en 3D.
-----------------------------------------------------------------------------------------------------------------------
Asegúrate de tener matplotlib y numpy instalados en tu entorno de Python para que funcione correctamente.

-------------------------------------------------------------------------------------------------------
El ejercicio fue realizado en un entorno Linux.
Plataforma Ubuntu 20.04.6 LTS.
Editado con Sublime txt.
Imágen de perfil
Actualizado

Lector, por cámara, de códigos "QR"


Python

estrellaestrellaestrellaestrellaestrella(12)
Actualizado el 14 de Junio del 2024 por Antonio (76 códigos) (Publicado el 22 de Abril del 2020)
42.909 visualizaciones desde el 22 de Abril del 2020
El programa tiene como objeto principal, la lectura, haciendo uso de la cámara web, de códigos QR. Para ello, simplemente pulsaremos el botón "INICIAR LECTURA POR CAMARA" (que desplegará el visor de la cámara) y colocaremos el código a leer, delante de la cámara. A su vez, también podremos leer códigos QR, en formato "png" y "jpg" almacenados en nuestra computadora (para lo que usaremos la opción "CARGAR ARCHIVO". Finalmente, también podremos leer, directamente, un código que se encuentre visible en pantalla (botón "DETECTAR EN PANTALLA").

qrcc
qrcm1
Imágen de perfil

Laboratory Lite: Sistema de Gestion de Analisis de Laboratorio en PHP+MySQL


PHP

Publicado el 11 de Junio del 2024 por Agustin (20 códigos)
137 visualizaciones desde el 11 de Junio del 2024
Laboratory Lite es un sistema para manejar o administrar analisis de laboratorio, personalizable se pueden crear los examenes y agregarle parametros , ver reportes y mas.

El sistema Laboratory Lite es gratis y open source, esta creada con la plantilla Core ui y bootstrap 5.

Tambien esta desarrollada usando PHP 8 y retrocompatible con PHP 7.

Entre los modulos del sistema cuenta con los siguientes:

Usuarios
Pruebas de laboratorio
Parametros para las pruebas de laboratorio
Examenes (Asignacion Prueba de Lab y paciente.)
Ventas (Lista de Examenes)
Pacientes
Usuarios

https://evilnapsis.com/2024/06/11/laboratory-lite-sistema-de-gestion-de-analisis-de-laboratorio/
Imágen de perfil

SwitchLoggers


C sharp

Publicado el 7 de Junio del 2024 por Pere
160 visualizaciones desde el 7 de Junio del 2024
Hoy quiero compartiros una pequeña librería de clases desarrollada en C# que permite el uso e intercambio de varios loggers.

Es un proyecto sencillo que permite ver con claridad buenas prácticas de programación como:
· Uso de interfaces.
· Inyección de dependencias.
· Separación de responsabilidades.
· Escalabilidad.
· Documentación.
· Compatibilidades…

Todas las instrucciones se encuentran en Readme.md del repositorio.

Deseo que os guste y si podéis mejorarlo, sois libres de hacerlo (no olvidéis compartir y hacer 'feedback').
Imágen de perfil

Red Neuronal CNN, selección de características.


Python

Publicado el 3 de Junio del 2024 por Hilario (129 códigos)
258 visualizaciones desde el 3 de Junio del 2024
imagen
Figure_1

***********************************************************************************************************************
------------------------------------------------------------------------------------------------------------------------------------------






Aula_28_Aprendizaje_RedNeuronal_CNN.py
-----------------------------------------------------------
**************************************************

Pretendemos alojar en esta ruta de mi ordenador:/home/margarito/python/PetImages, el directorio PetImages, que a su vez contiene otros dos directorios con el nombre cat y dog. Los mismos contienen imagenes de gatos y perros. Vamos a construir una red neuronal convolucional, que dada la imagen en esta ruta:/home/margarito/python/imagen.jpeg, determine si pertenece a un gato, o a un perro. También s deberá mostrar la imagen.

Lo primero que debemos hacer es el código que descargará los datos.

# Descargar el archivo de datos
url = "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip"
filename = "kagglecatsanddogs_5340.zip"
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content).
------------------------------------------------------------------------------------------------------------------------
Las partes del ejercicio a resaltar, son las siguientes:

En general, este ejercicio describe el proceso completo de implementación de una red neuronal convolucional (CNN) usando TensorFlow para clasificar imágenes de gatos y perros. A continuación se presenta un resumen de las partes más importantes:

1. Configuración Inicial y Descarga de Datos.
---------------------------------------------------------------
Se importa TensorFlow y otras bibliotecas necesarias.
Se descarga el dataset de gatos y perros desde una URL proporcionada y se descomprime en el directorio de trabajo.

2. Preparación de los Datos.
------------------------------------
Verificación de Imágenes: Se recorren las carpetas de imágenes para verificar que no haya archivos corruptos y se eliminan los que no son válidos.
Organización del Directorio: Se aseguran que las carpetas para las categorías cat y dog existan en el directorio base.

3. Preprocesamiento de los Datos.
---------------------------------------------
Se utiliza ImageDataGenerator para realizar una reescalado de las imágenes y dividir el conjunto de datos en entrenamiento y validación.
Generadores de Datos: Se crean generadores de datos para el conjunto de entrenamiento y de validación, especificando
el tamaño de las imágenes, el tamaño del batch, y el modo de clasificación binaria.

4. Construcción del Modelo CNN.
-------------------------------------------
Se define una arquitectura secuencial de la red neuronal con capas de:
Convolución: Tres capas convolucionales con activación ReLU.
Max-Pooling: Después de cada capa convolucional.
Flatten: Para convertir los mapas de características 2D a un vector 1D.
Densa: Una capa densa con 512 neuronas y activación ReLU.
Dropout: Con una tasa del 50% para reducir el sobreajuste.
Salida: Una capa de salida con activación sigmoide para la clasificación binaria.

5. Compilación del Modelo.
-----------------------------------
El modelo se compila utilizando el optimizador Adam y la función de pérdida de binary_crossentropy, con métrica de precisión.

6. Entrenamiento del Modelo.
------------------------------------------
El modelo se entrena durante 10 épocas utilizando los generadores de datos creados anteriormente.
Se calculan los pasos por época basados en el tamaño del conjunto de entrenamiento y validación.

7. Evaluación del Modelo.
--------------------------------------
Se evalúa el modelo usando el conjunto de validación y se imprime la precisión de validación.

8. Predicción de Nuevas Imágenes.
----------------------------------------------
Se carga una nueva imagen, se preprocesa y se realiza una predicción utilizando el modelo entrenado.
Se muestra la imagen junto con la predicción (gato o perro).

9- Características del EQUIPO donde se realizó el ejercicio.
----------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Con el sistema operativo Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El adware del mismo es:
------------------------------------
Intel® Core™ i5-10400 CPU @ 2.90GHz × 12
Intel® UHD Graphics 630 (CML GT2)

Para llegar a esta exactitud o accuracy
157/157 [==============================] - 9s 56ms/step - loss: 0.8151 - accuracy: 0.8177
Validation accuracy: 81.77%, tardamos 2258.9 segundos.

Como se puede apreciar, mucho tiempo de ejecución, y muy forzado el equipo a dedicación completa.

------------------------------------------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_Aprendizaje_RedNeuronal_CNN.py.
Quien desee salvar el modelo, para experimentar con él
puede hacerlo añadiendo esta línea de código
a continuación del proceso de compilación:
# Guardar el modelo
model.save('modelo_cnn_gatos_perros.h5')
# Guarda en formato HDF5, indicando la ruta de tu ordenador donde se desee salvarlo.
Imágen de perfil

Repaso graficos con matplotlib


Python

Publicado el 29 de Mayo del 2024 por Hilario (129 códigos)
184 visualizaciones desde el 29 de Mayo del 2024
Figure_1


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

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
sin imagen de perfil

Impresiones Xml


C sharp

Publicado el 27 de Mayo del 2024 por Elías Gabriel (3 códigos)
179 visualizaciones desde el 27 de Mayo del 2024
Definí un lenguaje Xml para generar salidas por la impresora, así como también un programa que lea los archivos Xml e imprima los mismos. Quizá pueda resultar útil para alguien que desee hacer salidas por impresora sin escribir código C#, sino escribiendo un archivo Xml y utilizando una librería que se incluye en el código (PrintFramework.dll). El programa tan sólo es una utilización de esa librería para poder apreciar cómo funciona la misma. Dentro del archivo comprimido está el código escrito en SharpDevelop y también un archivo de texto con las instrucciones para escribir los archivos xml para ser parseados por la librería, así como una reseña acerca del uso de la misma.
Imágen de perfil

Aplicación para ocultar información de texto en imágenes o fotografías (nueva versión).


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 25 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 26 de Marzo del 2021)
12.998 visualizaciones desde el 26 de Marzo del 2021
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.
stgp

Repositorio en GitHub:
https://github.com/antonioam82/Steganography
Imágen de perfil

Reproductor de música.


Python

Actualizado el 25 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 20 de Abril del 2021)
23.729 visualizaciones desde el 20 de Abril del 2021
Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
mp
Imágen de perfil

CALCULADORA DE DIVISAS


Python

Actualizado el 25 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 3 de Mayo del 2024)
375 visualizaciones desde el 3 de Mayo del 2024
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.

cuc
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
Imágen de perfil

Suavizado de imagen en archivos de vídeo por 'Filtrado bilateral', (aplicación en línea de comandos)


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 23 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 20 de Marzo del 2023)
6.974 visualizaciones desde el 20 de Marzo del 2023
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
bvf
bvf2
bvf3
bvf4
Imágen de perfil

Recordatorio, descenso con momentum


Python

Publicado el 23 de Mayo del 2024 por Hilario (129 códigos)
169 visualizaciones desde el 23 de Mayo del 2024
Figure_1

***********************************************************************************************************************
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

*****************************************************
Imágen de perfil

Diagnóstico de Vibraciones


Access

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 23 de Mayo del 2024 por Petergoff
131 visualizaciones desde el 23 de Mayo del 2024
El diagnóstico de vibraciones es una técnica fundamental en el mantenimiento predictivo y la gestión de activos industriales. A través de la monitorización y el análisis de vibraciones, es posible detectar fallos en los equipos antes de que se conviertan en problemas graves, lo que permite planificar las reparaciones y minimizar los tiempos de inactividad.
Importancia del Diagnóstico de Vibraciones

Prevención de Fallos: Al detectar anomalías en las vibraciones, se pueden identificar problemas como desalineaciones, desbalances, fallos en rodamientos y desgaste de componentes antes de que provoquen un fallo catastrófico.

Reducción de Costos: La identificación temprana de problemas evita reparaciones costosas y no planificadas, alargando la vida útil de los equipos y optimizando el uso de recursos.

Mejora de la Seguridad: Equipos que funcionan sin problemas son menos propensos a fallar de manera inesperada, lo que mejora la seguridad en el entorno de trabajo.

Optimización del Rendimiento: Un equipo bien mantenido y equilibrado opera de manera más eficiente, reduciendo el consumo de energía y mejorando la productividad.

Procedimientos del Diagnóstico de Vibraciones

El diagnóstico de vibraciones se realiza mediante varios pasos que aseguran la precisión y efectividad del análisis:

Monitorización de Vibraciones:
Se utilizan sensores de vibración, como acelerómetros, para recoger datos sobre las vibraciones en tiempo real. Estos sensores se instalan en puntos estratégicos de la maquinaria para capturar datos relevantes.

Registro de Datos:
Los datos de vibración se registran durante un período de tiempo para tener una visión completa del comportamiento del equipo. Esto puede incluir condiciones de operación normal y situaciones de carga máxima.

Análisis de Señales:
Los datos registrados se analizan utilizando software especializado que puede descomponer las señales de vibración en sus componentes de frecuencia. Esto ayuda a identificar patrones y anomalías.

Diagnóstico de Problemas:
Los patrones de vibración se comparan con modelos de fallos conocidos para diagnosticar problemas específicos. Por ejemplo, una frecuencia particular puede indicar un desequilibrio, mientras que otra puede señalar un problema en un rodamiento.

Acciones Correctivas:
Con base en el diagnóstico, se planifican y ejecutan las acciones correctivas necesarias. Esto puede incluir el reemplazo de componentes defectuosos, el reajuste de alineaciones o el equilibrado de ejes.

Tecnologías Utilizadas en el Diagnóstico de Vibraciones

El avance de la tecnología ha permitido desarrollar herramientas más precisas y eficaces para el diagnóstico de vibraciones:

Acelerómetros: Sensores que miden la aceleración de las vibraciones en diferentes partes de la maquinaria. Son esenciales para captar datos precisos y en tiempo real.
Análisis de Espectro: Software que transforma las señales de vibración en un espectro de frecuencias, facilitando la identificación de fallos específicos.
Monitorización Continua: Sistemas integrados que permiten la monitorización continua de las vibraciones, alertando automáticamente sobre cualquier anomalía detectada.
Técnicas de Inteligencia Artificial: Algoritmos avanzados que pueden aprender de los datos de vibración históricos y mejorar la precisión del diagnóstico prediciendo fallos futuros.

Aplicaciones del Diagnóstico de Vibraciones

El diagnóstico de vibraciones es aplicable en diversos sectores industriales:

Industria Automotriz: Para mantener el rendimiento óptimo de motores y transmisiones.
Aeronáutica: En la monitorización de turbinas y sistemas críticos para asegurar la seguridad y eficiencia.
Manufactura: En la gestión de maquinaria pesada y equipos de producción, donde el tiempo de inactividad puede ser extremadamente costoso.
Energía Eólica: Para el mantenimiento predictivo de turbinas eólicas, asegurando su operación continua y eficiente.

El diagnóstico de vibraciones es una herramienta indispensable en el mantenimiento industrial moderno. A través de la detección temprana de fallos, la reducción de costos y la mejora de la seguridad y eficiencia operativa, esta técnica asegura que los equipos funcionen de manera óptima. Con el uso de tecnologías avanzadas y procedimientos sistemáticos, el diagnóstico de vibraciones sigue siendo una piedra angular en la gestión efectiva de activos industriales.
Imágen de perfil

Red Neuronal sólo con Numpy.


Python

Publicado el 16 de Mayo del 2024 por Hilario (129 códigos)
287 visualizaciones desde el 16 de Mayo del 2024
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
***********************************************************************
Imágen de perfil

Juego de la Serpiente, en ASCII (versión con sonido)


Python

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 13 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 8 de Junio del 2020)
11.478 visualizaciones desde el 8 de Junio del 2020
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.
sgm
sg6
sg4
ggggg
Imágen de perfil

Visor de gráficos financieros (nueva versión)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 8 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 18 de Abril del 2022)
3.623 visualizaciones desde el 18 de Abril del 2022
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.
fg
Imágen de perfil

Generador de valores hash para contraseñas.


Python

Actualizado el 5 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 20 de Noviembre del 2022)
1.956 visualizaciones desde el 20 de Noviembre del 2022
El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.
ph
Imágen de perfil

Generador de gifs a partir de video (nueva version)


Python

Actualizado el 5 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 29 de Enero del 2024)
1.215 visualizaciones desde el 29 de Enero del 2024
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.

imagge
Imágen de perfil

Sumar dos imágenes.


Python

Publicado el 2 de Mayo del 2024 por Hilario (129 códigos)
237 visualizaciones desde el 2 de Mayo del 2024
PRIMERA IMAGEN.
*********************
x

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

y

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

********************************************************************************************************
*******************************************************************************************************
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
Imágen de perfil

Aplicación de la función ReLU a cada píxel.


Python

Publicado el 29 de Abril del 2024 por Hilario (129 códigos)
155 visualizaciones desde el 29 de Abril del 2024
Figure_1
original
******************************************************
********************************************************

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
-----------------------------------------------------------------------
Imágen de perfil

Buscador de archivos mediante expresiones regulares (nueva versión)


Python

Actualizado el 27 de Abril del 2024 por Antonio (76 códigos) (Publicado el 5 de Mayo del 2022)
2.496 visualizaciones desde el 5 de Mayo del 2022
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.
ff43
ff42
ff41
Imágen de perfil

Array MNIST. Trabajo con índices.


Python

Publicado el 21 de Abril del 2024 por Hilario (129 códigos)
283 visualizaciones desde el 21 de Abril del 2024
Figure_1
Figure_2
Figure_3

******************************************************************************************************************
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
Imágen de perfil
Val: 39
Ha disminuido 1 puesto en Java (en relación al último mes)
Gráfica de Java

Piano


Java

Actualizado el 17 de Abril del 2024 por Diego (6 códigos) (Publicado el 1 de Septiembre del 2020)
4.464 visualizaciones desde el 1 de Septiembre del 2020
fk
Imágen de perfil

Juego de la Serpiente (en ASCII)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 12 de Abril del 2024 por Antonio (76 códigos) (Publicado el 30 de Marzo del 2020)
6.929 visualizaciones desde el 30 de Marzo del 2020
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".
sg4
sg7
sng
Imágen de perfil

Visor de gráficos financieros.


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 1 de Abril del 2024 por Antonio (76 códigos) (Publicado el 7 de Julio del 2021)
9.423 visualizaciones desde el 7 de Julio del 2021
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.
gf