Penelusuran kesalahan interaktif dengan Visual Studio Code

Artikel
04/04/2023

Pelajari cara menelusuri kesalahan eksperimen, alur, dan penyebaran Azure Machine Learning secara interaktif menggunakan Visual Studio Code (VS Code) dan debugpy.

Menjalankan dan menelusuri kesalahan eksperimen secara lokal

Gunakan ekstensi Azure Machine Learning untuk memvalidasi, menjalankan, dan menelusuri kesalahan eksperimen pembelajaran mesin Anda sebelum mengirimkannya ke cloud.

Prasyarat

Ekstensi Visual Studio Code Azure Machine Learning (pratinjau). Untuk informasi selengkapnya, lihat Menyiapkan ekstensi Visual Studio Code Azure Machine Learning.

Penting

Ekstensi Visual Studio Code Azure Machine Learning menggunakan CLI (v2) secara default. Instruksi dalam panduan ini menggunakan CLI 1.0. Untuk beralih ke CLI 1.0, atur pengaturan azureML.CLI Compatibility Mode di Visual Studio Code ke 1.0. Untuk informasi selengkapnya tentang mengubah setelan Anda di Visual Studio Code, lihat dokumentasi setelan pengguna dan ruang kerja.

Penting

Fitur ini sedang dalam pratinjau umum. Versi pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan yang dibatasi.

Untuk informasi lebih lanjut, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.
Docker
- Desktop Docker untuk Mac dan Windows
- Mesin Docker untuk Linux.
  
  Catatan
  
  Di Windows, pastikan untuk mengonfigurasi Docker untuk menggunakan kontainer Linux.
  
  Tip
  
  Untuk Windows, meskipun tidak diperlukan, sangat disarankan untuk menggunakan Docker dengan Subsistem Windows untuk Linux (WSL) 2.
Python 3

Menelusuri kesalahan eksperimen secara lokal

Penting

Sebelum menjalankan eksperimen Anda secara lokal, pastikan bahwa:

Docker sedang berjalan.
azureML.CLI Compatibility ModePengaturan dalam Visual Studio Code diatur ke 1.0 sebagaimana ditentukan dalam prasyarat

Pada Visual Studio Code, buka tampilan ekstensi Azure Machine Learning.
Perluas node langganan yang berisi ruang kerja Anda. Jika Anda belum memilikinya, Anda dapat membuat ruang kerja Azure Machine Learning menggunakan ekstensi tersebut.
Perluas node ruang kerja Anda.
Klik kanan node Eksperimen dan pilih Buat eksperimen. Saat perintah muncul, berikan nama untuk eksperimen Anda.
Perluas node Eksperimen, klik kanan eksperimen yang ingin Anda jalankan dan pilih Jalankan Eksperimen.
Dari daftar opsi, pilih Lokal.
Pertama kali digunakan hanya pada Windows. Ketika diminta untuk mengizinkan Berbagi File, pilih Ya. Ketika Anda mengaktifkan berbagi file, Docker dapat memasang direktori yang berisi skrip Anda ke kontainer. Selain itu, berbagi file juga memungkinkan Docker menyimpan log dan output dari eksekusi Anda dalam direktori sementara pada sistem Anda.
Pilih Ya untuk menelusuri kesalahan eksperimen Anda. Jika tidak, pilih Tidak. Memilih tidak akan menjalankan eksperimen Anda secara lokal tanpa melampirkan ke debugger.
Pilih Buat Konfigurasi Eksekusi baru untuk membuat konfigurasi eksekusi Anda. Konfigurasi eksekusi menentukan skrip yang ingin Anda jalankan, dependensi, dan himpunan data yang digunakan. Atau, jika Anda sudah memilikinya, pilih dari dropdown.
1. Memilih lingkungan Anda. Anda dapat memilih dari salah satu Azure Machine Learning yang dikurasi atau membuat sendiri.
2. Berikan nama skrip yang ingin Anda jalankan. Jalur ini terkait dengan direktori yang dibuka di Visual Studio Code.
3. Pilih apakah Anda ingin menggunakan himpunan data Azure Machine Learning atau tidak. Anda dapat membuat himpunan data Azure Machine Learning menggunakan ekstensi.
4. Debugpy diperlukan untuk melampirkan debugger ke kontainer yang menjalankan eksperimen Anda. Untuk menambahkan debugpy sebagai dependensi, pilih Tambahkan Debugpy. Jika sebaliknya, pilih Tidak. Tidak menambahkan debugpy sebagai dependensi menjalankan eksperimen Anda tanpa melampirkan ke debugger.
5. File konfigurasi yang berisi pengaturan konfigurasi eksekusi Anda dibuka di editor. Jika Anda puas dengan pengaturan, pilih Kirim eksperimen. Atau, buka palet perintah(Tampilkan Palet Perintah>) dari bilah menu dan masukkan perintah AzureML: Submit experiment ke dalam kotak teks.
Setelah eksperimen Anda dikirim, gambar Docker yang berisi skrip Anda dan konfigurasi yang ditentukan dalam konfigurasi eksekusi Anda dibuat.

Saat proses build gambar Docker dimulai, konten file 60_control_log.txt mengalirkan ke konsol output di Visual Studio Code.

Catatan

Pertama kali gambar Docker Anda dibuat dapat memerlukan waktu beberapa menit.
Setelah gambar Anda dibuat, perintah akan muncul untuk memulai debugger. Atur titik henti Anda di skrip Anda dan pilih Mulai debugger saat Anda siap memulai penelusuran kesalahan. Melakukan tindakan tersebut melampirkan debugger Visual Studio Code ke kontainer yang menjalankan eksperimen Anda. Atau, di ekstensi Azure Machine Learning, arahkan kursor ke node untuk eksekusi saat ini dan pilih ikon putar untuk memulai debugger.

Penting

Anda tidak dapat memiliki beberapa sesi debug untuk satu eksperimen. Namun, Anda dapat menelusuri kesalahan dua eksperimen atau lebih menggunakan beberapa instans Visual Studio Code.

Pada titik ini, Anda harus dapat melangkah melalui dan menelusuri kesalahan kode Anda menggunakan Visual Studio Code.

Jika suatu saat Anda ingin membatalkan eksekusi, klik kanan node eksekusi Anda dan pilih Batalkan eksekusi.

Mirip dengan eksekusi eksperimen jarak jauh, Anda dapat memperluas node eksekusi untuk memeriksa log dan output.

Tip

Gambar docker yang menggunakan dependensi yang sama yang ditentukan di lingkungan Anda digunakan kembali di antara eksekusi. Namun, jika Anda menjalankan eksperimen menggunakan lingkungan baru atau berbeda, gambar baru akan dibuat. Karena gambar ini disimpan ke penyimpanan lokal Anda, sebaiknya hapus gambar Docker lama atau yang tidak digunakan. Untuk menghapus gambar dari sistem Anda, gunakan Docker CLI atau ekstensi Docker Visual Studio Code.

Men-debug dan memecahkan masalah alur pembelajaran mesin

Dalam beberapa kasus, Anda mungkin perlu secara interaktif men-debug kode Python yang digunakan dalam alur ML Anda. Dengan menggunakan Visual Studio Code dan debugpy, Anda dapat melampirkan ke kode saat berjalan di lingkungan pelatihan.

Prasyarat

Ruang kerja Azure Machine Learning yang dikonfigurasi untuk menggunakan Azure Virtual Network.
Alur Azure Machine Learning yang menggunakan skrip Python sebagai bagian dari langkah-langkah alur. Misalnya, PythonScriptStep.
Kluster Komputasi Azure Machine Learning, yang berada di jaringan virtual dan digunakan oleh alur untuk pelatihan.
Lingkungan pengembangan yang ada di jaringan virtual. Lingkungan pengembangan mungkin salah satu dari yang berikut:
- Azure Virtual Machine di jaringan virtual
- Instans Komputasi VM Notebook di jaringan virtual
- Komputer klien yang memiliki konektivitas jaringan privat ke jaringan virtual, baik oleh VPN maupun melalui ExpressRoute.

Untuk informasi selengkapnya tentang menggunakan Azure Virtual Network dengan Azure Machine Learning, lihat Gambaran umum isolasi dan privasi jaringan virtual.

Tip

Meskipun Anda dapat bekerja dengan sumber daya Azure Machine Learning yang tidak berada di belakang jaringan virtual, sebaiknya gunakan jaringan virtual.

Cara kerjanya

Langkah-langkah alur ML Anda menjalankan skrip Python. Skrip ini dimodifikasi untuk melakukan tindakan berikut:

Catat alamat IP host yang sedang dijalankan. Anda menggunakan alamat IP untuk menyambungkan debugger ke skrip.
Mulai komponen debug debugpy, dan tunggu hingga debugger tersambung.
Dari lingkungan pengembangan Anda, Anda memantau log yang dibuat oleh proses pelatihan untuk menemukan alamat IP tempat skrip berjalan.
Anda memberi tahu Visual Studio Code alamat IP untuk menyambungkan debugger menggunakan file launch.json.
Anda melampirkan debugger dan secara interaktif melangkah melalui skrip.

