Invoer en uitvoer voor onderdelen en pijplijnen beheren

Azure Machine Learning-pijplijnen ondersteunen invoer en uitvoer op zowel het onderdeel- als de pijplijnniveaus. In dit artikel worden de invoer en uitvoer van pijplijnen en onderdelen beschreven en hoe u deze beheert.

Op onderdeelniveau definiëren de invoer en uitvoer de onderdeelinterface. U kunt de uitvoer van het ene onderdeel gebruiken als invoer voor een ander onderdeel in dezelfde bovenliggende pijplijn, zodat gegevens of modellen tussen onderdelen kunnen worden doorgegeven. Deze interconnectiviteit vertegenwoordigt de gegevensstroom in de pijplijn.

Op pijplijnniveau kunt u invoer en uitvoer gebruiken om pijplijntaken te verzenden met verschillende gegevensinvoer of parameters, zoals learning_rate. Invoer en uitvoer zijn vooral handig wanneer u een pijplijn aanroept via een REST-eindpunt. U kunt verschillende waarden toewijzen aan de pijplijninvoer of toegang krijgen tot de uitvoer van verschillende pijplijntaken. Zie Taken en invoergegevens maken voor batcheindpunten voor meer informatie.

Invoer- en uitvoertypen

De volgende typen worden ondersteund als invoer en uitvoer van onderdelen of pijplijnen:

• Gegevenstypen voor meer informatie over IntDate. Zie Gegevenstypen voor meer informatie.

  • uri_file
  • uri_folder
  • mltable

• Modeltypen.

  • mlflow_model
  • custom_model

De volgende primitieve typen worden ook alleen ondersteund voor invoer:

• Primitieve typen
  • string
  • number
  • integer
  • boolean

Uitvoer van primitieve typen wordt niet ondersteund.

Voorbeeldinvoer en uitvoer

Deze voorbeelden zijn afkomstig van de NYC Taxi Data Regression-pijplijn in de GitHub-opslagplaats met Azure Machine Learning-voorbeelden .

• Het trainonderdeel heeft een invoer met de number naam test_split_ratio.
• Het voorbereidingsonderdeel heeft een uri_folder type-uitvoer. De broncode van het onderdeel leest de CSV-bestanden uit de invoermap, verwerkt de bestanden en schrijft de verwerkte CSV-bestanden naar de uitvoermap.
• Het trainonderdeel heeft een mlflow_model type-uitvoer. De broncode van het onderdeel slaat het getrainde model op met behulp van de mlflow.sklearn.save_model methode.

Uitvoerserialisatie

Als u gegevens of modeluitvoer gebruikt, worden de uitvoer geserialiseerd en opgeslagen als bestanden op een opslaglocatie. Latere stappen hebben toegang tot de bestanden tijdens het uitvoeren van de taak door deze opslaglocatie te koppelen of door de bestanden te downloaden of te uploaden naar het rekenbestandssysteem.

De broncode van het onderdeel moet het uitvoerobject, dat meestal in het geheugen wordt opgeslagen, serialiseren in bestanden. U kunt bijvoorbeeld een pandas-dataframe serialiseren in een CSV-bestand. Azure Machine Learning definieert geen gestandaardiseerde methoden voor objectserialisatie. U hebt de flexibiliteit om uw voorkeursmethoden te kiezen om objecten in bestanden te serialiseren. In het downstreamonderdeel kunt u kiezen hoe u deze bestanden deserialiseert en leest.

Invoer- en uitvoerpaden van gegevenstype

Voor invoer en uitvoer van gegevensassets moet u een padparameter opgeven die verwijst naar de gegevenslocatie. In de volgende tabel ziet u de ondersteunde gegevenslocaties voor azure Machine Learning-pijplijninvoer en -uitvoer, met path parametervoorbeelden.

Locatie	Invoer	Uitvoer	Opmerking
Een pad op uw lokale computer	✓		./home/<username>/data/my_data
Een pad op een openbare HTTP/s-server	✓		https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv
Een pad in Azure Storage	*		wasbs://<container_name>@<account_name>.blob.core.windows.net/<path> or abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
Een pad in een Azure Machine Learning-gegevensarchief	✓	✓	azureml://datastores/<data_store_name>/paths/<path>
Een pad naar een gegevensasset	✓	✓	azureml:my_data:<version>

* Het rechtstreeks gebruiken van Azure Storage wordt niet aanbevolen voor invoer, omdat er mogelijk extra identiteitsconfiguratie nodig is om de gegevens te lezen. Het is beter om Azure Machine Learning-gegevensopslagpaden te gebruiken, die worden ondersteund in verschillende typen pijplijntaken.

Invoer- en uitvoermodi voor gegevenstypen

Voor invoer en uitvoer van gegevenstypen kunt u kiezen uit verschillende download-, upload- en koppelmodi om te bepalen hoe het rekendoel toegang heeft tot gegevens. In de volgende tabel ziet u de ondersteunde modi voor verschillende typen invoer en uitvoer.

Type	upload	download	ro_mount	rw_mount	direct	eval_download	eval_mount
uri_folder invoer		✓	✓		✓
uri_file invoer		✓	✓		✓
mltable invoer		✓	✓		✓	✓	✓
uri_folder uitvoer	✓			✓
uri_file uitvoer	✓			✓
mltable uitvoer	✓			✓	✓

De ro_mount of rw_mount modi worden aanbevolen voor de meeste gevallen. Zie Modi voor meer informatie.

Invoer en uitvoer in pijplijngrafieken

Op de pagina pijplijntaak in Azure Machine Learning-studio worden onderdeelinvoer en -uitvoer weergegeven als kleine cirkels met de naam invoer-/uitvoerpoorten. Deze poorten vertegenwoordigen de gegevensstroom in de pijplijn. Uitvoer op pijplijnniveau wordt weergegeven in paarse vakken voor eenvoudige identificatie.

In de volgende schermopname van de pijplijngrafiek nyc taxigegevens worden veel onderdelen en pijplijninvoer en -uitvoer weergegeven.

Wanneer u de muisaanwijzer boven een invoer-/uitvoerpoort houdt, wordt het type weergegeven.

In de pijplijngrafiek worden geen primitieve invoertypen weergegeven. Deze invoer wordt weergegeven op het tabblad Instellingen van het overzichtsvenster van de pijplijntaak voor invoer op pijplijnniveau of het onderdeelpaneel voor invoer op onderdeelniveau. Als u het onderdeelpaneel wilt openen, dubbelklikt u op het onderdeel in de grafiek.

Wanneer u een pijplijn bewerkt in studio Designer, bevinden pijplijninvoer en -uitvoer zich in het deelvenster Pijplijninterface en bevinden de invoer en uitvoer van onderdelen zich in het onderdeelpaneel.

Niveau van onderdeelinvoer/uitvoer verhogen naar pijplijnniveau

Door de invoer/uitvoer van een onderdeel te promoveren naar het pijplijnniveau, kunt u de invoer/uitvoer van het onderdeel overschrijven wanneer u een pijplijntaak verzendt. Deze mogelijkheid is vooral handig voor het activeren van pijplijnen met behulp van REST-eindpunten.

In de volgende voorbeelden ziet u hoe u invoer/uitvoer op onderdeelniveau promoveert naar invoer/uitvoer op pijplijnniveau.

Azure-CLI

De volgende pijplijn bevordert drie invoer en drie uitvoerwaarden naar het pijplijnniveau. Is bijvoorbeeld pipeline_job_training_max_epocs invoer op pijplijnniveau, omdat deze wordt gedeclareerd onder de inputs sectie op het hoofdniveau.

Onder train_job in de jobs sectie wordt naar de benoemde max_epocs invoer verwezen als ${{parent.inputs.pipeline_job_training_max_epocs}}, wat betekent dat de invoer van het train_jobmax_epocs pijplijnniveau verwijst naar de invoer op pijplijnniveaupipeline_job_training_max_epocs. Pijplijnuitvoer wordt gepromoveerd met hetzelfde schema.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: 1b_e2e_registered_components
description: E2E dummy train-score-eval pipeline with registered components

inputs:
  pipeline_job_training_max_epocs: 20
  pipeline_job_training_learning_rate: 1.8
  pipeline_job_learning_rate_schedule: 'time-based'

outputs: 
  pipeline_job_trained_model:
    mode: upload
  pipeline_job_scored_data:
    mode: upload
  pipeline_job_evaluation_report:
    mode: upload

settings:
 default_compute: azureml:cpu-cluster

jobs:
  train_job:
    type: command
    component: azureml:my_train@latest
    inputs:
      training_data: 
        type: uri_folder 
        path: ./data      
      max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
      learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
      learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
    outputs:
      model_output: ${{parent.outputs.pipeline_job_trained_model}}
    services:
      my_vscode:
        type: vs_code
      my_jupyter_lab:
        type: jupyter_lab
      my_tensorboard:
        type: tensor_board
        log_dir: "outputs/tblogs"
    #  my_ssh:
    #    type: tensor_board
    #    ssh_public_keys: <paste the entire pub key content>
    #    nodes: all # Use the `nodes` property to pick which node you want to enable interactive services on. If `nodes` are not selected, by default, interactive applications are only enabled on the head node.

  score_job:
    type: command
    component: azureml:my_score@latest
    inputs:
      model_input: ${{parent.jobs.train_job.outputs.model_output}}
      test_data: 
        type: uri_folder 
        path: ./data
    outputs:
      score_output: ${{parent.outputs.pipeline_job_scored_data}}

  evaluate_job:
    type: command
    component: azureml:my_eval@latest
    inputs:
      scoring_result: ${{parent.jobs.score_job.outputs.score_output}}
    outputs:
      eval_output: ${{parent.outputs.pipeline_job_evaluation_report}}

U vindt het volledige voorbeeld in de pijplijn train-score-eval met geregistreerde onderdelen in de opslagplaats met Voorbeelden van Azure Machine Learning .

Python SDK

In het volgende codevoorbeeld wordt de nyc_taxi_data_regression pijplijn gedefinieerd. De pijplijn heeft één invoer pipeline_job_inputen genereert zes uitvoer zoals gedefinieerd in de return instructie. De pijplijnuitvoer wordt gepromoveerd vanuit het onderliggende onderdeel met behulp van het schema <step_name.outputs.output_name>, bijvoorbeeld prepare_sample_data.outputs.prep_data.

U vindt het end-to-end-notebook op nyc taxigegevensregressie in de opslagplaats met Voorbeelden van Azure Machine Learning .

# import required libraries
from azure.identity import DefaultAzureCredential

from azure.ai.ml import MLClient, Input
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

# set subscription, resource group, and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# define the directory that stores the input data 
parent_dir = ""

# load components
prepare_data = load_component(source=parent_dir + "./prep.yml")
transform_data = load_component(source=parent_dir + "./transform.yml")
train_model = load_component(source=parent_dir + "./train.yml")
predict_result = load_component(source=parent_dir + "./predict.yml")
score_data = load_component(source=parent_dir + "./score.yml")

# construct pipeline
@pipeline()
def nyc_taxi_data_regression(pipeline_job_input):
    """NYC taxi data regression example."""
    prepare_sample_data = prepare_data(raw_data=pipeline_job_input)
    transform_sample_data = transform_data(
        clean_data=prepare_sample_data.outputs.prep_data
    )
    train_with_sample_data = train_model(
        training_data=transform_sample_data.outputs.transformed_data
    )
    predict_with_sample_data = predict_result(
        model_input=train_with_sample_data.outputs.model_output,
        test_data=train_with_sample_data.outputs.test_data,
    )
    score_with_sample_data = score_data(
        predictions=predict_with_sample_data.outputs.predictions,
        model=train_with_sample_data.outputs.model_output,
    )
    return {
        "pipeline_job_prepped_data": prepare_sample_data.outputs.prep_data,
        "pipeline_job_transformed_data": transform_sample_data.outputs.transformed_data,
        "pipeline_job_trained_model": train_with_sample_data.outputs.model_output,
        "pipeline_job_test_data": train_with_sample_data.outputs.test_data,
        "pipeline_job_predictions": predict_with_sample_data.outputs.predictions,
        "pipeline_job_score_report": score_with_sample_data.outputs.score_report,
    }
# define pipeline job
pipeline_job = nyc_taxi_data_regression(
    Input(type="uri_folder", path=parent_dir + "./data/")
)
# demo how to change pipeline output settings
pipeline_job.outputs.pipeline_job_prepped_data.mode = "rw_mount"

# set pipeline level compute
pipeline_job.settings.default_compute = "cpu-cluster"
# set pipeline level datastore
pipeline_job.settings.default_datastore = "workspaceblobstore"

Gebruikersinterface van Studio

U kunt de invoer van een onderdeel promoveren naar invoer op pijplijnniveau op de ontwerppagina van Studio Designer.

1. Open het instellingenvenster van het onderdeel door te dubbelklikken op het onderdeel.

2. Selecteer ... naast de invoer die u wilt promoveren.

3. Selecteer Toevoegen aan pijplijninvoer.

   

Optionele invoer definiëren

Standaard zijn alle invoer vereist en moeten ze een standaardwaarde hebben of elke keer dat u een pijplijntaak verzendt, een waarde toewijzen. U kunt echter een optionele invoer definiëren.

Notitie

Optionele uitvoer wordt niet ondersteund.

Het instellen van optionele invoer kan nuttig zijn in twee scenario's:

• Als u een optionele invoer voor gegevens/modeltypen definieert en er geen waarde aan toewijst wanneer u de pijplijntaak verzendt, ontbreekt het pijplijnonderdeel aan die gegevensafhankelijkheid. Als de invoerpoort van het onderdeel niet is gekoppeld aan een onderdeel- of gegevens-/modelknooppunt, roept de pijplijn het onderdeel rechtstreeks aan in plaats van te wachten op een voorgaande afhankelijkheid.

• Als u voor de pijplijn instelt continue_on_step_failure = True , maar node2 de vereiste invoer van node1de pijplijn gebruikt, node2 wordt deze niet uitgevoerd als node1 dit mislukt. Als node1 invoer optioneel is, wordt deze uitgevoerd, node2 zelfs als node1 dit mislukt. In de volgende grafiek ziet u dit scenario.

  

Azure CLI/Python SDK

In het volgende codevoorbeeld ziet u hoe u optionele invoer definieert. Wanneer de invoer is ingesteld als optional = true, moet u de $[[]] opdrachtregelinvoer omhelzen, zoals in de gemarkeerde regels van het voorbeeld.

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
name: train_data_component_cli
display_name: train_data
description: A example train component
tags:
  author: azureml-sdk-team
type: command
inputs:
  training_data: 
    type: uri_folder
  max_epocs:
    type: integer
    optional: true
  learning_rate: 
    type: number
    default: 0.01
    optional: true
  learning_rate_schedule: 
    type: string
    default: time-based
    optional: true
outputs:
  model_output:
    type: uri_folder
code: ./train_src
environment: azureml://registries/azureml/environments/sklearn-1.5/labels/latest
command: >-
  python train.py 
  --training_data ${{inputs.training_data}} 
  $[[--max_epocs ${{inputs.max_epocs}}]]
  $[[--learning_rate ${{inputs.learning_rate}}]]
  $[[--learning_rate_schedule ${{inputs.learning_rate_schedule}}]]
  --model_output ${{outputs.model_output}}

Gebruikersinterface van Studio

In een pijplijngrafiek vertegenwoordigen stippelcirkels optionele invoer van gegevens of modeltypen. Optionele invoer van primitieve typen bevindt zich op het tabblad Instellingen . In tegenstelling tot vereiste invoer hebben optionele invoer geen sterretje ernaast, wat aangeeft dat ze niet verplicht zijn.

Uitvoerpaden aanpassen

Standaard wordt onderdeeluitvoer opgeslagen in de {default_datastore} uitvoer die u voor de pijplijn hebt ingesteld. azureml://datastores/${{default_datastore}}/paths/${{name}}/${{output_name}} Als dit niet is ingesteld, is de standaardwaarde de blobopslag van de werkruimte.

De taak {name} wordt opgelost tijdens de uitvoering van de taak en {output_name} is de naam die u hebt gedefinieerd in de YAML van het onderdeel. U kunt aanpassen waar de uitvoer moet worden opgeslagen door een uitvoerpad te definiëren.

Azure-CLI

Het pipeline.yml-bestand bij de pijplijn train-score-eval met geregistreerde onderdelen definieert een pijplijn met drie uitvoer op pijplijnniveau. U kunt de volgende opdracht gebruiken om aangepaste uitvoerpaden in te stellen voor de pipeline_job_trained_model uitvoer.

# define the custom output path using datastore uri
# add relative path to your blob container after "azureml://datastores/<datastore_name>/paths"
output_path="azureml://datastores/{datastore_name}/paths/{relative_path_of_container}"  

# create job and define path using --outputs.<outputname>
az ml job create -f ./pipeline.yml --set outputs.pipeline_job_trained_model.path=$output_path  

Python SDK

De volgende code die laat zien hoe u uitvoerpaden kunt aanpassen, is afkomstig uit de build-pijplijn met command_component ingerichte Python-functienotitieblok .

