Historial de los últimos códigos añadidos

Listado de los últimos códigos introducidos.
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

Generador de gifs a partir de video (nueva version)


Python

Actualizado el 18 de Abril del 2024 por Antonio (75 códigos) (Publicado el 29 de Enero del 2024)
630 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

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


Python

Actualizado el 17 de Abril del 2024 por Antonio (75 códigos) (Publicado el 20 de Marzo del 2023)
6.036 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
Actualizado

Piano


Java

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

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 15 de Abril del 2024 por Rafael (22 códigos) (Publicado el 21 de Diciembre del 2022)
18.930 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

Juego de la Serpiente (en ASCII)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 12 de Abril del 2024 por Antonio (75 códigos) (Publicado el 30 de Marzo del 2020)
6.761 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

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


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 11 de Abril del 2024 por Antonio (75 códigos) (Publicado el 18 de Abril del 2022)
3.267 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

Vista 'grid' (demo)


Python

Actualizado el 9 de Abril del 2024 por Antonio (75 códigos) (Publicado el 31 de Julio del 2023)
2.486 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

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


Python

Actualizado el 9 de Abril del 2024 por Antonio (75 códigos) (Publicado el 5 de Mayo del 2022)
2.285 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Reproductor de música.


Python

Actualizado el 3 de Abril del 2024 por Antonio (75 códigos) (Publicado el 20 de Abril del 2021)
23.270 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

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


Python

estrellaestrellaestrellaestrellaestrella(4)
Actualizado el 3 de Abril del 2024 por Antonio (75 códigos) (Publicado el 9 de Diciembre del 2022)
8.154 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Visor de gráficos financieros.


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 1 de Abril del 2024 por Antonio (75 códigos) (Publicado el 7 de Julio del 2021)
9.142 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
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

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


Python

estrellaestrellaestrellaestrellaestrella(12)
Actualizado el 27 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 22 de Abril del 2020)
42.159 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

Red neuronal CNN, detección de clases.


Python

Publicado el 24 de Marzo del 2024 por Hilario (121 códigos)
246 visualizaciones desde el 24 de Marzo del 2024
CLASES DE IMAGENES CON UNA MUESTRA DE CADA UNA.
-----------------------------------------------------------------------------------
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5

***************************************************************
IMAGEN PROPUESTA A EVALUAR.
------------------------------------------------------------------------------

imagen

****************************************************************************************************************
TUTORIAL DEL EJERCICIO.
--------------------------------------
Este ejercicio que propongo hoy, está realizado con el fin de entender la dinámica, o forma de realizar una red neuronal CNN.

Está compuesto por tres códigos:

1- Aula_28_Descarga_Imagenes.py
-------------------------------
En este primer código accedemos a:
dataset_url = https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"

De donde descargamos las imagenes necesarias para realizar el posterior modelo.
Las imagenes se guardaran, en nuestro usuario de Linux -Ubuntu-, en un fichero oculto (.Keras),
en un directorio llamado Datasets, en mi caso con la siguiente ruta: /home/margarito/.keras/datasets/flower_photos.
En el directorio:flower_photos, encontraremos las imagenes de las flores, con las clases a que corresponden.

Tres directorios con imágenes de estas clases:

-flower_photos
--daisy
--dandelion
--roses
--sunflowers
--tulips

Con el fin de utilizar estas imagenes de forma indirecta, copiaremos el directorio:-flower_photos
y lo pegaremos en nuestro directorio de usuario.
Al ejecutar este código, se muestra una imagen de cada clase.
---------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib


*************************************************************************************************************
2-Aula_28_Entreno_Modelo.py
--------------------------
Con este código, lo que hacemos es entrenar el modelo, salvandolo una vez entrenado en nuestro usuario, en el directorio donde tengamos nuestros códigos.

Básicamente este código hace lo siguiente:

Este código en Python utiliza TensorFlow y Keras para construir y entrenar una red
neuronal convolucional (CNN) para clasificar imágenes de flores. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa TensorFlow y algunas clases específicas
de Keras necesarias para el procesamiento de imágenes.

Definición de directorios y ruta del modelo:
Establece las rutas de los directorios donde se encuentran
los datos de entrenamiento de imágenes de flores y donde se guardará el modelo entrenado.

Parámetros de entrenamiento:
Define los parámetros para el entrenamiento,
como el tamaño del lote, la altura y el ancho de las imágenes, y el número de épocas.

Generador de datos de entrenamiento:
Crea un generador de datos de imágenes de entrenamiento
utilizando la clase ImageDataGenerator de Keras.
Esta clase realiza aumento de datos, como escalamiento, recorte, volteo horizontal, etc.

Configuración de generadores de flujo de datos de entrenamiento
y validación:
Configura los generadores de flujo de datos
de entrenamiento y validación utilizando el directorio de datos
de entrenamiento y especificando la división para la validación.

Creación del modelo CNN:
Define el modelo de la CNN utilizando
Sequential de Keras, que es una pila lineal de capas.
El modelo consta de varias capas convolucionales y de agrupación (pooling),
seguidas de capas totalmente conectadas. La última capa utiliza una función
de activación softmax para la clasificación de las clases de flores.

Compilación del modelo:
Compila el modelo especificando el optimizador,
la función de pérdida y las métricas para el entrenamiento.

Entrenamiento del modelo:
Entrena el modelo utilizando los generadores de flujo de datos de entrenamiento y validación.

Guardado del modelo:
Guarda el modelo entrenado en la ruta especificada.

Mensaje de finalización:
Imprime un mensaje para indicar que el modelo ha sido entrenado y guardado correctamente.

Como podéis apreciar, en mi caso de linux, las rutas donde tengo los datos,
y el lugar donde gusrado el modelo, es el siguiente:
# Rutas de los directorios de datos
train_dir = '/home/margarito/python/flower_photos'
model_path = '/home/margarito/python/Mi_Modelo_Hilario.h5'
******************************************************************************************************************

Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------------------------------------------------
3-Aula_28_Probar_Modelo.py
-------------------------
Con este código voy a probar el modelo.
En mi caso he sacado una fotografia, a una flor silvestre de diente de leon,
con el fin de evaluar el acierto de mi programa.
Este programa podría resumirse de la siguiente forma:

Este código realiza la inferencia de una imagen de flor utilizando un modelo de red neuronal convolucional (CNN) previamente entrenado. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa las bibliotecas necesarias, incluyendo NumPy para manipulación de matrices
y TensorFlow para el uso del modelo y la preprocesamiento de imágenes.

Cargar el modelo previamente entrenado:
Carga el modelo de CNN previamente entrenado desde la ruta especificada en modelo_ruta.

