Delen via

Interactieve foutopsporing met Visual Studio Code

  • Artikel

VAN TOEPASSING OP: Python SDK azureml v1

Meer informatie over het interactief opsporen van fouten in Azure Machine Learning-experimenten, pijplijnen en implementaties met behulp van Visual Studio Code (VS Code) en foutopsporing.

Experimenten lokaal uitvoeren en fouten opsporen

Gebruik de Azure Machine Learning-extensie om uw machine learning-experimenten te valideren, uit te voeren en fouten op te sporen voordat u ze naar de cloud verzendt.

Vereisten

  • Azure Machine Learning VS Code-extensie (preview). Zie Azure Machine Learning VS Code-extensie instellen voor meer informatie.

    Belangrijk

    De Azure Machine Learning VS Code-extensie maakt standaard gebruik van de CLI (v2). De instructies in deze handleiding gebruiken 1.0 CLI. Als u wilt overschakelen naar de 1.0 CLI, stelt u de azureML.CLI Compatibility Mode instelling in Visual Studio Code in op 1.0. Zie de documentatie over gebruikers- en werkruimte-instellingen voor meer informatie over het wijzigen van uw instellingen in Visual Studio Code.

    Belangrijk

    Deze functie is momenteel beschikbaar als openbare preview-versie. Deze preview-versie wordt geleverd zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt.

    Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.

  • Docker

  • Python 3

Lokaal foutopsporingsexperiment

Belangrijk

Voordat u uw experiment lokaal uitvoert, moet u ervoor zorgen dat:

  • Docker wordt uitgevoerd.
  • De azureML.CLI Compatibility Mode instelling in Visual Studio Code is ingesteld op 1.0 zoals is opgegeven in de vereisten

  1. Open in VS Code de azure Machine Learning-extensieweergave.

  2. Vouw het abonnementsknooppunt met uw werkruimte uit. Als u er nog geen hebt, kunt u een Azure Machine Learning-werkruimte maken met behulp van de extensie.

  3. Vouw het werkruimteknooppunt uit.

  4. Klik met de rechtermuisknop op het knooppunt Experimenten en selecteer Experiment maken. Wanneer de prompt wordt weergegeven, geeft u een naam op voor uw experiment.

  5. Vouw het knooppunt Experimenten uit, klik met de rechtermuisknop op het experiment dat u wilt uitvoeren en selecteer Experiment uitvoeren.

  6. Selecteer lokaal in de lijst met opties.

  7. Gebruik voor het eerst alleen in Windows. Wanneer u wordt gevraagd om bestandsshare toe te staan, selecteert u Ja. Wanneer u bestandsshare inschakelt, kan Docker de map met uw script koppelen aan de container. Daarnaast kan Docker de logboeken en uitvoer van uw uitvoering opslaan in een tijdelijke map op uw systeem.

  8. Selecteer Ja om fouten in uw experiment op te sporen. Anders selecteert u Nee. Als u nee selecteert, wordt uw experiment lokaal uitgevoerd zonder het foutopsporingsprogramma te koppelen.

  9. Selecteer Nieuwe uitvoeringsconfiguratie maken om uw uitvoeringsconfiguratie te maken. De uitvoeringsconfiguratie definieert het script dat u wilt uitvoeren, afhankelijkheden en gebruikte gegevenssets. Als u er al een hebt, selecteert u deze in de vervolgkeuzelijst.

    1. Kies uw omgeving. U kunt kiezen uit een van de Azure Machine Learning-services die u zelf hebt samengesteld of zelf kunt maken.
    2. Geef de naam op van het script dat u wilt uitvoeren. Het pad is relatief ten opzichte van de map die is geopend in VS Code.
    3. Kies of u een Azure Machine Learning-gegevensset wilt gebruiken of niet. U kunt Azure Machine Learning-gegevenssets maken met behulp van de extensie.
    4. Foutopsporing is vereist om het foutopsporingsprogramma te koppelen aan de container waarop uw experiment wordt uitgevoerd. Als u foutopsporing als een afhankelijkheid wilt toevoegen, selecteert u Foutopsporing toevoegen. Anders selecteert u Overslaan. Als u geen foutopsporing toevoegt als een afhankelijkheid, wordt uw experiment uitgevoerd zonder het foutopsporingsprogramma te koppelen.
    5. Er wordt een configuratiebestand met uw uitvoeringsconfiguratie-instellingen geopend in de editor. Als u tevreden bent met de instellingen, selecteert u Experiment verzenden. U kunt ook het opdrachtenpalet (opdrachtenpalet weergeven>) openen vanuit de menubalk en de AzureML: Submit experiment opdracht invoeren in het tekstvak.

  10. Zodra uw experiment is verzonden, wordt er een Docker-installatiekopie met uw script en de configuraties gemaakt die zijn opgegeven in de uitvoeringsconfiguratie.

    Wanneer het buildproces van de Docker-installatiekopieën begint, wordt de inhoud van de 60_control_log.txt bestandsstroom naar de uitvoerconsole in VS Code geleid.

    Notitie

    De eerste keer dat uw Docker-installatiekopieën worden gemaakt, kan het enkele minuten duren.

  11. Zodra uw installatiekopie is gemaakt, wordt er een prompt weergegeven om het foutopsporingsprogramma te starten. Stel uw onderbrekingspunten in uw script in en selecteer Foutopsporingsprogramma starten wanneer u klaar bent om foutopsporing te starten. Als u dit doet, wordt het foutopsporingsprogramma van VS Code gekoppeld aan de container waarop uw experiment wordt uitgevoerd. U kunt ook in de Azure Machine Learning-extensie de muisaanwijzer over het knooppunt voor uw huidige uitvoering bewegen en het afspeelpictogram selecteren om het foutopsporingsprogramma te starten.

    Belangrijk

    U kunt niet meerdere foutopsporingssessies voor één experiment hebben. U kunt echter fouten opsporen in twee of meer experimenten met behulp van meerdere VS Code-exemplaren.

