Descripción de las matrices de puertas programables por campo (FPGA) y procedimiento para realizar la implementaciónWhat are field-programmable gate arrays (FPGA) and how to deploy

Se aplica a: síBasic Edition síEnterprise Edition                    (Actualización a Enterprise Edition)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

En este artículo se proporciona una introducción a las matrices de puertas programables por campo (FPGA) y se muestra cómo se pueden implementar los modelos mediante Azure Machine Learning en una FPGA de Azure.This article provides an introduction to field-programmable gate arrays (FPGA), and shows you how to deploy your models using Azure Machine Learning to an Azure FPGA.

Las FPGA contienen una matriz de bloques de lógica programables y una jerarquía de interconexiones reconfigurables.FPGAs contain an array of programmable logic blocks, and a hierarchy of reconfigurable interconnects. Las interconexiones permiten que estos bloques se configuren de distintas maneras después de su fabricación.The interconnects allow these blocks to be configured in various ways after manufacturing. Las FPGA ofrecen una combinación de capacidad de programación y rendimiento en comparación con otros chips.Compared to other chips, FPGAs provide a combination of programmability and performance.

FPGA en comparación con CPU, GPU y ASICFPGAs vs. CPU, GPU, and ASIC

El diagrama y la tabla siguientes muestran cómo se comparan las FPGA con otros procesadores.The following diagram and table show how FPGAs compare to other processors.

Diagrama de comparación de FPGA de Azure Machine Learning

ProcesadorProcessor DESCRIPCIÓNDescription
Circuitos integrados específicos de la aplicaciónApplication-specific integrated circuits ASICASICs Los circuitos personalizados, como las unidades de procesador TensorFlow (TPU) de Google, proporcionan la máxima eficacia.Custom circuits, such as Google's TensorFlow Processor Units (TPU), provide the highest efficiency. No pueden reconfigurarse según las necesidades.They can't be reconfigured as your needs change.
Matrices de puertas programables por campoField-programmable gate arrays FPGAFPGAs Las FPGA como, por ejemplo, las disponibles en Azure, proporcionan un rendimiento similar al de los ASIC.FPGAs, such as those available on Azure, provide performance close to ASICs. También son flexibles y se pueden volver a configurar con el tiempo, para implementar una lógica nueva.They are also flexible and reconfigurable over time, to implement new logic.
Unidades de procesamiento gráficoGraphics processing units GPUGPUs Una opción popular para los cálculos de inteligencia artificial.A popular choice for AI computations. GPU ofrece funcionalidades de procesamiento en paralelo, lo que permite una representación de imágenes más rápida que las CPU.GPUs offer parallel processing capabilities, making it faster at image rendering than CPUs.
Unidades centrales de procesamientoCentral processing units CPUCPUs Procesadores de uso general cuyo rendimiento no es óptimo para el procesamiento de vídeo y gráficos.General-purpose processors, the performance of which isn't ideal for graphics and video processing.

FPGA en Azure se basa en los dispositivos FPGA de Intel, cuyos datos usan los científicos de datos y los desarrolladores para acelerar los cálculos de IA en tiempo real.FPGAs on Azure are based on Intel's FPGA devices, which data scientists and developers use to accelerate real-time AI calculations. Esta arquitectura habilitada para FPGA ofrece rendimiento, flexibilidad y escalado, y está disponible en Azure.This FPGA-enabled architecture offers performance, flexibility, and scale, and is available on Azure.

Las FPGA permiten alcanzar una latencia baja para las solicitudes de inferencia en tiempo real (o puntuación del modelo).FPGAs make it possible to achieve low latency for real-time inference (or model scoring) requests. Las solicitudes asincrónicas (procesamiento por lotes) no son necesarias.Asynchronous requests (batching) aren't needed. El procesamiento por lotes puede causar latencia porque se deben procesar más datos.Batching can cause latency, because more data needs to be processed. Las implementaciones de unidades de procesamiento neuronal no requieren procesamiento por lotes; por lo tanto, la latencia puede ser muchas veces menor en comparación con los procesadores de CPU y GPU.Implementations of neural processing units don't require batching; therefore the latency can be many times lower, compared to CPU and GPU processors.

Capacidad reconfigurableReconfigurable power

