Verificar la versión de Python

Asegúrese de que está utilizando la misma versión de Python que el administrador. Si se utiliza una versión diferente de Python se pueden producir problemas de compatibilidad. Para ver las versiones de Python compatibles con diferentes infraestructuras, consulte Compatibilidad de infraestructuras y versión de Python.

Abrir un proyecto

1. Utiliza un proyecto existente o crea uno nuevo. Debes tener al menos permisos de administrador.

2. Asocie el servicio watsonx.ai Runtime a su proyecto.

   1. En su proyecto, haga clic en Gestionar > Servicio e integraciones.
   2. Haga clic en Asociar servicio.
   3. Seleccione su instancia de watsonx.ai Runtime de la lista y haga clic en Asociar; o haga clic en Nuevo servicio si no tiene ninguno para configurar una instancia.

   

Tarea 1a: Crear el activo del experimento de aprendizaje federado

1. En su proyecto, haga clic en la pestaña Activos de su proyecto.

2. Haga clic en Nuevo activo > Entrenar modelos en datos distribuidos para crear el activo Experimento de aprendizaje federado.

3. Escriba un Nombre para su experimento y opcionalmente una descripción.

4. Verifique la instancia asociada de watsonx.ai Runtime en Seleccionar una instancia de aprendizaje automático. Si no ves una instancia de watsonx.ai Runtime asociada, sigue estos pasos:

   1. Haga clic en Asociar una instancia de servicio Machine Learning automático.

   2. Seleccione una instancia existente y haga clic en Asociar, o cree un Nuevo servicio.

   3. Pulse Volver a cargar para ver el servicio asociado.

      

   4. Pulse Siguiente.

Tarea 1b: Configurar el experimento

1. En la página Configurar, seleccione una especificación de Hardware.

2. En el menú desplegable Marco de aprendizaje automático, seleccione scikit-learn.

3. Para el Tipo de modelo, seleccione XGBoost.

4. Para el método de fusión, seleccione Fusión de clasificación XGBoost.

   

5. Pulse Siguiente.

Tarea 1c: Definir los hiperparámetros

1. Establezca el valor del campo Rounds en ' 5.

2. Acepte los valores por defecto para el resto de los campos.

   

3. Pulse Siguiente.

Tarea 1d: Seleccionar sistemas de teleformación

1. Pulse Añadir nuevos sistemas.

   

2. Escriba un nombre para su Sistema de Teleformación.

3. En Identidades permitidas, seleccione el usuario que participará en el experimento y, a continuación, haga clic en Añadir. Puede añadir tantas identidades permitidas como participantes en esta instancia de entrenamiento del experimento federado. Para este tutorial, elige sólo a ti mismo.
   ' Cualquier identidad permitida debe ser colaborador del proyecto y tener al menos permiso de Administrador. Añada sistemas adicionales repitiendo este paso para cada parte remota que desee utilizar.

4. Cuando haya terminado, pulse Añadir sistemas.

   

5. Vuelva a la página Seleccionar sistemas de formación remota, compruebe que su sistema está seleccionado y, a continuación, haga clic en Siguiente.

   

Tarea 1e: Revisar la configuración

1. Revise los valores y pulse Crear.

2. Vigila el estado. El estado del experimento de aprendizaje federado es Pendiente cuando se inicia. Cuando el experimento esté preparado para que las partes se conecten, el estado cambiará a Configuración - Esperando sistemas remotos. Esto puede tardar algunos minutos.

3. Haga clic en Ver información de configuración para descargar la configuración de la parte y el script del conector de la parte que puede ejecutar en la parte remota.

4. Haga clic en el icono Descargar configuración ' ' situado junto a cada uno de los sistemas de teleformación que haya creado. Guarda el script del conector de fiestas en un directorio de tu máquina con el nombre

   remote-test-system-configuration.py
   

   

5. Pulse Finalizado.

' Comprueba tu progreso

La siguiente imagen muestra el experimento con el estado 'esperando sistemas remotos'.

Tarea 2a: Descargar los conjuntos de datos y scripts

1. Cree un nuevo directorio local y coloque en él el script del conector de la fiesta que descargó en la Tarea 1e.

2. Descargue los siguientes archivos haciendo clic con el botón derecho en el nombre del archivo y, a continuación, en Guardar enlace como. Guárdelo en el mismo directorio que el script de conector de la parte.

   • Descargar el manejador de datos adult_sklearn_data_handler.py

   • Descargue el archivo de configuración del registro.

   • Descargar el conjunto de datos sobre adultos

3. Compruebe que tiene el script del conector del partido, el conjunto de datos de adultos, el manejador de datos y el archivo de configuración del registro en el mismo directorio. Si lista los archivos del directorio, debería ver estos archivos:

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

Tarea 2b: Instalar watsonx.ai Runtime

• Si utiliza Windows o Linux, ejecute ' pip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]'.

• Si utilizas Mac OS con CPU de serie M y Conda, descarga el script de instalación y ejecuta ' ./install_fl_rt23.1_macos.sh <name for new conda environment>.

Tarea 2c: Editar y ejecutar el script del conector del partido

Edita el archivo del conector del partido, ' remote-test-systm-configuration.py, y realiza los siguientes cambios:

1. Añade el siguiente código como segunda línea del archivo python.

   log_config_path = "log_config.yaml"
   

2. Proporcione sus credenciales: Pegue la clave API del usuario definido en el sistema de teleformación. Si no dispone de una clave de API, vaya a la página Claves de API deIBM Cloud y haga clic en Crear clave de API, rellene los campos y haga clic en Crear.

3. Para el campo party_metadata, proporcione el nombre, la ruta y la información, que deben ser similares al siguiente texto JSON.

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

   donde:

   • name: Nombre de la clase definida para el manejador de datos.
   • path: Vía de acceso donde se encuentra el manejador de datos.
   • info: Crea un par clave-valor para el tipo de archivo del conjunto de datos local, o la ruta de su conjunto de datos.

4. Guarde el script del conector del partido.

5. Ejecute el script del conector del partido utilizando ' python o ' python3 ' dependiendo de lo que tenga instalado.

   python remote-test-system-configuration.py
   

En la interfaz de usuario puede supervisar el estado de su experimento de Federated Learning. Cuando todas las partes participantes se conectan al agregador, éste facilita la formación del modelo local y la actualización del modelo global. Su estado es Entrenando. Puede supervisar el estado de su experimento de Federated Learning desde la interfaz de usuario. Una vez completado el entrenamiento, el partido recibe un " Received STOP message " en el partido. Ahora, puede guardar el modelo entrenado y desplegarlo en un espacio.

' Comprueba tu progreso

La siguiente imagen muestra el experimento completado.

Tarea 3a: Guarda tu modelo

1. En su experimento de Federated Learning completado, haga clic en Guardar agregado.
2. En la pantalla Guardar modelo agregado en proyecto, escriba un nombre para el modelo. y haga clic en Crear.
3. Cuando vea la notificación de que se ha creado el modelo, haga clic en Ver en proyecto. Si no recibe la notificación, haga clic en el nombre del proyecto para volver a la pestaña de activos y haga clic en el nombre del modelo para verlo.

Tarea 3b: Promocionar el modelo en un espacio

1. En la sección Modelos, haga clic en el modelo para ver su página de detalles.
2. Haga clic en Promover para desplegar el espacio ' .
3. Elija un espacio de destino de la lista o cree un nuevo espacio de despliegue.

   1. Seleccione Crear un nuevo espacio de despliegue.

   2. Escriba un nombre para el espacio de despliegue.

   3. Seleccione su servicio de almacenamiento.

   4. Seleccione su servicio de aprendizaje automático.

   5. Pulse Crear.

   6. Una vez creado el espacio de despliegue, cierre la ventana.

4. Seleccione la opción Ir al modelo en el espacio después de promoverlo.
5. Haga clic en Promover.

Tarea 3c: Crear y visualizar el despliegue en línea

1. Cuando el modelo se visualice dentro del espacio de despliegue, pulse Nuevo despliegue.
2. Seleccione En línea como Tipo de despliegue.
3. Especifique un nombre para el despliegue.
4. Pulse Crear.
5. Espere a que el estado de despliegue cambie a Desplegado y, a continuación, haga clic en el nombre del despliegue.
6. Vea los endpoints y fragmentos de código para utilizar esta implantación en su aplicación.

' Comprueba tu progreso

The following image shows the online deployment,

Configuración del entorno

Este código importa la biblioteca y el paquete necesarios y establece las credenciales para acceder al cliente de la API de aprendizaje automático.

# 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. Pegue su clave API IBM Cloud en el campo ' apikey '.
2. Pegue el ID de su espacio de despliegue. Siga estos pasos para encontrar el ID del espacio de despliegue.
   1. Navegue hasta sus espacios de despliegue.
   2. Abra su espacio de despliegue.
   3. Haz clic en la pestaña Gestionar.
   4. Copie el GUID del espacio y péguelo en lugar de ' <insert-deployment-space-id-here> ' en el código.

Cargar el conjunto de datos

Este código lee el conjunto de datos, que se almacena en el concentrador de recursos.

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

Crear el conjunto de datos de entrenamiento

Este código elige 10 filas aleatorias del conjunto de datos para puntuarlas.

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

training_data.head(10)

Definir la función para preparar los datos de seguimiento

Este código define una función para cargar los datos de puntuación en su formato bruto y procesar los datos exactamente como se hizo durante el entrenamiento. A continuación, puntúa los datos procesados

El código realiza el siguiente preprocesamiento en los datos de entrenamiento y prueba de adultos:

• Elimine las siguientes características: "clase trabajadora", "género", "educación", "estado civil", "ocupación", "relación", "plusvalía", "minusvalía", "horas semanales", "país de origen"

• Correlación:

  • valores de "raza", "sexo" y "clase" a 0/1
  • blanco': 1, 'Amerindio-Esquimal': 0, 'Asiático-Pacífico-Islandés': 0, ' Negro': 0, ' Otro': 0
  • ' Hombre': 1, ' Mujer': 0

  Encontrará más detalles en Kamiran, F. y Calders, T. Data preprocessing techniques for classification without discrimination

• Dividir las columnas "edad" y "educación" en varias columnas en función del valor

# 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

Procesar los datos de entrenamiento

Este código utiliza la función de preprocesamiento para preparar los datos.

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

Crear carga útil de datos para la puntuación

Este código crea el conjunto de datos de puntuación.

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

Puntuar el modelo

Este código envía una solicitud de puntuación al modelo utilizando el conjunto de datos de puntuación. Deberá incluir su ID de despliegue en línea en este código. Siga estos pasos para encontrar el ID de despliegue en línea.

1. Navegue hasta sus espacios de despliegue.
2. Abra su espacio de despliegue.
3. Pulse la pestaña Despliegues.
4. Abra su despliegue en línea.
5. En el panel de información, copie el ID de despliegue y péguelo en lugar de " <insert-your-online-deployment-id-here> " en la celda inferior.

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

' Comprueba tu progreso

La siguiente imagen muestra las predicciones y probabilidades de la solicitud de puntuación completada.

Próximos pasos

¿Está preparado para crear su propio experimento de Federated Learning? Consulte los pasos generales en Creación de su experimento de aprendizaje federado.

Tema principal: Tutorial y ejemplos de Federated Learning