Estadísticas de la versión: V-0. - PyTorch - Python

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

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