Puede volver a configurar las FPGA para distintos tipos de modelos de aprendizaje automático.You can reconfigure FPGAs for different types of machine learning models. Esta flexibilidad facilita la aceleración de las aplicaciones en función del modelo de memoria y la precisión numérica más óptima que se usa.This flexibility makes it easier to accelerate the applications based on the most optimal numerical precision and memory model being used. Como las FPGA se pueden volver a configurar, puede mantenerse al día con los requisitos de los algoritmos de inteligencia artificial que están en constante evolución.Because FPGAs are reconfigurable, you can stay current with the requirements of rapidly changing AI algorithms.

Qué se admite en AzureWhat's supported on Azure

Microsoft Azure es la mayor inversión en la nube del mundo en FPGA.Microsoft Azure is the world's largest cloud investment in FPGAs. Con esta arquitectura de hardware habilitada para FPGA, las redes neurales entrenadas se ejecutan rápidamente y con una latencia menor.Using this FPGA-enabled hardware architecture, trained neural networks run quickly and with lower latency. Azure puede paralelizar redes neuronales profundas (DNN) entrenadas previamente en las FPGA para realizar el escalado horizontal del servicio.Azure can parallelize pre-trained deep neural networks (DNN) across FPGAs to scale out your service. Las DNN pueden entrenarse previamente, como un caracterizador profundo para la transferencia de aprendizaje o ajustarse con cargas actualizadas.The DNNs can be pre-trained, as a deep featurizer for transfer learning, or fine-tuned with updated weights.

FPGA en Azure es compatible con:FPGAs on Azure supports:

  • Escenarios de reconocimiento y clasificación de imágenesImage classification and recognition scenarios
  • Implementación de TensorFlowTensorFlow deployment
  • Hardware de FPGA de IntelIntel FPGA hardware

Actualmente están disponibles los siguientes modelos de DNN:These DNN models are currently available:

  • ResNet 50ResNet 50
  • ResNet 152ResNet 152
  • DenseNet-121DenseNet-121
  • VGG-16VGG-16
  • SSD-VGGSSD-VGG

Las FPGA están disponibles en estas regiones de Azure:FPGAs are available in these Azure regions:

  • East USEast US
  • Sudeste asiáticoSoutheast Asia
  • Europa occidentalWest Europe
  • Oeste de EE. UU. 2West US 2

Importante

Para optimizar el rendimiento y la latencia, el envío de datos del cliente al modelo de FPGA debe hacerse en una de las regiones anteriores (aquella en la que se haya implementado el modelo).To optimize latency and throughput, your client sending data to the FPGA model should be in one of the regions above (the one you deployed the model to).

La familia PBS de máquinas virtuales de Azure contiene matrices FPGA Intel Arria 10.The PBS Family of Azure VMs contains Intel Arria 10 FPGAs. Esto se mostrará como "Standard PBS Family vCPUs" (vCPU de la familia PBS estándar) al revisar la asignación de cuota de Azure.It will show as "Standard PBS Family vCPUs" when you check your Azure quota allocation. La máquina virtual PB6 tiene seis vCPU y una FPGA, y Azure ML la aprovisionará automáticamente como parte de la implementación de un modelo en una FPGA.The PB6 VM has six vCPUs and one FPGA, and it will automatically be provisioned by Azure ML as part of deploying a model to an FPGA. Solo se usa con Azure ML y no puede ejecutar secuencias de bits arbitrarias.It is only used with Azure ML, and it cannot run arbitrary bitstreams. Por ejemplo, no podrá incorporar a la FPGA secuencias de bits para realizar cifrado, codificación, etcétera.For example, you will not be able to flash the FPGA with bitstreams to do encryption, encoding, etc.

Escenarios y aplicacionesScenarios and applications

Las FPGA de Azure se integran con Azure Machine Learning.Azure FPGAs are integrated with Azure Machine Learning. Microsoft usa las FPGA para la evaluación de DNN, la clasificación de búsquedas de Bing y la aceleración de redes definidas por software (SDN) para reducir la latencia y liberar las CPU para otras tareas.Microsoft uses FPGAs for DNN evaluation, Bing search ranking, and software defined networking (SDN) acceleration to reduce latency, while freeing CPUs for other tasks.

En los siguientes escenarios se usan FPGA:The following scenarios use FPGAs:

Ejemplo: Implementación de modelos en FPGAExample: Deploy models on FPGAs

