Accedere ai dati in un processo

  • Articolo
  • 7 minuti per la lettura

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Informazioni su come leggere e scrivere dati per i processi con Azure Machine Learning Python SDK v2 e l'estensione v2 dell'interfaccia della riga di comando di Azure Machine Learning.

Prerequisiti

Percorsi supportati

Quando si fornisce un input/output di dati a un processo, è necessario specificare un path parametro che punta alla posizione dei dati. Questa tabella mostra entrambe le diverse posizioni di dati supportate da Azure Machine Learning ed esempi per il path parametro :

Posizione Esempio
Un percorso nel computer locale ./home/username/data/my_data
Percorso in un server HTTP pubblico https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv
Un percorso in Archiviazione di Azure https://<account_name>.blob.core.windows.net/<container_name>/<path>
abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
Percorso in un archivio dati azureml://datastores/<data_store_name>/paths/<path>
Percorso di un asset di dati azureml:<my_data>:<version>

Modalità supportate

Quando si esegue un processo con input/output di dati, è possibile specificare la modalità , ad esempio se i dati devono essere montati in sola lettura o scaricati nella destinazione di calcolo. Questa tabella mostra le modalità possibili per diverse combinazioni di tipo/modalità/input/output:

Tipo Input/Output upload download ro_mount rw_mount direct eval_download eval_mount
uri_folder Input ✓ ✓ ✓
uri_file Input ✓ ✓ ✓
mltable Input ✓ ✓ ✓ ✓ ✓
uri_folder Output ✓ ✓
uri_file Output ✓ ✓
mltable Output ✓ ✓ ✓

Nota

eval_download e eval_mount sono univoci per mltable. ro_mount è la modalità predefinita per MLTable. In alcuni scenari, tuttavia, un OGGETTO MLTable può restituire file che non si trovano necessariamente in condivisione con il file MLTable nell'archiviazione. In alternativa, un oggetto mltable può subset o shuffle i dati che si trovano nella risorsa di archiviazione. Tale visualizzazione diventa visibile solo se il motore valuta effettivamente il file MLTable. Queste modalità forniscono tale visualizzazione dei file.

Leggere i dati in un processo

Creare un file YAML di specifica del processo (<file-name>.yml). inputs Nella sezione del processo specificare:

  1. Oggetto type, indipendentemente dal fatto che i dati siano un file specifico (uri_file), un percorso della cartella (uri_folder) o un oggetto mltable.
  2. Della path posizione dei dati. Tutti i percorsi descritti nella sezione Percorsi supportati funzioneranno.
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

# Possible Paths for Data:
# Blob: https://<account_name>.blob.core.windows.net/<container_name>/<folder>/<file>
# Datastore: azureml://datastores/paths/<folder>/<file>
# Data Asset: azureml:<my_data>:<version>

command: |
  ls ${{inputs.my_data}}
code: <folder where code is located>
inputs:
  my_data:
    type: <type> # uri_file, uri_folder, mltable
    path: <path>
environment: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
compute: azureml:cpu-cluster

Eseguire quindi nell'interfaccia della riga di comando

az ml job create -f <file-name>.yml

Leggere gli asset di dati V1

Questa sezione illustra come leggere le entità di dati e TabularDataset V1 FileDataset in un processo V2.

Lettura di un oggetto FileDataset

Creare un file YAML della specifica del processo (<file-name>.yml), con il tipo impostato su mltable e la modalità impostata su eval_mount:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

command: |
  ls ${{inputs.my_data}}
code: <folder where code is located>
inputs:
  my_data:
    type: mltable
    mode: eval_mount
    path: azureml:<filedataset_name>@latest
environment: azureml:<environment_name>@latest
compute: azureml:cpu-cluster

Eseguire quindi nell'interfaccia della riga di comando

az ml job create -f <file-name>.yml

Lettura di un oggetto TabularDataset

Creare un file YAML della specifica del processo (<file-name>.yml), con il tipo impostato su mltable e la modalità impostata su direct:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

command: |
  ls ${{inputs.my_data}}
code: <folder where code is located>
inputs:
  my_data:
    type: mltable
    mode: direct
    path: azureml:<tabulardataset_name>@latest
environment: azureml:<environment_name>@latest
compute: azureml:cpu-cluster

Eseguire quindi nell'interfaccia della riga di comando

az ml job create -f <file-name>.yml

Scrivere dati in un processo

Nel processo è possibile scrivere dati nell'archiviazione basata sul cloud con output. La sezione Modalità supportate ha mostrato che solo gli output del processo possono scrivere dati, perché la modalità può essere rw_mount o upload.

Creare un file YAML della specifica del processo (<file-name>.yml), con la outputs sezione popolata con il tipo e il percorso in cui si vogliono scrivere i dati:

$schema: https://azuremlschemas.azureedge.net/latest/CommandJob.schema.json

# Possible Paths for Data:
# Blob: https://<account_name>.blob.core.windows.net/<container_name>/<folder>/<file>
# Datastore: azureml://datastores/paths/<folder>/<file>
# Data Asset: azureml:<my_data>:<version>

code: src
command: >-
  python prep.py 
  --raw_data ${{inputs.raw_data}} 
  --prep_data ${{outputs.prep_data}}
inputs:
  raw_data: 
    type: <type> # uri_file, uri_folder, mltable
    path: <path>
outputs:
  prep_data: 
    type: <type> # uri_file, uri_folder, mltable
    path: <path>
environment: azureml:<environment_name>@latest
compute: azureml:cpu-cluster

Creare quindi un processo con l'interfaccia della riga di comando:

az ml job create --file <file-name>.yml

Dati nelle pipeline

Se si muovono pipeline di Azure Machine Learning, è possibile leggere e spostare i dati tra i componenti della pipeline con l'estensione v2 dell'interfaccia della riga di comando di Azure Machine Learning o Python SDK v2.

Interfaccia della riga di comando di Azure Machine Learning v2

Questo file YAML illustra come usare i dati di output di un componente come input per un altro componente della pipeline, con l'estensione dell'interfaccia della riga di comando di Azure Machine Learning v2:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v2 (corrente)

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: 3b_pipeline_with_data
description: Pipeline with 3 component jobs with data dependencies

settings:
  default_compute: azureml:cpu-cluster

outputs:
  final_pipeline_output:
    mode: rw_mount

jobs:
  component_a:
    type: command
    component: ./componentA.yml
    inputs:
      component_a_input: 
        type: uri_folder
        path: ./data

    outputs:
      component_a_output: 
        mode: rw_mount
  component_b:
    type: command
    component: ./componentB.yml
    inputs:
      component_b_input: ${{parent.jobs.component_a.outputs.component_a_output}}
    outputs:
      component_b_output: 
        mode: rw_mount
  component_c:
    type: command
    component: ./componentC.yml
    inputs:
      component_c_input: ${{parent.jobs.component_b.outputs.component_b_output}}
    outputs:
      component_c_output: ${{parent.outputs.final_pipeline_output}}
      #  mode: upload

Python SDK v2

Questo esempio definisce una pipeline contenente tre nodi e sposta i dati tra ogni nodo.

  • prepare_data_node carica l'immagine e le etichette dal set di dati Fashion MNIST in mnist_train.csv e mnist_test.csv.
  • train_node esegue il training di un modello CNN con Keras usando i dati di mnist_train.csv training.
  • score_node assegna punteggi al modello usando mnist_test.csv i dati di test.
# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=fashion_ds)

Passaggi successivi