Debugowanie interakcyjne za pomocą programu Visual Studio Code

Artykuł
03/25/2023
Czas czytania: 16 min

DOTYCZY:Zestaw SDK języka Python w wersji 1

Dowiedz się, jak interaktywnie debugować eksperymenty, potoki i wdrożenia usługi Azure Machine Learning przy użyciu Visual Studio Code (VS Code) i debugpy.

Uruchamianie i debugowanie eksperymentów lokalnie

Użyj rozszerzenia Azure Machine Learning, aby zweryfikować, uruchomić i debugować eksperymenty uczenia maszynowego przed przesłaniem ich do chmury.

Wymagania wstępne

Rozszerzenie programu VS Code usługi Azure Machine Learning (wersja zapoznawcza). Aby uzyskać więcej informacji, zobacz Konfigurowanie rozszerzenia programu VS Code usługi Azure Machine Learning.

Ważne

Rozszerzenie programu VS Code usługi Azure Machine Learning domyślnie używa interfejsu wiersza polecenia (wersja 2). Instrukcje w tym przewodniku używają interfejsu wiersza polecenia w wersji 1.0. Aby przełączyć się do interfejsu wiersza polecenia w wersji 1.0, ustaw azureML.CLI Compatibility Mode ustawienie w Visual Studio Code na 1.0. Aby uzyskać więcej informacji na temat modyfikowania ustawień w Visual Studio Code, zobacz dokumentację ustawień użytkownika i obszaru roboczego.

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest dostarczana bez umowy dotyczącej poziomu usług i nie jest zalecana w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone. Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.
Docker
- Docker Desktop dla komputerów Mac i Windows
- Aparat platformy Docker dla systemu Linux.
  
  Uwaga
  
  W systemie Windows upewnij się, że platforma Docker będzie używać kontenerów systemu Linux.
  
  Porada
  
  W przypadku systemu Windows, chociaż nie jest to wymagane, zdecydowanie zaleca się używanie platformy Docker z Podsystem Windows dla systemu Linux (WSL) 2.
Python 3

Lokalne debugowanie eksperymentu

Ważne

Przed uruchomieniem eksperymentu lokalnie upewnij się, że:

Platforma Docker jest uruchomiona.
Ustawienie azureML.CLI Compatibility Mode w Visual Studio Code jest ustawione zgodnie 1.0 z wymaganiami wstępnymi

W programie VS Code otwórz widok rozszerzenia Usługi Azure Machine Learning.
Rozwiń węzeł subskrypcji zawierający obszar roboczy. Jeśli jeszcze go nie masz, możesz utworzyć obszar roboczy usługi Azure Machine Learning przy użyciu rozszerzenia .
Rozwiń węzeł obszaru roboczego.
Kliknij prawym przyciskiem myszy węzeł Eksperymenty i wybierz pozycję Utwórz eksperyment. Po wyświetleniu monitu podaj nazwę eksperymentu.
Rozwiń węzeł Eksperymenty , kliknij prawym przyciskiem myszy eksperyment, który chcesz uruchomić, a następnie wybierz pozycję Uruchom eksperyment.
Z listy opcji wybierz pozycję Lokalnie.
Użycie tylko po raz pierwszy w systemie Windows. Po wyświetleniu monitu o zezwolenie na udział plików wybierz pozycję Tak. Po włączeniu udziału plików umożliwia platformie Docker instalowanie katalogu zawierającego skrypt w kontenerze. Ponadto umożliwia również platformie Docker przechowywanie dzienników i danych wyjściowych z uruchomienia w katalogu tymczasowym w systemie.
Wybierz pozycję Tak , aby debugować eksperyment. W przeciwnym razie wybierz opcję Nie. Wybranie opcji Nie spowoduje lokalnego uruchomienia eksperymentu bez dołączania do debugera.
Wybierz pozycję Utwórz nową konfigurację uruchamiania , aby utworzyć konfigurację przebiegu. Konfiguracja uruchamiania definiuje skrypt, który ma być uruchamiany, zależności i używane zestawy danych. Alternatywnie, jeśli masz już jeden, wybierz go z listy rozwijanej.
1. Wybierz środowisko. Możesz wybrać dowolną z wyselekcjonowanych lub utworzonych własnych usług Azure Machine Learning.
2. Podaj nazwę skryptu, który chcesz uruchomić. Ścieżka jest względna względem katalogu otwartego w programie VS Code.
3. Wybierz, czy chcesz użyć zestawu danych usługi Azure Machine Learning, czy nie. Zestawy danych usługi Azure Machine Learning można utworzyć przy użyciu rozszerzenia .
4. Debugpy jest wymagany w celu dołączenia debugera do kontenera uruchamiającego eksperyment. Aby dodać debugpy jako zależność, wybierz pozycję Dodaj debugpy. W przeciwnym razie wybierz pozycję Pomiń. Nie dodaje debugpy jako zależności uruchamia eksperyment bez dołączania do debugera.
5. Plik konfiguracji zawierający ustawienia konfiguracji uruchamiania zostanie otwarty w edytorze. Jeśli ustawienia są zadowalające, wybierz pozycję Prześlij eksperyment. Możesz też otworzyć paletę poleceń (Wyświetl > paletę poleceń) z paska menu i wprowadzić AzureML: Submit experiment polecenie w polu tekstowym.
Po przesłaniu eksperymentu zostanie utworzony obraz platformy Docker zawierający skrypt i konfiguracje określone w konfiguracji przebiegu.

Po rozpoczęciu procesu kompilacji obrazu platformy Docker zawartość 60_control_log.txt strumienia plików do konsoli wyjściowej w programie VS Code.

Uwaga

Utworzenie obrazu platformy Docker po raz pierwszy może potrwać kilka minut.
Po utworzeniu obrazu zostanie wyświetlony monit o uruchomienie debugera. Ustaw punkty przerwania w skrycie i wybierz pozycję Rozpocznij debuger , gdy wszystko będzie gotowe do rozpoczęcia debugowania. Spowoduje to dołączenie debugera programu VS Code do kontenera uruchamiającego eksperyment. Alternatywnie w rozszerzeniu usługi Azure Machine Learning umieść wskaźnik myszy na węźle dla bieżącego przebiegu i wybierz ikonę odtwarzania, aby uruchomić debuger.

Ważne

Nie można mieć wielu sesji debugowania dla jednego eksperymentu. Można jednak debugować co najmniej dwa eksperymenty przy użyciu wielu wystąpień programu VS Code.

Na tym etapie powinno być możliwe wykonanie kroków i debugowanie kodu przy użyciu programu VS Code.

Jeśli w dowolnym momencie chcesz anulować przebieg, kliknij prawym przyciskiem myszy węzeł uruchamiania i wybierz pozycję Anuluj przebieg.

Podobnie jak w przypadku przebiegów eksperymentów zdalnych, możesz rozwinąć węzeł uruchamiania, aby sprawdzić dzienniki i dane wyjściowe.

Porada

Obrazy platformy Docker korzystające z tych samych zależności zdefiniowanych w środowisku są ponownie używane między przebiegami. Jeśli jednak uruchomisz eksperyment przy użyciu nowego lub innego środowiska, zostanie utworzony nowy obraz. Ponieważ te obrazy są zapisywane w magazynie lokalnym, zaleca się usunięcie starych lub nieużywanych obrazów platformy Docker. Aby usunąć obrazy z systemu, użyj interfejsu wiersza polecenia platformy Docker lub rozszerzenia platformy Docker programu VS Code.

Debugowanie i rozwiązywanie problemów z potokami uczenia maszynowego

W niektórych przypadkach może być konieczne interaktywne debugowanie kodu języka Python użytego w potoku usługi ML. Za pomocą programu VS Code i debugpy można dołączyć go do kodu, gdy jest uruchamiany w środowisku szkoleniowym.

Wymagania wstępne

Obszar roboczy usługi Azure Machine Learning skonfigurowany do korzystania z usługi Azure Virtual Network.
Potok usługi Azure Machine Learning, który używa skryptów języka Python w ramach kroków potoku. Na przykład pythonScriptStep.
Klaster obliczeniowy usługi Azure Machine Learning, który znajduje się w sieci wirtualnej i jest używany przez potok do trenowania.
Środowisko programistyczne, które znajduje się w sieci wirtualnej. Środowisko programistyczne może być jednym z następujących elementów:
- Maszyna wirtualna platformy Azure w sieci wirtualnej
- Wystąpienie obliczeniowe maszyny wirtualnej notesu w sieci wirtualnej
- Maszyna kliencka, która ma prywatną łączność sieciową z siecią wirtualną, przez sieć VPN lub za pośrednictwem usługi ExpressRoute.

Aby uzyskać więcej informacji na temat korzystania z usługi Azure Virtual Network z usługą Azure Machine Learning, zobacz Omówienie izolacji sieci wirtualnej i prywatności.

Porada

Chociaż możesz pracować z zasobami usługi Azure Machine Learning, które nie znajdują się za siecią wirtualną, zaleca się użycie sieci wirtualnej.

Jak to działa

Kroki potoku uczenia maszynowego uruchamiają skrypty języka Python. Te skrypty są modyfikowane w celu wykonania następujących akcji:

Zarejestruj adres IP hosta, na którym są uruchomione. Adres IP służy do łączenia debugera ze skryptem.
Uruchom składnik debugowania debugowania i poczekaj na połączenie debugera.
W środowisku deweloperów można monitorować dzienniki utworzone przez proces trenowania, aby znaleźć adres IP, na którym działa skrypt.
Za pomocą pliku należy poinformować program VS Code o adresie IP umożliwiającym połączenie debugera z plikiem launch.json .
Debuger jest dołączany i interaktywnie przechodzi przez skrypt.

Konfigurowanie skryptów języka Python

Aby włączyć debugowanie, wprowadź następujące zmiany w skryptach języka Python używanych przez kroki w potoku uczenia maszynowego:

Dodaj następujące instrukcje importowania:

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

Dodaj następujące argumenty. Te argumenty umożliwiają włączenie debugera zgodnie z potrzebami i ustawienie limitu czasu dołączania debugera:

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

Dodaj następujące instrukcje. Te instrukcje ładują bieżący kontekst uruchomienia, aby można było zarejestrować adres IP węzła, na którym działa kod:
```
global run
run = Run.get_context()
```

Dodaj instrukcję if , która uruchamia debugpy i czeka na dołączenie debugera. Jeśli debuger nie dołączy przed przekroczeniem limitu czasu, skrypt będzie kontynuowany jako normalny. Pamiętaj, aby zastąpić HOST wartości i PORT jest listen funkcją własną.

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

Poniższy przykład języka Python przedstawia prosty train.py plik, który umożliwia debugowanie:

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

Konfigurowanie potoku uczenia maszynowego

Aby udostępnić pakiety języka Python potrzebne do uruchomienia debugpy i pobrania kontekstu uruchamiania, utwórz środowisko i ustaw polecenie pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Zmień wersję zestawu SDK, aby pasować do używanej wersji. Poniższy fragment kodu pokazuje, jak utworzyć środowisko:

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

W sekcji Konfigurowanie skryptów języka Python nowe argumenty zostały dodane do skryptów używanych przez kroki potoku uczenia maszynowego. Poniższy fragment kodu pokazuje, jak używać tych argumentów do włączania debugowania składnika i ustawiania limitu czasu. Pokazuje również, jak używać środowiska utworzonego wcześniej przez ustawienie 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)

Po uruchomieniu potoku każdy krok tworzy uruchomienie podrzędne. Jeśli debugowanie jest włączone, zmodyfikowany skrypt rejestruje informacje podobne do następującego tekstu w 70_driver_log.txt uruchomieniu podrzędnym:

