Cette IA qui choisit les meilleurs modèles pour toi : comment ça marche vraiment ?

UNE NOUVELLE FAÇON DE CONSTRUIRE LES IA : LE MÉLANGE ENTRE FLUX PRÉDÉFINI ET AGENT AUTONOME

Quand on crée une application d'intelligence artificielle, on doit choisir entre deux grandes méthodes : le flux prédéfini et l'agent autonome.

Le flux prédéfini, c'est comme une recette de cuisine : on sait exactement quelle étape suivre et dans quel ordre. Parfait quand on connaît la solution. Mais parfois, la meilleure approche dépend des résultats qu'on obtient en cours de route. Dans ce cas, il faut laisser l'IA choisir elle-même la prochaine étape.

L'agent autonome, lui, fonctionne comme un explorateur : il part d'un objectif et choisit ses Outils au fur et à mesure. Plus flexible, mais moins prévisible. Alors pourquoi choisir une seule méthode pour toute l'application ?

Prenons un exemple concret : une IA qui aide à choisir les meilleurs modèles de machine learning pour un problème de classification. Voici comment ça marche.

TROIS ÉTAPES POUR UN SYSTÈME PARFAIT : PRÉPARATION, EXPLORATION ET RAPPORT

Notre application suit trois étapes bien précises :

• Préparation : transformer la demande en un brief clair avec l'objectif, la métrique d'évaluation et le nombre de tests à faire.
• Exploration : tester différents modèles de machine learning et choisir les meilleurs.
• Rapport : résumer les résultats pour que l'utilisateur comprenne ce qui a été fait.

Les deux premières étapes utilisent l'IA, mais pas de la même façon. La préparation et le rapport suivent un flux fixe : une seule instruction suffit. L'exploration, elle, a besoin d'un agent qui s'adapte en fonction des résultats obtenus.

ÉTAPE 1 : TRANSFORMER LA DEMANDE EN BRIEF EXPÉRIMENTAL

Première étape : comprendre ce que l'utilisateur veut faire. Par exemple : « Construire un classifieur pour des images de chiffres manuscrits. Utiliser la validation croisée pour comparer les modèles. Recommander une configuration solide. »

L'IA transforme cette demande en un brief expérimental qui contient :

• L'objectif : « Construire et évaluer un classifieur pour des images de chiffres manuscrits. »
• La métrique d'évaluation : « accuracy » (précision).
• Le nombre de tests : 5 (validation croisée à 5 plis).

Pour faire ça, l'IA utilise un schéma de sortie structuré : un modèle qui garantit que la réponse aura toujours la même forme, comme un formulaire à remplir. Ici, c'est une classe Python qui définit les champs obligatoires.

LE CODE QUI FAIT TOUT ÇA : PRENDRE LA DEMANDE ET CRÉER LE BRIEF

Voici comment l'IA prépare le brief expérimental. D'abord, on définit la structure de la réponse :

from pydantic import BaseModel

class ExperimentSpec(BaseModel):
    objective: str
    primary_metric: str = Field(
        description="Un nom de métrique valide pour scikit-learn"
    )
    cv_folds: int

Ensuite, on prépare l'instruction pour l'IA :

PREPARER_INSTRUCTION = """
Créer un brief expérimental à partir de la demande de modélisation et du résumé du jeu de données.
"""

Puis, on construit le texte envoyé à l'IA en combinant la demande et le résumé des données :

def buildpreparerprompt(request: str, dataset_summary: dict) -> str:
    return f"""Demande de modélisation :
{request}

Résumé du jeu de données :
{json.dumps(dataset_summary, indent=2)}"""

Enfin, on appelle l'API de l'IA pour obtenir le brief :

from openai import AzureOpenAI

llm_client = AzureOpenAI(
    apikey=os.environ["OPENAIAPI_KEY"],
    azureendpoint=os.environ["OPENAIAPI_BASE"],
    apiversion=os.environ["OPENAIAPI_VERSION"],
)

def prepare_experiment(
    request: str,
    dataset_summary: dict,
) -> ExperimentSpec:
    response = llm_client.responses.parse(
        model="gpt-5.4",
        reasoning={"effort": "medium"},
        instructions=PREPARER_INSTRUCTION,
        input=buildpreparerprompt(request, dataset_summary),
        text_format=ExperimentSpec,
    )

    return response.output_parsed

