Inteligencia Artificial

Leer un archivo PDF, convertirlo a texto y traducir del inglés al español con Python.

Primero, necesitamos instalar las librerías. Puedes hacer esto utilizando pip en la terminal con los siguientes comandos:

pip install pdfplumber
pip install translate

Luego el código es muy sucinto. Cada instrucción cuenta con una descripción comentada de lo que realiza en el programa. Básicamente hay que tener el archivo PDF en el mismo directorio donde se corre este script de Python, y allí mismo se escribe un nuevo archivo con la traducción.

Estas rutas son también modificables a gusto o conveniencia del usuario o sistema en particular.

import os
import pdfplumber
from translate import Translator

# Ruta del archivo PDF
pdf_file = "doc_to_translate.pdf"

# Crear objeto Translator
translator = Translator(to_lang="es")

# Crear nombre de archivo para el archivo de salida
output_file = os.path.splitext(pdf_file)[0] + "_traducido.txt"

# Crear archivo de salida para escritura
try:
    with open(output_file, 'w', encoding='utf-8') as output:
        # Abrir el archivo PDF
        with pdfplumber.open(pdf_file) as pdf:
            # Iterar por cada página del archivo PDF
            for page in pdf.pages:
                # Obtener el contenido de la página y dividirlo en fragmentos de 500 caracteres
                text = page.extract_text()
                if text:
                    fragments = [text[i:i+500] for i in range(0, len(text), 500)]
                    # Traducir cada fragmento y escribirlo en el archivo de salida
                    for fragment in fragments:
                        translation = translator.translate(fragment)
                        output.write(translation + "\n")
            
    print("Traducción completada y guardada en el archivo:", output_file)

except Exception as e:
    print("No se pudo realizar la traducción. Error:", e)

En este código, estamos utilizando la biblioteca pdfplumber para leer el archivo PDF (bien podría ser PyPDF2 también). Además, estamos manejando los errores de lectura y escritura del archivo mediante la utilización de try y except blocks. Si hay algún error al leer o escribir el archivo, se mostrará un mensaje de error en lugar de simplemente fallar en silencio.

Translate es una herramienta de traducción simple pero poderosa escrita en python con soporte para múltiples proveedores de traducción. Ofrece integración con la API de traducción de Microsoft, la API de MyMemory traducida, LibreTranslate y las API gratuitas y profesionales de DeepL.

La principal razón para usar translate es hacer traducciones de una manera simple sin la necesidad de un mayor esfuerzo y puede usarse como una herramienta de traducción como línea de comando.

Translate posee una cli muy útil y sencilla de usar con la cual puede configurar los parámetros de traducción, definir el motor de traducción(MyMemory por defecto) o agregar una api-key para su uso. Escribes el siguiente comando y sigues las instrucciones.

translate-cli --generate-config-file

La biblioteca translate utiliza una API gratuita llamada MyMemory para realizar las traducciones, y hay un límite en el número de traducciones que se pueden hacer de forma gratuita en un día determinado. Este límite puede variar dependiendo de la disponibilidad del servicio.

Para evitar este problema, puedes intentar lo siguiente:

  1. Esperar hasta que se restablezcan las traducciones gratuitas. La biblioteca translate suele mostrar una hora aproximada de cuándo estará disponible la siguiente traducción gratuita.
  2. Utilizar un servicio de traducción de pago que no tenga límites en el número de traducciones que se pueden realizar. Hay varias opciones disponibles en línea, como Google Cloud Translation, Amazon Translate, etc. Deberás registrarte y seguir los pasos necesarios para obtener acceso a la API y las credenciales de autenticación.
  3. Utilizar otra biblioteca de traducción que utilice una API diferente y no tenga límites en el número de traducciones gratuitas. Hay varias opciones disponibles en línea, como TextBlob, DeepL, etc. Sin embargo, es posible que tengas que ajustar el código para utilizar la API de la biblioteca que elijas.

PostgreSQL, parte 3: Funciones y Procedimientos

Introducción

El lenguaje de procedimientos PL/pgSQL agrega muchos elementos de procedimientos, por ejemplo, estructuras de control, bucles y cálculos complejos, para ampliar el SQL estándar. Le permite desarrollar funciones complejas y procedimientos almacenados en PostgreSQL que pueden no ser posibles usando SQL simple.

El lenguaje de procedimiento PL/pgSQL es similar a Oracle PL/SQL . Las siguientes son algunas de las razones para aprender PL/pgSQL:

  • PL/pgSQL es fácil de aprender y fácil de usar.
  • PL/pgSQL viene con PostgreSQL por defecto. Las funciones definidas por el usuario y los procedimientos almacenados desarrollados en PL/pgSQL se pueden utilizar como cualquier función integrada y procedimiento almacenado.
  • PL/pgSQL hereda todos los tipos, funciones y operadores definidos por el usuario.
  • PL/pgSQL tiene muchas características que le permiten desarrollar funciones complejas y procedimientos almacenados.
  • PL/pgSQL se puede definir para que el servidor de base de datos de PostgreSQL confíe en él.

