Groq et LLM : Transformer le Texte en Données Tabulaires Structurées

LLM et Ingénierie des Caractéristiques : Une Nouvelle Approche

Les grands modèles de langage (LLM), bien connus pour leurs capacités conversationnelles, peuvent également être exploités pour des tâches complexes comme l'ingénierie des caractéristiques. En particulier, les modèles pré-entraînés de fournisseurs tels que Groq permettent de transformer des données textuelles non structurées en données tabulaires structurées. Ces données sont ensuite prêtes à être intégrées dans des modèles de machine learning prédictifs.

Configuration et Imports

Pour illustrer ce processus, il est nécessaire d'importer plusieurs bibliothèques, notamment pandas, scikit-learn, et la classe OpenAI. Cette dernière permet d'interagir avec divers fournisseurs et d'accéder à une large gamme de LLM via un client unique, y compris les modèles Llama de Groq.

import pandas as pd
import json
from pydantic import BaseModel, Field
from openai import OpenAI
from google.colab import userdata
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.preprocessing import StandardScaler

Pour utiliser ces modèles, il est crucial de configurer un client Groq avec une clé API. Cette clé doit être définie dans Google Colab via l'icône "Secrets" dans la barre latérale gauche. Il est nécessaire de s'inscrire sur le site de Groq pour obtenir cette clé, qui doit être nommée 'GROQ_API_KEY'.

groq_api_key = userdata.get('GROQ_API_KEY')
client = OpenAI(
    base_url="https://api.groq.com/openai/v1",
    api_key=groq_api_key
)

Création d'un Ensemble de Données Synthétique

Un ensemble de données synthétique est généré pour démontrer l'application pratique de cette technologie. Cet ensemble comprend des tickets de support client, combinant des descriptions textuelles avec des caractéristiques numériques structurées telles que l'âge du compte et le nombre de tickets précédents.

import random
data = []
for _ in range(100):
    cat = random.choice(categories)
    text = random.choice(templates[cat]).format(days=random.randint(1, 14))
    data.append({
        "text": text,
        "account_age_days": random.randint(1, 2000),
        "prior_tickets": random.choices([0, 1, 2, 3, 4, 5], weights=[40, 30, 15, 10, 3, 2])[0],
        "label": cat
    })

df = pd.DataFrame(data)

L'ensemble de données généré contient des tickets de support client, combinant des descriptions textuelles avec des caractéristiques numériques structurées telles que l'âge du compte et le nombre de tickets précédents, ainsi qu'une étiquette de classe couvrant plusieurs catégories de tickets. Ces étiquettes seront utilisées plus tard pour entraîner et évaluer un modèle de classification à la fin du processus.

### Extraction des Caractéristiques avec LLM

Les caractéristiques tabulaires à extraire du texte sont définies en fonction du domaine d'application. Par exemple, l'urgence et la frustration sont des indicateurs clés qui peuvent être extraits pour aider à classer les tickets de support client plus efficacement.

```python
class TicketFeatures(BaseModel):
    urgency_score: int = Field(description="Urgency of the ticket on a scale of 1 to 5")
    is_frustrated: int = Field(description="1 if the user expresses frustration, 0 otherwise")

Une fonction essentielle du processus utilise le LLM pour transformer le texte en un objet JSON correspondant au schéma défini, facilitant ainsi l'intégration des données textuelles dans des modèles de machine learning.

def extract_features(text: str) -> dict:
    time.sleep(2.5)
    schema_instructions = json.dumps(TicketFeatures.model_json_schema())
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[
            {
                "role": "system",
                "content": f"You are an extraction assistant. Output ONLY valid JSON matching this schema: {schema_instructions}"
            },
            {"role": "user", "content": text}
        ],
        response_format={"type": "json_object"},
        temperature=0.0
    )
    return json.loads(response.choices[0].message.content)

Entraînement et Évaluation du Modèle

Après l'extraction des caractéristiques, l'étape suivante consiste à entraîner un modèle de classification. Le modèle RandomForestClassifier de scikit-learn est utilisé ici pour démontrer comment les caractéristiques extraites peuvent améliorer la précision de la classification par rapport à l'utilisation du texte brut seul.

X = df.drop('label', axis=1)
y = df['label']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

predictions = model.predict(X_test_scaled)
print(classification_report(y_test, predictions))

Ce processus montre comment l'intégration de LLM dans l'ingénierie des caractéristiques peut transformer des données textuelles en informations exploitables, améliorant ainsi la performance des modèles de machine learning.