Memecahkan Masalah ParallelRunStep

Dalam artikel ini, Anda mempelajari cara memecahkan masalah saat menghadapi kesalahan menggunakan kelas \ParallelRunStep dari SDK Azure Machine Learning.

Untuk tips umum dalam memecahkan masalah alur, lihat Memecahkan masalah alur pembelajaran mesin.

Menguji skrip secara lokal

ParallelRunStep Anda berjalan sebagai langkah dalam alur ML. Anda mungkin ingin menguji skrip secara lokalsebagai langkah pertama.

Persyaratan skrip

Skrip untuk ParallelRunStep harus berisi dua fungsi:

  • init(): Gunakan fungsi ini untuk persiapan yang mahal atau umum untuk proses nanti. Misalnya, gunakan untuk memuat model ke objek global. Fungsi ini akan dipanggil hanya sekali di awal proses.

    Catatan

    Jika metode init Anda membuat direktori output, tentukan bahwa exist_ok=True. Metode init ini dipanggil dari setiap proses pekerja pada setiap node tempat pekerjaan berjalan.

  • run(mini_batch): Fungsi ini akan berjalan untuk setiap mini_batch instans.
    • mini_batch:ParallelRunStep akan memanggil metode eksekusi alur dan lulus daftar atau pandas DataFrame sebagai argumen ke metode tersebut. Setiap entri mini_batch akan menjadi jalur file jika input adalah FileDataset atau pandas DataFrame jika input adalah TabularDataset.
    • response: metode eksekusi alur() harus mengembalikan pandas DataFrame atau array. Misalnya append_row output_action elemen yang dikembalikan ini ditambahkan ke dalam file output umum. Misalnya summary_only, isi elemen diabaikan. Untuk semua tindakan output, setiap elemen output yang dikembalikan menunjukkan satu keberhasilan menjalankan elemen input dalam mini-batch input. Pastikan bahwa data yang cukup disertakan dalam hasil eksekusi alur untuk memetakan input untuk menjalankan hasil output. Eksekusi alur output akan ditulis dalam file output dan tidak dijamin berdasarkan urutan, Anda harus menggunakan beberapa kunci dalam output untuk memetakannya ke input.

      Catatan

      Satu elemen output diharapkan untuk satu elemen input.

%%writefile digit_identification.py
# Snippets from a sample script.
# Refer to the accompanying digit_identification.py
# (https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/machine-learning-pipelines/parallel-run)
# for the implementation script.

import os
import numpy as np
import tensorflow as tf
from PIL import Image
from azureml.core import Model


def init():
    global g_tf_sess

    # Pull down the model from the workspace
    model_path = Model.get_model_path("mnist")

    # Construct a graph to execute
    tf.reset_default_graph()
    saver = tf.train.import_meta_graph(os.path.join(model_path, 'mnist-tf.model.meta'))
    g_tf_sess = tf.Session()
    saver.restore(g_tf_sess, os.path.join(model_path, 'mnist-tf.model'))


def run(mini_batch):
    print(f'run method start: {__file__}, run({mini_batch})')
    resultList = []
    in_tensor = g_tf_sess.graph.get_tensor_by_name("network/X:0")
    output = g_tf_sess.graph.get_tensor_by_name("network/output/MatMul:0")

    for image in mini_batch:
        # Prepare each image
        data = Image.open(image)
        np_im = np.array(data).reshape((1, 784))
        # Perform inference
        inference_result = output.eval(feed_dict={in_tensor: np_im}, session=g_tf_sess)
        # Find the best probability, and add it to the result list
        best_result = np.argmax(inference_result)
        resultList.append("{}: {}".format(os.path.basename(image), best_result))

    return resultList

Jika Anda memiliki file atau folder lain dalam direktori yang sama dengan skrip inferensi, Anda bisa mereferensikannya dengan menemukan direktori kerja saat ini.

script_dir = os.path.realpath(os.path.join(__file__, '..',))
file_path = os.path.join(script_dir, "<file_name>")

Parameter untuk ParallelRunConfig