Ruta de la imagen de la flor:
Define la ruta de la imagen de la flor que se desea clasificar.

Cargar y redimensionar la imagen:
Carga la imagen de la flor desde la ruta especificada
y la redimensiona al tamaño requerido por el modelo, que es 224x224 píxeles.

Convertir la imagen a un array numpy:
Convierte la imagen cargada en un array numpy para que pueda ser procesada por el modelo.

Preprocesamiento de la imagen:
Realiza cualquier preprocesamiento necesario en la imagen, en este caso,
expandiendo las dimensiones del array para que coincida con el formato de entrada esperado por el modelo.

Normalización de los valores de píxeles:
Normaliza los valores de píxeles de la imagen para que estén en el rango de 0 a 1,
lo que es comúnmente necesario para la entrada de los modelos de redes neuronales.

Hacer la predicción:
Utiliza el modelo cargado para realizar la predicción en la imagen preprocesada.

Obtener la clase predicha:
Identifica la clase predicha asignando etiquetas de clases a las salidas del modelo
y seleccionando la clase con el valor de probabilidad más alto.

Imprimir la clase predicha:
Imprime la clase predicha de la flor en la imagen.

En resumen, este código toma una imagen de una flor,
la procesa adecuadamente para que pueda ser ingresada
al modelo, la clasifica utilizando el modelo
previamente entrenado y luego imprime la
clase predicha de la flor en la imagen.
------------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image

*********************************************************************************
Estos ejercicios han sido realizados y ejecutados bajo consola linux.
Concretamente bajo Ubuntu 20.04.6 LTS.
Fueron editados con Sublime text.

Debereis de tener en cuenta que para la ejecución de los ejercicios
deberéis tener instaladas las librerías y módulos necesarios, segfún se indica en cada código.
----------------------------------------------

SALIDA, EN MI CASO DEL EJERCICIO DE LA IMAGEN PROPUESTA DE EVALUACIÓN:

2024-03-24 12:47:54.765845: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.797982: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.798348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-03-24 12:47:55.329900: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT

1/1 [==============================] - ETA: 0s
1/1 [==============================] - 0s 114ms/step
La flor en la imagen es: dandelion
[Finished in 2.9s]
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Stock Monitor


Python

Actualizado el 18 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 22 de Octubre del 2023)
1.235 visualizaciones desde el 22 de Octubre del 2023
El siguiente script muestra en tiempo real las cotizaciones en bolsa, de acciones e índices bursátiles.
El programa utiliza un bucle en el que va realizando sucesivas peticiones de datos, usando 'yfinance'. Entre una petición y la siguiente, media un tiempo en segundos que viene determinado por la opción '-delay/--time_delay', teniendo un valor por defecto de 5 segundos y no pudiendo ser inferior a 0.5
Para detener la obtención de datos, pulsar la barra espaciadora. Al hacerlo, el programa mostrará el texto 'wait until application ends..' ya que tendrá que esperar el tiempo que quede restante del especificado por '-delay/--time_delay'. Finalizando definitivamente, transcurrido dicho tiempo restante.

ARGUMENTOS:
'-tick/--ticker' : Ticker o símbolo del valor cuya cotización se quiere obtener.
'-delay/--time_delay': Periodicidad, en segundos, entre una petición de datos y la siguiente.
'-clr/--color': Mostrar precio de cierre en color, en función de su fluctuación respecto del valor anterior.
'-uind/--use_index': Incluir esta opción para obtener cotizaciones de índices bursátiles (ej: ^IXIC, ^DJI..)

La petición de valores se interrumpe pulsando la barra espaciadora.
PARA CUALQUIER DUDA U OBSERVACIÓN, UTILICEN LA SECCIÓN DE COMENTARIOS.

sm1
sm2
sm3
Imágen de perfil

Evaluación con datos MINIST.


Python

Publicado el 10 de Marzo del 2024 por Hilario (121 códigos)
248 visualizaciones desde el 10 de Marzo del 2024
NÚMERO A PREDECIR.
--------------------------------
numero

*******************************************************************************************************************
Evaluamos como aprendizaje este ejercicio: Aula_18_Evaluar_CNN_Datos_Minist.py.
Este ejercicio propuesto está entrenado con datos MINIST.
Con el fin de que el Alunno, pueda apreciar la configuracion, y la estructura de datos,
guardamos el módulo entrenado en nuestro ordenador, en formato directorio, con el nombre :
MI-MODULO-MINIST


MNIST se refiere a un conjunto de datos muy utilizado
en el ámbito de la visión por computadora y el aprendizaje profundo.

El conjunto de datos MNIST consiste en imágenes de dígitos escritos
a mano, del 0 al 9. Cada imagen es en escala de grises y tiene un
tamaño de 28x28 píxeles. El conjunto está dividido en un conjunto
de entrenamiento y un conjunto de prueba, y se utiliza comúnmente
como punto de partida para probar algoritmos y modelos de aprendizaje
automático, especialmente en el contexto de reconocimiento de dígitos.

En nuestro código, estamos utilizando el conjunto de datos MNIST
proporcionado por TensorFlow para entrenar y evaluar tu red neuronal
convolucional (CNN) en el reconocimiento de estos dígitos manuscritos.

Como podemos apreciar, la evaluación del ejercicio, no es del todo positiva.
El alumno puede modificarlo para intentar ajustarlo.

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

El ejercicio propuesto podríamos describirlo, por pasos de la siguiente
forma:

Importaciones de Bibliotecas:
********************************

Se importa TensorFlow, una biblioteca popular para aprendizaje profundo y otras tareas de machine learning.
Se importan clases y funciones específicas de TensorFlow, como Dense, Flatten, Conv2D, Model, y otras necesarias para construir y entrenar modelos de redes neuronales.
Carga de Datos MNIST:

Utiliza TensorFlow para cargar el conjunto de datos MNIST, que consiste en imágenes de dígitos escritos a mano y sus respectivas etiquetas de clase (números del 0 al 9).
Normaliza las imágenes dividiendo los valores de píxeles por 255.0.

Preparación de Datos:
************************
Añade una dimensión extra a las imágenes para representar los canales de color (en este caso, escala de grises).
Crea conjuntos de datos (train_ds y test_ds) usando TensorFlow Dataset API para facilitar el manejo y la alimentación de datos durante el entrenamiento y prueba.

Definimos el Modelo:
***********************
Define una clase MyModel que hereda de la clase Model. Esta clase representa el modelo de la red neuronal convolucional (CNN) que se construirá.
En el constructor (__init__), se definen capas de convolución, aplanado (flatten), y capas densas.
En el método call, se define la secuencia de operaciones para la propagación hacia adelante.

