Sdílet prostřednictvím

Řešení potíží s třídou ParallelRunStep

  • Článek

PLATÍ PRO: Python SDK azureml v1

V tomto článku se dozvíte, jak řešit potíže s chybami pomocí třídy ParallelRunStep ze sady Azure Machine Learning SDK.

Obecné tipy pro řešení potíží s kanálem najdete v tématu Řešení potíží s kanály strojového učení.

Místní testování skriptů

Váš ParallelRunStep se spouští jako krok v kanálech ML. Skripty můžete chtít otestovat místně jako první krok.

Požadavky na vstupní skript

Vstupní skript pro funkci ParallelRunStep musí obsahovat run() funkci a volitelně obsahuje init() funkci:

  • init(): Tuto funkci použijte pro jakoukoli nákladnou nebo běžnou přípravu na pozdější zpracování. Můžete ho například použít k načtení modelu do globálního objektu. Tato funkce bude volána pouze jednou na začátku procesu.

    Poznámka:

    Pokud vaše init metoda vytvoří výstupní adresář, zadejte to parents=True a exist_ok=True. Metoda init se volá z každého pracovního procesu na každém uzlu, na kterém je úloha spuštěná.

  • run(mini_batch): Funkce se spustí pro každou mini_batch instanci.
    • mini_batch: ParallelRunStep vyvolá metodu run a předá metodě seznam nebo knihovnu pandas DataFrame jako argument. Každá položka v mini_batch bude cesta k souboru, pokud je vstup nebo FileDataset pandasDataFrame, pokud je vstup .TabularDataset
    • response: metoda run() by měla vrátit knihovnu pandas DataFrame nebo pole. Pro append_row output_action se tyto vrácené prvky připojí do společného výstupního souboru. Pro summary_only se obsah prvků ignoruje. U všech výstupních akcí každý vrácený výstupní prvek označuje jeden úspěšný spuštění vstupního prvku ve vstupní mini-batch. Ujistěte se, že je do výsledku spuštění zahrnutých dostatek dat pro mapování vstupu na výsledek spuštění výstupu. Výstup spuštění se zapíše do výstupního souboru a není zaručeno, že bude v pořádku. K mapování na vstup byste měli použít nějaký klíč ve výstupu.

      Poznámka:

      Jeden výstupní prvek je očekáváno pro jeden vstupní prvek.

%%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

Pokud máte jiný soubor nebo složku ve stejném adresáři jako skript pro odvozování, můžete na něj odkazovat vyhledáním aktuálního pracovního adresáře. Pokud chcete importovat balíčky, můžete do složky sys.pathbalíčku připojit také složku .

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

packages_dir = os.path.join(file_path, '<your_package_folder>')
if packages_dir not in sys.path:
    sys.path.append(packages_dir)
from <your_package> import <your_class>

Parametry pro ParallelRunConfig

ParallelRunConfig je hlavní konfigurace pro ParallelRunStep instanci v rámci kanálu Azure Machine Learning. Použijete ho k zabalení skriptu a konfiguraci nezbytných parametrů, včetně všech následujících položek:

  • entry_script: Uživatelský skript jako místní cesta k souboru, který se bude spouštět paralelně na více uzlech. Pokud source_directory je k dispozici, použijte relativní cestu. V opačném případě použijte jakoukoli cestu, která je na počítači přístupná.

  • mini_batch_size: Velikost minidávkové dávky předané do jednoho run() volání. (volitelné; výchozí hodnota je 10 soubory pro FileDataset a 1MB pro TabularDataset.)

    • Jedná FileDatasetse o počet souborů s minimální hodnotou 1. Do jedné minidávkové dávky můžete zkombinovat více souborů.
    • Pro TabularDataset, je to velikost dat. Příklady hodnot jsou 1024, 1024KB, 10MBa 1GB. Doporučená hodnota je 1MB. Minidávkové dávky TabularDataset nikdy nepřekračují hranice souborů. Pokud máte například .csv soubory s různými velikostmi, nejmenší soubor je 100 kB a největší je 10 MB. Pokud nastavíte mini_batch_size = 1MB, soubory s velikostí menší než 1 MB se budou považovat za jednu minidávku. Soubory s velikostí větší než 1 MB se rozdělí do několika mini dávek.

      Poznámka:

      TabularDatasets zálohované SQL nelze rozdělit na oddíly. TabularDatasets z jednoho souboru parquet a skupiny s jedním řádkem nelze rozdělit na oddíly.

  • error_threshold: Počet selhání záznamů a TabularDataset selhání souborů, FileDataset které by se měly během zpracování ignorovat. Pokud počet chyb pro celý vstup překročí tuto hodnotu, úloha se přeruší. Prahová hodnota chyby je určená pro celý vstup, nikoli pro jednotlivé minidávkové dávky odeslané do run() metody. Rozsah je [-1, int.max]. Tato -1 část označuje ignorování všech selhání během zpracování.

  • output_action: Jedna z následujících hodnot označuje, jak bude výstup uspořádán:

    • summary_only: Uživatelský skript uloží výstup. ParallelRunStep použije výstup pouze pro výpočet prahové hodnoty chyby.
    • append_row: Pro všechny vstupy se ve výstupní složce vytvoří pouze jeden soubor, který připojí všechny výstupy oddělené řádkem.

  • append_row_file_name: Chcete-li přizpůsobit název výstupního souboru pro append_row output_action (volitelné; výchozí hodnota je parallel_run_step.txt).

  • source_directory: Cesty ke složkám, které obsahují všechny soubory ke spuštění na cílovém výpočetním objektu (volitelné).

  • compute_target: Podporuje se pouze AmlCompute .

  • node_count: Počet výpočetníchuzlůchchch

  • process_count_per_node: Počet pracovních procesů na uzel pro paralelní spuštění vstupního skriptu. Pro počítač s GPU je výchozí hodnota 1. U počítače s procesorem je výchozí hodnota počet jader na uzel. Pracovní proces bude opakovaně volat run() předáním mini dávky, kterou získá. Celkový počet pracovních procesů ve vaší úloze je process_count_per_node * node_count, který rozhoduje o maximálním počtu paralelních run() spuštění.

  • environment: Definice prostředí Pythonu. Můžete ho nakonfigurovat tak, aby používal existující prostředí Pythonu nebo nastavil dočasné prostředí. Definice také zodpovídá za nastavení požadovaných závislostí aplikace (volitelné).

  • logging_level: Log verbosity. Hodnoty při zvyšování podrobností jsou: WARNING, INFOa DEBUG. (volitelné; výchozí hodnota je INFO)

  • run_invocation_timeout: Časový run() limit vyvolání metody v sekundách. (volitelné; výchozí hodnota je 60)

  • run_max_try: Maximální počet vyzkoušení run() pro minidávku. Chyba A run() se nezdařila, pokud je vyvolán výjimka, nebo se po run_invocation_timeout dosažení nevrací žádná hodnota (nepovinná, výchozí hodnota je 3).

Můžete zadat mini_batch_size, , node_count, process_count_per_node, logging_levelrun_invocation_timeouta jako PipelineParameter, run_max_try tak, aby při opětovném odeslání spuštění kanálu můžete doladit hodnoty parametrů. V tomto příkladu použijete PipelineParameter a mini_batch_size Process_count_per_node tyto hodnoty změníte při opětovném odeslání jiného spuštění.

Viditelnost zařízení CUDA

Pro výpočetní cíle vybavené grafickými procesory se proměnná CUDA_VISIBLE_DEVICES prostředí nastaví v pracovních procesech. V AmlCompute najdete celkový počet zařízení GPU v proměnné AZ_BATCHAI_GPU_COUNT_FOUNDprostředí, která je nastavena automaticky. Pokud chcete, aby každý pracovní proces měl vyhrazený GPU, nastavte process_count_per_node na počítači stejný počet zařízení GPU. Každý pracovní proces přiřadí jedinečnému indexu CUDA_VISIBLE_DEVICES. Pokud se pracovní proces z nějakého důvodu zastaví, použije další spuštěný pracovní proces vydaný index GPU.

Pokud je celkový počet zařízení GPU menší než process_count_per_node, pracovní procesy se přiřadí index GPU, dokud se všechny nepoužije.

Vzhledem k celkovému počtu zařízení GPU je 2 a process_count_per_node = 4 jako příklad bude mít proces 0 a proces 1 index 0 a 1. Proces 2 a 3 nebude mít proměnnou prostředí. Pro knihovnu používající tuto proměnnou prostředí pro přiřazení GPU nebude proces 2 a 3 obsahovat gpu a nebude se pokoušet získat zařízení GPU. Pokud se proces 0 zastaví, uvolní index GPU 0. Dalším procesem, který je procesem 4, bude mít přiřazený index GPU 0.

Další informace najdete v tématu CUDA Pro Tip: Řízení viditelnosti GPU pomocí CUDA_VISIBLE_DEVICES.

Parametry pro vytvoření ParallelRunStep

Vytvořte ParallelRunStep pomocí skriptu, konfigurace prostředí a parametrů. Zadejte cílový výpočetní objekt, který jste už připojili ke svému pracovnímu prostoru jako cíl provádění skriptu pro odvozování. Slouží ParallelRunStep k vytvoření kroku kanálu pro odvozování dávky, který přijímá všechny následující parametry:

  • name: Název kroku s následujícími omezeními pojmenování: jedinečný, 3–32 znaků a regulární výraz ^[a-z]([-a-z0-9]*[a-z0-9])?$.
  • parallel_run_config: Objekt ParallelRunConfig , jak je definováno dříve.
  • inputs: Jedna nebo více datových sad Azure Machine Learning s jedním typem, které se mají rozdělit pro paralelní zpracování.
  • side_inputs: Nejméně jedna referenční data nebo datové sady používané jako vstupy na straně, aniž by bylo nutné dělit oddíly.
  • output: Objekt OutputFileDatasetConfig představující cestu k adresáři, ve kterém budou uložena výstupní data.
  • arguments: Seznam argumentů předaných uživatelskému skriptu. Pomocí unknown_args je můžete načíst do vstupního skriptu (volitelné).
  • allow_reuse: Určuje, jestli má krok při spuštění použít předchozí výsledky se stejnými nastaveními nebo vstupy. Pokud je Falsetento parametr, při provádění kanálu se pro tento krok vždy vygeneruje nové spuštění. (volitelné; výchozí hodnota je 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
)

Ladění skriptů ze vzdáleného kontextu

Přechod z ladění bodovacího skriptu místně na ladění hodnoticího skriptu ve skutečném kanálu může být obtížné přeskočit. Informace o vyhledání protokolů na portálu najdete v části kanály strojového učení o ladění skriptů ze vzdáleného kontextu. Informace v této části platí také pro ParallelRunStep.

Soubor protokolu 70_driver_log.txt například obsahuje informace z kontroleru, který spouští kód ParallelRunStep.

Vzhledem k distribuované povaze úloh ParallelRunStep existují protokoly z několika různých zdrojů. Vytvoří se však dva konsolidované soubory, které poskytují základní informace:

  • ~/logs/job_progress_overview.txt: Tento soubor poskytuje základní informace o počtu minidávek (označovaných také jako úkoly) vytvořených doposud a počtu dosud zpracovaných minidávek. Na tomto konci se zobrazí výsledek úlohy. Pokud úloha selhala, zobrazí se chybová zpráva a kde spustit řešení potíží.

  • ~/logs/sys/master_role.txt: Tento soubor poskytuje zobrazení hlavního uzlu (označovaného také jako orchestrátor) spuštěné úlohy. Zahrnuje vytvoření úlohy, sledování průběhu, výsledek spuštění.

Protokoly vygenerované ze vstupního skriptu pomocí pomocné rutiny EntryScriptu a příkazů print se nacházejí v následujících souborech:

  • ~/logs/user/entry_script_log/<node_id>/<process_name>.log.txt: Tyto soubory jsou protokoly zapsané z entry_script pomocí pomocné rutiny EntryScriptu.

  • ~/logs/user/stdout/<node_id>/<process_name>.stdout.txt: Tyto soubory jsou protokoly z příkazu stdout (například příkaz print) entry_script.

  • ~/logs/user/stderr/<node_id>/<process_name>.stderr.txt: Tyto soubory jsou protokoly ze stderru entry_script.

Stručné porozumění chybám ve vašem skriptu je:

  • ~/logs/user/error.txt: Tento soubor se pokusí shrnout chyby ve skriptu.

Další informace o chybách ve skriptu najdete tady:

  • ~/logs/user/error/: Obsahuje úplné trasování zásobníku výjimek vyvolaných při načítání a spouštění vstupního skriptu.

Pokud potřebujete úplné znalosti o tom, jak každý uzel spustil skript skóre, podívejte se na jednotlivé protokoly procesů pro každý uzel. Protokoly procesů najdete ve sys/node složce seskupené podle pracovních uzlů:

  • ~/logs/sys/node/<node_id>/<process_name>.txt: Tento soubor obsahuje podrobné informace o každé minidávce při vyzvednutí nebo dokončení pracovníkem. Pro každou minidávku tento soubor obsahuje:

    • IP adresa a PID pracovního procesu.
    • Celkový počet položek, počet úspěšně zpracovaných položek a počet neúspěšných položek.
    • Čas spuštění, doba trvání, zpracování a čas spuštění metody.

Můžete také zobrazit výsledky pravidelných kontrol využití prostředků pro každý uzel. Soubory protokolů a instalační soubory jsou v této složce:

  • ~/logs/perf: Nastaví --resource_monitor_interval se změna intervalu kontroly v sekundách. Výchozí interval je 600, což je přibližně 10 minut. Pokud chcete monitorování zastavit, nastavte hodnotu na 0hodnotu . Každá <node_id> složka obsahuje:

    • os/: Informace o všech spuštěných procesech v uzlu. Při jedné kontrole se spustí příkaz operačního systému a výsledek se uloží do souboru. V Linuxu je pspříkaz . Ve Windows použijte tasklist.
      • %Y%m%d%H: Název podsložky je čas na hodinu.
        • processes_%M: Soubor končí minutou času kontroly.
    • node_disk_usage.csv: Podrobné využití disku uzlu.
    • node_resource_usage.csv: Přehled využití prostředků uzlu
    • processes_resource_usage.csv: Přehled využití prostředků jednotlivých procesů

Návody protokol z mého uživatelského skriptu ze vzdáleného kontextu?

ParallelRunStep může spouštět více procesů na jednom uzlu na základě process_count_per_node. Pokud chcete uspořádat protokoly z jednotlivých procesů na uzlu a kombinovat příkazy tisku a protokolu, doporučujeme použít logger ParallelRunStep, jak je znázorněno níže. Získáte protokolovací nástroj z EntryScriptu a protokoly se zobrazí ve složce logs/user na portálu.

Ukázkový vstupní skript pomocí protokolovacího nástroje:

from azureml_user.parallel_run import EntryScript

def init():
    """Init once in a worker process."""
    entry_script = EntryScript()
    logger = entry_script.logger
    logger.info("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.info(f"{__file__}: {mini_batch}.")
    ...

    return mini_batch

Kam zpráva z jímky Pythonu logging umožňuje?

ParallelRunStep nastaví obslužnou rutinu v kořenovém protokolovacím nástroji, který potopí zprávu na logs/user/stdout/<node_id>/processNNN.stdout.txt.

logging výchozí hodnota je nastavená na INFO úroveň. Ve výchozím nastavení se úrovně níže INFO nezobrazí, například DEBUG.

Jak můžu na portálu zapisovat do souboru, který se má zobrazit?

Soubory ve logs složce se nahrají a zobrazí se na portálu. Můžete získat složku logs/user/entry_script_log/<node_id> , například níže, a vytvořit cestu k souboru pro zápis:

from pathlib import Path
from azureml_user.parallel_run import EntryScript

def init():
    """Init once in a worker process."""
    entry_script = EntryScript()
    log_dir = entry_script.log_dir
    log_dir = Path(entry_script.log_dir)  # logs/user/entry_script_log/<node_id>/.
    log_dir.mkdir(parents=True, exist_ok=True) # Create the folder if not existing.

    proc_name = entry_script.agent_name  # The process name in pattern "processNNN".
    fil_path = log_dir / f"{proc_name}_<file_name>" # Avoid conflicting among worker processes with proc_name.

Jak zpracovat přihlášení k novým procesům?

V vstupním skriptu můžete vytvořit nové procesy pomocí subprocess modulu, připojit se k jejich vstupním/výstupním/chybovým kanálům a získat jejich návratové kódy.

Doporučeným přístupem je použít run() funkci s capture_output=True. Chyby se zobrazí v logs/user/error/<node_id>/<process_name>.txtsouboru .

Pokud chcete použít Popen(), měli byste přesměrovat stdout/stderr na soubory, například:

from pathlib import Path
from subprocess import Popen

from azureml_user.parallel_run import EntryScript


def init():
    """Show how to redirect stdout/stderr to files in logs/user/entry_script_log/<node_id>/."""
    entry_script = EntryScript()
    proc_name = entry_script.agent_name  # The process name in pattern "processNNN".
    log_dir = Path(entry_script.log_dir)  # logs/user/entry_script_log/<node_id>/.
    log_dir.mkdir(parents=True, exist_ok=True) # Create the folder if not existing.
    stdout_file = str(log_dir / f"{proc_name}_demo_stdout.txt")
    stderr_file = str(log_dir / f"{proc_name}_demo_stderr.txt")
    proc = Popen(
        ["...")],
        stdout=open(stdout_file, "w"),
        stderr=open(stderr_file, "w"),
        # ...
    )

Poznámka:

Pracovní proces spustí "systémový" kód a kód vstupního skriptu ve stejném procesu.

Pokud není stdout zadáno nebo stderr není zadáno, zdědí podproces vytvořený ve Popen() vstupním skriptu nastavení pracovního procesu.

stdout bude zapisovat do logs/sys/node/<node_id>/processNNN.stdout.txt a stderr do logs/sys/node/<node_id>/processNNN.stderr.txt.

Návody zapsat soubor do výstupního adresáře a pak ho zobrazit na portálu?

Výstupní adresář můžete získat z EntryScript třídy a zapisovat do něj. Pokud chcete zobrazit zapsané soubory, vyberte v kroku Zobrazení Spustit na portálu Azure Machine Learning kartu Výstupy a protokoly . Vyberte odkaz Výstupy dat a pak proveďte kroky popsané v dialogovém okně.

Použijte EntryScript ve vstupním skriptu, například v tomto příkladu:

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

Jak můžu předat vedlejší vstup, například soubor nebo soubory obsahující vyhledávací tabulku, všem svým pracovníkům?

Uživatel může předat referenční data skriptu pomocí side_inputs parametru ParalleRunStep. Všechny datové sady poskytované jako side_inputs se připojí ke každému pracovnímu uzlu. Uživatel může získat umístění připojení předáním argumentu.

Vytvořte datovou sadu obsahující referenční data, zadejte místní cestu připojení a zaregistrujte ji ve svém pracovním prostoru. Předejte ho parametru side_inputs vašeho ParallelRunStepsouboru . Kromě toho můžete přidat jeho cestu do oddílu arguments , abyste měli snadný přístup k jeho připojené cestě.

Poznámka:

FileDatasets používejte jenom pro 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,
)