Op dit moment moet u uw code stapsgewijs kunnen doorlopen en fouten opsporen met behulp van VS Code.

Als u de uitvoering wilt annuleren, klikt u met de rechtermuisknop op het uitvoeringsknooppunt en selecteert u Uitvoering annuleren.

Net als bij uitvoeringen van externe experimenten kunt u het uitvoeringsknooppunt uitbreiden om de logboeken en uitvoer te controleren.

Tip

Docker-installatiekopieën die gebruikmaken van dezelfde afhankelijkheden die in uw omgeving zijn gedefinieerd, worden opnieuw gebruikt tussen uitvoeringen. Als u echter een experiment uitvoert met behulp van een nieuwe of andere omgeving, wordt er een nieuwe installatiekopieën gemaakt. Omdat deze installatiekopieën worden opgeslagen in uw lokale opslag, is het raadzaam oude of ongebruikte Docker-installatiekopieën te verwijderen. Als u installatiekopieën uit uw systeem wilt verwijderen, gebruikt u de Docker CLI of de VS Code Docker-extensie.

Fouten in Machine Learning-pijplijnen opsporen en oplossen

In sommige gevallen moet u mogelijk interactief fouten opsporen in de Python-code die in uw ML-pijplijn wordt gebruikt. Door VS Code en foutopsporing te gebruiken, kunt u deze koppelen aan de code terwijl deze wordt uitgevoerd in de trainingsomgeving.

Vereisten

  • Een Azure Machine Learning-werkruimte die is geconfigureerd voor het gebruik van een virtueel Azure-netwerk.

  • Een Azure Machine Learning-pijplijn die Python-scripts gebruikt als onderdeel van de pijplijnstappen. Bijvoorbeeld een PythonScriptStep.

  • Een Azure Machine Learning Compute-cluster, dat zich in het virtuele netwerk bevindt en wordt gebruikt door de pijplijn voor training.

  • Een ontwikkelomgeving die zich in het virtuele netwerk bevindt. De ontwikkelomgeving kan een van de volgende zijn:

    • Een virtuele Azure-machine in het virtuele netwerk
    • Een rekenproces van notebook-VM in het virtuele netwerk
    • Een clientcomputer met een privénetwerkverbinding met het virtuele netwerk, hetzij via VPN of via ExpressRoute.