Configuración de Entrenamiento:
************************************
Define funciones de pérdida, optimizador y métricas para la fase de entrenamiento.
Define funciones train_step y test_step utilizando decoradores de TensorFlow (@tf.function) para ejecutar estas funciones de manera eficiente en modo gráfico.

Bucle de Entrenamiento:
***************************
Itera a través de un número de épocas predefinido (EPOCHS).
En cada época, realiza un bucle de entrenamiento y otro de prueba.
Muestra métricas como pérdida y precisión durante el entrenamiento y la prueba.

Guardamos del Modelo:
*******************
Guarda el modelo entrenado en un directorio especificado.

Carga de Imagen para Predicción:
*******************************
Intenta cargar una imagen (numero.jpg) para realizar una predicción utilizando el modelo entrenado.
Se produce un error debido a que el archivo no se encuentra en la ubicación especificada.

Impresión de Resultados:
*****************************
Imprime el número predicho y el porcentaje de precisión para la clase predicha.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

TensorFlow version: 2.13.1
Por favor, ESPERA A REALIZAR LAS 10 EPOCHS
Epoch 1, Loss: 0.13401952385902405, Accuracy: 95.94000244140625, Test Loss: 0.06022726744413376, Test Accuracy: 98.1500015258789
Epoch 2, Loss: 0.04087728634476662, Accuracy: 98.68333435058594, Test Loss: 0.055624209344387054, Test Accuracy: 98.18999481201172
Epoch 3, Loss: 0.02175530232489109, Accuracy: 99.288330078125, Test Loss: 0.05986746773123741, Test Accuracy: 98.12999725341797
Epoch 4, Loss: 0.013109182007610798, Accuracy: 99.57167053222656, Test Loss: 0.05405193939805031, Test Accuracy: 98.32999420166016
Epoch 5, Loss: 0.008494390174746513, Accuracy: 99.70832824707031, Test Loss: 0.06368830800056458, Test Accuracy: 98.44999694824219
Epoch 6, Loss: 0.008195172995328903, Accuracy: 99.7249984741211, Test Loss: 0.07445775717496872, Test Accuracy: 98.33999633789062
Epoch 7, Loss: 0.005741223692893982, Accuracy: 99.8066635131836, Test Loss: 0.07288998365402222, Test Accuracy: 98.38999938964844
Epoch 8, Loss: 0.003435570513829589, Accuracy: 99.8933334350586, Test Loss: 0.08180861920118332, Test Accuracy: 98.32999420166016
Epoch 9, Loss: 0.0059661963023245335, Accuracy: 99.80500030517578, Test Loss: 0.0844760537147522, Test Accuracy: 98.25999450683594
Epoch 10, Loss: 0.002849259879440069, Accuracy: 99.90166473388672, Test Loss: 0.08755964040756226, Test Accuracy: 98.3499984741211
Salvamos MI-MODULO-MINIST
1/1 [==============================] - 0s 49ms/step
Número predicho: 3 <-------------------En esta predicción hemos tenido éxito.
Porcentaje de precisión: 39.92%

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

El alumno, deberá tener cargadas las librerias necesarias en el sistema.
import tensorflow as tf
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing import image
import numpy as np

------------------------------------------------------------
Ejecución bajo consola Linux.
python3 Aula_18_Evaluar_CNN_Datos_Minist.py
Imágen de perfil

InceptionV3


Python

Publicado el 7 de Marzo del 2024 por Hilario (121 códigos)
239 visualizaciones desde el 7 de Marzo del 2024
IMAGEN A PREDECIR.
-------------------------------
predice

********************************************************************************************************************
Pretendemos evaluar el acierto de este ejercicio de red neuronal convolucional, CNN.
-----------------------------------------------------------------------------------------------------------------
Planteamos el sencillo código: Aula_28_inception_v3.py, utilizando una arquitectura de red neuronal convolucional (CNN), que se utiliza comúnmente para tareas de visión por computadora, como clasificación de imágenes.
Fue desarrollada por Google y es parte de la familia de modelos Inception.

La idea clave detrás de InceptionV3 es utilizar múltiples tamaños de filtros convolucionales
en paralelo para capturar patrones de diferentes escalas en una imagen. En lugar de elegir
un solo tamaño de filtro, InceptionV3 utiliza varios tamaños, desde pequeños hasta grandes,
y luego concatena las salidas de estos filtros para formar una representación más rica y completa de la imagen.

Además, InceptionV3 incorpora módulos llamados "módulos de Inception",
que son bloques de construcción que contienen diferentes operaciones convolucionales en paralelo.
Estos módulos permiten que la red aprenda representaciones más complejas y abstractas de las imágenes.

Sus principales características y funciones son las siguientes:

Extracción jerárquica de características: InceptionV3 utiliza capas convolucionales
para extraer características jerárquicas de las imágenes. Estas capas aprenden patrones
simples en las capas iniciales y patrones más complejos y abstractos a medida que se profundiza en la red.

Módulos de Inception: La arquitectura de InceptionV3 utiliza módulos llamados "módulos de Inception" o "bloques Inception".
Estos módulos incorporan múltiples operaciones convolucionales de diferentes tamaños de filtro en paralelo. Al hacerlo,
la red puede capturar patrones de información a diferentes escalas en una imagen.

Reducción de dimensionalidad: InceptionV3 incluye capas de reducción de dimensionalidad,
como capas de agrupación máxima y capas de convolución 1x1, para reducir la cantidad de
parámetros y operaciones, haciendo que la red sea más eficiente y manejable.

Regularización: La red incluye técnicas de regularización, como la normalización por lotes y la
regularización L2, para prevenir el sobreajuste y mejorar la generalización del modelo.

Arquitectura profunda: InceptionV3 es una red profunda con muchas capas, lo que le permite
aprender representaciones complejas y abstractas de las imágenes, lo que es beneficioso
para tareas de clasificación de imágenes en conjuntos de datos grandes y complejos.
**************************************************************************************
SALIDA DEL EJERCICIO, AL APORTAR LA IMAGEN DE MUESTRA.
1/1 [==============================] - ETA: 0s
1/1 [==============================] - 1s 744ms/step
1: trailer_truck (0.70)
2: moving_van (0.08)
3: garbage_truck (0.05)
[Finished in 3.9s]
**************************************************************************************
Se debera modificar en el código, la ruta de la imagen de muestra desde tu ordenador.
*************************************************************************************

El ejercicio ha sido realizado bajo plataforma linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
Ejecución bajo consola linux:
python3 Aula_28_inception_v3.py
---------------------------------------------------------------------------------------
Imágen de perfil