cluster_name = "cpu-cluster"
custom_path = "azureml://datastores/workspaceblobstore/paths/custom_path/${{name}}/"

# define a pipeline with component
@pipeline(default_compute=cluster_name)
def pipeline_with_python_function_components(input_data, test_data, learning_rate):
    """E2E dummy train-score-eval pipeline with components defined via python function components"""

    # Call component obj as function: apply given inputs & parameters to create a node in pipeline
    train_with_sample_data = train_model(
        training_data=input_data, max_epochs=5, learning_rate=learning_rate
    )
    score_with_sample_data = score_data(
        model_input=train_with_sample_data.outputs.model_output,
        test_data=test_data,
        model_file=train_with_sample_data.outputs.output,
    )
    # example how to change path of output on step level,
    # please note if the output is promoted to pipeline level you need to change path in pipeline job level
    score_with_sample_data.outputs.score_output = Output(
        type="uri_folder", mode="rw_mount", path=custom_path
    )
    eval_with_sample_data = eval_model(
        scoring_result=score_with_sample_data.outputs.score_output,
        scoring_file=score_with_sample_data.outputs.output,
    )

    # Return: pipeline outputs
    return {
        "eval_output": eval_with_sample_data.outputs.eval_output,
        "model_output": train_with_sample_data.outputs.model_output,
    }


pipeline_job = pipeline_with_python_function_components(
    input_data=Input(
        path="wasbs://demo@dprepdata.blob.core.windows.net/Titanic.csv", type="uri_file"
    ),
    test_data=Input(
        path="wasbs://demo@dprepdata.blob.core.windows.net/Titanic.csv", type="uri_file"
    ),
    learning_rate=0.1,
)
# example how to change path of output on pipeline level
pipeline_job.outputs.model_output = Output(
    type="uri_folder", mode="rw_mount", path=custom_path
)

Gebruikersinterface van Studio

Vouw in de interface designerpijplijn voor een pijplijn of het onderdeelpaneel voor een onderdeel uitvoer uit op het tabblad Instellingen om een aangepast pad op te geven.

Uitvoer downloaden

U kunt uitvoer downloaden op pijplijn- of onderdeelniveau.

Uitvoer op pijplijnniveau downloaden

Azure-CLI

U kunt alle uitvoer van een taak downloaden of een specifieke uitvoer downloaden.

# Download all the outputs of the job
az ml job download --all -n <JOB_NAME> -g <RESOURCE_GROUP_NAME> -w <WORKSPACE_NAME> --subscription <SUBSCRIPTION_ID>

# Download a specific output
az ml job download --output-name <OUTPUT_PORT_NAME> -n <JOB_NAME> -g <RESOURCE_GROUP_NAME> -w <WORKSPACE_NAME> --subscription <SUBSCRIPTION_ID>

Python SDK

Maak en initialiseer ml_client eerst als een ingang om naar uw werkruimte te verwijzen. Zie Een ingang maken voor de werkruimte voor meer informatie.

# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Download alle uitvoer van een taak of download een specifieke uitvoer.

# Download all the outputs of the job
output = client.jobs.download(name=job.name, download_path=tmp_path, all=True)

# Download specific output
output = client.jobs.download(name=job.name, download_path=tmp_path, output_name=output_port_name)

Gebruikersinterface van Studio

Op het tabblad Uitvoer en logboeken van de pagina taakdetails:

• Als u alle uitvoer wilt downloaden, selecteert u Alles downloaden in het bovenste menu.
• Als u een specifieke uitvoer wilt downloaden, selecteert u ... naast een bestand en selecteert u Downloaden in het contextmenu.

Uitvoer van onderdelen downloaden

Azure-CLI

Als u de uitvoer van een onderliggend onderdeel wilt downloaden, moet u eerst alle onderliggende taken van een pijplijntaak weergeven en vervolgens vergelijkbare code gebruiken om de uitvoer te downloaden.

# List all child jobs in the job and print job details in table format
az ml job list --parent-job-name <JOB_NAME> -g <RESOURCE_GROUP_NAME> -w <WORKSPACE_NAME> --subscription <SUBSCRIPTION_ID> -o table

# Select the desired child job name to download output
az ml job download --all -n <JOB_NAME> -g <RESOURCE_GROUP_NAME> -w <WORKSPACE_NAME> --subscription <SUBSCRIPTION_ID>

Python SDK

Maak en initialiseer ml_client eerst als een ingang om naar uw werkruimte te verwijzen. Zie Een ingang maken voor de werkruimte voor meer informatie.

# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Als u de uitvoer van een onderliggend onderdeel wilt downloaden, moet u eerst alle onderliggende taken van een pijplijntaak weergeven en vervolgens vergelijkbare code gebruiken om de uitvoer te downloaden.

# List all child jobs in the job
child_jobs = client.jobs.list(parent_job_name=job.name)

# Traverse and download all the outputs of child job
for child_job in child_jobs:
    client.jobs.download(name=child_job.name, all=True)

Gebruikersinterface van Studio

Selecteer Alles downloaden op het tabblad Uitvoer en logboeken van het onderdeelpaneel voor een onderdeel.

Uitvoer registreren als een benoemde asset

U kunt de uitvoer van een onderdeel of pijplijn registreren als een benoemde asset door een name en version aan de uitvoer toe te wijzen. De geregistreerde asset kan worden vermeld in uw werkruimte via de gebruikersinterface van studio, CLI of SDK en kan worden verwezen in toekomstige werkruimtetaken.

Uitvoer op pijplijnniveau registreren

Azure-CLI

display_name: register_pipeline_output
type: pipeline
jobs:
  node:
    type: command
    inputs:
      component_in_path:
        type: uri_file
        path: https://dprepdata.blob.core.windows.net/demo/Titanic.csv
    component: ../components/helloworld_component.yml
    outputs:
      component_out_path: ${{parent.outputs.component_out_path}}
outputs:
  component_out_path:
    type: mltable
    name: pipeline_output  # Define name and version to register pipeline output
    version: '1'
settings:
  default_compute: azureml:cpu-cluster

Python SDK

from azure.ai.ml import dsl, Output

# Load component functions
components_dir = "./components/"
helloworld_component = load_component(source=f"{components_dir}/helloworld_component.yml")

@pipeline()
def register_pipeline_output():
  # Call component obj as function: apply given inputs & parameters to create a node in pipeline
  node = helloworld_component(component_in_path=Input(
    type='uri_file', path='https://dprepdata.blob.core.windows.net/demo/Titanic.csv'))

  return {
      'component_out_path': node.outputs.component_out_path
  }

pipeline = register_pipeline_output()
# Define name and version to register pipeline output
pipeline.settings.default_compute = "azureml:cpu-cluster"
pipeline.outputs.component_out_path.name = 'pipeline_output'
pipeline.outputs.component_out_path.version = '1'

Gebruikersinterface van Studio

Selecteer op het tabblad Overzicht voor een pijplijntaak een koppeling gegevensasset onder Invoer of Uitvoer. Selecteer Registreren op de pagina gegevensasset.

Uitvoer van onderdeel registreren

Azure-CLI

display_name: register_node_output
type: pipeline
jobs:
  node:
    type: command
    component: ../components/helloworld_component.yml
    inputs:
      component_in_path:
        type: uri_file
        path: 'https://dprepdata.blob.core.windows.net/demo/Titanic.csv'
    outputs:
      component_out_path:
        type: uri_folder
        name: 'node_output'  # Define name and version to register a child job's output
        version: '1'
settings:
  default_compute: azureml:cpu-cluster

Python SDK

from azure.ai.ml import dsl, Output

# Load component functions
components_dir = "./components/"
helloworld_component = load_component(source=f"{components_dir}/helloworld_component.yml")

@pipeline()
def register_node_output():
  # Call component obj as function: apply given inputs & parameters to create a node in pipeline
  node = helloworld_component(component_in_path=Input(
    type='uri_file', path='https://dprepdata.blob.core.windows.net/demo/Titanic.csv'))

  # Define name and version to register node output
  node.outputs.component_out_path.name = 'node_output'
  node.outputs.component_out_path.version = '1'

pipeline = register_node_output()
pipeline.settings.default_compute = "azureml:cpu-cluster"

Gebruikersinterface van Studio

Selecteer op het tabblad Overzicht voor een onderdeel een koppeling gegevensasset onder Invoer of Uitvoer. Selecteer Registreren op de pagina gegevensasset.

Gerelateerde inhoud

• YAML-verwijzing voor pijplijntaak
• Fouten in pijplijn opsporen
• Een pijplijntaak plannen
• Een pijplijn implementeren met batch-eindpunten (preview)