Ces 5 IA qui automatisent TOUT votre travail de data scientist

QU'EST-CE QU'UN WORKFLOW AGENTIQUE ?

Un workflow agentique est un enchaînement d'étapes où une intelligence artificielle prend des décisions et exécute des tâches à votre place. Imaginez un assistant qui analyse vos données, repère les problèmes, propose des solutions, et optimise votre modèle… sans que vous ayez à toucher à quoi que ce soit. Ces workflows fonctionnent comme des chaînes de montage : chaque agent a un rôle précis, et ensemble, ils transforment vos données brutes en un modèle prêt à l'emploi.

POURQUOI AUTOMATISER SON PIPELINE DATA SCIENCE ?

Traiter des données, c'est souvent répétitif et chronophage. Il faut vérifier les valeurs manquantes, transformer les colonnes, tester des features, ajuster des paramètres… Une erreur à chaque étape peut fausser tout le résultat. Avec ces agents IA, vous gagnez du temps, évitez les oublis, et obtenez des résultats plus fiables. En plus, ces Outils s'adaptent à n'importe quel jeu de données, du plus simple au plus complexe.

LES 5 OUTILS INDISPENSABLES POUR DÉMARRER

Avant de plonger dans les workflows, installez ces bibliothèques Python avec une seule commande :

pip install openai pandas numpy scipy scikit-learn lightgbm shap pydantic

Ces outils couvrent l'analyse exploratoire, l'ingénierie des features, l'optimisation des hyperparamètres et la détection des dérives. Vous aurez aussi besoin d'une clé API OpenAI pour faire fonctionner les agents.

1. L'AGENT D'EXPLORATION DE DONNÉES (EDA)

Le premier agent, eda_agent.py, analyse vos données et génère un rapport complet. Il repère les valeurs manquantes, les colonnes mal formatées, les distributions anormales, et propose des solutions. Voici comment il fonctionne :

Installation et configuration

Installez les dépendances nécessaires avec :

pip install openai pandas scipy

Pour exécuter l'agent, utilisez cette commande :

python eda_agent.py

Le code de l'agent

L'agent commence par créer un profil pour chaque colonne de votre jeu de données. Il calcule des statistiques comme le type de données, le taux de valeurs manquantes, ou l'asymétrie (skewness) des distributions. Par exemple, pour une colonne numérique, il mesure la moyenne, l'écart-type et l'asymétrie. Pour une colonne texte, il vérifie si elle contient des valeurs numériques mal codées.

import json
import pandas as pd
from scipy import stats
from openai import OpenAI
from dataclasses import dataclass

client = OpenAI()  # Utilise la variable d'environnement OPENAIAPIKEY

@dataclass
class ColumnIssue:
    column: str
    issuetype: str   # nullrate | skewness | dtype | high_correlation
    severity: str     # low | medium | high
    detail: str

def profile_dataset(df: pd.DataFrame) -> dict:
    """
    Génère des statistiques par colonne.
    En production, remplacez par ydata-profiling pour un rapport plus riche.
    """
    profile = {}
    for col in df.columns:
        col_stats = {
            "dtype":     str(df[col].dtype),
            "null_rate": df[col].isnull().mean(),
            "n_unique":  df[col].nunique(),
        }
        if pd.api.types.isnumericdtype(df[col]):
            col_stats["skewness"] = float(df[col].skew())
            col_stats["mean"]     = float(df[col].mean())
            col_stats["std"]      = float(df[col].std())
        elif df[col].dtype == "object":
            non_null = df[col].dropna()
            numericcoerced = pd.tonumeric(non_null, errors="coerce")
            colstats["looksnumeric"] = bool(len(nonnull) > 0 and numericcoerced.notna().mean() > 0.9)
        profile[col] = col_stats
    return profile