Comprobar eficacia, código CNN.


Python

Publicado el 6 de Marzo del 2024 por Hilario (121 códigos)
154 visualizaciones desde el 6 de Marzo del 2024
IMAGEN A PREDECIR.
-----------------------------

zapato

El codigo de estudio, fue recogido en la página oficial de Tensorflow, con el Copyright (c) 2017 de François Chollet.

Ver nota final de uso.
Lo que trato con este ejercicio, es añadirle un tramo de código, con el fin de probar su eficacia al añadirle la predicción de una imagen aportada por mí.
Por lo que pude apreciar, los resultados no son del todo halagueños.


# Copyright (c) 2017 François Chollet
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
Imágen de perfil

CALENARIO


C sharp

Publicado el 6 de Marzo del 2024 por Benito De Jesus
136 visualizaciones desde el 6 de Marzo del 2024
calendario en base a inicio de semana domingo, especial para empresas que manejan proceso de produccion semanal como bananeras
Calendario1
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Colector de links


Python

Actualizado el 2 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 6 de Marzo del 2022)
3.419 visualizaciones desde el 6 de Marzo del 2022
Aplicación para guardar accesos directos a internet (que se guardan en un archivo 'json' que se genera al ejecutar el programa por primera vez), mediante la introducción de la URL en la entrada superior (o su copia mediante el botón 'IMPORT NEW LINK'). El nuevo acceso se guarda mediante el botón "SAVE LINK AS:" que abrirá una ventana pidiendo el nombre del nuevo acceso. Una vez guardado el acceso, se podrá acceder a la correspondiente página seleccionando, en la lista, el elemento guardado y clicando en el botón 'ACCESS' (admite selección normal y múltiple). También permite la eliminación la totalidad de los link o solo los seleccionados. También permite la búsqueda por nombre entre los accesos guardados. El botón "SAVE LIST" generará un archivo de texto con los nombres de enlace y sus correspondientes URLs asociadas, que estén almacenados en el archivo JSON.
PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.
LNKC
Imágen de perfil

PyTorch


Python

Publicado el 29 de Febrero del 2024 por Hilario (121 códigos)
221 visualizaciones desde el 29 de Febrero del 2024
Imagen a predecir.

***********************************************************
perro

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

Propongo el ejercicio: Aula_18_Ejercicio_torch.py
Este ejercicio fue realizado con PyTorch.
En mi caso lo he editado con Sublime text, y lo he ejecutado bajo consola
con Ubuntu 20.04.6 LTS.

Si se tuviera problemas para ejecutarlo bajo consola linux, por sosportación CUDA, al no tener GPU Nvidia, se podría optar
por su edición y ejecución bajo Google Colab, utilizando Drive de Google, como almacenamiento.
*******************************************************************************************************************
El ejercicio, muestra la opción más posible por porcentajes, y nos remite a una página web para comprobar el resultado.

Vease una salida tipo:

SALIDA POR CONSOLA LINUX.
West Highland white terrier 0.7944785952568054
Maltese dog 0.025748323649168015
Norwich terrier 0.013491143472492695
Scotch terrier 0.0073037706315517426
cairn 0.005692108068615198
Para ver imágenes de 'West Highland white terrier', visita: https://www.google.com/search?q=West+Highland+white+terrier&tbm=isch

****************************************************************************************************************************************************************************************************************************************
PyTorch, un marco de trabajo de aprendizaje profundo (deep learning) de código abierto desarrollado por Facebook. PyTorch es conocido por su flexibilidad y facilidad de uso, y es utilizado tanto en la investigación académica como en la producción industrial para desarrollar y entrenar modelos de aprendizaje profundo.

A continuación, se describen algunos aspectos clave de PyTorch:

Tensores:
PyTorch utiliza tensores como su estructura de datos fundamental. Los tensores son similares a los arreglos multidimensionales de NumPy y pueden representar datos numéricos para entrenar modelos de aprendizaje profundo.
Autograd:
PyTorch incorpora un sistema de diferenciación automática llamado Autograd. Este sistema permite calcular automáticamente gradientes para los tensores, facilitando la retropropagación y el entrenamiento de modelos.
Dinámica de gráficos computacionales:
A diferencia de algunos otros marcos de trabajo de aprendizaje profundo que utilizan gráficos computacionales estáticos, PyTorch utiliza gráficos computacionales dinámicos. Esto proporciona flexibilidad al construir y modificar dinámicamente la estructura del grafo durante la ejecución.
API amigable:
PyTorch ofrece una API amigable y fácil de usar que facilita el proceso de experimentación y desarrollo. Esto ha contribuido a su popularidad en la comunidad de investigación y desarrollo de aprendizaje profundo.
Módulos para visión, procesamiento de lenguaje natural, etc.:

PyTorch cuenta con diversos módulos y paquetes, como torchvision para visión por computadora, torchtext para procesamiento de lenguaje natural, y otros, que facilitan el desarrollo de modelos en diversas áreas de aplicación.
Compatibilidad con GPU:
PyTorch está diseñado para aprovechar el rendimiento de las GPU para acelerar el entrenamiento de modelos. Esto se logra mediante la ejecución de operaciones en tensores en GPU cuando sea posible.

Comunidad activa y soporte:

PyTorch cuenta con una comunidad activa de usuarios y desarrolladores, y hay una amplia variedad de recursos, tutoriales y documentación disponible.
En resumen, PyTorch (o simplemente torch en referencia a su nombre de paquete) es un marco de trabajo de aprendizaje profundo que ha ganado popularidad debido a su flexibilidad, facilidad de uso y la adopción en la comunidad de investigación y desarrollo de inteligencia artificial.


********************************************************************************************************************
Este script de Python utiliza PyTorch y la biblioteca de visión de torchvision para cargar un modelo de red neuronal preentrenado
(GoogleNet) y realizar inferencias sobre una imagen específica. Aquí está una descripción paso a paso del código:

Importación de bibliotecas:
import torch
from PIL import Image
from torchvision import transforms

torch: Librería principal de PyTorch.
Image: Clase de la biblioteca Python Imaging Library (PIL) para trabajar con imágenes.
transforms: Módulo de torchvision que proporciona funciones para realizar transformaciones en imágenes, como cambiar el tamaño, recortar, etc.

***********************************************************************
Carga del modelo preentrenado:

model = torch.hub.load('pytorch/vision:v0.10.0', 'googlenet', pretrained=True)
model.eval()

*******************************************************************************
Preprocesamiento de la imagen:

preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