Mengonfigurasi skrip Python

Untuk mengaktifkan penelusuran kesalahan, buat perubahan berikut pada skrip Python yang digunakan oleh langkah-langkah di alur ML Anda:

Tambahkan pernyataan import berikut:

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

Tambahkan argumen berikut. Argumen ini memungkinkan Anda mengaktifkan debugger sesuai kebutuhan, dan mengatur waktu habis untuk melampirkan 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')

Tambahkan pernyataan berikut. Pernyataan ini memuat konteks eksekusi saat ini agar Anda dapat mencatat alamat IP node yang dijalankan kode:
```
global run
run = Run.get_context()
```

Tambahkan pernyataan if yang memulai debugpy dan tunggu hingga debugger terpasang. Jika tidak ada debugger yang terpasang sebelum waktu habis, skrip berlanjut seperti biasa. Pastikan untuk mengganti HOST dan nilai PORT adalah fungsi listen dengan milik Anda sendiri.

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

Contoh Python berikut memperlihatkan file train.py sederhana yang memungkinkan penelusuran kesalahan:

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

Mengonfigurasi alur ML

Untuk menyediakan paket Python yang diperlukan untuk memulai debugpy dan mendapatkan konteks eksekusi, buat lingkungan dan atur pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Ubah versi SDK agar sesuai dengan versi yang Anda gunakan. Cuplikan kode berikut menunjukkan cara membuat lingkungan:

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

Di bagian Konfigurasi skrip Python, argumen baru ditambahkan ke skrip yang digunakan oleh langkah-langkah alur ML Anda. Cuplikan kode berikut menunjukkan cara menggunakan argumen ini untuk mengaktifkan penelusuran kesalahan untuk komponen dan mengatur waktu habis. Kode tersebut juga menunjukkan cara menggunakan lingkungan yang dibuat sebelumnya dengan mengatur 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)

Saat alur berjalan, setiap langkah membuat eksekusi anak. Jika penelusuran kesalahan diaktifkan, informasi log skrip yang dimodifikasi mirip dengan teks berikut dalam 70_driver_log.txt untuk eksekusi anak:

Timeout for debug connection: 300
ip_address: 10.3.0.5

Simpan nilai ip_address. Informasi ini digunakan di bagian berikutnya.

Tip

Anda juga dapat menemukan alamat IP dari log eksekusi untuk eksekusi anak untuk langkah alur ini. Untuk informasi selengkapnya tentang melihat informasi ini, lihat Memantau eksekusi dan metrik eksperimen Azure Machine Learning.

Konfigurasikan lingkungan pengembangan

