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

Les scientifiques des données et les développeurs d’IA utilisent le Kit de développement logiciel (SDK) Azure Machine Learning v1 pour Python afin de créer et d’exécuter des flux de travail Machine Learning avec les service Azure Machine Learning. Vous pouvez interagir avec le service dans n’importe quel environnement Python, y compris jupyter Notebooks, Visual Studio Codeou votre IDE Python favori.

Les domaines clés du Kit de développement logiciel (SDK) sont les suivants :

• 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.
• Entraîner des modèles localement ou à l’aide de ressources cloud, y compris l’entraînement de modèle accéléré par GPU.
• Utilisez le Machine Learning automatisé, qui accepte les paramètres de configuration et les données d’apprentissage. Il itère automatiquement via des algorithmes et des paramètres d’hyperparamètre pour trouver le meilleur modèle pour exécuter des prédictions.
• Déployez des services web pour convertir vos modèles entraînés en services RESTful qui peuvent être consommés dans n’importe quelle application.

Pour une procédure pas à pas sur la prise en main, essayez le didacticiel .

Les sections suivantes sont des présentations de certaines des classes les plus importantes dans le Kit de développement logiciel (SDK) et des modèles de conception courants pour les utiliser. Pour obtenir le Kit de développement logiciel (SDK), consultez le guide d’installation .

Stable ou expérimental

Le Kit de développement logiciel (SDK) Azure Machine Learning pour Python fournit des fonctionnalités stables et expérimentales dans le même SDK.

Les fonctionnalités expérimentales sont étiquetées par une section de note dans la référence du Kit de développement logiciel (SDK) et indiquées par du texte tel que (préversion) dans documentation Azure Machine Learning.

Espace

d’espace de noms : azureml.core.workspace.Workspace

La classe Workspace est une ressource fondamentale dans le cloud que vous utilisez pour expérimenter, entraîner et déployer des modèles Machine Learning. Il lie votre abonnement Azure et votre groupe de ressources à un objet facilement consommé.

Affichez tous les paramètres de la méthode create Workspace pour réutiliser des instances existantes (Storage, Key Vault, App-Insights et Azure Container Registry-ACR) et modifiez des paramètres supplémentaires tels que la configuration de point de terminaison privé et la cible de calcul.

Importez la classe et créez un espace de travail à l’aide du code suivant. Définissez create_resource_group sur False si vous disposez d’un groupe de ressources Azure existant que vous souhaitez utiliser pour l’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 enregistre vos données d’abonnement, de ressource et de nom d’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 de get() statique 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

d’espace de noms : azureml.core.experiment.Experiment

La classe Experiment est une autre ressource cloud fondamentale qui représente une collection d’essais (exécutions de modèles individuelles). Le code suivant extrait un objet Experiment à partir de 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 (essais) 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 façons d’exécuter une version d’évaluation d’expérience. Si vous expérimentez de manière interactive dans un notebook Jupyter, utilisez la fonction start_logging. Si vous envoyez 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.

Courir

d’espace de noms : azureml.core.run.Run

Une exécution représente une seule version d’évaluation d’une expérience. Run est l’objet que vous utilisez pour surveiller l’exécution asynchrone d’une version d’évaluation, stocker la sortie de la version d’é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 consigner les métriques et les artefacts dans le service d’historique des exécutions. Les fonctionnalités sont les suivantes :

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

Créez un objet Run en envoyant un objet Experiment avec un exécuter une configuration objet. Utilisez le paramètre tags pour attacher des catégories et des étiquettes personnalisées à vos exécutions. Vous pouvez facilement les trouver 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 list statique pour obtenir la liste de tous les objets Run de Experiment. Spécifiez le paramètre tags à 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 inclut :

• ID d’exécution
• Statut
• Heure de début et de fin
• Cible de calcul (local ou cloud)
• Dépendances et versions utilisées dans l’exécution
• Données spécifiques à l’entraînement (diffère selon le type de modèle)

Pour plus d’exemples de configuration et de surveillance des exécutions, consultez la procédure.

Modèle

d’espace de noms : azureml.core.model.Model

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

Vous pouvez utiliser l’inscription de modèle pour stocker et versionr vos modèles dans le cloud Azure, dans votre espace de travail. Les modèles inscrits sont identifiés par nom et 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 n’importe quel modèle qui peut être chargé via Python 3, pas seulement les modèles Azure Machine Learning.

L’exemple suivant montre comment créer un modèle de classification locale simple avec scikit-learn, inscrire le modèle dans Workspaceet télécharger le modèle à partir du cloud.