Se define una serie de transformaciones para preprocesar la imagen, incluyendo el cambio de tamaño, recorte, conversión a tensor y normalización.
*******************************************************************************
Carga de la imagen y aplicación del preprocesamiento:

input_image = Image.open(image_path_drive)
input_tensor = preprocess(input_image)
input_batch = input_tensor.unsqueeze(0)

Se carga la imagen desde la ruta especificada y se aplica el preprocesamiento.
**************************************************************************************
Transferencia a GPU (si está disponible):
if torch.cuda.is_available():
input_batch = input_batch.to('cuda')
model.to('cuda')

Si la GPU está disponible, se mueve tanto la entrada como el modelo a la GPU.
**********************************************************************************************
Inferencia del modelo:
with torch.no_grad():
output = model(input_batch)
Se realiza la inferencia en el modelo preentrenado para obtener las puntuaciones de salida
**************************************************************************************************
Postprocesamiento y visualización de resultados:
probabilities = torch.nn.functional.softmax(output[0], dim=0)
top5_prob, top5_catid = torch.topk(probabilities, 5)

for i in range(top5_prob.size(0)):
print(categories[top5_catid[i]], top5_prob[i].item())

Se calculan las probabilidades utilizando softmax y se imprimen las cinco categorías principales junto con sus puntuaciones de confianza.
*********************************************************************************************************

Búsqueda en Google Imagenes:

top_category = categories[top5_catid[0]]
search_query = top_category.replace(" ", "+")
search_link = f"https://www.google.com/search?q={search_query}&tbm=isch"
print(f"Para ver imágenes de '{top_category}', visita: {search_link}")

Se selecciona la categoría principal (la de mayor puntuación) y se construye un enlace para buscar imágenes relacionadas en Google Images.
********************************************************************************************************************

En resumen, este programa demuestra cómo cargar un modelo preentrenado, realizar inferencias en una imagen,
y luego visualizar las categorías principales y realizar una búsqueda en Google Images basada en la categoría principal identificada por el modelo.

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

EXIGENCIAS PARA SU DEBIDA EJECUCIÓN BAJO LINUX.
----------------------------------------------

Preparar la carga de librerías para un sistema Linux.
En concreto: Ubuntu 20.04.6 LTS. Se deberán cargar de
la siguiente forma, y en esta secuencia, en consola Linux:

sudo apt-get update
sudo apt-get install -y python3-pip python3-dev python3-venv
sudo apt-get install -y libopenblas-base libopenmpi-dev

-----------------------------------------------------
python3 -m venv myenv
source myenv/bin/activate

----------------------------------------------------
pip install torch torchvision torchaudio

----------------------------------------------
Comprobamos que todo ha ido bien:
import torch
print(torch.__version__)

----------------------------------------------------
También debemos descargar a nuestro directorio actual de ejecucion:imagenet_classes.txt
con este comando:
wget https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt

Debemos bajar la imagen de una raza de perro, y proporcionar la ruta para
que el programa haga la predicción. En mi caso sería:
image_path_drive = '/home/margarito/python/perro.jpg'

****************************************************************************
Como comenté en mi caso, el ejercicio fue realizado en una plataforma Linux.
Ubuntu 20.04.6 LTS.
Ejecución bajo consola con este comando:
python3 Aula_18_Ejercicio_torch.py

----------------------------------------------------------------------------------------------------------------------------------------
Imágen de perfil

Estructura de un Pixel.


Python

Publicado el 26 de Febrero del 2024 por Hilario (121 códigos)
203 visualizaciones desde el 26 de Febrero del 2024
1
2
3
4
5
6

***********************************************************************************************************************
Propongo este sencillo ejercicio:Aula_18_Pixel.py,
realizado en python, con el fin de ver la estructura de una imagen.
Permite aplicar zoom a una imagen, hasta llegar a ver la configuración y los valores,
en los diferentes canales de los pixels que la componen, pixel a pixel.
(Ver imágenes adjuntas)

Esta es una pequeña explicación del código que forma parte del ejercicio:

El código en Python utiliza la biblioteca OpenCV para cargar una imagen, mostrarla en una ventana, visualizar los valores de los píxeles y luego guardar la imagen resultante. Aquí tienes una descripción línea por línea:

import cv2: Importa la biblioteca OpenCV, que es utilizada para procesamiento de imágenes y visión por computadora.

import numpy as np: Importa la biblioteca NumPy y la asigna al alias 'np'. NumPy se utiliza para manipular matrices y arreglos, y se usa en conjunto con OpenCV en este código.

image_path = '/home/margarito/python/lorenzo.jpg': Asigna la ruta de la imagen de prueba a la variable image_path. Debes cambiar esta ruta por la ubicación de tu propia imagen.

image = cv2.imread(image_path): Lee la imagen desde la ruta especificada usando la función cv2.imread y guarda la imagen en la variable image.

cv2.imshow("Output Image", image): Muestra la imagen en una ventana con el título "Output Image" utilizando la función cv2.imshow.

cv2.waitKey(0): Espera hasta que se presione una tecla (código de tecla 0 indica que espera indefinidamente) antes de continuar la ejecución del programa.

cv2.destroyAllWindows(): Cierra todas las ventanas de visualización creadas por OpenCV.

cv2.imwrite("output_image.jpg", image): Guarda la imagen actual en el archivo "output_image.jpg" utilizando la función cv2.imwrite.

Este código es un muy ejemplo básico de cómo cargar, visualizar y guardar una imagen usando OpenCV en Python.
************************************************************************************************
El ejercicio fue ejecutado en una plataforma Linux, Ubuntu 20.04.6 LTS.
Editado con: Sublime text.
Se deberá tener caragdo en el sistema las librerías necesarias a importar:

import cv2
import numpy as np

Ejecutar bajo consola linux:python3 Aula_18_Pixel.py
Imágen de perfil

Zoom.


Python

Publicado el 23 de Febrero del 2024 por Hilario (121 códigos)
220 visualizaciones desde el 23 de Febrero del 2024
Figure_1
Figure_2
Figure_3

Este es un ejemplo sencillo, un ejemplo de cómo editar cualquier imagen de tres canales RGB, con ruta a tu ordenador . Para poder visualizar la imagen, y realizar zoon a la misma, hasta poder visualizar el valor de los pixeles en los tres canales RGB en la propia consola, con este tipo de salida:

