Créer un modèle de tendances pour les services financiers sur Google Cloud

Ce tutoriel explique comment explorer des données et créer un modèle de machine learning (ML) scikit-learn sur Google Cloud. Le cas d'utilisation de ce tutoriel est un modèle prédictif de "tendance d'achat" pour les services financiers.

Les modèles de tendances sont largement utilisés dans le secteur financier pour analyser la tendance d'un prospect à effectuer un achat. Les entreprises utilisent souvent des solutions sur site qui sont rigides et difficiles à faire évoluer. Ce tutoriel décrit un modèle de ML flexible et sans serveur sur Google Cloud qui peut être déployé dans le cadre d'un workflow métier.

Les bonnes pratiques décrites dans ce tutoriel peuvent être appliquées à un large éventail de cas d'utilisation du ML, et pas seulement aux services financiers.

Cet article suppose que vous connaissez les technologies suivantes :

Objectifs

  • Découvrez les bonnes pratiques pour explorer des données et créer un modèle de ML scikit-learn sans serveur sur Google Cloud en utilisant BigQuery, AI Platform Notebooks et AI Platform.
  • Découvrez comment utiliser des composants Open Source tels que Pandas Profiling et Lime pour obtenir plus d'informations sur vos données et votre modèle.
  • Découvrez comment sélectionner le meilleur modèle à l'aide de la comparaison de modèles.
  • Découvrez comment utiliser les réglages d'hyperparamètres pour scikit-learn.
  • Déployez un modèle scikit-learn en tant qu'API gérée sur Google Cloud.

Architecture

Le modèle de ML pour ce tutoriel utilise les composants Google Cloud suivants :

  • BigQuery stocke les données d'entraînement.
  • AI Platform Notebooks fournit une expérience de notebook pour l'exécution du profilage et de l'entraînement.
  • AI Platform fournit un entraînement et une prédiction évolutifs.

Le schéma suivant illustre l'architecture de ce modèle.

Schéma illustrant l'architecture du modèle de machine learning utilisé dans ce tutoriel.

Cette architecture met en évidence plusieurs étapes fonctionnelles :

  • Stockage. Vous stockez les données d'entraînement dans BigQuery.
  • Profilage. Vous interrogez les données à l'aide de BigQuery et les chargez en tant que DataFrame Pandas dans un notebook AI Platform. Vous utilisez ensuite Pandas pour le prétraitement de base.
  • Modélisation. Vous testez plusieurs modèles à l'aide de scikit-learn et sélectionnez celui qui offre les meilleures performances. Vous utilisez ensuite Lime pour expliquer le prédicteur choisi.
  • Entraînement. Vous conditionnez le modèle pour l'entraînement et la prédiction à l'aide d'AI Platform.

Ce tutoriel utilise Pandas et scikit-learn, car ils constituent un point de départ plus simple que d'autres approches. Cette approche présente plusieurs avantages :

  • Évolutivité. Google Cloud vous aide à faire évoluer l'entraînement et les prédictions.
  • Transparence. Lime et Pandas Profiling fournissent des informations sur les données et le modèle.
  • Flexibilité. Les modèles Open Source peuvent être transférés et réutilisés.
  • Simplicité. Pandas et scikit-learn peuvent produire des résultats rapides.

Les données d'entraînement de ce tutoriel sont conçues pour tenir dans la mémoire. Si vous souhaitez créer un modèle de ML pouvant gérer un ensemble de données plus important, ou effectuer un entraînement distribué à l'aide d'accélérateurs, consultez cet article sur l'entraînement distribué avec TensorFlow et AI Platform ainsi que la documentation Dataflow pour prétraitement des données.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Avant de commencer

  1. Sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  2. Activez la facturation pour votre projet Cloud.

    Découvrir comment activer la facturation

  3. Activez les BigQuery, AI Platform, and Compute Engine requises pour ce projet.

    Activer les API

Démarrer AI Platform Notebooks

La procédure suivante vous permet de créer une instance AI Platform Notebooks.

  1. Dans Cloud Console, accédez à la page Notebook instances (Instances de notebook) d'AI Platform.

    Accéder à la page "Notebook instances" (Instances de notebook)

  2. Dans la barre de menus, cliquez sur New Instance (Nouvelle instance) , puis sélectionnez le framework TensorFlow 1.x.

  3. Sélectionnez Without GPUs (Sans GPU).

  4. Dans la boîte de dialogue New notebook instance (Nouvelle instance de notebook), vérifiez les options suivantes :

    • Vous pouvez conserver le nom d'instance par défaut ou le modifier.
    • Vous pouvez cliquer sur Customize (Personnaliser) pour sélectionner la région, la zone, le framework de machine learning, le type de machine, le type de GPU, le nombre de GPU, le type de disque de démarrage et la taille. Si vous ajoutez un GPU, cochez la case Install NVIDIA GPU driver automatically for me (Installer le pilote de GPU NVIDIA automatiquement).
  5. Cliquez sur Create (Créer).

    La création de l'instance par AI Platform Notebooks prend quelques minutes.

Cloner le notebook depuis GitHub et le configurer

Maintenant que vous disposez d'une instance AI Platform Notebooks, vous pouvez télécharger le fichier de ce tutoriel. Ce notebook contient toutes les cellules préremplies pour analyser l'ensemble de données, puis créer un modèle de ML.

  1. Dans Cloud Console, accédez à la page Notebook instances (Instances de notebook) d'AI Platform.

    Accéder à la page "Notebook instances" (Instances de notebook)

  2. Pour l'instance que vous venez de créer, cliquez sur Open JupyterLab (Ouvrir JupyterLab).

  3. Sur la page Launcher (Lanceur d'applications), cliquez sur Terminal.

    Capture d'écran du bouton Terminal dans l'instance de notebook.

  4. Dans la fenêtre de terminal, collez la commande suivante, puis cliquez sur Run (Exécuter) :

    git clone https://github.com/GoogleCloudPlatform/professional-services.git
    

    Le résultat ressemble à ce qui suit :

    Cloning into 'professional-services'...
    remote: Enumerating objects: 24, done.
    remote: Counting objects: 100% (24/24), done.
    remote: Compressing objects: 100% (20/20), done.
    remote: Total 5085 (delta 8), reused 13 (delta 4), pack-reused 5061
    Receiving objects: 100% (5085/5085), 50.50 MiB | 19.47 MiB/s, done.
    Resolving deltas: 100% (2672/2672), done.
    

    Une fois le clonage terminé, un nouveau dossier nommé professional-services s'affiche dans un volet adjacent.

  5. Dans les ressources du fichier de notebook, sélectionnez professional-services, examples, cloudml-bank-marketing, puis double-cliquez sur bank_marketing_classification_model.ipynb.

  6. Dans le notebook, exécutez le code de la cellule 1 pour vous assurer que le package Lime est installé.

    Si vous recevez une erreur indiquant que le package Python est manquant, supprimez la première ligne du code de la cellule 1, qui contient la commande install pandas-profiling.

  7. Après l'installation, cliquez sur l'onglet Kernel (Noyau), puis sur Restart Kernel (Redémarrer le noyau).

  8. Ignorez la cellule 2, sauf si vous exécutez Colab.

  9. Dans la fenêtre du terminal, exécutez la cellule 3, qui apparaît avec un [2].

  10. Exécutez la cellule avec la commande suivante, en remplaçant PROJECT_ID par la valeur de votre ID de projet Cloud :

    %env GOOGLE_CLOUD_PROJECT=PROJECT_ID
    
  11. Passez à la cellule 7 et mettez à jour le code :

    import os
    your_dataset = 'your_dataset'
    your_table = 'your_table'
    project_id = os.environ["GOOGLE_CLOUD_PROJECT"]
    

    Remplacez your_dataset et your_table par le nom de votre choix.

    Pour en savoir plus sur l'attribution de noms à l'ensemble de données, consultez les conventions d'attribution de noms BigQuery.

  12. Après avoir mis à jour le code de la cellule 7, définissez les variables d'environnement et créez l'ensemble de données et la table BigQuery :

    !bq mk -d {project_id}:{your_dataset}
    !bq mk -t {your_dataset}.{your_table}
    

    Le résultat ressemble à ce qui suit :

    Dataset 'your_project.your_dataset' successfully created
    Table 'your_project.your_dataset.your_table' successfully created
    
  13. Exécutez la cellule suivante pour télécharger le fichier CSV et l'enregistrer localement sous le nom data.csv. Ce tutoriel utilise l'ensemble de données de marketing bancaire UCI.

    !curl https://storage.googleapis.com/erwinh-public-data/bankingdata/bank-full.csv --output data.csv
    
  14. Importez le fichier data.csv dans votre table BigQuery en exécutant la cellule :

    !bq load --autodetect --source_format=CSV --field_delimiter ';' --skip_leading_rows=1 --replace {your_dataset}.{your_table} data.csv
    

    Le résultat ressemble à ce qui suit :

    Upload complete.
    Waiting on job … (2s) Current status: DONE
    

Obtenir des données à partir de BigQuery et créer un DataFrame Pandas

Pour créer un DataFrame Pandas, utilisez les bibliothèques clientes Google Cloud pour récupérer les données de BigQuery, puis chargez-les dans un DataFrame Pandas. Cette fonctionnalité intégrée de la bibliothèque simplifie l'importation des données de BigQuery dans un DataFrame Pandas sans écrire de code supplémentaire.

  • Exécutez la cellule contenant ce code :

    client = bq.Client(project=project_id)
    df = client.query('''
      SELECT *
      FROM `%s.%s`
    ''' % (your_dataset, your_table)).to_dataframe()
    

L'instruction SQL précédente renvoie des données qui sont ensuite utilisées pour construire un DataFrame Pandas. L'avantage d'une instruction SQL est que vous pouvez la modifier afin de prendre différents échantillons de données à partir de BigQuery.

Explorer les données à l'aide de Pandas Profiling

  • Exécutez la cellule contenant ce code :

    import pandas_profiling as pp
    pp.ProfileReport(df)
    

Une fois le DataFrame Pandas chargé, vous pouvez explorer les données à l'aide de Pandas Profiling. Pandas Profiling génère un rapport pour une analyse explicative. Pandas Profiling fournit des statistiques qui vont au-delà de ce qui est généralement produit par la fonction df.describe(). Pour chaque colonne, vous recevez des statistiques récapitulatives pertinentes présentées dans un format HTML interactif.

Dans ce cas, la colonne y correspond au libellé et les autres colonnes peuvent être utilisées comme colonnes de caractéristiques. L'analyse de ces colonnes vous permet de sélectionner les fonctionnalités à utiliser et de déterminer si un prétraitement est nécessaire avant l'entraînement du modèle.

Le schéma suivant illustre un exemple de rapport de Pandas Profiling.

Capture d'écran de la présentation du rapport Pandas Profiling.

L'exemple de rapport de Pandas Profiling inclut un avertissement indiquant que les données de la colonne previous sont biaisées. Le rapport de profilage indique également que la colonne y contient environ 5 000 exemples True et environ 40 000 exemples Missing ou "Faux".

Capture d'écran des données du rapport Pandas Profiling.

Comme l'ensemble de données est considérablement biaisé, vous devez vous assurer que lorsque vous divisez vos données en ensembles d'entraînement et de test, certains exemples True ne se retrouvent ni dans l'ensemble de test, ni dans l'ensemble d'entraînement.

Gérer les ensembles de données biaisés

Vous pouvez résoudre le problème des données biaisées de deux manières :

  • En brassant l'ensemble de données pour éviter toute forme de pré-classement.
  • En utilisant l'échantillonnage stratifié pour vous assurer que vos ensembles de données de test et d'entraînement conservent une distribution similaire de y pour les deux ensembles de données. Environ 12 % des exemples de chaque ensemble de données doivent être True, et le reste False.

Le code suivant brasse les données et utilise l'échantillonnage stratifié.

  • Exécutez la cellule contenant ce code :

    from sklearn.model_selection import StratifiedShuffleSplit
    
    #Here we apply a shuffle and stratified split to create a train and test set.
    split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=40)
    for train_index, test_index in split.split(df, df["y"]):
        strat_train_set = df.loc[train_index]
        strat_test_set = df.loc[test_index]
    