Zie het overzicht van isolatie en privacy van virtuele netwerken voor meer informatie over het gebruik van een virtueel netwerk met Azure Machine Learning.

Tip

Hoewel u kunt werken met Azure Machine Learning-resources die zich niet achter een virtueel netwerk bevinden, wordt het gebruik van een virtueel netwerk aanbevolen.

Hoe het werkt

In uw ML-pijplijnstappen worden Python-scripts uitgevoerd. Deze scripts worden gewijzigd om de volgende acties uit te voeren:

  1. Registreer het IP-adres van de host waarop ze worden uitgevoerd. U gebruikt het IP-adres om het foutopsporingsprogramma te verbinden met het script.

  2. Start het foutopsporingsonderdeel voor foutopsporing en wacht tot een foutopsporingsprogramma verbinding maakt.

  3. Vanuit uw ontwikkelomgeving bewaakt u de logboeken die door het trainingsproces zijn gemaakt om het IP-adres te vinden waar het script wordt uitgevoerd.

  4. U vertelt VS Code het IP-adres om het foutopsporingsprogramma te verbinden met behulp van een launch.json bestand.

  5. U voegt het foutopsporingsprogramma toe en doorloopt interactief het script.

Python-scripts configureren

Als u foutopsporing wilt inschakelen, moet u de volgende wijzigingen aanbrengen in de Python-scripts die worden gebruikt door stappen in uw ML-pijplijn:

  1. Voeg de volgende importinstructies toe:

    import argparse
import os
import debugpy
import socket
from azureml.core import Run

  2. Voeg de volgende argumenten toe. Met deze argumenten kunt u het foutopsporingsprogramma indien nodig inschakelen en de time-out instellen voor het koppelen van het foutopsporingsprogramma:

    parser.add_argument('--remote_debug', action='store_true')
parser.add_argument('--remote_debug_connection_timeout', type=int,
                    default=300,
                    help=f'Defines how much time the Azure Machine Learning compute target '
                    f'will await a connection from a debugger client (VSCODE).')
parser.add_argument('--remote_debug_client_ip', type=str,
                    help=f'Defines IP Address of VS Code client')
parser.add_argument('--remote_debug_port', type=int,
                    default=5678,
                    help=f'Defines Port of VS Code client')

  3. Voeg de volgende -instructies toe. Met deze instructies wordt de huidige uitvoeringscontext geladen, zodat u het IP-adres kunt vastleggen van het knooppunt waarop de code wordt uitgevoerd:

    global run
run = Run.get_context()

  4. Voeg een if instructie toe die debugpy start en wacht totdat een foutopsporingsprogramma wordt toegevoegd. Als er vóór de time-out geen foutopsporingsprogramma wordt gekoppeld, gaat het script verder als normaal. Zorg ervoor dat u de HOST functie vervangt door PORTlisten uw eigen functie.

    if args.remote_debug:
    print(f'Timeout for debug connection: {args.remote_debug_connection_timeout}')
    # Log the IP and port
    try:
        ip = args.remote_debug_client_ip
    except:
        print("Need to supply IP address for VS Code client")
    print(f'ip_address: {ip}')
    debugpy.listen(address=(ip, args.remote_debug_port))
    # Wait for the timeout for debugger to attach
    debugpy.wait_for_client()
    print(f'Debugger attached = {debugpy.is_client_connected()}')

In het volgende Python-voorbeeld ziet u een eenvoudig train.py bestand dat foutopsporing mogelijk maakt:

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

import argparse
import os
import debugpy
import socket
from azureml.core import Run

print("In train.py")
print("As a data scientist, this is where I use my training code.")

parser = argparse.ArgumentParser("train")

parser.add_argument("--input_data", type=str, help="input data")
parser.add_argument("--output_train", type=str, help="output_train directory")

# Argument check for remote debugging
parser.add_argument('--remote_debug', action='store_true')
parser.add_argument('--remote_debug_connection_timeout', type=int,
                    default=300,
                    help=f'Defines how much time the Azure Machine Learning compute target '
                    f'will await a connection from a debugger client (VSCODE).')
parser.add_argument('--remote_debug_client_ip', type=str,
                    help=f'Defines IP Address of VS Code client')