Rectángulo seleccionado: (1564, 576) - (2400, 2239)
Rectángulo seleccionado: (1750, 956) - (2172, 1741)
Rectángulo seleccionado: (1066, 332) - (3362, 2374)
Rectángulo seleccionado: (1066, 323) - (3362, 2366)
Rectángulo seleccionado: (1539, 678) - (2307, 1843)
Rectángulo seleccionado: (914, 256) - (2704, 2273)
Rectángulo seleccionado: (914, 256) - (2704, 2273)
Rectángulo seleccionado: (1319, 796) - (1800, 1589)
Rectángulo seleccionado: (838, 534) - (2864, 2383)
Rectángulo seleccionado: (1176, 728) - (2307, 1615)
Rectángulo seleccionado: (1176, 1437) - (2307, 1615)
Rectángulo seleccionado: (787, 382) - (1724, 1995)
Rectángulo seleccionado: (1108, 1058) - (1108, 1058)
Rectángulo seleccionado: (1345, 737) - (3219, 2501)
Rectángulo seleccionado: (171, 154) - (4046, 2839)


Lo construimos aplicando las librerías usuales de Python

Otra forma de hacerlo podría ser importando OpenCV para manejar imágenes, visualizarlas y realizar operaciones como el zoom. Puedes adaptar el código según tu preferencia de biblioteca, y adaptarlo a esta otra librería.

********************************************************************************************************************
A continuación resumimos los pasos esenciales de este sencillo ejercicio:

Importación de Bibliotecas:
--------------------------
Se importan las bibliotecas necesarias, que incluyen matplotlib.pyplot, matplotlib.widgets.RectangleSelector, y matplotlib.image.

Carga de la Imagen:
--------------------------
Se especifica la ruta de la imagen en el ordenador.
La imagen se carga utilizando la función mpimg.imread de matplotlib.image.

Creación de la Figura:
----------------------------
Se crea una figura y un conjunto de ejes utilizando plt.subplots().
La imagen se muestra en los ejes con ax.imshow().

Definición de Funciones:
----------------------------------------
Se define una función onselect que se ejecutará cuando se seleccione un rectángulo.
Dentro de esta función, se calculan las coordenadas del rectángulo seleccionado y se imprimen en la consola.

Lista de Coordenadas de Rectángulos:
--------------------------------------------------
Se crea una lista rect_coords para almacenar las coordenadas de los rectángulos seleccionados.

Selector de Rectángulos:
------------------------------------
Se crea un objeto RectangleSelector que está asociado a los ejes (ax) y la función onselect.
Se especifica el botón del ratón permitido para la interacción (button=[1]), y otras configuraciones como la mínima separación horizontal y vertical (minspanx y minspany), y las coordenadas en las que se mide el ancho y el alto (spancoords).
Visualización y Interacción:

La imagen y los ejes se muestran con plt.show().
Se imprime un mensaje indicando que se puede hacer clic y arrastrar para seleccionar un rectángulo.
En resumen, este código crea una interfaz interactiva que te permite hacer clic y arrastrar para seleccionar rectángulos en una imagen. Las coordenadas de los rectángulos seleccionados se imprimen en la consola. Puedes ajustar las configuraciones según tus necesidades, como el botón del ratón permitido, la sensibilidad de la selección, entre otros.

------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
Realizado en platafroam Linux.
Ubuntu 20.04.6 LTS
Editado con:Sublime Text.

Ejecución bajo consola de linux.
python3 Aula_28_Zoom_Pixel.py
Imágen de perfil

Salidas entre Convolución CNN.


Python

Publicado el 21 de Febrero del 2024 por Hilario (121 códigos)
208 visualizaciones desde el 21 de Febrero del 2024
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5
Figure_6
Figure_7
Figure_8
Figure_9

********************************************************************************************************************
Propongo el ejercicio: Aula_18_Feb_24.py, realizado en python. En el mismo trato de formular una red convolucional, lo más sencilla posible, con el fin ver el desarrollo de nueve capas convolucionales. Tratando de indagar y visualizar la salida después de cada capa utilizando un bucle. Por cada salto de bucle iremos viendo los valores correspondientes de la activación, al mismo tiempo que visualizaremos el resultado de la imagen, que será un tanto incongruente ya que sólo se trata de ver su funcionamiento.

A continuación describo las particularidades de este corto código:
*************************************************************************
Como se aprecia en las llamadas iniciales de importación de módulos, utiliza TensorFlow y Keras para crear un modelo de red neuronal convolucional (CNN) y visualiza las salidas de cada capa convolucional para una imagen de entrada aleatoria. Aquí está la descripción del código:

Importar bibliotecas:
------------------------------
numpy: Para trabajar con matrices y generar imágenes aleatorias.
matplotlib.pyplot: Para visualizar las salidas de cada capa convolucional.
tensorflow.keras.models.Sequential y tensorflow.keras.layers.Conv2D: Para construir la arquitectura del modelo CNN.

Crear el modelo:
---------------------
Se crea un modelo secuencial (Sequential) que representa la arquitectura de la red.

Agregar capas convolucionales:
------------------------------------------------
Se agregan varias capas convolucionales al modelo con diferentes números de filtros y funciones de activación ReLU.

Obtener las salidas de cada capa convolucional:
-----------------------------------------------------------------------
Se crea un modelo de visualización (visualization_model) que toma la entrada del modelo original y produce las salidas de cada capa convolucional.

Generar una imagen de entrada aleatoria:
-----------------------------------------------------------
Se crea una imagen de entrada ficticia con dimensiones (1, 600, 506, 3).
Si se quiere se podría hacer con carácter fijo en vez de aleatorio.

Obtener las activaciones de cada capa:
--------------------------------------------------------
Se obtienen las activaciones de cada capa convolucional para la imagen de entrada utilizando el modelo de visualización.

Visualizar las salidas de cada capa:
----------------------------------------------
Se itera sobre las activaciones y se muestra la salida de cada capa convolucional. Si la salida tiene cuatro dimensiones, se aplanan y visualizan las activaciones en escala de grises.
Como indiqué, este código es útil para entender cómo evoluciona la representación de la imagen a medida que pasa a través de las capas convolucionales de la red. Cada visualización muestra las activaciones de una capa particular, lo que puede ayudar a interpretar cómo la red extrae características en diferentes niveles de abstracción.

******************************************************************************************************************
Este código fue realizado bajo plataforma linux, con Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.
Se deberá tener en cuenta que el sistema tendrá que tener cargado para las importaciones
los siguientes módulos:

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Conv2D

La Versión de Python en mi ordenador es: Python 3.8.10.
****************************************************************************************
#Ejecución:python3 Aula_18_Feb_24.py
Imágen de perfil

Red-CNN Detección de bordes


Python

Publicado el 19 de Febrero del 2024 por Hilario (121 códigos)
215 visualizaciones desde el 19 de Febrero del 2024
Figure_1
Figure_2