Prétraiter les données

Avant de pouvoir créer un modèle de ML, vous devez formater les données sous une forme que le modèle peut traiter. Cette étape est appelée prétraitement.

Pour prétraiter vos données, procédez comme suit :

  1. Pour les colonnes numériques, assurez-vous que toutes les valeurs sont comprises entre 0 et 1. Cette étape normalise les colonnes de sorte que si une colonne a une très grande valeur, cette valeur ne biaise pas les résultats.
  2. Transformez les valeurs catégorielles en valeurs numériques en remplaçant chaque valeur unique d'une colonne par un nombre entier. Par exemple, si la colonne Color comporte trois chaînes uniques (red, yellow et blue), remplacez les valeurs par 0, 1 et 2, respectivement.
  3. Convertissez les valeurs True/False en entiers 1/0, respectivement.

Le code suivant met en œuvre les trois approches.

  • Exécutez la cellule contenant ce code :

      def data_pipeline(df):
        """Normalizes and converts data and returns dataframe """
    
        num_cols = df.select_dtypes(include=np.number).columns
        cat_cols = list(set(df.columns) - set(num_cols))
        # Normalize Numeric Data
        df[num_cols] = StandardScaler().fit_transform(df[num_cols])
        # Convert categorical variables to integers
        df[cat_cols] = df[cat_cols].apply(LabelEncoder().fit_transform)
        return df
    