Créez un classifieur simple, clf, pour prédire l’attrition des clients en fonction de leur âge. Ensuite, videz 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’inscription du 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 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. Ensuite, utilisez 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 avez inscrit un modèle, le déploiement en tant que service web est un processus simple. Tout d’abord, vous créer et inscrire 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 créer une configuration de déploiement qui définit les cœurs du processeur et les paramètres de mémoire pour la cible de calcul. Vous attachez ensuite votre image.

ComputeTarget, RunConfiguration et ScriptRunConfig

d’espace de noms : azureml.core.compute.ComputeTarget
d’espace de noms : azureml.core.runconfig.RunConfiguration
d’espace de noms : azureml.core.script_run_config.ScriptRunConfig

La classe ComputeTarget est la classe parente abstraite permettant de créer et de gérer des cibles de calcul. Une cible de calcul représente une variété de ressources dans lesquelles vous pouvez entraîner vos modèles Machine Learning. Une cible de calcul peut être une machine locale ou une ressource cloud, telle qu’Azure Machine Learning Compute, Azure HDInsight ou une machine virtuelle distante.

Utilisez des cibles de calcul pour tirer parti des machines virtuelles puissantes pour l’entraînement du modèle et configurer des cibles de calcul persistantes ou des cibles appelées par le runtime temporaire. Pour obtenir un guide complet sur la configuration et la gestion des cibles de calcul, consultez le guide pratique .

Le code suivant montre un exemple simple de configuration d’une cible AmlCompute (classe enfant de ComputeTarget). Cette cible crée une ressource de calcul distante runtime dans votre objet Workspace. La ressource est mise à l’échelle automatiquement lorsqu’un travail est envoyé. Elle est supprimée automatiquement une fois l’exécution terminée.

Réutilisez le modèle de 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 répertoire appelé outputs. Cette étape crée un répertoire dans le cloud (votre espace de travail) pour stocker votre modèle entraîné qui joblib.dump() 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 cœur de processeur, 3,5 Go de mémoire). La variable list_vms contient une liste de machines virtuelles prises en charge et de leurs tailles.

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 distante à 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 cible de calcul et spécifier le chemin/fichier au script d’entraînement train.py. Envoyez 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 lorsque l’environnement est initialisé et que le modèle est entraîné.

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 entraîné churn-model.pkl est disponible dans votre espace de travail.

Environnement

d’espace de noms : azureml.core.environment

Les environnements Azure Machine Learning spécifient les packages Python, les variables d’environnement et les paramètres logiciels autour de vos scripts d’entraînement et de scoring. En plus de Python, vous pouvez également configurer PySpark, Docker et R pour les environnements. En interne, les environnements entraînent des images Docker 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 versionées au sein de votre espace de travail Machine Learning qui permettent des flux de travail Machine Learning reproductibles, auditables et portables sur diverses cibles de calcul et types de calcul.

Vous pouvez utiliser un objet Environment pour :

