Buscar un código de Python

El siguiente programa permite la creación de carpetas comprimidas.

Simple clase para trabajar con una base de datos SQLite3... permite crear una base de datos, crear una tabla, insertar, modificar, consultar y eliminar registros.

Simple agenda a modo de ejemplo para visualizar como trabajar con la base de datos sqlite3.
Esta permite añadir, eliminar, listas y buscar contactos.

Script que genera una multitud de códigos QR según el contenido del archivo url.txt que hay que generar.
Utiliza la librería 36.

************************************************////*******************************************



Aula_28_Diciembre_15_sql.py
**********************************


Programa realizado bajo paltaforma Linux, concretamente con Ubuntu 20.04.6 LTS.
Editado con Sublime text

#Ejecución.
#Bajo consola linux.
python3 Aula_28_Diciembre_15_sql.py
Alumnos, para entender mejor este ejercicio, inicialmente vamos a instalar el programa para Linux: DB Browser for SQLite
------------------------------------------//--------------------------------
Utilizaremos este comando por consola de linux, en mi caso utilizo Ubuntu.
sudo apt install sqlitebrowser

***************************************************************************************************
Vamos a realizar un ejercicio en Python, con el fin de relacionar un programa orientado a base de datos, para ir cargandolos secuencialmente en nuestra base datos y poder ver bajo genome, con el programa DB Browser for SQLite, los resultados.
Creo que es lo más sencillo que podemos hacer, queridos alumnos, para aprender sobre este importante tema, las bases SQL.

Bien, vamos a ver un poco este ejercicio.

Explicación General del Ejercicio: Aula_28_Diciembre_15_sql.py
Clase del 18 de Diciembre - Aula 28 (Mañana)

Este ejercicio tiene como objetivo enseñar a los alumnos cómo crear, gestionar y manipular una base de datos utilizando SQLite en Python. Se presenta una agenda de contactos como ejemplo práctico, con funcionalidades para agregar, buscar, eliminar y listar contactos. El archivo generado se llama Aula_28_Agenda.db y será almacenado localmente.

Conceptos Clave:
SQLite:
Es un sistema de gestión de bases de datos ligero y sin servidor. No requiere configuración previa, lo que lo hace ideal para proyectos pequeños o educativos.

Base de datos:
Un lugar donde almacenamos datos organizados en tablas. En este caso, tenemos una tabla llamada contactos que almacena:

id: Identificador único (autoincremental).
nombre: Nombre del contacto.
telefono: Número de teléfono.
ciudad: Ciudad del contacto.

Python y SQL:
Python se conecta con SQLite usando la biblioteca sqlite3. Los comandos SQL (CREATE, INSERT, SELECT, DELETE) nos permiten manipular los datos.

Estructura del Programa:

1. Inicialización de la Base de Datos:

La función inicializar_db() crea el archivo Aula_28_Agenda.db si no existe.
Dentro de este archivo, se define la tabla contactos con sus columnas (id, nombre, telefono, ciudad).
Se utiliza SQL para asegurar que la tabla se cree solo si no existe previamente.

Código relevante:

CREATE TABLE IF NOT EXISTS contactos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
telefono TEXT NOT NULL,
ciudad TEXT NOT NULL
)

2. Agregar Contactos

La función agregar_contacto(nombre, telefono, ciudad) permite al usuario añadir contactos a la base de datos.
Se utiliza una consulta SQL INSERT para insertar los datos proporcionados por el usuario.

INSERT INTO contactos (nombre, telefono, ciudad) VALUES (?, ?, ?)

3. Buscar Contactos

La función buscar_contacto(nombre) permite buscar contactos en la base de datos que coincidan parcialmente con un nombre.
Utiliza SELECT con una condición LIKE para encontrar coincidencias.
SELECT nombre, telefono, ciudad FROM contactos WHERE nombre LIKE ?

4. Eliminar Contactos

