Vérifier la version de Python

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

1. Utilisez un projet existant ou créez-en un nouveau. Vous devez avoir au moins le droit d'administrateur.

2. Associez le service watsonx.ai Runtime à votre projet.

   1. Dans votre projet, cliquez sur Manage > Service & integrations.
   2. Cliquez sur Associer un service.
   3. 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 1a: Créer l'actif de l'expérience d'apprentissage fédéré

1. Dans votre projet, cliquez sur l'onglet Assets.

2. Cliquez sur Nouvelle ressource > Former des modèles sur des données distribuées pour créer la ressource Expérience d'apprentissage fédéré.

3. Saisissez un nom pour votre expérience et éventuellement une description.

4. 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 :

   1. Cliquez sur Associer une instance de service d'Machine Learning.

   2. Sélectionnez une instance existante et cliquez sur Associer, ou créez un nouveau service.

   3. Cliquez sur Recharger pour afficher le service associé.

      

   4. Cliquez sur Suivant.

Tâche 1b: Configurer l'expérience

1. Sur la page Configurer, sélectionnez une spécification matérielle.

2. Dans la liste déroulante Machine learning framework, sélectionnez scikit-learn.

3. Pour le type de modèle, sélectionnez XGBoost.

4. Pour la méthode de fusion, sélectionnez la fusion de classification XGBoost.

   

5. Cliquez sur Suivant.

Tâche 1c: Définir les hyperparamètres

1. Attribuez la valeur " 5 au champ " Rounds ".

2. Acceptez les valeurs par défaut pour les autres champs.

   

3. Cliquez sur Suivant.

Tâche 1d: Sélectionner les systèmes de formation à distance

1. Cliquez sur Ajouter de nouveaux systèmes.

   

2. Saisissez un nom pour votre système de formation à distance.

3. Sous Identités autorisées, sélectionnez l'utilisateur qui participera à l'expérience, 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 l'autorisation de 'Administrateur Ajoutez des systèmes supplémentaires en répétant cette étape pour chaque partie distante que vous prévoyez d'utiliser.

4. Lorsque vous avez terminé, cliquez sur Ajouter des systèmes.

   

5. Revenez à la page Sélectionner les systèmes de formation à distance, vérifiez que votre système est sélectionné, puis cliquez sur Suivant.

   

Tâche 1e: Examiner les paramètres

1. Vérifiez vos paramètres, puis cliquez sur Créer.

2. Voir 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 quelques minutes.

3. Cliquez sur Afficher les informations de configuration pour télécharger la configuration du parti et le script du connecteur de parti que vous pouvez exécuter sur le parti distant.

4. Cliquez sur l'icône Download config ' à côté de chacun des systèmes de formation à distance que vous avez créés. Enregistrez le script du connecteur de parti dans un répertoire de votre machine sous le nom :

   remote-test-system-configuration.py
   

   

5. Cliquez sur Terminé.

Vérifier votre progression

L'image suivante montre l'expérience avec le statut "en attente de systèmes distants".

Tâche 2a: Télécharger les ensembles de données et les scripts

1. Créez un nouveau répertoire local et placez-y le script du connecteur de parti que vous avez téléchargé à la tâche 1e.

2. Téléchargez les fichiers suivants en faisant un clic droit sur le nom du fichier, puis en cliquant sur Enregistrer le lien sous. Sauvegardez-le dans le même répertoire que le script connecteur de parties.

   • Télécharger le gestionnaire de données adult_sklearn_data_handler.py

   • Télécharger le fichier de configuration du journal.

   • Télécharger l'ensemble des données sur les adultes

3. Vérifiez que le script du connecteur de parti, l'ensemble de données Adult, le gestionnaire de données et le fichier de configuration du journal se trouvent dans le même répertoire. Si vous dressez la liste des fichiers du répertoire, vous devriez voir ces fichiers :

   adult.csv
   adult_sklearn_data_handler.py
   remote-test-system-configuration.py
   log_config.yaml
   

Tâche 2b: Installer le moteur d'exécution watsonx.ai

• Si vous utilisez Windows ou Linux, exécutez 'pip 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 et exécutez './install_fl_rt23.1_macos.sh <name for new conda environment>.

Tâche 2c: Modifier et exécuter le script du connecteur de parti

Modifiez le fichier du connecteur de parti, " remote-test-systm-configuration.py, et apportez les modifications suivantes :

1. Ajoutez le code suivant à la deuxième ligne du fichier python.

   log_config_path = "log_config.yaml"
   

2. Fournissez vos informations d'identification : 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.

3. Pour le champ party_metadata, indiquez le nom, le chemin et les informations, qui doivent être similaires au texte JSON suivant.

   party_metadata = {
      wml_client.remote_training_systems.ConfigurationMetaNames.DATA_HANDLER: {
         "info": {"txt_file": "./adult.csv"},
         "name": "AdultSklearnDataHandler",
         "path": "./adult_sklearn_data_handler.py"
      }
   }
   

   où :

   • name: nom de la classe définie 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 le chemin d'accès de votre ensemble de données.

4. Enregistrez le script du connecteur de fête.

5. Exécutez le script du connecteur de parti en utilisant 'python ou 'python3 en fonction de ce que vous avez installé.

   python remote-test-system-configuration.py
   

A partir de l'interface utilisateur, vous pouvez surveiller le statut de votre expérimentation d'apprentissage fédéré. Lorsque toutes les parties participantes se connectent à l'agrégateur, celui-ci facilite l'apprentissage du modèle local et la mise à jour du modèle global. Son statut est en formation. Vous pouvez contrôler l'état de votre expérience Federated Learning à partir de l'interface utilisateur. Lorsque la formation est terminée, le parti reçoit un " Received STOP message sur le parti. Vous pouvez maintenant enregistrer le modèle formé et le déployer dans un espace.

Vérifier votre progression

L'image suivante montre l'expérience réalisée.
'

Tâche 3a: Enregistrez votre modèle

1. Dans votre expérience d'apprentissage fédéré, cliquez sur Enregistrer l'agrégat.
2. Dans l'écran Enregistrer le modèle agrégé dans le projet, saisissez un nom pour le modèle. et cliquez sur Créer.
3. Lorsque la notification de création du modèle s'affiche, cliquez sur Afficher dans le projet. Si vous manquez la notification, cliquez sur le nom du projet pour revenir à l'onglet Actifs et cliquez sur le nom du modèle pour l'afficher.

Tâche 3b: Promouvoir le modèle dans un espace

1. Dans la section Modèles, cliquez sur le modèle pour afficher sa page de détails.
2. Cliquez sur Promouvoir pour l'espace de déploiement " .
3. Choisissez un espace cible dans la liste ou créez un nouvel espace de déploiement.

   1. Sélectionnez Créer un nouvel espace de déploiement.

   2. Saisissez un nom pour l'espace de déploiement.

   3. Sélectionnez votre service de stockage.

   4. Sélectionnez votre service d'apprentissage automatique.

   5. Cliquez sur Créer.

   6. Lorsque l'espace de déploiement est créé, fermez la fenêtre.

4. Sélectionnez l'option Aller au modèle dans l'espace après l'avoir promu.
5. Cliquez sur Promouvoir.

Tâche 3c: Créer et visualiser le déploiement en ligne

1. Lorsque le modèle s'affiche dans l'espace de déploiement, cliquez sur Nouveau déploiement.
2. Sélectionnez En ligne comme Type de déploiement.
3. Indiquez un nom pour le déploiement.
4. Cliquez sur Créer.
5. Attendez que l'état de la répartition devienne Déployé, puis cliquez sur le nom de la répartition.
6. Consultez les points de terminaison et les extraits de code pour utiliser ce déploiement dans votre application.

Vérifier votre progression

L'image suivante montre le déploiement en ligne,
"

Configuration de l'environnement

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 credentials
from 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')

1. Collez votre clé API IBM Cloud dans le champ 'apikey
2. Collez votre ID d'espace de déploiement. Procédez comme suit pour trouver l'ID de l'espace de déploiement.
   1. Accédez à vos espaces de déploiement.
   2. Ouvrez votre espace de déploiement.
   3. Cliquez sur l'onglet Gérer.
   4. Copiez le " GUID de l'espace et collez-le à la place du " <insert-deployment-space-id-here> dans le code.

Charger l'ensemble des données

Ce code lit l'ensemble des données stockées dans le concentrateur de ressources.

# read the data set
import 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)

Créer l'ensemble de données d'apprentissage

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)

Définir la fonction de préparation des données de formation

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"

• Carte :

  • les valeurs "race", "sexe" et "classe" à 0/1
  • blanc" : 1, "Amérindien-Esquimau" : 0, "Asiatique-Pacifique-Islandais" : 0, ' Noir' : 0, ' Autre' : 0
  • homme' : 1, ' Femme' : 0

  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 scoring
def preprocess(training_data):

   if len(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 columns
   for i in range(8):
       if i != 0:
          training_dataset['age' + str(i)] = 0

   for index, row in training_dataset.iterrows():
       if row['age'] < 20:
            training_dataset.loc[index, 'age1'] = 1
       elif ((row['age'] < 30) & (row['age'] >= 20)):
            training_dataset.loc[index, 'age2'] = 1
       elif ((row['age'] < 40) & (row['age'] >= 30)):
            training_dataset.loc[index, 'age3'] = 1
       elif ((row['age'] < 50) & (row['age'] >= 40)):
            training_dataset.loc[index, 'age4'] = 1
       elif ((row['age'] < 60) & (row['age'] >= 50)):
            training_dataset.loc[index, 'age5'] = 1
       elif ((row['age'] < 70) & (row['age'] >= 60)):
            training_dataset.loc[index, 'age6'] = 1
       elif row['age'] >= 70:
            training_dataset.loc[index, 'age7'] = 1

   # split age column into multiple columns
   training_dataset['ed6less'] = 0
   for i in range(13):
       if i >= 6:
          training_dataset['ed' + str(i)] = 0
          training_dataset['ed12more'] = 0

   for index, row in training_dataset.iterrows():
       if row['education-num'] < 6:
            training_dataset.loc[index, 'ed6less'] = 1
       elif row['education-num'] == 6:
            training_dataset.loc[index, 'ed6'] = 1
       elif row['education-num'] == 7:
            training_dataset.loc[index, 'ed7'] = 1
       elif row['education-num'] == 8:
            training_dataset.loc[index, 'ed8'] = 1
       elif row['education-num'] == 9:
            training_dataset.loc[index, 'ed9'] = 1
       elif row['education-num'] == 10:
            training_dataset.loc[index, 'ed10'] = 1
       elif row['education-num'] == 11:
            training_dataset.loc[index, 'ed11'] = 1
       elif row['education-num'] == 12:
            training_dataset.loc[index, 'ed12'] = 1
       elif 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

Traiter les données d'apprentissage

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)

Créer des données utiles pour l'évaluation

Ce code crée l'ensemble des données de notation.

# create data payload for scoring
fields = processed_dataset.columns.values.tolist()
values = processed_dataset.values.tolist()
scoring_dataset = {client.deployments.ScoringMetaNames.INPUT_DATA: [{'fields': fields, 'values': values}]}

import json

print("Scoring data: ")

scoring_formatted = json.dumps(scoring_dataset, indent=2)

print(scoring_formatted)

Evaluer le modèle

Ce code envoie une demande de notation au modèle en utilisant l'ensemble de données de notation. 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.

1. Accédez à vos espaces de déploiement.
2. Ouvrez votre espace de déploiement.
3. Cliquez sur l'onglet Déploiements.
4. Ouvrez votre déploiement en ligne.
5. Dans le volet d'information, copiez l'ID de déploiement et collez-le à la place de " <insert-your-online-deployment-id-here> dans la cellule ci-dessous.

# score data
prediction = client.deployments.score('<insert-your-online-deployment-id-here>', scoring_dataset)

print("Predictions and probabilities: ")

prediction_formatted = json.dumps(prediction, indent=2)

print(prediction_formatted)

Vérifier votre progression

L'image suivante montre les prédictions et les probabilités de la demande de notation complétée.
'

Etapes suivantes

Est-vous prêt à créer votre propre expérimentation fédérée personnalisée ? Voir les étapes de haut niveau dans la création de votre expérience d'apprentissage fédéré.

Sujet parent : Tutoriel et exemples sur l'apprentissage fédéré