Qu’est-ce que le kit de développement logiciel (SDK) Azure Machine Learning pour Python ?

Les scientifiques des données et les développeurs d’IA utilisent le SDK Azure Machine Learning pour Python afin de générer et d’exécuter des workflows de machine learning avec Azure Machine Learning service. Vous pouvez interagir avec le kit de développement logiciel (SDK) dans n’importe quel environnement Python, y compris Jupyter Notebooks, Visual Studio Code ou votre IDE Python favori.

Les principales zones du kit de développement logiciel (SDK) sont les suivantes :

  • Explorez, préparez et gérez le cycle de vie de vos jeux de données utilisés dans les expériences de Machine Learning.
  • Gérez les ressources cloud pour la surveillance, la journalisation et l’organisation de vos expériences de Machine Learning.
  • Formez des modèles localement ou à l’aide de ressources cloud, y compris la formation du modèle avec accélération GPU.
  • Utilisez le Machine Learning automatisé, qui accepte les paramètres de configuration et les données de formation. Il s’itère automatiquement au sein des algorithmes et des paramètres d’hyperparamètre pour rechercher le meilleur modèle d’exécution des prédictions.
  • Déployez des services web pour convertir vos modèles formés en services RESTful qui peuvent être utilisés dans n’importe quelle application.

Pour obtenir une procédure pas à pas de prise en main, essayez le didacticiel.

Les sections suivantes sont des présentations des classes les plus importantes du kit de développement logiciel (SDK) et des modèles de conception courants pour les utiliser. Consultez le guide d’installation pour obtenir le kit de développement logiciel (SDK).

Espace de travail

Espace de noms : azureml.core.workspace.Workspace

Dans le cloud, la classe Workspace constitue la ressource de base que vous utilisez pour expérimenter, effectuer l'apprentissage et déployer des modèles Machine Learning. Il lie votre abonnement Azure et votre groupe de ressources à un objet facile à consommer.

Importez la classe et créez un nouvel espace de travail à l’aide du code suivant. Définissez create_resource_group sur False si vous disposez déjà d’un groupe de ressources Azure existant que vous souhaitez utiliser comme espace de travail. Certaines fonctions peuvent demander des informations d’identification d’authentification 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'
                     )

Utilisez le même espace de travail dans plusieurs environnements en l’écrivant d’abord dans un fichier JSON de configuration. Cela permet d’enregistrer les données de l’abonnement, de la ressource et du nom de l’espace de travail.

ws.write_config(path="./file-path", file_name="ws_config.json")

Chargez votre espace de travail en lisant le fichier de configuration.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Vous pouvez également utiliser la méthode statique get() pour charger un espace de travail existant sans utiliser de fichiers de configuration.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

La variable ws représente un objet Workspace dans les exemples de code suivants.

Expérience

Espace de noms : azureml.core.experiment.Experiment

Une classe Experiment est une autre ressource cloud de base qui représente une collection d’évaluations (exécutions de modèles individuels). Le code suivant extrait un objet Experiment à partir d'un Workspace par nom ou crée un nouvel objet Experiment si le nom n’existe pas.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Exécutez le code suivant pour obtenir la liste de tous les objets Experiment contenus dans Workspace.

list_experiments = Experiment.list(ws)

Utilisez la fonction get_runs pour récupérer une liste d’objets Run (évaluations) à partir de Experiment. Le code suivant récupère les exécutions et imprime chaque ID d’exécution.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Il existe deux manières d’exécuter une évaluation d’expérience. Si vous expérimentez de manière interactive dans un notebook Jupyter, utilisez la fonction start_logging. Si vous soumettez une expérience à partir d’un environnement Python standard, utilisez la fonction submit. Les deux fonctions retournent un objet Run. La variable experiment représente un objet Experiment dans les exemples de code suivants.

Exécuter

Espace de noms : azureml.core.run.Run

Une exécution représente l’évaluation unique d’une expérience. Run est l’objet que vous utilisez pour surveiller l’exécution asynchrone d’une évaluation, stocker la sortie de l’évaluation, analyser les résultats et accéder aux artefacts générés. Vous utilisez Run à l’intérieur de votre code d’expérimentation pour enregistrer les mesures et les artefacts dans le service des historiques des exécutions. Les fonctionnalités incluent :

  • Stockage et récupération des indicateurs de performance et des données.
  • Utilisation de balises et de la hiérarchie enfant pour faciliter la recherche des exécutions passées.
  • Enregistrement des fichiers de modèle stocké pour le déploiement.
  • Stockage, modification et récupération des propriétés d’une exécution.

Créez un objet Run en soumettant un objet Experiment avec un objet configuration de série de tests. Utilisez le paramètre tags pour joindre des catégories et des étiquettes personnalisées à vos exécutions. Vous pouvez facilement les retrouver et les récupérer ultérieurement à partir de Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Utilisez la fonction statique list pour obtenir la liste de tous les objets Run à partir de Experiment. Spécifiez le paramètre tags pour filtrer par votre balise créée précédemment.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Utilisez la fonction get_details pour récupérer la sortie détaillée de l’exécution.

run_details = run.get_details()

La sortie de cette fonction est un dictionnaire qui comprend :

  • ID d’exécution
  • Statut
  • Heures de début et de fin
  • Cible de calcul (local contre cloud)
  • Dépendances et versions utilisées dans l’exécution
  • Données spécifiques à la formation (diffèrent selon le type de modèle)

Pour obtenir plus d’exemples de configuration et de surveillance des exécutions, consultez la rubrique Aide et Astuces.

Modèle

Espace de noms : azureml.core.model.Model

La classe Model est utilisée pour travailler avec des représentations cloud de modèles Machine Learning. Les méthodes vous permettent de transférer des modèles entre les environnements de développement locaux et l’objet Workspace dans le cloud.

L’inscription de modèle vous permet de stocker vos modèles dans le cloud Azure, au sein de votre espace de travail et d’en gérer les versions. Les modèles inscrits sont identifiés par leur nom et par leur version. Chaque fois que vous inscrivez un modèle portant le même nom qu’un modèle existant, le registre incrémente la version. Azure Machine Learning prend en charge tous les modèles qui peuvent être chargés par le biais de Python 3, pas seulement les modèles Azure Machine Learning.

L’exemple suivant montre comment générer un modèle de classification locale simple avec scikit-learn, inscrire le modèle dans Workspace et télécharger le modèle à partir du cloud.

Créez un classifieur simple, clf, pour prédire l’attrition clients en fonction de son âge. Ensuite, sauvegardez le modèle dans un fichier .pkl dans le même répertoire.

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")

Utilisez la fonction register pour inscrire le modèle dans votre espace de travail Spécifiez le chemin d’accès du modèle local et le nom du modèle. L’enregistrement d’un même nom plusieurs fois crée une nouvelle version.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Maintenant que le modèle est inscrit dans votre espace de travail, il est facile de gérer, télécharger et organiser vos modèles. Pour récupérer un objet modèle (par exemple, dans un autre environnement) à partir de Workspace, utilisez le constructeur de classe et spécifiez le nom du modèle et tous les paramètres facultatifs. Utilisez ensuite la fonction download pour télécharger le modèle, y compris la structure de dossiers cloud.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Utilisez la fonction delete pour supprimer le modèle de Workspace.

model.delete()

Une fois que vous disposez d’un modèle inscrit, le déploiement en tant que service web est un processus simple. Tout d’abord, créez et inscrivez une image. Cette étape configure l’environnement Python et ses dépendances, ainsi qu’un script pour définir les formats de demande et de réponse du service web. Après avoir créé une image, vous générez une configuration de déploiement qui définit les cœurs d’UC et les paramètres de mémoire pour la cible de calcul. Joignez ensuite votre image.

ComputeTarget, RunConfiguration et ScriptRunConfig

Espace de noms : azureml.core.compute.ComputeTarget
Espace de noms : azureml.core.runconfig.RunConfiguration
Espace de noms : azureml.core.script_run_config.ScriptRunConfig

La classe ComputeTarget est la classe parente abstraite pour la création et la gestion des cibles de calcul. Une cible de calcul représente une variété de ressources où vous pouvez former vos modèles Machine Learning. Une cible de calcul peut être un ordinateur local ou une ressource cloud, comme capacité de calcul Azure Machine Learning, Azure HDInsight ou une machine virtuelle distante.

Utilisez des cibles de calcul pour tirer parti des machines virtuelles puissantes pour la formation du modèle et configurez des cibles de calcul persistantes ou des cibles appelées par l’exécution de manière temporaire. Pour obtenir un guide complet sur la configuration et la gestion des cibles de calcul, consultez la rubrique Aide et astuces.

Le code suivant illustre un exemple simple de configuration d’une cible AmlCompute (classe enfant de ComputeTarget). Cette cible crée une ressource de calcul à distance au moment de l’exécution dans votre objet Workspace. La ressource est automatiquement mise à l’échelle lors de l’envoi d’un travail. Elle est automatiquement supprimée à la fin de l’exécution.

Réutilisez le modèle d’attrition scikit-learn simple et générez-le dans son propre fichier, train.py, dans le répertoire actif. À la fin du fichier, créez un nouveau répertoire appelé outputs. Cette étape crée un répertoire dans le cloud (votre espace de travail) pour stocker votre modèle formé que joblib.dump() a sérialisé.

# 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")

Ensuite, vous créez la cible de calcul en instanciant un objet RunConfiguration et en définissant le type et la taille. Cet exemple utilise la plus petite taille de ressource (1 CU principal, 3,5 Go de mémoire). La variable list_vms contient la liste des machines virtuelles prises en charge et leur taille.

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"

Créez des dépendances pour l’environnement Python de la ressource de calcul à distance à l’aide de la classe CondaDependencies. Le fichier train.py utilise scikit-learn et numpy, qui doivent être installés dans l’environnement. Vous pouvez également spécifier des versions de dépendances. Utilisez l’objet dependencies pour définir l’environnement dans 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

Vous êtes maintenant prêt à soumettre l’expérience. Utilisez la classe ScriptRunConfig pour attacher la configuration de la cible de calcul et pour spécifier le chemin d’accès/fichier du script de formation train.py. Soumettez l’expérience en spécifiant le paramètre config de la fonction submit(). Appelez wait_for_completion sur l’exécution résultante pour voir la sortie d’exécution asynchrone pendant que l’environnement est initialisé et que le modèle est formé.

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)

Une fois l’exécution terminée, le fichier de modèle formé churn-model.pkl est disponible dans votre espace de travail.

Environnement

Espace de noms : azureml.core.environment

Les environnements Azure Machine Learning spécifient les packages, variables d’environnement et paramètres logiciels Python autour de vos scripts d’apprentissage et de scoring. En plus de Python, vous pouvez également configurer PySpark, Docker et R pour les environnements. En interne, les environnements génèrent des images Docker qui sont utilisées pour exécuter les processus d’entraînement et de scoring sur la cible de calcul. Les environnements sont des entités managées et avec version dans votre espace de travail Machine Learning qui permettent de bénéficier de workflows Machine Learning reproductibles, pouvant être audités et portables parmi une variété de cibles et de types de calcul.

Vous pouvez utiliser un objet Environment pour :

  • Développer votre script d’apprentissage.
  • Réutiliser le même environnement sur la capacité de calcul Azure Machine Learning pour l’apprentissage du modèle à l’échelle.
  • Déployer votre modèle avec ce même environnement sans être lié à un type de calcul spécifique.

Le code suivant importe la classe Environment à partir du SDK et instancie un objet d’environnement.

from azureml.core.environment import Environment
Environment(name="myenv")

Ajoutez des packages à un environnement à l'aide de fichiers Conda, pip ou de roues privés. Spécifiez chaque dépendance de package à l’aide de la classe CondaDependency pour l’ajouter à la classe PythonSection de l’environnement.

L'exemple suivant ajoute Il ajoute la version 1.17.0 de numpy. Il ajoute également le package pillow à l’environnement myenv. L'exemple utilise respectivement les méthodes add_conda_package() et add_pip_package().

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

Pour soumettre une exécution d'apprentissage, vous devez combiner votre environnement, la cible de calcul et votre script Python d'apprentissage dans la configuration d'une exécution. Cette configuration est un objet wrapper utilisé pour soumettre des exécutions.

Lorsque vous soumettez une exécution d'apprentissage, la génération d'un nouvel environnement peut prendre quelques minutes. La durée dépend de la taille des dépendances requises. Les environnements sont mis en cache par le service. Ainsi, tant que la définition de l'environnement reste inchangée, vous ne subissez l'intégralité du temps d'installation qu'une seule fois.

Voici un exemple dans lequel vous utilisez ScriptRunConfig comme objet 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)

Si vous ne spécifiez aucun environnement dans la configuration de votre exécution avant de soumettre celle-ci, un environnement par défaut est créé pour vous.

Consultez la section Déploiement de modèle pour utiliser des environnements afin de déployer un service web.

Pipeline, PythonScriptStep

Espace de noms : azureml.pipeline.core.pipeline.Pipeline
Espace de noms : azureml.pipeline.steps.python_script_step.PythonScriptStep

Un pipeline Azure Machine Learning est un workflow automatique d’une tâche Machine Learning complète. Les sous-tâches sont encapsulées sous la forme d’une série d’étapes au sein du pipeline. Un pipeline Azure Machine Learning peut être aussi simple qu’une seule étape qui appelle un script Python. Les pipelines incluent la fonctionnalité de :

  • Préparation des données, notamment l’importation, la validation et le nettoyage, la description et la transformation, la normalisation et la mise en lots
  • Configuration de la formation, notamment le paramétrage des arguments, les filePaths et les configurations de journalisation/création de rapports
  • Formation et validation efficaces et répétées, qui peuvent inclure la spécification de sous-ensembles de données spécifiques, différentes ressources de calcul matériel, le traitement distribué et la surveillance de la progression
  • Déploiement, y compris le contrôle de version, la mise à l’échelle, l’approvisionnement et le contrôle d’accès
  • Publication d’un pipeline sur un point de terminaison REST à réexécuter à partir de n’importe quelle bibliothèque HTTP

Un PythonScriptStep est une étape intégrée et de base pour exécuter un script Python sur une cible de calcul. Il accepte un nom de script et d’autres paramètres facultatifs, comme des arguments pour le script, la cible de calcul, les entrées et les sorties. Le code suivant est un exemple simple d’un PythonScriptStep. Pour obtenir un exemple d’un script train.py, consultez la sous-section du didacticiel.

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
)

Une fois qu’au moins une étape a été créée, les étapes peuvent être liées et publiées en tant que pipeline automatisé simple.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Pour obtenir un exemple complet de génération d’un workflow de pipeline, suivez le didacticiel avancé.

Modèle pour la création et l’utilisation de pipelines

Un pipeline Azure Machine Learning est associé à un espace de travail Azure Machine Learning et une étape de pipeline est associée à une cible de calcul disponible dans cet espace de travail. Pour plus d’informations, consultez cet article à propos des espaces de travail ou cette explication des cibles de calcul.

Voici un modèle commun pour les étapes de pipeline :

  1. Spécifier l’espace de travail, le calcul et le stockage
  2. Configurer vos données d’entrée et de sortie à l’aide de
    1. Dataset qui rend disponible un magasin de données Azure existant
    2. PipelineDataset qui encapsule les données tabulaires typées
    3. PipelineData qui est utilisé pour les données de fichier ou de répertoire intermédiaires écrites par une étape et destinées à être consommées par une autre
  3. Définir une ou plusieurs étapes de pipeline
  4. Instancier un pipeline à l’aide de votre espace de travail et étapes
  5. Créer une expérience à laquelle vous envoyez le pipeline
  6. Surveiller les résultats d’expérience

Ce notebook est un bon exemple pour ce modèle. travail

Pour plus d’informations sur les pipelines Azure Machine Learning et en particulier sur la façon dont ils diffèrent des autres types de pipelines, consultez cet article.

AutoMLConfig

Espace de noms : azureml.train.automl.automlconfig.AutoMLConfig

Utilisez la classe AutoMLConfig pour configurer les paramètres de formation Machine Learning automatisé. Le Machine Learning automatisé s’itère sur de nombreuses combinaisons d’algorithmes de Machine Learning et de paramètres d’hyperparamètres. Il recherche ensuite le modèle le mieux adapté en fonction de l’indicateur de performance de précision que vous avez choisi. La configuration permet de spécifier les éléments suivants :

  • type de tâche (classification, régression ou prévision)
  • nombre d’itérations d’algorithmes et temps maximal d’itération
  • indicateur de performance de précision à optimiser
  • algorithmes de liste rouge/liste verte
  • nombre de validations croisées
  • Cibles de calcul
  • Données de formation

Notes

Utilisez le supplément automl dans votre installation pour utiliser Machine Learning automatisé.

Pour obtenir des guides et des exemples détaillés sur la configuration des expériences Machine Learning automatisé, consultez le didacticiel et la rubrique Aide et astuces.

Le code suivant illustre la génération d’un objet de configuration de Machine Learning automatisé pour un modèle de classification et son utilisation lors de la soumission d’une expérience.

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
                            )

Utilisez l’objet automl_config pour soumettre une expérience.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Une fois que vous avez envoyé l’expérience, la sortie affiche la précision de la formation pour chaque itération à mesure qu’elle se termine. Une fois l’exécution terminée, un objet AutoMLRun (qui étend la classe Run) est retourné. Obtenez le modèle le mieux adapté à l’aide de la fonction get_output() pour retourner un objet Model.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Déploiement de modèle

Espace de noms : azureml.core.model.InferenceConfig
Espace de noms : azureml.core.webservice.webservice.Webservice

La classe InferenceConfig est destinée aux paramètres de configuration qui décrivent l’environnement nécessaire pour héberger le modèle et le service web.

Webservice est la classe parente abstraite pour la création et le déploiement de services web pour vos modèles. Pour obtenir un guide détaillé sur la préparation du déploiement de modèle et le déploiement de services web, consultez cette page.

Vous pouvez utiliser des environnements quand vous déployez votre modèle en tant que service web. Les environnements permettent d’exploiter un workflow connecté et reproductible dans lequel vous pouvez déployer votre modèle en utilisant les mêmes bibliothèques dans vos calculs d’entraînement et dans vos calculs d’inférence. En interne, les environnements sont implémentés en tant qu’images Docker. Vous pouvez utiliser l’une ou l’autre des images fournies par Microsoft ou utiliser vos propres images Docker personnalisées. Si vous utilisiez précédemment la classe ContainerImage pour votre déploiement, consultez la classe DockerSection pour accomplir un workflow similaire avec des environnements.

Pour déployer un service web, combinez l'environnement, le calcul d'inférence, le script de scoring et le modèle inscrit dans votre objet de déploiement, deploy().

L’exemple suivant suppose que vous avez déjà effectué une exécution d’entraînement à l’aide de l’environnement myenv et que vous souhaitez déployer ce modèle sur Azure Container Instances.

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)

Cet exemple crée un service web Azure Container Instances, qui est le mieux adapté aux tests à petite échelle et aux déploiements rapides. Pour déployer votre modèle en tant que service web de production à grande échelle, utilisez Azure Kubernetes Service (AKS). Pour plus d’informations, consultez classe AksCompute.

Dataset

Espace de noms : azureml.core.dataset.Dataset
Espace de noms : azureml.data.file_dataset.FileDataset
Espace de noms : azureml.data.tabular_dataset.TabularDataset

La classe Dataset est une ressource fondamentale pour l’exploration et la gestion des données dans Azure Machine Learning. Vous pouvez explorer vos données avec des statistiques de résumé et enregistrer le jeu de données dans votre espace de travail AML pour bénéficier de fonctionnalités de contrôle de version et de reproductibilité. Les jeux de données sont facilement consommés par les modèles au cours de la formation. Pour obtenir des exemples d’utilisation détaillés, consultez le guide Aide et astuces.

  • TabularDataset représente les données sous forme de tableau créé en analysant le fichier ou la liste de fichiers.
  • FileDataset fait référence à des fichiers uniques ou multiples dans vos magasins de données ou vos URL publiques.

L’exemple suivant montre comment créer un TabularDataset pointant vers un chemin d’accès unique dans un magasin de données.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

L’exemple suivant montre comment créer un FileDataset faisant référence à plusieurs URL de fichiers.

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)

Étapes suivantes

Essayez de suivre les étapes suivantes pour savoir comment utiliser le kit SDK Azure Machine Learning pour Python :

  • Suivez le didacticiel pour apprendre à générer, à former et à déployer un modèle dans Python.

  • Recherchez des classes et des modules dans la documentation de référence sur ce site à l’aide de la table des matières à gauche.