parser.add_argument('--remote_debug_port', type=int,
                    default=5678,
                    help=f'Defines Port of VS Code client')

# Get run object, so we can find and log the IP of the host instance
global run
run = Run.get_context()

args = parser.parse_args()

# Start debugger if remote_debug is enabled
if args.remote_debug:
    print(f'Timeout for debug connection: {args.remote_debug_connection_timeout}')
    # Log the IP and port
    ip = socket.gethostbyname(socket.gethostname())
    # try:
    #     ip = args.remote_debug_client_ip
    # except:
    #     print("Need to supply IP address for VS Code client")
    print(f'ip_address: {ip}')
    debugpy.listen(address=(ip, args.remote_debug_port))
    # Wait for the timeout for debugger to attach
    debugpy.wait_for_client()
    print(f'Debugger attached = {debugpy.is_client_connected()}')

print("Argument 1: %s" % args.input_data)
print("Argument 2: %s" % args.output_train)

if not (args.output_train is None):
    os.makedirs(args.output_train, exist_ok=True)
    print("%s created" % args.output_train)

ML-pijplijn configureren

Als u de Python-pakketten wilt opgeven die nodig zijn om debugpy te starten en de uitvoeringscontext op te halen, maakt u een omgeving en stelt u deze in pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Wijzig de SDK-versie zodat deze overeenkomt met de versie die u gebruikt. Het volgende codefragment laat zien hoe u een omgeving maakt:

# Use a RunConfiguration to specify some additional requirements for this step.
from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_CPU_IMAGE

# create a new runconfig object
run_config = RunConfiguration()

# enable Docker 
run_config.environment.docker.enabled = True

# set Docker base image to the default CPU-based image
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE

# use conda_dependencies.yml to create a conda environment in the Docker image for execution
run_config.environment.python.user_managed_dependencies = False

# specify CondaDependencies obj
run_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],
                                                                           pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>'])

In de sectie Python-scripts configureren zijn nieuwe argumenten toegevoegd aan de scripts die worden gebruikt door de ML-pijplijnstappen. Het volgende codefragment laat zien hoe u deze argumenten gebruikt om foutopsporing voor het onderdeel in te schakelen en een time-out in te stellen. Ook wordt gedemonstreerd hoe u de omgeving gebruikt die u eerder hebt gemaakt door het instellen runconfig=run_config:

# Use RunConfig from a pipeline step
step1 = PythonScriptStep(name="train_step",
                         script_name="train.py",
                         arguments=['--remote_debug', '--remote_debug_connection_timeout', 300,'--remote_debug_client_ip','<VS-CODE-CLIENT-IP>','--remote_debug_port',5678],
                         compute_target=aml_compute,
                         source_directory=source_directory,
                         runconfig=run_config,
                         allow_reuse=False)

Wanneer de pijplijn wordt uitgevoerd, maakt elke stap een onderliggende uitvoering. Als foutopsporing is ingeschakeld, registreert het gewijzigde script informatie die vergelijkbaar is met de volgende tekst in de 70_driver_log.txt voor de onderliggende uitvoering:

Timeout for debug connection: 300
ip_address: 10.3.0.5

Sla de ip_address waarde op. Deze wordt gebruikt in de volgende sectie.

Tip

U kunt ook het IP-adres vinden in de uitvoeringslogboeken voor de onderliggende uitvoering voor deze pijplijnstap. Zie Azure Machine Learning-experimentuitvoeringen en metrische gegevens bewaken voor meer informatie over het weergeven van deze informatie.