Une autre étape importante du prétraitement est la sélection de caractéristiques. Les ensembles de données peuvent souvent contenir des caractéristiques qui peuvent ne pas être utiles pour prédire un libellé. En supprimant ces caractéristiques, vous obtenez non seulement un modèle plus précis, mais vous gagnez également beaucoup de temps de calcul.

Vous pouvez utiliser l'une des options suivantes pour la sélection des fonctionnalités :

  • La méthode SelectKBest. Cette méthode sélectionne les K principales caractéristiques à l'aide d'une fonction d'évaluation (f_classif dans ce tutoriel).
  • Un classificateur en arborescence. Cette option détermine également les K principales caractéristiques.

Pour ce tutoriel, l'une des deux options permet de sélectionner les cinq principales fonctionnalités.

  • Pour utiliser la méthode SelectKBest, exécutez la cellule contenant le code suivant :

    from sklearn.feature_selection import SelectKBest, f_classif
    
    predictors = train_features_prepared.columns
    
    # Perform feature selection where `k` (5 in this case) indicates the number of features we wish to select
    selector = SelectKBest(f_classif, k=5)
    selector.fit(train_features_prepared[predictors], train_label)
    
  • Pour utiliser un outil de classification en arborescence, exécutez la cellule contenant le code suivant :

    from sklearn.ensemble import ExtraTreesClassifier
    from sklearn.feature_selection import SelectFromModel
    
    predictors_tree = train_features_prepared.columns
    
    selector_clf = ExtraTreesClassifier(n_estimators=50, random_state=0)
    selector_clf.fit(train_features_prepared[predictors], train_label)
    

Comparer et évaluer différents modèles de machine learning

Il peut être difficile de savoir quel modèle convient le mieux à votre cas d'utilisation et quels sont les meilleurs hyperparamètres.

