Integre fácilmente LLM en su flujo de trabajo de Scikit-learn con Scikit-LLM - KDnuggets

Reeditado por Platón

seguidores: 0

Integre fácilmente LLM en su flujo de trabajo de Scikit-learn con Scikit-LLM
Imagen generada por DALL-E 2

Las tareas de análisis de texto existen desde hace algún tiempo ya que las necesidades siempre están ahí. La investigación ha recorrido un largo camino, desde simples descripciones estadísticas hasta clasificación de texto y generación avanzada de texto. Con la incorporación del modelo de lenguaje grande a nuestro arsenal, nuestras tareas laborales se vuelven aún más accesibles.

Scikit-LLM es un paquete Python desarrollado para actividades de análisis de texto con el poder de LLM. Este paquete se destacó porque pudimos integrar el proceso estándar de Scikit-Learn con Scikit-LLM.

Entonces, ¿de qué se trata este paquete y cómo funciona? Entremos en ello.

Scikit-LLM es un paquete de Python para mejorar las tareas de análisis de datos de texto a través de LLM. Fue desarrollado por beatsbyte para ayudar a unir la biblioteca estándar Scikit-Learn y el poder del modelo de lenguaje. Scikit-LLM creó su API para que sea similar a la biblioteca SKlearn, por lo que no tenemos demasiados problemas para usarla.

Instalación

Para utilizar el paquete, necesitamos instalarlos. Para hacer eso, puede usar el siguiente código.

pip install scikit-llm

Al momento de escribir este artículo, Scikit-LLM solo es compatible con algunos de los modelos OpenAI y GPT4ALL. Por eso solo trabajaríamos con el modelo OpenAI. Sin embargo, puede utilizar el modelo GPT4ALL instalando el componente inicialmente.

pip install scikit-llm[gpt4all]

Después de la instalación, debe configurar la clave OpenAI para acceder a los modelos LLM.

from skllm.config import SKLLMConfig

SKLLMConfig.set_openai_key("")
SKLLMConfig.set_openai_org("")

Probando Scikit-LLM

Probemos algunas capacidades de Scikit-LLM con el entorno configurado. Una capacidad que tienen los LLM es realizar clasificación de texto sin necesidad de volver a capacitarse, lo que llamamos Zero-Shot. Sin embargo, inicialmente intentaríamos una clasificación de texto de pocas tomas con los datos de muestra.

from skllm import ZeroShotGPTClassifier
from skllm.datasets import get_classification_dataset


#label: Positive, Neutral, Negative
X, y = get_classification_dataset()


#Initiate the model with GPT-3.5
clf = ZeroShotGPTClassifier(openai_model="gpt-3.5-turbo")
clf.fit(X, y)
labels = clf.predict(X)

Solo necesita proporcionar los datos de texto dentro de la variable X y la etiqueta y en el conjunto de datos. En este caso, la etiqueta consta del sentimiento, que es Positivo, Neutral o Negativo.

Como puede ver, el proceso es similar a usar el método de ajuste en el paquete Scikit-Learn. Sin embargo, ya sabemos que Zero-Shot no requería necesariamente un conjunto de datos para el entrenamiento. Por eso podemos proporcionar las etiquetas sin los datos de entrenamiento.

X, _ = get_classification_dataset()

clf = ZeroShotGPTClassifier()
clf.fit(None, ["positive", "negative", "neutral"])
labels = clf.predict(X)

Esto también podría extenderse en los casos de clasificación multietiqueta, que puedes ver en el siguiente código.

from skllm import MultiLabelZeroShotGPTClassifier
from skllm.datasets import get_multilabel_classification_dataset
X, _ = get_multilabel_classification_dataset()
candidate_labels = [
    "Quality",
    "Price",
    "Delivery",
    "Service",
    "Product Variety",
    "Customer Support",
    "Packaging",,
]
clf = MultiLabelZeroShotGPTClassifier(max_labels=4)
clf.fit(None, [candidate_labels])
labels = clf.predict(X)

Lo sorprendente de Scikit-LLM es que permite al usuario extender el poder de LLM al proceso típico de Scikit-Learn.

Scikit-LLM en el proceso de aprendizaje automático

En el siguiente ejemplo, mostraré cómo podemos iniciar Scikit-LLM como vectorizador y usar XGBoost como clasificador de modelo. También incluiríamos los pasos en el proceso del modelo.

Primero, cargaríamos los datos e iniciaríamos el codificador de etiquetas para transformar los datos de la etiqueta en un valor numérico.

from sklearn.preprocessing import LabelEncoder

X, y = get_classification_dataset()

le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)

A continuación, definiríamos una canalización para realizar la vectorización y el ajuste del modelo. Podemos hacerlo con el siguiente código.

from sklearn.pipeline import Pipeline
from xgboost import XGBClassifier
from skllm.preprocessing import GPTVectorizer

steps = [("GPT", GPTVectorizer()), ("Clf", XGBClassifier())]
clf = Pipeline(steps)

#Fitting the dataset
clf.fit(X_train, y_train_enc)

Por último, podemos realizar predicciones con el siguiente código.

pred_enc = clf.predict(X_test)
preds = le.inverse_transform(pred_enc)

Como podemos ver, podemos usar Scikit-LLM y XGBoost en el proceso de Scikit-Learn. Combinar todos los paquetes necesarios haría que nuestra predicción fuera aún más sólida.

Todavía hay varias tareas que puede realizar con Scikit-LLM, incluido el ajuste del modelo, que le sugiero que consulte la documentación para obtener más información. También puede utilizar el modelo de código abierto de GPT4ALL si necesario.

Scikit-LLM es un paquete de Python que potencia las tareas de análisis de datos de texto de Scikit-Learn con LLM. En este artículo, analizamos cómo usamos Scikit-LLM para la clasificación de texto y los combinamos en el proceso de aprendizaje automático.

Cornelio Yudha Wijaya es subgerente de ciencia de datos y escritor de datos. Mientras trabaja a tiempo completo en Allianz Indonesia, le encanta compartir consejos sobre Python y datos a través de las redes sociales y los medios de escritura.