ParallelRunConfig adalah konfigurasi utama untuk instans ParallelRunStep dalam alur Azure Machine Learning. Anda menggunakannya untuk membungkus skrip Anda dan mengonfigurasi parameter yang diperlukan, termasuk semua entri berikut:

  • entry_script: Skrip pengguna sebagai jalur file lokal yang akan dijalankan secara paralel pada beberapa node. Jika source_directory ada, gunakan jalur relatif. Jika tidak, gunakan jalur apa pun yang dapat diakses di komputer.

  • mini_batch_size: Ukuran batch mini diteruskan ke satu panggilan run(). (opsional; nilai default adalah 10 file untukFileDataset dan 1MB untuk TabularDataset.)

    • Untuk FileDataset, ini adalah jumlah file dengan nilai minimum 1. Anda dapat menggabungkan beberapa file ke dalam satu batch mini.
    • Untuk TabularDataset, ini adalah ukuran data. Contoh nilai adalah 1024, 1024KB, 10MB, dan 1GB. Nilai yang disarankan adalah 1MB. Mini-batch dari TabularDataset tidak akan pernah melewati batas file. Misalnya, jika Anda memiliki file .csv dengan berbagai ukuran, file terkecil adalah 100 KB dan yang terbesar adalah 10 MB. Jika Anda mengatur mini_batch_size = 1MB, maka file dengan ukuran lebih kecil dari 1 MB akan diperlakukan sebagai satu batch mini. File dengan ukuran lebih besar dari 1 MB akan dibagi menjadi beberapa batch mini.

      Catatan

      TabularDataset yang didukung oleh SQL tidak bisa dipartisi. TabularDataset dari satu file parket dan grup baris tunggal tidak dapat dipartisi.

  • error_threshold: Jumlah kegagalan rekaman untuk TabularDataset dan kegagalan file untuk FileDataset yang harus diabaikan sebuah pemrosesan. Jika jumlah kesalahan untuk seluruh input berada di atas nilai ini, pekerjaan akan dibatalkan. Ambang kesalahan adalah untuk seluruh input dan bukan untuk batch mini individual yang dikirim ke metode run(). Kisarannya adalah [-1, int.max]. Bagian -1 tersebut mengindikasikan mengabaikan semua kegagalan selama pemrosesan.

  • output_action: Salah satu nilai berikut menunjukkan bagaimana output akan diatur:

    • summary_only: Skrip pengguna akan menyimpan output. ParallelRunStep akan menggunakan output hanya untuk perhitungan ambang batas kesalahan.
    • append_row: Untuk semua input, hanya satu file yang akan dibuat di folder output untuk menambahkan semua output yang dipisahkan oleh stripe.
  • append_row_file_name: Untuk menyesuaikan nama file output untuk append_row output_action (opsional; nilai default adalah parallel_run_step.txt).

  • source_directory: Jalur ke folder yang berisi semua file untuk dieksekusi pada target komputasi (opsional).

  • compute_target: Hanya AmlCompute yang didukung.

  • node_count: Jumlah node komputasi yang akan digunakan untuk menjalankan skrip pengguna.

  • process_count_per_node: Jumlah proses pekerja per node untuk menjalankan skrip entri secara paralel. Untuk komputer GPU, nilai defaultnya adalah 1. Untuk komputer CPU, nilai default adalah jumlah core per node. Proses pekerja akan memanggil run() berulang kali dengan melewati batch mini yang didapatnya. Jumlah total proses pekerja dalam pekerjaan Anda adalah process_count_per_node * node_count, yang memutuskan jumlah maksimum run() untuk dieksekusi secara paralel.

  • environment: Definisi lingkungan Python. Anda bisa mengonfigurasinya untuk menggunakan lingkungan Python yang ada atau untuk mengatur lingkungan sementara. Definisi ini juga bertanggung jawab untuk mengatur dependensi aplikasi yang diperlukan (opsional).

  • logging_level: Log verbositas. Nilai dalam meningkatkan verbositas adalah: WARNING, INFO, dan DEBUG. (opsional; nilai defaultnya adalah INFO)

  • run_invocation_timeout: Waktu pemanggilan metode run() habis dalam beberapa detik. (opsional; nilai default adalah 60)

  • run_max_try: Jumlah percobaan maksimum run()untuk batch mini. run() gagal jika pengecualian ditetapkan, atau tidak ada yang dikembalikan ketika run_invocation_timeout tercapai (opsional; nilai default adalah 3).

