Verificar el Python versión

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. Utilice un proyecto existente o cree uno nuevo. Debe tener al menos permiso de administrador.

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

   1. En el proyecto, pulse Gestionar > Servicio e integraciones.
   2. Pulse 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 Activos pestaña en su proyecto.

2. Hacer clic Nuevo activo > Entrenar modelos en datos distribuidos para crear el activo del experimento de aprendizaje federado.

3. Escriba un Nombre para el 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. Pulse Asociar una instancia de servicio de Machine Learning.

   2. Seleccione una instancia existente y pulse Asociaro 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 desplegable Infraestructura 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 de XGBoost.

   

5. Pulse Siguiente.

Tarea 1c: Definir los hiperparámetros.

1. Establezca el valor del campo Rondas en 5.

2. Acepte los valores predeterminados para el resto de los campos.

   

3. Pulse Siguiente.

Tarea 1d: Seleccionar sistemas de entrenamiento remoto

1. Pulse Añadir nuevos sistemas.

   

2. Escriba un nombre para su sistema de capacitación remota.

3. En Identidades permitidas, seleccione el usuario que participará en el experimento y, a continuación, pulse Añadir. Puede añadir tantas identidades permitidas como participantes en esta instancia de entrenamiento del experimento federado. Para este tutorial, elige solo a ti mismo.
   Cualquier identidad permitida debe ser colaboradora del proyecto y tener al menos Administración permiso. 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 entrenamiento remotos , verifique que el sistema está seleccionado y, a continuación, pulse Siguiente.

   

Tarea 1e: Revisar la configuración

1. Revise los valores y pulse Crear.

2. Observe 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. Esta acción puede tardar varios minutos.

3. Hacer clic 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 config situado junto a cada uno de los sistemas de formación remota que haya creado. Guarde el script del conector de grupo en un directorio de su 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: Descargue los conjuntos de datos y los scripts

1. Cree un nuevo directorio local y mueva el script del conector de grupo que descargó en Task 1e en el nuevo directorio.

2. Descargue los siguientes archivos haciendo clic derecho en el nombre del archivo y luego haga clic 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. Verifique que tenga el script del conector de parte, el Adulto conjunto de datos, el controlador de datos y el archivo de configuración de registro en el mismo directorio. Si enumera los archivos en el 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 está utilizando Windows o Linux, correrpip install 'ibm_watsonx_ai[fl-rt23.1-py3.10]' .

• Si está utilizando Mac OS con CPU de la serie M y Conda, descargue el guión de instalación y luego correr./install_fl_rt23.1_macos.sh <name for new conda environment> .

Tarea 2c: Editar y ejecutar el script del conector de grupo

Edite el archivo del conector de grupo,remote-test-systm-configuration.py y realice los siguientes cambios:

1. Agregue 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 capacitación remota. 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 fiesta_metadatos, 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 clase definido para el manejador de datos.
   • path: Vía de acceso donde se encuentra el manejador de datos.
   • info: cree un par de clave-valor para el tipo de archivo del conjunto de datos local o la vía de acceso del conjunto de datos.

4. Guarde el script del conector de grupo.

5. Ejecute el script del conector de grupo utilizando cualquiera de los dospython opython3 dependiendo de lo que tengas 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, el agregador facilita el entrenamiento del modelo local y la actualización del modelo global. Su estado es Entrenando. Puede supervisar el estado del experimento de aprendizaje federado desde la interfaz de usuario. Cuando se completa el entrenamiento, el grupo recibe unaReceived STOP message en la fiesta. 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 aprendizaje federado completado, haga clic en Guardar agregado.
2. Sobre el Guardar modelo agregado en proyecto pantalla, escriba un nombre para el modelo. y haga clic Crear.
3. Cuando vea la notificación de que se creó 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 , pulse el modelo para ver su página de detalles.
2. Haga clic en Promover para desplegar el espacio ' .
3. Escoge un Espacio objetivo de la lista o cree un nuevo espacio de implementación.

   1. Seleccionar Crear un nuevo espacio de implementación.

   2. Escriba un nombre para el espacio de implementación.

   3. Selecciona tu servicio de almacenamiento.

   4. Seleccione su servicio de aprendizaje automático.

   5. Pulse Crear.

   6. Cuando se cree el espacio de implementación, cierre la ventana.

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

Tarea 3c: Crear y ver la implementación 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 implementación cambie a Desplegada y luego haga clic en el nombre de la implementación.
6. Vea los puntos finales y los fragmentos de código para usar esta implementación en su aplicación.

' Comprueba tu progreso

La siguiente imagen muestra la implementación en línea,

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 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 Administrar.
   4. Copie el Space GUID, 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. Técnicas de preprocesamiento de datos para la clasificación sin discriminación

• 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 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 padre: Guía de aprendizaje y ejemplos de Federated Learning