De Texte à Tableaux : Ingénierie des Caractéristiques avec des LLM pour les Données Tabulaires

De Texte à Tableaux : Ingénierie des Caractéristiques avec des LLM pour les Données Tabulaires

Introduction

Les grands modèles de langage (LLM), bien qu'habituellement utilisés pour des interactions conversationnelles, peuvent également être utiles pour des tâches comme l'ingénierie des caractéristiques sur des ensembles de données complexes. En utilisant des LLM pré-entraînés de fournisseurs comme Groq (par exemple, des modèles de la famille Llama), il est possible de transformer des données non structurées, telles que du texte, en données tabulaires entièrement structurées, prêtes à alimenter des modèles de machine learning prédictifs.

Cet article vous guidera à travers le processus complet d'application de l'ingénierie des caractéristiques sur du texte structuré, le transformant en données tabulaires adaptées à un modèle de machine learning, à savoir un classificateur entraîné sur des caractéristiques créées à partir de texte à l'aide d'un LLM.

Configuration et Imports

Nous allons d'abord effectuer tous les imports nécessaires pour cet exemple pratique :

import pandas as pd
import json
from pydantic import BaseModel, Field
from [openai](/dossier/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

Notez qu'en plus des bibliothèques courantes pour le machine learning et le prétraitement des données comme scikit-learn, nous importons la classe OpenAI. Cela permet d'interagir avec divers fournisseurs et d'accéder à une large gamme de LLM via un seul client, y compris les modèles Llama via Groq.

Ensuite, nous configurons un client Groq pour accéder à un LLM pré-entraîné que nous pouvons appeler via API pour l'inférence pendant l'exécution :

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

Remarque importante : pour que le code ci-dessus fonctionne, vous devez définir une clé secrète API pour Groq. Dans Google Colab, vous pouvez le faire via l'icône "Secrets" dans la barre latérale gauche. Donnez à votre clé le nom 'GROQ_API_KEY', puis inscrivez-vous sur le site de Groq pour obtenir une clé réelle et collez-la dans le champ de valeur.

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

L'étape suivante consiste à générer un ensemble de données synthétique, partiellement aléatoire, à des fins d'illustration. Si vous avez votre propre ensemble de données textuelles, n'hésitez pas à adapter le code en conséquence.

import random
import time

random.seed(42)
categories = ["access", "inquiry", "software", "billing", "hardware"]
templates = {
    "access": [
        "I've been locked out of my account for {days} days and need urgent help!",
        "I can't log in, it keeps saying bad password.",
        "Reset my access credentials immediately.",
        "My 2FA isn't working, please help me get into my account."
    ],
    "inquiry": [
        "When will my new credit card arrive in the mail?",
        "Just checking on the status of my recent order.",
        "What are your business hours on weekends?",
        "Can I upgrade my current plan to the premium tier?"
    ],
    "software": [
        "The app keeps crashing every time I try to view my transaction history.",
        "Software bug: the submit button is greyed out.",
        "Pages are loading incredibly slowly since the last update.",
        "I'm getting a 500 Internal Server Error on the dashboard."
    ],
    "billing": [
        "I need a refund for the extra charges on my bill.",
        "Why was I billed twice this month?",
        "Please update my payment method, the old card expired.",
        "I didn't authorize this $49.99 transaction."
    ],
    "hardware": [
        "My hardware token is broken, I can't log in.",
        "The screen on my physical device is cracked.",
        "The card reader isn't scanning properly anymore.",
        "Battery drains in 10 minutes, I need a replacement unit."
    ]
}

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

Nous allons maintenant définir les caractéristiques tabulaires que nous souhaitons extraire du texte. Le choix des caractéristiques dépend du domaine et est entièrement personnalisable, mais vous utiliserez le LLM plus tard pour extraire ces champs dans un format structuré et cohérent :

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")

Par exemple, l'urgence et la frustration sont souvent corrélées à des types de tickets spécifiques (par exemple, les verrouillages d'accès et les pannes ont tendance à être plus urgents et émotionnellement chargés que les demandes générales), donc ces signaux peuvent aider un classificateur en aval à séparer les catégories plus efficacement que du texte brut seul.

La fonction suivante est un élément clé du processus, car elle encapsule l'intégration du LLM nécessaire pour transformer le texte d'un ticket en un objet JSON qui correspond à notre schéma :

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)