Mostrar los tags: n

Este código sirve para crear una cuenta regresiva que muestra el tiempo restante hasta una fecha y hora específicas, como el lanzamiento de un producto, un evento o una página web. Se actualiza en tiempo real y muestra los días, horas, minutos y segundos restantes de forma dinámica.

Es ideal para incluir en páginas web o proyectos donde quieras mantener a tus usuarios informados sobre el tiempo restante para un hito importante. Cuando el temporizador llega a cero, se puede mostrar un mensaje personalizado, como "¡Ya estamos en directo!" o cualquier texto que elijas. Ni necesitas más pildoras de Javascript, soy Alejandro Tamargo Desarrollador Web en Asturias

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

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

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

Ejercicio:Aula_28_token_sep_24.py
*********************************
Vamos a avanzar en el Aula 28, e iniciar, el tratamiento de textos en la Inteligencia Artificial.

Empezaremos con algo muy básico, ¿Qué es la tokenización?.
--------------------------------------------------------

-¿Qué es la tokenización?
Dividir el texto: La tokenización consiste en dividir un texto en partes más pequeñas llamadas tokens. Estos tokens pueden ser palabras, frases o incluso caracteres, dependiendo de cómo quieras analizarlos.

Ejemplo: Si tienes la frase "El perro ladra", la tokenización a nivel de palabras dividiría el texto en los siguientes tokens:

"El"
"perro"
"ladra"

Importancia:
-----------
Facilita el análisis: Al descomponer el texto, es más fácil realizar análisis, como contar palabras, buscar patrones o entender el significado.
Prepara para modelos:
Muchos modelos de IA trabajan con números, no con texto. La tokenización es un primer paso para convertir texto en un formato que los modelos puedan entender.

Tipos de tokenización:
---------------------
Por palabra: Divide el texto en palabras.
Por frase: Divide el texto en oraciones o frases.
Por carácter: Divide el texto en caracteres individuales.

Como ya digimos, la tokenización es el proceso de separar el texto en unidades más pequeñas (tokens) para que puedan ser analizadas y procesadas por algoritmos de IA. Es un paso esencial para entender y trabajar con el lenguaje en aplicaciones de inteligencia artificial.

*****************************************************************************************
Como se almacenaría, por ejemplo, en una matriz del tipo Tensor.
---------------------------------------------------------------
Definición: Un tensor es una estructura de datos que puede ser vista como una generalización de matrices y vectores.

Un escalar es un tensor de orden 0 (por ejemplo, un solo número).
Un vector es un tensor de orden 1 (una lista de números).
Una matriz es un tensor de orden 2 (una tabla de números).
Un tensor de orden superior puede tener más de dos dimensiones.
Representación: En matemáticas, los tensores se utilizan para representar datos de múltiples dimensiones. Por ejemplo, una imagen puede ser representada como un tensor de 3 dimensiones (alto, ancho, canales de color).

¿Cómo se utilizan los tensores en IA y procesamiento de texto?
Representación de texto:

Después de la tokenización, los tokens (palabras o frases) deben convertirse en números para que los algoritmos de IA puedan procesarlos. Esto se hace a menudo usando técnicas de embeddings (representaciones vectoriales de palabras).
Cada token se convierte en un vector (tensor de orden 1). Por ejemplo, la palabra "perro" podría representarse como un vector de características [0.5, 0.1, 0.9, ...].
Tensores en redes neuronales:

Los tensores son fundamentales en el entrenamiento de redes neuronales, donde los datos se alimentan a través de capas de la red. Cada capa procesa los tensores de entrada y produce tensores de salida.
Por ejemplo, en un modelo de procesamiento del lenguaje natural (como Transformers), el texto tokenizado se convierte en tensores, que luego son procesados en múltiples capas para generar resultados (como predicciones de texto).
Operaciones con tensores:

Se realizan varias operaciones matemáticas sobre tensores, como la suma, la multiplicación y la transformación, para aprender patrones en los datos. Esto se hace utilizando bibliotecas de programación como TensorFlow o PyTorch, que son especialmente diseñadas para manejar tensores y operaciones sobre ellos.
Batching:

En el entrenamiento de modelos, es común agrupar múltiples ejemplos en un batch (lote). Esto se hace representando varios textos como un tensor de 2 dimensiones (batch_size, longitud del texto), donde batch_size es el número de ejemplos en el lote y longitud del texto es el número máximo de tokens por ejemplo.

Diriamos, como conclusion.
------------------------
Los tensores son estructuras de datos esenciales en IA y procesamiento de texto. Se utilizan para representar texto, imágenes y otros tipos de datos en múltiples dimensiones. En el contexto del procesamiento de texto, los tensores permiten a los modelos de IA realizar cálculos complejos y aprender patrones a partir de datos tokenizados. Su uso se ha vuelto fundamental en la mayoría de las aplicaciones modernas de inteligencia artificial y aprendizaje profundo.

***************************************************************************************
EXPLICACCION DE NUESTRO EJERCICIO.
****************************************************************************************
Vamos a desglosar el ejercicio proporcionado paso a paso para entender cómo funciona y qué hace cada parte del código.

1. Importación de bibliotecas
****************************

import nltk
from nltk.tokenize import word_tokenize
import nltk: Importa la biblioteca Natural Language Toolkit (NLTK), que es una biblioteca popular en Python para el procesamiento del lenguaje natural.
from nltk.tokenize import word_tokenize: Importa la función word_tokenize, que se utiliza para dividir un texto en palabras (tokens).

2. Definición de la función
**************************

def tokenizar_con_matriz(frase):
Aquí se define una función llamada tokenizar_con_matriz, que acepta una cadena de texto (frase) como argumento.

3. Docstring
***********

"""Tokeniza una frase y crea una matriz 2D con los tokens y sus índices.

Args:
frase: La frase a tokenizar.

Returns:
Una lista de listas donde cada sublista contiene el token y su índice.
"""
Este bloque de texto es un comentario (docstring) que describe lo que hace la función, los argumentos que recibe y lo que devuelve. Es útil para que otros programadores (o tú mismo en el futuro) entiendan el propósito de la función.

4. Tokenización
**************
tokens = word_tokenize(frase)
word_tokenize(frase): Esta función toma la frase y la divide en una lista de tokens (palabras y puntuaciones). Por ejemplo, si la entrada es "El mar, amplio y profundo", tokens podría ser ['El', 'mar', ',', 'amplio', 'y', 'profundo'].

5. Creación de la matriz de tokens
*********************************
matriz_tokens = [[token, str(indice)] for indice, token in enumerate(tokens, start=1)]
enumerate(tokens, start=1): Esta función permite iterar sobre tokens, proporcionando tanto el índice (número de posición) como el valor del token. La opción start=1 significa que los índices comenzarán desde 1 en lugar de 0.
Lista de listas: Se crea una lista llamada matriz_tokens, donde cada sublista contiene un token y su índice correspondiente. Por ejemplo, si tokens es ['El', 'mar', ',', 'amplio', 'y', 'profundo'], matriz_tokens sería:
css

[['El', '1'],
['mar', '2'],
[',', '3'],
['amplio', '4'],
['y', '5'],
['profundo', '6']]
6. Solicitar entrada al usuario
*******************************
# Solicitar al usuario que introduzca la frase
frase = input("Introduce una frase: ")
Aquí se le pide al usuario que introduzca una frase a través de la consola. Lo que escriba el usuario se almacenará en la variable frase.

7. Llamada a la función y almacenamiento del resultado
******************************************************
matriz = tokenizar_con_matriz(frase)
Se llama a la función tokenizar_con_matriz, pasando la frase que el usuario introdujo como argumento. El resultado (la matriz de tokens) se guarda en la variable matriz.

8. Impresión de la matriz
************************
# Imprimir la matriz completa
for fila in matriz:
print(fila)
Este bucle for recorre cada sublista (fila) en matriz y las imprime. Cada fila contendrá un token y su índice, mostrando el resultado de la tokenización de forma estructurada.
Ejemplo de uso
Si el usuario ingresa la frase:


El mar, amplio y profundo
La salida sería:

css

['El', '1']
['mar', '2']
[',', '3']
['amplio', '4']
['y', '5']
['profundo', '6']
Podemos decir, queridos alumnos, como esumen que:
-------------------------------------------------
Este programa tokeniza una frase ingresada por el usuario, crea una estructura de datos en forma de matriz que muestra cada token y su índice correspondiente, y luego imprime esa matriz. Este ejercicio que os propuse, es un ejemplo básico pero efectivo de cómo manipular texto en Python utilizando NLTK.

*************************************************************************************************
Este ejercicio fue ralizado bajo Linux, en sistema operativo Ubuntu,
Editado con sublime text.

****************************************************************************************************************
Aula_18_Apli_Sep_Schrodinger_Oxigeno.py
***************************************

Proponemos, para el Aula 18, dentro del tema de la ecuación de Schrödinger, una aplicación realizada en lenguaje Python, donde aplicamos la ecuación de Schrödinger, para determinar la posible posicion sobre un electrón de la primera capa en un átomo de Oxigeno.

Explicación del Código

Parámetros y constantes:
Se definen las constantes físicas necesarias como la constante de Planck reducida (hbar), la carga del electrón (e), la masa del electrón (m_e), la permitividad del vacío (epsilon_0), y el número atómico del oxígeno (Z = 8).

Malla radial: Se crea una malla en el espacio radial para resolver la ecuación diferencial utilizando el método de diferencias finitas.

Potencial coulombiano: Se calcula el potencial de Coulomb debido al núcleo, que es la parte central de la energía potencial en el sistema.

Matriz Hamiltoniana: Se construye la matriz Hamiltoniana usando diferencias finitas.
Resolución de la ecuación de Schrödinger: Se obtienen los autovalores y autovectores de la matriz Hamiltoniana. El autovalor más bajo corresponde a la energía del estado fundamental (1s).

Normalización y cálculo de la probabilidad radial: La función de onda se normaliza y se calcula la densidad de probabilidad radial.

Gráfica: Se grafica la densidad de probabilidad radial en función de la distancia radial.
Consideraciones
Este código resuelve la ecuación de Schrödinger para un electrón en un campo de Coulomb, que es una aproximación simplificada para el átomo de hidrógeno. Para el átomo de oxígeno, este modelo no considera las interacciones electrón-electrón ni la repulsión entre electrones, pero proporciona una idea básica sobre la distribución de probabilidad de un electrón en el orbital 1s.

Este programa aplica muy básicamente la ecuación Schrödinger, explicando una forma de iniciación
que resuelve la posivilidad probabilistica de encontrar la párticula, como se puede ver en el gráfico resultante.

Durante el código, explicamos lo más conciso posible los pasos más importantes. En el aula, durante la segunda semana de spetiembre trataremos de explicar el resto de las dudas, así como aumentar la complejidad del
código para acercarlo lo más posible a la realidad CUÁNTICA.

-----------------------------------------------------------------------------------------------------
Programa realizado bajo Linux, sistema operativo: Ubuntu 20.04.6 LTS.
Editor Sublime text.
Ejecución:python3 Aula_18_Apli_Sep_Schrödinger_Oxigeno.py

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.

Aplicación en Java para chatear con la I.A. generativa Llama3.

* El usuario puede hablar al micrófono (speechToText), editar el texto reconocido y enviárselo a la I.A.

* La I.A. responde y el servidor va devolviendo esa respuesta en tiempo real, y las frases convertidas a audio (textToSpeech), y la aplicación las emite por el altavoz.

La aplicación está preparada para que únicamente haya un usuario ocupando los recursos del servidor, por lo que si el servidor está ocupado, en teoría no te dejará conectar.

Hay un vídeo de demostración que muestra el funcionamiento:

https://frojasg1.com:8443/resource_counter/resourceCounter?operation=countAndForward&url=https%3A%2F%2Ffrojasg1.com%2Fdemos%2Faplicaciones%2Fchat%2F20240815.Demo.Chat.mp4%3Forigin%3Dlawebdelprogramador&origin=web

Hola a todos aqui les dejo un generador de contraseñas que escribi en php, boostrap, css y javascript

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.

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.

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

Aula_26_Tecnología.py
******************************

Realizamos en lenguaje python. En un hipotetico espacio de Hilbert. La multiplicacion de dos ondas acusticas, con estos parámetros que os pongo a continuación:

Parámetros de las ondas:
frecuencia1 = 38 # Frecuencia de la primera onda (A4)
frecuencia2 = 36 # Frecuencia de la segunda onda (E5)
duracion = 12.0 # Duración en segundos
fs = 47100 # Frecuencia de muestreo

Mostraremos el resultado final graficamente. Al mismo tiempo deberemos guardar el archivo
resultante de sonido en (Debes de modificarla en tu caso) en esta ruta: /home/margarito/python/Mi_Archivo.wav.
Tambien se ejecutará el archivo de sonido incluyendo el código en el propio programa python.


Resumen del Ejercicio

En este ejercicio, hemos creado un programa en Python que realiza las siguientes tareas:

Definición de Parámetros:

Se definen dos frecuencias (38 Hz y 36 Hz), una duración de 12 segundos y una frecuencia de muestreo de 47100 Hz.

Generación de Ondas:

Se generan dos ondas sinusoidales (onda1 y onda2) con las frecuencias especificadas utilizando numpy.

Multiplicación de Ondas:

Las dos ondas generadas se multiplican para obtener una onda resultante (resultado).

Guardado de la Onda Resultante:

La onda resultante se guarda en un archivo de sonido WAV, usando soundfile.

Visualización Gráfica:

Se muestran gráficas de las dos ondas originales y la onda resultante en una figura con tres subgráficos utilizando matplotlib.

Reproducción del Sonido:

El archivo de sonido resultante se reproduce utilizando sounddevice.

----------------------------------------------------------------
Ejercicio realizado bajo Linux, con Ubuntu 20.04.6 LTS.
Editado con Sublime text. Ejecutado bajo consola Linux.


Para que todo funcione, deberemos instalar sounddevice.
Abre una terminal y ejecuta el siguiente comando para instalar portaudio:


sudo apt-get install portaudio19-dev
Paso 2: Instalar sounddevice usando pip.
Si pip no lo tienes instalado deberás instalarlo.

sudo apt-get install python3-pip
Luego, instala sounddevice:

pip3 install sounddevice

-------------------------------------------
Ejecución del ejercicio, bajo consola linux:
python3 Aula_26_Tecnología.py