• Développez votre script d’entraînement.
• Réutilisez le même environnement sur le calcul Azure Machine Learning pour l’entraînement de modèle à grande échelle.
• Déployez 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 Kit de développement logiciel (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 private wheel. Spécifiez chaque dépendance de package à l’aide de la classe CondaDependency pour l’ajouter au PythonSectionde l’environnement.

L’exemple suivant ajoute à l’environnement. Il ajoute la version 1.17.0 de numpy. Il ajoute également le package pillow à l’environnement, myenv. L’exemple utilise respectivement la méthode add_conda_package() et la méthode 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’entraînement, vous devez combiner votre environnement, cible de calculet votre script Python d’apprentissage dans une configuration d’exécution. Cette configuration est un objet wrapper utilisé pour l’envoi d’exécutions.

Lorsque vous soumettez une exécution d’entraînement, la création d’un nouvel environnement peut prendre plusieurs 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 n’entraînez la durée de configuration complète qu’une seule fois.

L’exemple suivant montre où vous utiliseriez 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 pas d’environnement dans votre configuration d’exécution avant d’envoyer l’exécution, un environnement par défaut est créé pour vous.

Consultez la section Model deploy pour utiliser des environnements pour déployer un service web.

Pipeline, PythonScriptStep

d’espace de noms : azureml.pipeline.core.pipeline.Pipeline
d’espace de noms : azureml.pipeline.steps.python_script_step.PythonScriptStep

Un pipeline Azure Machine Learning est un workflow automatisé d’une tâche machine learning complète. Les tâches subordonnées sont encapsulées sous la forme d’une série d’étapes dans le pipeline. Un pipeline Azure Machine Learning peut être aussi simple qu’une étape qui appelle un script Python. Les pipelines incluent des fonctionnalités pour :

• Préparation des données, y compris l’importation, la validation et le nettoyage, la collecte et la transformation, la normalisation et la mise en lots
• Configuration d’apprentissage, notamment le paramétrage des arguments, des chemins de fichier et la journalisation/configurations de création de rapports
• Formation et validation efficaces et reproductibles, ce qui peut inclure la spécification de sous-ensembles de données spécifiques, différentes ressources de calcul matérielles, 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 pour réexécuter à partir de n’importe quelle bibliothèque HTTP

Un PythonScriptStep est une étape intégrée de base pour exécuter un script Python sur une cible de calcul. Il prend un nom de script et d’autres paramètres facultatifs tels que 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 de script train.py, consultez le didacticiel sous-section.

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 création d’un flux de travail de pipeline, suivez le didacticiel avancé .

Modèle de création et d’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 sur les espaces de travail ou cette explication des cibles de calcul .

Un modèle courant pour les étapes de pipeline est le suivant :

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. jeu de données qui rend disponible un magasin de données Azure existant
   2. pipelineDataset qui encapsule les données tabulaires typées
   3. pipelineData utilisée pour les données de fichier ou de répertoire intermédiaires écrites par une étape et destinées à être consommées par un autre
3. Définir une ou plusieurs étapes de pipeline
4. Instancier un pipeline à l’aide de votre espace de travail et des étapes
5. Créer une expérience à laquelle vous soumettez le pipeline
6. Surveiller les résultats de l’expérience

ce notebook est un bon exemple de ce modèle. travail

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

AutoMLConfig

d’espace de noms : azureml.train.automl.automlconfig.AutoMLConfig

Utilisez la classe AutoMLConfig pour configurer des paramètres pour l’apprentissage automatique automatisé. L’apprentissage automatique effectue une itération sur de nombreuses combinaisons d’algorithmes d’apprentissage automatique et de paramètres d’hyperparamètre. Il trouve ensuite le modèle le mieux adapté en fonction de la métrique de précision choisie. La configuration permet de spécifier :

• Type de tâche (classification, régression, prévision)
• Nombre d’itérations d’algorithme et durée maximale par itération
• Métrique de précision à optimiser
• Algorithmes pour blocklist/allowlist
• Nombre de validations croisées
• Cibles de calcul
• Données d’apprentissage

Pour obtenir des guides détaillés et des exemples de configuration d’expériences de Machine Learning automatisées, consultez le didacticiel et procédures.

Le code suivant illustre la création d’un objet de configuration Machine Learning automatisé pour un modèle de classification et son utilisation lors de l’envoi 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 l’expérience envoyée, la sortie affiche la précision de l’entraînement 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 renvoyer un objet Model.

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

Déploiement de modèle

d’espace de noms : azureml.core.model.InferenceConfig
d’espace de noms : azureml.core.webservice.webservice.Webservice

La classe InferenceConfig concerne les 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 permettant de créer et de déployer des services web pour vos modèles. Pour obtenir un guide détaillé sur la préparation du déploiement de modèles et le déploiement de services web, consultez cette guide pratique pour.

Vous pouvez utiliser environnements lorsque vous déployez votre modèle en tant que service web. Les environnements permettent un flux de travail reproductible et connecté dans lequel vous pouvez déployer votre modèle à l’aide des mêmes bibliothèques dans votre calcul d’entraînement et votre calcul d’inférence. En interne, les environnements sont implémentés en tant qu’images Docker. Vous pouvez utiliser les 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 flux de travail 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, myenvet 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 meilleur pour les tests à petite échelle et les déploiements rapides. Pour déployer votre modèle en tant que service web à l’échelle de la production, utilisez Azure Kubernetes Service (AKS). Pour plus d’informations, consultez classe AksCompute.

Jeu de données

d’espace de noms : azureml.core.dataset.Dataset
d’espace de noms : azureml.data.file_dataset.FileDataset
d’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 récapitulatives et enregistrer le jeu de données dans votre espace de travail AML pour obtenir des fonctionnalités de contrôle de version et de reproductibilité. Les jeux de données sont facilement consommés par les modèles pendant l’entraînement. Pour obtenir des exemples d’utilisation détaillés, consultez le guide pratique .

• TabularDataset représente des données dans un format tabulaire créé en analysant un fichier ou une liste de fichiers.
• FileDataset référence des fichiers uniques ou multiples dans des magasins de données ou à partir d’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 référençant plusieurs URL de fichier.

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 ces étapes suivantes pour apprendre à utiliser le Kit de développement logiciel (SDK) Azure Machine Learning pour Python :

• Suivez le didacticiel pour apprendre à générer, entraîner et déployer un modèle en 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.