Mostrar los tags: OR

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.

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


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

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

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

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

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.

IMAGEN A PREDECIR.
-----------------------------



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.

Imagen a predecir.

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


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

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

----------------------------------------------------------------------------------------------------------------------------------------

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.

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

---------------------------------------------------------------------------------------------------------------------------

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




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

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

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

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

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

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

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

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

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



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

El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.

USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.