Rubrique traduite automatiquement Vous pouvez passer à la version anglaiseVoir la clause de protection
Pour obtenir la version la plus précise et la plus à jour de cette documentation, voir la version anglaise (originale). IBM n'est pas responsable des dommages ou pertes résultant de l'utilisation du contenu traduit automatiquement (machine).
Tutoriel de l'apprentissage fédéré XGBoost pour l'interface utilisateur
Dernière mise à jour : 28 nov. 2024
Tutoriel de l'apprentissage fédéré XGBoost pour l'interface utilisateur
Ce tutoriel présente l'utilisation de l'apprentissage fédéré dans le but d'entraîner un modèle d'apprentissage automatique avec des données provenant de différents utilisateurs sans que ces derniers aient à partager leurs données. Les
étapes sont réalisées dans un environnement low-code avec l'interface utilisateur et avec une infrastructure XGBoost. En utilisant l'ensemble de données UCI : Adult - Predict income, le modèle formé prédit si le revenu dépasse $50K/yr sur la base des données de recensement. L'ensemble de données est également connu sous le nom de "Census Income".
Dans ce tutoriel, vous exécutez les tâches suivantes :
Il s'agit d'un tutoriel pas à pas pour l'exécution d'une expérimentation d'apprentissage fédéré pilotée par l'interface utilisateur. Pour afficher un exemple de code pour une approche pilotée par API, accédez à Federated Learning XGBoost samples.
Dans ce tutoriel, admin fait référence à l'utilisateur qui démarre l'expérimentation d'apprentissage fédéré, et party fait référence à un ou plusieurs utilisateurs qui envoient leurs résultats de modèle après le démarrage de l'expérimentation par l'administrateur. Bien que le tutoriel puisse être exécuté par l'administrateur et plusieurs parties, un seul utilisateur peut également effectuer une exécution complète en tant qu'administrateur et partie. Pour faciliter la démonstration dans le tutoriel suivant, un seul jeu de données est soumis par une seule partie. Pour plus d'informations sur l'administrateur et la partie, voir Terminologie.
Prérequis
Copy link to section
Vérifiez le Python version
Copy link to section
Vérifiez que vous utilisez la même version de Python que l'administrateur. L'utilisation d'une version Python différente peut entraîner des problèmes de compatibilité. Pour voir les versions de Python compatibles avec différentes infrastructures, voir infrastructures et compatibilité de version Python.
Ouvrir un projet
Copy link to section
Utilisez un projet existant ou créez-en un nouveau. Vous devez disposer au moins des droits d'administrateur.
Associez le service watsonx.ai Runtime à votre projet.
Dans votre projet, cliquez sur Gérer > Services & intégrations.
Cliquez sur Associer un service.
Sélectionnez votre instance watsonx.ai Runtime dans la liste, et cliquez sur Associer; ou cliquez sur Nouveau service si vous n'en avez pas pour configurer une instance.
Tâche 1 : Démarrer l'apprentissage fédéré
Copy link to section
Dans cette section, vous allez créer, configurer et démarrer une expérience d'apprentissage fédéré.
Dans votre projet, cliquez sur le Actifs onglet dans votre projet.
Cliquez sur Nouvel actif > Entraîner des modèles sur des données distribuées pour créer l’actif Expérience d’apprentissage fédéré.
Entrez un nom pour votre expérimentation et éventuellement une description.
Vérifiez l'instance watsonx.ai Runtime associée sous Select a machine learning instance. Si vous ne voyez pas d'instance de Runtime watsonx.ai associée, suivez les étapes suivantes :
Cliquez sur Associer une instance de service Machine Learning.
Sélectionnez une instance existante et cliquez sur Associerou créez un nouveau service.
Cliquez sur Recharger pour afficher le service associé.
Cliquez sur Suivant.
Tâche 1b: Configurer l'expérience
Copy link to section
Sur la page Configurer , sélectionnez une spécification matérielle.
Dans la liste déroulante Machine learning framework , sélectionnez scikit-learn.
Pour le Type de modèle, sélectionnez XGBoost.
Pour la méthode de fusion, sélectionnez Fusion de classification XGBoost.
Cliquez sur Suivant.
Tâche 1c: Définir les hyperparamètres
Copy link to section
Définissez la valeur de la zone Rondes sur 5.
Acceptez les valeurs par défaut pour le reste des zones.
Cliquez sur Suivant.
Tâche 1d: Sélectionnez des systèmes de formation à distance
Copy link to section
Cliquez sur Ajouter de nouveaux systèmes.
Tapez un nom pour votre système de formation à distance.
Sous Identités autorisées, sélectionnez l'utilisateur qui participera à l'expérimentation, puis cliquez sur Ajouter. Vous pouvez ajouter autant d'identités autorisées que les participants à cette instance d'entraînement d'expérimentation fédérée. Pour ce tutoriel, choisissez uniquement vous-même. Toute identité autorisée doit être un collaborateur du projet et avoir au moins Administrateur autorisation. Ajoutez des systèmes supplémentaires en répétant cette étape pour chaque partie distante que vous prévoyez d'utiliser.
Lorsque vous avez terminé, cliquez sur Ajouter des systèmes.
Revenez à la page Sélection des systèmes d'entraînement à distance , vérifiez que votre système est sélectionné, puis cliquez sur Suivant.
Tâche 1e: Vérifiez les paramètres
Copy link to section
Vérifiez vos paramètres, puis cliquez sur Créer.
Surveillez le statut. Le statut de votre expérimentation d'apprentissage fédéré est En attente quand elle démarre. Lorsque votre expérimentation est prête pour que les parties prenantes s'y connectent, le statut devient Configuration - En attente de systèmes distants. Cette opération peut prendre plusieurs minutes.
Cliquez sur Afficher les informations de configuration pour télécharger la configuration du groupe et le script du connecteur de groupe que vous pouvez exécuter sur le groupe distant.
Cliquez sur l'icône Télécharger la configuration à côté de chacun des systèmes de formation à distance que vous avez créés. Enregistrez le script du connecteur de partie dans un répertoire de votre ordinateur sous le nom :
remote-test-system-configuration.py
Copy to clipboardCopié dans le presse-papiers
Cliquez sur Terminé.
Vérifiez vos progrès
Copy link to section
L'image suivante montre l'expérience avec le statut « en attente de systèmes distants ».
Tâche 2 : Former le modèle en tant que groupe
Copy link to section
Pour entraîner le modèle, vous devez télécharger les ensembles de données, puis modifier et exécuter des scripts Python. Suivez ces étapes pour entraîner le modèle en tant que groupe :
Tâche 2a: Téléchargez les ensembles de données et les scripts
Copy link to section
Créez un nouveau répertoire local et placez le script de connecteur de partie que vous avez téléchargé dans la tâche 1e dans le nouveau répertoire.
Téléchargez les fichiers suivants en cliquant avec le bouton droit sur le nom du fichier, puis cliquez sur Enregistrer le lien sous. Sauvegardez-le dans le même répertoire que le script
connecteur de parties.
Vérifiez que vous disposez du script du connecteur de partie, du Adulte l'ensemble de données, le gestionnaire de données et le fichier de configuration du journal dans le même répertoire. Si vous répertoriez les fichiers dans le répertoire, vous devriez voir ces fichiers :
Tâche 2b: Installer le moteur d'exécution watsonx.ai
Copy link to section
Si vous utilisez Windows ou Linux, courirpip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]' .
Si vous utilisez Mac OS avec un processeur de la série M et Conda, téléchargez le script d'installation puis cours./install_fl_rt23.1_macos.sh <name for new conda environment> .
Tâche 2c: Modifier et exécuter le script du connecteur de partie
Copy link to section
Modifiez le fichier du connecteur de partie,remote-test-systm-configuration.py et apportez les modifications suivantes :
Ajoutez le code suivant comme deuxième ligne du fichier python.
log_config_path = "log_config.yaml"
Copy to clipboardCopié dans le presse-papiers
Fournissez vos identifiants : Collez la clé API de l'utilisateur défini dans le système de formation à distance. Si vous n'avez pas de clé API, accédez à la page Clés API d'IBM Cloud, puis cliquez sur Créer une clé API, remplissez les champs et cliquez sur Créer.
Pour le party_metadonnées, indiquez le nom, le chemin et les informations, qui doivent être similaires au texte JSON suivant.
name: nom de classe défini pour le gestionnaire de données.
path: chemin d'accès au gestionnaire de données.
info: créez une paire clé-valeur pour le type de fichier de l'ensemble de données local ou pour le chemin de votre ensemble de données.
Enregistrez le script du connecteur de partie.
Exécutez le script du connecteur de partie en utilisant soitpython oupython3 en fonction de ce que vous avez installé.
python remote-test-system-configuration.py
Copy to clipboardCopié dans le presse-papiers
A partir de l'interface utilisateur, vous pouvez surveiller l'état de votre expérimentation d'apprentissage fédéré. Lorsque toutes les parties participantes se connectent à l'agrégateur, ce dernier facilite l'entraînement du modèle local et la mise à jour du modèle global. Son statut est en formation. Vous pouvez surveiller le statut de votre expérimentation d'apprentissage fédéré à partir de l'interface utilisateur. Une fois la formation terminée, le groupe reçoit unReceived STOP message à la fête. Vous pouvez maintenant sauvegarder le modèle entraîné et le déployer dans un espace.
Vérifier votre progression
Copy link to section
L'image suivante montre l'expérience terminée.
Tâche 3 : Enregistrer et déployer le modèle en ligne
Copy link to section
Dans cette section, vous allez apprendre à sauvegarder et à déployer le modèle que vous avez entraîné.
Tâche 3a: Enregistrez votre modèle
Copy link to section
Dans votre expérience d’apprentissage fédéré terminée, cliquez sur Enregistrer l'agrégat.
Sur le Enregistrer le modèle agrégé dans le projet écran, saisissez un nom pour le modèle. et cliquez Créer.
Lorsque vous voyez la notification indiquant que le modèle est créé, cliquez sur Afficher dans le projet. Si vous manquez la notification, cliquez sur le nom du projet pour revenir à l'onglet Actifs, puis cliquez sur le nom du modèle pour l'afficher.
Tâche 3b: Promouvoir le modèle dans un espace
Copy link to section
Dans la section Modèles , cliquez sur le modèle pour afficher sa page de détails.
Cliquez sur Promouvoir pour l'espace de déploiement " .
Choisis un Espace cible dans la liste ou créez un nouvel espace de déploiement.
Sélectionner Créer un nouvel espace de déploiement.
Tapez un nom pour l'espace de déploiement.
Sélectionnez votre service de stockage.
Sélectionnez votre service d'apprentissage automatique.
Cliquez sur Créer.
Lorsque l'espace de déploiement est créé, fermez la fenêtre.
Sélectionnez l'option Aller au modèle dans l'espace après l'avoir promu .
Cliquez sur Promouvoir.
Tâche 3c: Créer et afficher le déploiement en ligne
Copy link to section
Lorsque le modèle s'affiche dans l'espace de déploiement, cliquez sur Nouveau déploiement.
Sélectionnez En ligne comme Type de déploiement.
Indiquez un nom pour le déploiement.
Cliquez sur Créer.
Attendez que l'état du déploiement passe à Déployé, puis cliquez sur le nom du déploiement.
Affichez les points de terminaison et les extraits de code pour utiliser ce déploiement dans votre application.
Vérifier votre progression
Copy link to section
L'image suivante montre le déploiement en ligne,
Tâche 4 : Noter le modèle
Copy link to section
Dans cette section, vous apprendrez à créer une fonction Python pour traiter les données de notation afin de s'assurer qu'elles sont dans le même format que celui utilisé lors de la formation. À titre de comparaison, vous obtiendrez également un score pour l'ensemble des données brutes en appelant la fonction Python que nous avons créée.
Vous pouvez créer un script Python et l'exécuter localement, ou vous pouvez créer un carnet Jupyter et exécuter le code dans le carnet.
Configuration de l'environnement
Copy link to section
Ce code importe la bibliothèque et le paquetage nécessaires et définit les informations d'identification pour accéder au client de l'API d'apprentissage automatique.
# import the library and package and set the credentialsfrom ibm_watsonx_ai import APIClient
wml_credentials = {
"url": "https://us-south.ml.cloud.ibm.com",
"apikey": "<insert-api-key-here>"
}
client = APIClient(wml_credentials)
client.set.default_space('<insert-deployment-space-id-here>')
software_spec_id = client.software_specifications.get_id_by_name('default_py3.10')
Copy to clipboardCopié dans le presse-papiers
Collez votre IBM Cloud clé API dans le champ apikey.
Collez votre ID d'espace de déploiement. Procédez comme suit pour trouver l'ID de l'espace de déploiement.
Copiez le Space GUID et collez-le à la place de <insert-deployment-space-id-here> dans le code.
Charger l'ensemble des données
Copy link to section
Ce code lit l'ensemble des données stockées dans le concentrateur de ressources.
# read the data setimport pandas as pd
import io
import requests
url = "https://api.dataplatform.cloud.ibm.com/v2/gallery-assets/entries/5fcc01b02d8f0e50af8972dc8963f98e/data"
s = requests.get(url).content
adult_csv = pd.read_csv(io.StringIO(s.decode('utf-8')))
adult_csv.head(5)
Copy to clipboardCopié dans le presse-papiers
Créer l'ensemble de données d'apprentissage
Copy link to section
Ce code choisit 10 lignes aléatoires dans l'ensemble de données pour la notation.
# choose 10 random rows for the test data set
training_data = adult_csv.sample(n=10)
training_data.head(10)
Copy to clipboardCopié dans le presse-papiers
Définir la fonction de préparation des données de formation
Copy link to section
Ce code définit une fonction permettant de charger les données de notation dans leur format brut et de traiter les données exactement comme elles l'ont été pendant la formation. Ensuite, il faut noter les données traitées
Le code effectue le prétraitement suivant sur les données d'entraînement et de test des adultes :
Supprimer les caractéristiques suivantes : "classe ouvrière", "fnlwgt", "éducation", "état civil", "profession", "relation", "gain en capital", "perte en capital", "heures par semaine", "pays d'origine"
Pour plus de détails, voir Kamiran, F. et Calders, T. Data preprocessing techniques for classification without discrimination
Diviser les colonnes "âge" et "éducation" en plusieurs colonnes en fonction de la valeur
# define the preprocess function to prepare the data for scoringdefpreprocess(training_data):
iflen(training_data.columns)==15:
# drop 'fnlwgt' column
training_data = training_data.drop(training_data.columns[2], axis='columns')
training_data.columns = ['age',
'workclass',
'education',
'education-num',
'marital-status',
'occupation',
'relationship',
'race',
'sex',
'capital-gain',
'capital-loss',
'hours-per-week',
'native-country',
'class']
# filter out columns unused in training, and reorder columns
training_dataset = training_data[['race', 'sex', 'age', 'education-num', 'class']]
# map 'sex' and 'race' feature values based on sensitive attribute privileged/unpriveleged groups
training_dataset['sex'] = training_dataset['sex'].map({
' Female': 0,
' Male': 1
})
training_dataset['race'] = training_dataset['race'].map({
' Asian-Pac-Islander': 0,
' Amer-Indian-Eskimo': 0,
' Other': 0,
' Black': 0,
' White': 1
})
# map 'class' values to 0/1 based on positive and negative classification
training_dataset['class'] = training_dataset['class'].map({' <=50K': 0, ' >50K': 1})
training_dataset['age'] = training_dataset['age'].astype(int)
training_dataset['education-num'] = training_dataset['education-num'].astype(int)
# split age column into category columnsfor i inrange(8):
if i != 0:
training_dataset['age' + str(i)] = 0for index, row in training_dataset.iterrows():
if row['age'] < 20:
training_dataset.loc[index, 'age1'] = 1elif ((row['age'] < 30) & (row['age'] >= 20)):
training_dataset.loc[index, 'age2'] = 1elif ((row['age'] < 40) & (row['age'] >= 30)):
training_dataset.loc[index, 'age3'] = 1elif ((row['age'] < 50) & (row['age'] >= 40)):
training_dataset.loc[index, 'age4'] = 1elif ((row['age'] < 60) & (row['age'] >= 50)):
training_dataset.loc[index, 'age5'] = 1elif ((row['age'] < 70) & (row['age'] >= 60)):
training_dataset.loc[index, 'age6'] = 1elif row['age'] >= 70:
training_dataset.loc[index, 'age7'] = 1# split age column into multiple columns
training_dataset['ed6less'] = 0for i inrange(13):
if i >= 6:
training_dataset['ed' + str(i)] = 0
training_dataset['ed12more'] = 0for index, row in training_dataset.iterrows():
if row['education-num'] < 6:
training_dataset.loc[index, 'ed6less'] = 1elif row['education-num'] == 6:
training_dataset.loc[index, 'ed6'] = 1elif row['education-num'] == 7:
training_dataset.loc[index, 'ed7'] = 1elif row['education-num'] == 8:
training_dataset.loc[index, 'ed8'] = 1elif row['education-num'] == 9:
training_dataset.loc[index, 'ed9'] = 1elif row['education-num'] == 10:
training_dataset.loc[index, 'ed10'] = 1elif row['education-num'] == 11:
training_dataset.loc[index, 'ed11'] = 1elif row['education-num'] == 12:
training_dataset.loc[index, 'ed12'] = 1elif row['education-num'] > 12:
training_dataset.loc[index, 'ed12more'] = 1
training_dataset.drop(['age', 'education-num'], axis=1, inplace=True)
# move class column to be last column
label = training_dataset['class']
training_dataset.drop('class', axis=1, inplace=True)
training_dataset['class'] = label
return training_dataset
Copy to clipboardCopié dans le presse-papiersShow more
Traiter les données d'apprentissage
Copy link to section
Ce code utilise la fonction preprocess pour préparer les données.
# use the preprocess function to prepare the data
processed_dataset = preprocess(training_data)
# drop class column
processed_dataset.drop('class', inplace=True, axis='columns')
processed_dataset.head(10)
Ce code envoie une demande de notation au modèle en utilisant le jeu de données scoring_dataset. Vous devrez inclure votre identifiant de déploiement en ligne dans ce code. Procédez comme suit pour trouver l'identifiant de déploiement en ligne.