Vérifiez le Python version

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 disposer au moins des droits d'administrateur.

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

   1. Dans votre projet, cliquez sur Gérer > Services & intégrations.
   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 Expérience d'apprentissage fédéré

1. Dans votre projet, cliquez sur le Actifs onglet dans votre projet.

2. 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é.

3. Entrez un nom pour votre expérimentation 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 Machine Learning.

   2. Sélectionnez une instance existante et cliquez sur Associerou 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 Fusion de classification XGBoost.

   

5. Cliquez sur Suivant.

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

1. Définissez la valeur de la zone Rondes sur 5.

2. Acceptez les valeurs par défaut pour le reste des zones.

   

3. Cliquez sur Suivant.

Tâche 1d: Sélectionnez des systèmes de formation à distance

1. Cliquez sur Ajouter de nouveaux systèmes.

   

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

3. 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.

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

   

5. 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

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

2. 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.

3. 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.

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

   

5. Cliquez sur Terminé.

Vérifiez vos progrès

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

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

1. 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.

2. 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.

   • 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 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 :

   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, 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

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

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

   log_config_path = "log_config.yaml"
   

2. 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.

3. Pour le party_metadonnées, 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 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.

4. Enregistrez le script du connecteur de partie.

5. 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
   

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

L'image suivante montre l'expérience terminée.

Tâche 3a: Enregistrez votre modèle

1. Dans votre expérience d’apprentissage fédéré terminée, cliquez sur Enregistrer l'agrégat.
2. Sur le Enregistrer le modèle agrégé dans le projet écran, saisissez un nom pour le modèle. et cliquez Créer.
3. 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

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. Choisis un Espace cible dans la liste ou créez un nouvel espace de déploiement.

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

   2. Tapez 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 afficher 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 du déploiement passe à Déployé, puis cliquez sur le nom du déploiement.
6. Affichez 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 IBM Cloud clé API 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. Naviguez vers vos espaces de déploiement.
   2. Ouvrez votre espace de déploiement.
   3. Cliquez sur l'onglet Gestion.
   4. Copiez le Space GUID et collez-le à la place de <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 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.

1. Naviguez vers 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 Information, copiez le Deployment ID 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é.

Rubrique parent: Tutoriel et exemples d'apprentissage fédéré