def flag_issues(profile: dict) -> list[ColumnIssue]:
    """
    Signale les problèmes de qualité des données à partir du profil des colonnes.
    Gravité : élevée = nécessite une attention immédiate, moyenne = à surveiller.
    """
    issues = []
    for col, stats_dict in profile.items():
        nullrate = statsdict.get("null_rate", 0.0)
        if null_rate > 0.15:
            issues.append(ColumnIssue(col, "null_rate", "high",
                                      f"{null_rate:.0%} des valeurs sont manquantes"))
        elif null_rate > 0.05:
            issues.append(ColumnIssue(col, "null_rate", "medium",
                                      f"{null_rate:.0%} des valeurs sont manquantes"))

        skewness = abs(stats_dict.get("skewness", 0.0))
        if skewness > 5.0:
            issues.append(ColumnIssue(col, "skewness", "high",
                                      f"Asymétrie extrême={skewness:.1f} -- envisagez une transformation logarithmique"))
        elif skewness > 2.0:
            issues.append(ColumnIssue(col, "skewness", "medium",
                                      f"Asymétrie modérée={skewness:.1f}"))

        # Les colonnes texte contenant uniquement des valeurs numériques sont probablement mal codées
        if statsdict["dtype"] == "object" and statsdict.get("looks_numeric", False):
            issues.append(ColumnIssue(col, "dtype", "medium",
                                      "Valeurs numériques stockées sous forme de chaînes de caractères"))

    return issues

Génération du rapport

Une fois les problèmes identifiés, l'agent envoie ces informations à un modèle de langage pour générer un rapport structuré. Ce rapport comprend :

• Un aperçu général du jeu de données
• Les problèmes prioritaires à résoudre avant de modéliser
• Les problèmes secondaires à surveiller
• Les prochaines étapes recommandées, classées par ordre de priorité

L'agent utilise le modèle gpt-4o-mini avec une température très basse (0.2) pour garantir des réponses cohérentes et structurées.

Exécution avec un exemple concret

Pour tester l'agent, exécutez ce code qui génère un jeu de données fictif de transactions commerciales :

# Exemple : données de transactions commerciales
import numpy as np
np.random.seed(42)
n = 5000
df = pd.DataFrame({
    "revenue":       np.random.exponential(scale=200, size=n),     # distribution très asymétrique
    "customer_age":  np.random.normal(40, 12, n),
    "createdat":    pd.daterange("2024-01-01", periods=n, freq="h").astype(str),
    "region_code":   np.random.choice(["US", "EU", "APAC", None], size=n, p=[0.5, 0.3, 0.1, 0.1]),
    "session_count": np.where(np.random.rand(n) < 0.2, None, np.random.randint(1, 50, n)),
})
report = run_eda_agent(df, "Données de transactions commerciales avec démographie client")
print(report)

Le rapport généré pourrait ressembler à ceci :

2. L'AGENT DE GÉNÉRATION DE FEATURES

Le deuxième agent, feature_agent.py, automatise la création de nouvelles features. Il analyse les colonnes existantes et propose des transformations qui pourraient améliorer les performances de votre modèle. Voici comment il fonctionne :

Installation et configuration

Installez les dépendances nécessaires avec :

pip install openai lightgbm shap scikit-learn pandas numpy

Pour exécuter l'agent, utilisez cette commande :

python feature_agent.py

Création de features candidates

L'agent commence par analyser les descriptions des colonnes et la variable cible. Il propose ensuite des features candidates sous forme de formules pandas. Par exemple, pour prédire l'attrition client, il pourrait suggérer :

• Le ratio entre le nombre de tickets de support et le nombre de sessions
• La racine carrée des dépenses mensuelles
• Une variable binaire indiquant si le client est dans une région spécifique

def generatefeaturecandidates(
    column_descriptions: dict[str, str],
    target: str,
    task_type: str = "classification",
    n_candidates: int = 10,
) -> list[dict]:
    """
    Demande au modèle de langage de proposer des features candidates à partir des descriptions de colonnes et de la tâche de prédiction.
    Retourne une liste de dictionnaires avec 'name', 'formula' et 'rationale'.
    """
    prompt = f"""Vous êtes un ingénieur senior en machine learning effectuant de l'ingénierie des features pour une tâche de {task_type}.

Variable cible : {target}

Colonnes disponibles :
{json.dumps(column_descriptions, indent=2)}

Proposez {n_candidates} features candidates susceptibles d'améliorer les performances du modèle.
Pour chaque feature, fournissez :
- name : un nom de feature en snake_case
- formula : comment la calculer à partir des colonnes disponibles (expression pandas)
- rationale : une phrase expliquant pourquoi cette feature pourrait aider

Retournez un objet JSON avec une seule clé "features" contenant un tableau d'objets,
chacun avec les clés : name, formula, rationale.
Retournez UNIQUEMENT un JSON valide -- aucune explication en dehors du JSON."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        responseformat={"type": "jsonobject"},
        temperature=0.4,
    )
    result = json.loads(response.choices[0].message.content)
    return result.get("features", result.get("candidates", []))

Évaluation et sélection des features

Une fois les features candidates générées, l'agent les ajoute au jeu de données et entraîne un modèle rapide (LightGBM) pour évaluer leur importance. Il garde uniquement les features dont l'importance dépasse un seuil (par défaut : 1%). Les features moins importantes sont éliminées.

L'agent utilise cette fonction pour évaluer les candidates :

def evaluateandprune(
    df: pd.DataFrame,
    candidate_features: list[dict],
    target_col: str,
    importance_threshold: float = 0.01,
) -> tuple[list[str], list[str], dict[str, float]]:
    """
    Ajoute les features candidates au dataframe, entraîne un modèle LightGBM de base,
    extrait les importances des features et élimine celles en dessous du seuil.

    Retourne (featuresgardées, featureséliminées, scores_importance)
    """
    feature_df = df.copy()
    added = []

    for candidate in candidate_features:
        try:
            # Évalue la formule -- en production, utilisez un bac à sable sécurisé
            featuredf[candidate["name"]] = featuredf.eval(candidate["formula"])
            added.append(candidate["name"])
        except Exception as e:
            # La formule a échoué -- ignore cette candidate
            print(f"  Ignorée '{candidate['name']}' : {e}")

    if not added:
        return [], [], {}

    X = feature_df[added].fillna(0)
    y = df[target_col]

    model = lgb.LGBMClassifier(nestimators=100, randomstate=42, verbose=-1)
    model.fit(X, y)

    importancescores = dict(zip(added, model.featureimportances / model.featureimportances_.sum()))

    kept   = [f for f in added if importancescores.get(f, 0) >= importancethreshold]
    pruned = [f for f in added if importance_scores.get(f, 0)  str:
    """Demande à l'agent d'expliquer ses décisions de sélection en langage clair."""
    prompt = f"""Vous examinez les résultats de sélection de features pour un pipeline de machine learning.

Features GARDÉES (au-dessus du seuil d'importance) :
{json.dumps({f: round(scores.get(f, 0), 4) for f in kept}, indent=2)}

Features ÉLIMINÉES (en dessous du seuil) :
{json.dumps({f: round(scores.get(f, 0), 4) for f in pruned}, indent=2)}

Rédigez un résumé de 3 à 5 phrases sur le résultat de la sélection.
Notez toute élimination surprenante ou feature d'importance inattendue.
Suggérer une feature supplémentaire à tester en fonction de celles qui ont survécu."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3,
    )
    return response.choices[0].message.content


if __name__ == "__main__":
    column_descriptions = {
        "dayssincelogin":    "Nombre de jours depuis la dernière connexion du client",
        "plan_tier":           "Niveau d'abonnement : basique, pro ou entreprise",
        "supporttickets90d": "Nombre de tickets de support ouverts dans les 90 derniers jours",
        "monthly_spend":       "Dépenses mensuelles moyennes du client en USD",
    }

    candidates = generatefeaturecandidates(
        columndescriptions, target="churned", tasktype="classification", n_candidates=10
    )

    # En production, chargez ici de vraies données clients
    np.random.seed(42)
    n = 3000
    df = pd.DataFrame({
        "dayssincelogin":    np.random.randint(0, 90, n),
        "plan_tier":           np.random.choice(["basic", "pro", "enterprise"], n),
        "supporttickets90d": np.random.poisson(1.5, n),
        "monthly_spend":       np.random.exponential(80, n),
        "churned":             np.random.binomial(1, 0.15, n),
    })

    kept, pruned, scores = evaluateandprune(df, candidates, target_col="churned")
    summary = explain_selection(kept, pruned, scores)
    print(summary)

3. L'AGENT D'OPTIMISATION DES HYPERPARAMÈTRES

Le troisième agent, hp_agent.py, automatise la recherche des meilleurs hyperparamètres pour votre modèle. Il entraîne plusieurs configurations et choisit celle qui donne les meilleurs résultats. Voici comment il fonctionne :

Installation et configuration

Installez les dépendances nécessaires avec :

pip install openai scikit-learn pydantic pandas numpy

Pour exécuter l'agent, utilisez cette commande :

python hp_agent.py

Validation des paramètres avec Pydantic

Avant même d'entraîner un modèle, l'agent valide les hyperparamètres avec Pydantic, une bibliothèque qui vérifie que les valeurs respectent les contraintes définies. Par exemple, le nombre d'estimateurs doit être entre 10 et 1000, et la profondeur maximale des arbres entre 1 et 50. Si un paramètre est invalide, l'entraînement est annulé avant même de commencer, ce qui évite de gaspiller du temps et des ressources.

from pydantic import BaseModel, Field, field_validator

class HyperparamConfig(BaseModel):
    n_estimators:      int   = Field(., ge=10, le=1000, description="Nombre d'arbres")
    max_depth:         int   = Field(., ge=1,  le=50,   description="Profondeur maximale des arbres")
    minsamplessplit: int   = Field(., ge=2,  le=50,   description="Nombre minimal d'échantillons pour diviser un nœud")
    max_features:      float = Field(., gt=0,  le=1.0,  description="Fraction des features utilisées pour chaque division")

Entraînement et évaluation des configurations

L'agent entraîne un modèle RandomForest avec les paramètres proposés et calcule deux métriques : l'AUC sur les données d'entraînement et l'AUC sur les données de validation (via une validation croisée à 5 plis). Il mesure aussi le temps d'entraînement pour chaque configuration.

Voici la fonction qui effectue l'entraînement :

def trainandevaluate(config: dict, X, y) -> TrialResult:
    """
    Entraîne un RandomForest avec la configuration donnée et retourne les métriques validées.
    C'est l'outil que l'agent appelle à chaque itération.
    """
    import time
    params = HyperparamConfig(**config)  # Valide avant l'entraînement
    clf = RandomForestClassifier(
        nestimators=params.nestimators,
        maxdepth=params.maxdepth,
        minsamplessplit=params.minsamplessplit,
        maxfeatures=params.maxfeatures,
        random_state=42,
        n_jobs=-1,
    )
    t0 = time.time()
    valscores = crossvalscore(clf, X, y, cv=5, scoring="rocauc")
    clf.fit(X, y)
    trainauc = rocaucscore(y, clf.predictproba(X)[:, 1])
    return TrialResult(
        iteration=0,
        config=config,
        valauc=round(float(valscores.mean()), 4),
        trainauc=round(float(trainauc), 4),
        traintimes=round(time.time() - t0, 2),
    )

Détection de convergence

L'agent arrête la recherche quand les scores AUC des 3 dernières itérations varient de moins de 0,005. Cela signifie que le modèle a atteint un plateau et que des itérations supplémentaires n'apporteront pas d'amélioration significative.

def detect_convergence(results: list[TrialResult], window: int = 3, tol: float = 0.005) -> bool:
    """Arrête quand les {window} derniers scores AUC varient de moins de {tol}."""
    if len(results)  dict:
    """
    Demande à l'agent de proposer la prochaine configuration d'hyperparamètres,
    en analysant l'historique complet des essais.
    """
    history_text = "\n".join(
        f"Essai {r.iteration} : config={r.config}, valAUC={r.valauc}, "
        f"écartsurapprentissage={r.overfitgap}, temps={r.traintimes}s"
        for r in trial_history
    )
    prompt = f"""Vous optimisez un classifieur RandomForest. Votre objectif est de maximiser l'AUC de validation.

Historique des essais :
{history_text}

Plages de paramètres :
- n_estimators : 10-1000
- max_depth : 1-50
- minsamplessplit : 2-50
- max_features : 0.1-1.0

Analysez la tendance. Identifiez quels paramètres semblent les plus influents.
Proposez la prochaine configuration à tester, en expliquant votre raisonnement en une phrase.

Retournez un objet JSON avec les clés : nestimators, maxdepth, minsamplessplit, max_features, reasoning"""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        responseformat={"type": "jsonobject"},
        temperature=0.3,
    )
    result = json.loads(response.choices[0].message.content)
    print(f"  Raisonnement de l'agent : {result.get('reasoning', '')}")
    return {k: v for k, v in result.items() if k .= "reasoning"}


def runhpagent(X, y, max_iterations: int = 15) -> TrialResult:
    """
    Exécute la boucle d'optimisation agentique des hyperparamètres.
    Commence avec un point de départ raisonnable, puis laisse l'agent guider la recherche.
    """
    # Point de départ raisonnable -- pas de démarrage aléatoire
    initialconfig = {"nestimators": 100, "maxdepth": 10, "minsamplessplit": 5, "maxfeatures": 0.5}
    results = []

    for i in range(max_iterations):
        config = initialconfig if i == 0 else proposenext_config(results)
        try:
            result = trainandevaluate(config, X, y)
        except Exception as e:
            print(f"  Essai {i+1} échoué : {e} -- ignoré")
            continue

        result.iteration = i + 1
        results.append(result)
        best = max(results, key=lambda r: r.val_auc)
        print(f"Essai {i+1:02d} : AUC={result.valauc:.4f} (meilleur={best.valauc:.4f})")

        if detect_convergence(results, window=3, tol=0.005):
            print(f"Convergence atteinte après {i+1} itérations.")
            break

    return max(results, key=lambda r: r.val_auc)


if __name__ == "__main__":
    X, y = makeclassification(nsamples=5000, nfeatures=20, ninformative=10, random_state=42)
    best = runhpagent(X, y, max_iterations=15)
    print(f"\nMeilleure configuration : {best.config}")
    print(f"Meilleure AUC de validation : {best.val_auc}")

4. L'AGENT DE DÉTECTION DE DÉRIVE

Le quatrième agent, drift_agent.py, surveille les dérives dans vos données. Il compare les nouvelles données avec un jeu de référence et alerte si une dérive significative est détectée. Voici comment il fonctionne :

Installation et configuration

Installez les dépendances nécessaires avec :

pip install openai pandas scipy numpy

Pour exécuter l'agent, utilisez cette commande :

python drift_agent.py

Calcul de l'indice de stabilité de la population (PSI)

L'agent utilise deux méthodes pour détecter les dérives :

• L'Indice de Stabilité de la Population (PSI) : mesure la différence entre la distribution des données de référence et celle des nouvelles données. Un PSI supérieur à 0,25 indique une dérive sévère.
• Le test de Kolmogorov-Smirnov (KS) : compare les distributions de deux échantillons et calcule une statistique et une valeur p. Une valeur p faible (inférieure à 0,05) indique une différence significative.

Voici la fonction qui calcule le PSI :

def compute_psi(baseline: np.ndarray, current: np.ndarray, buckets: int = 10) -> float:
    """
    Indice de Stabilité de la Population entre les distributions de référence et actuelle.
    PSI = somme((%actuelle - %référence) * ln(%actuelle / %référence))

    Valeurs : 0.25 dérive sévère
    """
    min_val      = min(baseline.min(), current.min())
    max_val      = max(baseline.max(), current.max())
    bucketwidth = (maxval - min_val) / buckets

    def bucket_freqs(data: np.ndarray) -> list[float]:
        counts = np.zeros(buckets)
        for v in data:
            idx = min(int((v - minval) / bucketwidth), buckets - 1)
            counts[idx] += 1
        freqs = counts / len(data)
        return [max(f, 1e-6) for f in freqs]   # Évite log(0)

    bfreq = bucketfreqs(baseline)
    cfreq = bucketfreqs(current)
    return round(sum((c - b) * math.log(c / b) for b, c in zip(bfreq, cfreq)), 4)

Classification des dérives

L'agent classe les dérives en trois catégories :