La función eliminar_contacto(nombre) elimina todos los contactos cuyo nombre coincida con el criterio de búsqueda.
Utiliza DELETE para borrar los registros encontrados.

DELETE FROM contactos WHERE nombre LIKE ?

5. Mostrar Todos los Contactos

La función mostrar_agenda() lista todos los contactos almacenados en la base de datos.
Utiliza SELECT para recuperar toda la información de la tabla contactos.


SELECT nombre, telefono, ciudad FROM contactos
Interacción con el Usuario
El programa incluye un menú interactivo que guía al usuario por las diferentes funcionalidades de la agenda.
Este menú permite:

Opción 1: Agregar un contacto.
Opción 2: Buscar un contacto.
Opción 3: Eliminar un contacto.
Opción 4: Mostrar todos los contactos.
Opción 5: Salir del programa.

El menú se ejecuta dentro de un bucle while hasta que el usuario elige salir.

Ejemplo Práctico
Al ejecutar el programa, se crea el archivo Aula_28_Agenda.db.
Desde el menú:
Seleccionas 1. Agregar contacto, introduces Juan, 123456789 y Madrid.
Seleccionas 2. Buscar contacto, introduces Juan y ves los detalles de ese contacto.
Seleccionas 3. Eliminar contacto, introduces Juan y confirmas que se ha eliminado.
Seleccionas 4. Mostrar todos los contactos, y verificas que no hay contactos.

Objetivos de Aprendizaje
Comprender cómo funcionan las bases de datos relacionales.
Conectar y manipular bases de datos SQLite desde Python.
Implementar operaciones básicas de bases de datos:
Crear tablas (CREATE).
Insertar datos (INSERT).
Leer datos (SELECT).
Eliminar datos (DELETE).

Desarrollar un programa estructurado y modular.
-----------------------------------------------------------------------------------------------------
Conclusión
Este ejercicio combina teoría y práctica para ayudar a los alumnos del Aula 28 a entender el manejo de bases de datos desde Python. Los conceptos aprendidos pueden ser aplicados en proyectos más complejos en el futuro.

-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Ejercicio:
<<<<<<<<<
Aula_28_Redaccion_IA.py
----------------------
Avanzando más en el tratamiento de textos, dentro de la Inteligencia Artificial. Proponemos ahora este ejercicio sencillo en el que vamos a utilizar un módulo ya entrenado en la elaboración de textos congruentes.
Como siempre trabajaremos bajo consola de Linux, con un sistema operativo Ubuntu 20.04.6 LTS. Utilizando como editor Sublime text.

Bien, queridos, alumnos. Para crear un programa que redacte textos amplios sobre un tema introducido por consola, puedemos usar modelos de lenguaje preentrenados, como los de la biblioteca transformers de Hugging.
Estos modelos son capaces de generar textos de manera coherente sobre prácticamente
cualquier tema. Es importante que el tema introducido por consola, sea descriptivo en el tema planteado, para que nuestro Módulo tenga más posibilidades de concretar la pequeña redacción resultante. En nuestro caso hemos planteado el tema de la siguiente forma:
"El mar es hermoso, pero esclavo para los pescadores que trabajan en ella"

Primero, asegúrate de tener instalada la biblioteca transformers y torch si aún no las tienes.
Puedes instalarlas ejecutando en la terminal:

pip install transformers torch

***************************************************************************************
Vamos a explicar de forma breve, en que consiste y como importamos el módulo entrenado.
----------------------------------------------------------------------------------------

Módulos Importados:

GPT2LMHeadModel:
Este es un modelo preentrenado basado en GPT-2, un tipo de modelo de lenguaje desarrollado por OpenAI que genera texto. La parte LMHead se refiere a la cabeza del modelo, que está diseñada específicamente para tareas de generación de lenguaje. El modelo puede generar nuevas secuencias de texto basadas en una entrada inicial.

GPT2Tokenizer:
Este es el tokenizador de GPT-2, encargado de convertir el texto que introduces (en formato de palabras) en un formato numérico que el modelo puede entender (tokens). Cuando quieres que el modelo genere texto o lo procese, el tokenizador traduce el texto a tokens, y después de que el modelo trabaja con ellos, el tokenizador traduce esos tokens de nuevo a texto legible.

Funcionamiento:
1. Tokenización -como recordareis ya hemos explicado este tema en un ejercicio anterior-:

El texto en lenguaje natural no puede ser entendido directamente por el modelo; necesita ser convertido a un formato que pueda procesar, llamado tokens (que son números que representan palabras o partes de palabras).
Ejemplo:
Si introduces la frase "Hola mundo", el tokenizador puede convertirla en algo como [15496, 1107], donde cada número representa una palabra o fragmento de una palabra.

2. Generación del texto:
El modelo GPT-2 toma esos tokens y predice cuál debería ser el siguiente token (o secuencia de tokens) basándose en lo que ya ha "visto". Se basa en patrones que ha aprendido de grandes cantidades de datos durante su entrenamiento.
Usando el mismo ejemplo, si das el input "Hola mundo", el modelo podría generar una continuación como "es un lugar hermoso" o cualquier secuencia plausible que siga.

3. Proceso completo:
Input: Tú introduces una frase (por ejemplo, "El cielo es azul").
Tokenización: El tokenizador convierte esta frase en tokens numéricos.
Modelo GPT-2: El modelo procesa esos tokens y genera nuevos tokens que representan la continuación del texto (basado en lo que ha aprendido).
Des-tokenización: El tokenizador traduce esos nuevos tokens de vuelta a palabras legibles, generando un texto nuevo como salida.

***************************************************************************
Explicación del código:

GPT2LMHeadModel.from_pretrained('gpt2'): Carga el modelo GPT-2 preentrenado.
tokenizador.encode(): Convierte el texto de entrada en tokens.
modelo.generate(): Genera la continuación del texto basado en los tokens de entrada.
tokenizador.decode(): Convierte los tokens generados nuevamente a texto para que puedas leer la salida.

Este enfoque permite que los modelos como GPT-2 generen texto natural en una gran variedad de tareas, como responder preguntas, redactar historias o completar oraciones. Todo esto se hace aprovechando la capacidad del modelo para aprender patrones del lenguaje y generar textos coherentes basados en un contexto previo.

**************************************************************************************
La ejecucion de este programa se realiza con el siguiente comando, bajo consola de Linux:
python3 Aula_28_Redaccion_IA.py
////////////////////////////////////////////////////////////////////////////////////////////
-------------------------------------------------------------------------------------------
Como veremos en clase, el próximo 29 de Octubre, existen muchas limitaciones en este proceso.
Revisaremos el ejercicio paso a paso, y comrobaremos cómo funciona.
He de decir que partimos de una forma básica, pero intentaremos poner las bases, para aumentar la complejidad y la efectividad con nuevos ejercicios.

Nuestras limitaciones son muchas, somos meros mortales en limitaciones tecnologicas, a continuacion
os hago un resumen de nuetras limitaciones, digamos, caseras:

Cuando ejecutas módulos como GPT2LMHeadModel y GPT2Tokenizer en un ordenador normal (casero), hay algunas limitaciones que debes tener en cuenta. Aquí te detallo las más importantes:

1. Recursos de hardware:
**********************
Memoria RAM: Los modelos como GPT-2 requieren bastante memoria. Incluso el modelo GPT-2 pequeño puede ocupar varios GB de RAM. Si tu ordenador tiene poca memoria (por ejemplo, menos de 8 GB de RAM), puede que se bloquee o funcione muy lentamente, especialmente con textos largos.
GPU (Unidad de Procesamiento Gráfico): Aunque los modelos se pueden ejecutar en CPU, los modelos como GPT-2 son mucho más rápidos si se ejecutan en una GPU. Los ordenadores caseros generalmente no tienen GPUs tan potentes como las de los servidores especializados o las tarjetas gráficas usadas para IA (como las NVIDIA de la serie RTX). Sin una GPU potente, la generación de texto puede ser extremadamente lenta.
CPU: Si no tienes una GPU, el modelo se ejecutará en la CPU, pero esto hará que el procesamiento sea mucho más lento. Procesar o generar textos largos podría tomar minutos en lugar de segundos.