Anda dapat menentukan mini_batch_size, node_count, process_count_per_node, logging_level, run_invocation_timeout, dan run_max_try sebagai PipelineParameter, sehingga ketika Anda mengirim ulang eksekusi alur, Anda dapat menyempurnakan nilai parameter. Dalam contoh ini, Anda menggunakan PipelineParameteruntuk mini_batch_size dan Process_count_per_node Anda akan mengubah nilai-nilai ini saat mengirim ulang eksekusi alur nanti.

Visibilitas perangkat CUDA

Untuk target komputasi yang dilengkapi dengan GPU, variabel lingkungan CUDA_VISIBLE_DEVICES akan ditetapkan dalam proses pekerja. Di AmlCompute, Anda bisa menemukan jumlah total perangkat GPU dalam lingkungan variabel AZ_BATCHAI_GPU_COUNT_FOUND, yang diatur secara otomatis. Jika Anda ingin setiap proses pekerja untuk memiliki GPU khusus, atur process_count_per_node setara dengan perangkat GPU pada komputer. Setiap proses pekerja akan menetapkan indeks unik untuk CUDA_VISIBLE_DEVICES. Jika proses pekerja berhenti karena alasan apa pun, proses pekerja yang dimulai berikutnya akan menggunakan indeks GPU yang dirilis.

Jika jumlah total perangkat GPU kurang dari process_count_per_node, proses pekerja akan ditetapkan indeks GPU sampai semua telah digunakan.

Total perangkat GPU yang diberikan adalah 2 dan process_count_per_node = 4 misalnya, proses 0 dan proses 1 akan memiliki indeks 0 dan 1. Proses 2 dan 3 tidak akan memiliki variabel lingkungan. Untuk pustaka yang menggunakan variabel lingkungan ini untuk penetapan GPU, proses 2 dan 3 tidak akan memiliki GPU dan tidak akan mencoba memperoleh perangkat GPU. Jika proses 0 berhenti, indeks GPU 0 akan dirilis. Proses berikutnya, yaitu proses 4, akan memiliki indeks GPU 0 yang ditetapkan.

Untuk informasi selengkapnya, lihat Tips pro CUDA: Kontrol Visibilitas GPU dengan CUDA_VISIBLE_DEVICES.

Parameter untuk membuat ParallelRunStep

Buat ParallelRunStep menggunakan skrip, konfigurasi lingkungan, dan parameter. Tentukan target komputasi yang sudah Anda lampirkan ke ruang kerja sebagai target eksekusi untuk skrip inferensi Anda. Gunakan ParallelRunStep untuk membuat langkah batch inferensi alur, yang mengambil semua parameter berikut:

  • name: Nama langkah, dengan batas penamaan berikut, 3-32 karakter, dan regex ^[a-z]([-a-z0-9]*[a-z0-9])?$.
  • parallel_run_config: Objek ParallelRunConfig, seperti yang didefinisikan sebelumnya.
  • inputs: Satu atau beberapa himpunan data Azure Machine Learning yang diketik tunggal yang akan dipartisi untuk pemrosesan paralel.
  • side_inputs: Satu atau lebih data referensi atau himpunan data yang digunakan sebagai input sampingan tanpa perlu dipartisi.
  • output: Objek OutputFileDatasetConfig yang mewakili jalur direktori tempat data output kan disimpan.
  • arguments: Daftar argumen yang diteruskan ke skrip pengguna. Gunakan unknown_args untuk mengambilnya dalam skrip entri Anda (opsional).
  • allow_reuse: Apakah langkah harus menggunakan kembali hasil sebelumnya ketika dijalankan dengan pengaturan/input yang sama. Jika parameter ini False, eksekusi alur baru akan selalu dibuat untuk langkah ini selama eksekusi alur. (opsional; nilai default adalah True.)
from azureml.pipeline.steps import ParallelRunStep

parallelrun_step = ParallelRunStep(
    name="predict-digits-mnist",
    parallel_run_config=parallel_run_config,
    inputs=[input_mnist_ds_consumption],
    output=output_dir,
    allow_reuse=True
)

Men-debug skrip dari konteks jarak jauh

Transisi dari proses debug skrip penilaian secara lokal ke proses debug skrip penilaian dalam alur aktual bisa menjadi lompatan yang sulit. Untuk informasi tentang menemukan log Anda di portal, lihat bagian alur pembelajaran mesin pada skrip proses debug dari konteks jarak jauh. Informasi di bagian itu juga berlaku untuk ParallelRunStep.

Misalnya, file log 70_driver_log.txt berisi informasi dari pengontrol yang meluncurkan kode ParallelRunStep.