Pour vous aider à sélectionner le meilleur modèle et les meilleurs hyperparamètres, la fonction create_classifiers est définie ci-dessous.

  • Pour créer la fonction create_classifiers, exécutez la cellule contenant le code suivant :

    def create_classifiers():
        """Create classifiers and specify hyper parameters"""
    
        log_params = [{'penalty': ['l1', 'l2'], 'C': np.logspace(0, 4, 10)}]
    
        knn_params = [{'n_neighbors': [3, 4, 5]}]
    
        svc_params = [{'kernel': ['linear', 'rbf'], 'probability': [True]}]
    
        tree_params = [{'criterion': ['gini', 'entropy']}]
    
        forest_params = {'n_estimators': [1, 5, 10]}
    
        mlp_params = {'activation': [
                        'identity', 'logistic', 'tanh', 'relu'
                      ]}
    
        ada_params = {'n_estimators': [1, 5, 10]}
    
        classifiers = [
            ['LogisticRegression', LogisticRegression(random_state=42),
             log_params],
            ['KNeighborsClassifier', KNeighborsClassifier(), knn_params],
            ['SVC', SVC(random_state=42), svc_params],
            ['DecisionTreeClassifier',
             DecisionTreeClassifier(random_state=42), tree_params],
            ['RandomForestClassifier',
             RandomForestClassifier(random_state=42), forest_params],
            ['MLPClassifier', MLPClassifier(random_state=42), mlp_params],
            ['AdaBoostClassifier', AdaBoostClassifier(random_state=42),
             ada_params],
            ]
    
        return classifiers
    

La fonction create_classifiers utilise jusqu'à sept classificateurs et hyperparamètres comme paramètres d'entrée. Les cellules suivantes de cette section du notebook utilisent cette fonction pour sélectionner la configuration optimale (hyperparamètres) pour chaque classificateur.

Ce tutoriel présente deux méthodes pour sélectionner le meilleur outil de classification :

  • La première méthode consiste à créer une table avec un certain nombre de métriques pour chaque classificateur. Cette approche fournit différentes métriques à prendre en compte, en fonction de votre cas d'utilisation. Par exemple, la métrique Accuracy peut ne pas être la meilleure métrique dans votre cas.

    Capture d'écran du tableau des outils de classification.

  • La deuxième méthode consiste à générer un graphique ROC (fonction d’efficacité du récepteur) pour analyser plus en détail chaque classificateur, comme illustré dans le schéma suivant.

    Capture d'écran du graphique des outils de classification.

En examinant les deux ensembles de données, vous pouvez choisir la régression logistique comme modèle, car sa surface sous la courbe (AUC) est la plus élevée. Le "meilleur" modèle peut dépendre de votre cas d'utilisation.

Expliquer le modèle

Après avoir sélectionné votre modèle, vous devez mieux comprendre les performances de vos prédictions. Pour cela, ce tutoriel utilise le package Python Lime. À l'aide de Lime, vous pouvez créer une instance d'explication et afficher le résultat.

  • Exécutez le code de la cellule de notebook suivante :

    i = 106
    exp = explainer.explain_instance(train[i], predict_fn)
    pprint.pprint(exp.as_list())
    fig = exp.as_pyplot_figure()
    

Dans Lime, vous voyez la valeur (en abscisse) pour chacun des principaux éléments géographiques (en ordonnées), comme illustré dans le diagramme suivant.

Capture d'écran de l'explication Lime.

Entraîner et prédire avec AI Platform

Jusqu'à ce stade du tutoriel, vous avez entraîné et prédit vos modèles localement. Toutefois, si vous souhaitez réduire le temps d'entraînement ou effectuer des prédictions à grande échelle, vous pouvez utiliser AI Platform. AI Platform propose un service géré capable de faire évoluer votre entraînement sur de nombreux nœuds et fournit un point de terminaison d'API pour les modèles déployés.

Dans les étapes suivantes, vous allez déployer le modèle sur AI Platform, puis utiliser AI Platform pour déployer le modèle de manière à l'utiliser dans les futures prédictions.

L'utilisation d'AI Platform pour entraîner votre modèle et demander des prédictions nécessite deux étapes :

  1. Envoyer une tâche d'entraînement à AI Platform.
  2. Créer un modèle dans AI Platform.

Envoyer une tâche d'entraînement

  1. Définissez les variables d'environnement suivantes, en remplaçant gcs_bucket par le nom de votre bucket Cloud Storage :

    %env GCS_BUCKET=gcs_bucket
    %env REGION=us-central1
    %env LOCAL_DIRECTORY=./trainer/data
    %env TRAINER_PACKAGE_PATH=./trainer
    
  2. Envoyez la tâche d'entraînement en exécutant les cellules contenant les commandes suivantes :

    %%bash
    
    JOBNAME=banking_$(date -u +%y%m%d_%H%M%S)
    
    echo $JOBNAME
    
    gcloud ai-platform jobs submit training model_training_$JOBNAME \
            --job-dir $GCS_BUCKET/$JOBNAME/output \
            --package-path trainer \
            --module-name trainer.task \
            --region $REGION \
            --runtime-version=1.9 \
            --python-version=3.5 \
            --scale-tier BASIC
    

    Ces commandes stockent votre ensemble de données d'entraînement dans un bucket Cloud Storage et créent un répertoire pour stocker vos fichiers Python.

    Pour afficher l'état de la tâche, accédez à AI Platform dans la barre latérale, puis sélectionnez Tâches. L'entraînement prend environ huit minutes.

Créer un modèle dans AI Platform

Une fois l'entraînement du modèle terminé, vous pouvez lui demander des prédictions.

Définir les variables de configuration et d'environnement

  1. Dans la cellule contenant le code suivant, remplacez la variable d'environnement gcs_bucket pour spécifier le bucket Cloud Storage utilisé dans la procédure d'entraînement précédente :

    gcs_bucket
    

    Ce bucket Cloud Storage sert à préproduire la sortie intermédiaire et à stocker les résultats.

  2. Recherchez le répertoire du modèle et copiez le nom.

    Le répertoire du modèle a été stocké dans votre bucket Cloud Storage lors de l'étape d'entraînement précédente. Le répertoire se présente sous la forme model_YYYYMMDD_HHMMSS.

  3. Dans la cellule contenant le code suivant, remplacez model_directory par la valeur du répertoire de modèle que vous avez copiée précédemment :

    model_directory
    

Créer le modèle

  • Dans le notebook, exécutez la cellule avec le code suivant :

    ! gcloud ai-platform models create $MODEL_NAME --regions=us-central1
    
    ! gcloud ai-platform versions create $VERSION_NAME \
            --model $MODEL_NAME --origin $MODEL_DIR \
            --runtime-version 1.9 --framework $FRAMEWORK \
            --python-version 3.5
    

    Ces commandes créent un modèle appelé cmle_model et une version appelée v1. Une version est une configuration spécifique pour le modèle donné que vous créez. Un modèle peut avoir plusieurs versions.

Utiliser le modèle

Après avoir créé un modèle et sa version, vous pouvez demander la prédiction par l'intermédiaire l'API de prédiction d'AI Platform. Vous pouvez utiliser la ligne de commande ou la bibliothèque cliente Python pour effectuer une prédiction, comme indiqué dans les dernières cellules du notebook.

Pour utiliser le modèle déployé pour la production dans le cadre d'un processus métier, vous pouvez prendre des mesures supplémentaires pour développer une mise en œuvre prête pour la production. Ces étapes, qui n'entrent pas dans le cadre de ce tutoriel, incluent les éléments suivants :

  • Évaluer et supprimer l'identification des données (pour plus d'informations, consultez la section Considérations relatives aux données sensibles dans les ensembles de données de machine learning).
  • Créer un pipeline de traitement et de transformation de données reproductible pour l'entraînement et les prédictions, de sorte que l'entraînement et les prédictions passent par les mêmes transformations de données.
  • Créer un processus de déploiement reproductible pour gérer le réentraînement de modèles.
  • Définir des autorisations IAM (Identity and Access Management) appropriées pour l'accès aux données, les pipelines de données et les ressources AI Platform déployées.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Google Cloud que vous avez créé pour ce tutoriel.

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante