Run Classe

Adicione propriedades imutáveis à execução.

Tags e propriedades (ambas dict[str, str]) diferem em sua mutabilidade. As propriedades são imutáveis, por isso criam um registro permanente para fins de auditoria. As tags são mutáveis. Para obter mais informações sobre como trabalhar com tags e propriedades, consulte Marcar e localizar execuções.

add_properties(properties)

Parâmetros

Gancho de extensibilidade para tipos de execução personalizados armazenados no Histórico de execução.

static add_type_provider(runtype, run_factory)

Parâmetros

Marque a execução como cancelada.

Se houver um trabalho associado a um conjunto cancel_uri campo, encerre esse trabalho também.

cancel()

Crie uma corrida filho.

child_run(name=None, run_id=None, outputs=None)

Parâmetros

Devoluções

Observações

Isso é usado para isolar parte de uma corrida em uma subseção. Isso pode ser feito para "partes" identificáveis de uma execução que são interessantes para separar, ou para capturar métricas independentes através de uma interação de um subprocesso.

Se um diretório de saída for definido para a execução filho, o conteúdo desse diretório será carregado para o registro de execução filho quando o filho for concluído.

Remova os arquivos correspondentes à execução atual no destino especificado na configuração de execução.

clean()

Devoluções

Aguarde até que a fila de tarefas seja processada.

Em seguida, executar é marcado como concluído. Isso geralmente é usado em cenários de bloco de anotações interativo.

complete(_set_status=True)

Parâmetros

Crie uma ou várias execuções filhas.

create_children(count=None, tag_key=None, tag_values=None)

Parâmetros

Devoluções

Observações

O parâmetro count OU os parâmetros tag_key E tag_values devem ser especificados.

Transfira um ficheiro associado a partir do armazenamento.

download_file(name, output_file_path=None, _validate_checksum=False)

Parâmetros

Baixe arquivos de um determinado prefixo de armazenamento (nome da pasta) ou de todo o contêiner se o prefixo não for especificado.

download_files(prefix=None, output_directory=None, output_paths=None, batch_size=100, append_prefix=True, timeout_seconds=None)

Parâmetros

Marque a execução como falha.

Opcionalmente, defina a propriedade Error da execução com uma mensagem ou exceção passada para error_details.

fail(error_details=None, error_code=None, _set_status=True)

Parâmetros

Aguarde até que a fila de tarefas seja processada.

flush(timeout_seconds=300)

Parâmetros

Obtenha a execução para este espaço de trabalho com sua ID de execução.

static get(workspace, run_id)

Parâmetros

Devoluções

Baixe todos os logs para a execução em um diretório.

get_all_logs(destination=None)

Parâmetros

Devoluções

Obtenha todas as crianças para a execução atual selecionada por filtros especificados.

get_children(recursive=False, tags=None, properties=None, type=None, status=None, _rehydrate_runs=True)

Parâmetros

Devoluções

Retornar o contexto de serviço atual.

Use esse método para recuperar o contexto de serviço atual para registrar métricas e carregar arquivos. Se allow_offline for True (o padrão), as ações contra o objeto Run serão impressas como padrão.

get_context(allow_offline=True, used_for_context_manager=False, **kwargs)

Parâmetros

Devoluções

Observações

Essa função é comumente usada para recuperar o objeto Run autenticado dentro de um script a ser enviado para execução via experiment.submit(). Esse objeto de execução é um contexto autenticado para se comunicar com os serviços do Azure Machine Learning e um contêiner conceitual no qual métricas, arquivos (artefatos) e modelos estão contidos.

   run = Run.get_context() # allow_offline=True by default, so can be run locally as well
   ...
   run.log("Accuracy", 0.98)
   run.log_row("Performance", epoch=e, error=err)

Obtenha o status mais recente da execução. Se o status da execução for "Enfileirado", ele mostrará os detalhes.

get_detailed_status()

Devoluções

Observações

• status: o status atual da execução. O mesmo valor que o retornado de get_status().

• detalhes: As informações detalhadas para o status atual.

   run = experiment.submit(config)
   details = run.get_detailed_status()
   # details = {
   #     'status': 'Queued',
   #     'details': 'Run requested 1 node(s). Run is in pending status.',
   # }

Obtenha a definição, informações de status, arquivos de log atuais e outros detalhes da execução.

get_details()

Devoluções

Observações

O dicionário retornado contém os seguintes pares chave-valor:

• runId: ID desta execução.

• alvo

• status: o status atual da execução. O mesmo valor que o retornado de get_status().

• startTimeUtc: Hora UTC de quando esta execução foi iniciada, em ISO8601.

• endTimeUtc: Hora UTC de quando esta execução foi concluída (Concluída ou Reprovada), em ISO8601.

  Essa chave não existe se a execução ainda estiver em andamento.

• propriedades: pares chave-valor imutáveis associados à execução. As propriedades padrão incluem o ID de instantâneo da execução e informações sobre o repositório git a partir do qual a execução foi criada (se houver). Propriedades adicionais podem ser adicionadas a uma execução usando add_propertieso .

• inputDatasets: conjuntos de dados de entrada associados à execução.

• outputDatasets: Conjuntos de dados de saída associados à execução.

• arquivos de log

• enviadoPor

   run = experiment.start_logging()

   details = run.get_details()
   # details = {
   #     'runId': '5c24aa28-6e4a-4572-96a0-fb522d26fe2d',
   #     'target': 'sdk',
   #     'status': 'Running',
   #     'startTimeUtc': '2019-01-01T13:08:01.713777Z',
   #     'endTimeUtc': '2019-01-01T17:15:65.986253Z',
   #     'properties': {
   #         'azureml.git.repository_uri': 'https://example.com/my/git/repo',
   #         'azureml.git.branch': 'master',
   #         'azureml.git.commit': '7dc972657c2168927a02c3bc2b161e0f370365d7',
   #         'azureml.git.dirty': 'True',
   #         'mlflow.source.git.repoURL': 'https://example.com/my/git/repo',
   #         'mlflow.source.git.branch': 'master',
   #         'mlflow.source.git.commit': '7dc972657c2168927a02c3bc2b161e0f370365d7',
   #         'ContentSnapshotId': 'b4689489-ce2f-4db5-b6d7-6ad11e77079c'
   #     },
   #     'inputDatasets': [{
   #         'dataset': {'id': 'cdebf245-701d-4a68-8055-41f9cf44f298'},
   #         'consumptionDetails': {
   #             'type': 'RunInput',
   #             'inputName': 'training-data',
   #             'mechanism': 'Mount',
   #             'pathOnCompute': '/mnt/datasets/train'
   #         }
   #     }],
   #     'outputDatasets': [{
   #         'dataset': {'id': 'd04e8a19-1caa-4b1f-b318-4cbff9af9615'},
   #         'outputType': 'RunOutput',
   #         'outputDetails': {
   #             'outputName': 'training-result'
   #         }
   #     }],
   #     'runDefinition': {},
   #     'logFiles': {},
   #     'submittedBy': 'Alan Turing'
   # }

Retornar o status da execução, incluindo o conteúdo do arquivo de log.

get_details_with_logs()

Devoluções

Obtenha a definição de ambiente que foi usada por esta execução.

get_environment()

Devoluções

Liste os arquivos armazenados em associação com a execução.

get_file_names()

Devoluções

Recupere as métricas registradas na execução.

Se recursive for True (False por padrão), busque métricas para execuções na subárvore de determinada execução.

get_metrics(name=None, recursive=False, run_type=None, populate=False)

Parâmetros

Devoluções

Observações

   run = experiment.start_logging() # run id: 123
   run.log("A", 1)
   with run.child_run() as child: # run id: 456
       child.log("A", 2)

   metrics = run.get_metrics()
   # metrics = { 'A': 1 }

   metrics = run.get_metrics(recursive=True)
   # metrics = { '123': { 'A': 1 }, '456': { 'A': 2 } } note key is runId

Buscar as propriedades mais recentes da execução do serviço.

get_properties()

Devoluções

Observações

As propriedades são informações imutáveis geradas pelo sistema, como duração, data de execução, usuário e propriedades personalizadas adicionadas com o add_properties método. Para obter mais informações, consulte Marcar e localizar execuções.

Ao enviar um trabalho para o Aprendizado de Máquina do Azure, se os arquivos de origem forem armazenados em um repositório git local, as informações sobre o repositório serão armazenadas como propriedades. Essas propriedades git são adicionadas ao criar uma execução ou chamar Experiment.submit. Para obter mais informações sobre propriedades do git, consulte Integração do Git para o Azure Machine Learning.

Obtenha o valor secreto do contexto de uma execução.

Obtenha o valor secreto para o nome fornecido. O nome secreto faz referência a um valor armazenado no Cofre da Chave do Azure associado ao seu espaço de trabalho. Para obter um exemplo de como trabalhar com segredos, consulte Usar segredos em execuções de treinamento.

get_secret(name)

Parâmetros

Devoluções

Obtenha os valores secretos para uma determinada lista de nomes secretos.

Obtenha um dicionário de segredos encontrados e não encontrados para a lista de nomes fornecidos. Cada nome secreto faz referência a um valor armazenado no Cofre da Chave do Azure associado ao seu espaço de trabalho. Para obter um exemplo de como trabalhar com segredos, consulte Usar segredos em execuções de treinamento.

get_secrets(secrets)

Parâmetros

Devoluções

Obtenha o ID de instantâneo mais recente.

get_snapshot_id()

Devoluções

Obtenha o status mais recente da execução.

Os valores comuns retornados incluem "Em execução", "Concluído" e "Falha".

get_status()

Devoluções

Observações

• NotStarted - Este é um estado temporário em que os objetos Run do lado do cliente estão antes do envio da nuvem.

• Iniciando - A execução começou a ser processada na nuvem. O chamador tem um ID de execução neste momento.

• Provisionamento - Retornado quando a computação sob demanda está sendo criada para um determinado envio de trabalho.

• Preparação - O ambiente de corrida está sendo preparado:

  • Compilação de imagem do Docker

  • Configuração do ambiente Conda

• Enfileirado - O trabalho é enfileirado no destino de computação. Por exemplo, no BatchAI o trabalho está em estado de fila

  enquanto aguarda que todos os nós solicitados estejam prontos.

• Em execução - O trabalho começou a ser executado no destino de computação.

• Finalização - O código do usuário foi concluído e a execução está em estágios de pós-processamento.

• CancelRequested - Foi solicitado o cancelamento para o trabalho.

• Concluído - A execução foi concluída com êxito. Isso inclui o código do usuário e executar

  fases de pós-processamento.

• Falha - A execução falhou. Normalmente, a propriedade Error em uma execução fornecerá detalhes sobre o motivo.

• Cancelado - Segue uma solicitação de cancelamento e indica que a execução foi cancelada com êxito.

• NotResponding - Para execuções com Heartbeats ativado, nenhum heartbeat foi enviado recentemente.

   run = experiment.submit(config)
   while run.get_status() not in ['Completed', 'Failed']: # For example purposes only, not exhaustive
       print('Run {} not in terminal state'.format(run.id))
       time.sleep(10)

PRETERIDO. Utilize get_context.

Obtenha a execução enviada para este experimento.

get_submitted_run(**kwargs)

Devoluções

Buscar o conjunto mais recente de tags mutáveis em execução do serviço.

get_tags()

Devoluções

Obtenha uma lista de execuções em um experimento especificado por filtros opcionais.

static list(experiment, type=None, tags=None, properties=None, status=None, include_children=False, _rehydrate_runs=True)

Parâmetros

Devoluções

Observações

O exemplo de código a seguir mostra alguns usos do list método.

   favorite_completed_runs = Run.list(experiment, status='Completed', tags='favorite')

   all_distinct_runs = Run.list(experiment)
   and_their_children = Run.list(experiment, include_children=True)

   only_script_runs = Run.list(experiment, type=ScriptRun.RUN_TYPE)

Obtenha uma lista de execuções em uma computação especificada por filtros opcionais.

static list_by_compute(compute, type=None, tags=None, properties=None, status=None)

Parâmetros

Devoluções

Registre um valor de métrica na execução com o nome fornecido.

log(name, value, description='', step=None)

Parâmetros

Observações

O registro de uma métrica em uma execução faz com que essa métrica seja armazenada no registro de execução no experimento. Você pode registrar a mesma métrica várias vezes em uma execução, sendo o resultado considerado um vetor dessa métrica. Se a etapa for especificada para uma métrica, ela deverá ser especificada para todos os valores.

Registre uma tabela de precisão no repositório de artefatos.

A métrica da tabela de precisão é uma métrica multiuso, não escalar, que pode ser usada para produzir vários tipos de gráficos de linhas que variam continuamente no espaço de probabilidades previstas. Exemplos desses gráficos são ROC, precisão de recordação e curvas de elevação.

O cálculo da tabela de precisão é semelhante ao cálculo de uma curva ROC. Uma curva ROC armazena taxas de verdadeiros positivos e taxas de falsos positivos em muitos limiares de probabilidade diferentes. A tabela de precisão armazena o número bruto de verdadeiros positivos, falsos positivos, verdadeiros negativos e falsos negativos em muitos limiares de probabilidade.

Existem dois métodos usados para selecionar limites: "probabilidade" e "percentil". Eles diferem em como eles amostram do espaço de probabilidades previstas.

Os limiares de probabilidade são limiares uniformemente espaçados entre 0 e 1. Se NUM_POINTS for 5, os limiares de probabilidade seriam [0,0, 0,25, 0,5, 0,75, 1,0].

Os limiares de percentis são espaçados de acordo com a distribuição das probabilidades previstas. Cada limiar corresponde ao percentil dos dados num limiar de probabilidade. Por exemplo, se NUM_POINTS é 5, então o primeiro limiar seria no percentil 0, o segundo no percentil 25, o terceiro no percentil 50, e assim por diante.

As tabelas de probabilidade e tabelas de percentis são ambas listas 3D onde a primeira dimensão representa o rótulo da classe, a segunda dimensão representa a amostra em um limiar (escalas com NUM_POINTS), e a terceira dimensão sempre tem 4 valores: TP, FP, TN, FN, e sempre nessa ordem.

Os valores de confusão (TP, FP, TN, FN) são calculados com a estratégia one vs. rest. Consulte o link a seguir para obter mais detalhes: https://en.wikipedia.org/wiki/Multiclass_classification

N = # de amostras no conjunto de dados de validação (200 no exemplo) M = # limiares = # amostras retiradas do espaço de probabilidade (5 no exemplo) C = # classes no conjunto de dados completo (3 no exemplo)

Algumas invariantes da tabela de precisão:

• TP + FP + TN + FN = N para todos os limiares para todas as classes
• TP + FN é o mesmo em todos os limiares para qualquer classe
• TN + FP é o mesmo em todos os limiares para qualquer classe
• As tabelas de probabilidade e as tabelas de percentis têm forma [C, M, 4]

Nota: M pode ser qualquer valor e controla a resolução dos gráficos Isso é independente do conjunto de dados, é definido ao calcular métricas e compensa o espaço de armazenamento, o tempo de computação e a resolução.

Os rótulos de classe devem ser cadeias de caracteres, os valores de confusão devem ser inteiros e os limites devem ser flutuantes.

log_accuracy_table(name, value, description='')

Parâmetros

Observações

Exemplo de um valor JSON válido:

   {
       "schema_type": "accuracy_table",
       "schema_version": "1.0.1",
       "data": {
           "probability_tables": [
               [
                   [82, 118, 0, 0],
                   [75, 31, 87, 7],
                   [66, 9, 109, 16],
                   [46, 2, 116, 36],
                   [0, 0, 118, 82]
               ],
               [
                   [60, 140, 0, 0],
                   [56, 20, 120, 4],
                   [47, 4, 136, 13],
                   [28, 0, 140, 32],
                   [0, 0, 140, 60]
               ],
               [
                   [58, 142, 0, 0],
                   [53, 29, 113, 5],
                   [40, 10, 132, 18],
                   [24, 1, 141, 34],
                   [0, 0, 142, 58]
               ]
           ],
           "percentile_tables": [
               [
                   [82, 118, 0, 0],
                   [82, 67, 51, 0],
                   [75, 26, 92, 7],
                   [48, 3, 115, 34],
                   [3, 0, 118, 79]
               ],
               [
                   [60, 140, 0, 0],
                   [60, 89, 51, 0],
                   [60, 41, 99, 0],
                   [46, 5, 135, 14],
                   [3, 0, 140, 57]
               ],
               [
                   [58, 142, 0, 0],
                   [56, 93, 49, 2],
                   [54, 47, 95, 4],
                   [41, 10, 132, 17],
                   [3, 0, 142, 55]
               ]
           ],
           "probability_thresholds": [0.0, 0.25, 0.5, 0.75, 1.0],
           "percentile_thresholds": [0.0, 0.01, 0.24, 0.98, 1.0],
           "class_labels": ["0", "1", "2"]
       }
   }

Registre uma matriz de confusão no repositório de artefatos.

Isso registra um invólucro em torno da matriz de confusão do sklearn. Os dados da métrica contêm os rótulos de classe e uma lista 2D para a própria matriz. Consulte o link a seguir para obter mais detalhes sobre como a métrica é calculada: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html

log_confusion_matrix(name, value, description='')

Parâmetros

Observações

Exemplo de um valor JSON válido:

   {
       "schema_type": "confusion_matrix",
       "schema_version": "1.0.0",
       "data": {
           "class_labels": ["0", "1", "2", "3"],
           "matrix": [
               [3, 0, 1, 0],
               [0, 1, 0, 1],
               [0, 0, 1, 0],
               [0, 0, 0, 1]
           ]
       }
   }

Registre uma métrica de imagem no registro de execução.

log_image(name, path=None, plot=None, description='')

Parâmetros

Observações

Use esse método para registrar um arquivo de imagem ou um gráfico matplotlib para a execução. Estas imagens serão visíveis e comparáveis no registo de execução.

Registre uma lista de valores de métrica na execução com o nome fornecido.

log_list(name, value, description='')

Parâmetros

Registre previsões no repositório de artefatos.

Isso registra uma pontuação métrica que pode ser usada para comparar as distribuições de valores de destino verdadeiros com a distribuição de valores previstos para uma tarefa de regressão.

As previsões são vinculadas e os desvios-padrão são calculados para barras de erro em um gráfico de linhas.

log_predictions(name, value, description='')

Parâmetros

Observações

Exemplo de um valor JSON válido:

   {
       "schema_type": "predictions",
       "schema_version": "1.0.0",
       "data": {
           "bin_averages": [0.25, 0.75],
           "bin_errors": [0.013, 0.042],
           "bin_counts": [56, 34],
           "bin_edges": [0.0, 0.5, 1.0]
       }
   }

Registre resíduos no repositório de artefatos.

Isso registra os dados necessários para exibir um histograma de resíduos para uma tarefa de regressão. Os resíduos são previstos - real.

Deve haver uma aresta a mais do que o número de contagens. Consulte a documentação do histograma numpy para obter exemplos de uso de contagens e bordas para representar um histograma. https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html

log_residuals(name, value, description='')

Parâmetros

Observações

Exemplo de um valor JSON válido:

   {
       "schema_type": "residuals",
       "schema_version": "1.0.0",
       "data": {
           "bin_edges": [50, 100, 200, 300, 350],
           "bin_counts": [0.88, 20, 30, 50.99]
       }
   }

Registre uma métrica de linha na execução com o nome fornecido.

log_row(name, description=None, **kwargs)

Parâmetros

Observações

Usar log_row cria uma métrica de tabela com colunas conforme descrito em kwargs. Cada parâmetro nomeado gera uma coluna com o valor especificado. log_row pode ser chamado uma vez para registrar uma tupla arbitrária, ou várias vezes em um loop para gerar uma tabela completa.

   citrus = ['orange', 'lemon', 'lime']
   sizes = [ 10, 7, 3]
   for index in range(len(citrus)):
       run.log_row("citrus", fruit = citrus[index], size=sizes[index])

Registre uma métrica de tabela na execução com o nome fornecido.

log_table(name, value, description='')

Parâmetros

Cadastrar um modelo para operacionalização.

register_model(model_name, model_path=None, tags=None, properties=None, model_framework=None, model_framework_version=None, description=None, datasets=None, sample_input_dataset=None, sample_output_dataset=None, resource_configuration=None, **kwargs)

Parâmetros

Devoluções

Observações

   model = best_run.register_model(model_name = 'best_model', model_path = 'outputs/model.pkl')

Exclua a lista de tags mutáveis nesta execução.

remove_tags(tags)

Parâmetros

Devoluções

Restaure um instantâneo como um arquivo ZIP. Retorna o caminho para o ZIP.

restore_snapshot(snapshot_id=None, path=None)

Parâmetros

Devoluções

Adicione ou modifique um conjunto de tags na execução. As tags não passadas no dicionário são deixadas intocadas.

Você também pode adicionar tags de cadeia de caracteres simples. Quando essas tags aparecem no dicionário de tags como chaves, elas têm um valor de Nenhum. Para obter mais informações, consulte Marcar e localizar execuções.

set_tags(tags)

Parâmetros

Marque a execução como iniciada.

Isso geralmente é usado em cenários avançados quando a execução foi criada por outro ator.

start()

Envie um experimento e retorne a execução filho ativa.

submit_child(config, tags=None, **kwargs)

Parâmetros

Devoluções

Observações

Enviar é uma chamada assíncrona para a plataforma Azure Machine Learning para executar uma avaliação em hardware local ou remoto. Dependendo da configuração, o envio preparará automaticamente seus ambientes de execução, executará seu código e capturará seu código-fonte e resultados no histórico de execução do experimento.

Para enviar um experimento, primeiro você precisa criar um objeto de configuração descrevendo como o experimento deve ser executado. A configuração depende do tipo de avaliação necessária.

Um exemplo de como enviar um experimento filho de sua máquina local usando ScriptRunConfig é o seguinte:

   from azureml.core import ScriptRunConfig

   # run a trial from the train.py code in your current directory
   config = ScriptRunConfig(source_directory='.', script='train.py',
       run_config=RunConfiguration())
   run = parent_run.submit_child(config)

   # get the url to view the progress of the experiment and then wait
   # until the trial is complete
   print(run.get_portal_url())
   run.wait_for_completion()

Para obter detalhes sobre como configurar uma execução, consulte submit.

Marque a execução com uma chave de cadeia de caracteres e um valor de cadeia de caracteres opcional.

tag(key, value=None)

Parâmetros

Observações

Tags e propriedades em uma execução são dicionários de string -> string. A diferença entre eles é a mutabilidade: as tags podem ser definidas, atualizadas e excluídas, enquanto as propriedades só podem ser adicionadas. Isso torna as Propriedades mais apropriadas para gatilhos de comportamento relacionados ao sistema/fluxo de trabalho, enquanto as Tags geralmente são voltadas para o usuário e significativas para os consumidores do experimento.

   run = experiment.start_logging()
   run.tag('DeploymentCandidate')
   run.tag('modifiedBy', 'Master CI')
   run.tag('modifiedBy', 'release pipeline') # Careful, tags are mutable

   run.add_properties({'BuildId': os.environ.get('VSTS_BUILD_ID')}) # Properties are not

   tags = run.get_tags()
   # tags = { 'DeploymentCandidate': None, 'modifiedBy': 'release pipeline' }

Salve um instantâneo do arquivo ou pasta de entrada.

take_snapshot(file_or_folder_path)

Parâmetros

Devoluções

Observações

Os instantâneos destinam-se a ser o código-fonte usado para executar a execução do experimento. Eles são armazenados com a execução para que a avaliação de execução possa ser replicada no futuro.

Carregue um arquivo para o registro de execução.

upload_file(name, path_or_stream, datastore_name=None)

Parâmetros

Devoluções

Observações

   run = experiment.start_logging()
   run.upload_file(name='important_file', path_or_stream="path/on/disk/file.txt")

Carregue arquivos para o registro de execução.

upload_files(names, paths, return_artifacts=False, timeout_seconds=None, datastore_name=None)

Parâmetros

Observações

upload_files tem o mesmo efeito que upload_file em arquivos separados, no entanto, há benefícios de desempenho e utilização de recursos ao usar upload_fileso .

   import os

   run = experiment.start_logging()
   file_name_1 = 'important_file_1'
   file_name_2 = 'important_file_2'
   run.upload_files(names=[file_name_1, file_name_2],
                       paths=['path/on/disk/file_1.txt', 'other/path/on/disk/file_2.txt'])

   run.download_file(file_name_1, 'file_1.txt')

   os.mkdir("path")  # The path must exist
   run.download_file(file_name_2, 'path/file_2.txt')

Carregue a pasta especificada para o nome do prefixo fornecido.

upload_folder(name, path, datastore_name=None)

Parâmetros

Observações

   run = experiment.start_logging()
   run.upload_folder(name='important_files', path='path/on/disk')

   run.download_file('important_files/existing_file.txt', 'local_file.txt')

Aguarde a conclusão desta execução. Retorna o objeto de status após a espera.

wait_for_completion(show_output=False, wait_post_processing=False, raise_on_error=True)

Parâmetros

Devoluções

Retornar a descrição da execução.

A descrição opcional da execução é uma cadeia de caracteres especificada pelo usuário útil para descrever uma execução.

Devoluções

Retorne o nome de exibição da execução.

O nome de exibição opcional da execução é uma cadeia de caracteres especificada pelo usuário útil para a identificação posterior da execução.

Devoluções

Obtenha um experimento contendo a corrida.

Devoluções

Obtenha o ID de execução.

O ID da execução é um identificador exclusivo em todo o experimento que contém.

Devoluções

PRETERIDO. Use display_name.

O nome opcional da execução é uma cadeia de caracteres especificada pelo usuário útil para a identificação posterior da execução.

Devoluções

Obter número de execução.

Um número monotonicamente crescente que representa a ordem das execuções dentro de um experimento.

Devoluções

Buscar a execução pai para esta execução do serviço.

As execuções podem ter um pai opcional, resultando em uma hierarquia de árvore potencial de execuções. Para registrar métricas em uma execução pai, use o log método do objeto pai, por exemplo, run.parent.log().

Devoluções

Retornar as propriedades imutáveis desta execução.

Devoluções

Observações

As propriedades incluem informações imutáveis geradas pelo sistema, como duração, data de execução, usuário, etc.

Retorne o status do objeto run.

Retorne o conjunto de tags mutáveis nesta execução.

Devoluções

Obter tipo de execução.

Indica como a execução foi criada ou configurada.

Devoluções