Potom k němu můžete přistupovat ve skriptu pro odvozování (například v metodě init() následujícím způsobem:

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

labels_path = args.labels_dir

Jak používat vstupní datové sady s ověřováním instančního objektu?

Uživatel může předat vstupní datové sady s ověřováním instančního objektu použitým v pracovním prostoru. Použití takové datové sady v ParallelRunStep vyžaduje, aby byla datová sada zaregistrovaná pro vytvoření konfigurace 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)

Jak zkontrolovat průběh a analyzovat

V této části se dozvíte, jak zkontrolovat průběh úlohy ParallelRunStep a zkontrolovat příčinu neočekávaného chování.

Jak zkontrolovat průběh úlohy?

Kromě pohledu na celkový stav StepRun lze počet naplánovaných/zpracovaných minidávek a průběh generování výstupu zobrazit v ~/logs/job_progress_overview.<timestamp>.txtsouboru . Soubor se každý den obměňuje, můžete zkontrolovat, jestli je v nejnovějším časovém razítku největší časové razítko.

Co mám zkontrolovat, jestli nějakou dobu nedochází k žádnému pokroku?

Můžete se ~/logs/sys/errror podívat, jestli nedošlo k nějaké výjimce. Pokud žádný neexistuje, je pravděpodobné, že váš vstupní skript trvá dlouho, můžete v kódu vytisknout informace o průběhu a vyhledat časově náročnou část nebo přidat "--profiling_module", "cProfile" do ParallelRunStep arguments souboru profilu s názvem pod <process_name>.profile ~/logs/sys/node/<node_id> složkou.

Kdy se úloha zastaví?

pokud nezrušíte, úloha se zastaví se stavem:

  • Dokončeno. Pokud byly všechny minidávkové dávky zpracovány a výstup se vygeneroval pro append_row režim.
  • Neúspěch. Parameters for ParallelRunConfig Pokud error_threshold dojde k překročení nebo došlo k systémové chybě během úlohy.

Kde najít původní příčinu selhání?

Pokud chcete zjistit příčinu a podrobný protokol chyb, postupujte podle pokynů ~logs/job_result.txt .

Ovlivní selhání uzlu výsledek úlohy?

Ne, pokud jsou v určeném výpočetním clusteru k dispozici další uzly. Orchestrátor spustí nový uzel jako náhradu a ParallelRunStep je odolný vůči takové operaci.

Co se stane, když init funkce ve vstupním skriptu selže?

ParallelRunStep má mechanismus opakování po určitou dobu, aby poskytoval šanci na obnovení z přechodných problémů bez zpoždění selhání úlohy příliš dlouho, mechanismus je následující:

  1. Pokud po spuštění init uzlu dochází u všech agentů k selhání, přestaneme se po selhání pokoušet 3 * process_count_per_node .
  2. Pokud po spuštění init úlohy dochází u všech agentů všech uzlů k selhání, zastavíme se pokus o spuštění úlohy déle než 2 minuty a dojde k 2 * node_count * process_count_per_node selháním.
  3. Pokud se všichni agenti zablokují init déle než 3 * run_invocation_timeout + 30 sekundy, úloha se nezdaří kvůli příliš dlouhému pokroku.

Co se stane na OutOfMemory? Jak můžu zjistit příčinu?

ParallelRunStep nastaví aktuální pokus o zpracování minidávkové dávky na stav selhání a pokusí se restartovat neúspěšný proces. Můžete zkontrolovat ~logs/perf/<node_id> proces, který využívá paměť.

Proč mám hodně souborů processNNN?

ParallelRunStep spustí nové pracovní procesy na nahrazení těch, které byly ukončeny neobvykle, a každý proces vygeneruje processNNN soubor jako protokol. Pokud ale proces selhal kvůli výjimce během init funkce uživatelského skriptu a že se chyba opakovaně opakuje po 3 * process_count_per_node dobu, nebude spuštěn žádný nový pracovní proces.

Další kroky