2. Tamaño del modelo:
********************
Versiones grandes de GPT-2: GPT-2 tiene varios tamaños (pequeño, mediano, grande y extra grande). Los modelos más grandes requieren mucha más memoria y procesamiento, lo que los hace casi impracticables en un ordenador casero promedio. Por ejemplo, el modelo más grande (GPT-2 XL) ocupa más de 6 GB solo para cargar, y esto sin contar el procesamiento del texto.
Tiempo de carga: Incluso si tu ordenador puede manejar el tamaño del modelo, cargar el modelo en la memoria puede ser lento, y cada nueva inferencia (generación de texto) puede tomar bastante tiempo.

3. Almacenamiento:
*****************
Espacio en disco: Los modelos preentrenados de GPT-2 ocupan varios gigabytes de almacenamiento. Si tienes un disco duro pequeño o poco espacio disponible, descargar y guardar estos modelos puede ser problemático.
Actualizaciones de modelos: Los modelos mejorados o adicionales también ocupan más espacio y descargar varios de ellos podría llenar el almacenamiento disponible rápidamente.

4. Rendimiento limitado en generación de texto:
**********************************************
Latencia: En un ordenador casero, puede haber una latencia significativa entre la entrada de texto y la generación de salida. Generar texto en tiempo real o manejar peticiones rápidas no es tan fluido como en infraestructuras especializadas.
Longitud del texto: La longitud del texto que puedes procesar o generar también está limitada por los recursos de tu máquina. Textos muy largos podrían hacer que el modelo consuma más memoria de la disponible, lo que puede llevar a fallos o tiempos de procesamiento extremadamente largos.

5. Optimización limitada:
************************
Uso eficiente del hardware: Los modelos como GPT-2 están optimizados para funcionar mejor en infraestructuras de alto rendimiento, donde los recursos se pueden gestionar de manera más eficiente. En un ordenador casero, la falta de optimizaciones específicas para tu hardware (como las que se usan en servidores o clusters) hará que el rendimiento sea más bajo.

6. Entrenamiento o ajuste fino (fine-tuning):
********************************************
Imposibilidad de reentrenar: Entrenar o ajustar finamente un modelo como GPT-2 en un ordenador casero es prácticamente inviable debido a la cantidad de recursos que consume. Necesitarías GPUs especializadas y días o semanas de procesamiento para reentrenar el modelo, algo que no es posible en un equipo casero normal.
Acceso a grandes datasets: Para ajustar finamente el modelo, necesitarías un conjunto de datos extenso y adecuado, lo que no siempre es fácil de gestionar ni de almacenar en un ordenador personal.

7. Conexión a internet (si usas modelos en la nube):
***************************************************
Como recurso, os digo:
Aunque puedes ejecutar los modelos localmente, algunos prefieren usar versiones en la nube o APIs (como OpenAI GPT-3) para ahorrar recursos en el ordenador local. En estos casos, dependes de una conexión a internet rápida y estable para obtener resultados eficientes. Las conexiones lentas podrían hacer que el proceso sea menos fluido.

Como os comento, los de nuestra Aula, somos puramente terrenales.
Gracias, amigos, y a trabajar.

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

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

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

Nueva versión del juego de la serpiente con caracteres ASCII. Esta versión se diferencia de las dos anteriores (que pueden verse en mi lista de códigos) en que se acompaña de un archivo (de nombre "hiScore") que irá almacenando de modo permanente, la puntuación máxima alcanzada por el jugador.

BOTONES:
Mover serpiente: Botones de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida en curso: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.