Distribuera ML-modeller till fältprogrammerbara gatematriser (FPGA) med Azure Machine Learning

Artikel
01/10/2024

I den här artikeln får du lära dig mer om FPGA:er och hur du distribuerar dina ML-modeller till en Azure FPGA med hjälp av python-paketet med maskinvaruaccelererade modeller från Azure Machine Learning.

Vad är FPGA?

En FPGA innehåller en matris med programmerbara logiska block och en hierarki med omkonfigurerbara anslutningar. Med sammanlänkningarna kan dessa block konfigureras på olika sätt efter tillverkningen. Jämfört med andra chips ger FPGA en kombination av programmerbarhet och prestanda.

FPGA:er gör det möjligt att uppnå låg svarstid för begäranden om slutsatsdragning i realtid (eller modellbedömning). Asynkrona begäranden (batchbearbetning) behövs inte. Batchbearbetning kan orsaka svarstid eftersom mer data måste bearbetas. Implementeringar av neurala bearbetningsenheter kräver inte batchbearbetning. Därför kan svarstiden vara många gånger lägre jämfört med CPU- och GPU-processorer.

Du kan konfigurera om FPGA:er för olika typer av maskininlärningsmodeller. Den här flexibiliteten gör det enklare att påskynda programmen baserat på den mest optimala numeriska precisions- och minnesmodellen som används. Eftersom FPGA:er kan konfigureras om kan du hålla dig uppdaterad med kraven på snabbt föränderliga AI-algoritmer.

Diagram of Azure Machine Learning FPGA comparison

Processor	Förkortning	beskrivning
Programspecifika integrerade kretsar	Asics	Anpassade kretsar, till exempel Googles TPU (Tensor Processor Units), ger högsta effektivitet. De kan inte konfigureras om när dina behov ändras.
Fältprogrammabla gatematriser	FPGA:er	FPGA:er, till exempel de som är tillgängliga i Azure, ger prestanda nära ASIC:er. De är också flexibla och omkonfigurerbara över tid för att implementera ny logik.
Grafikbearbetningsenheter	GPU: er	Ett populärt val för AI-beräkningar. GPU:er erbjuder parallella bearbetningsfunktioner, vilket gör det snabbare vid bildåtergivning än processorer.
Centrala bearbetningsenheter	CPU:er	Processorer för generell användning, vars prestanda inte är idealisk för grafik- och videobearbetning.

FPGA-stöd i Azure

Microsoft Azure är världens största molninvestering i FPGA:er. Microsoft använder FPGA:er för utvärdering av djupa neurala nätverk (DNN), Bing-sökrankning och SDN-acceleration (software defined networking) för att minska svarstiden, samtidigt som processorer frigörs för andra uppgifter.

FPGA:er i Azure baseras på Intels FPGA-enheter, som dataexperter och utvecklare använder för att påskynda AI-beräkningar i realtid. Den här FPGA-aktiverade arkitekturen erbjuder prestanda, flexibilitet och skalning och är tillgänglig i Azure.

Azure FPGA:er är integrerade med Azure Machine Learning. Azure kan parallellisera förtränade DNN mellan FPGA:er för att skala ut din tjänst. DNN:erna kan förtränas som en djup funktionaliserare för överföringsinlärning eller finjusteras med uppdaterade vikter.

Scenarier och konfigurationer i Azure	DNN-modeller som stöds	Regionalt stöd
+ Scenarier för bildklassificering och igenkänning + TensorFlow-distribution (kräver Tensorflow 1.x) + Intel FPGA-maskinvara	– ResNet 50 – ResNet 152 – DenseNet-121 - VGG-16 - SSD-VGG	- USA, östra -Sydostasien - Europa, västra - USA, västra 2

För att optimera svarstid och dataflöde bör klienten som skickar data till FPGA-modellen finnas i en av regionerna ovan (den som du distribuerade modellen till).

PBS-serien med virtuella Azure-datorer innehåller Intel Arria 10 FPGA:er. Den visas som "Standard PBS Family vCPU:er" när du kontrollerar din Azure-kvotallokering. Den virtuella PB6-datorn har sex vCPU:er och en FPGA. DEN virtuella PB6-datorn etableras automatiskt av Azure Machine Learning under modelldistributionen till en FPGA. Den används bara med Azure Machine Learning och kan inte köra godtyckliga bitstreams. Du kommer till exempel inte att kunna flasha FPGA med bitströms för att utföra kryptering, kodning osv.

Distribuera modeller på FPGA:er

Du kan distribuera en modell som en webbtjänst på FPGA:er med Azure Machine Learning Hardware Accelerated Models. Användning av FPGA:er ger slutsatsdragning med extremt låg svarstid, även med en enda batchstorlek.

I det här exemplet skapar du ett TensorFlow-diagram för att förbearbeta indatabilden, gör den till en funktionaliserare med ResNet 50 på en FPGA och kör sedan funktionerna via en klassificerare som tränats på ImageNet-datauppsättningen. Sedan distribueras modellen till ett AKS-kluster.

Förutsättningar

En Azure-prenumeration. Om du inte har ett skapar du ett betala per användning-konto (kostnadsfria Azure-konton är inte berättigade till FPGA-kvot).
En Azure Machine Learning-arbetsyta och Azure Machine Learning SDK för Python installerat enligt beskrivningen i Skapa en arbetsyta.
Paketet med maskinvaruaccelererade modeller: pip install --upgrade azureml-accel-models[cpu]
Azure CLI
FPGA-kvot. Skicka en begäran om kvot eller kör det här CLI-kommandot för att kontrollera kvoten:
```
az vm list-usage --location "eastus" -o table --query "[?localName=='Standard PBS Family vCPUs']"
```
Kontrollera att du har minst 6 vCPU:er under CurrentValue som returneras.

Definiera TensorFlow-modellen

Börja med att använda Azure Machine Learning SDK för Python för att skapa en tjänstdefinition. En tjänstdefinition är en fil som beskriver en pipeline med grafer (indata, funktionaliserare och klassificerare) baserat på TensorFlow. Distributionskommandot komprimerar definitionen och graferna till en ZIP-fil och laddar upp ZIP-filen till Azure Blob Storage. DNN har redan distribuerats för att köras på FPGA.

Läs in Azure Machine Learning-arbetsytan

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

Förbearbeta avbildning. Indata till webbtjänsten är en JPEG-bild. Det första steget är att avkoda JPEG-avbildningen och förbearbeta den. JPEG-bilderna behandlas som strängar och resultatet är tensorer som kommer att vara indata till ResNet 50-modellen.

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

Läs in featurizer. Initiera modellen och ladda ned en TensorFlow-kontrollpunkt för den kvantiserade versionen av ResNet50 som ska användas som en funktionaliserare. Ersätt "QuantizedResnet50" i kodfragmentet för att importera andra djupa neurala nätverk:
- QuantizedResnet152
- QuantizedVgg16
- Densenet121
```
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)
```

Lägg till en klassificerare. Den här klassificeraren tränades på ImageNet-datauppsättningen.

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

Spara modellen. Nu när förprocessorn, ResNet 50 featurizer och klassificeraren har lästs in sparar du grafen och associerade variabler som en modell.

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

Spara in- och utdata tensorer som du kommer att använda dem för modellkonvertering och slutsatsdragningsbegäranden.

input_tensors = in_images.name
output_tensors = classifier_output.name

print(input_tensors)
print(output_tensors)

Följande modeller visas med deras klassificerare utdata tensorer för slutsatsdragning om du använde standardklassificeraren.

Resnet50, QuantizedResnet50

output_tensors = "classifier_1/resnet_v1_50/predictions/Softmax:0"

Resnet152, QuantizedResnet152

output_tensors = "classifier/resnet_v1_152/predictions/Softmax:0"

Densenet121, QuantizedDensenet121

output_tensors = "classifier/densenet121/predictions/Softmax:0"

Vgg16, QuantizedVgg16

output_tensors = "classifier/vgg_16/fc8/squeezed:0"

SsdVgg, 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']

Konvertera modellen till Open Neural Network Exchange-format (ONNX)

Innan du kan distribuera till FPGA:er konverterar du modellen till ONNX-format .

Registrera modellen med hjälp av SDK med ZIP-filen i Azure Blob Storage. Genom att lägga till taggar och andra metadata om modellen kan du hålla reda på dina tränade modeller.

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

Om du redan har registrerat en modell och vill läsa in den kan du hämta den.

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

Konvertera TensorFlow-grafen till ONNX-formatet. Du måste ange namnen på tensorerna för indata och utdata, så att klienten kan använda dem när du använder webbtjänsten.

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

Containerisera och distribuera modellen

Skapa sedan en Docker-avbildning från den konverterade modellen och alla beroenden. Den här Docker-avbildningen kan sedan distribueras och instansieras. Distributionsmål som stöds omfattar Azure Kubernetes Service (AKS) i molnet eller en gränsenhet som Azure Stack Edge. Du kan också lägga till taggar och beskrivningar för din registrerade Docker-avbildning.

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)

Visa en lista över avbildningar efter tagg och hämta detaljerade loggar för felsökning.

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

Distribuera till ett Azure Kubernetes Service-kluster

Om du vill distribuera din modell som en storskalig produktionswebbtjänst använder du AKS. Du kan skapa en ny med hjälp av Azure Machine Learning SDK, CLI eller 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)

AKS-distributionen kan ta cirka 15 minuter. Kontrollera om distributionen lyckades.

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

Distribuera containern till AKS-klustret.

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)

Distribuera till en lokal gränsserver

Alla Azure Stack Edge-enheter innehåller en FPGA för att köra modellen. Endast en modell kan köras på FPGA i taget. Om du vill köra en annan modell distribuerar du bara en ny container. Instruktioner och exempelkod finns i det här Azure-exemplet.

Använda den distribuerade modellen

Slutligen använder du exempelklienten för att anropa till Docker-avbildningen för att hämta förutsägelser från modellen. Exempelklientkod är tillgänglig:

Python
C#

Docker-avbildningen stöder gRPC och TensorFlow-server -API:et "predict".

Du kan också ladda ned en exempelklient för TensorFlow-servering.

# Using the grpc client in Azure Machine Learning 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 Azure Machine Learning Accelerated Models client
client = PredictionClient(address=address,
                          port=port,
                          use_ssl=ssl_enabled,
                          service_name=aks_service.name)

Eftersom den här klassificeraren har tränats på ImageNet-datauppsättningen mappar du klasserna till etiketter som kan läsas av människor.

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

Rensa resurser

För att undvika onödiga kostnader rensar du dina resurser i den här ordningen: webbtjänst, sedan bild och sedan modellen.

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

Nästa steg

Lär dig hur du skyddar webbtjänstdokumentet .
Lär dig mer om priser och kostnader för FPGA och Azure Machine Learning.
Hyperskala maskinvara: ML i stor skala ovanpå Azure + FPGA: Build 2018 (video)
Project Brainwave för AI i realtid
Automatiserat optiskt inspektionssystem

Share via