③ Créez un notebook Jupyter

Lorsque l'état devient «En service», appuyez sur «Ouvrir Jupyter» pour passer à l'écran supérieur du bloc-notes Jupyter. Lorsque vous accédez à l'écran supérieur du notebook Jupyter, spécifiez "conda_python3" dans "new" en haut à droite et créez un notebook, il sera comme indiqué dans la figure ci-dessous.

Importez les variables de configuration et les bibliothèques requises. Remplacez l'élément de compartiment ci-dessous par le nom du compartiment S3 que vous avez choisi précédemment. De plus, si les régions de SageMaker et S3 sont différentes, cela ne fonctionnera pas, alors faites attention si les régions sont identiques. Le dossier spécifié par le préfixe est nouvellement créé dans S3. Aucune modification particulière n'est requise, mais il n'y a pas de problème même si elle est modifiée le cas échéant. Enfin, déclarez les rôles de boto3 et IAM. Bien qu'il s'agisse de boto3, il s'agit d'une bibliothèque qui intègre Python développé par AWS et divers services AWS.

Pour exécuter une cellule, appuyez sur Maj + Entrée. Lorsque l'exécution est terminée, elle sera numérotée comme indiqué dans In [1] dans la figure ci-dessous. Parfois, le nom de la cellule sera In [*], mais cela ne prend que beaucoup de temps pour exécuter la cellule, alors attendez un moment avant de passer à l'étape suivante.

In[1]

#Veuillez définir le nom du compartiment de S3 comme suit
#Définir le préfixe S3 (aucune modification requise)
bucket = 'bank-xgboost'
prefix = 'sagemaker/xgboost-dm'
 
#Déclaration du rôle IAM
import boto3
import re
from sagemaker import get_execution_role
 
role = get_execution_role()

Ensuite, importez les différentes bibliothèques requises pour cette construction de modèle dans. Outre Numpy, Pandas et Matplotlib, qui sont du machine learning standard, un module de traçage de tables avec ipython (Jupyter Notebook) et le SDK Python de SageMaker sont également importés.

In[2]

import numpy as np                                #Pour les opérations matricielles et le traitement numérique
import pandas as pd                               #Pour modifier les données tabulaires
import matplotlib.pyplot as plt                   #Pour la visualisation des figures, etc.
from IPython.display import Image                 #Pour afficher des images dans le bloc-notes
from IPython.display import display               #Pour afficher la sortie dans le notebook
from time import gmtime, strftime                 #Pour étiqueter les modèles SageMaker, les points finaux, etc.
import sys                                        #Pour écrire la sortie sur le notebook
import math                                       #Pour la fonction de plafond
import json                                       #Pour l'analyse de la sortie d'hébergement
import os                                         #Pour manipuler le nom du chemin du fichier
import sagemaker                                  #De nombreuses fonctions d'assistance sont fournies à l'aide du SDK Python d'Amazon SageMaker
from sagemaker.predictor import csv_serializer    #Convertir les chaînes de requête HTTP POST lors de l'inférence

④ Téléchargez, sondez et convertissez les données d'entraînement

L'ensemble de données est disponible sur le site Web de l'Université de Californie à Irvine, alors obtenez-le directement à partir de là. Téléchargez directement depuis l'URL avec wget et unizip.

In[3]

#Téléchargez l'ensemble de données à partir de l'URL publique de l'Université de Californie à Irvine
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00222/bank-additional.zip
!unzip -o bank-additional.zip

Chargez l'ensemble de données du fichier csv téléchargé en tant que trame de données Pandas.

In[4]

# bank-additional-full.Stocker le CSV dans les données
data = pd.read_csv('./bank-additional/bank-additional-full.csv', sep=';')
 
#Modification des paramètres de numéro de colonne d'affichage maximum et de numéro de ligne de Pandas
pd.set_option('display.max_columns', 500)
pd.set_option('display.max_rows', 30)
 
#Afficher les 10 premières lignes
data.head(10)

Si vous affichez les 10 premières lignes de l'ensemble de données, vous pouvez voir que les informations client sont stockées. Voici une partie du plan des articles.

· Âge - Âge du client · Emploi - Catégorie d'emploi ・ Marital - État matrimonial ・ Éducation - Éducation · Par défaut - Statut de paiement en retard de crédit · Logement - avec ou sans prêt immobilier ・ Prêt - Qu'il y ait ou non un prêt personnel, etc ...

Vérifiez les données manquantes. S'il manque des données, cela est gênant car il est nécessaire de discuter de la façon de les traiter séparément.

In[5]

#Une fonction de table qui résume les données manquantes dans une trame de données
def missing_values_table(df): 
        mis_val = df.isnull().sum()
        mis_val_percent = 100 * df.isnull().sum()/len(df)
        mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
        mis_val_table_ren_columns = mis_val_table.rename(
        columns = {0 : 'Missing Values', 1 : '% of Total Values'})
        return mis_val_table_ren_columns 
 
#Vérifiez si des données sont manquantes
missing_values_table(data)

En regardant la figure ci-dessous, on peut observer qu'il n'y a pas de perte de données. Comme prévu, l'ensemble de données bancaires.

Ensuite, le nettoyage des données (pré-traitement de l'ensemble de données) est effectué. Le nettoyage des ensembles de données est devenu un élément essentiel de presque tous les processus d'apprentissage automatique.

Cette fois, quatre types de prétraitement sont effectués.

** ① Extrayez les clients qui n'ont pas été contactés depuis pdays ** Le pdays (combien de jours se sont écoulés depuis le dernier contact) contient une grande quantité de données "999", et on peut dire que la plupart des clients n'ont pas contacté depuis la dernière fois. Le traitement des données est effectué avec 999 jours (c'est-à-dire les clients qui n'ont pas été contactés) comme "1" et les autres comme "0".

** ② Extraire les clients qui ne sont pas actuellement en poste à partir du poste ** Il existe 12 types d'éléments de travail, y compris inconnus. Cet élément comprend les clients qui ne sont pas actuellement en emploi, tels que «étudiants» ou «chômeurs». Par conséquent, le processus consistant à séparer s'il fonctionne actuellement ou non et à ajouter un nouvel élément "not_working" (ne fonctionne pas) est effectué.

** ③ Faire des données catégorielles une variable factice ** La méthode de numérisation des données non numériques est appelée variable fictive. Par exemple, dans le cas de ces données, la cible de prédiction est "y", mais les valeurs qu'elle a sont "yes" et "no". Lorsque cela est transformé en une variable factice, un élément "y" est initialement divisé en deux éléments "y_yes" et "y_no", et "0" et "1" sont donnés en fonction de chaque valeur.

** ④ Supprimer les éléments qui ne sont pas inclus dans le modèle de prédiction ** Enfin, utilisez pd.drop pour supprimer les éléments non utilisés dans cette formation, tels que les indicateurs de facteurs environnementaux externes (emp.var.rate), de la base de données.

In[7]

#Ajout d'un nouvel élément pour identifier les personnes qui n'ont pas été contactées auparavant
data['no_previous_contact'] = np.where(data['pdays'] == 999, 1, 0)
 
#Ajout de drapeaux "Personnes sans emploi" (étudiants, etc.) de la profession
data['not_working'] = np.where(np.in1d(data['job'], ['student', 'retired', 'unemployed']), 1, 0)
 
#Faire des données catégorielles une variable factice
model_data = pd.get_dummies(data)
 
#Supprimer les éléments non utilisés dans ce modèle
model_data = model_data.drop(['duration', 'emp.var.rate', 'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed'], axis=1)

Une fois le prétraitement terminé, la tâche suivante consiste à diviser les données en trois parties: données d'entraînement, données de vérification et données de test.

En ce qui concerne la raison pour laquelle il est divisé, pour le dire simplement, je veux l'entraîner plusieurs fois pour améliorer la précision du modèle, je vais donc le laisser au point de vue cette fois.

In[8]

#Modèle pré-traité_Trier les données de manière aléatoire dans 3 trames de données
train_data, validation_data, test_data = np.split(model_data.sample(frac=1, random_state=1729), [int(0.7 * len(model_data)), int(0.9 * len(model_data))])   # Randomly sort the data then split out first 70%, second 20%, and last 10%

Vient ensuite la dernière étape du prétraitement des données. Le format de données du conteneur Amazon SageMaker XGBoost est libSVM. Bien qu'il soit au format libSVM, la fonction (quantité de fonctionnalités) et la cible de prédiction (variable d'objectif) doivent être des arguments séparés, de sorte que le processus est exécuté. Enfin, envoyez cet ensemble de données d'entraînement (format libSVM) à AWS S3 via boto3.

In[9]

#Exporter le fichier libSVM
dump_svmlight_file(X=train_data.drop(['y_no', 'y_yes'], axis=1), y=train_data['y_yes'], f='train.libsvm')
dump_svmlight_file(X=validation_data.drop(['y_no', 'y_yes'], axis=1), y=validation_data['y_yes'], f='validation.libsvm')
dump_svmlight_file(X=test_data.drop(['y_no', 'y_yes'], axis=1), y=test_data['y_yes'], f='test.libsvm')
 
#Copier des fichiers sur S3 à l'aide de Boto3
boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'train/train.libsvm')).upload_file('train.libsvm')
boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'validation/validation.libsvm')).upload_file('validation.libsvm')

Cela créera un nouveau dossier appelé «sagemaker» dans le premier compartiment AWS S3 que vous avez spécifié. Comme le montre la figure ci-dessous, si train.libsvm est nouvellement créé dans le répertoire de S3> nom du compartiment> sagemaker> xgboost-dm> train, il s'est déroulé sans problème.

⑤ Former le modèle

Maintenant que le prétraitement est terminé, il est temps de créer le modèle à l'aide de XGBoost.

Tout d'abord, spécifiez l'emplacement du conteneur ECR pour XGBoost d'Amazon SageMaker et liez les données d'entraînement (libSVM) avec S3.

In[10]

#Spécifier le conteneur ECR pour SageMaker XGBoost
containers = {'us-west-2': '433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest',
              'us-east-1': '811284229777.dkr.ecr.us-east-1.amazonaws.com/xgboost:latest',
              'us-east-2': '825641698319.dkr.ecr.us-east-2.amazonaws.com/xgboost:latest',
              'eu-west-1': '685385470294.dkr.ecr.eu-west-1.amazonaws.com/xgboost:latest'}

#Je vais lier les données d'entraînement et S3
s3_input_train = sagemaker.s3_input(s3_data='s3://{}/{}/train'.format(bucket, prefix), content_type='libsvm')
s3_input_validation = sagemaker.s3_input(s3_data='s3://{}/{}/validation/'.format(bucket, prefix), content_type='libsvm')

Ensuite, spécifiez les paramètres nécessaires et les hyperparamètres dans SageMaker Estimator et effectuez l'ajustement. Le code ci-dessous utilise "ml.m4.xlarge" </ font> comme instance de formation. Le processus est terminé en environ 10 minutes.

#Session SageMaker
sess = sagemaker.Session()
 
#Spécifiez les éléments requis pour l'estimateur de sagemaker
xgb = sagemaker.estimator.Estimator(containers[boto3.Session().region_name],
                                    role, 
                                    train_instance_count=1, 
                                    train_instance_type='ml.m4.xlarge',
                                    output_path='s3://{}/{}/output'.format(bucket, prefix),
                                    sagemaker_session=sess)
 
#Spécification d'hyper paramètres
xgb.set_hyperparameters(max_depth=5,
                        eta=0.2,
                        gamma=4,
                        min_child_weight=6,
                        subsample=0.8,
                        silent=0,
                        objective='binary:logistic',
                        num_round=100)
 
#Ajustement du modèle et spécification de la destination de sortie (S3)
xgb.fit({'train': s3_input_train, 'validation': s3_input_validation})

2019-11-18 16:36:46 Uploading - Uploading generated training model
2019-11-18 16:36:46 Completed - Training job completed
Training seconds: 63
Billable seconds: 63

# ml.t2.Déployer avec une instance de support
xgb_predictor = xgb.deploy(initial_instance_count=1,
                           instance_type='ml.t2.medium')

ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling the CreateEndpoint operation: The account-level service limit 'ml.c4.xlarge for endpoint usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please contact AWS support to request an increase for this limit.

#Définir les paramètres de transfert de données
xgb_predictor.content_type = 'text/csv'
xgb_predictor.serializer = csv_serializer

#Xgb par petits lots de 500 lignes_Prédire et calculer avec le prédicteur
def predict(data, rows=500):
    split_array = np.array_split(data, int(data.shape[0] / float(rows) + 1))
    predictions = ''
    for array in split_array:
        predictions = ','.join([predictions, xgb_predictor.predict(array).decode('utf-8')])
 
    return np.fromstring(predictions[1:], sep=',')
 
#Test créé dans l'élément précédent_Supprimer l'élément cible des données et générer la prévision
predictions = predict(test_data.drop(['y_no', 'y_yes'], axis=1).as_matrix())
 
#Tableau de comparaison des données de prédiction et de réponse correcte
pd.crosstab(index=test_data['y_yes'], columns=np.round(predictions), rownames=['actuals'], colnames=['predictions'])

#Supprimer le point de terminaison créé
sagemaker.Session().delete_endpoint(xgb_predictor.endpoint)