Résultat : un brief expérimental prêt à être utilisé pour la suite.

ÉTAPE 2 : L'AGENT QUI CHOISIT LES MEILLEURS MODÈLES AUTOMATIQUEMENT

Deuxième étape : tester différents modèles de machine learning pour trouver la meilleure configuration. Mais attention, l'IA ne peut pas deviner à l'avance quels modèles seront les plus performants. Elle doit essayer, observer les résultats, et ajuster sa stratégie en conséquence.

C'est là qu'intervient l'agent autonome. Contrairement à une simple instruction, l'agent peut :

• Choisir quel modèle tester (parmi une liste de classifieurs disponibles).
• Définir les hyperparamètres à utiliser.
• Lancer les tests et analyser les résultats.
• Décider de la prochaine configuration à tester en fonction des scores obtenus.

Pour que l'agent fonctionne, on lui donne accès à un outil : une fonction qui évalue un modèle avec une configuration donnée. Par exemple, tester un SVC (Support Vector Classifier) avec des paramètres spécifiques.

LE CODE DE L'AGENT : COMMENT IL TESTE LES MODÈLES

D'abord, on configure le client pour l'agent :

from openai import AsyncAzureOpenAI
from agents import OpenAIResponsesModel

agent_client = AsyncAzureOpenAI(
    apikey=os.environ["OPENAIAPI_KEY"],
    azureendpoint=os.environ["OPENAIAPI_BASE"],
    apiversion=os.environ["OPENAIAPI_VERSION"],
)

agent_model = OpenAIResponsesModel(
    model="gpt-5.4",
    openaiclient=agentclient,
)

Ensuite, on définit la structure de la réponse de l'agent : quel modèle il a choisi, avec quels paramètres, et pourquoi.

from pydantic import BaseModel

class AgentRecommendation(BaseModel):
    model_name: str
    hyperparameters_json: str
    rationale: str

AGENT_INSTRUCTION = """
Trouver un classifieur performant pour le problème fourni.
"""

def buildagentprompt(
    experiment_spec: ExperimentSpec,
    dataset_summary: dict,
) -> str:
    return f"""Brief expérimental :
{experimentspec.modeldump_json(indent=2)}

Résumé du jeu de données :
{json.dumps(dataset_summary, indent=2)}"""

Puis, on crée l'outil que l'agent peut utiliser pour tester un modèle :

import json
from agents import function_tool
from sklearn.modelselection import crossval_score
from sklearn.utils import all_estimators

def buildexperimenttool(
    X,
    y,
    experiment_spec,
    trial_history,
):
    classifiers = dict(
        allestimators(typefilter="classifier")
    )

    @function_tool
    def run_experiment(
        model_name: str,
        hyperparameters_json: str,
    ) -> str:
        """Évaluer une configuration de classifieur scikit-learn."""
        parameters = json.loads(hyperparameters_json)
        classifier = classifiers[model_name](**parameters)

        scores = crossvalscore(
            classifier,
            X,
            y,
            cv=experimentspec.cvfolds,
            scoring=experimentspec.primarymetric,
        )

        result = {
            "modelname": modelname,
            "hyperparameters": parameters,
            "mean_score": round(float(scores.mean()), 4),
        }

        trial_history.append(result)
        return json.dumps(result)

    return run_experiment

Enfin, on configure l'agent avec ses instructions, ses outils et ses paramètres :

# pip install openai-agents
from agents import Agent, ModelSettings, Runner

async def explore_configurations(
    X,
    y,
    experiment_spec,
    dataset_summary,
):
    trial_history = []

    runexperiment = buildexperiment_tool(
        X,
        y,
        experiment_spec,
        trial_history,
    )

    agent = Agent(
        name="Agent de sélection de modèle",
        instructions=AGENT_INSTRUCTION,
        model=agent_model,
        model_settings=ModelSettings(
            reasoning={"effort": "medium"},
            paralleltoolcalls=True,
        ),
        tools=[run_experiment],
        output_type=AgentRecommendation,
    )

    result = await Runner.run(
        agent,
        buildagentprompt(
            experiment_spec,
            dataset_summary,
        ),
        max_turns=10,
    )

    return result.finaloutput, trialhistory

L'option paralleltoolcalls=True permet à l'agent de tester plusieurs configurations en même temps, comme un chef qui prépare plusieurs plats en parallèle.

CE QUE L'AGENT A TROUVÉ : LES MEILLEURS MODÈLES POUR CLASSIFIER DES CHIFFRES

Pour tester notre système, on utilise un jeu de données classique : les chiffres manuscrits de scikit-learn. Ce jeu contient 1797 images de chiffres (0 à 9), chacune décrite par 64 caractéristiques (pixels).

L'agent teste plusieurs modèles de machine learning et retient les meilleurs. Voici les résultats des 5 premiers tests :

[
    {
        "model_name": "LogisticRegression",
        "hyperparameters": {
            "max_iter": 1000
        },
        "mean_score": 0.9132
    },
    {
        "model_name": "RandomForestClassifier",
        "hyperparameters": {
            "n_estimators": 100,
            "max_depth": null
        },
        "mean_score": 0.9382
    },
    {
        "model_name": "SVC",
        "hyperparameters": {
            "C": 1,
            "kernel": "rbf",
            "gamma": "scale"
        },
        "mean_score": 0.9638
    },
    {
        "model_name": "KNeighborsClassifier",
        "hyperparameters": {
            "n_neighbors": 3
        },
        "mean_score": 0.9661
    },
    {
        "model_name": "SVC",
        "hyperparameters": {
            "C": 10,
            "kernel": "rbf",
            "gamma": "scale"
        },
        "mean_score": 0.975
    }
]

On voit que le SVC (Support Vector Classifier) avec les paramètres C=10, kernel="rbf" et gamma="scale" obtient le meilleur score : 97,5 % de précision. L'agent a donc recommandé ce modèle.

ÉTAPE 3 : GÉNÉRER UN RAPPORT CLAR ET STRUCTURÉ

Dernière étape : transformer les résultats en un rapport compréhensible. Ici, pas besoin d'agent : c'est une tâche simple et répétitive. L'IA résume les informations clés :

• Quel modèle a été choisi ?
• Quels paramètres ont été utilisés ?
• Quel score a été obtenu ?
• Pourquoi ce modèle est-il le meilleur ?

Pour cela, on utilise à nouveau un schéma de sortie structuré :

from pydantic import BaseModel

class ModelSelectionReport(BaseModel):
    selected_model: str
    selected_hyperparameters: str
    meancvscore: float
    summary: str

Puis, on prépare l'instruction pour l'IA :

REPORTER_INSTRUCTION = """
Résumer l'exécution terminée de la sélection de modèle.
"""

def buildreporterprompt(
    experiment_spec: ExperimentSpec,
    trial_history: list[dict],
    agent_recommendation: AgentRecommendation,
) -> str:
    return f"""Brief expérimental :
{experimentspec.modeldump_json(indent=2)}

Essais terminés :
{json.dumps(trial_history, indent=2)}

Recommandation de l'agent :
{agentrecommendation.modeldump_json(indent=2)}"""

Enfin, on appelle l'API pour générer le rapport :

def summarize_run(
    experiment_spec: ExperimentSpec,
    trial_history: list[dict],
    agent_recommendation: AgentRecommendation,
) -> ModelSelectionReport:
    response = llm_client.responses.parse(
        model="gpt-5.4",
        reasoning={"effort": "medium"},
        instructions=REPORTER_INSTRUCTION,
        input=buildreporterprompt(
            experiment_spec,
            trial_history,
            agent_recommendation,
        ),
        text_format=ModelSelectionReport,
    )

    return response.output_parsed

Résultat : un rapport clair et structuré, prêt à être utilisé.

LE RAPPORT FINAL : UN MODÈLE À 97,5 % DE PRÉCISION RECOMMANDÉ

Voici le rapport généré par l'IA :

{
    "selected_model": "SVC",
    "selected_hyperparameters": '{"C": 10, "kernel": "rbf", "gamma": "scale"}',
    "meancvscore": 0.975,
    "summary": "La configuration SVC a obtenu le meilleur score de validation croisée parmi les candidats testés et est recommandée comme classifieur final."
}

QUAND UTILISER CE MODÈLE HYBRIDE ?

Ce système hybride (flux prédéfini + agent autonome) est particulièrement utile quand :

• Votre application a des étapes claires, mais certaines nécessitent une adaptation en temps réel.
• Vous voulez garder le contrôle sur le déroulement global, mais laisser l'IA prendre des décisions locales.
• Vous avez besoin de résultats reproductibles, mais aussi de flexibilité pour explorer différentes solutions.

Si une étape a une opération connue et répétitive, utilisez un appel d'IA structuré. Si une étape a un objectif clair mais que la prochaine action dépend des résultats obtenus, utilisez un agent.

Dans notre exemple, la préparation et le rapport sont des étapes fixes, tandis que l'exploration est gérée par un agent. Résultat : une application à la fois puissante et compréhensible.

POURQUOI CE SYSTÈME VA TOUT CHANGER POUR LES DATA SCIENTISTS

Ce modèle hybride change la donne pour les data scientists et les développeurs. Avant, il fallait :

• Comprendre en profondeur les modèles de machine learning.
• Savoir configurer les hyperparamètres manuellement.
• Passer des heures à tester et comparer les résultats.

Avec ce système, l'IA fait le gros du travail : elle teste les modèles, analyse les résultats et recommande la meilleure solution. Le data scientist peut se concentrer sur l'interprétation des résultats et l'amélioration du modèle final.

Bien sûr, l'IA ne remplace pas totalement un expert. Mais elle automatise les tâches répétitives et permet de gagner un temps précieux. Dans notre exemple, l'agent a testé 19 configurations différentes en quelques minutes, alors qu'un humain aurait mis des heures, voire des jours.

LES LIMITES À CONNAÎTRE

Ce système n'est pas parfait. Voici quelques limites à garder en tête :

• Coût : chaque appel à l'API de l'IA a un coût. Tester 20 modèles peut vite devenir cher.
• Transparence : l'agent prend des décisions, mais il est parfois difficile de comprendre pourquoi il a choisi un modèle plutôt qu'un autre.
• Biais : si les données d'entraînement sont biaisées, les résultats le seront aussi. L'IA ne fait que refléter les données qu'on lui donne.
• Complexité : mettre en place ce système demande des compétences en programmation et en machine learning.

Malgré ces limites, le système hybride reste une avancée majeure pour automatiser la sélection de modèles.

COMMENT L'UTILISER DANS VOS PROJETS

Si vous voulez tester ce système dans vos propres projets, voici les étapes à suivre :

1. Préparer vos données : assurez-vous que votre jeu de données est propre et bien structuré.
2. Définir l'objectif : quelle métrique voulez-vous optimiser ? Précision, rappel, F1-score ?
3. Configurer l'agent : donnez-lui accès aux outils nécessaires (classifieurs, fonctions d'évaluation).
4. Lancer le processus : laissez l'agent explorer les configurations possibles.
5. Analyser les résultats : utilisez le rapport généré pour choisir le meilleur modèle.

Avec un peu de code et une bonne configuration, vous pouvez automatiser une grande partie du travail de sélection de modèles.

LE FUTUR : VERS DES AGENTS DE MACHINE LEARNING ENCORE PLUS PUISSANTS

Ce système n'est qu'un début. Les agents de machine learning vont devenir de plus en plus performants. Dans un futur proche, ils pourront :

• Tester automatiquement des milliers de modèles en parallèle.
• Adapter les hyperparamètres en temps réel, sans intervention humaine.
• Combiner plusieurs techniques d'apprentissage pour résoudre des problèmes complexes.

Les data scientists de demain ne passeront plus leur temps à configurer des modèles manuellement. Ils utiliseront des agents intelligents pour automatiser les tâches répétitives et se concentrer sur l'innovation.

Ce système hybride est une première étape vers cette nouvelle ère. Avec un peu de code et beaucoup d'imagination, les possibilités sont infinies.

EN RÉSUMÉ : CE QU'IL FAUT RETENIR

Ce système hybride (flux prédéfini + agent autonome) permet de :

• Automatiser la sélection de modèles de machine learning.
• Garder le contrôle sur le déroulement global de l'application.
• Laisser l'IA prendre des décisions locales en fonction des résultats obtenus.

Dans notre exemple, l'agent a testé 19 configurations différentes et recommandé un SVC avec un score de 97,5 % de précision. Tout cela en quelques minutes, sans intervention humaine.

Ce système change la façon dont on construit les applications d'IA. Plus besoin de tout faire manuellement : l'IA peut prendre en charge les tâches répétitives, tandis que l'humain se concentre sur l'interprétation et l'amélioration.

Alors, prêt à automatiser vos sélections de modèles ?