Gépi tanulási modellek üzembe helyezése helyszínen programozható kaputömbökben (FPGA-k) Azure Machine LearningDeploy ML models to field-programmable gate arrays (FPGAs) with Azure Machine Learning

Ebből a cikkből megismerheti az FPGA-szolgáltatásokat, és megtudhatja, hogyan helyezheti üzembe gépi tanulási modelljeit egy Azure FPGA-ban a hardveresen gyorsított modellek Python-csomagját használva a 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.

Mik azok az FPGA-k?What are FPGAs?

Az FPGA-k programozható logikai blokkok tömbjét és újrakonfigurálható összekötők hierarchiáját tartalmazzák.FPGAs contain an array of programmable logic blocks, and a hierarchy of reconfigurable interconnects. Az összekapcsolásokkal ezek a blokkok többféleképpen konfigurálhatóak a gyártás után.The interconnects allow these blocks to be configured in various ways after manufacturing. Más lapkákhoz képest az FPGA-k a programozhatóság és a teljesítmény kombinációját biztosítják.Compared to other chips, FPGAs provide a combination of programmability and performance.

Az FPGA-k lehetővé teszik a valós idejű következtetési (vagy modellpontozási) kérések kis késését.FPGAs make it possible to achieve low latency for real-time inference (or model scoring) requests. Aszinkron kérések (kötegezés) nem szükségesek.Asynchronous requests (batching) aren't needed. A kötegolás késést okozhat, mivel több adatot kell feldolgozni.Batching can cause latency, because more data needs to be processed. A neurális feldolgozási egységek implementációi nem igényelnek kötegeket; ezért a késés a CPU- és GPU-processzorok esetében sokszor alacsonyabb is lehet.Implementations of neural processing units don't require batching; therefore the latency can be many times lower, compared to CPU and GPU processors.

Az FPGA-k újrakonfigurálva különböző típusú gépi tanulási modellekhez használhatók.You can reconfigure FPGAs for different types of machine learning models. Ez a rugalmasság megkönnyíti az alkalmazások felgyorsítését a legoptimálisabb numerikus pontosság és a használt memóriamodell alapján.This flexibility makes it easier to accelerate the applications based on the most optimal numerical precision and memory model being used. Mivel az FPGA-k újrakonfigurálhatók, mindig megfelelhet a gyorsan változó AI-algoritmusok követelményeinek.Because FPGAs are reconfigurable, you can stay current with the requirements of rapidly changing AI algorithms.

Az FPGA Azure Machine Learning ábrája

ProcesszorProcessor RövidítésAbbreviation DescriptionDescription
Alkalmazásspecifikus integrált kapcsolati körökApplication-specific integrated circuits AsicsASICs Az egyéni kapcsolati körök, például a Google Tensor Processzoregységei (TPU) biztosítják a legnagyobb hatékonyságot.Custom circuits, such as Google's Tensor Processor Units (TPU), provide the highest efficiency. Ezeket nem lehet újrakonfigurálni az igények változásának megfelelően.They can't be reconfigured as your needs change.
Helyszínen programozható kaputömbökField-programmable gate arrays FPGA-kFPGAs Az FPGA-k, például az Azure-ban elérhetőek, az ASI-k közelében biztosítják a teljesítményt.FPGAs, such as those available on Azure, provide performance close to ASICs. Emellett rugalmasak és újrakonfigurálhatók az új logika implementálhatók.They are also flexible and reconfigurable over time, to implement new logic.
Grafikus feldolgozó egységekGraphics processing units GPU-kGPUs Népszerű választás az MI-számításokhoz.A popular choice for AI computations. A GPU-k párhuzamos feldolgozási képességeket biztosítanak, így gyorsabban renderelik a képeket, mint a CPU-k.GPUs offer parallel processing capabilities, making it faster at image rendering than CPUs.
Központi feldolgozó egységekCentral processing units CPU-kCPUs Általános célú processzorok, amelyek teljesítménye nem ideális grafikus és videófeldolgozási célokra.General-purpose processors, the performance of which isn't ideal for graphics and video processing.

FPGA-támogatás az Azure-banFPGA support in Azure

Microsoft Azure a világ legnagyobb felhőbeli befektetése az FPGA-kba.Microsoft Azure is the world's largest cloud investment in FPGAs. A Microsoft FPGA-kat használ a mély neurális hálózatok (DNN) értékeléséhez, a Bing Search rangsorolásához és a szoftveralapú hálózat (SDN) gyorsításához a késés csökkentése érdekében, miközben más feladatokhoz is felszabadítja a processzorokat.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.

Az Azure-beli FPGA-k az Intel FPGA-eszközein alapulnak, amelyeket az adattudósok és fejlesztők a valós idejű AI-számítások felgyorsítására használhatnak.FPGAs on Azure are based on Intel's FPGA devices, which data scientists and developers use to accelerate real-time AI calculations. Ez az FPGA-kompatibilis architektúra teljesítményt, rugalmasságot és méretezést kínál, és elérhető az Azure-ban.This FPGA-enabled architecture offers performance, flexibility, and scale, and is available on Azure.

Az Azure FPGA-k integrálva vannak a Azure Machine Learning.Azure FPGAs are integrated with Azure Machine Learning. Az Azure képes párhuzamosítani az előre betanított DNN-eket az FPGA-k között a szolgáltatás horizontális felskálizálása előtt.Azure can parallelize pre-trained DNN across FPGAs to scale out your service. A DNN-eket előre be lehet tanítani, mély dekattizálóként a tanulás átviteléhez, vagy finomhangolhatók frissített súlyokkal.The DNNs can be pre-trained, as a deep featurizer for transfer learning, or fine-tuned with updated weights.

Forgatókönyvek & Azure-banScenarios & configurations on Azure Támogatott DNN-modellekSupported DNN models Regionális támogatásRegional support
+ Képosztályozási és -felismerési forgatókönyvek+ Image classification and recognition scenarios
+ TensorFlow üzembe helyezése (a Tensorflow 1.x-et igényli)+ TensorFlow deployment (requires Tensorflow 1.x)
+ Intel FPGA hardver+ Intel FPGA hardware
- ResNet 50- ResNet 50
- ResNet 152- ResNet 152
- DenseNet-121- DenseNet-121
- VGG-16- VGG-16
- SSD-VGG- SSD-VGG
- USA keleti régiója- East US
- Délkelet-Ázsia- Southeast Asia
- Nyugat-Európa- West Europe
- USA 2. nyugati régiója- West US 2

A késés és az átviteli sebesség optimalizálásához az FPGA-modellnek adatokat küldő ügyfélnek a fenti régiók egyikében kell lennie (azon a régión, ahol a modellt üzembe helyezett).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).

Az Azure-beli virtuális gépek PBS-családja tartalmazza az Intel Arria 10 FPGA-ket.The PBS Family of Azure VMs contains Intel Arria 10 FPGAs. Az Azure-kvótakiosztás ellenőrzésekor "Standard PBS-család vCPU-ként" fog jelenni.It will show as "Standard PBS Family vCPUs" when you check your Azure quota allocation. A PB6 virtuális gép hat vCPU-val és egy FPGA-vel rendelkezik.The PB6 VM has six vCPUs and one FPGA. A PB6 virtuális gépet a rendszer automatikusan Azure Machine Learning a modell FPGA-beli üzembe helyezése során.PB6 VM is automatically provisioned by Azure Machine Learning during model deployment to an FPGA. Csak az Azure ML-sel használható, és nem futtathat tetszőleges bitstreameket.It is only used with Azure ML, and it cannot run arbitrary bitstreams. Például nem fogja tudni bitstreamekkel flashlni az FPGA-t titkosításhoz, kódoláshoz stb.For example, you will not be able to flash the FPGA with bitstreams to do encryption, encoding, etc.

Modellek üzembe helyezése FPGA-konDeploy models on FPGAs

A modellt webszolgáltatásként helyezheti üzembe az FPGA-kban az Azure Machine Learning Hardware Accelerated Models.You can deploy a model as a web service on FPGAs with Azure Machine Learning Hardware Accelerated Models. Az FPGA-k használata rendkívül alacsony késleltetésű dedienciát biztosít, akár egyetlen kötegmérettel is.Using FPGAs provides ultra-low latency inference, even with a single batch size.

Ebben a példában egy TensorFlow-gráfot hoz létre a bemeneti kép előfeldolgozására, jellemzősítővé teszi a ResNet 50 használatával egy FPGA-n, majd futtatja a szolgáltatásokat az ImageNet-adatkészleten betanított osztályozón keresztül.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. Ezután a modellt üzembe kell helyezni egy AKS-fürtön.Then, the model is deployed to an AKS cluster.

ElőfeltételekPrerequisites

  • Azure-előfizetés.An Azure subscription. Ha még nincs fiókja, hozzon létre egy használat alapján fizetett fiókot (az ingyenes Azure-fiókok nem jogosultak az FPGA-kvótára).If you do not have one, create a pay-as-you-go account (free Azure accounts are not eligible for FPGA quota).

  • Egy Azure Machine Learning munkaterület és a telepített Azure Machine Learning SDK for Python, a Munkaterület létrehozása dokumentumban leírtak szerint.An Azure Machine Learning workspace and the Azure Machine Learning SDK for Python installed, as described in Create a workspace.

  • A hardveresen gyorsított modellek csomagja: pip install --upgrade azureml-accel-models[cpu]The hardware-accelerated models package: pip install --upgrade azureml-accel-models[cpu]

  • Az Azure CLIThe Azure CLI

  • FPGA-kvóta.FPGA quota. Küldjön el egy kvótakérést,vagy futtassa a következő CLI-parancsot a kvóta ellenőrzéshez: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']"
    

    Győződjön meg arról, hogy legalább 6 vCPU van a visszaadott CurrentValue érték alatt.Make sure you have at least 6 vCPUs under the CurrentValue returned.

A TensorFlow-modell meghatározásaDefine the TensorFlow model

Első lépésként hozzon létre egy Azure Machine Learning-definíciót a Pythonhoz készült Azure Machine Learning SDK-val.Begin by using the Azure Machine Learning SDK for Python to create a service definition. A szolgáltatásdefiníció egy, a TensorFlow-alapú gráfok (bemenet, featurizer és osztályozó) folyamatát leíró fájl.A service definition is a file describing a pipeline of graphs (input, featurizer, and classifier) based on TensorFlow. Az üzembe helyezési parancs tömöríti a definíciókat és a gráfokat egy ZIP-fájlba, és feltölti a ZIP-fájlt az Azure Blob Storage-ba.The deployment command compresses the definition and graphs into a ZIP file, and uploads the ZIP to Azure Blob storage. A DNN már telepítve van az FPGA-n való futtatáshoz.The DNN is already deployed to run on the FPGA.

  1. Munkaterület Azure Machine Learning betöltéseLoad 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. Rendszerkép előfeldolgozása.Preprocess image. A webszolgáltatás bemenete egy JPEG-kép.The input to the web service is a JPEG image. Az első lépés a JPEG-kép dekódolása és előfeldolgozása.The first step is to decode the JPEG image and preprocess it. A JPEG-képeket a rendszer sztringekként kezeli, és az eredmény tenzorok lesznek, amelyek a ResNet 50 modell bemenetei lesznek.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. Töltse be a featurizert.Load featurizer. Inicializálja a modellt, és töltse le a ResNet50 kvantált verziójának TensorFlow ellenőrzőpontját, hogy az a főcsomópontként használható legyen.Initialize the model and download a TensorFlow checkpoint of the quantized version of ResNet50 to be used as a featurizer. A kódrészletben cserélje le a "QuantizedResnet50" helyére más mély neurális hálózatok importálását: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. Adjon hozzá egy osztályozót.Add a classifier. Ez az osztályozó az ImageNet-adathalmazon lett betanítva.This classifier was trained on the ImageNet data set.

    classifier_output = model_graph.get_default_classifier(feature_tensor)
    print(classifier_output)
    
  5. Mentse a modellt.Save the model. Most, hogy betöltötte az előprocesszort, a ResNet 50 jellemzősítőt és az osztályozót, modellként mentse a gráfot és a társított változókat.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. Mentse a bemeneti és kimeneti tenzorokat, mivel modellátalakítási és következtetési kérelmekhez fogja használni őket.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)
    

    Ha az alapértelmezett osztályozót használta, a következő modellek érhetők el az osztályozó kimeneti tenzorokkal együtt, dedukcióhoz.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']
      

A modell konvertálása Open Neural Network Exchange formátumra (ONNX)Convert the model to the Open Neural Network Exchange format (ONNX)

Mielőtt FPGA-kba helyezné az üzembe helyezést, alakítsa át a modellt ONNX formátumra.Before you can deploy to FPGAs, convert the model to the ONNX format.

  1. Regisztrálja a modellt az SDK-val és a ZIP-fájllal az Azure Blob Storage-ban.Register the model by using the SDK with the ZIP file in Azure Blob storage. Címkék és egyéb metaadatok hozzáadásával nyomon követheti a betanított modelleket.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')
    

    Ha már regisztrált egy modellt, és szeretné betölteni, lekérheti.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. Konvertálja a TensorFlow-gráfot ONNX formátumra.Convert the TensorFlow graph to the ONNX format. Meg kell adnia a bemeneti és kimeneti tenzorok nevét, hogy az ügyfél használni tudja őket a webszolgáltatás használatakor.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')
    

A modell tárolóba helyezése és üzembe helyezéseContainerize and deploy the model

Ezután hozzon létre egy Docker-rendszerképet a konvertált modellből és az összes függőségből.Next, create a Docker image from the converted model and all dependencies. Ez a Docker-rendszerkép ezután üzembe helyezhető és példányosulhat.This Docker image can then be deployed and instantiated. A támogatott üzembe helyezési célok közé Azure Kubernetes Service (AKS) a felhőben, vagy egy peremhálózati eszköz, például az 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. A regisztrált Docker-rendszerképhez címkéket és leírásokat is hozzáadhat.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)

Címkével sorolja fel a képeket, és szerezze be a hibakeresés részletes naplóit.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))

Üzembe helyezés egy Azure Kubernetes Service fürtönDeploy to an Azure Kubernetes Service Cluster

  1. A modell nagy léptékű éles webszolgáltatásként való üzembe helyezéséhez használja az AKS-t.To deploy your model as a high-scale production web service, use AKS. Újat az Azure Machine Learning SDK, a CLI vagy a Azure Machine Learning stúdió használatával hozhat Azure Machine Learning stúdió.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)
    

    Az AKS üzembe helyezése körülbelül 15 percet is igénybe vehet.The AKS deployment may take around 15 minutes. Ellenőrizze, hogy az üzembe helyezés sikeres volt-e.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. A tároló üzembe helyezése az AKS-fürtön.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)
    

Üzembe helyezés helyi peremhálózati kiszolgálónDeploy to a local edge server

Minden Azure Data Box Edge-eszköz tartalmaz egy FPGA-t a modell futtatásához.All Azure Data Box Edge devices contain an FPGA for running the model. Egyszerre csak egy modell futhat az FPGA-n.Only one model can be running on the FPGA at one time. Egy másik modell futtatásához egyszerűen üzembe kell helyeznie egy új tárolót.To run a different model, just deploy a new container. Az utasításokat és a mintakódot ebben az Azure-mintában talál.Instructions and sample code can be found in this Azure Sample.

Az üzembe helyezett modell felhasználtaConsume the deployed model

Végül a minta-ügyfél használatával hívja meg a-t a Docker-rendszerképbe, hogy előrejelzéseket kap a modellből.Lastly, use the sample client to call into the Docker image to get predictions from the model. Elérhető minta ügyfélkód:Sample client code is available:

A Docker-rendszerkép támogatja a gRPC-t és a TensorFlow Serving "predict" API-t.The Docker image supports gRPC and the TensorFlow Serving "predict" API.

A TensorFlow-kiszolgálóhoz egy minta-ügyfelet is letölthet.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)

Mivel ez az osztályozó az ImageNet-adathalmazon lett betanítva, az osztályokat emberek által olvasható címkékre képezte le.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])

Az erőforrások eltávolításaClean up resources

A felesleges költségek elkerülése érdekében az erőforrásokat ebben a sorrendben kell megtisztítani: webszolgáltatás, kép, majd a modell.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()

Következő lépésekNext steps