Karena sifat pekerjaan ParallelRunStep yang didistribusikan, ada log dari beberapa sumber yang berbeda. Namun, dua file konsolidasi dibuat yang memberikan informasi tingkat tinggi:

  • ~/logs/job_progress_overview.txt: File ini memberikan info tingkat tinggi tentang jumlah batch mini (juga dikenal sebagai tugas) yang dibuat sejauh ini dan jumlah batch mini yang diproses sejauh ini. Pada akhirnya, itu menunjukkan hasil pekerjaan. Jika pekerjaan gagal, maka akan pesan kesalahan dan di mana memulai pemecahan masalah.

  • ~/logs/sys/master_role.txt: File ini menyediakan tampilan node utama (juga dikenal sebagai orkestrator) pekerjaan yang berjalan. Termasuk pembuatan tugas, pemantauan progres, hasil eksekusi.

Log yang dihasilkan dari skrip entri menggunakan pembantu EntryScript dan pernyataan cetak akan ditemukan dalam file berikut:

  • ~/logs/user/entry_script_log/<node_id>/<process_name>.log.txt: File-file ini adalah log yang ditulis entry_script menggunakan pembantu EntryScript.

  • ~/logs/user/stdout/<node_id>/<process_name>.stdout.txt: File-file ini adalah log dari stdout (misalnya, pernyataan cetak) dari entry_script.

  • ~/logs/user/stderr/<node_id>/<process_name>.stderr.txt: File-file ini adalah log dari stderr entry_script.

Untuk pemahaman singkat tentang kesalahan dalam skrip Anda, ada:

  • ~/logs/user/error.txt: File ini akan mencoba meringkas kesalahan dalam skrip Anda.

Untuk informasi selengkapnya tentang kesalahan dalam skrip Anda, ada:

  • ~/logs/user/error/: Berisi jejak tumpukan penuh pengecualian yang ditetapkan saat memuat dan menjalankan skrip entri.

Ketika Anda membutuhkan pemahaman penuh tentang bagaimana setiap node mengeksekusi skrip skor, lihat log proses individual untuk setiap node. Log proses dapat ditemukan di foldersys/node, dikelompokkan menurut node pekerja:

  • ~/logs/sys/node/<node_id>/<process_name>.txt: File ini memberikan info terperinci tentang setiap batch mini saat diambil atau diselesaikan oleh pekerja. Untuk setiap batch mini, file ini mencakup:

    • Alamat IP dan PID proses pekerja.
    • Jumlah total item, jumlah item yang berhasil diproses, dan jumlah item yang gagal.
    • Waktu mulai, durasi, waktu proses, dan waktu metode eksekusi.

Anda juga bisa melihat hasil pemeriksaan berkala dari penggunaan sumber daya untuk setiap node. Berkas log dan berkas penyiapan ada di dalam folder ini:

  • ~/logs/perf: Atur --resource_monitor_interval untuk mengubah interval pemeriksaan dalam detik. Interval default adalah 600, yaitu sekitar 10 menit. Untuk menghentikan pemantauan, atur nilai ke 0. Setiap folder <node_id> meliputi:

    • os/: Informasi tentang semua proses yang berjalan dalam node. Satu pemeriksaan menjalankan perintah sistem operasi dan menyimpan hasilnya ke dalam file. Di Linux, perintahnya adalah ps. Di Windows, gunakan tasklist.
      • %Y%m%d%H: Nama sub folder adalah waktu ke jam.
        • processes_%M: File diakhiri dengan menit waktu pemeriksaan.
    • node_disk_usage.csv: Penggunaan disk terperinci node.
    • node_resource_usage.csv: Gambaran umum penggunaan sumber daya node.
    • processes_resource_usage.csv: Gambaran umum penggunaan sumber dari setiap proses.

Bagaimana cara mencatat dari skrip pengguna saya dari konteks jarak jauh?

ParallelRunStep dapat menjalankan beberapa proses pada satu node berdasarkan process_count_per_node. Untuk mengatur log dari setiap proses pada node dan menggabungkan pernyataan cetak dan log, kami sarankan menggunakan pencatat ParallelRunStep seperti yang ditunjukkan di bawah ini. Anda mendapatkan pencatat dari EntryScript dan membuat log yang muncul di folder log/pengguna di dalam portal.

Sampel skrip entri yang menggunakan pencatat:

from azureml_user.parallel_run import EntryScript

def init():
    """Init once in a worker process."""
    entry_script = EntryScript()
    logger = entry_script.logger
    logger.debug("This will show up in files under logs/user on the Azure portal.")


def run(mini_batch):
    """Call once for a mini batch. Accept and return the list back."""
    # This class is in singleton pattern and will return same instance as the one in init()
    entry_script = EntryScript()
    logger = entry_script.logger
    logger.debug(f"{__file__}: {mini_batch}.")
    ...

    return mini_batch

Di mana pesan dari Python logging masuk?

ParallelRunStep menentukan pengatur pada pencatat akar, yang masuk pesan ke logs/user/stdout/<node_id>/processNNN.stdout.txt.

logging default ke tingkat WARNING. Secara default, tingkat WARNING di bawah ini tidak akan muncul, seperti INFO atau DEBUG.

Di mana pesan dari subproses dibuat dengan Popen()?

Jika tidak ada stdout ataustderr yang ditentukan, subproses akan mewarisi pengaturan proses pekerja.

stdout akan menulis ke logs/sys/node/<node_id>/processNNN.stdout.txt dan stderr ke logs/sys/node/<node_id>/processNNN.stderr.txt.

Bagaimana saya bisa menulis ke file agar muncul di portal?

File logs dalam folder akan diunggah dan muncul di portal. Anda bisa mendapatkan folder seperti logs/user/entry_script_log/<node_id> di bawah ini dan menyusun jalur file Anda untuk menulis:

from pathlib import Path
def init():
    """Init once in a worker process."""
    entry_script = EntryScript()
    folder = entry_script.log_dir

    fil_path = Path(folder) / "<file_name>"

Bagaimana cara menulis file ke direktori output, lalu melihatnya di portal?

Anda bisa mendapatkan direktori output dari kelas EntryScript dan menulisnya. Untuk melihat file tertulis, dalam langkah Tampilan eksekusi di portal Azure Machine Learning, pilih tab Output + log. Pilih tautan Output data, lalu selesaikan langkah-langkah yang dijelaskan dalam dialog.

Gunakan EntryScript dalam skrip entri Anda seperti dalam contoh ini:

from pathlib import Path
from azureml_user.parallel_run import EntryScript

def run(mini_batch):
    output_dir = Path(entry_script.output_dir)
    (Path(output_dir) / res1).write...
    (Path(output_dir) / res2).write...

Bagaimana cara meneruskan input sampingan seperti, file atau file yang berisi tabel pencarian, ke semua pekerja saya?

Pengguna bisa meneruskan data referensi ke skrip parameter side_inputs dari ParalleRunStep. Semua himpunan data yang disediakan side_inputs akan dipasang pada setiap node pekerja. Pengguna bisa mendapatkan lokasi pemasangan dengan melewati argumen.

Buat Kumpulan data yang berisi data referensi, tentukan jalur pemasangan lokal dan daftarkan dengan ruang kerja Anda. Berikan ke parameter side_inputs dari ParallelRunStep milik Anda. Selain itu, Anda bisa menambahkan jalurnya di bagian arguments untuk dengan mudah mengakses jalur yang dipasang.

Catatan

Gunakan FileDataset hanya untuk side_inputs.

local_path = "/tmp/{}".format(str(uuid.uuid4()))
label_config = label_ds.as_named_input("labels_input").as_mount(local_path)
batch_score_step = ParallelRunStep(
    name=parallel_step_name,
    inputs=[input_images.as_named_input("input_images")],
    output=output_dir,
    arguments=["--labels_dir", label_config],
    side_inputs=[label_config],
    parallel_run_config=parallel_run_config,
)

Setelah itu Anda bisa mengaksesnya di skrip inferensi Anda (misalnya, dalam metode init() Anda) sebagai berikut:

parser = argparse.ArgumentParser()
parser.add_argument('--labels_dir', dest="labels_dir", required=True)
args, _ = parser.parse_known_args()

labels_path = args.labels_dir

Bagaimana cara menggunakan himpunan data input dengan autentikasi perwakilan layanan?

Pengguna bisa meneruskan input himpunan data dengan autentikasi perwakilan layanan yang digunakan di ruang kerja. Menggunakan himpunan data tersebut di ParallelRunStep mengharuskan himpunan data didaftarkan untuk membuat konfigurasi ParallelRunStep.

service_principal = ServicePrincipalAuthentication(
    tenant_id="***",
    service_principal_id="***",
    service_principal_password="***")
 
ws = Workspace(
    subscription_id="***",
    resource_group="***",
    workspace_name="***",
    auth=service_principal
    )
 
default_blob_store = ws.get_default_datastore() # or Datastore(ws, '***datastore-name***') 
ds = Dataset.File.from_files(default_blob_store, '**path***')
registered_ds = ds.register(ws, '***dataset-name***', create_new_version=True)

Cara Memeriksa Progres dan Menganalisisnya

Bagian ini adalah tentang cara memeriksa progres pekerjaan ParallelRunStep dan memeriksa penyebab perilaku tak terduga.

Bagaimana cara memeriksa progres pekerjaan?

Selain melihat status keseluruhan StepRun, hitungan batch mini terjadwal/diproses dan progres pembuatan output dapat dilihat di ~/logs/job_progress_overview.<timestamp>.txt. File berputar setiap hari, Anda dapat memeriksa yang memiliki tanda waktu terbesar untuk informasi terbaru.

Apa yang harus diperiksa jika tidak ada progres untuk sementara waktu?

Anda bisa pergi ke ~/logs/sys/errror untuk melihat apakah ada pengecualian. Jika tidak ada, mungkin skrip entri Anda memakan waktu lama, Anda bisa mencetak informasi progres dalam kode Anda untuk menemukan bagian yang memakan waktu, atau tambahkan "--profiling_module", "cProfile" ke arguments dari ParallelRunStep untuk membuat nama file profil sebagai <process_name>.profile di folder ~/logs/sys/node/<node_id>.

Kapan pekerjaan akan berhenti?

jika tidak dibatalkan, pekerjaan akan berhenti dengan status:

  • Selesai. Jika semua batch mini telah diproses dan output telah dihasilkan untuk mode append_row.
  • Gagal. Jika error_threshold di dalam Parameters for ParallelRunConfig terlampaui, atau terjadi kesalahan sistem selama pekerjaan.

Di mana menemukan akar penyebab kegagalan?

Anda bisa mengikuti petunjuk di ~logs/job_result.txt untuk menemukan penyebab dan log kesalahan terperinci.

Akankah kegagalan node berdampak pada hasil pekerjaan?

Tidak jika ada node lain yang tersedia di kluster komputasi yang ditunjuk. Orkestrator akan memulai node baru sebagai pengganti, dan ParallelRunStep tahan terhadap operasi tersebut.

Apa yang terjadi jika fungsi init dalam skrip entri gagal?

ParallelRunStep memiliki mekanisme untuk mencoba kembali pada waktu-waktu tertentu guna memberikan kesempatan untuk pemulihan dari masalah sementara tanpa menunda kegagalan pekerjaan terlalu lama, mekanismenya adalah sebagai berikut:

  1. Jika setelah node dimulai, init pada semua agen terus gagal, kami akan berhenti mencoba setelah 3 * process_count_per_node kegagalan.
  2. Jika setelah pekerjaan init dimulai, pada semua agen dari semua node terus gagal, kami akan berhenti mencoba jika pekerjaan berjalan lebih dari 2 menit dan ada 2 * node_count * process_count_per_node kegagalan.
  3. Jika semua agen terjebak di init selama lebih dari beberapa 3 * run_invocation_timeout + 30 detik, pekerjaan akan gagal karena tidak ada progres terlalu lama.

Apa yang akan terjadi di OutOfMemory? Bagaimana cara memeriksa penyebabnya?

ParallelRunStep akan mengatur upaya saat ini untuk memproses status batch mini ke status kegagalan dan mencoba menghidupkan ulang proses yang gagal. Anda bisa memeriksa ~logs/perf/<node_id> untuk menemukan proses yang memakan waktu.

Mengapa saya memiliki banyak file processNNN?

ParallelRunStep akan memulai proses pekerja baru menggantikan yang keluar secara tidak normal, dan setiap proses akan menghasilkan file processNNN sebagai log. Namun, jika proses gagal karena pengecualian selama init fungsi skrip pengguna, dan bahwa kesalahan berulang terus menerus untuk 3 * process_count_per_node kali, tidak ada proses pekerja baru yang akan dimulai.

Langkah berikutnya