Puede implementar un modelo como servicio web en FPGA con modelos acelerados mediante hardware de Azure Machine Learning.You can deploy a model as a web service on FPGAs with Azure Machine Learning Hardware Accelerated Models. El uso de las FPGA brinda una inferencia de latencia ultrabaja, incluso con un tamaño de lote único.Using FPGAs provides ultra-low latency inference, even with a single batch size. Inferencia o modelo de puntuación, es la fase donde se usa el modelo implementado para la predicción, frecuentemente en datos de producción.Inference, or model scoring, is the phase where the deployed model is used for prediction, most commonly on production data.

Requisitos previosPrerequisites

  • Una suscripción de Azure.An Azure subscription. Si no tiene una, cree una cuenta gratuita antes de empezar.If you do not have one, create a free account before you begin. Pruebe hoy mismo la versión gratuita o de pago de Azure Machine Learning.Try the free or paid version of Azure Machine Learning today.

  • Cuota de FPGA.FPGA quota. Use la CLI de Azure para comprobar si dispone de cuota:Use the Azure CLI to check whether you have quota:

    az vm list-usage --location "eastus" -o table --query "[?localName=='Standard PBS Family vCPUs']"
    

    Sugerencia

    Las otras ubicaciones posibles son southeastasia, westeurope y westus2.The other possible locations are southeastasia, westeurope, and westus2.

    El comando devuelve un texto similar al siguiente:The command returns text similar to the following:

    CurrentValue    Limit    LocalName
    --------------  -------  -------------------------
    0               6        Standard PBS Family vCPUs
    

    Asegúrese de que tiene al menos 6 vCPU en CurrentValue.Make sure you have at least 6 vCPUs under CurrentValue.

    Si no tiene cuota, envíe una solicitud a https://aka.ms/accelerateAI.If you do not have quota, then submit a request at https://aka.ms/accelerateAI.

  • Un área de trabajo de Azure Machine Learning y el SDK de Azure Machine Learning para Python instalado.An Azure Machine Learning workspace and the Azure Machine Learning SDK for Python installed. Para obtener más información, consulte Create a workspace (Crear un área de trabajo).For more information, see Create a workspace.

  • El SDK de Python para modelos acelerados por hardware:The Python SDK for hardware-accelerated models:

    pip install --upgrade azureml-accel-models
    

1. Creación e inclusión de modelos en un contenedor1. Create and containerize models

En este documento se describe cómo crear un gráfico de TensorFlow para preprocesar la imagen de entrada, caracterizarla mediante ResNet 50 en una FPGA y, a continuación, ejecutar las características mediante un clasificador entrenado en el conjunto de datos de ImageNet.This document will describe how to create a TensorFlow graph to preprocess the input image, make it a featurizer using ResNet 50 on an FPGA, and then run the features through a classifier trained on the ImageNet data set.

Siga las instrucciones para:Follow the instructions to:

  • Definir el modelo de TensorFlowDefine the TensorFlow model
  • Convertir el modeloConvert the model
  • Implementación del modeloDeploy the model
  • Consumo del modelo implementadoConsume the deployed model
  • Eliminación de los servicios implementadosDelete deployed services

Use el SDK de Azure Machine Learning para Python para crear una definición de servicio.Use the Azure Machine Learning SDK for Python to create a service definition. Una definición de servicio es un archivo que describe una canalización de grafos (entrada, caracterizador y clasificador) basado en TensorFlow.A service definition is a file describing a pipeline of graphs (input, featurizer, and classifier) based on TensorFlow. El comando de implementación comprime automáticamente la definición y los grafos en un archivo ZIP, que cargará en Azure Blog Storage.The deployment command automatically compresses the definition and graphs into a ZIP file, and uploads the ZIP to Azure Blob storage. La DNN ya está implementada para ejecutarse en la FPGA.The DNN is already deployed to run on the FPGA.

Cargar el área de trabajo de Azure MLLoad Azure ML workspace

Cargue el área de trabajo de Azure ML.Load your Azure ML workspace.

import os
import tensorflow as tf

from azureml.core import Workspace

ws = Workspace.from_config()
print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep='\n')

Imagen de preprocesamientoPreprocess image

La entrada al servicio web es una imagen JPEG.The input to the web service is a JPEG image. El primer paso es descodificar la imagen JPEG y preprocesarla.The first step is to decode the JPEG image and preprocess it. Las imágenes JPEG se tratan como cadenas y el resultado son tensores que serán la entrada del modelo ResNet 50.The JPEG images are treated as strings and the result are tensors that will be the input to the ResNet 50 model.

