O que é o SDK do Azure Machine Learning v1 para Python?
Importante
Este artigo é sobre o SDK do Azure Machine Learning v1, que não é o SDK atual. A versão atual do SDK é a do SDK do Python do Azure Machine Learning v2. Para obter informações sobre as diferenças entre as versões do SDK, leia Atualizar para ov2.
Cientistas de dados e desenvolvedores de IA usam o SDK do Azure Machine Learning v1 para Python para criar e executar fluxos de trabalho de aprendizado de máquina com o serviço do Azure Machine Learning. Você pode interagir com o serviço em qualquer ambiente do Python, incluindo Jupyter Notebooks, do Visual Studio Code ou seu IDE do Python favorito.
As principais áreas do SDK incluem:
- Explore, prepare e gerencie o ciclo de vida de seus conjuntos de dados usados em experimentos de machine learning.
- Gerencie recursos de nuvem para monitorar, registrar em log e organizar seus experimentos de machine learning.
- Treine modelos localmente ou usando recursos de nuvem, incluindo treinamento de modelo acelerado por GPU.
- Use o machine learning automatizado, que aceita parâmetros de configuração e dados de treinamento. Ele itera automaticamente por meio de algoritmos e configurações de hiperparâmetro para encontrar o melhor modelo para executar previsões.
- Implante serviços Web para converter seus modelos treinados em serviços RESTful que podem ser consumidos em qualquer aplicativo.
Para obter um passo a passo passo de como começar, experimente o tutorial .
As seções a seguir são visões gerais de algumas das classes mais importantes do SDK e padrões de design comuns para usá-las. Para obter o SDK, consulte o guia de instalação .
Estável versus experimental
O SDK do Azure Machine Learning para Python fornece recursos estáveis e experimentais no mesmo SDK.
Status do recurso/funcionalidade | Descrição |
---|---|
Recursos estáveis |
produção pronta Esses recursos são recomendados para a maioria dos casos de uso e ambientes de produção. Eles são atualizados com menos frequência do que os recursos experimentais. |
Recursos experimentais |
de desenvolvimento Esses recursos são recursos recém-desenvolvidos & atualizações que podem não estar prontas ou totalmente testadas para uso em produção. Embora os recursos normalmente estejam funcionais, eles podem incluir algumas alterações interruptivas. Os recursos experimentais são usados para resolver bugs de falha do SDK e receberão apenas atualizações durante o período de teste. Os recursos experimentais também são conhecidos como recursos que estão em versão prévia. Como o nome indica, os recursos experimentais (versão prévia) são para experimentos e não são consideradossem bugs ou estáveis. Por esse motivo, recomendamos apenas recursos experimentais para usuários avançados que desejam experimentar versões iniciais de funcionalidades e atualizações e pretendemos participar do relatório de bugs e falhas. |
Os recursos experimentais são rotulados por uma seção de observação na referência do SDK e indicados por texto, como (versão prévia) em toda documentação do Azure Machine Learning.
Área de trabalho
do namespace
A classe Workspace
é um recurso fundamental na nuvem que você usa para experimentar, treinar e implantar modelos de machine learning. Ele vincula sua assinatura do Azure e o grupo de recursos a um objeto facilmente consumido.
Exiba todos os parâmetros do método create Workspace para reutilizar instâncias existentes (Storage, Key Vault, App-Insights e Azure Container Registry-ACR), bem como modificar configurações adicionais, como configuração de ponto de extremidade privado e destino de computação.
Importe a classe e crie um novo workspace usando o código a seguir. Defina create_resource_group
para False
se você tiver um grupo de recursos do Azure existente anteriormente que deseja usar para o workspace. Algumas funções podem solicitar credenciais de autenticação do Azure.
from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
subscription_id='<azure-subscription-id>',
resource_group='myresourcegroup',
create_resource_group=True,
location='eastus2'
)
Use o mesmo workspace em vários ambientes primeiro gravando-o em um arquivo JSON de configuração. Isso salva seus dados de nome de assinatura, recurso e workspace.
ws.write_config(path="./file-path", file_name="ws_config.json")
Carregue seu workspace lendo o arquivo de configuração.
from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")
Como alternativa, use o método de get()
estático para carregar um workspace existente sem usar arquivos de configuração.
from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')
A variável ws
representa um objeto Workspace
nos exemplos de código a seguir.
Experimentar
do namespace
A classe Experiment
é outro recurso de nuvem fundamental que representa uma coleção de avaliações (execuções de modelo individuais). O código a seguir busca um objeto Experiment
de dentro de Workspace
por nome ou cria um novo objeto Experiment
se o nome não existir.
from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')
Execute o código a seguir para obter uma lista de todos os objetos Experiment
contidos no Workspace
.
list_experiments = Experiment.list(ws)
Use a função get_runs
para recuperar uma lista de objetos Run
(avaliações) de Experiment
. O código a seguir recupera as execuções e imprime cada ID de execução.
list_runs = experiment.get_runs()
for run in list_runs:
print(run.id)
Há duas maneiras de executar uma avaliação de experimento. Se você estiver experimentando interativamente em um jupyter notebook, use a função start_logging
. Se você estiver enviando um experimento de um ambiente python padrão, use a função submit
. Ambas as funções retornam um objeto Run
. A variável experiment
representa um objeto Experiment
nos exemplos de código a seguir.
Correr
do namespace
Uma execução representa uma única avaliação de um experimento.
Run
é o objeto que você usa para monitorar a execução assíncrona de uma avaliação, armazenar a saída da avaliação, analisar resultados e acessar artefatos gerados. Você usa Run
dentro do código de experimentação para registrar métricas e artefatos no serviço De Histórico de Execuções. A funcionalidade inclui:
- Armazenando e recuperando métricas e dados.
- Usando marcas e a hierarquia filho para facilitar a pesquisa de execuções passadas.
- Registrando arquivos de modelo armazenados para implantação.
- Armazenando, modificando e recuperando propriedades de uma execução.
Crie um objeto Run
enviando um objeto Experiment
com um objeto de configuração de execução objeto. Use o parâmetro tags
para anexar categorias e rótulos personalizados às suas execuções. Você pode encontrá-los e recuperá-los mais tarde de Experiment
.
tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)
Use a função list
estática para obter uma lista de todos os objetos Run
de Experiment
. Especifique o parâmetro tags
a ser filtrado pela marca criada anteriormente.
from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)
Use a função get_details
para recuperar a saída detalhada da execução.
run_details = run.get_details()
A saída para essa função é um dicionário que inclui:
- Executar ID
- Estado
- Hora de início e término
- Destino de computação (local versus nuvem)
- Dependências e versões usadas na execução
- Dados específicos do treinamento (diferem dependendo do tipo de modelo)
Para obter mais exemplos de como configurar e monitorar execuções, consulte o de instruções.
Modelo
do namespace
A classe Model
é usada para trabalhar com representações em nuvem de modelos de machine learning. Os métodos ajudam você a transferir modelos entre ambientes de desenvolvimento locais e o objeto Workspace
na nuvem.
Você pode usar o registro de modelo para armazenar e versão de seus modelos na nuvem do Azure, em seu workspace. Os modelos registrados são identificados por nome e versão. Cada vez que você registra um modelo com o mesmo nome de um existente, o Registro incrementa a versão. O Azure Machine Learning dá suporte a qualquer modelo que possa ser carregado por meio do Python 3, não apenas dos modelos do Azure Machine Learning.
O exemplo a seguir mostra como criar um modelo de classificação local simples com scikit-learn
, registrar o modelo em Workspace
e baixar o modelo da nuvem.
Crie um classificador simples, clf
, para prever a variação do cliente com base em sua idade. Em seguida, despeje o modelo em um arquivo .pkl
no mesmo diretório.
from sklearn import svm
import joblib
import numpy as np
# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]
clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)
joblib.dump(value=clf, filename="churn-model.pkl")
Use a função register
para registrar o modelo em seu workspace. Especifique o caminho do modelo local e o nome do modelo. Registrar o mesmo nome mais de uma vez criará uma nova versão.
from azureml.core.model import Model
model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")
Agora que o modelo está registrado em seu workspace, é fácil gerenciar, baixar e organizar seus modelos. Para recuperar um objeto modelo (por exemplo, em outro ambiente) de Workspace
, use o construtor de classe e especifique o nome do modelo e quaisquer parâmetros opcionais. Em seguida, use a função download
para baixar o modelo, incluindo a estrutura de pastas de nuvem.
from azureml.core.model import Model
import os
model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())
Use a função delete
para remover o modelo do Workspace
.
model.delete()
Depois de ter um modelo registrado, implantá-lo como um serviço Web é um processo simples. Primeiro, você criar e registrar uma imagem. Esta etapa configura o ambiente do Python e suas dependências, juntamente com um script para definir os formatos de solicitação e resposta do serviço Web. Depois de criar uma imagem, você criar uma configuração de implantação que define os núcleos de CPU e os parâmetros de memória para o destino de computação. Em seguida, você anexa sua imagem.
ComputeTarget, RunConfiguration e ScriptRunConfig
do namespace
A classe ComputeTarget
é a classe pai abstrata para criar e gerenciar destinos de computação. Um destino de computação representa uma variedade de recursos em que você pode treinar seus modelos de machine learning. Um destino de computação pode ser um computador local ou um recurso de nuvem, como a Computação do Azure Machine Learning, o Azure HDInsight ou uma máquina virtual remota.
Use destinos de computação para aproveitar máquinas virtuais avançadas para treinamento de modelo e configure destinos de computação persistentes ou destinos temporários invocados por runtime. Para obter um guia abrangente sobre como configurar e gerenciar destinos de computação, consulte o de instruções.
O código a seguir mostra um exemplo simples de configuração de um destino de AmlCompute
(classe filho de ComputeTarget
). Esse destino cria um recurso de computação remota de runtime em seu objeto Workspace
. O recurso é dimensionado automaticamente quando um trabalho é enviado. Ele é excluído automaticamente quando a execução é concluída.
Reutilize o modelo de variação de scikit-learn
simples e compile-o em seu próprio arquivo, train.py
, no diretório atual. No final do arquivo, crie um novo diretório chamado outputs
. Esta etapa cria um diretório na nuvem (seu workspace) para armazenar seu modelo treinado que joblib.dump()
serializado.
# train.py
from sklearn import svm
import numpy as np
import joblib
import os
# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]
clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)
os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")
Em seguida, você cria o destino de computação criando uma instância de um objeto RunConfiguration
e definindo o tipo e o tamanho. Este exemplo usa o menor tamanho de recurso (1 núcleo de CPU, 3,5 GB de memória). A variável list_vms
contém uma lista de máquinas virtuais com suporte e seus tamanhos.
from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)
compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"
Crie dependências para o ambiente Python do recurso de computação remota usando a classe CondaDependencies
. O arquivo train.py
está usando scikit-learn
e numpy
, que precisam ser instalados no ambiente. Você também pode especificar versões de dependências. Use o objeto dependencies
para definir o ambiente em compute_config
.
from azureml.core.conda_dependencies import CondaDependencies
dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies
Agora você está pronto para enviar o experimento. Use a classe ScriptRunConfig
para anexar a configuração de destino de computação e especificar o caminho/arquivo para o script de treinamento train.py
. Envie o experimento especificando o parâmetro config
da função submit()
. Chame wait_for_completion
na execução resultante para ver a saída de execução assíncrona à medida que o ambiente é inicializado e o modelo é treinado.
Aviso
Veja a seguir as limitações em torno de caracteres específicos quando usados em parâmetros de ScriptRunConfig
:
- Os caracteres
"
,$
,;
e\
são escapados pelo back-end, pois são considerados caracteres reservados para separar comandos bash. - Os caracteres
(
,)
,%
,!
,^
,<
,>
,&
e|
são escapados para execuções locais no Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig
script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)
Após a conclusão da execução, o arquivo de modelo treinado churn-model.pkl
estará disponível em seu workspace.
Ambiente
do namespace
Os ambientes do Azure Machine Learning especificam os pacotes do Python, as variáveis de ambiente e as configurações de software em torno de seus scripts de treinamento e pontuação. Além do Python, você também pode configurar o PySpark, o Docker e o R para ambientes. Internamente, os ambientes resultam em imagens do Docker usadas para executar os processos de treinamento e pontuação no destino de computação. Os ambientes são entidades gerenciadas e com controle de versão em seu workspace do Machine Learning que permitem fluxos de trabalho de aprendizado de máquina reproduzíveis, auditáveis e portáteis em uma variedade de destinos de computação e tipos de computação.
Você pode usar um objeto Environment
para:
- Desenvolva seu script de treinamento.
- Reutilize o mesmo ambiente na Computação do Azure Machine Learning para treinamento de modelo em escala.
- Implante seu modelo com esse mesmo ambiente sem estar vinculado a um tipo de computação específico.
O código a seguir importa a classe Environment
do SDK e instancia um objeto de ambiente.
from azureml.core.environment import Environment
Environment(name="myenv")
Adicione pacotes a um ambiente usando arquivos conda, pip ou roda privada. Especifique cada dependência de pacote usando a classe CondaDependency
para adicioná-la à PythonSection
do ambiente.
O exemplo a seguir adiciona ao ambiente. Ele adiciona a versão 1.17.0 do numpy
. Ele também adiciona o pacote pillow
ao ambiente, myenv
. O exemplo usa o método add_conda_package()
e o método add_pip_package()
, respectivamente.
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
myenv = Environment(name="myenv")
conda_dep = CondaDependencies()
# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")
# Installs pillow package
conda_dep.add_pip_package("pillow")
# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep
Para enviar uma execução de treinamento, você precisa combinar seu ambiente, destino de computaçãoe seu script Python de treinamento em uma configuração de execução. Essa configuração é um objeto wrapper usado para enviar execuções.
Quando você envia uma execução de treinamento, a criação de um novo ambiente pode levar vários minutos. A duração depende do tamanho das dependências necessárias. Os ambientes são armazenados em cache pelo serviço. Portanto, enquanto a definição de ambiente permanecer inalterada, você incorrerá no tempo de instalação completo apenas uma vez.
O exemplo a seguir mostra onde você usaria ScriptRunConfig
como objeto wrapper.
from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment
exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")
# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")
# Attach compute target to run config
runconfig.run_config.target = "local"
# Attach environment to run config
runconfig.run_config.environment = myenv
# Submit run
run = exp.submit(runconfig)
Se você não especificar um ambiente em sua configuração de execução antes de enviar a execução, um ambiente padrão será criado para você.
Consulte a seção Model deploy para usar ambientes para implantar um serviço Web.
Pipeline, PythonScriptStep
do namespace
Um pipeline do Azure Machine Learning é um fluxo de trabalho automatizado de uma tarefa completa de machine learning. As subtarefas são encapsuladas como uma série de etapas dentro do pipeline. Um pipeline do Azure Machine Learning pode ser tão simples quanto uma etapa que chama um script Python. Os pipelines incluem funcionalidade para:
- Preparação de dados, incluindo importação, validação e limpeza, munging e transformação, normalização e preparo
- Configuração de treinamento, incluindo argumentos de parametrização, caminhos de arquivo e configurações de log/relatório
- Treinamento e validação de maneira eficiente e repetida, o que pode incluir a especificação de subconjuntos de dados específicos, diferentes recursos de computação de hardware, processamento distribuído e monitoramento de progresso
- Implantação, incluindo controle de versão, dimensionamento, provisionamento e acesso
- Publicando um pipeline em um ponto de extremidade REST para executar novamente de qualquer biblioteca HTTP
Um PythonScriptStep
é uma etapa básica e interna para executar um Script Python em um destino de computação. Ele usa um nome de script e outros parâmetros opcionais, como argumentos para o script, destino de computação, entradas e saídas. O código a seguir é um exemplo simples de um PythonScriptStep
. Para obter um exemplo de um script de train.py
, consulte o tutorial sub-seção.
from azureml.pipeline.steps import PythonScriptStep
train_step = PythonScriptStep(
script_name="train.py",
arguments=["--input", blob_input_data, "--output", output_data1],
inputs=[blob_input_data],
outputs=[output_data1],
compute_target=compute_target,
source_directory=project_folder
)
Depois que pelo menos uma etapa tiver sido criada, as etapas poderão ser vinculadas e publicadas como um pipeline automatizado simples.
from azureml.pipeline.core import Pipeline
pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)
Para obter um exemplo abrangente de criação de um fluxo de trabalho de pipeline, siga o tutorial avançado.
Padrão para criar e usar pipelines
Um pipeline do Azure Machine Learning está associado a um workspace do Azure Machine Learning e uma etapa de pipeline está associada a um destino de computação disponível nesse workspace. Para obter mais informações, consulte este artigo sobre workspaces ou esta explicação de destinos de computação.
Um padrão comum para etapas de pipeline é:
- Especificar workspace, computação e armazenamento
- Configurar seus dados de entrada e saída usando
- de conjunto de dados que disponibiliza um armazenamento de dados existente do Azure
- pipelineDataset que encapsula dados tabulares tipados
- PipelineData que é usado para dados intermediários de arquivo ou diretório gravados por uma etapa e destinados a serem consumidos por outra
- Definir uma ou mais etapas de pipeline
- Criar uma instância de um pipeline usando seu workspace e etapas
- Criar um experimento para o qual você envia o pipeline
- Monitorar os resultados do experimento
este bloco de anotações é um bom exemplo desse padrão. trabalho
Para obter mais informações sobre os Pipelines do Azure Machine Learning e, em particular, como eles são diferentes de outros tipos de pipelines, consulte este artigo .
AutoMLConfig
do namespace
Use a classe AutoMLConfig
para configurar parâmetros para treinamento automatizado de machine learning. O aprendizado de máquina automatizado itera em várias combinações de algoritmos de aprendizado de máquina e configurações de hiperparâmetro. Em seguida, ele encontra o modelo de melhor ajuste com base na métrica de precisão escolhida. A configuração permite especificar:
- Tipo de tarefa (classificação, regressão, previsão)
- Número de iterações de algoritmo e tempo máximo por iteração
- Métrica de precisão para otimizar
- Algoritmos para lista de bloqueios/lista de permissões
- Número de validações cruzadas
- Destinos de computação
- Dados de treinamento
Nota
Use o automl
extra em sua instalação para usar o machine learning automatizado.
Para obter guias detalhados e exemplos de configuração de experimentos automatizados de machine learning, consulte o tutorial e de instruções.
O código a seguir ilustra a criação de um objeto de configuração de machine learning automatizado para um modelo de classificação e o uso quando você está enviando um experimento.
from azureml.train.automl import AutoMLConfig
automl_config = AutoMLConfig(task="classification",
X=your_training_features,
y=your_training_labels,
iterations=30,
iteration_timeout_minutes=5,
primary_metric="AUC_weighted",
n_cross_validations=5
)
Use o objeto automl_config
para enviar um experimento.
from azureml.core.experiment import Experiment
experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)
Depois de enviar o experimento, a saída mostra a precisão de treinamento para cada iteração conforme ele é concluído. Após a conclusão da execução, um objeto AutoMLRun
(que estende a classe Run
) é retornado. Obtenha o modelo de melhor ajuste usando a função get_output()
para retornar um objeto Model
.
best_model = run.get_output()
y_predict = best_model.predict(X_test)
Implantação de modelo
do namespace
A classe InferenceConfig
é para configurações que descrevem o ambiente necessário para hospedar o modelo e o serviço Web.
Webservice
é a classe pai abstrata para criar e implantar serviços Web para seus modelos. Para obter um guia detalhado sobre como preparar para implantação de modelo e implantação de serviços Web, consulte este de instruções.
Você pode usar ambientes ao implantar seu modelo como um serviço Web. Os ambientes permitem um fluxo de trabalho reproduzível e conectado em que você pode implantar seu modelo usando as mesmas bibliotecas na computação de treinamento e na computação de inferência. Internamente, os ambientes são implementados como imagens do Docker. Você pode usar imagens fornecidas pela Microsoft ou usar suas próprias imagens personalizadas do Docker. Se você já estava usando a classe ContainerImage
para sua implantação, consulte a classe DockerSection
para realizar um fluxo de trabalho semelhante com ambientes.
Para implantar um serviço Web, combine o ambiente, a computação de inferência, o script de pontuação e o modelo registrado em seu objeto de implantação, deploy()
.
O exemplo a seguir pressupõe que você já concluiu uma execução de treinamento usando o ambiente, myenv
e deseja implantar esse modelo nas Instâncias de Contêiner do Azure.
from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice
# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")
# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
environment=myenv)
# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
memory_gb = 1)
# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
name = "my_web_service",
models = [model],
inference_config = inference_config,
deployment_config = deployment_config)
Este exemplo cria um serviço Web de Instâncias de Contêiner do Azure, que é melhor para testes em pequena escala e implantações rápidas. Para implantar seu modelo como um serviço Web em escala de produção, use o AKS (Serviço de Kubernetes do Azure). Para obter mais informações, consulte classe AksCompute.
Dataset
do namespace
A classe Dataset
é um recurso fundamental para explorar e gerenciar dados no Azure Machine Learning. Você pode explorar seus dados com estatísticas de resumo e salvar o conjunto de dados em seu workspace AML para obter recursos de controle de versão e reprodução. Os conjuntos de dados são facilmente consumidos por modelos durante o treinamento. Para obter exemplos de uso detalhados, consulte o guia de instruções .
-
TabularDataset
representa dados em um formato tabular criado analisando um arquivo ou uma lista de arquivos. -
FileDataset
faz referência a arquivos únicos ou múltiplos em armazenamentos de dados ou de URLs públicas.
O exemplo a seguir mostra como criar um TabularDataset apontando para um único caminho em um armazenamento de dados.
from azureml.core import Dataset
dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()
O exemplo a seguir mostra como criar um FileDataset
referenciando várias URLs de arquivo.
from azureml.core.dataset import Dataset
url_paths = [
'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
]
dataset = Dataset.File.from_files(path=url_paths)
Próximas etapas
Experimente estas próximas etapas para aprender a usar o SDK do Azure Machine Learning para Python:
Siga o tutorial para aprender a criar, treinar e implantar um modelo no Python.
Pesquise classes e módulos na documentação de referência neste site usando o sumário à esquerda.