• stable : PSI inférieur à 0,10
• dérive légère : PSI entre 0,10 et 0,25
• dérive sévère : PSI supérieur à 0,25

Voici la fonction qui classe les dérives :

def classify_drift(psi: float) -> str:
    if psi  list[FeatureDrift]:
    """Calcule le PSI et le test KS pour chaque feature numérique."""
    from scipy.stats import ks_2samp
    results = []
    for col in numeric_cols:
        b = baseline_df[col].dropna().values
        c = current_df[col].dropna().values
        psi        = compute_psi(b, c)
        ksstat, kspvalue = ks_2samp(b, c)
        results.append(FeatureDrift(
            feature=col,
            psi=psi,
            ksstat=round(float(ksstat), 4),
            kspvalue=round(float(kspvalue), 6),
            severity=classify_drift(psi),
        ))
    return results

Génération du rapport de dérive

Une fois les dérives calculées, l'agent génère un rapport qui indique :

• Le niveau de sévérité de la dérive pour chaque feature
• Les actions à entreprendre en fonction de la sévérité

Voici la fonction qui génère ce rapport :

def runmonitoringagent(
    baseline_df: pd.DataFrame,
    current_df: pd.DataFrame,
    numeric_cols: list[str],
    modelname: str = "churnmodel_v3",
) -> str:
    """
    Exécute l'agent de surveillance.
    Il calcule les statistiques de dérive et décide de la réponse en fonction de la sévérité.
    """
    driftresults = computedriftstats(baselinedf, currentdf, numericcols)

    drift_summary = [
        {"feature": d.feature, "psi": d.psi, "kspvalue": d.kspvalue, "severity": d.severity}
        for d in drift_results
    ]

    severefeatures = [d.feature for d in driftresults if d.severity == "severe_drift"]
    mildfeatures   = [d.feature for d in driftresults if d.severity == "mild_drift"]

    prompt = f"""Vous êtes un agent de surveillance de modèle pour {model_name}.

Résultats de l'analyse de dérive :
{json.dumps(drift_summary, indent=2)}

Dérives sévères (PSI > 0.25) : {severe_features}
Dérives légères (PSI 0.10-0.25) : {mild_features}

En fonction de la sévérité, déterminez la réponse appropriée :
- STABLE : enregistrez un passage, aucune action nécessaire
- DÉRIVE LÉGÈRE : rédigez un message d'alerte pour l'équipe data science
- DÉRIVE SÉVÈRE : rédigez un message d'alerte ET déclenchez le pipeline de réentraînement

Rédigez votre réponse dans ce format :
NIVEAUDESÉVÉRITÉ :
ACTION :
MESSAGE : """

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1,  # Très bas -- c'est une prise de décision, pas une création
    )
    return response.choices[0].message.content


if __name__ == "__main__":
    np.random.seed(42)
    n = 2000

    # Jeu de référence : comportement normal de navigation e-commerce
    baseline = pd.DataFrame({
        "sessiondurations":    np.random.normal(180, 60, n),
        "pagespersession":     np.random.normal(4.2, 1.5, n),
        "cartaddrate":         np.clip(np.random.normal(0.12, 0.04, n), 0, 1),
    })

    # Données actuelles : un événement promotionnel modifie significativement toutes les features
    current = pd.DataFrame({
        "sessiondurations":    np.random.normal(310, 90, n),   # sessions beaucoup plus longues
        "pagespersession":     np.random.normal(6.8, 2.1, n),  # plus de pages consultées
        "cartaddrate":         np.clip(np.random.normal(0.31, 0.08, n), 0, 1),  # taux beaucoup plus élevé
    })

    result = runmonitoringagent(baseline, current, list(baseline.columns))
    print(result)

5. L'AGENT DE DÉPLOIEMENT ET DE SURVEILLANCE EN PRODUCTION

Le cinquième agent est un workflow complet qui enchaîne les quatre précédents. Il permet de déployer un modèle de bout en bout, de l'exploration des données à la surveillance en production. Voici comment l'utiliser :

Structure du workflow

Ce workflow combine les quatre agents précédents dans un pipeline cohérent :

