Interactieve foutopsporing met Visual Studio Code

  • Artikel

VAN TOEPASSING OP:Python SDK azureml v1

Meer informatie over het interactief opsporen van fouten in Experimenten, pijplijnen en implementaties van Azure Machine Learning 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

Lokaal fouten opsporen in experiment

Belangrijk

Voordat u uw experiment lokaal uitvoert, controleert u het volgende:

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

  1. Open in VS Code de weergave Azure Machine Learning-extensie.

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

  3. Vouw uw 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. Alleen de eerste keer dat u windows gebruikt. Wanneer u wordt gevraagd om bestandsshare toe te staan, selecteert u Ja. Wanneer u de 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 gekoppeld aan het foutopsporingsprogramma.

  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 gecureerde Azure Machine Learning of uw eigen 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. Selecteer anders Overslaan. Als u de foutopsporingspy niet toevoegt als een afhankelijkheid, wordt uw experiment uitgevoerd zonder te koppelen aan het foutopsporingsprogramma.
    5. In de editor wordt een configuratiebestand geopend met de configuratie-instellingen voor uitvoeren. 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 in het tekstvak invoeren.

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

    Wanneer het proces voor het maken van de Docker-installatiekopieën wordt gestart, wordt de inhoud van het 60_control_log.txt bestand gestreamd naar de uitvoerconsole in VS Code.

    Notitie

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

  11. Zodra de installatiekopieën zijn 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 de foutopsporing te starten. Als u dit doet, wordt het VS Code-foutopsporingsprogramma gekoppeld aan de container waarop uw experiment wordt uitgevoerd. U kunt ook in de Azure Machine Learning-extensie de muisaanwijzer op het knooppunt voor de huidige uitvoering plaatsen en het afspeelpictogram selecteren om het foutopsporingsprogramma te starten.

    Belangrijk

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

Op dit moment moet u stapsgewijs in staat zijn om fouten in uw code op te sporen met behulp van VS Code.

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

Net als bij externe experimentuitvoeringen kunt u uw 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 tussen uitvoeringen opnieuw gebruikt. Als u echter een experiment uitvoert met een nieuwe of een andere omgeving, wordt er een nieuwe installatiekopieën gemaakt. Omdat deze installatiekopieën worden opgeslagen in uw lokale opslag, is het raadzaam om oude of ongebruikte Docker-installatiekopieën te verwijderen. Als u installatiekopieën van 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 wordt gebruikt in uw ML-pijplijn. Door VS Code en foutopsporing te gebruiken, kunt u 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 Azure Virtual Network.

  • Een Azure Machine Learning-pijplijn die gebruikmaakt van Python-scripts 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 Overzicht van isolatie en privacy van virtuele netwerken voor meer informatie over het gebruik van een Azure-Virtual Network 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.

Uitleg

Met de ML-pijplijnstappen worden Python-scripts uitgevoerd. Deze scripts worden aangepast 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 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 waarop het script wordt uitgevoerd.

  4. U vertelt VS Code het IP-adres waarmee het foutopsporingsprogramma moet worden verbonden 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-script(s) 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 registreren van het knooppunt waarop de code wordt uitgevoerd:

    global run
run = Run.get_context()

  4. Voeg een if -instructie toe waarmee de foutopsporing wordt gestart en wordt gewacht totdat een foutopsporingsprogramma is toegevoegd. Als er vóór de time-out geen foutopsporingsprogramma wordt gekoppeld, wordt het script gewoon voortgezet. Zorg ervoor dat u de HOST functie en PORT -waarden vervangt listen door 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 leveren die nodig zijn om foutopsporing te starten en de uitvoeringscontext op te halen, maakt u een omgeving en stelt u pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']in. 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. Het laat ook zien hoe u de omgeving gebruikt die u eerder hebt gemaakt door in te stellen 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, wordt bij elke stap een onderliggende uitvoering gemaakt. 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 waarde op ip_address . Deze wordt gebruikt in de volgende sectie.

Tip

U kunt het IP-adres ook vinden in de uitvoeringslogboeken voor de onderliggende uitvoering voor deze pijplijnstap. Zie Uitvoeringen en metrische gegevens van Azure Machine Learning-experimenten 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 foutopsporingsconfiguratie:

    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 bestand launch.json de regel die bevat "configurations": [en voeg de volgende tekst erna in. Wijzig de "host": "<IP-ADDRESS>" vermelding in het IP-adres dat in uw logboeken uit de vorige sectie is geretourneerd. 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 in verschillende mappen opspoort, maakt u een afzonderlijke configuratiesectie voor elk script.

    3. Sla het bestand launch.json op.

Het foutopsporingsprogramma verbinden

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

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

  3. Terwijl het onderliggende proces het script uitvoert en de Timeout for debug connection wordt weergegeven in de logboeken, gebruikt u de toets F5 of selecteert u Fouten opsporen. Wanneer u hierom wordt gevraagd, selecteert u de configuratie Azure Machine Learning Compute: externe foutopsporing . U kunt ook het pictogram voor foutopsporing selecteren in de zijbalk, de vermelding Azure Machine Learning: externe foutopsporing in de vervolgkeuzelijst 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 bij 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 met de vermelding Debugger attached = False, is de time-out verlopen en is het script 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. Bijvoorbeeld als het invoerscript 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 wordt uitgevoerd in de Docker-container.

Tip

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

Belangrijk

Deze methode voor foutopsporing werkt niet bij het gebruik van Model.deploy() en LocalWebservice.deploy_configuration om een model lokaal te implementeren. In plaats daarvan moet u een installatiekopieën maken met behulp van de methode Model.package().

Lokale webservice-implementaties vereisen een werkende Docker-installatie op uw lokale systeem. 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 debugpy 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 voor communicatie met de Docker-installatiekopieën, maakt u een nieuwe foutopsporingsconfiguratie:

    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 'configurations' (de regel met "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 het invoegen moet het bestand launch.json 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 de sectie configuraties al andere vermeldingen bevat, 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 met foutopsporing

  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 foutopsporing 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 dit 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 in stap 1 zijn gemaakt.

    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 meer dan 10 minuten duren), wordt het pad naar de installatiekopieën (inclusief opslagplaats, naam en tag, in dit geval ook de digest) weergegeven in een bericht dat er ongeveer als volgt uitziet:

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

  4. Als u het gemakkelijker wilt maken om lokaal met de installatiekopieën te werken, kunt u de volgende opdracht gebruiken om een tag voor deze afbeelding toe te voegen. 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 installatiekopieën als debug:1 in plaats van de waarde van het volledige pad naar de afbeelding.

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 het klaar is voordat u de stappen in deze sectie uitvoert.

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

  1. Als u een Docker-container wilt starten met behulp van de installatiekopieën, gebruikt u de volgende opdracht:

    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 die in de container. Daarom worden alle wijzigingen die in de editor worden 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 de lokale container die u hebt gemaakt. In deze documentatie is het .debug:1 Klik met de rechtermuisknop op deze container en selecteer "Attach Visual Studio Code", waarna er automatisch een nieuwe VS Code-interface wordt geopend en deze interface de binnenkant van de gemaakte container weergeeft.

    De VS Code-interface van de container

  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:

    Console-uitvoer van de container uitvoeren

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

    Het pictogram foutopsporing, de knop Foutopsporing starten en de configuratiekiezer

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

    De bijgevoegde informatie van het containerfoutopsporingsprogramma

    In uw hoofdinterface van VS Code 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 bij 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 op te sporen in Python.

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 probleemoplossing: