Megosztás a következőn keresztül:

Interaktív hibakeresés a Visual Studio Code használatával

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azureml v1

Megtudhatja, hogyan végezhet interaktív hibakeresést az Azure Machine Learning-kísérletekben, folyamatokban és üzembe helyezésekben a Visual Studio Code (VS Code) és a debugpy használatával.

Kísérletek helyi futtatása és hibakeresése

Az Azure Machine Learning-bővítmény használatával érvényesítheti, futtathatja és hibakeresésre használhatja a gépi tanulási kísérleteket, mielőtt elküldené őket a felhőbe.

Előfeltételek

  • Azure Machine Learning VS Code-bővítmény (előzetes verzió). További információ: Az Azure Machine Learning VS Code bővítmény beállítása.

    Fontos

    Az Azure Machine Learning VS Code bővítmény alapértelmezés szerint a CLI -t (v2) használja. Az útmutató utasításai az 1.0 parancssori felületet használják. Az 1.0 parancssori felületre való váltáshoz állítsa a azureML.CLI Compatibility Mode Visual Studio Code beállítását a következőre 1.0: . A Visual Studio Code beállításainak módosításáról további információt a felhasználói és munkaterület-beállítások dokumentációjában talál.

    Fontos

    Ez a funkció jelenleg nyilvános előzetes verzióban érhető el. Ez az előzetes verzió szolgáltatásszintű szerződés nélkül érhető el, és éles számítási feladatokhoz nem javasoljuk. Előfordulhat, hogy néhány funkció nem támogatott, vagy korlátozott képességekkel rendelkezik.

    További információ: Kiegészítő használati feltételek a Microsoft Azure előzetes verziójú termékeihez.

  •   Docker

  • Python 3

Hibakeresési kísérlet helyileg

Fontos

A kísérlet helyi futtatása előtt győződjön meg arról, hogy:

  • A Docker fut.
  • A azureML.CLI Compatibility Mode Visual Studio Code-ban a beállítás az előfeltételekben megadott módon van beállítva 1.0

  1. A VS Code-ban nyissa meg az Azure Machine Learning bővítmény nézetet.

  2. Bontsa ki a munkaterületet tartalmazó előfizetési csomópontot. Ha még nincs ilyenje, létrehozhat egy Azure Machine Learning-munkaterületet a bővítmény használatával.

  3. Bontsa ki a munkaterület csomópontját.

  4. Kattintson a jobb gombbal a Kísérletek csomópontra, és válassza a Kísérlet létrehozása lehetőséget. Amikor megjelenik a kérdés, adjon nevet a kísérletnek.

  5. Bontsa ki a Kísérletek csomópontot, kattintson a jobb gombbal a futtatni kívánt kísérletre, és válassza a Kísérlet futtatása lehetőséget.

  6. A beállítások listájában válassza a Helyi lehetőséget.

  7. Csak windowsos első használat esetén. Amikor a rendszer kéri a fájlmegosztás engedélyezését, válassza az Igen lehetőséget. Ha engedélyezi a fájlmegosztást, a Docker csatlakoztathatja a szkriptet tartalmazó könyvtárat a tárolóhoz. Emellett lehetővé teszi a Docker számára, hogy a futtatás naplóit és kimeneteit a rendszer egy ideiglenes könyvtárában tárolja.

  8. Válassza az Igen lehetőséget a kísérlet hibakereséséhez. Egyéb esetben a Nem választógombot jelölje be. Ha nemet választ, helyileg futtatja a kísérletet a hibakereső csatolása nélkül.

  9. Válassza az Új futtatási konfiguráció létrehozása lehetőséget a futtatási konfiguráció létrehozásához. A futtatási konfiguráció határozza meg a futtatni kívánt szkriptet, a függőségeket és a használt adatkészleteket. Másik lehetőségként, ha már van ilyenje, válassza ki a legördülő listából.

    1. Válassza ki a környezetét. Választhat bármelyik Azure Machine Learning-válogatott közül, vagy létrehozhatja sajátját.
    2. Adja meg a futtatni kívánt szkript nevét. Az elérési út a VS Code-ban megnyitott könyvtárhoz képest van.
    3. Válassza ki, hogy Azure Machine Learning-adatkészletet szeretne-e használni. A bővítmény használatával Azure Machine Learning-adatkészleteket hozhat létre.
    4. Debugpy szükséges ahhoz, hogy a hibakeresőt a kísérletét futtató tárolóhoz csatolja. Ha függőségként szeretné hozzáadni a hibakeresőt, válassza a Hibakeresés hozzáadása lehetőséget. Ellenkező esetben válassza a Kihagyás lehetőséget. Ha nem ad hozzá hibakeresési elemet függőségként, futtatja a kísérletet anélkül, hogy a hibakeresőhöz csatlakozik.
    5. Megnyílik a szerkesztőben a futtatási konfigurációs beállításokat tartalmazó konfigurációs fájl. Ha elégedett a beállításokkal, válassza a Kísérlet elküldése lehetőséget. Másik lehetőségként nyissa meg a parancskatalógust (parancskatalógus megtekintése>) a menüsávon, és írja be a AzureML: Submit experiment parancsot a szövegmezőbe.

  10. A kísérlet elküldése után létrejön egy Docker-rendszerkép, amely tartalmazza a szkriptet és a futtatási konfigurációban megadott konfigurációkat.

    Amikor megkezdődik a Docker-rendszerkép-létrehozási folyamat, a 60_control_log.txt fájlstream tartalma a VS Code kimeneti konzoljára kerül.

    Feljegyzés

    A Docker-rendszerkép első létrehozása több percet is igénybe vehet.

  11. A rendszerkép létrehozása után megjelenik egy üzenet, amely elindítja a hibakeresőt. Állítsa be a töréspontokat a szkriptben, és válassza a Hibakereső indítása lehetőséget, amikor készen áll a hibakeresésre. Ezzel csatolja a VS Code hibakeresőt a kísérletét futtató tárolóhoz. Másik lehetőségként az Azure Machine Learning bővítményben mutasson az aktuális futtatás csomópontja fölé, és válassza a lejátszás ikont a hibakereső elindításához.

    Fontos

    Egyetlen kísérlethez nem lehet több hibakeresési munkamenet. Több VS Code-példány használatával azonban hibakeresést végezhet két vagy több kísérletben.

Ezen a ponton képesnek kell lennie arra, hogy a VS Code használatával végiglépkedjen a kódon, és hibakeresést végezzen.

Ha bármikor megszakítja a futtatásokat, kattintson a jobb gombbal a futtatási csomópontra, és válassza a Futtatás megszakítása lehetőséget.

A távoli kísérletfuttatásokhoz hasonlóan kibonthatja a futtatási csomópontot a naplók és kimenetek vizsgálatához.

Tipp.

A környezetében definiált függőségeket használó Docker-rendszerképek újra felhasználhatók a futtatások között. Ha azonban egy kísérletet egy új vagy más környezettel futtat, létrejön egy új rendszerkép. Mivel ezeket a képeket a rendszer a helyi tárolóba menti, javasoljuk, hogy távolítsa el a régi vagy a nem használt Docker-lemezképeket. A rendszerképek eltávolításához használja a Docker CLI-t vagy a VS Code Docker-bővítményt.

Hibakeresés és hibaelhárítás a gépi tanulási folyamatokban

Egyes esetekben előfordulhat, hogy interaktív hibakeresést kell végeznie az ML-folyamatban használt Python-kódon. A VS Code és a debugpy használatával csatolhatja a kódot a betanítási környezetben futó kódhoz.

Előfeltételek

  • Azure Machine Learning-munkaterület, amely azure-beli virtuális hálózat használatára van konfigurálva.

  • Egy Azure Machine Learning-folyamat , amely Python-szkripteket használ a folyamat lépéseinek részeként. Például egy PythonScriptStep.

  • Egy Azure Machine Learning Compute-fürt, amely a virtuális hálózaton található, és amelyet a folyamat a betanításhoz használ.

  • A virtuális hálózaton található fejlesztői környezet. A fejlesztési környezet az alábbiak egyike lehet:

    • Azure-beli virtuális gép a virtuális hálózaton
    • Notebook virtuális gép számítási példánya a virtuális hálózaton
    • Olyan ügyfélszámítógép, amely magánhálózati kapcsolattal rendelkezik a virtuális hálózathoz VPN-en vagy ExpressRoute-on keresztül.

Az Azure Virtual Network és az Azure Machine Learning használatával való használatáról további információt a virtuális hálózatok elkülönítése és az adatvédelem áttekintése című témakörben talál.

Tipp.

Bár olyan Azure Machine Learning-erőforrásokkal is dolgozhat, amelyek nem állnak virtuális hálózat mögött, a virtuális hálózat használata ajánlott.

Hogyan működik?

Az ML-folyamat lépései Python-szkripteket futtatnak. Ezek a szkriptek a következő műveletek végrehajtására módosulnak:

  1. Naplózza annak a gazdagépnek az IP-címét, amelyen fut. Az IP-cím használatával csatlakoztathatja a hibakeresőt a szkripthez.

  2. Indítsa el a hibakeresési összetevőt, és várja meg, amíg egy hibakereső csatlakozik.

  3. A fejlesztési környezetből figyelheti a betanítási folyamat által létrehozott naplókat, hogy megkeresse azt az IP-címet, amelyen a szkript fut.

  4. Meg kell adnia a VS Code-nak azt az IP-címet, amelyhez a hibakeresőt egy launch.json fájl használatával csatlakoztatja.

  5. Csatolja a hibakeresőt, és interaktívan végiglépked a szkripten.

Python-szkriptek konfigurálása

A hibakeresés engedélyezéséhez végezze el a következő módosításokat az ML-folyamat lépései által használt Python-szkript(ek)ben:

  1. Adja hozzá a következő importálási utasításokat:

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

  2. Adja hozzá a következő argumentumokat. Ezek az argumentumok lehetővé teszik, hogy szükség szerint engedélyezze a hibakeresőt, és beállítsa a hibakereső csatolásának időtúllépését:

    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. Adja hozzá a következő -utasításokat. Ezek az utasítások betöltik az aktuális futtatási környezetet, hogy naplózhassa annak a csomópontnak az IP-címét, amelyen a kód fut:

    global run
run = Run.get_context()

  4. Adjon hozzá egy olyan utasítást if , amely elindítja a hibakeresést, és várja a hibakereső csatolását. Ha az időtúllépés előtt egyetlen hibakereső sem csatlakozik, a szkript a szokásos módon folytatódik. Ügyeljen arra, hogy a függvényt PORT listen cserélje HOST le a saját értékére.

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

Az alábbi Python-példa egy egyszerű train.py fájlt mutat be, amely lehetővé teszi a hibakeresést:

# 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-folyamat konfigurálása

A hibakeresés indításához és a futtatási környezet lekéréséhez szükséges Python-csomagok biztosításához hozzon létre egy környezetet, és állítsa be a következőt pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']: Módosítsa az SDK-verziót úgy, hogy az megfeleljen a használt verziónak. A következő kódrészlet bemutatja, hogyan hozhat létre környezetet:

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

A Python-szkriptek konfigurálása szakaszban új argumentumok lettek hozzáadva az ML-folyamat lépései által használt szkriptekhez. Az alábbi kódrészlet bemutatja, hogyan használhatja ezeket az argumentumokat az összetevő hibakeresésének engedélyezéséhez és időtúllépés beállításához. Azt is bemutatja, hogyan használhatja a korábban létrehozott környezetet a következő beállítással 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)

A folyamat futtatásakor minden lépés létrehoz egy gyermekfuttatást. Ha a hibakeresés engedélyezve van, a módosított szkript a gyermekfuttatás következő 70_driver_log.txt szövegéhez hasonló adatokat naplóz:

Timeout for debug connection: 300
ip_address: 10.3.0.5

Mentse az ip_address értéket. A következő szakaszban használatos.

Tipp.

Az IP-címet a gyermekfuttatás futtatási naplóiból is megtalálhatja ehhez a folyamatlépéshez. Az információk megtekintéséről további információt az Azure Machine Learning-kísérletfuttatások és metrikák monitorozása című témakörben talál.

A fejlesztési környezet konfigurálása

  1. Ha hibakeresést szeretne telepíteni a VS Code fejlesztői környezetében, használja a következő parancsot:

    python -m pip install --upgrade debugpy

    A hibakereső VS Code-tal való használatáról további információt a Távoli hibakeresés című témakörben talál.

  2. Ha a VS Code-ot úgy szeretné konfigurálni, hogy kommunikáljon a hibakeresőt futtató Azure Machine Learning-számítással, hozzon létre egy új hibakeresési konfigurációt:

    1. A VS Code-ból válassza a Hibakeresés menüt, majd a Konfigurációk megnyitása lehetőséget. Megnyílik egy launch.json nevű fájl.

    2. A launch.json fájlban keresse meg a vonalat, "configurations": [és szúrja be utána a következő szöveget. Módosítsa a bejegyzést "host": "<IP-ADDRESS>" az előző szakasz naplóiban visszaadott IP-címre. Módosítsa a "localRoot": "${workspaceFolder}/code/step" bejegyzést egy helyi könyvtárra, amely tartalmazza a hibakeresés alatt álló szkript másolatát:

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

      Fontos

      Ha már vannak más bejegyzések a konfigurációk szakaszban, adjon hozzá egy vesszőt (,) a beszúrt kód után.

      Tipp.

      Az ajánlott eljárás, különösen a folyamatok esetében az, hogy a szkriptek erőforrásait külön könyvtárakban kell tartani, hogy a kód csak az egyes lépésekhez legyen releváns. Ebben a példában a localRoot példa értékre hivatkozik /code/step1.

      Ha több szkript hibakeresését végzi, különböző könyvtárakban hozzon létre egy külön konfigurációs szakaszt minden szkripthez.

    3. Mentse a launch.json fájlt.

A hibakereső csatlakoztatása

  1. Nyissa meg a VS Code-ot, és nyissa meg a szkript helyi példányát.

  2. Állítsa be azokat a töréspontokat, ahol le szeretné állítani a szkriptet a csatolás után.

  3. Amíg a gyermekfolyamat futtatja a szkriptet, és az Timeout for debug connection megjelenik a naplókban, használja az F5 billentyűt, vagy válassza a Hibakeresés lehetőséget. Amikor a rendszer kéri, válassza ki az Azure Machine Learning Compute: távoli hibakeresési konfigurációt. A hibakeresés ikont az oldalsávon, az Azure Machine Learning: távoli hibakeresési bejegyzésben is kiválaszthatja a Hibakeresés legördülő menüből, majd a zöld nyíllal csatolhatja a hibakeresőt.

    Ezen a ponton a VS Code csatlakozik a számítási csomópont hibakereséséhez, és a korábban beállított töréspontnál áll meg. Most már végiglépkedhet a kódon futás közben, megtekintheti a változókat stb.

    Feljegyzés

    Ha a napló egy bejegyzést jelenít meg, Debugger attached = Falseakkor az időtúllépés lejárt, és a szkript a hibakereső nélkül folytatódott. Küldje el újra a folyamatot, és csatlakoztassa a hibakeresőt az Timeout for debug connection üzenet után, majd az időtúllépés lejárta előtt.

Központi telepítések hibakeresése és hibaelhárítása

Bizonyos esetekben előfordulhat, hogy interaktívan kell hibakeresést végeznie a modell üzembe helyezésében található Python-kódban. Ha például a belépési szkript meghiúsul, és az ok nem határozható meg extra naplózással. A VS Code és a hibakereső használatával csatolhatja a Docker-tárolóban futó kódot.

Tipp.

Ha helyileg felügyelt online végpontokat és üzemelő példányokat használ, tekintse meg a felügyelt online végpontok helyi hibakeresését a Visual Studio Code-ban (előzetes verzió).

Fontos

Ez a hibakeresési módszer nem működik modell helyi használatakor Model.deploy() és LocalWebservice.deploy_configuration üzembe helyezésekor. Ehelyett létre kell hoznia egy képet a Model.package() metódussal.

A helyi webszolgáltatás üzembe helyezéséhez működő Docker-telepítésre van szükség a helyi rendszeren. A Docker használatával kapcsolatos további információkért tekintse meg a Docker dokumentációját. Számítási példányok használatakor a Docker már telepítve van.

A fejlesztési környezet konfigurálása

  1. A hibakeresés helyi VS Code-fejlesztési környezetben való telepítéséhez használja a következő parancsot:

    python -m pip install --upgrade debugpy

    A hibakereső VS Code-tal való használatáról további információt a Távoli hibakeresés című témakörben talál.

  2. Ha a VS Code-ot a Docker-lemezképpel való kommunikációra szeretné konfigurálni, hozzon létre egy új hibakeresési konfigurációt:

    1. A VS Code-ban válassza a Hibakeresés menüt a Futtatás terjedelmében, majd válassza a Konfigurációk megnyitása lehetőséget. Megnyílik egy launch.json nevű fájl.

    2. A launch.json fájlban keresse meg a "konfigurációk" elemet (a sort, amely tartalmazza"configurations": [), és szúrja be a következő szöveget utána.

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

      A beszúrás után a launch.json fájlnak a következőhöz hasonlónak kell lennie:

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

      Fontos

      Ha már vannak más bejegyzések a konfigurációk szakaszban, adjon hozzá egy vesszőt ( , ) a beszúrt kód után.

      Ez a szakasz az 5678-es porton keresztül csatlakozik a Docker-tárolóhoz.

    3. Mentse a launch.json fájlt.

Debugpy-t tartalmazó rendszerkép létrehozása

  1. Módosítsa az üzembe helyezés conda-környezetét úgy, hogy az tartalmazza a hibakeresést. Az alábbi példa azt mutatja be, hogy a paraméterrel adja hozzá: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())

  2. A hibakeresés elindításához és a szolgáltatás indításakor várja meg a kapcsolatot, adja hozzá a következőket a score.py fájl tetejére:

    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. Hozzon létre egy lemezképet a környezetdefiníció alapján, és kérje le a lemezképet a helyi beállításjegyzékbe.

    Feljegyzés

    Ez a példa feltételezi, hogy ws az Azure Machine Learning-munkaterületre mutat, és ez model az üzembe helyezett modell. A myenv.yml fájl az 1. lépésben létrehozott conda-függőségeket tartalmazza.

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

    A rendszerkép létrehozása és letöltése után (ez a folyamat több mint 10 percet is igénybe vehet), a rendszerkép elérési útja (az adattárat, a nevet és a címkét is tartalmazza, amely ebben az esetben a kivonata is) végül az alábbihoz hasonló üzenetben jelenik meg:

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

  4. A kép helyi használatának megkönnyítése érdekében az alábbi paranccsal hozzáadhat egy címkét a képhez. Cserélje le myimagepath az alábbi parancsot az előző lépés helyértékére.

    docker tag myimagepath debug:1

    A többi lépésnél a teljes kép elérési útja helyett a helyi rendszerképre debug:1 is hivatkozhat.

A szolgáltatás hibakeresése

Tipp.

Ha időtúllépést állít be a hibakeresési kapcsolathoz a score.py fájlban, az időtúllépés lejárta előtt csatlakoztatnia kell a VS Code-ot a hibakeresési munkamenethez. Indítsa el a VS Code-ot, nyissa meg a helyi példányt score.py, állítson be egy töréspontot, és tegye készen arra, hogy továbblépjen, mielőtt a szakasz lépéseit követené.

A hibakereséssel és a töréspontok beállításával kapcsolatos további információkért lásd a hibakeresést.

  1. Docker-tároló rendszerkép használatával való elindításához használja a következő parancsot:

    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

    Ez a parancs helyileg csatolja a score.py tárolóban lévőhöz. Ezért a szerkesztőben végrehajtott módosítások automatikusan megjelennek a tárolóban

  2. A jobb élmény érdekében egy új VS Code-felülettel léphet be a tárolóba. Válassza ki a Docker terjedelmet a VS Code oldalsávjáról, keresse meg a létrehozott helyi tárolót, ebben a dokumentációban annak debug:1. Kattintson a jobb gombbal erre a tárolóra, és válassza a lehetőséget "Attach Visual Studio Code", majd automatikusan megnyílik egy új VS Code-felület, és ez a felület megjeleníti a létrehozott tároló belsejét.

    A tároló VS Code felülete

  3. A tárolón belül futtassa a következő parancsot a rendszerhéjban

    runsvdir /var/runit

    Ezután a következő kimenet jelenik meg a tárolóban lévő rendszerhéjban:

    A tároló futtatási konzoljának kimenete

  4. Ha a VS Code-ot a tárolón belüli hibakereséshez szeretné csatolni, nyissa meg a VS Code-ot, és használja az F5 billentyűt, vagy válassza a Hibakeresés lehetőséget. Amikor a rendszer kéri, válassza ki az Azure Machine Learning Deployment: Docker Debug konfigurációját. Az oldalsávon a Run extention ikont is kiválaszthatja, az Azure Machine Learning Deployment: Docker Debug entry elemét a Hibakeresés legördülő menüből, majd a zöld nyíllal csatolhatja a hibakeresőt.

    A hibakeresés ikon, a hibakeresés indítása gomb és a konfigurációválasztó

    Miután kiválasztotta a zöld nyilat, és csatolta a hibakeresőt, a tároló VS Code felületén néhány új információ jelenik meg:

    A tároló hibakeresője által csatolt információk

    Emellett a fő VS Code-felületen az alábbiak láthatók:

    A VS Code töréspontja a score.py

Most pedig a tárolóhoz csatolt helyi score.py hely már leállt a beállított töréspontoknál. Ezen a ponton a VS Code csatlakozik a Docker-tárolón belüli hibakereséshez, és leállítja a Docker-tárolót a korábban beállított töréspontnál. Most már végiglépkedhet a kódon futás közben, megtekintheti a változókat stb.

A Python hibakereséséhez a VS Code használatával kapcsolatos további információkért lásd a Python-kód hibakeresését ismertető témakört.

A tároló leállítása

A tároló leállításához használja a következő parancsot:

docker stop debug

Következő lépések

Most, hogy beállította a VS Code Remote szolgáltatást, egy számítási példányt használhat távoli számításként a VS Code-ból a kód interaktív hibakereséséhez.

További információ a hibaelhárításról: