img_header_blog

    Un premier retour d’expérience sur AutoML

    [fa icon="calendar"] 28/09/20 10:34 / par Idriss BRAHIMI

    2020-09-25-Auto ML

    L’AutoML (ou en français, « le machine learning automatisé ») permet l’assistance et l’automatisation du processus de création d’un modèle de Machine Learning.

    A l’instar des data scientists, de telles solutions sont capables d’élaborer des modèles mathématiques complexes et de développer ces modèles jusqu’à l’implémentation en production.

    Bref, l’AutoML aide à démocratiser le machine learning !

     

    Ainsi, des solutions telles que DataRobot, H2O.ai et AutoML de Google Cloud Plateform atteignent un public de plus en plus large. Et, le Machine Learning devient enfin accessible à tous.

     

    Avant de partager avec vous un cas pratique développé sur MLBox, cet article va tenter de répondre à un certain nombre de questions. Qu’est-ce exactement que le Machine Learning automatisé ? Pourquoi les entreprises se tournent-elles de plus en plus vers ce type de solutions ? L’AutoML va-t-il remplacer le métier de data scientist ? Quelles sont les solutions Auto ML présentent sur le marché ?

     

    Avantages et inconvénients d’AutoML ?

     

    Avantages

    Inconvénients

    ·  Possibilité pour une entreprise de supprimer l’expertise d’un data scientist.

    ·  Réduction importante du coût global du projet

    ·  Effet boîte noire du modèle algorithmique final. (L’utilisateur dispose de très peu d’informations pour comprendre les prédictions et le fonctionnement du modèle final).

    ·  Coût de développement de l’algorithme réduit

    ·  Solutions d’AutoML simples à utiliser

    ·  Performances généralement bonnes mais non optimales

    ·  Mise en production simplifiée (parce les solutions d’AutoML assurent généralement l'hébergement du modèle et le stockage des données)

    ·  Solutions AutoML non adaptées à des données ou à des problématiques métiers complexes

     

    En conclusion, si l’usage d’AutoML paraît alléchant au premier abord mais ce n’est pas un outil à recommander systématiquement pour résoudre un problème avec vos données.

     

    Étapes clés du processus de Machine Learning :

     

    La construction d’un modèle de Machine Learning requiert de nombreuses étapes :

     

    • Très schématiquement, le data scientist doit d’abord comprendre le problème métier et business qu’il doit résoudre avec les données dont il dispose (étape 1 du schéma ci-dessous). Il s’agit d’auditer les données/flux d’entrée et d’échanger avec les différents acteurs clés du projet pour comprendre l’enjeu global du projet.
    • Puis, les données sont normalisées et intégrées dans un modèle de données pour pourvoir ensuite être exploitées. C’est la phase de data intégration (étape 2).
    • La phase de data preparation (étape 3 du schéma ci-dessous) est une partie importante du travail de préparation des données par le data scientist. Cette étape inclut le nettoyage et la transformation des données, l’imputation des données manquantes ou encore la réduction des dimensions... Or, Auto ML effectue partiellement cette tâche.

    img1-4

    Figure 1 : Etapes clés d’un projet de machine learning

     

    • On parle de feature engineering (étape 4) pour désigner l’action de créer les meilleures variables d’entrée pour notre modèle de Machine Learning. AutoML est capable d’effectuer partiellement cette tâche.
    • L’étape d’entraînement du modèle (étape 5) correspond à la phase d’apprentissage de l’algorithme qui cherche à trouver le meilleur modèle à partir des données.

    Auto ML peut trouver mathématiquement les meilleurs paramètres ainsi qu’un algorithme efficace sans l’intervention d’un expert en data science.

    • Les étapes 6 et 7 du schéma ci-dessus permettent de valider que le modèle retenu est cohérent et que sa performance est optimale. AutoML est capable d’être autonome sur la tâche d’évaluation du modèle. Par contre, si AutoML trouve généralement des modèles performants, ces modèles sont rarement optimaux.
    • Enfin, le déploiement du modèle (étape 8) correspond à la phase d’industrialisation. Il s’agit de livrer le modèle à toute l’entreprise.

    Auto ML propose un déploiement rapide et simple du fait que les solutions d’AutoML assurent généralement l'hébergement du modèle et le stockage des données.

     

    En conclusion, il y a 4 étapes (parmi 9) qu’AutoML est capable d’automatiser :

    • la phase de data preparation,
    • l’étape de feature engineering,
    • l’apprentissage du modèle,
    • et enfin, l’étape de déploiement du modèle.

     

    L’AutoML ne risque pas de remplacer le métier de data scientist. C’est d’abord un outil d’assistance qui permet de gagner beaucoup de temps.

    En effet, l’utilisation d’AutoML (Google Cloud Plateform) pour la mise en œuvre d’un usecase de churn client m’a permis de me rendre compte que ce type de solution supprime bon nombre de tâches répétitives et fastidieuses.

    Pour ce qui est du travail de feature engineering, les solutions AutoML sont loin d’être satisfaisantes et nous sommes encore loin de la créativité humaine. Et, si c’est uniquement AutoML qui prend la main sur cette tâche, les résultats du modèle ne seront pas bons.

    En effet, les experts de la data ont une réelle plus-value dans la phase de data featuring en modélisant et en construisant des variables business, avec un fort impact métier.

     

    Autre information : la majeure partie des problèmes résolus par Auto ML sont des problèmes en apprentissage supervisé. De ce fait, à l’heure actuelle, beaucoup de méthodes d’apprentissage ne peuvent pas utiliser AutoML comme par exemple, les méthodes de reinforcement learning.

     

    Les solutions AutoML les plus connues

     

    Il existe actuellement un grand nombre de solutions AutoML sur le marché. 

    Nous allons en présenter trois :

    • Google Cloud AutoML : Un des services managés de Machine Learning de Google Cloud Plateform créé en Janvier 2018?
    • DataRobot : Créée en 2012, la plateforme permet de démocratiser la science des données et d’automatiser toute la chaîne data depuis l’intégration des données jusqu’à la phase de déploiement des modèles. DataRobot s’alimente des derniers algorithmes open sources connus pour améliorer les performances de son IA (Intelligence artificielle),
    • H20.ai : Créée en 2011, H20.ai est une plateforme open source de Machine Learning avec de fortes possibilités en AutoML learning.

     

    Le tableau ci-dessous donne quelques exemples de cas d’usage réalisés par AutoML.

     

     

    Entreprise

    Outil AutoML

    Industrie

    Cas d’usage

    Résultats

    Paypal

    H20.ai

    Service Finance

    Détection de fraude

    ▪ Amélioration de la prédiction de 89% à 94.7%

    ▪ Réduction du temps d’entraînement du modèle

    Vision Banco

    H2O.ai

    Banque

    Risque de crédits

    ▪ Diminution du temps de création des modèles : de 6 mois à moins d’une semaine

    ▪ Augmentation de la précision des modèles

    Avant

    DataRobot

    Finance

    Décision de prêts

    ▪ Réduction du temps

    ▪ Plus précis pour identifier les risques

    Domestic & General

    DataRobot

    Assurance

    Expérience client

    ▪ Augmentation du nombre de clients de 40 000 à 300 000

    Imagia

    Google cloud AutoML

    Santé

    R&D

    ▪ Réduction du temps des processus de test de 16 à 1 heure

    California Design Den

    Google cloud AutoML

    Retail

    E-Commerce

    ▪ 50% de réduction des reports d’inventaires

    Figure 2 : Exemples de cas d’usage selon différents outils AutoML (https://research.aimultiple.com/automl-case-studies)

     

    Ces différents cas d’usage montrent la diversité des applications sur lesquelles ces solutions AutoML sont efficaces.

     

    Dans le tableau qui suit, sur la base de nos retours d’expériences, nous avons comparé les différentes solutions selon leurs capacités à automatiser certaines tâches d’un projet de Machine Learning.

     

     

    Feature Engineering

    Benchmarking des modèles

    Optimisation des hyperparamètres

    Mise en production

    DataRobot

    =

    ++

    +

    =

    Google Cloud AutoML

    ++

    +++

    ++

    +++

    H20 ai

    ++

    =

    =

    =

    Figure 3 : Comparatif de 3 solutions AutoML

     

    Exemple pratique développé à partir du framework open source MLBox

     

    Nous vous proposons de rentrer dans les détails techniques avec le framework AutoML de MLBox et quelques lignes de code écrits en Python.

    Si nous avons choisi l’outil MLBox (et non pas l’un des 3 frameworks vus auparavant), c’est parce que MLBox est gratuit et qu’il reste simple à installer.

     

     

    Prédiction du cancer du sein

    Nous allons utiliser la base de données load_breast_cancer qui contient les descriptions de tumeurs avec une étiquette précisant si la tumeur est maligne ou bénigne pour 569 individus.

    La base de données contient 569 individus décrits à l’aide de 30 variables d’entrées.

     

    Ces données permettent de résoudre un problème de classification, c’est-à-dire un problème du type : quelles sont les variables d’entrée qui permettent de prédire si un individu est atteint du cancer (statut : malignité) ou non (statut : bénignité) ?

    Ici, le but n’est pas de montrer les performances de MLBox avec des données compliquées et massives ; il s’agit de comprendre les concepts de base d’un framework AutoML.

     

     

    Chargement des librairies

    D’abord, nous importons la librairie MLBox, le dataset load_breast_cancer et toutes les librairies qui permettent de faire du Machine Learning.

     

    from mlbox.preprocessing import Reader

    from mlbox.optimisation import Optimiser

    from mlbox.prediction import Predictor

    import mlbox

    import pandas as pd

    from sklearn.datasets import load_breast_cancer

    from sklearn.model_selection import train_test_split

    from sklearn.metrics import accuracy_score as acc

    from sklearn.metrics import fbeta_score, make_scorer, roc_auc_score, roc_curve, auc, classification_report, confusion_matrix

    from sklearn.metrics import precision_score, recall_score

    from sklearn.metrics import plot_confusion_matrix, plot_precision_recall_curve, plot_roc_curve, precision_recall_curve, auc

    from sklearn.metrics import average_precision_score

    from sklearn import metrics

     

     

    Chargement de la base de données

    Nous chargeons les données et effectuons une séparation entre les données d’entraînement (utilisées lors de la phase d’apprentissage du modèle de Machine Learning) et les données de test (qui permettent d’évaluer la performance du modèle retenu).

     

    Nous procédons également à une distinction entre la variable cible (le statut du cancer) et l’ensemble des autres variables d’entrée à partir desquelles nous allons baser notre apprentissage.

     

    data = load_breast_cancer()

    df = pd.DataFrame(data.data, columns=data.feature_names)

    df['target'] = data.target

    df.target = 1 - df.target

    X = df.drop('target', axis=1)

    y = df['target']

    RS = 124 # random seed

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=RS)

     

    Data preparation

    Nous allons ensuite concaténer (ici, regrouper horizontalement) la variable cible (y_train) et l’ensemble des données d’entrée (X_train) de la base d’apprentissage uniquement.

     

    trainMlBox = pd.concat([X_train, y_train], axis=1, sort=False)

     

    Export vers csv

    MLBox a besoin en entrée de deux fichiers au format csv.

    Le premier permet l’apprentissage du modèle (variables d’entrée et variables cible).

    Le second csv correspond aux données de test (X_test) qui permettent d’évaluer la performance des résultats.

     

    file_trainMLBox = "C:\\Users\\user_name\\Documents\\Input\\trainMlBox.csv"

    file_X_test = "C:\\Users\\user_name\\Documents\\Input\\testMlBox.csv"

    trainMlBox.to_csv(file_trainMLBox, index=False)

    X_test.to_csv(file_X_test, index=False)

     

    Lecture MLBox

    Dans la fonction Reader, le paramètre to_path est important. Il permet d’insérer dans un répertoire spécifique un fichier encoder. Nous utiliserons le même répertoire durant tout l’exemple !

    A ce stade, MLBox vérifie le nombre de variables communes entre les phases d’entraînement et les phases de test.

    MLBox vérifie également s’il existe des valeurs manquantes dans les données, la nature des variables (qualitatives/quantitatives), …

    %%time

    s = ","

    repertoire_testMLBox = "C:\\Users\\user_name\\Documents\\testMLBox"

    r = Reader(s, to_path = repertoire_testMLBox)

    paths = [file_trainMLBox, file_X_test]

    variable_cible = "target"

    data = r.train_test_split(paths,variable_cible)

     

    img2-3

     

    Recherche du meilleur modèle et optimisation

    Cette étape permet d’avoir quelques clés pour une meilleure compréhension de la manière dont MLBox recherche et optimise son modèle.

    Nous pouvons ajouter les hyperparamètres (paramètres du modèle à ajuster pour améliorer les performances).

    Pour plus d’informations, nous vous invitons à consulter la documentation de MLBox.

     

    Nous allons choisir une méthode de scoring : c’est une méthode qui fournit pour chaque individu la probabilité d’être atteint du cancer ou non ; ne pas oublier de mettre le résultat dans le même répertoire précédent !

     

    %%time

    import warnings

    warnings.filterwarnings('ignore')

    space = {'ne__numerical_strategy':{"search":"choice","space":['mean','median']},

    'ce__strategy':{"search":"choice","space":['label_encoding','entity_embedding','random_projection']},

    'fs__strategy':{"search":"choice","space":['l1','variance','rf_feature_importance']},

    'fs__threshold':{"search":"uniform","space":[0.01, 0.3]},

    'est__max_depth':{"search":"choice","space":[3,5,7]},

    'est__max_iter':{"search":"choice","space":[1000,2000]},

    'est__strategy':{"search":"choice","space":['LightGBM','RandomForest','ExtraTrees','Bagging','AdaBoost','Linear']},

    'est__n_estimators':{"search":"choice","space":[250,500,700,1000]}}

    opt = Optimiser(scoring = "accuracy", n_folds = 2, to_path = repertoire_testMLBox)

    best = opt.optimise(space, data, max_evals = 5)

     

    img3-3

     

    Entraînement du modèle

    Il s’agit de la phase d’apprentissage du modèle : on entraîne le modèle afin qu’il apprenne à bien prédire le risque d’être atteint du cancer du sein.

    En sortie de l’exécution nous possédons dans notre répertoire, une image sur l’importance des variables et aussi le résultat de la prédiction.

     

    Nous visualisons le classement des variables d’entrée qui impactent le plus notre prédiction.

    %%time

    %matplotlib inline

    import warnings

    warnings.filterwarnings('ignore')

    pred = Predictor(to_path=repertoire_testMLBox)

    pred.fit_predict(best, data)

    #pred.fit_predict(None,data)

     

    img4-3

     

    Fonction évaluation du modèle

    Cette fonction vous aidera à avoir le résultat de la prédiction croisé avec différentes métriques de performance.

    Il s’agit de mesurer la qualité des résultats de la prédiction selon différents indicateurs de performance.

     

    def evaluate_model(_y_test, _clf_pred, _clf_pred_proba):

        _accuracy = round(acc(_y_test, _clf_pred), 3)

        _precision = round(precision_score(_y_test, _clf_pred), 3)

        _recall = round(recall_score(_y_test, _clf_pred), 3)

        _f1 = round(fbeta_score(_y_test, _clf_pred, beta=1), 3)

       

        _roc_auc = round(roc_auc_score(_y_test, _clf_pred_proba), 3)

        _average_precision = round(average_precision_score(_y_test, _clf_pred_proba), 3)

     

        _pre, _rec, _thresholds = metrics.precision_recall_curve(_y_test, _clf_pred_proba)

        _precision_recall_auc = round(auc(_rec, _pre), 3)

       

        print("accuracy :\t\t%s" % _accuracy)

        print("precision :\t\t%s" % _precision)

        print("recall :\t\t%s" % _recall)

        print("F1 score :\t\t%s" % _f1)

     

        print("\nAUC ROC :\t\t%s" % _roc_auc)

       print("AUC precision-recall :\t%s" % _precision_recall_auc)

        print("average precision :\t%s" % _average_precision)

     

    Récupérer les prédictions

    Vérifier que votre répertoire contient un csv de la prédiction du test. 

    predictions = pd.read_csv(""C:\\Users\\user_name\\Documents\\testMLBox\\target_predictions.csv", sep=',')

    y_pred = predictions['target_predicted']

    clf_proba_un = predictions['1.0']

     

    Résultats du modèle

    evaluate_model(y_test, y_pred, clf_proba_un)

    confusion = confusion_matrix(y_test, y_pred)

    print(classification_report(y_test, y_pred, target_names=['0', '1']))

    cm = (confusion.astype('float') / confusion.sum(axis=1)[:, np.newaxis]).round(2)

    print(cm)

    print(confusion)

     

    img5-3

     

    Conclusion 

    L’AutoML s’adresse d’abord à des développeurs et non à des data scientists.

    Retenez que chaque cas d'usage (problématique data) reste spécifique. Certaines solutions d’AutoML peuvent apporter des résultats très faibles ; d'autres, des résultats excellents. Et, cette logique dépend à la fois des données, du cas d’usage et de la solution AutoML retenue.

     

    Ce sont tous ces critères qui impactent in fine le choix du décideur : dois-je réaliser un projet de Machine Learning selon un mode de fonctionnement traditionnel, avec a minima un data scientist ? Ou bien, faut-il privilégier une approche par AutoML avec une équipe de développeurs sans connaissance en data science ?

     

    En tout cas, si vous cherchez un service AutoML sur lequel faire vos premières expériences, nous vous invitons à consulter les solutions qui suivent :

    Thèmes : Actu Ysance, Data Science, Data Services, Data Scientist, Auto ML

    S'abonner au blog