Los kernels Sobel son filtros utilizados comúnmente en procesamiento de imágenes para realizar operaciones de convolución, especialmente en el contexto de detección de bordes. Estos filtros están diseñados para resaltar cambios rápidos en la intensidad de los píxeles en una imagen, lo que generalmente indica la presencia de bordes.

El operador Sobel consiste en dos kernels, uno para la detección de cambios horizontales y otro para cambios verticales. Estos kernels son matrices pequeñas que se aplican a la imagen mediante la operación de convolución. Los kernels Sobel comúnmente utilizados son los siguientes:

Kernel Sobel para detección de bordes horizontales (kernel_sobel_x):

[ -1, 0, 1]
[ -2, 0, 2]
[ -1, 0, 1]

Kernel Sobel para detección de bordes verticales (kernel_sobel_y):

[ 1, 2, 1]
[ 0, 0, 0]
[-1, -2, -1]

La operación de convolución implica deslizar estos kernels sobre la imagen original, multiplicando los valores de los píxeles en la región correspondiente del kernel y sumándolos para obtener un nuevo valor en la posición central. Este proceso se repite para cada píxel en la imagen, generando así dos nuevas imágenes filtradas: una resaltando cambios horizontales y otra resaltando cambios verticales.

La magnitud de los bordes se calcula combinando las respuestas horizontales y verticales mediante una fórmula de magnitud Euclidiana.

Este resultado proporciona una representación de la intensidad de los bordes en la imagen original, lo cual es útil para tareas como detección de contornos. En el código que compartiste anteriormente, estos kernels Sobel se utilizan para realizar la detección de bordes en la imagen cargada.


Este programa en Python: python3 Aula_28_bordes_CNN.py, realiza la detección de bordes en una imagen utilizando el operador Sobel. Aquí tienes una explicación paso a paso:

Cargar la imagen:
Utiliza la biblioteca OpenCV (cv2) para cargar una imagen desde la ruta "/home/margarito/python/tulipanes.jpeg".
Verifica si la carga de la imagen fue exitosa.

Convertir la imagen a formato RGB:
Utiliza la función cv2.cvtColor para convertir la imagen cargada (en formato BGR) a formato RGB.
Muestra la imagen original utilizando la biblioteca matplotlib.

Definir los kernels Sobel:
Define dos kernels Sobel, uno para la detección de bordes horizontales (kernel_sobel_x) y otro para la detección de bordes verticales (kernel_sobel_y).

Aplicar los filtros Sobel:
Utiliza la función cv2.filter2D para aplicar los filtros Sobel a la imagen original, obteniendo dos imágenes resultantes (imagen_bordes_x e imagen_bordes_y), que representan los bordes horizontales y verticales, respectivamente.

Calcular la magnitud de los bordes:
Calcula la magnitud de los bordes combinando las imágenes resultantes de los filtros Sobel mediante la fórmula de la magnitud Euclidiana.

Verificar si hay datos válidos en la matriz antes de normalizar:
Antes de normalizar la magnitud de los bordes, verifica si hay datos válidos en la matriz utilizando np.any.

Convertir a tipo de datos float32 antes de normalizar:
Convierte la matriz de magnitud de bordes a tipo de datos float32. Esto es necesario para evitar problemas de normalización con tipos de datos no compatibles.

Normalizar la imagen:
Utiliza el método de normalización para escalar los valores de la magnitud de los bordes al rango [0, 1]. Esto es importante para visualizar correctamente la imagen de bordes.

Mostrar la imagen con bordes:
Utiliza plt.imshow para mostrar la imagen resultante de la detección de bordes en escala de grises.
Muestra un título indicando que se ha aplicado el operador Sobel para la detección de bordes.

Manejar casos donde la matriz de magnitud de bordes está vacía:
Si la matriz de magnitud de bordes está vacía (todos los elementos son cero), imprime un mensaje indicando que la matriz está vacía o no contiene datos válidos.

En resumen, este programa carga una imagen, aplica el operador Sobel para detectar bordes y muestra la imagen resultante de la detección de bordes. Además, maneja casos donde la matriz de magnitud de bordes no contiene datos válidos.
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

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


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 30 de Enero del 2024 por Antonio (75 códigos) (Publicado el 26 de Marzo del 2021)
12.337 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
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Generador de contraseñas.


Python

estrellaestrellaestrellaestrellaestrella(3)
Actualizado el 30 de Enero del 2024 por Antonio (75 códigos) (Publicado el 2 de Agosto del 2021)
8.983 visualizaciones desde el 2 de Agosto del 2021
Programa para generar contraseñas de forma aleatoria, de hasta 50 caracteres. Cuenta con un campo "LENGTH" para especificar la longitud de la contraseña, un campo "MIN LOWERCASE" para especificar el número mínimo de caracteres en minúsculas, un campo "MIN UPPERCASE" para el número mínimo de caracteres en mayúsculas y un campo "MIN NUMBERS" para especificar el número mínimo de caracteres numéricos.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
pg
Imágen de perfil

Función Softmax


Python

Publicado el 30 de Enero del 2024 por Hilario (121 códigos)
229 visualizaciones desde el 30 de Enero del 2024
*******************************************************************************************************************
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5
Figure_6

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

Ejercicios:Aula_28_Softmax.py - Aula_28_softmax_pooling.py

Proponemos dos ejemplos en los utilizamos la función softmax, en una sencilla red convolucional CNN
En el primer ejemplo lo hacemos sin aplicar maxpooling, en el segundo ejemplo lo hacemos aplicando maxpooling

La función Softmax toma un vector de logits y produce una distribución de probabilidad sobre las clases. Esto es útil en problemas de clasificación, ya que permite interpretar las salidas de la red como la probabilidad de que una entrada pertenezca a cada clase posible. La clase con la probabilidad más alta se considera la predicción final de la red. Este enfoque es especialmente útil en problemas de clasificación multiclase, como el reconocimiento de dígitos en el conjunto de datos MNIST.


La función Softmax se utiliza para calcular probabilidades finales en el contexto de clasificación. Después de aplicar Softmax a los logits (las salidas de la red antes de aplicar ninguna función de activación en la capa de salida), obtienes un conjunto de valores que representan las probabilidades de pertenencia a cada clase posible.

Estas probabilidades están normalizadas de manera que sumen 1. Cada valor indica la probabilidad estimada de que la entrada pertenezca a la clase correspondiente. La clase con la probabilidad más alta se considera la predicción final del modelo.

Entonces, en resumen, Softmax toma los logits y los convierte en una distribución de probabilidad sobre las clases, lo que facilita la interpretación y la toma de decisiones al seleccionar la clase con la probabilidad más alta como la predicción final del modelo.