Untuk menginstal debugpy di lingkungan pengembangan Visual Studio Code Anda, gunakan perintah berikut:
```
python -m pip install --upgrade debugpy
```
Untuk informasi selengkapnya tentang menggunakan debugpy dengan Visual Studio Code, lihat Penelusuran Kesalahan Jarak Jauh.
Untuk mengonfigurasi Visual Studio Code agar berkomunikasi dengan komputasi Azure Machine Learning yang menjalankan debugger, buat konfigurasi debug baru:
1. Dari Visual Studio Code, pilih menu Debug, lalu pilih Buka konfigurasi. File bernama launch.json terbuka.
2. Di file launch.json, temukan baris yang berisi "configurations": [, dan sisipkan teks berikut setelahnya. Ubah entri "host": "<IP-ADDRESS>" ke alamat IP yang dikembalikan di log Anda dari bagian sebelumnya. Ubah entri "localRoot": "${workspaceFolder}/code/step" ke direktori lokal yang memuat salinan skrip yang sedang ditelusuri kesalahannya:
```
{
    "name": "Azure Machine Learning Compute: remote debug",
    "type": "python",
    "request": "attach",
    "port": 5678,
    "host": "<IP-ADDRESS>",
    "redirectOutput": true,
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}/code/step1",
            "remoteRoot": "."
        }
    ]
}
```
  Penting
  
  Jika sudah ada entri lain di bagian konfigurasi, tambahkan koma (,) setelah kode yang Anda sisipkan.
  
  Tip
  
  Praktik terbaik, terutama untuk alur adalah menyimpan sumber daya untuk skrip di direktori terpisah sehingga kode hanya relevan untuk setiap langkah. Dalam contoh ini, nilai contoh localRoot mereferensi /code/step1.
  
  Jika Anda menelusuri kesalahan beberapa skrip, di direktori yang berbeda, buat bagian konfigurasi terpisah untuk setiap skrip.
3. Simpan file launch.json.

Menyambungkan debugger

Buka Visual Studio Code dan buka salinan skrip lokal.
Atur titik henti tempat Anda ingin skrip berhenti setelah Anda melampirkan.
Saat proses anak menjalankan skrip, dan Timeout for debug connection ditampilkan dalam log, gunakan tombol F5 atau pilih Debug. Saat diminta, pilih konfigurasi Komputasi Azure Machine Learning: debug jarak jauh. Anda juga dapat memilih ikon debug dari bilah samping, entri Azure Machine Learning: debug jarak jauh dari menu dropdown Debug, lalu gunakan panah hijau untuk melampirkan debugger.

Pada titik ini, Visual Studio Code terhubung ke debugpy pada node komputasi dan berhenti di titik henti yang Anda tetapkan sebelumnya. Anda sekarang dapat melangkah melalui kode saat berjalan, melihat variabel, dll.

Catatan

Jika log menampilkan entri yang menyatakan Debugger attached = False, waktu habis sudah berakhir dan skrip berlanjut tanpa debugger. Kirim alur lagi dan sambungkan debugger setelah pesan Timeout for debug connection, dan sebelum waktu habis berakhir.

Menelusuri kesalahan dan memecahkan masalah penyebaran

Dalam beberapa kasus, Anda mungkin perlu menelusuri kesalahan kode Python yang terdapat dalam penyebaran model secara interaktif. Misalnya, jika skrip entri gagal dan alasannya tidak dapat diketahui dengan pencatatan tambahan. Dengan menggunakan Visual Studio Code dan debugpy, Anda dapat melampirkan ke kode yang sedang berjalan di dalam kontainer Docker.

Tip

Jika Anda menggunakan titik akhir dan penyebaran online terkelola secara lokal, lihat Debug titik akhir online terkelola secara lokal di Visual Studio Code (pratinjau).

Penting

Metode penelusuran kesalahan ini tidak berfungsi saat menggunakan Model.deploy() dan LocalWebservice.deploy_configuration untuk menyebarkan model secara lokal. Sebagai gantinya, Anda harus membuat gambar menggunakan metode Model.package().

Penyebaran layanan web lokal memerlukan penginstalan Docker yang berfungsi pada sistem lokal Anda. Untuk informasi selengkapnya tentang menggunakan Docker, lihat Dokumentasi Docker. Saat bekerja dengan instans komputasi, Docker sudah diinstal.

Konfigurasikan lingkungan pengembangan

Untuk menginstal debugpy di lingkungan pengembangan Visual Studio Code lokal Anda, gunakan perintah berikut:
```
python -m pip install --upgrade debugpy
```
Untuk informasi selengkapnya tentang menggunakan debugpy dengan Visual Studio Code, lihat Penelusuran Kesalahan Jarak Jauh.

Untuk mengonfigurasi Visual Studio Code agar berkomunikasi dengan gambar Docker, buat konfigurasi debug baru:

Dari Visual Studio Code, pilih menu Debug di ekstensi Eksekusi, lalu pilih Buka konfigurasi. File bernama launch.json terbuka.

Di file launch.json, temukan item "configurations" (baris yang berisi "configurations": [), dan sisipkan teks berikut setelahnya.

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

Setelah disisipkan,file launch.json harus mirip dengan yang berikut ini:

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

Penting

Jika sudah ada entri lain di bagian konfigurasi, tambahkan koma (,) ( , ) setelah kode yang Anda sisipkan.

Bagian ini melampirkan ke kontainer Docker menggunakan port 5678.

Simpan file launch.json.

Membuat gambar yang menyertakan debugpy

Ubah lingkungan conda untuk penyebaran Anda sehingga menyertakan debugpy. Contoh berikut menunjukkan penambahan menggunakan parameter 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())

Untuk memulai debugpy dan menunggu koneksi saat layanan dimulai, tambahkan berikut ini ke bagian atas file score.py Anda:

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

Buat gambar berdasarkan definisi lingkungan dan tarik gambar ke registri lokal.

Catatan

Contoh ini mengasumsikan ws menunjuk ke ruang kerja Azure Machine Learning Anda, dan model adalah model yang sedang disebarkan. File myenv.yml berisi dependensi conda yang dibuat di langkah 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()

Setelah gambar dibuat dan diunduh (proses ini mungkin memakan waktu lebih dari 10 menit, jadi), jalur gambar (termasuk repositori, nama, dan tag, yang dalam hal ini juga digest-nya) akhirnya ditampilkan dalam pesan yang mirip dengan yang berikut:

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

Untuk mempermudah bekerja dengan gambar secara lokal, Anda dapat menggunakan perintah berikut untuk menambahkan tag untuk gambar ini. Ganti myimagepath dalam perintah berikut dengan nilai lokasi dari langkah sebelumnya.
```
docker tag myimagepath debug:1
```
Untuk langkah-langkah lainnya, Anda dapat merujuk ke gambar lokal sebagai debug:1, bukan nilai jalur gambar penuh.

Menelusuri kesalahan layanan

Tip

Jika Anda mengatur waktu habis untuk koneksi debugpy dalam file score.py, Anda harus menyambungkan Visual Studio Code ke sesi debug sebelum waktu habis berakhir. Mulai Visual Studio Code, buka salinan lokal score.py, atur titik henti, dan siapkan sebelum menggunakan langkah-langkah di bagian ini.

Untuk informasi selengkapnya tentang penelusuran kesalahan dan pengaturan titik henti, lihat Penelusuran kesalahan.

Untuk memulai kontainer Docker menggunakan gambar, gunakan perintah berikut:
```
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
```
Perintah ini melampirkan score.py Anda secara lokal ke yang ada di kontainer. Oleh karena itu, perubahan apa pun yang dilakukan pada editor secara otomatis tercermin dalam kontainer
Untuk pengalaman yang lebih baik, Anda dapat masuk ke kontainer dengan antarmuka Visual Studio Code baru. Pilih ekstensi Docker dari bilah sisi Visual Studio Code, temukan kontainer lokal Anda yang dibuat, dalam dokumentasi ini, kontainer tersebut adalah debug:1. Klik kanan kontainer ini dan pilih "Attach Visual Studio Code", antarmuka Visual Studio Code baru selanjutnya akan terbuka secara otomatis, dan antarmuka ini memperlihatkan bagian dalam kontainer yang Anda buat.
Di dalam kontainer, jalankan perintah berikut di shell
```
runsvdir /var/runit
```
Selanjutnya Anda dapat melihat output berikut di shell di dalam kontainer Anda:
Untuk melampirkan Visual Studio Code ke debugpy di dalam kontainer, buka Visual Studio Code dan gunakan tombol F5 atau pilih Debug. Saat diminta, pilih konfigurasi Penyebaran Azure Machine Learning: Docker Debug. Anda juga dapat memilih ikon ekstensi Eksekusi dari bilah sisi, entri Penyebaran Azure Machine Learning: Docker Debug dari menu dropdown Debug, lalu menggunakan panah hijau untuk melampirkan debugger.

Setelah Anda memilih panah hijau dan melampirkan debugger, Anda dapat melihat beberapa informasi baru di antarmuka kontainer Visual Studio Code:

Selain itu, di antarmuka Visual Studio Code utama Anda, Anda dapat melihat hal berikut:

Dan sekarang, score.py lokal yang dilampirkan di kontainer sudah berhenti di titik henti yang Anda atur. Pada titik ini, Visual Studio Code terhubung ke debugpy di dalam kontainer Docker dan menghentikan kontainer Docker di titik henti yang Anda atur sebelumnya. Anda sekarang dapat melangkah melalui kode saat berjalan, melihat variabel, dll.

Untuk informasi selengkapnya tentang menggunakan Visual Studio Code untuk menelusuri kesalahan Python, lihat Menelusuri kesalahan kode Python Anda.

Menghentikan kontainer

Untuk menghentikan kontainer, gunakan perintah berikut:

docker stop debug

Langkah berikutnya

Setelah menyiapkan Visual Studio Code Remote, Anda dapat menggunakan instans komputasi sebagai komputasi jarak jauh dari Visual Studio Code untuk menelusuri kesalahan kode Anda secara interaktif.

Pelajari selengkapnya tentang pemecahan masalah:

Penelusuran kesalahan interaktif dengan Visual Studio Code

Menjalankan dan menelusuri kesalahan eksperimen secara lokal

Prasyarat

Menelusuri kesalahan eksperimen secara lokal

Men-debug dan memecahkan masalah alur pembelajaran mesin

Prasyarat

Cara kerjanya

Mengonfigurasi skrip Python

Mengonfigurasi alur ML

Konfigurasikan lingkungan pengembangan

Menyambungkan debugger

Menelusuri kesalahan dan memecahkan masalah penyebaran

Konfigurasikan lingkungan pengembangan

Membuat gambar yang menyertakan debugpy

Menelusuri kesalahan layanan

Menghentikan kontainer

Langkah berikutnya

Sumber Daya Tambahan: