Überprüfen Sie die Python Ausführung

Stellen Sie sicher, dass Sie dieselbe Python-Version wie der Administrator verwenden. Die Verwendung einer anderen Python-Version kann zu Kompatibilitätsproblemen führen. Informationen zu Python-Versionen, die mit verschiedenen Frameworks kompatibel sind, finden Sie im Abschnitt zur Kompatibilität zwischen Frameworks und Python-Versionen.

Ein Projekt öffnen

1. Verwenden Sie ein vorhandenes Projekt oder erstellen Sie ein neues. Sie müssen mindestens über Administratorberechtigung verfügen.

2. Verknüpfen Sie den watsonx.ai Runtime-Dienst mit Ihrem Projekt.

   1. Klicken Sie in Ihrem Projekt auf Verwalten > Service & Integrationen.
   2. Klicken Sie auf Service zuordnen.
   3. Wählen Sie Ihre watsonx.ai Runtime-Instanz aus der Liste aus und klicken Sie auf Assoziieren; oder klicken Sie auf Neuer Dienst, wenn Sie noch keinen haben, um eine Instanz einzurichten.

   

Aufgabe 1a: Erstellen des Federated Learning-Experiment-Assets

1. Klicken Sie in Ihrem Projekt auf das Vermögenswerte Registerkarte in Ihrem Projekt.

2. Klicken Neues Asset > Modelle anhand verteilter Daten trainieren um das Federated Learning-Experiment-Asset zu erstellen.

3. Geben Sie einen Namen für Ihr Experiment und optional eine Beschreibung ein.

4. Überprüfen Sie die zugehörige watsonx.ai Runtime Instanz unter Wählen Sie eine Machine Learning Instanz. Wenn Sie keine zugehörige watsonx.ai Runtime-Instanz sehen, folgen Sie diesen Schritten:

   1. Klicken Sie auf Machine Learning -Serviceinstanz zuordnen.

   2. Wählen Sie eine vorhandene Instanz aus und klicken Sie auf Zuordnenoder erstellen Sie einen neuen Service.

   3. Klicken Sie auf Neu laden, um den zugehörigen Service anzuzeigen.

      

   4. Klicken Sie auf Weiter.

Aufgabe 1b: Konfigurieren des Experiments

1. Wählen Sie auf der Seite Konfigurieren eine Hardwarespezifikationaus.

2. Wählen Sie im Dropdown-Menü Machine Learning framework die Option scikit-learnaus.

3. Wählen Sie als Modelltyp XGBoostaus.

4. Wählen Sie für die Fusionsmethode XGBoost classification fusionaus.

   

5. Klicken Sie auf Weiter.

Aufgabe 1c: Definieren Sie die Hyperparameter

1. Setzen Sie den Wert für das Feld Runden auf 5.

2. Akzeptieren Sie die Standardwerte für die restlichen Felder.

   

3. Klicken Sie auf Weiter.

Aufgabe 1d: Ausgewählte Fernschulungssysteme

1. Klicken Sie auf Neue Systeme hinzufügen.

   

2. Geben Sie einen Namen für Ihr Remote-Trainingssystem ein.

3. Wählen Sie unter Zulässige Identitätenden Benutzer aus, der am Experiment teilnehmen soll, und klicken Sie anschließend auf Add. Sie können so viele zulässige Identitäten wie Teilnehmer in dieser Trainingsinstanz für das Federated Learning-Experiment hinzufügen. Wählen Sie für dieses Tutorial nur sich selbst.
   Alle erlaubten Identitäten müssen Mitarbeiter des Projekts sein und mindestens Administrator Erlaubnis. Fügen Sie weitere Systeme hinzu, indem Sie diesen Schritt für jeden fernen Teilnehmer, der verwendet werden soll, wiederholen.

4. Klicken Sie anschließend auf Systeme hinzufügen.

   

5. Kehren Sie zur Seite Ferne Trainingssysteme auswählen zurück, prüfen Sie, ob Ihr System ausgewählt ist, und klicken Sie anschließend auf Next.

   

Aufgabe 1e: Überprüfen der Einstellungen

1. Überprüfen Sie Ihre Einstellungen und klicken Sie dann auf Erstellen.

2. Beobachten Sie den Status. Wenn Ihr Federated Learning-Experiment gestartet wird, hat es den Status Anstehend. Sobald Parteien eine Verbindung zu Ihrem Experiment herstellen können, ändert sich der Status in Einrichtung – Warten auf ferne Systeme. Dieser Vorgang kann einige Minuten dauern.

3. Klicken Anzeigen von Setup-Informationen um die Partykonfiguration und das Partyconnector-Skript herunterzuladen, das Sie auf der Remote-Party ausführen können.

4. Klicken Sie auf das Konfiguration herunterladen-Symbol neben jedem der von Ihnen erstellten Fernunterrichtssysteme. Speichern Sie das Party-Connector-Skript in einem Verzeichnis auf Ihrem Computer mit dem Namen:

   remote-test-system-configuration.py
   

   

5. Klicken Sie auf Fertig.

Überprüfen Sie Ihren Fortschritt

Das folgende Bild zeigt das Experiment mit dem Status „Warten auf Remote-Systeme“.

Aufgabe 2a: Herunterladen der Datensätze und Skripte

1. Erstellen Sie ein neues lokales Verzeichnis und verschieben Sie das Party Connector-Skript, das Sie in Task heruntergeladen haben 1e in das neue Verzeichnis.

2. Laden Sie die folgenden Dateien herunter, indem Sie mit der rechten Maustaste auf den Dateinamen klicken und dann auf Verknüpfung speichern unter. Speichern Sie in demselben Verzeichnis wie das Verbindungsscript der Partei.

   • Laden Sie den Datenhandler adult_sklearn_data_handler.py herunter

   • Laden Sie die Protokollkonfigurationsdatei herunter .

   • Laden Sie den Datensatz für Erwachsene herunter

3. Überprüfen Sie, ob Sie das Party Connector-Skript haben, das Erwachsene Datensatz, Datenhandler und Protokollkonfigurationsdatei im selben Verzeichnis. Wenn Sie die Dateien im Verzeichnis auflisten, sollten Sie diese Dateien sehen:

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

Aufgabe 2b: watsonx.ai Runtime installieren

• Wenn Sie Windows verwenden oder Linux, laufenpip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]' .

• Wenn Sie Mac OS mit M-Serie CPU und Conda verwenden, laden Sie die Installationsskript und dann laufen./install_fl_rt23.1_macos.sh <name for new conda environment> .

Aufgabe 2c: Bearbeiten und Ausführen des Party-Connector-Skripts

Bearbeiten Sie die Party-Connector-Datei.remote-test-systm-configuration.py und nehmen Sie die folgenden Änderungen vor:

1. Fügen Sie den folgenden Code als zweite Zeile der Python-Datei hinzu.

   log_config_path = "log_config.yaml"
   

2. Geben Sie Ihre Anmeldeinformationen ein: Fügen Sie den API-Schlüssel für den im Remote-Trainingssystem definierten Benutzer ein. Wenn Sie keinen API-Schlüssel haben, rufen Sie die Seite IBM Cloud -API-Schlüssel“ auf, klicken Sie auf „API-Schlüssel erstellen“ , füllen Sie die Felder aus und klicken Sie auf „Erstellen“ .

3. Für die Party-Metadaten Geben Sie im Feld Name, Pfad und Informationen ein, die dem folgenden JSON-Text ähneln sollten.

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

   Dabei gilt:

   • name: Der für den Datenhandler definierte Klassenname.
   • path: Der Pfad, in dem sich der Datenhandler befindet.
   • info: Erstellen Sie ein Schlüssel/Wert-Paar für den Dateityp des lokalen Datasets oder den Pfad Ihres Datasets.

4. Speichern Sie das Party-Connector-Skript.

5. Führen Sie das Party-Connector-Skript aus, indem Sie entwederpython oderpython3 je nachdem was du installiert hast.

   python remote-test-system-configuration.py
   

In der Benutzerschnittstelle können Sie den Status des Experiments für föderiertes überwachen. Wenn alle teilnehmenden Parteien eine Verbindung zum Aggregator herstellen, vereinfacht der Aggregator das lokale Modelltraining und die globale Modellaktualisierung. Sein Status lautet Training. Sie können den Status Ihres Experiments für föderiertes Lernen über die Benutzerschnittstelle überwachen. Nach Abschluss der Ausbildung erhält die Gruppe eineReceived STOP message auf der Party. Jetzt können Sie das trainierte Modell speichern und in einem Bereich bereitstellen.

Überprüfen Sie Ihren Fortschritt

Das folgende Bild zeigt das abgeschlossene Experiment.

Aufgabe 3a: Speichern Sie Ihr Modell

1. Klicken Sie in Ihrem abgeschlossenen Federated Learning-Experiment auf Aggregat speichern.
2. Auf der Aggregiertes Modell im Projekt speichern Geben Sie auf dem Bildschirm einen Namen für das Modell ein. und klicken Sie auf Erstellen.
3. Wenn Sie die Benachrichtigung sehen, dass das Modell erstellt wurde, klicken Sie auf Im Projekt anzeigen. Wenn Sie die Benachrichtigung verpassen, klicken Sie auf den Projektnamen, um zur Registerkarte „Assets“ zurückzukehren, und klicken Sie auf den Modellnamen, um ihn anzuzeigen.

Aufgabe 3b: Befördern Sie das Modell in einen Bereich

1. Klicken Sie im Abschnitt Modelle auf das Modell, um seine Detailseite anzuzeigen.
2. Klicken Sie auf „In Bereitstellungsbereich befördern“.
3. Wähle ein Zielraum aus der Liste oder erstellen Sie einen neuen Bereitstellungsbereich.

   1. Wählen Einen neuen Bereitstellungsbereich erstellen.

   2. Geben Sie einen Namen für den Bereitstellungsbereich ein.

   3. Wählen Sie Ihren Speicherdienst aus.

   4. Wählen Sie Ihren Machine-Learning-Dienst aus.

   5. Klicken Sie auf Erstellen.

   6. Wenn der Bereitstellungsbereich erstellt ist, schließen Sie das Fenster.

4. Wählen Sie die Option Nach dem Hochstufen zum Modell im Bereich wechseln aus.
5. Klicken Sie auf Hochstufen.

Aufgabe 3c: Erstellen und Anzeigen der Onlinebereitstellung

1. Wenn das Modell im Bereitstellungsbereich angezeigt wird, klicken Sie auf Neue Bereitstellung.
2. Wählen Sie Online als Bereitstellungstyp aus.
3. Geben Sie einen Namen für die Bereitstellung an.
4. Klicken Sie auf Erstellen.
5. Warten Sie, bis sich der Bereitstellungsstatus ändert in Bereitgestellt und klicken Sie dann auf den Bereitstellungsnamen.
6. Sehen Sie sich die Endpunkte und Codeausschnitte an, um diese Bereitstellung in Ihrer Anwendung zu verwenden.

Überprüfen Sie Ihren Fortschritt

Das folgende Bild zeigt die Online-Bereitstellung.

Umgebung einrichten

Dieser Code importiert die erforderliche Bibliothek und das Paket und legt die Anmeldeinformationen für den Zugriff auf den API-Client für maschinelles Lernen fest.

# 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. Fügen Sie Ihren IBM Cloud API-Schlüssel in das Feld apikey ein.
2. Fügen Sie die ID Ihres Bereitstellungsraums ein. Gehen Sie folgendermaßen vor, um die ID des Bereitstellungsraums zu ermitteln.
   1. Navigieren Sie zu Ihren Entwicklungsräumen.
   2. Öffnen Sie Ihren Bereitstellungsraum.
   3. Klicken Sie auf die Registerkarte Verwaltung.
   4. Kopieren Sie die Space GUID, und fügen Sie sie anstelle von <insert-deployment-space-id-here> in den Code ein.

Laden Sie den Datensatz

Dieser Code liest den Datensatz, der in der Ressourcendrehscheibe gespeichert ist.

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

Erstellen Sie den Trainingsdatensatz

Dieser Code wählt 10 zufällige Zeilen aus dem Datensatz für die Bewertung aus.

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

training_data.head(10)

Definieren Sie die Funktion zur Aufbereitung der Traing-Daten

Dieser Code definiert eine Funktion, die die Bewertungsdaten in ihrem Rohformat lädt und die Daten genau so verarbeitet, wie es beim Training geschehen ist. Anschließend werden die verarbeiteten Daten bewertet

Der Code führt die folgenden Vorverarbeitungen an den Trainings- und Testdaten für Erwachsene durch:

• Streichen Sie die folgenden Merkmale: 'Arbeitsklasse', 'fnlwgt', 'Bildung', 'Familienstand', 'Beruf', 'Beziehung', 'Kapitalgewinn', 'Kapitalverlust', 'Wochenstunden', 'Heimatland'

• Karte:

  • Werte für "Ethnie", "Geschlecht" und "Klasse" auf 0/1
  • ' Weiß': 1, ' Amer-Indianer-Eskimo': 0, ' Asiatisch-Pazifischer-Isländer': 0, ' Schwarz': 0, ' Andere': 0
  • ' Männlich': 1, ' Weiblich': 0

  Weitere Einzelheiten finden Sie in Kamiran, F. und Calders, T. Data preprocessing techniques for classification without discrimination

• Aufteilung der Spalten "Alter" und "Bildung" in mehrere Spalten auf der Grundlage des Wertes

# 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

Verarbeiten der Trainingsdaten

Dieser Code verwendet die Vorverarbeitungsfunktion, um die Daten vorzubereiten.

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

Daten-Payload für Scoring erstellen

Dieser Code erstellt den Scoring-Datensatz.

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

Das Modell scoren

Dieser Code sendet eine Scoring-Anfrage an das Modell unter Verwendung des scoring_dataset. In diesem Code müssen Sie Ihre Online-Deployment-ID angeben. Gehen Sie folgendermaßen vor, um die Online-Bereitstellungs-ID zu finden.

1. Navigieren Sie zu Ihren Entwicklungsräumen.
2. Öffnen Sie Ihren Bereitstellungsraum.
3. Klicken Sie auf die Registerkarte Bereitstellungen.
4. Öffnen Sie Ihre Online-Bereitstellung.
5. Kopieren Sie im Bereich Informationen die Einsatz-ID und fügen Sie sie anstelle von <insert-your-online-deployment-id-here> in die Zelle darunter ein.

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

Überprüfen Sie Ihren Fortschritt

Die folgende Abbildung zeigt die Vorhersagen und Wahrscheinlichkeiten aus der abgeschlossenen Scoring-Anfrage.

Nächste Schritte

Sind Sie bereit, Ihr eigenes angepasstes Federated Learning-Experiment zu erstellen? Dann befolgen Sie die allgemeinen Schritte unter Federated Learning-Experiment erstellen.

Übergeordnetes Thema: Lernprogramm und Beispiele für Federated Learning