La aplicación de la función Softmax generalmente se realiza en la capa de salida de la red neuronal, justo antes de tomar la decisión final sobre la clase a la que pertenece la entrada. En términos de programación, esto se realiza comúnmente como parte de la definición del modelo en el código.
********************************************************************************************************************

Para realizar este ejercicio tomamos datos MNIST.
MNIST es un conjunto de datos ampliamente utilizado en el campo de la visión por computadora y el aprendizaje profundo. Este conjunto de datos consiste en imágenes en escala de grises de dígitos escritos a mano (0 al 9), cada una de 28x28 píxeles. MNIST se utiliza comúnmente como un punto de partida para probar y desarrollar algoritmos de reconocimiento de imágenes utilizando redes neuronales convolucionales.

El objetivo típico es entrenar un modelo para clasificar correctamente las imágenes en sus respectivas categorías de dígitos. Muchos investigadores y desarrolladores utilizan MNIST como una especie de "Hello World" para la visión por computadora, ya que proporciona un caso de prueba relativamente simple pero efectivo para evaluar el rendimiento de modelos de aprendizaje profundo en tareas de clasificación de imágenes.
********************************************************************************************************************
Ejercicio realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS

---------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_softmax_pooling.py
python3 Aula_28_softmax_pooling.py

--------------------------------------------------------------------
Se deberá tener cargado en el sistema estos módulos:
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
-------------------------------------------------------------------
Para que vustro ordenador no produzca desbordamiento:Instrucción ilegal (`core' generado)

Vuestro ordenador deberá tener una cpu que soprte AVX (Advanced Vector Extensions) que es una extensión de instrucciones introducida por Intel y AMD en sus procesadores para realizar operaciones de manera más eficiente, especialmente en tareas que involucran cálculos en paralelo. Cuando se dice que una CPU "soporta AVX", significa que es capaz de ejecutar las instrucciones AVX.

Las instrucciones AVX permiten realizar operaciones en vectores más grandes de datos simultáneamente, lo que puede mejorar significativamente el rendimiento en aplicaciones que están optimizadas para utilizar estas extensiones. Este tipo de instrucciones son particularmente beneficiosas en tareas intensivas en cálculos, como aquellas encontradas en aplicaciones científicas, de inteligencia artificial, gráficos 3D y procesamiento de señales, entre otras.

En el contexto de programación y desarrollo de software, si un procesador es compatible con AVX, los desarrolladores pueden aprovechar estas instrucciones para optimizar sus programas y mejorar el rendimiento en hardware que admite esta tecnología. Sin embargo, es importante destacar que no todos los procesadores admiten AVX y que la capacidad de aprovechar estas instrucciones depende del soporte tanto del hardware como del software.

*******************************************************************************************************************
Si vuestra CPU, no cubre estos requisitos, también se pueden ejecutar con Google Colab.
******************************************************************************************************************
Imágen de perfil

ImageDataGenerator.


Python

Publicado el 23 de Enero del 2024 por Hilario (121 códigos)
289 visualizaciones desde el 23 de Enero del 2024
palomas
descarga

********************************************************************************************************************
En este breve ejercicio, pretendo explicar algunas dudas sobre la utilizacion de ImageDataGenerator.
Esta función se utiliza en las redes convolucionales, para nodificar los parámetros o apariencia de las imagenes
utilizadas para el training, con el propósito principal de mejorar el rendimiento y la generalización del modelo mediante el aumento de datos y la normalización.

Aquí están los objetivos clave:
--------------------------------------

Aumento de Datos para Mejor Generalización:

El aumento de datos implica aplicar transformaciones aleatorias a las imágenes durante el entrenamiento, como rotación, cambio de escala, volteo horizontal, etc. Este proceso aumenta la diversidad del conjunto de datos, permitiendo que el modelo vea variaciones de las imágenes originales. Como resultado, la CNN se vuelve más robusta y generaliza mejor a nuevas imágenes que puede encontrar durante la inferencia.

Prevención de Sobreajuste (Overfitting):

El sobreajuste ocurre cuando un modelo aprende demasiado bien los detalles específicos del conjunto de entrenamiento y tiene dificultades para generalizar a datos no vistos. El aumento de datos ayuda a prevenir el sobreajuste al introducir variaciones artificiales en las imágenes de entrenamiento. Esto es crucial cuando el conjunto de datos es relativamente pequeño.

Normalización para Facilitar el Entrenamiento:

La normalización de píxeles (escalando valores a un rango específico, como [0, 1]) facilita el proceso de entrenamiento. Al tener valores de píxeles en un rango más pequeño, los gradientes durante el entrenamiento son más estables, lo que puede llevar a una convergencia más rápida del modelo.

Manejo Eficiente de Grandes Conjuntos de Datos:

Cuando trabajas con grandes conjuntos de datos que no caben completamente en la memoria, ImageDataGenerator permite cargar y procesar las imágenes de manera eficiente en lotes durante el entrenamiento. Esto es esencial para hacer frente a conjuntos de datos de tamaño considerable.
En resumen, ImageDataGenerator contribuye significativamente a mejorar la capacidad de generalización de una CNN, a hacer que el modelo sea más robusto frente a variaciones en los datos y a facilitar el proceso de entrenamiento, especialmente cuando se trata de conjuntos de datos grandes.

********************************************************************************************************************
Un ejemplo típico de argumentos pasados a ImageDataGenerator sería el siguiente:

datagen = ImageDataGenerator(
rescale=1./255, # Normalización
rotation_range=20, # Rango de rotación aleatoria
width_shift_range=0.2, # Rango de cambio horizontal aleatorio
height_shift_range=0.2, # Rango de cambio vertical aleatorio
shear_range=0.2, # Rango de cizallamiento aleatorio
zoom_range=0.2, # Rango de zoom aleatorio
horizontal_flip=True # Volteo horizontal aleatorio
)

********************************************************************************************************************
********************************************************************************************************************
Este programa ha sido editado y ejecutadoi con Google Colab.
El archivo de jemplo estaba alojado en Drive de Google Colab.


---------------------------------------------------------------------------------------------------------------------------
Imágen de perfil

Visualización de la imagen normalizada.


Python

Publicado el 22 de Enero del 2024 por Hilario (121 códigos)
144 visualizaciones desde el 22 de Enero del 2024
Sencillo_Concep_Pixel_Aula_28.py
**********************

Figure_1
Figure_12

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

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

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


Python

estrellaestrellaestrellaestrellaestrella(5)
Actualizado el 22 de Enero del 2024 por Antonio (75 códigos) (Publicado el 8 de Junio del 2020)
11.098 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