Verificare il Python versione

Assicurati di utilizzare la stessa versione di Python dell'amministratore. L'utilizzo di una versione di Python differente potrebbe causare problemi di compatibilità. Per vedere le versioni Python compatibili con diversi framework, vedi Frameworks e Python version compatibility.

Aprire un progetto

1. Utilizzare un progetto esistente o crearne uno nuovo. È necessario disporre almeno dell'autorizzazione di amministratore.

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

   1. Nel tuo progetto, fai clic su Manage> Service & integrations.
   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.

   

Compito 1a: Crea la risorsa dell'esperimento di apprendimento federato

1. Nel tuo progetto, fai clic su Risorse scheda nel tuo progetto.

2. Clic Nuova risorsa > Addestra modelli su dati distribuiti per creare la risorsa dell'esperimento di apprendimento federato.

3. Immettere 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 Machine Learning.

   2. Selezionare un'istanza esistente e fare clic su Associaoppure creare un Nuovo servizio.

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

      

   4. Fare clic su Avanti.

Compito 1b: Configura l'esperimento

1. Nella pagina Configura , selezionare Specifica hardware.

2. Nel menu a discesa Machine learning framework , seleziona scikit-learn.

3. Per il Tipo di modello, selezionare XGBoost.

4. Per il Metodo di fusione, selezionare Fusione 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 il resto dei campi.

   

3. Fare clic su Avanti.

Compito 1d: Seleziona i sistemi di formazione a distanza

1. Fare clic su Aggiungi nuovi sistemi.

   

2. Digita un nome per il tuo sistema di formazione remota.

3. In Identità consentite, selezionare l'utente che parteciperà all'esperimento e fare clic su Aggiungi. È possibile aggiungere un numero di identità consentite pari al numero di partecipanti in questa istanza di addestramento Esperimento federato. Per questo tutorial, scegli solo te stesso.
   Qualsiasi identità consentita deve essere un collaboratore del progetto e avere almeno Ammin autorizzazione. Aggiungi ulteriori sistemi ripetendo questo passaggio per ogni partecipante remoto che intendi utilizzare.

4. Una volta terminato, fare clic su Aggiungi sistemi.

   

5. Tornare alla pagina Seleziona sistemi di addestramento remoti , verificare che il sistema sia selezionato e fare clic su Avanti.

   

Compito 1e: Rivedi le impostazioni

1. Rivedere le proprie impostazioni e fare clic su Crea.

2. Guarda lo stato. Lo stato dell'esperimento Federated Learning è In sospeso quando viene avviato. Quando l'esperimento è pronto per la connessione delle parti, lo stato cambia in Impostazione - In attesa di sistemi remoti. Questa operazione potrebbe richiedere alcuni minuti.

3. Clic Visualizza le informazioni di configurazione per scaricare la configurazione del party e lo script del connettore del party che è possibile eseguire sul party remoto.

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

   remote-test-system-configuration.py
   

   

5. Fare clic su Eseguito.

Controllare i progressi compiuti

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

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

1. Crea una nuova directory locale e inserisci sposta lo script del connettore del party scaricato in Task 1e nella nuova directory.

2. Scaricare i seguenti file facendo clic con il pulsante destro del mouse sul nome del file, quindi fare clic su Salva collegamento come. Salvalo nella stessa directory dello script del connettore del party.

   • Scaricare il gestore di dati adult_sklearn_data_handler.py

   • Scaricare il file di configurazione del registro.

   • Scarica il set di dati sugli adulti

3. Verificare di disporre dello script del connettore del party, the Adulto set di dati, il gestore dati e il file di configurazione del log nella stessa directory. Se elenchi i file nella directory, dovresti 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 utilizzi Windows o Linux, correrepip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]' .

• Se utilizzi Mac OS con CPU serie M e Conda, scarica il file script di installazione e poi corri./install_fl_rt23.1_macos.sh <name for new conda environment> .

Compito 2c: Modifica ed esegui lo script del connettore del party

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

1. Aggiungi il seguente codice come seconda riga del file Python.

   log_config_path = "log_config.yaml"
   

2. Fornisci le tue credenziali: incolla la chiave API per l'utente definito nel sistema di formazione remota. 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 party_metadata campo, 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: il nome classe definito per il gestore dati.
   • path: percorso dell'ubicazione del gestore dati.
   • info: creare una coppia di valori chiave per il tipo di file del dataset locale o il percorso del dataset.

4. Salva lo script del connettore del party.

5. Esegui lo script del connettore del party utilizzando uno dei duepython Opython3 a seconda di cosa hai installato.

   python remote-test-system-configuration.py
   

Dall'interfaccia utente puoi monitorare lo stato del tuo esperimento di apprendimento federato. Quando tutte le parti partecipanti si collegano all'aggregatore, l'aggregatore facilita l'addestramento del modello locale e l'aggiornamento del modello globale. Lo stato è Formazione. È possibile monitorare lo stato dell'esperimento Federated Learning dall'interfaccia utente. Una volta completata la formazione, il gruppo riceve unReceived STOP message sulla festa. Ora, puoi salvare il modello preparato e distribuirlo in uno spazio.

Controllare i progressi

L'immagine seguente mostra l'esperimento completato.

Compito 3a: Salva il tuo modello

1. Nell'esperimento di Federated Learning completato, fai clic su Salva aggregato.
2. Sul Salva il modello aggregato nel progetto schermata, digitare un nome per il modello. e fare clic Creare.
3. Quando vedi la notifica che il modello è stato creato, fai clic su Visualizza nel progetto. Se perdi la notifica, fai clic sul nome del progetto per tornare alla scheda delle risorse e fai clic sul nome del modello per visualizzarlo.

Compito 3b: Promuovere il modello in uno spazio

1. Nella sezione Modelli , fare clic sul modello per visualizzare la pagina dei dettagli.
2. Fare clic su Promuovi per lo spazio di distribuzione '.
3. Scegli un 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. Seleziona il tuo servizio di archiviazione.

   4. Seleziona il tuo servizio di machine learning.

   5. Fare clic su Crea.

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

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

Compito 3c: Creare e visualizzare la distribuzione online

1. Quando il modello viene visualizzato nello spazio di distribuzione, fare clic su Nuova distribuzione.
2. Selezionare In linea come Tipo di distribuzione.
3. Specificare un nome per la distribuzione.
4. Fare clic su Crea.
5. Attendi che lo stato della distribuzione venga modificato in Distribuito, quindi fare clic sul nome della distribuzione.
6. Visualizza gli endpoint e gli snippet di codice per utilizzare questa distribuzione nella tua applicazione.

Controllare i progressi

L'immagine seguente mostra la distribuzione online,

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. Navigate verso i vostri spazi di distribuzione.
   2. Aprire lo spazio di distribuzione.
   3. Fare clic sulla scheda Gestione.
   4. Copiare il GUID dello spazio e incollarlo al posto di <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 pre-elaborazione 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 utilizzando lo scoring_dataset. In questo codice è necessario includere l'ID dell'impiego online. Seguite questi passaggi per trovare l'ID di distribuzione online.

1. Navigate verso i vostri spazi di distribuzione.
2. Aprire lo spazio di distribuzione.
3. Fate clic sulla scheda Deployments.
4. Aprire l'installazione online.
5. Nel riquadro Informazioni, copiare l'Identificazione dell'installazione e incollarlo 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)

Controllare i progressi

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

Passi successivi

Pronto a creare il tuo esperimento federato personalizzato? Guarda i passaggi di alto livello Creazione del tuo esperimento di apprendimento federato.

Argomento principale: Esercitazione ed esempi di apprendimento federato