1. L'agent EDA analyse les données et génère un rapport
2. L'agent de génération de features crée de nouvelles colonnes
3. L'agent d'optimisation des hyperparamètres trouve la meilleure configuration
4. L'agent de détection de dérive surveille les nouvelles données en production

Chaque agent peut être exécuté séparément ou enchaîné dans un script unique. L'avantage ? Vous n'avez plus à vous soucier des étapes manuelles : tout est automatisé et reproductible.

Exécution du pipeline complet

Pour exécuter le pipeline complet, créez un fichier principal qui appelle chaque agent dans l'ordre. Voici un exemple de structure :

# workflow_pipeline.py
import pandas as pd
from edaagent import runeda_agent
from featureagent import generatefeaturecandidates, evaluateand_prune
from hpagent import runhp_agent
from driftagent import runmonitoring_agent

# Étape 1 : Exploration des données
print("🔍 Étape 1/4 : Exploration des données")
df = pd.readcsv("votredataset.csv")
edareport = runeda_agent(df, "Description de votre jeu de données")
print(eda_report)

# Étape 2 : Génération de features
print("🔧 Étape 2/4 : Génération de features")
column_descriptions = {
    "col1": "Description de la colonne 1",
    "col2": "Description de la colonne 2",
}
candidates = generatefeaturecandidates(columndescriptions, target="votrecible")
keptfeatures, ,  = evaluateandprune(df, candidates, targetcol="votre_cible")
print(f"Features gardées : {kept_features}")

# Étape 3 : Optimisation des hyperparamètres
print("⚙️ Étape 3/4 : Optimisation des hyperparamètres")
X = df[kept_features]
y = df["votre_cible"]
bestconfig = runhp_agent(X, y)
print(f"Meilleure configuration : {best_config.config}")

# Étape 4 : Surveillance en production (à exécuter régulièrement)
print("📊 Étape 4/4 : Surveillance en production")
# Chargez vos nouvelles données et comparez-les au jeu de référence
newdata = pd.readcsv("nouvelles_donnees.csv")
driftreport = runmonitoringagent(baselinedf, newdata, numericcols=["col1", "col2"])
print(drift_report)

Avantages de ce workflow agentique

Ce pipeline automatisé offre plusieurs avantages :

• Reproductibilité : Chaque exécution donne les mêmes résultats, car les décisions sont prises par des algorithmes, pas par des humains.
• Gain de temps : Plus besoin de passer des heures à vérifier les données ou à ajuster manuellement les paramètres.
• Adaptabilité : Ces agents fonctionnent avec n'importe quel jeu de données, quel que soit son format ou sa taille.
• Maintenabilité : Si vos données changent, les agents s'adaptent automatiquement et alertent en cas de problème.

LIMITES ET PRÉCAUTIONS À PRENDRE

Ces agents IA ne sont pas magiques. Ils ont des limites qu'il faut connaître :

• Les agents dépendent de la qualité des données d'entrée. Si vos données sont biaisées ou incomplètes, les résultats seront biaisés.
• Les modèles de langage comme GPT-4o-mini peuvent faire des erreurs. Toujours vérifier les rapports générés avant de les utiliser en production.
• Ces outils consomment des ressources (API OpenAI, calculs). Assurez-vous d'avoir les moyens techniques et financiers pour les utiliser à grande échelle.
• Les agents ne remplacent pas votre expertise. Ils sont des assistants, pas des décideurs finaux.

COMMENT INTÉGRER CES AGENTS DANS VOTRE PROJET ?

Pour intégrer ces workflows dans votre projet, suivez ces étapes :

1. Installez les dépendances avec pip install.
2. Configurez votre clé API OpenAI dans la variable d'environnement OPENAIAPIKEY.
3. Adaptez les exemples de code à votre jeu de données (colonnes, variable cible, etc.).
4. Exécutez chaque agent séparément ou enchaînez-les dans un script unique.
5. Surveillez les rapports générés et ajustez les seuils si nécessaire.

Ces agents sont conçus pour être modifiables. Vous pouvez ajuster les seuils, les modèles de langage, ou les bibliothèques utilisées selon vos besoins.