De ontwikkelomgeving configureren

  1. Als u foutopsporing wilt installeren in uw VS Code-ontwikkelomgeving, gebruikt u de volgende opdracht:

    python -m pip install --upgrade debugpy

    Zie Externe foutopsporing voor meer informatie over het gebruik van foutopsporing met VS Code.

  2. Als u VS Code wilt configureren om te communiceren met de Azure Machine Learning-berekening waarop het foutopsporingsprogramma wordt uitgevoerd, maakt u een nieuwe configuratie voor foutopsporing:

    1. Selecteer in VS Code het menu Foutopsporing en selecteer vervolgens Configuraties openen. Er wordt een bestand met de naam launch.json geopend.

    2. Zoek in het launch.json bestand de regel die het bevat "configurations": [en voeg de volgende tekst erna in. Wijzig de "host": "<IP-ADDRESS>" vermelding in het IP-adres dat wordt geretourneerd in uw logboeken uit de vorige sectie. Wijzig de "localRoot": "${workspaceFolder}/code/step" vermelding in een lokale map die een kopie bevat van het script dat wordt opgespoord:

      {
    "name": "Azure Machine Learning Compute: remote debug",
    "type": "python",
    "request": "attach",
    "port": 5678,
    "host": "<IP-ADDRESS>",
    "redirectOutput": true,
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}/code/step1",
            "remoteRoot": "."
        }
    ]
}

      Belangrijk

      Als er al andere vermeldingen in de sectie configuraties staan, voegt u een komma (,) toe na de code die u hebt ingevoegd.

      Tip

      De aanbevolen procedure, met name voor pijplijnen, is om de resources voor scripts in afzonderlijke mappen te bewaren, zodat code alleen relevant is voor elk van de stappen. In dit voorbeeld verwijst de localRoot voorbeeldwaarde naar /code/step1.

      Als u fouten in meerdere scripts opspoort, maakt u in verschillende mappen een afzonderlijke configuratiesectie voor elk script.

    3. Sla het bestand launch.json op.

Verbinding maken met het foutopsporingsprogramma

  1. Open VS Code en open een lokale kopie van het script.

  2. Stel onderbrekingspunten in waar u het script wilt stoppen nadat u het hebt gekoppeld.

  3. Terwijl het onderliggende proces het script uitvoert en het Timeout for debug connection wordt weergegeven in de logboeken, gebruikt u de F5-toets of selecteert u Fouten opsporen. Wanneer u hierom wordt gevraagd, selecteert u azure Machine Learning Compute: configuratie voor externe foutopsporing . U kunt ook het pictogram voor foutopsporing selecteren in de zijbalk, de Azure Machine Learning: externe foutopsporingsvermelding in het vervolgkeuzemenu Foutopsporing en vervolgens de groene pijl gebruiken om het foutopsporingsprogramma toe te voegen.

    Op dit moment maakt VS Code verbinding met foutopsporing op het rekenknooppunt en stopt het onderbrekingspunt dat u eerder hebt ingesteld. U kunt nu de code doorlopen terwijl deze wordt uitgevoerd, variabelen weergeven, enzovoort.

    Notitie

    Als in het logboek een vermelding wordt weergegeven waarin Debugger attached = Falsestaat dat de time-out is verlopen en het script is voortgezet zonder het foutopsporingsprogramma. Verzend de pijplijn opnieuw en verbind het foutopsporingsprogramma na het Timeout for debug connection bericht en voordat de time-out verloopt.

Fouten opsporen en problemen met implementaties oplossen

In sommige gevallen moet u mogelijk interactief fouten opsporen in de Python-code in uw modelimplementatie. Als het invoerscript bijvoorbeeld mislukt en de reden niet kan worden bepaald door extra logboekregistratie. Met behulp van VS Code en de foutopsporing kunt u koppelen aan de code die in de Docker-container wordt uitgevoerd.

Tip

Als u beheerde online-eindpunten en implementaties lokaal gebruikt, raadpleegt u Lokaal beheerde online-eindpunten opsporen in Visual Studio Code (preview).

Belangrijk

Deze foutopsporingsmethode werkt niet wanneer u een model lokaal gebruikt Model.deploy() en LocalWebservice.deploy_configuration implementeert. In plaats daarvan moet u een installatiekopieën maken met behulp van de methode Model.package().

Voor implementaties van lokale webservices is een werkende Docker-installatie op uw lokale systeem vereist. Zie de Docker-documentatie voor meer informatie over het gebruik van Docker. Wanneer u met rekeninstanties werkt, is Docker al geïnstalleerd.

De ontwikkelomgeving configureren

  1. Als u foutopsporing wilt installeren in uw lokale VS Code-ontwikkelomgeving, gebruikt u de volgende opdracht:

    python -m pip install --upgrade debugpy

    Zie Externe foutopsporing voor meer informatie over het gebruik van foutopsporing met VS Code.

  2. Als u VS Code wilt configureren om te communiceren met de Docker-installatiekopieën, maakt u een nieuwe configuratie voor foutopsporing:

    1. Selecteer in VS Code het menu Foutopsporing in de uitbreiding Uitvoeren en selecteer vervolgens Configuraties openen. Er wordt een bestand met de naam launch.json geopend.

    2. Zoek in het bestand launch.json het item 'configuraties' (de regel die het bevat "configurations": [) en voeg de volgende tekst erna in.

      {
    "name": "Azure Machine Learning Deployment: Docker Debug",
    "type": "python",
    "request": "attach",
    "connect": {
        "port": 5678,
        "host": "0.0.0.0",
    },
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/var/azureml-app"
        }
    ]
}

      Na de invoeging moet het launch.json-bestand er ongeveer als volgt uitzien:

      {
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/linkid=830387
"version": "0.2.0",
"configurations": [
    {
        "name": "Python: Current File",
        "type": "python",
        "request": "launch",
        "program": "${file}",
        "console": "integratedTerminal"
    },
    {
        "name": "Azure Machine Learning Deployment: Docker Debug",
        "type": "python",
        "request": "attach",
        "connect": {
            "port": 5678,
            "host": "0.0.0.0"
            },
        "pathMappings": [
            {
                "localRoot": "${workspaceFolder}",
                "remoteRoot": "/var/azureml-app"
            }
        ]
    }
    ]
}

      Belangrijk

      Als er al andere vermeldingen in de configuratiesectie staan, voegt u een komma ( , ) toe na de code die u hebt ingevoegd.

      Deze sectie wordt gekoppeld aan de Docker-container met behulp van poort 5678.

    3. Sla het bestand launch.json op.

Een installatiekopie maken die foutopsporing bevat

  1. Wijzig de Conda-omgeving voor uw implementatie zodat deze foutopsporing bevat. In het volgende voorbeeld ziet u hoe u deze toevoegt met behulp van de pip_packages parameter:

    from azureml.core.conda_dependencies import CondaDependencies 


# Usually a good idea to choose specific version numbers
# so training is made on same packages as scoring
myenv = CondaDependencies.create(conda_packages=['numpy==1.15.4',
                            'scikit-learn==0.19.1', 'pandas==0.23.4'],
                             pip_packages = ['azureml-defaults==1.0.83', 'debugpy'])

with open("myenv.yml","w") as f:
    f.write(myenv.serialize_to_string())

  2. Als u debugpy wilt starten en wilt wachten op een verbinding wanneer de service wordt gestart, voegt u het volgende toe aan het begin van het score.py bestand:

    import debugpy
# Allows other computers to attach to debugpy on this IP address and port.
debugpy.listen(('0.0.0.0', 5678))
# Wait 30 seconds for a debugger to attach. If none attaches, the script continues as normal.
debugpy.wait_for_client()
print("Debugger attached...")

  3. Maak een installatiekopie op basis van de omgevingsdefinitie en haal de installatiekopie naar het lokale register.

    Notitie

    In dit voorbeeld wordt ervan uitgegaan dat ws deze verwijst naar uw Azure Machine Learning-werkruimte en dat is het model dat model wordt geïmplementeerd. Het myenv.yml bestand bevat de conda-afhankelijkheden die zijn gemaakt in stap 1.

    from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment


myenv = Environment.from_conda_specification(name="env", file_path="myenv.yml")
myenv.docker.base_image = None
myenv.docker.base_dockerfile = "FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest"
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)
package = Model.package(ws, [model], inference_config)
package.wait_for_creation(show_output=True)  # Or show_output=False to hide the Docker build logs.
package.pull()

    Zodra de installatiekopieën zijn gemaakt en gedownload (dit proces kan langer dan 10 minuten duren), wordt het pad naar de installatiekopieën (inclusief opslagplaats, naam en tag, die in dit geval ook de samenvatting is), weergegeven in een bericht dat er ongeveer als volgt uitziet:

    Status: Downloaded newer image for myregistry.azurecr.io/package@sha256:<image-digest>

  4. U kunt de volgende opdracht gebruiken om een tag voor deze afbeelding toe te voegen, zodat u de installatiekopieën gemakkelijker lokaal kunt gebruiken. Vervang myimagepath in de volgende opdracht door de locatiewaarde uit de vorige stap.

    docker tag myimagepath debug:1

    Voor de rest van de stappen kunt u verwijzen naar de lokale afbeelding, zoals debug:1 in plaats van de volledige waarde van het afbeeldingspad.

Fouten opsporen in de service

Tip

Als u een time-out instelt voor de foutopsporingsverbinding in het score.py bestand, moet u VS Code verbinden met de foutopsporingssessie voordat de time-out verloopt. Start VS Code, open de lokale kopie van score.py, stel een onderbrekingspunt in en zorg ervoor dat u klaar bent voordat u de stappen in deze sectie gebruikt.

Zie Foutopsporing voor meer informatie over foutopsporing en het instellen van onderbrekingspunten.

  1. Gebruik de volgende opdracht om een Docker-container te starten met behulp van de installatiekopieën:

    docker run -it --name debug -p 8000:5001 -p 5678:5678 -v <my_local_path_to_score.py>:/var/azureml-app/score.py debug:1 /bin/bash

    Met deze opdracht wordt uw score.py lokaal gekoppeld aan de opdracht in de container. Daarom worden alle wijzigingen die in de editor zijn aangebracht, automatisch doorgevoerd in de container

  2. Voor een betere ervaring kunt u naar de container gaan met een nieuwe VS Code-interface. Selecteer de Docker uitbreiding in de zijbalk van VS Code, zoek uw lokale container die is gemaakt in deze documentatie debug:1. Klik met de rechtermuisknop op deze container en selecteer "Attach Visual Studio Code", vervolgens wordt er automatisch een nieuwe VS Code-interface geopend. Deze interface toont de binnenkant van de gemaakte container.

    De interface van de container VS Code

  3. Voer in de container de volgende opdracht uit in de shell

    runsvdir /var/runit

    Vervolgens ziet u de volgende uitvoer in de shell in uw container:

    Uitvoer van de console voor containeruitvoering

  4. Als u VS Code wilt koppelen om fouten op te sporen in de container, opent u VS Code en gebruikt u de F5-sleutel of selecteert u Fouten opsporen. Wanneer u hierom wordt gevraagd, selecteert u de Azure Machine Learning-implementatie: Docker-configuratie voor foutopsporing . U kunt ook het pictogram Uitbreiding uitvoeren selecteren in de zijbalk, de Azure Machine Learning-implementatie: Docker Debug-vermelding in het vervolgkeuzemenu Foutopsporing en vervolgens de groene pijl gebruiken om het foutopsporingsprogramma te koppelen.

    Het pictogram voor foutopsporing, start de foutopsporingsknop en configuratiekiezer

    Nadat u de groene pijl hebt geselecteerd en het foutopsporingsprogramma hebt gekoppeld, ziet u in de interface van container VS Code enkele nieuwe informatie:

    Gekoppelde informatie over het containerdebugger

    In uw belangrijkste VS Code-interface ziet u ook het volgende:

    Het VS Code-onderbrekingspunt in score.py

En nu is de lokale score.py die is gekoppeld aan de container al gestopt op de onderbrekingspunten waar u hebt ingesteld. Op dit moment maakt VS Code verbinding met foutopsporing in de Docker-container en stopt de Docker-container op het onderbrekingspunt dat u eerder hebt ingesteld. U kunt nu de code doorlopen terwijl deze wordt uitgevoerd, variabelen weergeven, enzovoort.

Zie Fouten opsporen in uw Python-code voor meer informatie over het gebruik van VS Code om fouten in Python op te sporen.

De container stoppen

Gebruik de volgende opdracht om de container te stoppen:

docker stop debug

Volgende stappen

Nu u VS Code Remote hebt ingesteld, kunt u een rekenproces als extern rekenproces van VS Code gebruiken om interactief fouten in uw code op te sporen.

Meer informatie over het oplossen van problemen: