Migración de un marco de inferencia de terceros a un motor de inferencia personalizado

Contexto

ModelArts permite el despliegue de marcos de inferencia de terceros. Esta sección describe cómo migrar TF Serving y Triton a un motor de inferencia personalizado.

• TensorFlow Serving (TF Serving) es un sistema de despliegue de modelo flexible y de alto rendimiento para el aprendizaje automático. Proporciona funciones de gestión de versiones de modelos y de reversión de servicios. Al configurar parámetros como la ruta del modelo, el puerto del modelo y el nombre del modelo, las imágenes nativas de TF Serving pueden comenzar rápidamente a proporcionar servicios a los que se puede acceder con las API gRPC y HTTP RESTful.
• Triton es un marco de servicios de inferencia de alto rendimiento desarrollado por NVIDIA. Soporta múltiples protocolos de servicio, incluidos HTTP y gRPC. Además, Triton es compatible con varios motores de inferencia como TensorFlow, TensorRT, PyTorch y ONNX Runtime. En concreto, permite la concurrencia multimodelo y el procesamiento dinámico por lotes, lo que optimiza la utilización de la GPU y mejora el rendimiento del servicio de inferencia.

La migración de un marco de terceros a un marco de inferencia de ModelArts requiere la reconstrucción de la imagen nativa del marco de terceros. Después de eso, se puede utilizar la gestión de versiones del modelo de ModelArts y la carga dinámica del modelo. En esta sección se muestra cómo completar una reconstrucción de este tipo. Después de crear una imagen del motor personalizado, puede usarla para crear una versión de aplicación de IA y desplegar y gestionar servicios con la aplicación de IA.

La siguiente figura muestra los elementos de reconstrucción.

Figura 1 Elementos de reconstrucción

El proceso de reconstrucción puede diferir para las imágenes de diversos marcos. Para obtener más detalles, consulte el procedimiento de migración específico del marco de destino.

• Migración de TF Serving
• Migración de Triton

Migración de TF Serving

1. Agregue el usuario ma-user.

   La imagen se crea según la imagen nativa tensorflow/serving:2.8.0. El grupo de usuarios 100 existe en la imagen de forma predeterminada. Ejecute el siguiente comando en Dockerfile para agregar usuario ma-user:

   RUN useradd -d /home/ma-user -m -u 1000 -g 100 -s /bin/bash ma-user

2. Configure un proxy de Nginx para soportar HTTPS.

   Después de convertir el protocolo a HTTPS, el puerto expuesto cambia de 8501 de TF Serving a 8080.

   1. Ejecute los siguientes comandos en Dockerfile para instalar y configurar Nginx:

      RUN apt-get update && apt-get -y --no-install-recommends install nginx && apt-get clean
      RUN mkdir /home/mind && \
          mkdir -p /etc/nginx/keys && \
          mkfifo /etc/nginx/keys/fifo && \
          chown -R ma-user:100 /home/mind && \
          rm -rf /etc/nginx/conf.d/default.conf && \
          chown -R ma-user:100 /etc/nginx/ && \
          chown -R ma-user:100 /var/log/nginx && \
          chown -R ma-user:100 /var/lib/nginx && \
          sed -i "s#/var/run/nginx.pid#/home/ma-user/nginx.pid#g" /etc/init.d/nginx
      ADD nginx /etc/nginx
      ADD run.sh /home/mind/
      ENTRYPOINT []
      CMD /bin/bash /home/mind/run.sh
   2. Cree el directorio de Nginx.

      nginx
      ├──nginx.conf
      └──conf.d
             ├── modelarts-model-server.conf
   3. Escriba el archivo nginx.conf.

      user ma-user 100;
      worker_processes 2;
      pid /home/ma-user/nginx.pid;
      include /etc/nginx/modules-enabled/*.conf;
      events {
          worker_connections 768;
      }
      http {
          ##
          # Basic Settings
          ##
          sendfile on;
          tcp_nopush on;
          tcp_nodelay on;
          types_hash_max_size 2048;
          fastcgi_hide_header X-Powered-By;
          port_in_redirect off;
          server_tokens off;
          client_body_timeout 65s;
          client_header_timeout 65s;
          keepalive_timeout 65s;
          send_timeout 65s;
          # server_names_hash_bucket_size 64;
          # server_name_in_redirect off;
          include /etc/nginx/mime.types;
          default_type application/octet-stream;
          ##
          # SSL Settings
          ##
          ssl_protocols TLSv1.2;
          ssl_prefer_server_ciphers on;
          ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256;
          ##
          # Logging Settings
          ##
          access_log /var/log/nginx/access.log;
          error_log /var/log/nginx/error.log;
          ##
          # Gzip Settings
          ##
          gzip on;
          ##
          # Virtual Host Configs
          ##
          include /etc/nginx/conf.d/modelarts-model-server.conf;
      }
   4. Escriba el archivo de configuración modelarts-model-server.conf.

      server {
          client_max_body_size 15M;
          large_client_header_buffers 4 64k;
          client_header_buffer_size 1k;
          client_body_buffer_size 16k;
          ssl_certificate /etc/nginx/ssl/server/server.crt;
          ssl_password_file /etc/nginx/keys/fifo;
          ssl_certificate_key /etc/nginx/ssl/server/server.key;
          # setting for mutual ssl with client
          ##
          # header Settings
          ##
          add_header X-XSS-Protection "1; mode=block";
          add_header X-Frame-Options SAMEORIGIN;
          add_header X-Content-Type-Options nosniff;
          add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";
          add_header Content-Security-Policy "default-src 'self'";
          add_header Cache-Control "max-age=0, no-cache, no-store, must-revalidate";
          add_header Pragma "no-cache";
          add_header Expires "-1";
          server_tokens off;
          port_in_redirect off;
          fastcgi_hide_header X-Powered-By;
          ssl_session_timeout 2m;
          ##
          # SSL Settings
          ##
          ssl_protocols TLSv1.2;
          ssl_prefer_server_ciphers on;
          ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256;
          listen    0.0.0.0:8080 ssl;
          error_page 502 503 /503.html;
          location /503.html {
              return 503 '{"error_code": "ModelArts.4503","error_msg": "Failed to connect to backend service, please confirm your service is connectable. "}';
          }
          location / {
      #       limit_req zone=mylimit;
      #       limit_req_status 429;
              proxy_pass http://127.0.0.1:8501;
          }
      }
   5. Cree un script de inicio.
      NOTA:

      Antes de ejecutar el script de inicio de TF Serving, debe crear un certificado de SSL.

      El código de ejemplo del script de inicio run.sh es el siguiente:

      #!/bin/bash
      mkdir -p /etc/nginx/ssl/server && cd /etc/nginx/ssl/server
      cipherText=$(openssl rand -base64 32)
      openssl genrsa -aes256 -passout pass:"${cipherText}" -out server.key 2048
      openssl rsa -in server.key -passin pass:"${cipherText}" -pubout -out rsa_public.key
      openssl req -new -key server.key -passin pass:"${cipherText}" -out server.csr -subj "/C=CN/ST=GD/L=SZ/O=Huawei/OU=ops/CN=*.huawei.com"
      openssl genrsa -out ca.key 2048
      openssl req -new -x509 -days 3650 -key ca.key -out ca-crt.pem -subj "/C=CN/ST=GD/L=SZ/O=Huawei/OU=dev/CN=ca"
      openssl x509 -req -days 3650 -in server.csr -CA ca-crt.pem -CAkey ca.key -CAcreateserial -out server.crt
      service nginx start &
      echo ${cipherText} > /etc/nginx/keys/fifo
      unset cipherText
      sh /usr/bin/tf_serving_entrypoint.sh

3. Modifique la ruta del modelo por defecto para admitir la carga dinámica del modelo de ModelArts.

   Ejecute los siguientes comandos en Dockerfile para cambiar la ruta predeterminada del modelo:

   ENV MODEL_BASE_PATH /home/mind
   ENV MODEL_NAME model

Ejemplo de Dockerfile:

FROM tensorflow/serving:2.8.0
RUN useradd -d /home/ma-user -m -u 1000 -g 100 -s /bin/bash ma-user
RUN apt-get update && apt-get -y --no-install-recommends install nginx && apt-get clean
RUN mkdir /home/mind && \
    mkdir -p /etc/nginx/keys && \
    mkfifo /etc/nginx/keys/fifo && \
    chown -R ma-user:100 /home/mind && \
    rm -rf /etc/nginx/conf.d/default.conf && \
    chown -R ma-user:100 /etc/nginx/ && \
    chown -R ma-user:100 /var/log/nginx && \
    chown -R ma-user:100 /var/lib/nginx && \
    sed -i "s#/var/run/nginx.pid#/home/ma-user/nginx.pid#g" /etc/init.d/nginx
ADD nginx /etc/nginx
ADD run.sh /home/mind/
ENV MODEL_BASE_PATH /home/mind
ENV MODEL_NAME model
ENTRYPOINT []
CMD /bin/bash /home/mind/run.sh

Migración de Triton

Esta sección utiliza la imagen nvcr.io/nvidia/tritonserver:23.03-py3 proporcionada por NVIDIA para la adaptación y el modelo de base de código abierto LLaMA 7B para la inferencia.

1. Agregue el usuario ma-user.

   El usuario triton-server, cuyo ID es 1000, existe en la imagen de Triton de forma predeterminada. Cambie el ID de usuario triton-server y agregue el usuario ma-user ejecutando este comando en Dockerfile.

   RUN usermod -u 1001 triton-server && useradd -d /home/ma-user -m -u 1000 -g 100 -s /bin/bash ma-user

2. Configure un proxy de Nginx para soportar HTTPS.
   1. Ejecute los siguientes comandos en Dockerfile para instalar y configurar Nginx:

      RUN apt-get update && apt-get -y --no-install-recommends install nginx && apt-get clean && \
          mkdir /home/mind && \
          mkdir -p /etc/nginx/keys && \
          mkfifo /etc/nginx/keys/fifo && \
          chown -R ma-user:100 /home/mind && \
          rm -rf /etc/nginx/conf.d/default.conf && \
          chown -R ma-user:100 /etc/nginx/ && \
          chown -R ma-user:100 /var/log/nginx && \
          chown -R ma-user:100 /var/lib/nginx && \
          sed -i "s#/var/run/nginx.pid#/home/ma-user/nginx.pid#g" /etc/init.d/nginx
   2. Cree el directorio de Nginx de la siguiente manera:

      nginx
      ├──nginx.conf
      └──conf.d
             ├── modelarts-model-server.conf
   3. Escriba el archivo nginx.conf.

      user ma-user 100;
      worker_processes 2;
      pid /home/ma-user/nginx.pid;
      include /etc/nginx/modules-enabled/*.conf;
      events {
          worker_connections 768;
      }
      http {
          ##
          # Basic Settings
          ##
          sendfile on;
          tcp_nopush on;
          tcp_nodelay on;
          types_hash_max_size 2048;
          fastcgi_hide_header X-Powered-By;
          port_in_redirect off;
          server_tokens off;
          client_body_timeout 65s;
          client_header_timeout 65s;
          keepalive_timeout 65s;
          send_timeout 65s;
          # server_names_hash_bucket_size 64;
          # server_name_in_redirect off;
          include /etc/nginx/mime.types;
          default_type application/octet-stream;
          ##
          # SSL Settings
          ##
          ssl_protocols TLSv1.2;
          ssl_prefer_server_ciphers on;
          ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256;
          ##
          # Logging Settings
          ##
          access_log /var/log/nginx/access.log;
          error_log /var/log/nginx/error.log;
          ##
          # Gzip Settings
          ##
          gzip on;
          ##
          # Virtual Host Configs
          ##
          include /etc/nginx/conf.d/modelarts-model-server.conf;
      }
   4. Escriba el archivo de configuración modelarts-model-server.conf.

      server {
          client_max_body_size 15M;
          large_client_header_buffers 4 64k;
          client_header_buffer_size 1k;
          client_body_buffer_size 16k;
          ssl_certificate /etc/nginx/ssl/server/server.crt;
          ssl_password_file /etc/nginx/keys/fifo;
          ssl_certificate_key /etc/nginx/ssl/server/server.key;
          # setting for mutual ssl with client
          ##
          # header Settings
          ##
          add_header X-XSS-Protection "1; mode=block";
          add_header X-Frame-Options SAMEORIGIN;
          add_header X-Content-Type-Options nosniff;
          add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";
          add_header Content-Security-Policy "default-src 'self'";
          add_header Cache-Control "max-age=0, no-cache, no-store, must-revalidate";
          add_header Pragma "no-cache";
          add_header Expires "-1";
          server_tokens off;
          port_in_redirect off;
          fastcgi_hide_header X-Powered-By;
          ssl_session_timeout 2m;
          ##
          # SSL Settings
          ##
          ssl_protocols TLSv1.2;
          ssl_prefer_server_ciphers on;
          ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256;
          listen    0.0.0.0:8080 ssl;
          error_page 502 503 /503.html;
          location /503.html {
              return 503 '{"error_code": "ModelArts.4503","error_msg": "Failed to connect to backend service, please confirm your service is connectable. "}';
          }
          location / {
      #       limit_req zone=mylimit;
      #       limit_req_status 429;
              proxy_pass http://127.0.0.1:8000;
          }
      }
   5. Cree un script de inicio run.sh.
      NOTA:

      Antes de ejecutar el script de inicio de Triton, debe crear un certificado de SSL.

      #!/bin/bash
      mkdir -p /etc/nginx/ssl/server && cd /etc/nginx/ssl/server
      cipherText=$(openssl rand -base64 32)
      openssl genrsa -aes256 -passout pass:"${cipherText}" -out server.key 2048
      openssl rsa -in server.key -passin pass:"${cipherText}" -pubout -out rsa_public.key
      openssl req -new -key server.key -passin pass:"${cipherText}" -out server.csr -subj "/C=CN/ST=GD/L=SZ/O=Huawei/OU=ops/CN=*.huawei.com"
      openssl genrsa -out ca.key 2048
      openssl req -new -x509 -days 3650 -key ca.key -out ca-crt.pem -subj "/C=CN/ST=GD/L=SZ/O=Huawei/OU=dev/CN=ca"
      openssl x509 -req -days 3650 -in server.csr -CA ca-crt.pem -CAkey ca.key -CAcreateserial -out server.crt
      service nginx start &
      echo ${cipherText} > /etc/nginx/keys/fifo
      unset cipherText
      
      bash /home/mind/model/triton_serving.sh

3. Prepare tensorrtllm_backend.
   1. Obtener el código de fuente de tensorrtllm_backend; instalar las dependencias (TensorRT, CMake y PyTorch); compilar e instalar.

      # get tensortllm_backend source code
      WORKDIR /opt/tritonserver
      RUN apt-get install -y --no-install-recommends rapidjson-dev python-is-python3 git-lfs && \
          git config --global http.sslVerify false && \
          git config --global http.postBuffer 1048576000 && \
          git clone -b v0.5.0 https://github.com/triton-inference-server/tensorrtllm_backend.git --depth 1 && \
          cd tensorrtllm_backend && git lfs install && \
          git config submodule.tensorrt_llm.url https://github.com/NVIDIA/TensorRT-LLM.git && \
          git submodule update --init --recursive --depth 1 && \
          pip3 install -r requirements.txt
      
      # build tensorrtllm_backend
      WORKDIR /opt/tritonserver/tensorrtllm_backend/tensorrt_llm
      RUN sed -i "s/wget/wget --no-check-certificate/g" docker/common/install_tensorrt.sh && \
          bash docker/common/install_tensorrt.sh && \
          export  LD_LIBRARY_PATH=/usr/local/tensorrt/lib:${LD_LIBRARY_PATH} && \
          sed -i "s/wget/wget --no-check-certificate/g" docker/common/install_cmake.sh && \
          bash docker/common/install_cmake.sh && \
          export PATH=/usr/local/cmake/bin:$PATH && \
          bash docker/common/install_pytorch.sh pypi && \
          python3 ./scripts/build_wheel.py --trt_root /usr/local/tensorrt && \
          pip install ./build/tensorrt_llm-0.5.0-py3-none-any.whl && \
          rm -f ./build/tensorrt_llm-0.5.0-py3-none-any.whl && \
          cd ../inflight_batcher_llm && bash scripts/build.sh && \
          mkdir /opt/tritonserver/backends/tensorrtllm && \
          cp ./build/libtriton_tensorrtllm.so /opt/tritonserver/backends/tensorrtllm/ && \
          chown -R ma-user:100 /opt/tritonserver
   2. Cree el script de inicio triton_serving.sh del Triton serving. A continuación se muestra un ejemplo para el modelo de LLaMA:

      MODEL_NAME=llama_7b
      MODEL_DIR=/home/mind/model/${MODEL_NAME}
      OUTPUT_DIR=/tmp/llama/7B/trt_engines/fp16/1-gpu/
      MAX_BATCH_SIZE=1
      export LD_LIBRARY_PATH=/usr/local/tensorrt/lib:${LD_LIBRARY_PATH}
      
      # build tensorrt_llm engine
      cd /opt/tritonserver/tensorrtllm_backend/tensorrt_llm/examples/llama
      python build.py --model_dir ${MODEL_DIR} \
                      --dtype float16 \
                      --remove_input_padding \
                      --use_gpt_attention_plugin float16 \
                      --enable_context_fmha \
                      --use_weight_only \
                      --use_gemm_plugin float16 \
                      --output_dir ${OUTPUT_DIR} \
                      --paged_kv_cache \
                      --max_batch_size ${MAX_BATCH_SIZE}
      
      # set config parameters
      cd /opt/tritonserver/tensorrtllm_backend
      mkdir triton_model_repo
      cp all_models/inflight_batcher_llm/* triton_model_repo/ -r
      
      python3 tools/fill_template.py -i triton_model_repo/preprocessing/config.pbtxt tokenizer_dir:${MODEL_DIR},tokenizer_type:llama,triton_max_batch_size:${MAX_BATCH_SIZE},preprocessing_instance_count:1
      python3 tools/fill_template.py -i triton_model_repo/postprocessing/config.pbtxt tokenizer_dir:${MODEL_DIR},tokenizer_type:llama,triton_max_batch_size:${MAX_BATCH_SIZE},postprocessing_instance_count:1
      python3 tools/fill_template.py -i triton_model_repo/ensemble/config.pbtxt triton_max_batch_size:${MAX_BATCH_SIZE}
      python3 tools/fill_template.py -i triton_model_repo/tensorrt_llm/config.pbtxt triton_max_batch_size:${MAX_BATCH_SIZE},decoupled_mode:False,max_beam_width:1,engine_dir:${OUTPUT_DIR},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:V1,max_queue_delay_microseconds:600
      
      # launch tritonserver
      python3 scripts/launch_triton_server.py --world_size 1 --model_repo=triton_model_repo/
      while true; do sleep 10000; done

      Descripción de algunos parámetros:

      • MODEL_NAME: nombre de la carpeta de OBS donde se almacena el archivo de ponderación del modelo en formato de Hugging Face.
      • OUTPUT_DIR: ruta al archivo de modelo convertido por TensorRT-LLM en el contenedor.

      El Dockerfile completo es el siguiente:

      FROM nvcr.io/nvidia/tritonserver:23.03-py3
      
      # add ma-user and install nginx
      RUN usermod -u 1001 triton-server && useradd -d /home/ma-user -m -u 1000 -g 100 -s /bin/bash ma-user && \
          apt-get update && apt-get -y --no-install-recommends install nginx && apt-get clean && \
          mkdir /home/mind && \
          mkdir -p /etc/nginx/keys && \
          mkfifo /etc/nginx/keys/fifo && \
          chown -R ma-user:100 /home/mind && \
          rm -rf /etc/nginx/conf.d/default.conf && \
          chown -R ma-user:100 /etc/nginx/ && \
          chown -R ma-user:100 /var/log/nginx && \
          chown -R ma-user:100 /var/lib/nginx && \
          sed -i "s#/var/run/nginx.pid#/home/ma-user/nginx.pid#g" /etc/init.d/nginx
      
      # get tensortllm_backend source code
      WORKDIR /opt/tritonserver
      RUN apt-get install -y --no-install-recommends rapidjson-dev python-is-python3 git-lfs && \
          git config --global http.sslVerify false && \
          git config --global http.postBuffer 1048576000 && \
          git clone -b v0.5.0 https://github.com/triton-inference-server/tensorrtllm_backend.git --depth 1 && \
          cd tensorrtllm_backend && git lfs install && \
          git config submodule.tensorrt_llm.url https://github.com/NVIDIA/TensorRT-LLM.git && \
          git submodule update --init --recursive --depth 1 && \
          pip3 install -r requirements.txt
      
      # build tensorrtllm_backend
      WORKDIR /opt/tritonserver/tensorrtllm_backend/tensorrt_llm
      RUN sed -i "s/wget/wget --no-check-certificate/g" docker/common/install_tensorrt.sh && \
          bash docker/common/install_tensorrt.sh && \
          export  LD_LIBRARY_PATH=/usr/local/tensorrt/lib:${LD_LIBRARY_PATH} && \
          sed -i "s/wget/wget --no-check-certificate/g" docker/common/install_cmake.sh && \
          bash docker/common/install_cmake.sh && \
          export PATH=/usr/local/cmake/bin:$PATH && \
          bash docker/common/install_pytorch.sh pypi && \
          python3 ./scripts/build_wheel.py --trt_root /usr/local/tensorrt && \
          pip install ./build/tensorrt_llm-0.5.0-py3-none-any.whl && \
          rm -f ./build/tensorrt_llm-0.5.0-py3-none-any.whl && \
          cd ../inflight_batcher_llm && bash scripts/build.sh && \
          mkdir /opt/tritonserver/backends/tensorrtllm && \
          cp ./build/libtriton_tensorrtllm.so /opt/tritonserver/backends/tensorrtllm/ && \
          chown -R ma-user:100 /opt/tritonserver
      
      ADD nginx /etc/nginx
      ADD run.sh /home/mind/
      CMD /bin/bash /home/mind/run.sh

      Una vez creada la imagen, regístrela con Huawei Cloud SWR para desplegar servicios de inferencia en ModelArts.

4. Utilice la imagen adaptada para desplegar de un servicio de inferencia en tiempo real en ModelArts.
   1. Cree un directorio model en OBS y cargue el archivo triton_serving.sh y la carpeta llama_7b en el directorio model.
      Figura 2 Carga de archivos en el directorio model
      
   2. Cree una aplicación de IA. Configure Meta Model Source como OBS y seleccione el metamodelo desde el directorio model. Configure AI Engine como Custom. Establezca Engine Package en la imagen creada en 3.
      Figura 3 Creación de una aplicación de IA
      
   3. Utilice la aplicación de IA creada como un servicio en tiempo real. Por lo general, el tiempo necesario para cargar e iniciar un modelo grande es largo al que el de un modelo común. Establezca Timeout en un valor adecuado. De lo contrario, el tiempo de espera puede transcurrir antes de la finalización de la puesta en marcha del modelo, y el despliegue puede fallar.
      Figura 4 Despliegue de un servicio en tiempo real
      
   4. Llama al servicio en tiempo real para la inferencia del modelo de la fundación. Establezca la ruta de la solicitud en /v2/models/ensemble/infer. A continuación se muestra un ejemplo de llamada:

      {
          "inputs": [
              {
                  "name": "text_input",
                  "shape": [1, 1],
                  "datatype": "BYTES",
                  "data": ["what is machine learning"]
              },
              {
                  "name": "max_tokens",
                  "shape": [1, 1],
                  "datatype": "UINT32",
                  "data": [64]
              },
              {
                  "name": "bad_words",
                  "shape": [1, 1],
                  "datatype": "BYTES",
                  "data": [""]
              },
              {
                  "name": "stop_words",
                  "shape": [1, 1],
                  "datatype": "BYTES",
                  "data": [""]
              },
              {
                  "name": "pad_id",
                  "shape": [1, 1],
                  "datatype": "UINT32",
                  "data": [2]
              },
              {
                  "name": "end_id",
                  "shape": [1, 1],
                  "datatype": "UINT32",
                  "data": [2]
              }
          ],
          "outputs": [
              {
                  "name": "text_output"
              }
          ]
      }
      NOTA:

      • En "inputs", el elemento con el "name" "text_input" representa la entrada, y su campo "data" especifica una sentencia de entrada concreta. En este ejemplo, la sentencia de entrada es "what is machine learning".
      • El elemento con el "name" "max_tokens" indica el número máximo de tokens de salida. En este caso, el valor es 64.
      Figura 5 Invocación a un servicio en tiempo real