# Input images as a two-dimensional tensor containing an arbitrary number of images represented a strings
import azureml.accel.models.utils as utils
tf.reset_default_graph()

in_images = tf.placeholder(tf.string)
image_tensors = utils.preprocess_array(in_images)
print(image_tensors.shape)

Carga de un caracterizadorLoad featurizer

Inicialice el modelo y descargue un punto de control de TensorFlow de la versión cuantificada de ResNet50 que se usará como caracterizador.Initialize the model and download a TensorFlow checkpoint of the quantized version of ResNet50 to be used as a featurizer. Puede reemplazar "QuantizedResnet50" en el fragmento de código siguiente mediante la importación de otras redes neuronales profundas:You may replace "QuantizedResnet50" in the code snippet below with by importing other deep neural networks:

  • QuantizedResnet152QuantizedResnet152
  • QuantizedVgg16QuantizedVgg16
  • Densenet121Densenet121
from azureml.accel.models import QuantizedResnet50
save_path = os.path.expanduser('~/models')
model_graph = QuantizedResnet50(save_path, is_frozen=True)
feature_tensor = model_graph.import_graph_def(image_tensors)
print(model_graph.version)
print(feature_tensor.name)
print(feature_tensor.shape)

Incorporación de un clasificadorAdd classifier

Este clasificador se ha entrenado en el conjunto de datos de ImageNet.This classifier has been trained on the ImageNet data set. Hay ejemplos disponibles para transferir aprendizaje y entrenamiento de las ponderaciones personalizadas en el conjunto de cuadernos de ejemplo.Examples for transfer learning and training your customized weights are available in the set of sample notebooks.

classifier_output = model_graph.get_default_classifier(feature_tensor)
print(classifier_output)

Guardar el modeloSave the model

Ahora que se han cargado el clasificador, el preprocesador y caracterizador de ResNet 50, guarde el gráfico y las variables asociadas como modelo.Now that the preprocessor, ResNet 50 featurizer, and the classifier have been loaded, save the graph and associated variables as a model.

model_name = "resnet50"
model_save_path = os.path.join(save_path, model_name)
print("Saving model in {}".format(model_save_path))

with tf.Session() as sess:
    model_graph.restore_weights(sess)
    tf.saved_model.simple_save(sess, model_save_path,
                               inputs={'images': in_images},
                               outputs={'output_alias': classifier_output})

Guardar los tensores de entrada y salidaSave input and output tensors

Los tensores de entrada y salida que se han creado durante los pasos de preprocesamiento y el clasificador serán necesarios para la inferencia y la conversión del modelo.The input and output tensors that were created during the preprocessing and classifier steps will be needed for model conversion and inference.

input_tensors = in_images.name
output_tensors = classifier_output.name

print(input_tensors)
print(output_tensors)

Importante

Guarde los tensores de entrada y salida porque los necesitará para las solicitudes de inferencia y conversión del modelo.Save the input and output tensors because you will need them for model conversion and inference requests.

Los modelos disponibles y los tensores de salida del clasificador predeterminado correspondiente se muestran a continuación, y es lo que se usaría para la inferencia si se ha usado el clasificador predeterminado.The available models and the corresponding default classifier output tensors are below, which is what you would use for inference if you used the default classifier.

  • Resnet50, QuantizedResnet50Resnet50, QuantizedResnet50
    output_tensors = "classifier_1/resnet_v1_50/predictions/Softmax:0"
    
  • Resnet152, QuantizedResnet152Resnet152, QuantizedResnet152
    output_tensors = "classifier/resnet_v1_152/predictions/Softmax:0"
    
  • Densenet121, QuantizedDensenet121Densenet121, QuantizedDensenet121
    output_tensors = "classifier/densenet121/predictions/Softmax:0"
    
  • Vgg16, QuantizedVgg16Vgg16, QuantizedVgg16
    output_tensors = "classifier/vgg_16/fc8/squeezed:0"
    
  • SsdVgg, QuantizedSsdVggSsdVgg, QuantizedSsdVgg
    output_tensors = ['ssd_300_vgg/block4_box/Reshape_1:0', 'ssd_300_vgg/block7_box/Reshape_1:0', 'ssd_300_vgg/block8_box/Reshape_1:0', 'ssd_300_vgg/block9_box/Reshape_1:0', 'ssd_300_vgg/block10_box/Reshape_1:0', 'ssd_300_vgg/block11_box/Reshape_1:0', 'ssd_300_vgg/block4_box/Reshape:0', 'ssd_300_vgg/block7_box/Reshape:0', 'ssd_300_vgg/block8_box/Reshape:0', 'ssd_300_vgg/block9_box/Reshape:0', 'ssd_300_vgg/block10_box/Reshape:0', 'ssd_300_vgg/block11_box/Reshape:0']
    

Registro del modeloRegister model

Registre el modelo mediante el SDK con el archivo .zip en Azure Blob Storage.Register the model by using the SDK with the ZIP file in Azure Blob storage. Agregar etiquetas y otros metadatos sobre el modelo le ayuda a realizar el seguimiento de los modelos entrenados.Adding tags and other metadata about the model helps you keep track of your trained models.

from azureml.core.model import Model

registered_model = Model.register(workspace=ws,
                                  model_path=model_save_path,
                                  model_name=model_name)

print("Successfully registered: ", registered_model.name,
      registered_model.description, registered_model.version, sep='\t')

Si ya se ha registrado un modelo y quiere cargarlo, puede recuperarlo.If you've already registered a model and want to load it, you may retrieve it.

from azureml.core.model import Model
model_name = "resnet50"
# By default, the latest version is retrieved. You can specify the version, i.e. version=1
registered_model = Model(ws, name="resnet50")
print(registered_model.name, registered_model.description,
      registered_model.version, sep='\t')

Conversión del modeloConvert model

Convierta el gráfico de TensorFlow al formato de intercambio de red neuronal abierta (ONNX).Convert the TensorFlow graph to the Open Neural Network Exchange format (ONNX). Deberá proporcionar los nombres de los tensores de entrada y salida y estos nombres los utilizará el cliente cuando se consuma el servicio web.You will need to provide the names of the input and output tensors, and these names will be used by your client when you consume the web service.

from azureml.accel import AccelOnnxConverter

convert_request = AccelOnnxConverter.convert_tf_model(
    ws, registered_model, input_tensors, output_tensors)

# If it fails, you can run wait_for_completion again with show_output=True.
convert_request.wait_for_completion(show_output=False)

# If the above call succeeded, get the converted model
converted_model = convert_request.result
print("\nSuccessfully converted: ", converted_model.name, converted_model.url, converted_model.version,
      converted_model.id, converted_model.created_time, '\n')

Creación de una imagen de DockerCreate Docker image

El modelo convertido y todas las dependencias se agregan a una imagen de Docker.The converted model and all dependencies are added to a Docker image. A continuación, se puede implementar esta imagen de Docker y se puede crear una instancia de ella.This Docker image can then be deployed and instantiated. Entre los destinos de implementación admitidos se incluye AKS en la nube o un dispositivo perimetral como Azure Data Box Edge.Supported deployment targets include AKS in the cloud or an edge device such as Azure Data Box Edge. También puede agregar etiquetas y descripciones para la imagen de Docker registrada.You can also add tags and descriptions for your registered Docker image.

from azureml.core.image import Image
from azureml.accel import AccelContainerImage

image_config = AccelContainerImage.image_configuration()
# Image name must be lowercase
image_name = "{}-image".format(model_name)

image = Image.create(name=image_name,
                     models=[converted_model],
                     image_config=image_config,
                     workspace=ws)
image.wait_for_creation(show_output=False)

Enumere las imágenes por etiqueta y obtenga los registros detallados para cualquier tipo de depuración.List the images by tag and get the detailed logs for any debugging.

for i in Image.list(workspace=ws):
    print('{}(v.{} [{}]) stored at {} with build log {}'.format(
        i.name, i.version, i.creation_state, i.image_location, i.image_build_log_uri))

2. Implementación en la nube o perimetral2. Deploy to cloud or edge

Implementación en la nubeDeploy to the cloud

Para implementar el modelo como un servicio web de producción a gran escala, use Azure Kubernetes Service (AKS).To deploy your model as a high-scale production web service, use Azure Kubernetes Service (AKS). Puede crear uno con el SDK de Azure Machine Learning, la CLI o Azure Machine Learning Studio.You can create a new one using the Azure Machine Learning SDK, CLI, or Azure Machine Learning studio.

from azureml.core.compute import AksCompute, ComputeTarget

# Specify the Standard_PB6s Azure VM and location. Values for location may be "eastus", "southeastasia", "westeurope", or "westus2”. If no value is specified, the default is "eastus".
prov_config = AksCompute.provisioning_configuration(vm_size = "Standard_PB6s",
                                                    agent_count = 1,
                                                    location = "eastus")

aks_name = 'my-aks-cluster'
# Create the cluster
aks_target = ComputeTarget.create(workspace=ws,
                                  name=aks_name,
                                  provisioning_configuration=prov_config)

La implementación de AKS puede tardar unos 15 minutos.The AKS deployment may take around 15 minutes. Compruebe que la implementación se ha realizado correctamente.Check to see if the deployment succeeded.

aks_target.wait_for_completion(show_output=True)
print(aks_target.provisioning_state)
print(aks_target.provisioning_errors)

Implemente el contenedor en el clúster de AKS.Deploy the container to the AKS cluster.

from azureml.core.webservice import Webservice, AksWebservice

# For this deployment, set the web service configuration without enabling auto-scaling or authentication for testing
aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False,
                                                num_replicas=1,
                                                auth_enabled=False)

aks_service_name = 'my-aks-service'

aks_service = Webservice.deploy_from_image(workspace=ws,
                                           name=aks_service_name,
                                           image=image,
                                           deployment_config=aks_config,
                                           deployment_target=aks_target)
aks_service.wait_for_deployment(show_output=True)

Prueba del servicio en la nubeTest the cloud service

La imagen de Docker admite gRPC y la API de "predicción" de TensorFlow Serving.The Docker image supports gRPC and the TensorFlow Serving "predict" API. Use el cliente de ejemplo para llamar a la imagen de Docker y obtener predicciones a partir del modelo.Use the sample client to call into the Docker image to get predictions from the model. Hay código de cliente de ejemplo disponible:Sample client code is available:

Si quiere usar TensorFlow Serving, puede descargar un cliente de ejemplo.If you want to use TensorFlow Serving, you can download a sample client.

# Using the grpc client in Azure ML Accelerated Models SDK package
from azureml.accel import PredictionClient

address = aks_service.scoring_uri
ssl_enabled = address.startswith("https")
address = address[address.find('/')+2:].strip('/')
port = 443 if ssl_enabled else 80

# Initialize AzureML Accelerated Models client
client = PredictionClient(address=address,
                          port=port,
                          use_ssl=ssl_enabled,
                          service_name=aks_service.name)

Puesto que este clasificador se ha entrenado en el conjunto de datos ImageNet, asigne las clases a etiquetas de lenguaje natural.Since this classifier was trained on the ImageNet data set, map the classes to human-readable labels.

import requests
classes_entries = requests.get(
    "https://raw.githubusercontent.com/Lasagne/Recipes/master/examples/resnet50/imagenet_classes.txt").text.splitlines()

# Score image with input and output tensor names
results = client.score_file(path="./snowleopardgaze.jpg",
                            input_name=input_tensors,
                            outputs=output_tensors)

# map results [class_id] => [confidence]
results = enumerate(results)
# sort results by confidence
sorted_results = sorted(results, key=lambda x: x[1], reverse=True)
# print top 5 results
for top in sorted_results[:5]:
    print(classes_entries[top[0]], 'confidence:', top[1])

Limpieza del servicioClean-up the service

Elimine el servicio web, la imagen y el modelo (se debe realizar en este orden, ya que existen dependencias).Delete your web service, image, and model (must be done in this order since there are dependencies).

aks_service.delete()
aks_target.delete()
image.delete()
registered_model.delete()
converted_model.delete()

Implementación en un servidor perimetral localDeploy to a local edge server

Todos los dispositivos perimetrales de Azure Data Box Edge contienen una FPGA para ejecutar el modelo.All Azure Data Box Edge devices contain an FPGA for running the model. Solo se puede ejecutar un único modelo en la FPGA al mismo tiempo.Only one model can be running on the FPGA at one time. Para ejecutar otro modelo, basta con implementar un nuevo contenedor.To run a different model, just deploy a new container. Pueden encontrarse instrucciones y código de ejemplo en este ejemplo de Azure.Instructions and sample code can be found in this Azure Sample.

Protección de los servicios web FPGASecure FPGA web services

Para proteger los servicios web FPGA, consulte el documento Protección de servicios web.To secure your FPGA web services, see the Secure web services document.

Pasos siguientesNext steps

Consulte estos cuadernos, vídeos y blogs:Check out these notebooks, videos, and blogs: