Container Service for Kubernetes:Cloud Native AI Suite developer guide

Contexto

El paquete de IA nativa de la nube ofrece componentes que se despliegan de forma independiente (K8s Helm charts) para acelerar la ingeniería de IA.

Requisitos previos

Asegúrese de que un administrador haya completado las siguientes tareas:

• Un Kubernetes cluster is created.

  • Cada nodo del clúster tiene como mínimo 300 GB de espacio en disco.

  • Para obtener los mejores resultados de aceleración de datos, utilice cuatro instancias, cada una equipada con ocho GPU V100.

  • Para lograr los mejores resultados de detección de topología, utilice dos instancias V100.

• El cloud-native AI suite is installed.

• Tiene acceso al AI Dashboard.

• Tiene acceso al AI Developer Console.

  Nota

  A partir del 22 de enero de 2025, la AI Console de Alibaba Cloud, que incluye AI Developer Console y AI Dashboard, será una función disponible solo por lista blanca. Este cambio no afecta los despliegues existentes. Los usuarios que no estén en la lista blanca pueden instalar y configurar AI Console desde la comunidad de código abierto. Para más detalles, consulte AI Console de código abierto.

• Se descargó el conjunto de datos Fashion MNIST y uploaded to OSS.

• Cuenta con la URL del repositorio de Git, el nombre de usuario y la contraseña del código de prueba.

• Un cliente kubectl está connected to the cluster.

• El Arena CLI is configured.

Entorno del tutorial

Objetivos

Paso 1: crear una cuenta y asignar recursos

Paso 2: crear un conjunto de datos

Los administradores gestionan los conjuntos de datos. Este ejemplo utiliza el conjunto de datos fashion-mnist.

Paso 1: crear el conjunto de datos fashion-mnist

1. Cree el archivo fashion-mnist.yaml con base en el siguiente ejemplo de YAML.

   Este ejemplo crea un volumen persistente (PV) y una solicitud de volumen persistente (PVC) de tipo OSS.

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     name: fashion-demo-pv
   spec:
     accessModes:
     - ReadWriteMany
     capacity:
       storage: 10Gi
     csi:
       driver: ossplugin.csi.alibabacloud.com
       volumeAttributes:
         bucket: fashion-mnist
         otherOpts: ""
         url: oss-cn-beijing.aliyuncs.com
         akId: "AKID"
         akSecret: "AKSECRET"
       volumeHandle: fashion-demo-pv
     persistentVolumeReclaimPolicy: Retain
     storageClassName: oss
     volumeMode: Filesystem
   ---
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: fashion-demo-pvc
     namespace: demo-ns
   spec:
     accessModes:
     - ReadWriteMany
     resources:
       requests:
         storage: 10Gi
     selector:
       matchLabels:
         alicloud-pvname: fashion-demo-pv
     storageClassName: oss
     volumeMode: Filesystem
     volumeName: fashion-demo-pv

2. Cree el conjunto de datos fashion-mnist.

   kubectl create -f fashion-mnist.yaml

3. Consulte el estado del PV y del PVC.

   • Compruebe el estado del PV.

     kubectl get pv fashion-mnist-jackwg

     Salida esperada:

     NAME                   CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                          STORAGECLASS   REASON   AGE
     fashion-mnist-jackwg   10Gi       RWX            Retain           Bound    ns1/fashion-mnist-jackwg-pvc   oss                     8h

   • Compruebe el estado del PVC.

     kubectl get pvc fashion-mnist-jackwg-pvc -n ns1

     Salida esperada:

     NAME                       STATUS   VOLUME                 CAPACITY   ACCESS MODES   STORAGECLASS   AGE
     fashion-mnist-jackwg-pvc   Bound    fashion-mnist-jackwg   10Gi       RWX            oss            8h

   Tanto el PV como el PVC muestran el estado Bound.

Paso 2: crear un conjunto de datos acelerado

Los administradores utilizan AI Dashboard para acelerar los conjuntos de datos.

1. Access the AI Dashboard como administrador.

2. En el panel de navegación izquierdo de AI Dashboard, seleccione Dataset > Dataset List.

3. En la página Dataset List, haga clic en Accelerate en la columna Actions del conjunto de datos deseado.

   Una vez que acelera el conjunto de datos, su información se actualiza en la página Dataset List. La lista incluye columnas como Task name, Namespace, Data source, Accelerated y Status. Para el conjunto de datos acelerado, la columna Accelerated muestra Sí y su Status cambia de NotReady a Ready cuando finaliza la aceleración.

Paso 3: desarrollar el modelo

(Opcional) Paso 1: crear un notebook a partir de una imagen personalizada

AI Developer Console proporciona Jupyter Notebooks con imágenes precompiladas para distintas versiones de TensorFlow y PyTorch. Si estas imágenes no cubren sus necesidades, cree una imagen personalizada.

1. Cree un archivo llamado Dockerfile con base en la siguiente plantilla.

   Consulte Create and use notebooks para conocer los requisitos de las imágenes personalizadas.

   cat<<EOF >dockerfile
   FROM tensorflow/tensorflow:1.15.5-gpu
   USER root
   RUN pip install jupyter && \
       pip install ipywidgets && \
       jupyter nbextension enable --py widgetsnbextension && \
       pip install jupyterlab && jupyter serverextension enable --py jupyterlab
   EXPOSE 8888
   #USER jovyan
   CMD ["sh", "-c", "jupyter-lab --notebook-dir=/home/jovyan --ip=0.0.0.0 --no-browser --allow-root --port=8888 --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.allow_origin='*' --NotebookApp.base_url=${NB_PREFIX} --ServerApp.authenticate_prometheus=False"]
   EOF

2. Compile la imagen a partir del Dockerfile.

   docker build -f dockerfile .

   Salida esperada:

   Sending build context to Docker daemon  9.216kB
   Step 1/5 : FROM tensorflow/tensorflow:1.15.5-gpu
    ---> 73be11373498
   Step 2/5 : USER root
    ---> Using cache
    ---> 7ee21dc7e42e
   Step 3/5 : RUN pip install jupyter &&     pip install ipywidgets &&     jupyter nbextension enable --py widgetsnbextension &&     pip install jupyterlab && jupyter serverextension enable --py jupyterlab
    ---> Using cache
    ---> 23bc51c5e16d
   Step 4/5 : EXPOSE 8888
    ---> Using cache
    ---> 76a55822ddae
   Step 5/5 : CMD ["sh", "-c", "jupyter-lab --notebook-dir=/home/jovyan --ip=0.0.0.0 --no-browser --allow-root --port=8888 --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.allow_origin='*' --NotebookApp.base_url=${NB_PREFIX} --ServerApp.authenticate_prometheus=False"]
    ---> Using cache
    ---> 3692f04626d5
   Successfully built 3692f04626d5

