Wdrażanie modeli ML do opartych na programowalnych tablic bram (FPGA) z Azure Machine LearningDeploy ML models to field-programmable gate arrays (FPGAs) with Azure Machine Learning

Ten artykuł zawiera informacje na temat FPGA i sposobu wdrażania modeli ML na platformie Azure FPGA przy użyciu pakietu języka Python z przyspieszeniem sprzętowym z Azure Machine Learning.In this article, you learn about FPGAs and how to deploy your ML models to an Azure FPGA using the hardware-accelerated models Python package from Azure Machine Learning.

Co to są FPGA?What are FPGAs?

Układy FPGA zawierają tablicę programowalnych bloków logicznych i hierarchię możliwych do ponownego skonfigurowania wzajemnych połączeń.FPGAs contain an array of programmable logic blocks, and a hierarchy of reconfigurable interconnects. Połączenia międzyłączne umożliwiają skonfigurowanie tych bloków na różne sposoby po zakończeniu produkcji.The interconnects allow these blocks to be configured in various ways after manufacturing. W porównaniu z innymi mikroukładami FPGA zapewniają kombinację programowania i wydajności.Compared to other chips, FPGAs provide a combination of programmability and performance.

FPGA umożliwiają osiągnięcie małych opóźnień dla żądań wnioskowania w czasie rzeczywistym (lub oceniania modeli).FPGAs make it possible to achieve low latency for real-time inference (or model scoring) requests. Żądania asynchroniczne (wsadowe) nie są potrzebne.Asynchronous requests (batching) aren't needed. Przetwarzanie wsadowe może spowodować opóźnienia, ponieważ trzeba przetworzyć więcej danych.Batching can cause latency, because more data needs to be processed. Implementacje jednostek przetwarzania neuronowych nie wymagają przetwarzania wsadowego; w związku z tym opóźnienie może być znacznie mniejsze, w porównaniu z procesorami CPU i procesora GPU.Implementations of neural processing units don't require batching; therefore the latency can be many times lower, compared to CPU and GPU processors.

Można ponownie skonfigurować FPGA dla różnych typów modeli uczenia maszynowego.You can reconfigure FPGAs for different types of machine learning models. Ta elastyczność ułatwia przyspieszenie aplikacji w oparciu o najbardziej optymalną precyzję liczbową i używany model pamięci.This flexibility makes it easier to accelerate the applications based on the most optimal numerical precision and memory model being used. Ze względu na to, że FPGA są modyfikowane, można zachować aktualność z wymaganiami natychmiastowej zmiany algorytmów AI.Because FPGAs are reconfigurable, you can stay current with the requirements of rapidly changing AI algorithms.

Diagram Azure Machine Learning porównania FPGA

ProcesorProcessor SkrótAbbreviation OpisDescription
Zintegrowane obwody specyficzne dla aplikacjiApplication-specific integrated circuits ASICsASICs Obwody niestandardowe, takie jak jednostki procesora (TPU) firmy Google, zapewniają najwyższą wydajność.Custom circuits, such as Google's Tensor Processor Units (TPU), provide the highest efficiency. Nie można ich ponownie skonfigurować zgodnie z potrzebami zmian.They can't be reconfigured as your needs change.
Programowalne tablice bramField-programmable gate arrays Układy FPGAFPGAs FPGA, takie jak te dostępne na platformie Azure, zapewniają wydajność zbliżoną do ASICs.FPGAs, such as those available on Azure, provide performance close to ASICs. Są one również elastyczne i można je skonfigurować w miarę upływu czasu w celu zaimplementowania nowej logiki.They are also flexible and reconfigurable over time, to implement new logic.
Jednostki przetwarzania grafikiGraphics processing units Procesory GPUGPUs Popularny wybór dla obliczeń AI.A popular choice for AI computations. Procesory GPU oferują równoległe możliwości przetwarzania, przyspieszając renderowanie obrazów niż procesory CPU.GPUs offer parallel processing capabilities, making it faster at image rendering than CPUs.
Jednostki przetwarzania centralnegoCentral processing units Procesory CPUCPUs Procesor ogólnego przeznaczenia, wydajność, która nie jest idealnym rozwiązaniem w przypadku przetwarzania grafiki i wideo.General-purpose processors, the performance of which isn't ideal for graphics and video processing.

Obsługa FPGA na platformie AzureFPGA support in Azure

Microsoft Azure to największe inwestycje chmury w FPGA.Microsoft Azure is the world's largest cloud investment in FPGAs. Firma Microsoft używa usługi FPGA do oceny usługi głębokiej sieci neuronowych (DNN), klasyfikacji wyszukiwania Bing i przyspieszenia sieci zdefiniowanej przez oprogramowanie (SDN), aby ograniczyć opóźnienia, a jednocześnie zwalniając procesory dla innych zadań.Microsoft uses FPGAs for deep neural networks (DNN) evaluation, Bing search ranking, and software defined networking (SDN) acceleration to reduce latency, while freeing CPUs for other tasks.

FPGA na platformie Azure są oparte na urządzeniach FPGA firmy Intel, których analityki danych i Deweloperzy używają do przyspieszenia obliczeń w czasie rzeczywistym.FPGAs on Azure are based on Intel's FPGA devices, which data scientists and developers use to accelerate real-time AI calculations. Ta architektura z obsługą FPGA oferuje wydajność, elastyczność i skalowalność oraz jest dostępna na platformie Azure.This FPGA-enabled architecture offers performance, flexibility, and scale, and is available on Azure.

Usługa Azure FPGA jest zintegrowana z usługą Azure Machine Learning.Azure FPGAs are integrated with Azure Machine Learning. Platforma Azure może zrównoleglanie wstępnie przeszkolony DNN w firmie FPGA w celu skalowania w poziomie usługi.Azure can parallelize pre-trained DNN across FPGAs to scale out your service. DNNsy mogą być wstępnie nauczone, jako głębokie featurized do uczenia w zakresie transferu, lub precyzyjnie dopasowane do zaktualizowanych wag.The DNNs can be pre-trained, as a deep featurizer for transfer learning, or fine-tuned with updated weights.

Scenariusze & konfiguracje na platformie AzureScenarios & configurations on Azure Obsługiwane modele DNNSupported DNN models Wsparcie regionalneRegional support
+ Scenariusze klasyfikacji i rozpoznawania obrazów+ Image classification and recognition scenarios
+ Wdrożenie TensorFlow (wymaga Tensorflow 1. x)+ TensorFlow deployment (requires Tensorflow 1.x)
+ Sprzęt Intel FPGA+ Intel FPGA hardware
-ResNet 50- ResNet 50
-ResNet 152- ResNet 152
-DenseNet-121- DenseNet-121
-VGG-16- VGG-16
-SSD-VGG- SSD-VGG
— Wschodnie stany USA- East US
— Azja Południowo-Wschodnia- Southeast Asia
— Europa Zachodnia- West Europe
— Zachodnie stany USA 2- West US 2

Aby zoptymalizować opóźnienia i przepływność, klient wysyłający dane do modelu FPGA powinien znajdować się w jednym z powyższych regionów (na którym został wdrożony model).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).

Rodzina PBS maszyn wirtualnych platformy Azure zawiera technologię Intel Arria 10 FPGA.The PBS Family of Azure VMs contains Intel Arria 10 FPGAs. Zostanie on wyświetlony jako "standardowa rodzina PBS procesorów wirtualnych vCPU" podczas sprawdzania przydziału przydziału platformy Azure.It will show as "Standard PBS Family vCPUs" when you check your Azure quota allocation. Maszyna wirtualna PB6 ma sześć procesorów wirtualnych vCPU i jeden FPGA.The PB6 VM has six vCPUs and one FPGA. Maszyna wirtualna w PB6 jest automatycznie obsługiwana przez Azure Machine Learning podczas wdrażania modelu w FPGA.PB6 VM is automatically provisioned by Azure Machine Learning during model deployment to an FPGA. Jest ona używana tylko z platformą Azure ML i nie może uruchamiać dowolnego bitstreams.It is only used with Azure ML, and it cannot run arbitrary bitstreams. Na przykład nie będzie można wykonać czynności Flash FPGA z bitstreams do szyfrowania, kodowania itp.For example, you will not be able to flash the FPGA with bitstreams to do encryption, encoding, etc.

Wdróż modele na FPGADeploy models on FPGAs

Model można wdrożyć jako usługę sieci Web na FPGA z Modele z przyspieszaniem sprzętowym Azure Machine Learning.You can deploy a model as a web service on FPGAs with Azure Machine Learning Hardware Accelerated Models. Korzystanie z usługi FPGA zapewnia bardzo małe ilości opóźnienia, nawet w przypadku pojedynczego rozmiaru partii.Using FPGAs provides ultra-low latency inference, even with a single batch size.

W tym przykładzie utworzysz Graf TensorFlow na potrzeby wstępnego przetwarzania obrazu wejściowego, ustaw go jako featurized przy użyciu ResNet 50 na FPGA, a następnie uruchom funkcje za pośrednictwem klasyfikatora przeszkolonego na zestawie danych ImageNet.In this example, you 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. Następnie model jest wdrażany w klastrze AKS.Then, the model is deployed to an AKS cluster.

Wymagania wstępnePrerequisites

  • Subskrypcja platformy Azure.An Azure subscription. Jeśli go nie masz, Utwórz konto z płatnością zgodnie z rzeczywistym użyciem (bezpłatne konta platformy Azure nie kwalifikują się do przydziału FPGA).If you do not have one, create a pay-as-you-go account (free Azure accounts are not eligible for FPGA quota).

  • Azure Machine Learning obszar roboczy i zestaw Azure Machine Learning SDK dla języka Python, zgodnie z opisem w temacie Tworzenie obszaru roboczego.An Azure Machine Learning workspace and the Azure Machine Learning SDK for Python installed, as described in Create a workspace.

  • Pakiet modeli przyspieszanych sprzętowo: pip install --upgrade azureml-accel-models[cpu]The hardware-accelerated models package: pip install --upgrade azureml-accel-models[cpu]

  • Interfejs wiersza polecenia platformy AzureThe Azure CLI

  • Limit przydziału FPGA.FPGA quota. Prześlij żądanie przydzielenia limitu przydziałulub Uruchom to polecenie interfejsu wiersza polecenia, aby sprawdzić limit przydziału:Submit a request for quota, or run this CLI command to check quota:

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

    Upewnij się, że masz co najmniej 6 procesorów wirtualnych vCPU pod zwróconym CurrentValue .Make sure you have at least 6 vCPUs under the CurrentValue returned.

Zdefiniuj model TensorFlowDefine the TensorFlow model

Aby utworzyć definicję usługi, Zacznij od użycia zestawu SDK Azure Machine Learning dla języka Python .Begin by using the Azure Machine Learning SDK for Python to create a service definition. Definicja usługi jest plikiem opisującym potok grafów (Input, featurized i klasyfikator) oparty na TensorFlow.A service definition is a file describing a pipeline of graphs (input, featurizer, and classifier) based on TensorFlow. Polecenie wdrażania kompresuje definicje i wykresy do pliku ZIP i przekazuje je do usługi Azure Blob Storage.The deployment command compresses the definition and graphs into a ZIP file, and uploads the ZIP to Azure Blob storage. DNN jest już wdrożony do uruchamiania na FPGA.The DNN is already deployed to run on the FPGA.

  1. Załaduj obszar roboczy Azure Machine LearningLoad Azure Machine Learning 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')
    
  2. Obraz wstępnie przetworzony.Preprocess image. Wejście do usługi sieci Web jest obrazem JPEG.The input to the web service is a JPEG image. Pierwszym krokiem jest Dekodowanie obrazu JPEG i jego wstępne przetworzenie.The first step is to decode the JPEG image and preprocess it. Obrazy JPEG są traktowane jako ciągi, a wynikiem są dwuplikowe dane wejściowe modelu 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)
    
  3. Ładuj featurized.Load featurizer. Zainicjuj model i Pobierz punkt kontrolny TensorFlow wersji ResNet50, który będzie używany jako featurized.Initialize the model and download a TensorFlow checkpoint of the quantized version of ResNet50 to be used as a featurizer. Zastąp ciąg "QuantizedResnet50" w fragmencie kodu, aby zaimportować inne głębokie sieci neuronowych:Replace "QuantizedResnet50" in the code snippet to import 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)
    
  4. Dodaj klasyfikator.Add a classifier. Ten klasyfikator został przeszkolony na zestawie danych ImageNet.This classifier was trained on the ImageNet data set.

    classifier_output = model_graph.get_default_classifier(feature_tensor)
    print(classifier_output)
    
  5. Zapisz model.Save the model. Teraz, gdy preprocesor, ResNet 50 featurized i klasyfikator został załadowany, Zapisz wykres i skojarzone zmienne jako model.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})
    
  6. Zapisz natężenia danych wejściowych i wyjściowych , ponieważ będą one używane do konwersji modeli i żądań wnioskowania.Save input and output tensors as you will use them for model conversion and inference requests.

    input_tensors = in_images.name
    output_tensors = classifier_output.name
    
    print(input_tensors)
    print(output_tensors)
    

    Następujące modele są dostępne z licznikami wyjściowymi klasyfikatora dla wnioskowania, jeśli użyto klasyfikatora domyślnego.The following models are available listed with their classifier output tensors 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']
      

Konwertuj model na otwarty format neuronowych Network Exchange (ONNX)Convert the model to the Open Neural Network Exchange format (ONNX)

Aby można było wdrożyć program w programie FPGA, należy przekonwertować model do formatu ONNX .Before you can deploy to FPGAs, convert the model to the ONNX format.

  1. Zarejestruj model przy użyciu zestawu SDK z plikiem zip w usłudze Azure Blob Storage.Register the model by using the SDK with the ZIP file in Azure Blob storage. Dodawanie tagów i innych metadanych dotyczących modelu ułatwia śledzenie przeszkolonych modeli.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')
    

    Jeśli model został już zarejestrowany i chcesz go załadować, możesz go pobrać.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')
    
  2. Przekonwertuj wykres TensorFlow na format ONNX.Convert the TensorFlow graph to the ONNX format. Należy podać nazwy natężeń wejściowych i wyjściowych, aby klient mógł ich używać podczas korzystania z usługi sieci Web.You must provide the names of the input and output tensors, so your client can use them 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')
    

Konteneryzowanie i Wdróż modelContainerize and deploy the model

Następnie Utwórz obraz platformy Docker z konwertowanego modelu i wszystkich zależności.Next, create a Docker image from the converted model and all dependencies. Ten obraz platformy Docker można następnie wdrożyć i utworzyć jego wystąpienie.This Docker image can then be deployed and instantiated. Obsługiwane cele wdrożenia obejmują usługę Azure Kubernetes Service (AKS) w chmurze lub urządzeniem brzegowym, takim jak Azure Data Box Edge.Supported deployment targets include Azure Kubernetes Service (AKS) in the cloud or an edge device such as Azure Data Box Edge. Możesz również dodać tagi i opisy dla zarejestrowanego obrazu platformy Docker.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)

Wyświetl listę obrazów według tagów i uzyskaj szczegółowe dzienniki dla dowolnego debugowania.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))

Wdrażanie w klastrze usługi Azure Kubernetes ServiceDeploy to an Azure Kubernetes Service Cluster

  1. Aby wdrożyć model jako usługę sieci Web o dużej skali produkcyjnej, użyj AKS.To deploy your model as a high-scale production web service, use AKS. Nowy element można utworzyć przy użyciu zestawu SDK Azure Machine Learning, interfejsu wiersza polecenia lub 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)
    

    Wdrożenie AKS może potrwać około 15 minut.The AKS deployment may take around 15 minutes. Sprawdź, czy wdrożenie zakończyło się pomyślnie.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)
    
  2. Wdróż kontener w klastrze 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)
    

Wdrażanie na lokalnym serwerze brzegowymDeploy to a local edge server

Wszystkie urządzenia Azure Data Box Edge zawierają FPGA do uruchamiania modelu.All Azure Data Box Edge devices contain an FPGA for running the model. Tylko jeden model może być uruchomiony w FPGA jednocześnie.Only one model can be running on the FPGA at one time. Aby uruchomić inny model, po prostu wdróż nowy kontener.To run a different model, just deploy a new container. Instrukcje i przykładowy kod można znaleźć w tym przykładzie platformy Azure.Instructions and sample code can be found in this Azure Sample.

Korzystanie ze wdrożonego modeluConsume the deployed model

Na koniec użyj przykładowego klienta do wywołania obrazu platformy Docker, aby uzyskać prognozy z modelu.Lastly, use the sample client to call into the Docker image to get predictions from the model. Kod przykładowego klienta jest dostępny:Sample client code is available:

Obraz platformy Docker obsługuje gRPC i TensorFlow obsługujący interfejs API "przewidywania".The Docker image supports gRPC and the TensorFlow Serving "predict" API.

Możesz również pobrać przykładowego klienta do obsługi TensorFlow.You can also download a sample client for TensorFlow Serving.

# 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 Azure ML Accelerated Models client
client = PredictionClient(address=address,
                          port=port,
                          use_ssl=ssl_enabled,
                          service_name=aks_service.name)

Ponieważ ten klasyfikator został przeszkolony w zestawie danych ImageNet , Mapuj klasy na etykiety czytelne dla człowieka.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])

Czyszczenie zasobówClean up resources

Aby uniknąć niepotrzebnych kosztów, wyczyść zasoby w następującej kolejności: usługa sieci Web, następnie obraz, a następnie model.To avoid unnecessary costs, clean up your resources in this order: web service, then image, and then the model.

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

Następne krokiNext steps