La IA se ha convertido en una palabra de moda y las aplicaciones de procesamiento del lenguaje natural (NLP) están creciendo exponencialmente en el dominio de la IA. Python ha sido un actor destacado en la IA y, en este artículo, profundizaremos en los detalles de una nueva y emocionante biblioteca de Python conocida como Scikit-LLM.
Scikit-LLM integra a la perfección modelos de lenguaje potentes como ChatGPT en scikit-learn para tareas de análisis de texto mejoradas. En este artículo, descubriremos cómo usar esta herramienta con el conjunto de datos de revisión de medicamentos de UCI y un conjunto de datos de Diamonds.
Para seguir este artículo, puede usar Google Colab o cualquier otro entorno de Python. ¡Empecemos!
Puede instalar Scikit-LLM usando pip:
!pip install scikit-llm
A continuación, comprendamos los pasos necesarios para configurar Scikit-LLM para su uso. Necesitamos una clave API de OpenAI. Sin embargo, los límites de tasa de una cuenta OpenAI de prueba gratuita no son suficientes. Cambie al plan de «pago por uso».
from skllm.config import SKLLMConfigSKLLMConfig.set_openai_key("<YOUR_KEY>")
SKLLMConfig.set_openai_org("<YOUR_ORGANISATION>")
Descargaremos el conjunto de datos de revisión de medicamentos y lo procesaremos previamente para nuestro análisis. Este conjunto de datos contiene revisiones y calificaciones de diferentes medicamentos.
import requests
import zipfile
import os# URL of the dataset zip file
url = 'https://github.com/fenago/datasets/raw/main/drugsComTest_raw.zip'
# Send a HTTP request to the URL of the zip file
response = requests.get(url)
# Name of the zip file
zip_file_name = 'drugsComTest_raw.zip'
# Write the content of the response to a zip file in the current directory
with open(zip_file_name, 'wb') as file:
file.write(response.content)
# Use zipfile to extract the file
with zipfile.ZipFile(zip_file_name, 'r') as file:
file.extractall()
import pandas as pddf = pd.read_csv('drugsComTest_raw.tsv', delimiter='\t')
df_subset = df.head(30)
Comenzaremos con una aplicación simple pero poderosa de ChatGPT: clasificación de texto de tiro cero. Aquí, nuestro objetivo es predecir el estado del paciente en función de la revisión del fármaco.
from skllm import ZeroShotGPTClassifier# Preparing data
X = df["review"].values[:100] # Let's only take a subset for quick testing
y = df["condition"].values[:100]
# Training the classifier
clf = ZeroShotGPTClassifier(openai_model="gpt-3.5-turbo")
clf.fit(X, y)
# Making predictions
labels = clf.predict(X)
print(labels)
En el código de Python provisto, usamos una técnica llamada Aprendizaje de tiro cero con el modelo ChatGPT para clasificar las revisiones de medicamentos según sus condiciones.
El aprendizaje de tiro cero es un concepto en el aprendizaje automático en el que un modelo puede comprender y tomar decisiones sobre datos que no ha visto durante el entrenamiento. La clase «ZeroShotGPTClassifier» de la biblioteca «scikit-llm» nos permite realizar una clasificación de texto de tiro cero utilizando el modelo GPT-3.5-turbo de OpenAI.
Primero, extraemos un subconjunto de 100 revisiones y sus condiciones asociadas de nuestro DataFrame de revisiones de medicamentos. Luego instanciamos un ZeroShotGPTClassifier, especificando el modelo GPT-3.5-turbo de OpenAI como nuestro modelo de lenguaje elegido. Después de esto, llamamos al método de ajuste en el clasificador y pasamos nuestros textos de revisión y condiciones, preparando así al clasificador para clasificar nuevos textos de revisión en una de las condiciones que ha visto durante la fase de entrenamiento.
Finalmente, hacemos predicciones introduciendo las mismas 100 reseñas en el clasificador. El método de predicción devuelve una lista de condiciones, una para cada texto de revisión. Luego se imprime esta lista.
En lenguaje sencillo, entrenamos un modelo inteligente de IA para leer y comprender las condiciones que se discutieron en un conjunto de revisiones de medicamentos. Después de mostrarle 100 revisiones y decirle de qué condición se trataba cada revisión, le pedimos que adivinara las condiciones de esas mismas 100 revisiones en función de lo que había aprendido. El resultado final impreso es la mejor suposición del modelo de IA sobre la condición de la que trata cada revisión.
Esta canalización simple le permite integrar GPT-3 de OpenAI en los flujos de trabajo de scikit-learn. Impresionante, ¿no?
Los modelos GPT se destacan en la realización de tareas de resumen. Aquí, intentaremos generar un breve resumen de cada revisión.
from skllm.preprocessing import GPTSummarizer# Preparing data
X = df["review"].values[:100]
# Text summarization
s = GPTSummarizer(openai_model="gpt-3.5-turbo", max_words=15)
summaries = s.fit_transform(X)
print(summaries)
En este fragmento de Python, aprovechamos el poder de los grandes modelos de lenguaje para resumir el texto. Específicamente, usamos el modelo GPT-3.5-turbo de OpenAI y la clase «GPTSummarizer» de la biblioteca «scikit-llm» para crear resúmenes concisos de revisiones de medicamentos.
Inicialmente, extraemos un subconjunto de 100 revisiones de nuestro DataFrame de revisiones de medicamentos.
A continuación, creamos una instancia de GPTSummarizer y especificamos que el resumen debe limitarse a 15 palabras como máximo (vale la pena señalar que este es un límite suave y que la longitud real a veces puede excederlo).
El método fit_transform se llama en el resumen, con nuestro conjunto de revisiones como entrada. Este método funciona alimentando cada revisión al modelo de lenguaje y recuperando una versión resumida de la misma.
Finalmente, imprimimos las reseñas resumidas. Estos deben representar una versión destilada del texto original, conservando solo las partes más esenciales y significativas y omitiendo detalles menos importantes.
En términos simples, le pedimos a un modelo de IA que leyera 100 revisiones de medicamentos y generara una versión más corta de cada una, limitada a unas 15 palabras. El resultado resultante es el intento de la IA de crear un «resumen» de cada revisión.
La Vectorización de Texto es un paso esencial en cualquier tarea de PNL. Con Scikit-LLM, puede convertir fácilmente sus datos de texto en un formato numérico que se puede usar con prácticamente cualquier modelo de clasificación o regresión. Combinaremos esto con un conjunto de datos de Diamantes, prediciendo el precio de un diamante en función de sus atributos y un campo de descripción.
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestRegressor
from skllm.preprocessing import GPTVectorizer# Let's download and read the Diamonds dataset
diamonds_url = "https://raw.githubusercontent.com/fenago/datasets/main/diamonds.csv"
df_diamonds = pd.read_csv(diamonds_url)
# Let's assume that we have a 'description' field (combining cut, color, and clarity into one text field)
df_diamonds['description'] = df_diamonds[['cut', 'color', 'clarity']].agg(' '.join, axis=1)
# Splitting the data
X = df_diamonds['description']
y = df_diamonds['price']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Creating a pipeline with GPTVectorizer and RandomForestRegressor
steps = [("GPT", GPTVectorizer()), ("RF", RandomForestRegressor())]
clf = Pipeline(steps)
# Training the model
clf.fit(X_train, y_train)
# Predicting diamond prices
y_pred = clf.predict(X_test)
print(y_pred)
En este fragmento de código, estamos integrando el poder de los modelos de lenguaje grande con el aprendizaje automático tradicional para predecir los precios de los diamantes en función de sus características descritas en formato de texto.
En primer lugar, usamos la biblioteca pandas para leer un archivo CSV que contiene información sobre diamantes, específicamente su corte, color, claridad y precio.
A continuación, creamos una nueva columna ‘descripción’ en el marco de datos que es una combinación de las columnas ‘corte’, ‘color’ y ‘claridad’. Esto nos proporciona un único campo de texto que resume las características de cada diamante.
Luego dividimos nuestros datos en un conjunto de entrenamiento (80% de los datos) y un conjunto de prueba (20% de los datos) usando la función train_test_split de sklearn. El campo ‘descripción’ se usa como nuestros datos de entrada (X), y el campo ‘precio’ es nuestra variable objetivo (y).
Ahora viene la parte interesante. Creamos un pipeline de sklearn que consta de dos pasos:
- GPTVectorizador: este es un paso de preprocesamiento que transforma la descripción textual de cada diamante en un vector de dimensión fija utilizando un modelo de lenguaje grande (específicamente, un modelo GPT). Este paso es necesario porque los algoritmos tradicionales de aprendizaje automático no pueden procesar datos de texto sin procesar y necesitan una entrada numérica.
- RandomForestRegresor: este es un modelo de aprendizaje automático que aprende a predecir el precio de un diamante en función de la representación vectorizada de su descripción. Los bosques aleatorios son un tipo de modelo de conjunto que combina las predicciones de múltiples árboles de decisión para hacer una predicción final.
Finalmente, ajustamos nuestra canalización a los datos de entrenamiento, lo que significa que estamos entrenando nuestro Random Forest Regressor en las representaciones vectorizadas de las descripciones de nuestros diamantes.
Luego se llama al método de «predicción» en el modelo entrenado, con nuestros datos de prueba como entrada, lo que nos da los precios previstos para los diamantes en nuestro conjunto de prueba.
La salida impresa ‘y_pred’ representa los precios pronosticados de los diamantes en el conjunto de prueba según la descripción de su corte, color y claridad. Esto muestra cómo los modelos de lenguaje grande se pueden integrar con los modelos tradicionales de aprendizaje automático para obtener información de los datos de texto.
Conclusión
Scikit-LLM es una poderosa herramienta que integra a la perfección grandes modelos de lenguaje como GPT-3 en canalizaciones de scikit-learn, mejorando las capacidades de sus tareas de análisis de texto. Cubrimos algunos casos de uso y puede encontrar muchos más en la documentación oficial de Scikit-LLM. ¡Feliz codificación!
El análisis de sentimientos es otra tarea común de PNL donde el objetivo es determinar el sentimiento expresado en un bloque de texto. Scikit-LLM proporciona una manera poderosa de realizar análisis de opinión utilizando GPTVectorizer junto con un clasificador de aprendizaje automático tradicional, como la regresión logística.
Para esta tarea, necesitamos convertir las calificaciones a una forma binaria: «positiva» para calificaciones superiores a 5 y «negativa» en caso contrario. Esto servirá como nuestra etiqueta de sentimiento.
from sklearn.linear_model import LogisticRegression
from skllm.preprocessing import GPTVectorizer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split# Creating binary sentiment labels
df['sentiment'] = df['rating'].apply(lambda x : +1 if x > 5 else -1)
# Preparing the data
X = df['review']
y = df['sentiment']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Creating a pipeline with GPTVectorizer and LogisticRegression
steps = [("GPT", GPTVectorizer()), ("LR", LogisticRegression())]
clf = Pipeline(steps)
# Training the model
clf.fit(X_train, y_train)
# Predicting sentiments
y_pred = clf.predict(X_test)
print(y_pred)
En este ejemplo, está utilizando una combinación de procesamiento de lenguaje natural (NLP) y técnicas tradicionales de aprendizaje automático para predecir el sentimiento de las revisiones de medicamentos.
Inicialmente, se crea una nueva columna ‘sentimiento’ en el DataFrame. Esta columna se completa aplicando una función a la columna «calificación», de modo que las calificaciones superiores a 5 se consideren positivas (+1) y las calificaciones inferiores o iguales a 5 se consideren negativas (-1). Esta es una forma común de crear una tarea de clasificación de opiniones binarias.
Luego, los datos se dividen en características (X: el texto de ‘revisión’) y la variable de destino (y: el ‘sentimiento’ recién creado). Los datos se dividen en conjuntos de entrenamiento y prueba con una proporción de 80/20 utilizando la función train_test_split de sklearn.
Una canalización se configura con dos componentes:
- GPTVectorizador: este es un paso de preprocesamiento que transforma los datos de texto sin procesar en forma numérica al convertir cada revisión en una representación vectorial de dimensión fija utilizando el modelo GPT. Esta vectorización permite que los algoritmos tradicionales de aprendizaje automático procesen los datos de texto.
- Regresión logística: Este es un algoritmo de aprendizaje automático tradicional que a menudo se usa para tareas de clasificación binaria como esta. La regresión logística aprenderá la relación entre la representación vectorizada de cada reseña y su opinión.
Una vez que se ha configurado la canalización, el modelo se entrena llamando a clf.fit(X_train, y_train). Esto implica entrenar el modelo de regresión logística en las representaciones vectorizadas de las revisiones.
Luego, se usa el método clf.predict(X_test) para hacer predicciones de opinión sobre los datos de prueba no vistos.
La salida impresa final, y_pred, representa los sentimientos previstos de las revisiones de medicamentos en el conjunto de prueba. Las predicciones tienen la forma de +1 (sentimiento positivo) o -1 (sentimiento negativo), según el contenido de las reseñas. Este es un gran ejemplo de cómo un modelo de lenguaje grande como GPT se puede combinar con un modelo de aprendizaje automático tradicional para realizar análisis de opinión en datos de texto.