Timeout for debug connection: 300
ip_address: 10.3.0.5

ip_address Zapisz wartość. Jest on używany w następnej sekcji.

Porada

Adres IP można również znaleźć w dziennikach uruchamiania dla podrzędnego uruchomienia dla tego kroku potoku. Aby uzyskać więcej informacji na temat wyświetlania tych informacji, zobacz Monitorowanie przebiegów eksperymentów i metryk usługi Azure Machine Learning.

Konfigurowanie środowiska programowania

Aby zainstalować debugpy w środowisku programistycznym programu VS Code, użyj następującego polecenia:
```
python -m pip install --upgrade debugpy
```
Aby uzyskać więcej informacji na temat korzystania z debugpy z programem VS Code, zobacz Debugowanie zdalne.
Aby skonfigurować program VS Code do komunikowania się z obliczeniami usługi Azure Machine Learning z uruchomionym debugerem, utwórz nową konfigurację debugowania:
1. W programie VS Code wybierz menu Debuguj , a następnie wybierz pozycję Otwórz konfiguracje. Zostanie otwarty plik o nazwie launch.json .
2. W pliku launch.json znajdź wiersz zawierający "configurations": [ciąg , a następnie wstaw następujący tekst. "host": "<IP-ADDRESS>" Zmień wpis na adres IP zwrócony w dziennikach z poprzedniej sekcji. "localRoot": "${workspaceFolder}/code/step" Zmień wpis na katalog lokalny zawierający kopię debugowanego skryptu:
```
{
    "name": "Azure Machine Learning Compute: remote debug",
    "type": "python",
    "request": "attach",
    "port": 5678,
    "host": "<IP-ADDRESS>",
    "redirectOutput": true,
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}/code/step1",
            "remoteRoot": "."
        }
    ]
}
```
  Ważne
  
  Jeśli w sekcji konfiguracji znajdują się już inne wpisy, dodaj przecinek (,) po wstawionym kodzie.
  
  Porada
  
  Najlepszym rozwiązaniem, szczególnie w przypadku potoków, jest przechowywanie zasobów skryptów w oddzielnych katalogach, aby kod był odpowiedni tylko dla każdego z kroków. W tym przykładzie przykładowa localRoot wartość odwołuje się /code/step1do elementu .
  
  Jeśli debugujesz wiele skryptów, w różnych katalogach utwórz oddzielną sekcję konfiguracji dla każdego skryptu.
3. Zapisz plik launch.json .

Łączenie debugera

Otwórz program VS Code i otwórz lokalną kopię skryptu.
Ustaw punkty przerwania, w których skrypt ma zostać zatrzymany po dołączeniu.
Gdy proces podrzędny uruchamia skrypt i Timeout for debug connection jest wyświetlany w dziennikach, użyj klucza F5 lub wybierz pozycję Debuguj. Po wyświetleniu monitu wybierz pozycję Azure Machine Learning Compute: konfiguracja debugowania zdalnego . Możesz również wybrać ikonę debugowania na pasku bocznym, wpis Azure Machine Learning: debugowanie zdalne z menu rozwijanego Debugowanie, a następnie użyć zielonej strzałki, aby dołączyć debuger.

W tym momencie program VS Code łączy się z debugpy w węźle obliczeniowym i zatrzymuje się w ustawionym wcześniej punkcie przerwania. Teraz możesz przechodzić przez kod podczas uruchamiania, wyświetlać zmienne itp.

Uwaga

Jeśli w dzienniku zostanie wyświetlony wpis z informacją Debugger attached = False, upłynął limit czasu, a skrypt będzie kontynuowany bez debugera. Prześlij potok ponownie i połącz debuger po Timeout for debug connection komunikacie i przed wygaśnięciem limitu czasu.

Debugowanie i rozwiązywanie problemów z wdrożeniami

W niektórych przypadkach może być konieczne interaktywne debugowanie kodu języka Python zawartego we wdrożeniu modelu. Jeśli na przykład skrypt wpisu kończy się niepowodzeniem i przyczyną nie można określić przez dodatkowe rejestrowanie. Za pomocą programu VS Code i debugpy można dołączyć do kodu uruchomionego w kontenerze platformy Docker.

Porada

Oszczędzaj czas i przechwytuj usterki na wczesnym etapie, debugując zarządzane punkty końcowe online i wdrożenia lokalnie. Aby uzyskać więcej informacji, zobacz Debugowanie zarządzanych punktów końcowych online lokalnie w Visual Studio Code (wersja zapoznawcza).

Ważne

Ta metoda debugowania nie działa podczas używania Model.deploy() i LocalWebservice.deploy_configuration wdrażania modelu lokalnie. Zamiast tego należy utworzyć obraz przy użyciu metody Model.package().

Lokalne wdrożenia usługi sieci Web wymagają działającej instalacji platformy Docker w systemie lokalnym. Aby uzyskać więcej informacji na temat korzystania z platformy Docker, zobacz dokumentację platformy Docker. Podczas pracy z wystąpieniami obliczeniowymi platforma Docker jest już zainstalowana.

Konfigurowanie środowiska programowania

Aby zainstalować debugpy w lokalnym środowisku programistycznym programu VS Code, użyj następującego polecenia:
```
python -m pip install --upgrade debugpy
```
Aby uzyskać więcej informacji na temat korzystania z debugpy z programem VS Code, zobacz Debugowanie zdalne.

Aby skonfigurować program VS Code do komunikowania się z obrazem platformy Docker, utwórz nową konfigurację debugowania:

W programie VS Code wybierz menu Debuguj w obszarze Zakres uruchamiania , a następnie wybierz pozycję Otwórz konfiguracje. Zostanie otwarty plik o nazwie launch.json .

W pliku launch.json znajdź element "configurations" (wiersz zawierający "configurations": [) i wstaw następujący tekst po nim.

{
    "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"
        }
    ]
}

Po wstawieniu plik launch.json powinien być podobny do następującego:

{
// 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"
            }
        ]
    }
    ]
}

Ważne

Jeśli w sekcji konfiguracji znajdują się już inne wpisy, dodaj przecinek ( , ) po wstawionym kodzie.

Ta sekcja jest dołączana do kontenera platformy Docker przy użyciu portu 5678.

Zapisz plik launch.json .

Tworzenie obrazu zawierającego debugpy

Zmodyfikuj środowisko conda dla wdrożenia, aby obejmowało debugpy. W poniższym przykładzie pokazano, jak dodać go przy użyciu parametru pip_packages :

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

Aby uruchomić debugpy i poczekać na połączenie po uruchomieniu usługi, dodaj następujące polecenie do góry score.py pliku:

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

Utwórz obraz na podstawie definicji środowiska i pobierz obraz do rejestru lokalnego.

Uwaga

W tym przykładzie przyjęto założenie, że ws wskazuje obszar roboczy usługi Azure Machine Learning i model jest to model, który jest wdrażany. Plik myenv.yml zawiera zależności conda utworzone w kroku 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:20210615.v1"
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()

Po utworzeniu i pobraniu obrazu (ten proces może potrwać więcej niż 10 minut), ścieżka obrazu (obejmuje repozytorium, nazwę i tag, który w tym przypadku jest również jego skrótem) zostanie ostatecznie wyświetlona w komunikacie podobnym do następującego:

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

Aby ułatwić pracę z obrazem lokalnie, możesz użyć następującego polecenia, aby dodać tag dla tego obrazu. Zastąp myimagepath ciąg w poniższym poleceniu wartością lokalizacji z poprzedniego kroku.
```
docker tag myimagepath debug:1
```
W pozostałych krokach można odwoływać się do obrazu debug:1 lokalnego zamiast pełnej wartości ścieżki obrazu.

Debugowanie usługi

Porada

Jeśli ustawisz limit czasu dla połączenia debugpy w score.py pliku, musisz połączyć program VS Code z sesją debugowania przed wygaśnięciem limitu czasu. Uruchom program VS Code, otwórz lokalną kopię score.pyprogramu , ustaw punkt przerwania i przygotuj go do pracy przed wykonaniem kroków w tej sekcji.

Aby uzyskać więcej informacji na temat debugowania i ustawiania punktów przerwania, zobacz Debugowanie.

Aby uruchomić kontener platformy Docker przy użyciu obrazu, użyj następującego polecenia:
```
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
```
To polecenie dołącza lokalnie score.py do niego w kontenerze. W związku z tym wszelkie zmiany wprowadzone w edytorze są automatycznie odzwierciedlane w kontenerze
Aby uzyskać lepsze środowisko, możesz przejść do kontenera przy użyciu nowego interfejsu programu VS Code. Docker Wybierz zakres na pasku bocznym programu VS Code, znajdź utworzony kontener lokalny w tej dokumentacjidebug:1. Kliknij prawym przyciskiem myszy ten kontener i wybierz polecenie "Attach Visual Studio Code", a następnie zostanie otwarty automatycznie nowy interfejs programu VS Code, a ten interfejs pokazuje wewnątrz utworzonego kontenera.
W kontenerze uruchom następujące polecenie w powłoce
```
runsvdir /var/runit
```
Następnie możesz zobaczyć następujące dane wyjściowe w powłoce wewnątrz kontenera:
Aby dołączyć program VS Code do debugpy wewnątrz kontenera, otwórz program VS Code i użyj klucza F5 lub wybierz pozycję Debuguj. Po wyświetleniu monitu wybierz konfigurację wdrożenia usługi Azure Machine Learning: Docker Debug . Możesz również wybrać ikonę Uruchom rozszerzenie na pasku bocznym, wpis Wdrożenie usługi Azure Machine Learning: Debugowanie platformy Docker z menu rozwijanego Debugowanie, a następnie użyć zielonej strzałki, aby dołączyć debuger.

Po wybraniu zielonej strzałki i dołącz debugerze w interfejsie programu VS Code kontenera są widoczne nowe informacje:

Ponadto w głównym interfejsie programu VS Code widoczne są następujące elementy:

A teraz lokalna score.py , która jest dołączona do kontenera, została już zatrzymana w punktach przerwania, w których ustawiono. W tym momencie program VS Code łączy się z debugpy wewnątrz kontenera platformy Docker i zatrzymuje kontener platformy Docker w ustawionym wcześniej punkcie przerwania. Teraz możesz przechodzić przez kod podczas jego uruchamiania, wyświetlać zmienne itp.

Aby uzyskać więcej informacji na temat debugowania języka Python przy użyciu programu VS Code, zobacz Debugowanie kodu w języku Python.

Zatrzymywanie kontenera

Aby zatrzymać kontener, użyj następującego polecenia:

docker stop debug

Następne kroki

Po skonfigurowaniu programu VS Code Remote możesz użyć wystąpienia obliczeniowego jako zdalnego przetwarzania z programu VS Code, aby interaktywnie debugować kod.

Dowiedz się więcej o rozwiązywaniu problemów:

Debugowanie interakcyjne za pomocą programu Visual Studio Code

Uruchamianie i debugowanie eksperymentów lokalnie

Wymagania wstępne

Lokalne debugowanie eksperymentu

Debugowanie i rozwiązywanie problemów z potokami uczenia maszynowego

Wymagania wstępne

Jak to działa

Konfigurowanie skryptów języka Python

Konfigurowanie potoku uczenia maszynowego

Konfigurowanie środowiska programowania

Łączenie debugera

Debugowanie i rozwiązywanie problemów z wdrożeniami

Konfigurowanie środowiska programowania

Tworzenie obrazu zawierającego debugpy

Debugowanie usługi

Zatrzymywanie kontenera

Następne kroki

Dodatkowe zasoby

Dodatkowe zasoby