Las funciones creadas con PL/pgSQL se pueden usar en cualquier lugar donde se puedan usar las funciones integradas. Por ejemplo, es posible crear funciones de cálculo condicional complejas y luego usarlas para definir operadores o usarlas en expresiones de índice.

En PostgreSQL 9.0 y versiones posteriores, PL/pgSQL está instalado de forma predeterminada. Sin embargo, sigue siendo un módulo cargable, por lo que los administradores especialmente conscientes de la seguridad podrían optar por eliminarlo.

Cómo crear un campo updated_at que automaticamente registre la fecha cuando el registro se modifica con PostgreSQL?

Función para actualizar campo de fecha «updated_at»

Para crear un campo updated_at que se actualice automáticamente cuando se modifica un registro por ejemplo en una base de datos MySQL, puedes utilizar la función CURRENT_TIMESTAMP junto con el atributo ON UPDATE.

Aquí está el código para crear una tabla con un campo updated_at:

CREATE TABLE ejemplo (
   id INT PRIMARY KEY,
   nombre VARCHAR(50),
   descripcion VARCHAR(255),
   updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

En este ejemplo, el campo updated_at se establece con un valor predeterminado de la fecha y hora actual utilizando la función CURRENT_TIMESTAMP, y también se agrega el atributo ON UPDATE CURRENT_TIMESTAMP, lo que significa que se actualizará automáticamente con la fecha y hora actual cada vez que se modifique el registro.

Sin embargo, para crear un campo updated_at que se actualice automáticamente cuando se modifica un registro en PostgreSQL, se debe utilizar una función llamada trigger.

Aquí está el código para crear una tabla con un campo updated_at:

CREATE TABLE ejemplo (
   id SERIAL PRIMARY KEY,
   nombre VARCHAR(50),
   descripcion VARCHAR(255),
   updated_at TIMESTAMP
);

En este ejemplo, el campo updated_at se deja sin valor predeterminado ya que será actualizado automáticamente a través de la función trigger.

A continuación, puedes crear una función trigger que se active cada vez que se modifique un registro en la tabla ejemplo, y actualizará automáticamente el valor del campo updated_at con la fecha y hora actual.

CREATE OR REPLACE FUNCTION actualizar_updated_at()
RETURNS TRIGGER AS $$
BEGIN
   NEW.updated_at = NOW();
   RETURN NEW;
END;
$$ LANGUAGE plpgsql;

Esta función trigger utiliza la función NOW() para obtener la fecha y hora actuales y actualizar el campo updated_at del registro modificado.

Por último, puedes crear el trigger que se activará cada vez que se realice una operación UPDATE en la tabla ejemplo, y ejecutará la función trigger actualizar_updated_at().

CREATE TRIGGER trigger_actualizar_updated_at
BEFORE UPDATE ON ejemplo
FOR EACH ROW
EXECUTE FUNCTION actualizar_updated_at();

Este trigger se activará antes de que se actualice cualquier registro en la tabla ejemplo, y ejecutará la función trigger actualizar_updated_at(), que actualizará el campo updated_at con la fecha y hora actuales.

Con estos pasos, el campo updated_at se actualizará automáticamente cada vez que se modifique un registro en la tabla ejemplo. Puedes ajustar los nombres de la tabla y los campos para que se adapten a tus necesidades específicas.

Artículos previos:

PostgreSQL conn, parte 2 técnicas avanzadas, en ChatGPT (OpenAI)

PostgreSQL conn en ChatGPT (OpenAI), Psycopg v2 o v3?

PostgreSQL conn, parte 2 técnicas avanzadas, en ChatGPT (OpenAI)

Hoy he interactuado con Inteligencia Artificial ChatGPT sobre algunas técnicas de SQL, que van más allá de las operaciones CRUD (Crear, Leer, Actualizar y Eliminar) básicas en PostgreSQL. Así que analizaremos la Agregación, daremos un vistazo a las Transacciones que se ampliarán en otro tutorial, y finalmente entraremos a dos ejemplos de lectura y tregistro de datos desde un archivo CSV usando Insert y Copy.

SQL (imagen; Freepik)

Que es la técnica de bases de datos aggregation?

La técnica de agregación de bases de datos es una forma de resumir y analizar grandes conjuntos de datos. Se utiliza comúnmente en bases de datos relacionales y se refiere a la aplicación de una función de agregación a un conjunto de datos para producir un resultado consolidado.

La agregación se puede hacer sobre una o varias columnas de datos y puede involucrar diferentes funciones de agregación, como sumas, promedios, valores máximos y mínimos, entre otras. El resultado de la agregación es una tabla con una sola fila que resume el conjunto de datos en función de las columnas y la función de agregación seleccionada.

Esta técnica se utiliza para generar informes y análisis de datos que permitan a los usuarios ver rápidamente la información importante en una base de datos sin tener que examinar todos los registros individuales. Las consultas de agregación también pueden utilizarse para identificar patrones y tendencias en los datos, lo que puede ayudar a los analistas a tomar decisiones informadas.

tion?

Un ejemplo de la técnica de bases de datos aggregation.

La técnica de agregación de bases de datos se utiliza para realizar cálculos y resúmenes de datos en una tabla de base de datos. Un ejemplo común de la técnica de agregación es el cálculo de la suma, el promedio o la cuenta de los valores en una columna.

Por ejemplo, supongamos que tenemos una tabla de ventas que contiene información sobre los productos vendidos en una tienda en línea. La tabla podría tener las siguientes columnas:

  • id_venta: identificador único de la venta
  • id_producto: identificador único del producto
  • cantidad: cantidad vendida del producto
  • precio_unitario: precio unitario del producto
  • fecha_venta: fecha en que se realizó la venta

Para calcular el total de ventas por día, podríamos utilizar la técnica de agregación. El siguiente ejemplo utiliza SQL para calcular la suma de las ventas por día:

SELECT fecha_venta, SUM(cantidad * precio_unitario) AS total_ventas
FROM ventas
GROUP BY fecha_venta;

Este código SQL utiliza la función SUM() para sumar el producto de la cantidad y el precio unitario para cada venta y agrupar los resultados por fecha de venta utilizando la cláusula GROUP BY. El resultado de esta consulta sería una tabla que muestra el total de ventas por día:

Este es un ejemplo de cómo se puede utilizar la técnica de agregación para resumir y analizar grandes cantidades de datos en una tabla de base de datos de manera eficiente y efectiva.

Qué son las transactions en la base de datos postgresql?

En PostgreSQL, una transacción es un conjunto de operaciones de base de datos que se ejecutan como una única unidad lógica y atómica de trabajo. Una transacción garantiza que todas las operaciones realizadas en la base de datos se completen con éxito, o que se reviertan a su estado anterior si alguna operación falla.

En una transacción, se pueden realizar una o varias operaciones de base de datos, como inserciones, actualizaciones o eliminaciones. Estas operaciones se agrupan y se ejecutan en una secuencia lógica. Si todas las operaciones se completan con éxito, se confirman y se hacen permanentes en la base de datos. Si alguna operación falla, se deshacen todas las operaciones realizadas en la transacción y se revierten a su estado anterior.

El uso de transacciones es importante para garantizar la integridad y consistencia de los datos en la base de datos, especialmente en entornos de base de datos con múltiples usuarios concurrentes. Si varias transacciones intentan acceder a los mismos datos al mismo tiempo, pueden producirse conflictos que afecten la integridad de los datos. Las transacciones permiten a los desarrolladores manejar estos conflictos de manera efectiva y garantizar que la base de datos siempre esté en un estado coherente y correcto.

¿Cómo se realiza el leer y analizar archivos CSV e insertar datos en postgresql utilizando INSERT?

Para leer y analizar archivos CSV y luego insertar los datos en una tabla de PostgreSQL, se puede seguir los siguientes pasos utilizando el lenguaje de programación Python y las librerías Pandas y Psycopg2:

Importar las librerías necesarias:

import pandas as pd
import psycopg2

Leer el archivo CSV en un DataFrame de Pandas:

data = pd.read_csv(‘file.csv’)

Conectarse a la base de datos de PostgreSQL utilizando Psycopg2:

conn = psycopg2.connect(host="localhost", database="mydatabase", user="myusername", password="mypassword")
cur = conn.cursor()

Crear una tabla en PostgreSQL para almacenar los datos del archivo CSV (si aún no existe):

cur.execute("CREATE TABLE IF NOT EXISTS mytable (column1 datatype1, column2 datatype2, ...)")

Recorrer el DataFrame de Pandas y, por cada fila, insertar los datos en la tabla de PostgreSQL:

for index, row in data.iterrows():
    cur.execute("INSERT INTO mytable (column1, column2, ...) VALUES (%s, %s, ...)", (row['column1'], row['column2'], ...))

Confirmar los cambios en la base de datos y cerrar la conexión:

conn.commit()
cur.close()
conn.close()

Con estos pasos, se puede leer y analizar un archivo CSV y luego insertar los datos en una tabla de PostgreSQL de manera eficiente utilizando Python, Pandas y Psycopg2. Es importante asegurarse de que los datos del archivo CSV se correspondan con los tipos de datos de las columnas de la tabla de PostgreSQL para evitar errores de inserción.

¿Cómo se realiza el leer y analizar archivos CSV e insertar datos en postgresql usando COPY?

Para leer y analizar archivos CSV y luego insertar los datos en una tabla de PostgreSQL usando el comando COPY, se pueden seguir los siguientes pasos:

  1. Crear una tabla en PostgreSQL que tenga la misma estructura que el archivo CSV que se va a cargar:
CREATE TABLE mytable (
  column1 datatype1,
  column2 datatype2,
  ...
);
  1. Preparar un archivo CSV que tenga el mismo formato que la tabla en PostgreSQL y que contenga los datos que se van a cargar.
  2. Abrir una conexión a la base de datos de PostgreSQL usando un objeto psycopg2 y crear un cursor:
import psycopg2

conn = psycopg2.connect(database="mydatabase", user="myusername", password="mypassword", host="localhost", port="5432")
cur = conn.cursor()

4. Usar el comando COPY para cargar los datos del archivo CSV en la tabla de PostgreSQL:

with open('file.csv', 'r') as f:
    next(f) # Omitir la primera fila si es un encabezado
    cur.copy_from(f, 'mytable', sep=',')

El primer argumento de la función copy_from() es el objeto de archivo CSV que se va a cargar. El segundo argumento es el nombre de la tabla de PostgreSQL en la que se van a cargar los datos. El tercer argumento es el separador de campo utilizado en el archivo CSV (en este ejemplo, una coma).

5. Confirmar los cambios en la base de datos y cerrar la conexión:

conn.commit()
cur.close()
conn.close()

Con estos pasos, se pueden leer y analizar archivos CSV y luego insertar los datos en una tabla de PostgreSQL utilizando el comando COPY de manera eficiente y sin tener que recorrer los datos fila por fila. Es importante asegurarse de que los datos del archivo CSV se correspondan con los tipos de datos de las columnas de la tabla de PostgreSQL para evitar errores de carga.

Recursos

OpenAI API link

Curso recomendado link

Tutorial ¿Cómo configurar Airflow en un servidor Ubuntu? Parte 1

AirFlow corriendo en localhost:8080

Para configurar Airflow en un servidor Ubuntu, sigue estos pasos:

Instala Python en el servidor Ubuntu si aún no lo has hecho. Puedes hacerlo ejecutando el siguiente comando:

Por lo general las distribuciones de Linux ya traen por defecto Python instalado, así que sin problema puedes saltar el paso anterior.

Instala Apache Airflow y sus dependencias usando pip. Puedes hacerlo ejecutando el siguiente comando:

Configura la base de datos de Airflow. Puedes hacerlo ejecutando los siguientes comandos incorporando tus credenciales:

airflow db init
airflow users create --username admin --password admin --firstname FIRST_NAME --lastname LAST_NAME --role Admin --email admin@example.com

El primer comando inicializa la base de datos de Airflow y el segundo comando crea un usuario administrador para Airflow. Toma en consideración que esta configuración se realiza por defecto sobre SQLite así que tendrás un entorno configurado para desarrollo no para ´producción, para lo cual deberás configurar otro motor de base de datos que utilice AirFlow.

Inicia el servidor web de Airflow ejecutando el siguiente comando:

airflow webserver -p 8080

Esto iniciará el servidor web de Airflow en el puerto 8080.

Inicia el scheduler de Airflow ejecutando el siguiente comando en otra ventana de terminal:

El scheduler es responsable de programar y ejecutar las tareas en Airflow.

Accede a la interfaz web de Airflow en tu navegador web navegando a http://<IP del servidor Ubuntu>:8080. Ingresa con las credenciales de usuario que creaste anteriormente.

Crea un archivo DAG (directed acyclic graph) para definir y programar tus tareas en Airflow. Puedes crear el archivo DAG en un directorio específico que hayas configurado en el archivo de configuración de Airflow.

A partir de aca te recomendamos leer y seguir la documentación oficial de AirFlow en How-to Guides

Verifica que tus tareas se ejecuten correctamente en Airflow y realiza cualquier ajuste necesario en el archivo DAG. Siguiendo estos pasos, deberías poder configurar Airflow en un servidor Ubuntu y comenzar a programar y ejecutar tareas. Ten en cuenta que es importante seguir las mejores prácticas de seguridad al configurar tu servidor y Airflow.

En el siguiente tutorial mostraremos como cambiar la base de datos default que utiliza Airflow de SQLite a Postgresql.

ETL pipeline Comprendiendo a Elon Musk por sus tweets Parte 1

Creación de un conjunto de datos de Twitter con Pandas en Python utilizando la biblioteca Snscrape. Persistencia de datos en MySQL. Este código busca tweets de Elon Musk desde el 1 de enero de 2021 hasta el 1 de enero de 2022 y guarda los resultados en un archivo CSV llamado «tweets.csv».

Instalar Snscrape y Pandas utilizando pip en tu entorno virtual de Python:

pip install snscrape pandas

Importar las bibliotecas necesarias:

import snscrape.modules.twitter as sntwitter import pandas as pd

Definir una consulta de búsqueda utilizando el formato de consulta de búsqueda de Twitter:

query = «from:elonmusk since:2021-01-01 until:2022-01-01»

image

Opcionalmente, puedes guardar el dataframe en un archivo CSV para su posterior uso:

Captura de pantalla dataset

Para limpiar los datos obtenidos del archivo «tweets.csv» creado anteriormente, podemos utilizar Pandas para cargar el archivo CSV en un dataframe y luego realizar diversas operaciones de limpieza y preprocesamiento de datos.

image

Este es solo un ejemplo básico de algunas de las operaciones de limpieza que se pueden realizar en los datos de los tweets. Dependiendo de los datos específicos que se estén utilizando, puede ser necesario realizar otras operaciones de limpieza y preprocesamiento de datos.

Para guardar el dataset de tweets limpios en un nuevo archivo CSV llamado «tweets_limpios.csv», podemos utilizar el método to_csv() del dataframe de Pandas.

Aquí te dejo un ejemplo de cómo podrías hacerlo:

image

Para guardar los datos del archivo «tweets_limpios.csv» en una base de datos MySQL, necesitaremos instalar la librería de Python mysql-connector-python. También necesitaremos crear una base de datos y una tabla en MySQL para almacenar los datos.

A continuación te dejo un ejemplo de cómo podrías hacerlo:

Primero, instala la librería mysql-connector-python utilizando el siguiente comando en la terminal o en el símbolo del sistema (si estás utilizando Windows):

pip install mysql-connector-python

A continuación, crea una base de datos y una tabla en MySQL utilizando los siguientes scripts SQL:

image

Este script creará una base de datos llamada tweets_db y una tabla llamada tweets con dos columnas: id (un número de identificación único para cada tweet) y tweet_text (el texto del tweet).

Ahora, puedes utilizar el siguiente script de Python para leer los datos del archivo «tweets_limpios.csv» y guardarlos en la base de datos:

image

Asegúrate de cambiar los valores de host, user y password en la función mysql.connector.connect() para que coincidan con tu configuración de MySQL.

Este script carga los datos del archivo CSV en un dataframe de Pandas y luego se conecta a la base de datos MySQL utilizando la librería mysql-connector-python. A continuación, se crea un cursor para ejecutar comandos SQL y se inserta cada tweet en la tabla de la base de datos utilizando un bucle for y la función cursor.execute(). Finalmente, se cierra la conexión con la base de datos y se imprime un mensaje para confirmar que los datos se han guardado correctamente.

Espero que esto te ayude a guardar los datos del archivo «tweets_limpios.csv» en una base de datos MySQL.

Código en GitHub >> https://github.com/DaveSV/ETL-pipeline-Elon-Musk-1

En la Parte 2 de este tutorial avanzaremos a programar, monitorear y administrar todo el flujo de trabajo de estos datos con Airflow.

Reconocimiento de voz usando Transformers en Python.

Resumen: Reconocimiento automático de voz (ASR) usando el transformador wav2vec2 con la ayuda de la biblioteca de transformadores Huggingface en Python

El reconocimiento automático de voz (ASR) es la tecnología que nos permite convertir el habla humana en texto digital. Este tutorial se sumergirá en el modelo de vanguardia actual llamado Wav2vec2 utilizando la biblioteca de transformadores Huggingface en Python.

Wav2Vec2  es un modelo preentrenado que se entrenó solo en el audio del habla (autosupervisado) y luego siguió un ajuste fino en los datos del habla transcritos ( conjunto de datos LibriSpeech ). Ha superado a los modelos semisupervisados ​​anteriores.

Al igual que en el modelado de lenguaje enmascarado, Wav2Vec2 codifica el audio del habla a través de una red neuronal convolucional de múltiples capas y luego enmascara tramos de las representaciones del habla latente resultantes. Estas representaciones luego se alimentan a una red de transformadores para construir representaciones contextualizadas; Consulte el documento Wav2Vec2 para obtener más información.

Para comenzar, instalemos las bibliotecas requeridas:

$ pip3 install transformers==4.11.2 soundfile sentencepiece torchaudio pydub pyaudio

Usaremos torchaudio para cargar archivos de audio. Tenga en cuenta que necesita instalar PyAudio si va a usar el código en su entorno y PyDub si está en un entorno Colab. Los vamos a usar para grabar desde el micrófono en Python.

Empezando

Importemos nuestras bibliotecas:

from transformers import *
import torch
import soundfile as sf
# import librosa
import os
import torchaudio

A continuación, cargando el procesador y los pesos del modelo de wav2vec2:

# model_name = "facebook/wav2vec2-base-960h" # 360MB
model_name = "facebook/wav2vec2-large-960h-lv60-self" # 1.18GB

processor = Wav2Vec2Processor.from_pretrained(model_name)
model = Wav2Vec2ForCTC.from_pretrained(model_name)

Hay dos arquitecturas de modelo y pesos más utilizados para wav2vec. wav2vec2-base-960hes una arquitectura base con aproximadamente 360 ​​MB de tamaño, logró una tasa de error de palabra (WER) del 3,4 % en el conjunto de prueba limpio y se entrenó en 960 horas del conjunto de datos LibriSpeech en audio de voz muestreado de 16 kHz.

Por otro lado, wav2vec2-large-960h-lv60-selfes un modelo más grande con aproximadamente 1,18 GB de tamaño (probablemente no se ajuste a la memoria RAM de su computadora portátil) pero logró un 1,9 % de WER (cuanto más bajo, mejor) en el conjunto de prueba limpio. Entonces, este es mucho mejor para el reconocimiento, pero más pesado y toma más tiempo para la inferencia. Siéntase libre de elegir cuál se adapta mejor a usted.

Wav2Vec2 se entrenó usando la clasificación temporal conexionista (CTC) , por eso estamos usando la Wav2Vec2ForCTCclase para cargar el modelo.

A continuación, aquí hay algunas muestras de audio:

# audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/16-122828-0002.wav"
audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/30-4447-0004.wav"
# audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/7601-291468-0006.wav"

Preparación del archivo de audio

Siéntase libre de elegir cualquiera de los archivos de audio anteriores. A continuación, la celda carga el archivo de audio:

# load our wav file
speech, sr = torchaudio.load(audio_url)
speech = speech.squeeze()
# or using librosa
# speech, sr = librosa.load(audio_file, sr=16000)
sr, speech.shape

(16000, torch.Size([274000]))

La torchaudio.load()función carga el archivo de audio y devuelve el audio como un vector y la frecuencia de muestreo. También descarga automáticamente el archivo si es una URL. Si es una ruta en el disco, también lo cargará.Tenga en cuenta que también usamos el squeeze()método, es para eliminar las dimensiones con el tamaño de 1. es decir, convertir el tensor de (1, 274000)(274000,).

A continuación, debemos asegurarnos de que el archivo de audio de entrada al modelo tenga una frecuencia de muestreo de 16000 Hz porque wav2vec2 está entrenado para eso:

# resample from whatever the audio sampling rate to 16000
resampler = torchaudio.transforms.Resample(sr, 16000)
speech = resampler(speech)
speech.shape

torch.Size([274000])

Usamos Resamplede torchaudio.transforms , que nos ayuda a convertir el archivo de audio cargado sobre la marcha de una frecuencia de muestreo a otra.

Antes de hacer la inferencia, pasamos el vector de audio al procesador wav2vec2:

# tokenize our wav
input_values = processor(speech, return_tensors="pt", sampling_rate=16000)["input_values"]
input_values.shape

torch.Size([1, 274000])

CopiarEspecificamos el argumento sampling_ratey pasamos "pt"return_tensorspara obtener los tensores de PyTorch en los resultados.

Realización de inferencia

Ahora pasemos el vector a nuestro modelo:

# perform inference
logits = model(input_values)["logits"]
logits.shape

torch.Size([1, 856, 32])

Pasando los logits a torch.argmax()para obtener la predicción probable:

# use argmax to get the predicted IDs
predicted_ids = torch.argmax(logits, dim=-1)
predicted_ids.shape

torch.Size([1, 856, 32])

Al decodificarlos de nuevo a texto, también bajamos el texto, ya que está en mayúsculas:

# decode the IDs to text
transcription = processor.decode(predicted_ids[0])
transcription.lower()

and missus goddard three ladies almost always at the service of an invitation from hartfield and who were fetched and carried home so often that mister woodhouse thought it no hardship for either james or the horses had it taken place only once a year it would have been a grievance

Terminando el código

Ahora recopilemos todo nuestro código anterior en una sola función, que acepta la ruta de audio y devuelve la transcripción:

def get_transcription(audio_path):
  # load our wav file
  speech, sr = torchaudio.load(audio_path)
  speech = speech.squeeze()
  # or using librosa
  # speech, sr = librosa.load(audio_file, sr=16000)
  # resample from whatever the audio sampling rate to 16000
  resampler = torchaudio.transforms.Resample(sr, 16000)
  speech = resampler(speech)
  # tokenize our wav
  input_values = processor(speech, return_tensors="pt", sampling_rate=16000)["input_values"]
  # perform inference
  logits = model(input_values)["logits"]
  # use argmax to get the predicted IDs
  predicted_ids = torch.argmax(logits, dim=-1)
  # decode the IDs to text
  transcription = processor.decode(predicted_ids[0])
  return transcription.lower()

CopiarImpresionante, puede pasar cualquier ruta de archivo de voz de audio:

get_transcription("http://www0.cs.ucl.ac.uk/teaching/GZ05/samples/lathe.wav")

a late is a big tool grab every dish of sugar

Aplicándolo al idioma español

Este modelo funciona muy bien, pero con audios y modelos pre-entrenados en idioma inglés. Lo hemos adecuado a que funcione con audios en español, tanto de archivos como grabados en directo, utilizando en este caso modelos de Hugging Face entrenados en idioma español.

Más archivos de audio en este link.

Puedes acceder al link de Hugging Face y mirar los demas modelos filtrando por idioma.

Conclusión

Impresionante, ahora si quieres usar tu voz, he preparado un fragmento de código en los cuadernos para grabar con tu micrófono. Siéntase libre de elegir el entorno que está utilizando:

Como indiqué, tenga en cuenta que hay otros pesos wav2vec2 entrenados por otras personas en idiomas diferentes al inglés. Consulte la página de modelos y filtre en el idioma de su deseo para obtener el modelo deseado, por ejemplo los desarrollados por Open AI.

PostgreSQL conn en ChatGPT (OpenAI), Psycopg v2 o v3?

Hoy le he dado la siguiente orden a la Inteligencia Artificial ChatGPT para la creación de un broque de código: «crea codigo en python para conectarse a una base de datos postgresql y insertar datos desde un archivo csv linea por linea omitiendop el encabezado»

La IA, como en otras ocasiones, empezó a escribir el bloque de código en la ventana del chat:

import psycopg2
import csv

# Conexión a la base de datos
conn = psycopg2.connect(
    host="hostname",
    database="database",
    user="username",
    password="password"
)
cursor = conn.cursor()

# Nombre de la tabla y los nombres de las columnas que se insertarán
table_name = "table_name"
column_names = ["col_1", "col_2", "col_3"]

# Apertura del archivo CSV y lectura de datos
with open('data.csv', 'r') as file:
    reader = csv.reader(file)
    header = True
    for row in reader:
        if header:
            header = False
            continue
        # Creación de una lista con los valores de cada columna
        values = [row[0], row[1], row[2]]
        # Creación de una sentencia SQL para insertar datos
        sql = f"INSERT INTO {table_name} ({','.join(column_names)}) VALUES ({','.join(['%s'] * len(column_names))});"
        cursor.execute(sql, values)

# Guardar los cambios y cerrar la conexión
conn.commit()
cursor.close()
conn.close()

Es un código correcto, en donde únicamente hay que considerar que se asume que el archivo CSV data.csv tiene tres columnas y que el encabezado está en la primera línea del archivo. Se puede modificar el código según sea necesario para adaptarlo a los requisitos específicos, como son las credenciales a la base de datos, o restringir por campos el volcado de datos del CSV.

Sin embargo lo interesante es que ChatGPT recomendara, por defecto, el uso de psycopg v2 y no la version 3 der apadtador la cual tiene ya un par de años de estar disponible. Esta versión de adaptador la utilizo en la actualidad satisfactoriamente.

Psycopg 3 es un adaptador de base de datos PostgreSQL de nuevo diseño para el lenguaje de programación Python.

Psycopg 3 presenta una interfaz familiar para todos los que han utilizado Psycopg 2 o cualquier otro adaptador de base de datos DB-API 2.0, pero permite utilizar características más modernas de PostgreSQL y Python, tales como:

  • Soporte asincrónico
  • Compatibilidad con COPY desde objetos Python
  • Un grupo de conexiones rediseñado
  • Soporte para escritura estática
  • Enlace de parámetros del lado del servidor
  • Declaraciones preparadas
  • Canalización de estados de cuenta
  • Comunicación binaria
  • Acceso directo a las funcionalidades libpq

Sobre el uso básico del módulo, métodos abreviados y su utilización como gestor de contexto visite >> Uso básico del módulo – documentación de psycopg 3.2.0.dev1

Detección de antisemitismo en línea usando aprendizaje profundo multimodal

En los últimos tiempos, el antisemitismo en línea se ha convertido en una de las formas más extendidas de discurso de odio en las principales plataformas de redes sociales.

El aumento exponencial de las redes sociales en línea ha permitido la creación, distribución y consumo de información a un ritmo sin precedentes. Sin embargo, también ha llevado al florecimiento de varias formas de abuso en línea.

Los crecientes casos de antisemitismo en línea se han convertido en una de las principales preocupaciones debido a sus consecuencias sociopolíticas.

A diferencia de otras formas importantes de abuso en línea como el racismo, el sexismo, etc., el antisemitismo en línea no se ha estudiado mucho desde la perspectiva del aprendizaje automático.

El machine learning o aprendizaje automático es una de las disciplinas más conocidas y exitosas de la Inteligencia Artificial (IA). Esta disciplina proporciona a los sistemas la capacidad de aprender y mejorar automáticamente a partir de la experiencia, sin ser explícitamente programados para ello.

Los autores proponen de esta investigación proponen una arquitectura detallada de detección de antisemitismo multimodal (texto e imagen) que aprovecha el progreso reciente en arquitecturas de aprendizaje profundo (deep learning).

Artículo en idioma inglés >> https://dl.acm.org/doi/fullHtml/10.1145/3447535.3462502

Repositorio GitHub >> https://github.com/mohit3011/Online-Antisemitism-Detection-Using-MultimodalDeep-Learning/blob/main/main.py

Contenido compartido respetando derechos de autor.

¿Puede la Inteligencia Artificial sustituir al Ser Humano? ¿Puede imitar o sustituirlo en sus labores?

Lo primero por mirar para responder esta pregunta son las capacidades de Procesamiento de Lenguaje Natural (NLP) de los nuevos sistemas.

Photo by Alex Knight on Pexels.com

Hoy en dia tiene gran suceso la aparición de ChatGPT de OpenAI.

ChatGPT es un prototipo de chatbot de inteligencia artificial desarrollado en 2022 por OpenAI que se especializa en el diálogo.

https://openai.com/blog/chatgpt/

El chatbot es un gran modelo de lenguaje ajustado con técnicas de aprendizaje tanto supervisadas como de refuerzo. O lo que es, en pocas palabras, un robot de conversación con inteligencia artificial.

Para probar esta AI puede superar algunos limites que presupopnes respecto de estas nuevas tecnologías le solicité que resolviera uno de los retos de codificación que plantea HackerRank en su serie «30 Days of Code». Propiamente, «Day 10: Binary Numbers».

https://www.hackerrank.com/challenges/30-binary-numbers/problem?isFullScreen=true

ChatGPT screen

La codificación plantea la conversión entre sistemas numéricos y el conteo de series. La respuesta de ChatGPT la dió en una función que denominó «consecutive_ones()», como se muestra en la imagen.

Esto código lo corrí en la plataforma de testeo de HackerRank y lo validó como correcto.

Código en Python generado por ChatGPT
Validación de código por HackerRank

Sin embargo esto no nos permite extraer conclusiones generalizadas ni mucho menos contestar a la pregunta inicial. En mi criterio la AI puede emular capacidades de cálculo y razonamiento, es lo que hacen los sistemas de cómputo actuales, y generar decisiones sobre esto.

Pero aún distan mucho de poder hacer valoraciones éticas o morales conforme a paradigmas vigentes en la sociedad, pero de lo visto si podemos concluir que la inteligencia artificial podría cambiar la forma en la que los seres humanos ejecutan sus labores a corto y mediano plazo.

La Pandemia aún no acaba, y como señalan los expertos, no acabará.

Vino para quedarse, y algunos paises donde se ha controlado el contagio la han recalificado como «gripe o enfermedad respiratoria simple».

El sentimiento frente al COVID19 entre usuarios de redes sociales (en este caso Twitter) se ha tormado positivo como se muestra en el mapa de calor donde verde es positivo (1-0) y rojo negativo (-1.0).

Sin embargo esta percepción positiva podría acarrear problemas a corto plazo por ejemplo en la efectividad de los esquemas de vacunación frente a la mutabilidad del virus, y otros pautas de prevención que en forma generalizada se han ido relajando.

Por otro lado, es importante considerar que a pesar del carácter esencial de los datos para la toma de decisiones tanto de las autoridades, grupos de influencia y población en general, no ha habido un buen manejo de los datos como los casos y muertes por sexo y edad, salvo en pocos paises.

Incluso la polémica se ha llevado a esferas de algunos gobiernos a quienes señalan de haber ocultados o manipulado las cifras con algún interés calculado. Caso aparte es el de paises como China, Venezuela o Corea del Norte.

Datos: Rabindra Lamsal, March 13, 2020, «Coronavirus (COVID-19) Tweets Dataset», IEEE Dataport, doi: https://dx.doi.org/10.21227/781w-ef42.