Debug interattivo con Visual Studio Code

SI APPLICA A: Python SDK azureml v1

Informazioni su come eseguire il debug interattivo di esperimenti, pipeline e distribuzioni di Azure Machine Learning con Visual Studio Code (VS Code) e debugpy.

Eseguire esperimenti ed eseguirne il debug in locale

Usare l'estensione Azure Machine Learning per convalidare, eseguire ed eseguire il debug degli esperimenti di Machine Learning prima di inviarli al cloud.

Prerequisiti

• Estensione di VS Code per Azure Machine Learning (anteprima). Per altre informazioni, vedere Configurare l'estensione di VS Code per Azure Machine Learning.

  Importante

  Per impostazione predefinita, l'estensione di VS Code per Azure Machine Learning usa l'interfaccia della riga di comando (v2). Nelle istruzioni di questa guida viene usata l'interfaccia della riga di comando 1.0. Per passare all'interfaccia della riga di comando 1.0, impostare azureML.CLI Compatibility Mode su 1.0 in Visual Studio Code. Per altre informazioni sulla modifica delle impostazioni in Visual Studio Code, vedere la documentazione sulle impostazioni dell'utente e dell'area di lavoro.

  Importante

  Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

  Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

• Docker

  • Docker Desktop per Mac e Windows

  • Docker Engine per Linux.

    Nota

    In Windows assicurarsi di configurare Docker per l'uso di contenitori Linux.

    Suggerimento

    Anche se non è necessario, per Windows è consigliabile usare Docker con sottosistema Windows per Linux (WSL) 2.

• Python 3

Eseguire il debug di un esperimento in locale

1. In VS Code aprire la visualizzazione dell'estensione per Azure Machine Learning.

2. Espandere il nodo della sottoscrizione contenente l'area di lavoro. Se non si ha già un'area di lavoro, è possibile usare l'estensione per creare un'area di lavoro di Azure Machine Learning.

3. Espandere il nodo dell'area di lavoro.

4. Fare clic con il pulsante destro del mouse sul nodo Esperimenti e selezionare Crea esperimento. Quando viene visualizzata la richiesta, specificare un nome per l'esperimento.

5. Espandere il nodo Esperimenti, fare clic con il pulsante destro del mouse sull'esperimento da eseguire e selezionare Esegui esperimento.

6. Nell'elenco delle opzioni selezionare In locale.

7. Prima volta solo in Windows. Quando viene richiesto di consentire la condivisione file, selezionare Sì. Quando si abilita la condivisione file, Docker può montare la directory contenente lo script nel contenitore. Docker può anche archiviare i log e gli output dell'esecuzione in una directory temporanea nel sistema.

8. Selezionare Sì per eseguire il debug dell'esperimento. In caso contrario, selezionare No. Se si seleziona No, l'esperimento verrà eseguito in locale senza collegamento al debugger.

9. Selezionare Crea nuova configurazione di esecuzione per creare la configurazione di esecuzione. La configurazione di esecuzione definisce lo script da eseguire, le dipendenze e i set di dati usati. In alternativa, se ne esiste già una, selezionarla nell'elenco a discesa.

   1. Scegliere l'ambiente. È possibile sceglierne uno di quelli curati da Azure Machine Learning o crearne uno personalizzato.
   2. Specificare il nome dello script da eseguire. Il percorso è relativo alla directory aperta in VS Code.
   3. Scegliere se usare o meno un set di dati di Azure Machine Learning. È possibile creare set di dati di Azure Machine Learning usando l'estensione.
   4. Debugpy è necessario per collegare il debugger al contenitore in cui viene eseguito l'esperimento. Per aggiungere debugpy come dipendenza, selezionare Aggiungi Debugpy. In caso contrario, selezionare Ignora. Se non si aggiunge debugpy come dipendenza, l'esperimento verrà eseguito senza collegamento al debugger.
   5. Nell'editor viene aperto un file di configurazione contenente le impostazioni di configurazione dell'esecuzione. Se si è soddisfatti delle impostazioni, selezionare Invia esperimento. In alternativa, aprire il riquadro comandi (Visualizza > Riquadro comandi) dalla barra dei menu e immettere il comando AzureML: Submit experiment nella casella di testo.

10. Dopo l'invio dell'esperimento, viene creata un'immagine Docker contenente lo script e le configurazioni specificate nella configurazione di esecuzione.

    All'avvio del processo di creazione dell'immagine Docker, il contenuto del file 60_control_log.txt viene visualizzato nella console di output in VS Code.

    Nota

    La prima volta che viene creata l'immagine Docker, l'operazione può richiedere alcuni minuti.

11. Dopo che l'immagine è stata creata, viene visualizzata una richiesta di avvio del debugger. Impostare i punti di interruzione nello script e selezionare Avvia debugger quando si è pronti per avviare il debug. In questo modo il debugger di VS Code viene collegato al contenitore in cui viene eseguito l'esperimento. In alternativa, nell'estensione per Azure Machine Learning passare il puntatore del mouse sul nodo dell'esecuzione corrente e selezionare l'icona di riproduzione per avviare il debugger.

    Importante

    Non è possibile avere più sessioni di debug per un singolo esperimento. È tuttavia possibile eseguire il debug di due o più esperimenti usando più istanze di VS Code.

A questo punto dovrebbe essere possibile eseguire il codice istruzione per istruzione ed eseguirne il debug con VS Code.

Se in qualsiasi momento si vuole annullare l'esecuzione, fare clic con il pulsante destro del mouse sul nodo dell'esecuzione e selezionare Annulla esecuzione.

Analogamente alle esecuzioni dell'esperimento in remoto, è possibile espandere il nodo dell'esecuzione per esaminare i log e gli output.

Eseguire il debug e risolvere i problemi delle pipeline di Machine Learning

In alcuni casi, potrebbe essere necessario eseguire il debug interattivo del codice Python contenuto nella pipeline di ML. Usando VS Code e debugpy, è possibile collegarsi al codice durante l'esecuzione nell'ambiente di training.

Prerequisiti

• Un'area di lavoro di Azure Machine Learning configurata per l'uso di una rete virtuale di Azure.

• Una pipeline di Azure Machine Learning che usa script Python nei passaggi della pipeline, ad esempio PythonScriptStep.

• Un cluster di elaborazione di Azure Machine Learning, che si trova nella rete virtuale e viene usato dalla pipeline per il training.

• Un ambiente di sviluppo che si trova nella rete virtuale. L'ambiente di sviluppo può essere uno dei seguenti:

  • Una macchina virtuale di Azure nella rete virtuale
  • Un'istanza di ambiente di calcolo della macchina virtuale con notebook nella rete virtuale
  • Un computer client con connettività di rete privata alla rete virtuale, tramite VPN o ExpressRoute.

Per altre informazioni sull'uso di una rete virtuale di Azure con Azure Machine Learning, vedere la panoramica sulla privacy e l'isolamento della rete virtuale.

Funzionamento

I passaggi della pipeline ML eseguono gli script Python. Questi script sono modificati per eseguire le azioni seguenti:

1. Registrare l'indirizzo IP dell'host in cui sono in esecuzione. Per connettere il debugger al script, si usa l'indirizzo IP.

2. Avviare il componente di debug di debugpy e attendere la connessione di un debugger.

3. Dall'ambiente di sviluppo si monitorano i log creati dal processo di training per trovare l'indirizzo IP in cui è in esecuzione lo script.

4. Si usa un file launch.json per indicare a VS Code l'indirizzo IP a cui connettere il debugger.

5. Si collega il debugger e si esegue lo script in modo interattivo istruzione per istruzione.

Configurare gli script Python

Per abilitare il debug, apportare le modifiche seguenti agli script Python usati dai passaggi della pipeline ML:

1. Aggiungere le seguenti istruzioni Import:

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

2. Aggiungere gli argomenti seguenti. Questi argomenti consentono di abilitare il debugger in base alle esigenze e impostare il timeout per il collegamento del debugger:

   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. Aggiungere le istruzioni seguenti. Queste istruzioni consentono di caricare il contesto di esecuzione corrente in modo che sia possibile registrare l'indirizzo IP del nodo in cui è in esecuzione il codice:

   global run
   run = Run.get_context()
   

4. Aggiungere un'istruzione if che avvia debugpy e attende il collegamento di un debugger. Se non viene collegato alcun debugger prima del timeout, l'esecuzione dello script continua come di consueto. Assicurarsi di sostituire i valori di HOST e PORT nella funzione listen con quelli personalizzati.

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

L'esempio di Python seguente illustra un file train.py semplice che abilita il debug:

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

Configurare la pipeline ML

Per fornire i pacchetti Python necessari per avviare debugpy e ottenere il contesto di esecuzione, creare un ambiente e impostare pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Modificare la versione dell'SDK in modo che corrisponda a quella in uso. Il frammento di codice seguente illustra come creare un ambiente:

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

Nella sezione Configurare gli script Python sono stati aggiunti nuovi argomenti agli script usati dai passaggi della pipeline ML. Il frammento di codice seguente illustra come usare questi argomenti per abilitare il debug per il componente e impostare un timeout. Viene inoltre illustrato come usare l'ambiente creato in precedenza impostando 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)

Quando si esegue la pipeline, a ogni passaggio viene creata un'esecuzione figlio. Se il debug è abilitato, lo script modificato registra nel file 70_driver_log.txt informazioni simili al testo seguente per l'esecuzione figlio:

Timeout for debug connection: 300
ip_address: 10.3.0.5

Salvare il valore di ip_address. Verrà usato nella sezione successiva.

Configurare l'ambiente di sviluppo

1. Per installare debugpy nell'ambiente di sviluppo VS Code, usare il comando seguente:

   python -m pip install --upgrade debugpy
   

   Per altre informazioni sull'uso di debugpy con VS Code, vedere Debug remoto.

2. Per configurare VS Code in modo che comunichi con l'ambiente di calcolo di Azure Machine Learning che esegue il debugger, creare una nuova configurazione di debug:

   1. Da VS Code selezionare il menu Debug, quindi selezionare Apri configurazioni. Viene aperto un file denominato launch.json.

   2. Nel file launch.json individuare la riga che contiene "configurations": [ e inserire il testo seguente dopo di essa. Modificare la voce "host": "<IP-ADDRESS>" impostando l'indirizzo IP restituito nei log dalla sezione precedente. Modificare la voce "localRoot": "${workspaceFolder}/code/step" impostando una directory locale contenente una copia dello script di cui viene eseguito il debug:

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

      Importante

      Se nella sezione Configurazioni sono già presenti altre voci, aggiungere una virgola (,) dopo il codice inserito.

      Suggerimento

      La procedura consigliata, in particolare per le pipeline, consiste nel mantenere le risorse per gli script in directory separate in modo che il codice sia pertinente solo per ognuno dei passaggi. In questo esempio il valore di esempio localRoot fa riferimento a /code/step1.

      Se si esegue il debug di più script in directory diverse, creare una sezione di configurazione separata per ogni script.

   3. Salvare il file launch.json.

Connettere il debugger

1. Aprire VS Code e aprire una copia locale dello script.

2. Impostare i punti di interruzione in cui si vuole che lo script si arresti dopo il collegamento.

3. Mentre il processo figlio esegue lo script e nei log viene visualizzato Timeout for debug connection, premere il tasto F5 o selezionare Esegui debug. Quando richiesto, selezionare la configurazione Ambiente di calcolo di Azure Machine Learning:debug remoto. È anche possibile selezionare l'icona di debug dalla barra laterale, la voce Azure Machine Learning: debug remoto dal menu a discesa Debug e quindi usare la freccia verde per collegare il debugger.

   A questo punto, VS Code si connette a debugpy nel nodo di calcolo e si arresta in corrispondenza del punto di interruzione impostato in precedenza. È ora possibile scorrere il codice durante l'esecuzione, visualizzare le variabili e così via.

   Nota

   Se nel log viene visualizzata una voce Debugger attached = False, il timeout è scaduto e l'esecuzione dello script è proseguita senza il debugger. Inviare di nuovo la pipeline e connettere il debugger dopo il messaggio Timeout for debug connection e prima della scadenza del timeout.

Eseguire il debug e la risoluzione dei problemi relativi alle distribuzioni

In alcuni casi, potrebbe essere necessario eseguire il debug interattivo del codice Python contenuto nella distribuzione del modello. Ad esempio, se l'esecuzione dello script di immissione non riesce e non è possibile determinare il motivo con una registrazione aggiuntiva. Usando VS Code e debugpy, è possibile connettersi al codice in esecuzione all'interno del contenitore Docker.

Per le distribuzioni di servizi Web locali è necessaria un'installazione Docker funzionante nel sistema locale. Per altre informazioni sull'uso di Docker, vedere la Documentazione di Docker. Quando si usano istanze di ambienti di calcolo, Docker è già installato.

Configurare l'ambiente di sviluppo

1. Per installare debugpy nell'ambiente di sviluppo VS Code locale, usare il comando seguente:

   python -m pip install --upgrade debugpy
   

   Per altre informazioni sull'uso di debugpy con VS Code, vedere Debug remoto.

2. Per configurare VS Code per la comunicazione con l'immagine Docker, creare una nuova configurazione di debug:

   1. Da VS Code selezionare il menu Debug nell'estensione Esegui e quindi selezionare Apri configurazioni. Viene aperto un file denominato launch.json.

   2. Nel file launch.json individuare la voce "configurations" (la riga che contiene "configurations": [) e inserire il testo seguente dopo di essa.

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

      Dopo l'inserimento, il file launch.json dovrebbe essere simile al seguente:

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

      Importante

      Se nella sezione configurations sono già presenti altre voci, aggiungere una virgola (,) dopo il codice inserito.

      Questa sezione consente di connettersi al contenitore Docker tramite la porta 5678.

   3. Salvare il file launch.json.

Creare un'immagine che includa debugpy

1. Modificare l'ambiente Conda per la distribuzione, in modo che includa debugpy. L'esempio seguente illustra come aggiungerlo usando il parametro 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. Per avviare debugpy e attendere la connessione all'avvio del servizio, aggiungere quanto segue all'inizio del file score.py:

   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. Creare un'immagine in base alla definizione dell'ambiente ed eseguire il pull dell'immagine nel Registro di sistema locale.

   Nota

   In questo esempio si presuppone che ws punti all'area di lavoro di Azure Machine Learning e che model sia il modello distribuito. Il file myenv.yml contiene le dipendenze Conda create nel passaggio 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()
   

   Una volta che l'immagine è stata creata e scaricata (questo processo può richiedere più di 10 minuti), alla fine il percorso dell'immagine (inclusi repository, nome e tag, che in questo caso è anche il codice hash) viene visualizzato in un messaggio simile al seguente:

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

4. Per semplificare le operazioni con l'immagine in locale, è possibile usare il comando seguente per aggiungere un tag per questa immagine. Nel comando seguente sostituire myimagepath con il valore del percorso del passaggio precedente.

   docker tag myimagepath debug:1
   

   Per i passaggi rimanenti, è possibile fare riferimento all'immagine locale come debug:1 anziché al valore del percorso dell'immagine completa.

Eseguire il debug del servizio

1. Per avviare un contenitore Docker usando l'immagine, usare il comando seguente:

   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
   

   Questo comando consente di collegare il file score.py in locale a quello nel contenitore. Di conseguenza, eventuali modifiche apportate nell'editor vengono applicate automaticamente nel contenitore.

2. Per un'esperienza migliore, è possibile accedere al contenitore con una nuova interfaccia di VS Code. Selezionare l'estensione Docker dalla barra laterale di VS Code, individuare il contenitore locale creato, in questa documentazione il relativo debug:1. Fare clic con il pulsante destro del mouse su questo contenitore e selezionare "Attach Visual Studio Code". Verrà aperta automaticamente una nuova interfaccia di VS Code in cui verrà mostrato l'interno del contenitore creato.

   

3. All'interno del contenitore eseguire il comando seguente nella shell:

   runsvdir /var/runit
   

   È quindi possibile visualizzare l'output seguente nella shell all'interno del contenitore:

   

4. Per collegare VS Code a debugpy all'interno del contenitore, aprire VS Code e premere F5 oppure selezionare Esegui debug. Quando richiesto, selezionare la configurazione Distribuzione di Azure Machine Learning: debug di Docker. È anche possibile selezionare l'icona dell'estensione Esegui dalla barra laterale, la voce Distribuzione di Azure Machine Learning: debug di Docker dal menu a discesa Debug e quindi usare la freccia verde per collegare il debugger.

   

   Dopo aver selezionato la freccia verde e aver collegato il debugger, nell'interfaccia di VS Code del contenitore vengono visualizzate alcune nuove informazioni:

   

   Inoltre, nell'interfaccia principale di VS Code viene visualizzato quanto segue:

   

Il file score.py locale collegato al contenitore è già stato arrestato in corrispondenza dei punti di interruzione impostati. A questo punto, VS Code si connette a debugpy all'interno del contenitore Docker e arresta il contenitore Docker in corrispondenza del punto di interruzione impostato in precedenza. È ora possibile scorrere il codice durante l'esecuzione, visualizzare le variabili e così via.

Per altre informazioni sull'uso di VS Code per eseguire il debug di Python, vedere Eseguire il debug del codice Python.

Arrestare il contenitore

Per arrestare il contenitore, usare il comando seguente:

docker stop debug

Passaggi successivi

Dopo aver configurato l'ambiente di calcolo remoto di VS Code, è possibile usare un'istanza di ambiente di calcolo come ambiente di calcolo remoto da VS Code per eseguire il debug interattivo del codice.

Altre informazioni sulla risoluzione dei problemi:

• Distribuzione modello locale
• Distribuzione modello remota
• Pipeline di Machine Learning
• ParallelRunStep