3. Envíe la imagen a su registro de contenedores.

   docker tag ${IMAGE_ID} registry-vpc.cn-beijing.aliyuncs.com/${DOCKER_REPO}/jupyter:fashion-mnist-20210802a
   docker push registry-vpc.cn-beijing.aliyuncs.com/${DOCKER_REPO}/jupyter:fashion-mnist-20210802a

4. Cree un secret de extracción de imágenes para descargar la imagen desde su registro de contenedores privado.

   Consulte Crear un Secret para extraer una imagen de un registro privado.

   kubectl create secret docker-registry regcred \
     --docker-server=<your-registry-server> \
     --docker-username=<your-username> \
     --docker-password=<your-password> \
     --docker-email=<your-email-address>

5. Cree un Jupyter Notebook en AI Developer Console.

   Consulte Create and use notebooks.

   Configure los parámetros del Jupyter Notebook de la siguiente manera: en la sección Notebook Basic Information de la izquierda, establezca Notebook Name y Notebook Image (puede elegir una imagen personalizada), y especifique Namespace e Image Pull Secret. En Data Configuration, seleccione el conjunto de datos para mostrar la solicitud de volumen persistente y el directorio de almacenamiento local correspondientes. Si habilita Workspace PVC, debe especificar Target PVC y Mount Path. En la sección Notebook Resource Configuration de la derecha, configure CPU (Cores), Memory (GB) y GPU (Units). Cuando termine la configuración, haga clic en Create Notebook.

Paso 2: desarrollar y probar en un notebook

1. Access the AI Developer Console

2. En el panel de navegación izquierdo de AI Developer Console, haga clic en Notebook.

3. En la página Notebook, haga clic en el nombre del Jupyter Notebook deseado cuyo Status sea Running.

4. Abra una nueva terminal y ejecute los siguientes comandos para comprobar que los datos se montaron correctamente:

   pwd
   /root/data
   ls -alh

   Salida esperada:

   total 30M
   drwx------ 1 root root    0 Jan  1  1970 .
   drwx------ 1 root root 4.0K Aug  2 04:15 ..
   drwxr-xr-x 1 root root    0 Aug  1 14:16 saved_model
   -rw-r----- 1 root root 4.3M Aug  1 01:53 t10k-images-idx3-ubyte.gz
   -rw-r----- 1 root root 5.1K Aug  1 01:53 t10k-labels-idx1-ubyte.gz
   -rw-r----- 1 root root  26M Aug  1 01:54 train-images-idx3-ubyte.gz
   -rw-r----- 1 root root  29K Aug  1 01:53 train-labels-idx1-ubyte.gz

5. En su entorno de Jupyter Notebook, cree un nuevo archivo de notebook para desarrollar el modelo fashion-mnist e inicialícelo con el siguiente código:

   #!/usr/bin/python
   # -*- coding: UTF-8 -*-
   
   import os
   import gzip
   import numpy as np
   import tensorflow as tf
   from tensorflow import keras
   print('TensorFlow version: {}'.format(tf.__version__))
   dataset_path = "/root/data/"
   model_path = "./model/"
   model_version =  "v1"
   
   def load_data():
       files = [
           'train-labels-idx1-ubyte.gz',
           'train-images-idx3-ubyte.gz',
           't10k-labels-idx1-ubyte.gz',
           't10k-images-idx3-ubyte.gz'
       ]
       paths = []
       for fname in files:
           paths.append(os.path.join(dataset_path, fname))
       with gzip.open(paths[0], 'rb') as labelpath:
           y_train = np.frombuffer(labelpath.read(), np.uint8, offset=8)
       with gzip.open(paths[1], 'rb') as imgpath:
           x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
       with gzip.open(paths[2], 'rb') as labelpath:
           y_test = np.frombuffer(labelpath.read(), np.uint8, offset=8)
       with gzip.open(paths[3], 'rb') as imgpath:
           x_test = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)
       return (x_train, y_train),(x_test, y_test)
   
   def train():
       (train_images, train_labels), (test_images, test_labels) = load_data()
   
       # scale the values to 0.0 to 1.0
       train_images = train_images / 255.0
       test_images = test_images / 255.0
   
       # reshape for feeding into the model
       train_images = train_images.reshape(train_images.shape[0], 28, 28, 1)
       test_images = test_images.reshape(test_images.shape[0], 28, 28, 1)
   
       class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
                   'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
   
       print('\ntrain_images.shape: {}, of {}'.format(train_images.shape, train_images.dtype))
       print('test_images.shape: {}, of {}'.format(test_images.shape, test_images.dtype))
   
       model = keras.Sequential([
       keras.layers.Conv2D(input_shape=(28,28,1), filters=8, kernel_size=3,
                           strides=2, activation='relu', name='Conv1'),
       keras.layers.Flatten(),
       keras.layers.Dense(10, activation=tf.nn.softmax, name='Softmax')
       ])
       model.summary()
       testing = False
       epochs = 5
       model.compile(optimizer='adam',
                   loss='sparse_categorical_crossentropy',
                   metrics=['accuracy'])
       logdir = "/training_logs"
       tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
       model.fit(train_images,
           train_labels,
           epochs=epochs,
           callbacks=[tensorboard_callback],
       )
       test_loss, test_acc = model.evaluate(test_images, test_labels)
       print('\nTest accuracy: {}'.format(test_acc))
       export_path = os.path.join(model_path, model_version)
       print('export_path = {}\n'.format(export_path))
       tf.keras.models.save_model(
           model,
           export_path,
           overwrite=True,
           include_optimizer=True,
           save_format=None,
           signatures=None,
           options=None
       )
       print('\nSaved model success')
   if __name__ == '__main__':
       train()

   Importante

   En el código, dataset_path y model_path deben apuntar a las rutas de montaje del origen de datos en el Notebook. Así, el Notebook podrá acceder al conjunto de datos montado en el sistema de archivos local.

6. En el Notebook correspondiente, haga clic en el ícono para ejecutar el código.

   Salida esperada:

   TensorFlow version: 1.15.5
   
   train_images.shape: (60000, 28, 28, 1), of float64
   test_images.shape: (10000, 28, 28, 1), of float64
   Model: "sequential_2"
   _________________________________________________________________
   Layer (type)                 Output Shape              Param #
   =================================================================
   Conv1 (Conv2D)               (None, 13, 13, 8)         80
   _________________________________________________________________
   flatten_2 (Flatten)          (None, 1352)              0
   _________________________________________________________________
   Softmax (Dense)              (None, 10)                13530
   =================================================================
   Total params: 13,610
   Trainable params: 13,610
   Non-trainable params: 0
   _________________________________________________________________
   Train on 60000 samples
   Epoch 1/5
   60000/60000 [==============================] - 3s 57us/sample - loss: 0.5452 - acc: 0.8102
   Epoch 2/5
   60000/60000 [==============================] - 3s 52us/sample - loss: 0.4103 - acc: 0.8555
   Epoch 3/5
   60000/60000 [==============================] - 3s 55us/sample - loss: 0.3750 - acc: 0.8681
   Epoch 4/5
   60000/60000 [==============================] - 3s 55us/sample - loss: 0.3524 - acc: 0.8757
   Epoch 5/5
   60000/60000 [==============================] - 3s 53us/sample - loss: 0.3368 - acc: 0.8798
   10000/10000 [==============================] - 0s 37us/sample - loss: 0.3770 - acc: 0.8673
   
   Test accuracy: 0.8672999739646912
   export_path = ./model/v1
   Saved model success

Paso 3: enviar el código a un repositorio de Git

Envíe el código a su repositorio de Git directamente desde el Notebook.

1. Instale Git.

   apt-get update
   apt-get install git

2. Inicialice la configuración de Git y almacene sus credenciales.

   git config --global credential.helper store
   git pull ${YOUR_GIT_REPO}

3. Envíe el código al repositorio de Git.

   git push origin fashion-test

   Salida esperada:

   Total 0 (delta 0), reused 0 (delta 0)
   To codeup.aliyun.com:60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git
    * [new branch]      fashion-test -> fashion-test

Paso 4: enviar un trabajo de entrenamiento con Arena SDK

1. Instale las dependencias de Arena SDK.

   !pip install coloredlogs

2. Cree un nuevo archivo de Python e inicialícelo con el siguiente código:

   import os
   import sys
   import time
   from arenasdk.client.client import ArenaClient
   from arenasdk.enums.types import *
   from arenasdk.exceptions.arena_exception import *
   from arenasdk.training.tensorflow_job_builder import *
   from arenasdk.logger.logger import LoggerBuilder
   
   def main():
       print("start to test arena-python-sdk")
       client = ArenaClient("","demo-ns","info","arena-system") # The job is submitted to the demo-ns namespace.
       print("create ArenaClient succeed.")
       print("start to create tfjob")
       job_name = "arena-sdk-distributed-test"
       job_type = TrainingJobType.TFTrainingJob
       try:
           # build the training job
           job =  TensorflowJobBuilder().with_name(job_name)\
               .with_workers(1)\
               .with_gpus(1)\
               .with_worker_image("tensorflow/tensorflow:1.5.0-devel-gpu")\
               .with_ps_image("tensorflow/tensorflow:1.5.0-devel")\
               .with_ps_count(1)\
               .with_datas({"fashion-demo-pvc":"/data"})\
               .enable_tensorboard()\
               .with_sync_mode("git")\
               .with_sync_source("https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git")\  # URL of the Git repository.
               .with_envs({\
                   "GIT_SYNC_USERNAME":"USERNAME", \   # Username for the Git repository.
                   "GIT_SYNC_PASSWORD":"PASSWORD",\    # Password for the Git repository.
                   "TEST_TMPDIR":"/",\
               })\
               .with_command("python code/tensorflow-fashion-mnist-sample/tf-distributed-mnist.py").build()
           # If the training job already exists, delete it
           if client.training().get(job_name, job_type):
               print("The job {} already exists. Deleting it.".format(job_name))
               client.training().delete(job_name, job_type)
               time.sleep(3)
   
           output = client.training().submit(job)
           print(output)
   
           count = 0
           # Wait for the training job to start running.
           while True:
               if count > 160:
                   raise Exception("Timeout waiting for the job to start running")
               jobInfo = client.training().get(job_name,job_type)
               if jobInfo.get_status() == TrainingJobStatus.TrainingJobPending:
                   print("job status is PENDING,waiting...")
                   count = count + 1
                   time.sleep(5)
                   continue
               print("current status is {} of job {}".format(jobInfo.get_status().value,job_name))
               break
           # get the training job logs
           logger = LoggerBuilder().with_accepter(sys.stdout).with_follow().with_since("5m")
           #jobInfo.get_instances()[0].get_logs(logger)
           # display the training job information
           print(str(jobInfo))
           # delete the training job
           #client.training().delete(job_name, job_type)
       except ArenaException as e:
           print(e)
   
   main()

   • namespace: en este ejemplo, el trabajo de entrenamiento se envía al namespace demo-ns.

   • with_sync_source: la URL del repositorio de Git.

   • with_envs: el nombre de usuario y la contraseña del repositorio de Git.

3. En el Notebook correspondiente, haga clic en el ícono para ejecutar el código.

   Salida esperada:

   2021-11-02/08:57:28 DEBUG util.py[line:19] - execute command: [arena get --namespace=demo-ns --arena-namespace=arena-system --loglevel=info arena-sdk-distributed-test --type=tfjob -o json]
   2021-11-02/08:57:28 DEBUG util.py[line:19] - execute command: [arena submit --namespace=demo-ns --arena-namespace=arena-system --loglevel=info tfjob --name=arena-sdk-distributed-test --workers=1 --gpus=1 --worker-image=tensorflow/tensorflow:1.5.0-devel-gpu --ps-image=tensorflow/tensorflow:1.5.0-devel --ps=1 --data=fashion-demo-pvc:/data --tensorboard --sync-mode=git --sync-source=https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git --env=GIT_SYNC_USERNAME=kubeai --env=GIT_SYNC_PASSWORD=kubeai@ACK123 --env=TEST_TMPDIR=/ python code/tensorflow-fashion-mnist-sample/tf-distributed-mnist.py]
   start to test arena-python-sdk
   create ArenaClient succeed.
   start to create tfjob
   2021-11-02/08:57:29 DEBUG util.py[line:19] - execute command: [arena get --namespace=demo-ns --arena-namespace=arena-system --loglevel=info arena-sdk-distributed-test --type=tfjob -o json]
   service/arena-sdk-distributed-test-tensorboard created
   deployment.apps/arena-sdk-distributed-test-tensorboard created
   tfjob.kubeflow.org/arena-sdk-distributed-test created
   
   job status is PENDING,waiting...
   2021-11-02/09:00:34 DEBUG util.py[line:19] - execute command: [arena get --namespace=demo-ns --arena-namespace=arena-system --loglevel=info arena-sdk-distributed-test --type=tfjob -o json]
   current status is RUNNING of job arena-sdk-distributed-test
   {
       "allocated_gpus": 1,
       "chief_name": "arena-sdk-distributed-test-worker-0",
       "duration": "185s",
       "instances": [
           {
               "age": "13s",
               "gpu_metrics": [],
               "is_chief": false,
               "name": "arena-sdk-distributed-test-ps-0",
               "node_ip": "192.168.5.8",
               "node_name": "cn-beijing.192.168.5.8",
               "owner": "arena-sdk-distributed-test",
               "owner_type": "tfjob",
               "request_gpus": 0,
               "status": "Running"
           },
           {
               "age": "13s",
               "gpu_metrics": [],
               "is_chief": true,
               "name": "arena-sdk-distributed-test-worker-0",
               "node_ip": "192.168.5.8",
               "node_name": "cn-beijing.192.168.5.8",
               "owner": "arena-sdk-distributed-test",
               "owner_type": "tfjob",
               "request_gpus": 1,
               "status": "Running"
           }
       ],
       "name": "arena-sdk-distributed-test",
       "namespace": "demo-ns",
       "priority": "N/A",
       "request_gpus": 1,
       "tensorboard": "http://192.168.5.6:31068",
       "type": "tfjob"
   }

Paso 4: Entrenar el modelo

A continuación se presentan ejemplos que abarcan el entrenamiento independiente, el entrenamiento distribuido, el entrenamiento acelerado con Fluid y la programación consciente de topología mediante el programador de trabajos de IA.

Ejemplo 1: Enviar un trabajo de entrenamiento independiente de TensorFlow

Envíe un trabajo de entrenamiento con la CLI de Arena o con AI Developer Console.

Método 1: Usar la CLI de Arena

arena \
  submit \
  tfjob \
  -n ns1 \
  --name=fashion-mnist-arena \
  --data=fashion-mnist-jackwg-pvc:/root/data/ \
  --env=DATASET_PATH=/root/data/ \
  --env=MODEL_PATH=/root/saved_model \
  --env=MODEL_VERSION=1 \
  --env=GIT_SYNC_USERNAME=<GIT_USERNAME> \
  --env=GIT_SYNC_PASSWORD=<GIT_PASSWORD> \
  --sync-mode=git \
  --sync-source=https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git \
  --image="tensorflow/tensorflow:2.2.2-gpu" \
  "python /root/code/tensorflow-fashion-mnist-sample/train.py --log_dir=/training_logs"

Método 2: Usar AI Developer Console

1. Configure a data source.

   La siguiente tabla describe algunos de los parámetros clave.

   Parámetro	Ejemplo	Obligatorio
   Name	fashion-demo	Sí
   Namespace	demo-ns	Sí
   PersistentVolumeClaim	fashion-demo-pvc	Sí
   Local storage directory	/root/data	No

2. Configure a source code repository.

   Parámetro	Ejemplo	Obligatorio
   Name	fashion-git	Sí
   Git URL	https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git	Sí
   Default branch	master	No
   Local storage directory	/root/	No
   Private Git username	El nombre de usuario de su repositorio Git privado.	No
   Private Git password or token	La contraseña o el token de acceso personal de su repositorio Git privado.	No

3. Submit a standalone training job.

   Después de configurar los parámetros de entrenamiento, haga clic en Submit. Luego podrá consultar el trabajo de entrenamiento en la página Job List. La siguiente tabla describe los parámetros para enviar el trabajo.

   Parámetro	Descripción
   Task Name	En este ejemplo, el nombre del trabajo es fashion-tf-ui.
   Job type	Para este ejemplo, seleccione Tensorflow Standalone.
   Namespace	En este ejemplo, utilice demo-ns. Debe ser el mismo namespace que el del conjunto de datos.
   Data source configuration	Para este ejemplo, seleccione fashion-demo, configurado en Step 1.
   Code configuration	Para este ejemplo, seleccione fashion-git, configurado en Step 2.
   Code branch	En este ejemplo, utilice master.
   Command	En este ejemplo, utilice "export DATASET_PATH=/root/data/ &&export MODEL_PATH=/root/saved_model &&export MODEL_VERSION=1 &&python /root/code/tensorflow-fashion-mnist-sample/train.py".
   Private Git repository	Si utiliza un repositorio privado, debe proporcionar el nombre de usuario y la contraseña.
   Instance count	El valor predeterminado es 1.
   Image	En este ejemplo, utilice tensorflow/tensorflow:2.2.2-gpu.
   Image pull secret	Si utiliza una imagen de un registro privado, primero debe crear un image pull secret.
   CPU (cores)	El valor predeterminado es 4.
   Memory (GB)	El valor predeterminado es 8.

   Consulte Parámetros de la CLI de Arena para TFJob.

4. Una vez enviado el trabajo, consulte sus registros.

   1. En el panel de navegación izquierdo de AI Developer Console, haga clic en Tasks.

   2. En la página Tasks, haga clic en el nombre del trabajo objetivo.

   3. En la página de detalles del trabajo, haga clic en la pestaña Instance. Después, en la columna Actions de la instancia objetivo, haga clic en Logs.

      El siguiente fragmento muestra la salida de registros de este ejemplo:

      train_images.shape: (60000, 28, 28, 1), of float64
      test_images.shape: (10000, 28, 28, 1), of float64
      Model: "sequential"
      _________________________________________________________________
      Layer (type)                 Output Shape              Param #
      =================================================================
      Conv1 (Conv2D)               (None, 13, 13, 8)         80
      _________________________________________________________________
      flatten (Flatten)            (None, 1352)              0
      _________________________________________________________________
      Softmax (Dense)              (None, 10)                13530
      =================================================================
      Total params: 13,610
      Trainable params: 13,610
      Non-trainable params: 0
      _________________________________________________________________
      Epoch 1/5
      2021-08-01 14:21:17.532237: E tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1430] function cupti_interface_->EnableCallback( 0 , subscriber_, CUPTI_CB_DOMAIN_DRIVER_API, cbid)failed with error CUPTI_ERROR_INVALID_PARAMETER
      2021-08-01 14:21:17.532390: I tensorflow/core/profiler/internal/gpu/device_tracer.cc:216]  GpuTracer has collected 0 callback api events and 0 activity events.
      2021-08-01 14:21:17.533535: I tensorflow/core/profiler/rpc/client/save_profile.cc:168] Creating directory: /training_logs/train/plugins/profile/2021_08_01_14_21_17
      2021-08-01 14:21:17.533928: I tensorflow/core/profiler/rpc/client/save_profile.cc:174] Dumped gzipped tool data for trace.json.gz to /training_logs/train/plugins/profile/2021_08_01_14_21_17/fashion-mnist-arena-chief-0.trace.json.gz
      2021-08-01 14:21:17.534251: I tensorflow/core/profiler/utils/event_span.cc:288] Generation of step-events took 0 ms
      
      2021-08-01 14:21:17.534961: I tensorflow/python/profiler/internal/profiler_wrapper.cc:87] Creating directory: /training_logs/train/plugins/profile/2021_08_01_14_21_17Dumped tool data for overview_page.pb to /training_logs/train/plugins/profile/2021_08_01_14_21_17/fashion-mnist-arena-chief-0.overview_page.pb
      Dumped tool data for input_pipeline.pb to /training_logs/train/plugins/profile/2021_08_01_14_21_17/fashion-mnist-arena-chief-0.input_pipeline.pb
      Dumped tool data for tensorflow_stats.pb to /training_logs/train/plugins/profile/2021_08_01_14_21_17/fashion-mnist-arena-chief-0.tensorflow_stats.pb
      Dumped tool data for kernel_stats.pb to /training_logs/train/plugins/profile/2021_08_01_14_21_17/fashion-mnist-arena-chief-0.kernel_stats.pb
      
      1875/1875 [==============================] - 3s 2ms/step - loss: 0.5399 - accuracy: 0.8116
      Epoch 2/5
      1875/1875 [==============================] - 3s 2ms/step - loss: 0.4076 - accuracy: 0.8573
      Epoch 3/5
      1875/1875 [==============================] - 3s 2ms/step - loss: 0.3727 - accuracy: 0.8694
      Epoch 4/5
      1875/1875 [==============================] - 3s 2ms/step - loss: 0.3512 - accuracy: 0.8769
      Epoch 5/5
      1875/1875 [==============================] - 3s 2ms/step - loss: 0.3351 - accuracy: 0.8816
      313/313 [==============================] - 0s 1ms/step - loss: 0.3595 - accuracy: 0.8733
      2021-08-01 14:21:34.820089: W tensorflow/python/util/util.cc:329] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
      WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:1817: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
      Instructions for updating:
      If using Keras pass *_constraint arguments to layers.
      
      Test accuracy: 0.8733000159263611
      export_path = /root/saved_model/1
      
      Saved model success

5. Consulte las métricas de entrenamiento en TensorBoard.

   Reenvíe el puerto del servicio de TensorBoard a su computadora local mediante kubectl port-forward.

   1. Obtenga los detalles del servicio de TensorBoard.

      kubectl get svc -n demo-ns

      Salida esperada:

      NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)               AGE
      tf-dist-arena-tensorboard   NodePort    172.16.XX.XX     <none>        6006:32226/TCP        80m

   2. Reenvíe el puerto de TensorBoard.

      kubectl port-forward svc/tf-dist-arena-tensorboard -n demo-ns 6006:6006

      Salida esperada:

      Forwarding from 127.0.0.1:6006 -> 6006
      Forwarding from [::1]:6006 -> 6006
      Handling connection for 6006
      Handling connection for 6006

   3. En un navegador web, abra http://localhost:6006/ para consultar el panel de TensorBoard.

      La pestaña GRAPHS muestra el grafo computacional del modelo, donde se aprecian las conexiones y el flujo de datos entre capas como Conv1, flatten y Softmax. El panel lateral proporciona las propiedades detalladas del nodo seleccionado.

Ejemplo 2: Enviar un trabajo de entrenamiento distribuido de TensorFlow

Método 1: Usar la CLI de Arena

1. Envíe el trabajo de entrenamiento.

   arena submit tf \
       -n demo-ns \
       --name=tf-dist-arena \
       --working-dir=/root/ \
       --data fashion-mnist-pvc:/data \
       --env=TEST_TMPDIR=/ \
       --env=GIT_SYNC_USERNAME=kubeai \
       --env=GIT_SYNC_PASSWORD=kubeai@ACK123 \
       --env=GIT_SYNC_BRANCH=master \
       --gpus=1 \
       --workers=2 \
       --worker-image=tensorflow/tensorflow:1.5.0-devel-gpu \
       --sync-mode=git \
       --sync-source=https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git \
       --ps=1 \
       --ps-image=tensorflow/tensorflow:1.5.0-devel \
       --tensorboard \
       "python code/tensorflow-fashion-mnist-sample/tf-distributed-mnist.py --log_dir=/training_logs"

2. Obtenga los detalles del servicio de TensorBoard.

   kubectl get svc -n demo-ns

   Salida esperada:

   NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                 AGE
   tf-dist-arena-tensorboard   NodePort    172.16.204.248   <none>        6006:32226/TCP          80m

3. Reenvíe el puerto de TensorBoard.

   kubectl port-forward svc/tf-dist-arena-tensorboard -n demo-ns 6006:6006

   Salida esperada:

   Forwarding from 127.0.0.1:6006 -> 6006
   Forwarding from [::1]:6006 -> 6006
   Handling connection for 6006
   Handling connection for 6006

4. En un navegador web, abra http://localhost:6006/ para consultar el panel de TensorBoard.

   La pestaña SCALARS muestra gráficas de métricas como accuracy y cross_entropy durante el entrenamiento. En el panel lateral puede filtrar por ejecuciones de train y test, además de ajustar las opciones de visualización de Smoothing y de los ejes.

Método 2: Usar AI Developer Console

1. Configure a data source.

   Reutiliza los datos de Step 1.

2. Configure a source code repository.

   Reutiliza el código de Step 2.

3. Submit the distributed TensorFlow training job.

   Después de configurar los parámetros de entrenamiento, haga clic en Submit. Luego podrá consultar el trabajo en la página Job List. La siguiente tabla describe los parámetros clave del trabajo.

   Parámetro	Descripción
   Task Name	En este ejemplo, utilice fashion-ps-ui.
   Job type	Seleccione TF Distributed.
   Namespace	En este ejemplo, utilice demo-ns. Debe ser el mismo namespace que el del conjunto de datos.
   Data source configuration	Para este ejemplo, seleccione fashion-demo, configurado en Step 1 del ejemplo anterior.
   Code configuration	Para este ejemplo, seleccione fashion-git, configurado en Step 2 del ejemplo anterior.
   Command	En este ejemplo, utilice " export TEST_TMPDIR=/root/ && python code/tensorflow-fashion-mnist-sample/tf-distributed-mnist.py --log_dir=/training_logs".
   Image	En Task Resource Configuration, dentro de la pestaña Worker, establezca Image como tensorflow/tensorflow:1.5.0-devel-gpu. En Task Resource Configuration, dentro de la pestaña PS, establezca Image como tensorflow/tensorflow:1.5.0-devel.

   Consulte Parámetros de la CLI de Arena para TFJob.

4. Para consultar TensorBoard, siga los pasos 2 al 4 del apartado Método 1: Usar la CLI de Arena.

Ejemplo 3: Enviar un trabajo de entrenamiento acelerado con Fluid

1. Acelere un conjunto de datos existente.

   Omita este paso si ya aceleró fashion-demo-pvc en Step 2: Create a dataset. Consulte Manage datasets.

2. Envíe un trabajo que utilice el conjunto de datos acelerado.

   Envíe el trabajo de entrenamiento al namespace demo-ns. Estas son las diferencias clave para los conjuntos de datos acelerados:

   • --data: el nombre del PersistentVolumeClaim (PVC) acelerado. En este ejemplo, es fashion-demo-pvc-acc.

   • --env=DATASET_PATH: esta ruta se forma al agregar el nombre del PVC (fashion-demo-pvc-acc) a la ruta de montaje (/root/data/) especificada en el parámetro --data.

   arena \
     submit \
     tfjob \
     -n demo-ns \
     --name=fashion-mnist-fluid \
     --data=fashion-demo-pvc-acc:/root/data/ \
     --env=DATASET_PATH=/root/data/fashion-demo-pvc-acc \
     --env=MODEL_PATH=/root/saved_model \
     --env=MODEL_VERSION=1 \
     --env=GIT_SYNC_USERNAME=${GIT_USERNAME} \
     --env=GIT_SYNC_PASSWORD=${GIT_PASSWORD} \
     --sync-mode=git \
     --sync-source=https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git \
     --image="tensorflow/tensorflow:2.2.2-gpu" \
     "python /root/code/tensorflow-fashion-mnist-sample/train.py --log_dir=/training_logs"

3. Compare los tiempos de ejecución de ambos trabajos de entrenamiento.

   arena list -n demo-ns

   Salida esperada:

   NAME                 STATUS     TRAINER  DURATION  GPU(Requested)  GPU(Allocated)  NODE
   fashion-mnist-fluid  SUCCEEDED  TFJOB    33s       0               N/A             192.168.5.7
   fashion-mnist-arena  SUCCEEDED  TFJOB    3m        0               N/A             192.168.5.8

   Con el mismo código y los mismos recursos, el trabajo acelerado con Fluid finalizó en 33 segundos, mientras que el trabajo estándar tardó 3 minutos.

Ejemplo 4: Acelerar un trabajo de entrenamiento distribuido con el programador de trabajos de IA

El programador de trabajos de IA es un plugin de ACK diseñado para cargas de trabajo de IA y big data. Admite Gang Scheduling, Capacity Scheduling y programación consciente de topología. Este ejemplo demuestra la programación consciente de topología de GPU.

El programador utiliza información de topología a nivel de nodo (enlaces de GPU como NVLink y PCIe Switch, o la arquitectura NUMA de CPU) para optimizar la programación de los trabajos de IA. Consulte GPU topology-aware scheduling y CPU topology-aware scheduling.

Habilite la programación consciente de topología de GPU y compare el rendimiento de los trabajos.

1. Cree un trabajo de entrenamiento sin programación consciente de topología.

   arena submit mpi \
     --name=tensorflow-4-vgg16 \
     --gpus=1 \
     --workers=4 \
     --image=registry.cn-hangzhou.aliyuncs.com/kubernetes-image-hub/tensorflow-benchmark:tf2.3.0-py3.7-cuda10.1 \
     "mpirun --allow-run-as-root -np "4" -bind-to none -map-by slot -x NCCL_DEBUG=INFO -x NCCL_SOCKET_IFNAME=eth0 -x LD_LIBRARY_PATH -x PATH --mca pml ob1 --mca btl_tcp_if_include eth0 --mca oob_tcp_if_include eth0 --mca orte_keep_fqdn_hostnames t --mca btl ^openib python /tensorflow/benchmarks/scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py --model=vgg16 --batch_size=64 --variable_update=horovod"

2. Cree un trabajo de entrenamiento con la programación consciente de topología habilitada.

   Etiquete el nodo. Reemplace cn-beijing.192.168.XX.XX por el nombre real de su nodo.

   kubectl label node cn-beijing.192.168.XX.XX ack.node.gpu.schedule=topology --overwrite

   Cree el trabajo de entrenamiento. La bandera --gputopology=true habilita la detección de topología en Arena.

   arena submit mpi \
     --name=tensorflow-topo-4-vgg16 \
     --gpus=1 \
     --workers=4 \
     --gputopology=true \
     --image=registry.cn-hangzhou.aliyuncs.com/kubernetes-image-hub/tensorflow-benchmark:tf2.3.0-py3.7-cuda10.1 \
     "mpirun --allow-run-as-root -np "4" -bind-to none -map-by slot -x NCCL_DEBUG=INFO -x NCCL_SOCKET_IFNAME=eth0 -x LD_LIBRARY_PATH -x PATH --mca pml ob1 --mca btl_tcp_if_include eth0 --mca oob_tcp_if_include eth0 --mca orte_keep_fqdn_hostnames t --mca btl ^openib python /tensorflow/benchmarks/scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py --model=vgg16 --batch_size=64 --variable_update=horovod

3. Compare el rendimiento de ambos trabajos.

   1. Compare los tiempos de ejecución.

      arena list -n demo-ns

      Salida esperada:

      NAME                             STATUS     TRAINER  DURATION  GPU(Requested)  GPU(Allocated)  NODE
      tensorflow-topo-4-vgg16          SUCCEEDED  MPIJOB   44s       4               N/A             192.168.4.XX1
      tensorflow-4-vgg16-image-warned  SUCCEEDED  MPIJOB   2m        4               N/A             192.168.4.XX0

   2. Consulte el rendimiento del trabajo con detección de topología.

      arena logs tensorflow-topo-4-vgg16 -n demo-ns

      Salida esperada:

      100 images/sec: 251.7 +/- 0.1 (jitter = 1.2)  7.262
      ----------------------------------------------------------------
      total images/sec: 1006.44

   3. Consulte el rendimiento del trabajo estándar.

      arena logs tensorflow-4-vgg16-image-warned -n demo-ns

      Salida esperada:

      100 images/sec: 56.4 +/- 0.2 (jitter = 1.5)  7.261
      ----------------------------------------------------------------
      total images/sec: 225.50

kubectl label node cn-beijing.192.168.XX.XX0 ack.node.gpu.schedule=default --overwrite

Paso 5: Gestionar el modelo

1. Access the AI Developer Console

2. En el panel de navegación izquierdo de AI Developer Console, haga clic en Model Manage.

3. En la página Model Management, haga clic en Create Model.

4. En el cuadro de diálogo Create, configure Model Name, Model Version y Job Name.

   En este ejemplo, el nombre del modelo es fashion-mnist-demo, la versión del modelo es v1 y el trabajo de entrenamiento es tf-single.

5. Haga clic en OK. El nuevo modelo aparecerá en la lista.

   Para evaluar el modelo, haga clic en New Model Evaluation en la fila correspondiente.

Paso 6: Evaluar el modelo

1. Envíe un trabajo de entrenamiento con la generación de checkpoints habilitada.

   Envíe un trabajo de entrenamiento con Arena. El trabajo guardará los checkpoints en el volumen fashion-demo-pvc.

   arena \
     submit \
     tfjob \
     -n demo-ns \ # Set the namespace as needed.
     --name=fashion-mnist-arena-ckpt \
     --data=fashion-demo-pvc:/root/data/ \
     --env=DATASET_PATH=/root/data/ \
     --env=MODEL_PATH=/root/data/saved_model \
     --env=MODEL_VERSION=1 \
     --env=GIT_SYNC_USERNAME=${GIT_USERNAME} \ # Enter your Git username.
     --env=GIT_SYNC_PASSWORD=${GIT_PASSWORD} \ # Enter your Git password.
     --env=OUTPUT_CHECKPOINT=1 \
     --sync-mode=git \
     --sync-source=https://codeup.aliyun.com/60b4cf5c66bba1c04b442e49/tensorflow-fashion-mnist-sample.git \
     --image="tensorflow/tensorflow:2.2.2-gpu" \
     "python /root/code/tensorflow-fashion-mnist-sample/train.py --log_dir=/training_logs"

2. Envíe un trabajo de evaluación del modelo.

   1. Compile la imagen de evaluación.

      En el directorio kubeai-sdk, ejecute los siguientes comandos para compilar y enviar la imagen.

      docker build . -t ${DOCKER_REGISTRY}:fashion-mnist
      docker push ${DOCKER_REGISTRY}:fashion-mnist

   2. Obtenga los detalles del servicio de MySQL.

      kubectl get svc -n kube-ai ack-mysql

      Salida esperada:

      NAME        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
      ack-mysql   ClusterIP   172.16.XX.XX    <none>        3306/TCP   28h

   3. Envíe un trabajo de evaluación del modelo con Arena.

      arena evaluate model \
       --namespace=demo-ns \
       --loglevel=debug \
       --name=evaluate-job \
       --image=registry.cn-beijing.aliyuncs.com/kube-ai/kubeai-sdk-demo:fashion-minist \
       --env=ENABLE_MYSQL=True \
       --env=MYSQL_HOST=172.16.77.227 \
       --env=MYSQL_PORT=3306 \
       --env=MYSQL_USERNAME=kubeai \
       --env=MYSQL_PASSWORD=kubeai@ACK \
       --data=fashion-demo-pvc:/data \
       --model-name=1 \
       --model-path=/data/saved_model/ \
       --dataset-path=/data/ \
       --metrics-path=/data/output \
       "python /kubeai/evaluate.py"

      Nota

      Puede obtener la dirección IP y el puerto del servicio de MySQL en el paso anterior.

3. Compare los resultados de la evaluación.

   1. En el panel de navegación izquierdo de AI Developer Console, haga clic en Model Management.

      La página muestra una lista de trabajos de evaluación de modelos. La lista incluye columnas como Name, Model name, Model version, Namespace, Status, Creation time y End time. Para los trabajos finalizados, la columna Status muestra Complete. Puede comparar los resultados de varios trabajos si hace clic en el botón Compare Metrics en la parte superior de la página.

   2. En Tasks, haga clic en el nombre de un trabajo para consultar sus métricas.

      Los resultados de la evaluación muestran las siguientes métricas: accuracy, precision, recall, F1_score y AUC. Una curva ROC también permite visualizar el rendimiento de clasificación del modelo.

      Un gráfico de barras compara visualmente el rendimiento de los trabajos seleccionados con base en métricas como AUC y accuracy.

Paso 7: Desplegar el modelo

Despliegue el modelo entrenado como un servicio de inference de TensorFlow Serving. Arena también admite otros frameworks como Triton y Seldon (consulte Documentación de Arena serve).

Este ejemplo utiliza el modelo de Step 4, almacenado en el PVC fashion-demo-pvc de Step 2. Si su modelo usa un tipo de almacenamiento distinto, cree primero el PVC correspondiente.

1. Despliegue el modelo de TensorFlow en TensorFlow Serving con Arena.

   arena serve tensorflow \
     --loglevel=debug \
     --namespace=demo-ns \
     --name=fashion-mnist \
     --model-name=1  \
     --gpus=1  \
     --image=tensorflow/serving:1.15.0-gpu \
     --data=fashion-demo-pvc:/data \
     --model-path=/data/saved_model/ \
     --version-policy=latest

2. Obtenga el nombre del servicio de inference desplegado.

   arena serve list -n demo-ns

   Salida esperada:

   NAME           TYPE        VERSION       DESIRED  AVAILABLE  ADDRESS         PORTS                   GPU
   fashion-mnist  Tensorflow  202111031203  1        1          172.16.XX.XX    GRPC:8500,RESTFUL:8501  1

   Utilice los valores de ADDRESS y PORTS de la salida para invocar el servicio desde dentro del clúster.

3. En Jupyter, cree un nuevo archivo Notebook para enviar solicitudes al servicio HTTP de TensorFlow Serving.

   Este ejemplo utiliza el Jupyter Notebook creado en Step 3: Develop the model para enviar las solicitudes.

   • En el siguiente código de inicialización, reemplace el valor de server_ip por el valor de ADDRESS (172.16.XX.XX) obtenido en el paso anterior.

   • Establezca server_http_port con el puerto RESTFUL (8501) obtenido en el paso anterior.

   El código de inicialización del archivo Notebook es el siguiente:

   import os
   import gzip
   import numpy as np
   # import matplotlib.pyplot as plt
   import random
   import requests
   import json
   
   server_ip = "172.16.XX.XX"
   server_http_port = 8501
   
   dataset_dir = "/root/data/"
   
   def load_data():
           files = [
               'train-labels-idx1-ubyte.gz',
               'train-images-idx3-ubyte.gz',
               't10k-labels-idx1-ubyte.gz',
               't10k-images-idx3-ubyte.gz'
           ]
   
           paths = []
           for fname in files:
               paths.append(os.path.join(dataset_dir, fname))
   
           with gzip.open(paths[0], 'rb') as labelpath:
               y_train = np.frombuffer(labelpath.read(), np.uint8, offset=8)
           with gzip.open(paths[1], 'rb') as imgpath:
               x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
           with gzip.open(paths[2], 'rb') as labelpath:
               y_test = np.frombuffer(labelpath.read(), np.uint8, offset=8)
           with gzip.open(paths[3], 'rb') as imgpath:
               x_test = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)
   
           return (x_train, y_train),(x_test, y_test)
   
   def show(idx, title):
     plt.figure()
     plt.imshow(test_images[idx].reshape(28,28))
     plt.axis('off')
     plt.title('\n\n{}'.format(title), fontdict={'size': 16})
   
   class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
                  'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
   
   (train_images, train_labels), (test_images, test_labels) = load_data()
   train_images = train_images / 255.0
   test_images = test_images / 255.0
   
   # reshape for feeding into the model
   train_images = train_images.reshape(train_images.shape[0], 28, 28, 1)
   test_images = test_images.reshape(test_images.shape[0], 28, 28, 1)
   
   print('\ntrain_images.shape: {}, of {}'.format(train_images.shape, train_images.dtype))
   print('test_images.shape: {}, of {}'.format(test_images.shape, test_images.dtype))
   
   rando = random.randint(0,len(test_images)-1)
   #show(rando, 'An Example Image: {}'.format(class_names[test_labels[rando]]))
   
   # !pip install -q requests
   
   # import requests
   # headers = {"content-type": "application/json"}
   # json_response = requests.post('http://localhost:8501/v1/models/fashion_model:predict', data=data, headers=headers)
   # predictions = json.loads(json_response.text)['predictions']
   
   # show(0, 'The model thought this was a {} (class {}), and it was actually a {} (class {})'.format(
   #   class_names[np.argmax(predictions[0])], np.argmax(predictions[0]), class_names[test_labels[0]], test_labels[0]))
   
   def request_model(data):
       headers = {"content-type": "application/json"}
       json_response = requests.post('http://{}:{}/v1/models/1:predict'.format(server_ip, server_http_port), data=data, headers=headers)
       print('=======response:', json_response, json_response.text)
       predictions = json.loads(json_response.text)['predictions']
   
       print('The model thought this was a {} (class {}), and it was actually a {} (class {})'.format(class_names[np.argmax(predictions[0])], np.argmax(predictions[0]), class_names[test_labels[0]], test_labels[0]))
       #show(0, 'The model thought this was a {} (class {}), and it was actually a {} (class {})'.format(
       #  class_names[np.argmax(predictions[0])], np.argmax(predictions[0]), class_names[test_labels[0]], test_labels[0]))
   
   # def request_model_version(data):
   #     headers = {"content-type": "application/json"}
   #     json_response = requests.post('http://{}:{}/v1/models/1/version/1:predict'.format(server_ip, server_http_port), data=data, headers=headers)
   #     print('=======response:', json_response, json_response.text)
   
   #     predictions = json.loads(json_response.text)
   #     for i in range(0,3):
   #       show(i, 'The model thought this was a {} (class {}), and it was actually a {} (class {})'.format(
   #         class_names[np.argmax(predictions[i])], np.argmax(predictions[i]), class_names[test_labels[i]], test_labels[i]))
   
   data = json.dumps({"signature_name": "serving_default", "instances": test_images[0:3].tolist()})
   print('Data: {} ... {}'.format(data[:50], data[len(data)-52:]))
   #request_model_version(data)
   request_model(data)

   Haga clic en el ícono en Jupyter Notebook para ver a continuación la salida:

   train_images.shape: (60000, 28, 28, 1), of float64
   test_images.shape: (10000, 28, 28, 1), of float64
   Data: {"signature_name": "serving_default", "instances": ...  [0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.0]]]]}
   =======response: <Response [200]> {
       "predictions": [[7.42696e-07, 6.91237556e-09, 2.66364452e-07, 2.27735413e-07, 4.0373439e-07, 0.00490919966, 7.27086217e-06, 0.0316713452, 0.0010733594, 0.962337255], [0.00685342, 1.8516447e-08, 0.9266119, 2.42278338e-06, 0.0603800081, 4.01338771e-12, 0.00613868702, 4.26091073e-15, 1.35764185e-05, 3.38685469e-10], [1.09047969e-05, 0.999816835, 7.98738e-09, 0.000122893631, 4.85748023e-05, 1.50353979e-10, 3.57102294e-07, 1.89657579e-09, 4.4604468e-07, 9.23274524e-09]
       ]
   }
   The model thought this was a Ankle boot (class 9), and it was actually a Ankle boot (class 9)

Preguntas frecuentes

• ¿Cómo instalo software en la consola de Jupyter Notebook?

  Para instalar software, ejecute el siguiente comando en la consola de Jupyter Notebook.

  apt-get install <software-name>

• ¿Cómo corrijo los caracteres ilegibles en la consola de Jupyter Notebook?

  Edite el archivo /etc/locale para que contenga lo siguiente y luego vuelva a abrir la terminal.

  LC_CTYPE="da_DK.UTF-8"
  LC_NUMERIC="da_DK.UTF-8"
  LC_TIME="da_DK.UTF-8"
  LC_COLLATE="da_DK.UTF-8"
  LC_MONETARY="da_DK.UTF-8"
  LC_MESSAGES="da_DK.UTF-8"
  LC_PAPER="da_DK.UTF-8"
  LC_NAME="da_DK.UTF-8"
  LC_ADDRESS="da_DK.UTF-8"
  LC_TELEPHONE="da_DK.UTF-8"
  LC_MEASUREMENT="da_DK.UTF-8"
  LC_IDENTIFICATION="da_DK.UTF-8"
  LC_ALL=