0 / 0
Torna alla versione inglese della documentazione
Tutorial sull'apprendimento federato XGBoost per l'interfaccia utente
Ultimo aggiornamento: 28 nov 2024
Tutorial sull'apprendimento federato XGBoost per l'interfaccia utente

Questa esercitazione mostra l'uso dell'apprendimento federato con l'obiettivo di addestrare un modello di apprendimento automatico con i dati di diversi utenti senza che questi condividano i loro dati. I passaggi vengono eseguiti in un ambiente a basso codice con l'interfaccia utente e con un framework XGBoost. Utilizzando il set di dati UCI: Adult - Predict income, il modello addestrato prevede se il reddito supera i $50K/yr in base ai dati del censimento. Il set di dati è noto anche come "Census Income".

In questa esercitazione, completerete questi compiti:

Note:

  • Questo è un tutorial passo passo per eseguire un esperimento di apprendimento federato guidato dall'interfaccia utente. Per vedere un esempio di codice per un approccio guidato da API, andate a Federated Learning XGBoost samples.
  • In questo tutorial, admin si riferisce all'utente che avvia l'esperimento di Federated Learning e party si riferisce a uno o più utenti che inviano i risultati dei loro modelli dopo che l'esperimento è stato avviato dall'admin. Mentre l'esercitazione può essere eseguita dall'amministratore e da più parti, un singolo utente può anche completare un'esercitazione completa sia come amministratore che come parte. A scopo dimostrativo, nel seguente tutorial viene presentato un solo set di dati da una parte. ulteriori informazioni su admin e party, vedere Terminologia.

Prerequisiti

Verificare la versione di Python

Assicurarsi di utilizzare la stessa versione di Python dell'amministratore. L'uso di una versione diversa di Python potrebbe causare problemi di compatibilità. Per vedere le versioni di Python compatibili con diversi framework, vedere Framework e compatibilità delle versioni di Python.

Aprire un progetto

  1. Utilizzate un progetto esistente o createne uno nuovo. È necessario avere almeno l'autorizzazione di amministratore.

  2. Associare il servizio watsonx.ai Runtime al progetto.

    1. Nel progetto, fare clic su Gestione > Servizi e integrazioni.
    2. Fare clic su Associa servizio.
    3. Selezionare l'istanza di watsonx.ai Runtime dall'elenco e fare clic su Associa; oppure fare clic su Nuovo servizio se non si dispone di un'istanza.

    Schermata di associazione del servizio

Compito 1: Avviare l'apprendimento federato

In questa sezione si crea, si configura e si avvia un esperimento di apprendimento federato.

Compito 1a: Creare l'asset dell'esperimento di apprendimento federato

  1. Nel progetto, fare clic sulla scheda Assets (Risorse).

  2. Fate clic su Nuova risorsa > Formare modelli su dati distribuiti per creare la risorsa Esperimento di apprendimento federato.

  3. Digitare un nome per l'esperimento e, facoltativamente, una descrizione.

  4. Verificare l'istanza di watsonx.ai Runtime associata in Seleziona un'istanza di apprendimento automatico. Se non si vede associata un'istanza di watsonx.ai Runtime, seguire questi passaggi:

    1. Fare clic su Associa un'istanza del servizio di Machine Learning.

    2. Selezionare un'istanza esistente e fare clic su Associa, oppure creare un nuovo servizio.

    3. Fare clic su Ricarica per visualizzare il servizio associato.

      Schermata di associazione del servizio

    4. Fare clic su Avanti.

Compito 1b: Configurare l'esperimento

  1. Nella pagina Configura, selezionare una specifica hardware.

  2. Nel menu a tendina Machine learning framework, selezionare scikit-learn.

  3. Per il tipo di modello, selezionare XGBoost.

  4. Per il metodo di fusione, selezionare la fusione di classificazione XGBoost.

    Schermata di selezione della classificazione XGBoost

  5. Fare clic su Avanti.

Compito 1c: Definire gli iperparametri

  1. Impostare il valore del campo Rounds su '5.

  2. Accettare i valori predefiniti per gli altri campi.

    Schermata di selezione degli iperparametri

  3. Fare clic su Avanti.

Compito 1d: Selezionare i sistemi di formazione a distanza

  1. Fare clic su Aggiungi nuovi sistemi.

    Schermata di Aggiungi interfaccia utente RTS

  2. Digitare un nome per il sistema di addestramento a distanza.

  3. In Identità consentite, selezionare l'utente che parteciperà all'esperimento, quindi fare clic su Aggiungi. È possibile aggiungere un numero massimo di identità consentite come partecipanti a questa istanza di formazione Federated Experiment. Per questo tutorial, scegliere solo se stessi.
    Qualsiasi identità ammessa deve essere un collaboratore del progetto e avere almeno l'autorizzazione di amministratore. Per aggiungere altri sistemi, ripetere questo passaggio per ogni parte remota che si intende utilizzare.

  4. Al termine, fare clic su Aggiungi sistemi.

    Schermata di creazione di un RTS

  5. Tornare alla pagina Selezionare i sistemi di formazione remota, verificare che il sistema sia selezionato e fare clic su Avanti.

    Schermata di selezione di RTS

Compito 1e: Rivedere le impostazioni

  1. Rivedere le impostazioni, quindi fare clic su Crea.

  2. Osservare lo stato. Lo stato dell'esperimento di Federated Learning è Pending quando viene avviato. Quando l'esperimento è pronto per la connessione degli utenti, lo stato cambia in Setup - Waiting for remote systems. Questa operazione può richiedere alcuni minuti.

  3. Fare clic su Visualizza informazioni di configurazione per scaricare la configurazione del gruppo e lo script del connettore del gruppo da eseguire sul gruppo remoto.

  4. Fare clic sull'icona Scarica configurazione 'Scarica configurazione accanto a ciascuno dei sistemi di formazione remota creati. Salvare lo script del connettore di partito in una directory del computer con il nome:

    remote-test-system-configuration.py
    

    Informazioni sulla configurazione dei sistemi di addestramento remoti

  5. Fare clic su Eseguito.

Icona del punto di controllo Controllare i progressi

L'immagine seguente mostra l'esperimento con lo stato "in attesa di sistemi remoti".
'
'

L'immagine seguente mostra l'esperimento con lo stato "in attesa di sistemi remoti".

Compito 2: addestrare il modello come un partito

Per addestrare il modello, è necessario scaricare i set di dati, quindi modificare ed eseguire gli script python. Seguire questi passaggi per addestrare il modello come un partito:

Compito 2a: Scaricare i set di dati e gli script

  1. Creare una nuova directory locale e spostare lo script del connettore di partito scaricato nel Task 1e nella nuova directory.

  2. Scaricate i seguenti file facendo clic con il tasto destro del mouse sul nome del file, quindi su Salva link con nome. Salvarlo nella stessa directory dello script del connettore di partito.

  3. Verificare che lo script del connettore di partito, il set di dati Adult, il gestore dei dati e il file di configurazione del registro si trovino nella stessa directory. Se si elencano i file della directory, si dovrebbero vedere questi file:

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

Compito 2b: Installare il runtime watsonx.ai

  • Se si utilizza Windows o Linux, eseguire 'pip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]'.

  • Se si utilizza Mac OS con CPU serie M e Conda, scaricare lo script di installazione ed eseguire './install_fl_rt23.1_macos.sh <name for new conda environment>.

Task 2c: Modificare ed eseguire lo script del connettore di partito

Modificare il file del connettore di partito, " remote-test-systm-configuration.py, e apportare le seguenti modifiche:

  1. Aggiungete il seguente codice come seconda riga del file python.

    log_config_path = "log_config.yaml"
    
  2. Fornire le proprie credenziali: Incollare la chiave API dell'utente definito nel sistema di formazione a distanza. Se non si dispone di una chiave API, andare alla pagina delle chiavi API diIBM Cloud, fare clic su Crea chiave API, compilare i campi e fare clic su Crea.

  3. Per il campo party_metadata, fornire il nome, il percorso e le informazioni, che dovrebbero essere simili al seguente testo JSON.

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

    dove:

    • name: nome della classe definita per il gestore dei dati.
    • path: Percorso del gestore dei dati.
    • info: creare una coppia chiave-valore per il tipo di file del set di dati locale o il percorso del set di dati.
  4. Salvare lo script del connettore di partito.

  5. Eseguire lo script del connettore di partito utilizzando 'python o 'python3, a seconda di quello che è stato installato.

    python remote-test-system-configuration.py
    

Dall'interfaccia utente è possibile monitorare lo stato dell'esperimento di Federated Learning. Quando tutte le parti partecipanti si connettono all'aggregatore, quest'ultimo facilita l'addestramento del modello locale e l'aggiornamento del modello globale. Il suo stato è Formazione. È possibile monitorare lo stato dell'esperimento di Federated Learning dall'interfaccia utente. Al termine dell'addestramento, il partito riceve un " Received STOP message sul partito. Ora è possibile salvare il modello addestrato e distribuirlo in uno spazio.

Icona del punto di controllo Controllare i progressi

L'immagine seguente mostra l'esperimento completato.
'

L'immagine seguente mostra l'esperimento completato.

Attività 3: salvare e distribuire il modello online

In questa sezione si apprende come salvare e distribuire il modello addestrato.

Compito 3a: salvare il modello

  1. Nell'esperimento di apprendimento federato completato, fare clic su Salva aggregato.
  2. Nella schermata Salva modello aggregato nel progetto, digitare un nome per il modello. e fare clic su Crea.
  3. Quando viene visualizzata la notifica di creazione del modello, fare clic su Visualizza nel progetto. Se si perde la notifica, fare clic sul nome del progetto per tornare alla scheda delle risorse e fare clic sul nome del modello per visualizzarlo.

Compito 3b: Promuovere il modello in uno spazio

  1. Nella sezione Modelli, fare clic sul modello per visualizzarne i dettagli.
  2. Fare clic su Promuovi per lo spazio di distribuzione 'Promuovi nello spazio di distribuzione.
  3. Scegliere uno spazio di destinazione dall'elenco o creare un nuovo spazio di distribuzione.
    1. Selezionare Crea un nuovo spazio di distribuzione.

    2. Digitare un nome per lo spazio di distribuzione.

    3. Selezionare il servizio di archiviazione.

    4. Selezionare il servizio di apprendimento automatico.

    5. Fare clic su Crea.

    6. Una volta creato lo spazio di distribuzione, chiudere la finestra.

  4. Selezionare l'opzione Vai al modello nello spazio dopo averlo promosso.
  5. Fare clic su Promuovi.

Compito 3c: Creare e visualizzare l'installazione online

  1. Quando il modello viene visualizzato nello spazio di installazione client, fate clic su Nuova installazione client.
  2. Selezionate Online come tipo di distribuzione.
  3. Specificare un nome per l'installazione client.
  4. Fare clic su Crea.
  5. Attendere che lo stato dell'installazione client venga modificato in Distribuito, quindi fare clic sul nome dell'installazione client.
  6. Visualizzare gli endpoint e gli snippet di codice per utilizzare questa distribuzione nella propria applicazione.

Icona del punto di controllo Controllare i progressi

L'immagine seguente mostra l'installazione online,
'

Distribuzione online

Compito 4: valutazione del modello

In questa sezione, si apprende come creare una funzione Python per elaborare i dati dei punteggi e assicurarsi che siano nello stesso formato utilizzato durante l'addestramento. Per un confronto, è possibile ottenere il punteggio del set di dati grezzi richiamando la funzione Python che abbiamo creato.

È possibile creare uno script Python ed eseguirlo localmente, oppure creare un notebook Jupyter ed eseguire il codice nel notebook.

Impostazione dell'ambiente

Questo codice importa la libreria e il pacchetto necessari e imposta le credenziali per accedere al client API di apprendimento automatico.

# 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. Incollare la chiave API di IBM Cloud nel campo " apikey.
  2. Incollare l'ID dello spazio di distribuzione. Seguite questi passaggi per trovare l'ID dello spazio di distribuzione.
    1. Navigare negli spazi di distribuzione.
    2. Aprire lo spazio di distribuzione.
    3. Fare clic sulla scheda Gestione.
    4. Copiare il 'Spazio GUID e incollarlo al posto del '<insert-deployment-space-id-here> nel codice.

Caricare il set di dati

Questo codice legge il set di dati memorizzato nell'hub delle risorse.

# 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)

Creare il set di dati di addestramento

Questo codice sceglie 10 righe casuali dal set di dati per l'assegnazione del punteggio.

# choose 10 random rows for the test data set
training_data = adult_csv.sample(n=10)

training_data.head(10)

Definire la funzione per preparare i dati di tracciamento

Questo codice definisce una funzione per caricare i dati del punteggio nel loro formato grezzo ed elaborare i dati esattamente come è stato fatto durante l'allenamento. Quindi, attribuire un punteggio ai dati elaborati

Il codice esegue la seguente preelaborazione sui dati di addestramento e di test degli adulti:

  • Eliminare le seguenti caratteristiche: 'classe di lavoro', 'classe di età', 'istruzione', 'stato civile', 'occupazione', 'relazione', 'guadagno di capitale', 'perdita di capitale', 'ore settimanali', 'paese di origine'

  • Mappa:

    • i valori di "razza", "sesso" e "classe" a 0/1
    • ' Bianco': 1, ' Amer-Indian-Eskimo': 0, ' Asian-Pac-Islander': 0, ' Nero': 0, ' Altro': 0
    • ' Maschio': 1, ' Femmina': 0

    Ulteriori dettagli in Kamiran, F. e Calders, T. Tecniche di preelaborazione dei dati per la classificazione senza discriminazione

  • Dividere le colonne "età" e "istruzione" in più colonne in base al valore

# 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

Elaborare i dati di formazione

Questo codice utilizza la funzione preprocess per preparare i dati.

# 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)

Creare il carico di dati per la valutazione

Questo codice crea il set di dati di valutazione.

# 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)

Punteggio del modello

Questo codice invia una richiesta di punteggio al modello usando lo scoring_dataset. In questo codice è necessario includere l'ID dell'impiego online. Seguite questi passaggi per trovare l'ID di distribuzione online.

  1. Navigare negli spazi di distribuzione.
  2. Aprire lo spazio di distribuzione.
  3. Fare clic sulla scheda Deployments.
  4. Aprire l'installazione online.
  5. Nel riquadro Informazioni, copiate l'ID dell'installazione client e incollatelo al posto di '<insert-your-online-deployment-id-here> nella cella sottostante.
# 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)

Icona del punto di controllo Controllare i progressi

L'immagine seguente mostra le previsioni e le probabilità della richiesta di punteggio completata.

L'immagine seguente mostra le previsioni e le probabilità della richiesta di punteggio completata.

Passi successivi

Siete pronti a creare il vostro Esperimento Federato personalizzato? Vedere i passaggi di alto livello in Creare un esperimento di apprendimento federato.

Argomento principale: Tutorial ed esempi di apprendimento federato

Ricerca e risposta AI generativa
Queste risposte sono generate da un modello di lingua di grandi dimensioni in watsonx.ai basato sul contenuto della documentazione del prodotto. Ulteriori informazioni