Öğretici: veri ve scikit ile görüntü sınıflandırma modellerini eğitme-Azure Machine Learning kullanmayı öğreninTutorial: Train image classification models with MNIST data and scikit-learn using Azure Machine Learning

Uygulama hedefi: YesBasic Edition EvetEnterprise edition                   (Enterprise Edition 'A yükseltme)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Bu öğreticide, bir makine öğrenimi modelini uzaktan işlem kaynaklarında eğitebilirsiniz.In this tutorial, you train a machine learning model on remote compute resources. Bir Python Jupyter not defterinde Azure Machine Learning için eğitim ve dağıtım iş akışını kullanacaksınız.You'll use the training and deployment workflow for Azure Machine Learning in a Python Jupyter notebook. Ardından not defterini şablon olarak kullanıp kendi verilerinizle kendi makine öğrenmesi modelinizi eğitebilirsiniz.You can then use the notebook as a template to train your own machine learning model with your own data. Bu öğretici, iki bölümden oluşan bir öğretici serisinin birinci bölümüdür.This tutorial is part one of a two-part tutorial series.

Bu öğreticide, Mnist veri kümesini ve scikit 'i kullanarak basit bir Lojistik gerileme yapılır. Azure Machine Learning hakkında bilgi edinin .This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning. MNIST, 70.000 gri tonlamalı resimden oluşan popüler bir veri kümesidir.MNIST is a popular dataset consisting of 70,000 grayscale images. Her görüntü, sıfır ile dokuz arasında bir sayıyı temsil eden 28 x 28 piksellik bir sayının el ile yazılmış bir rakamdır.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. Amaç, belirli bir resim temsil ettiği rakamı tanımlamak için çok sınıflı bir sınıflandırıcı oluşturmaktır.The goal is to create a multi-class classifier to identify the digit a given image represents.

Aşağıdaki eylemleri nasıl gerçekleştireceğinizi öğrenin:Learn how to take the following actions:

  • Geliştirme ortamınızı ayarlayın.Set up your development environment.
  • Verilere erişin ve verileri inceleyin.Access and examine the data.
  • Uzak bir kümede basit bir lojistik regresyon modeli eğitme.Train a simple logistic regression model on a remote cluster.
  • Eğitim sonuçlarını gözden geçirin ve en iyi modeli kaydedin.Review training results and register the best model.

Bir modelin nasıl seçeceğinizi ve Bu öğreticinin ikinci bölümündenasıl dağıtılacağını öğreneceksiniz.You learn how to select a model and deploy it in part two of this tutorial.

Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun.If you don’t have an Azure subscription, create a free account before you begin. Azure Machine Learning ücretsiz veya ücretli sürümünü bugün deneyin.Try the free or paid version of Azure Machine Learning today.

Not

Bu makaledeki kod, Azure MACHINE LEARNING SDK sürümü 1.0.65 ile test edilmiştir.Code in this article was tested with Azure Machine Learning SDK version 1.0.65.

Ön koşullarPrerequisites

  • Öğreticiyi doldurun: Ilk ml denemenizi oluşturmaya başlama :Complete the Tutorial: Get started creating your first ML experiment to:

    • Çalışma alanı oluşturmaCreate a workspace
    • Öğreticiler Not defterini çalışma alanındaki klasörünüze kopyalayın.Clone the tutorials notebook to your folder in the workspace.
    • Bulut tabanlı bir not defteri VM 'si oluşturun.Create a cloud-based Notebook VM.
  • Klonlanan öğreticiler klasörünüzde img-Classification-part1-eğitim. ipynb Not defterini açın.In your cloned tutorials folder, open the img-classification-part1-training.ipynb notebook.

Öğretici ve ilgili Utils.py dosyası, kendi Yerel ortamınızdakullanmak isterseniz GitHub 'da da kullanılabilir.The tutorial and accompanying utils.py file is also available on GitHub if you wish to use it on your own local environment. Bu öğreticinin bağımlılıklarını yüklemek için pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib çalıştırın.Run pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib to install dependencies for this tutorial.

Önemli

Bu makalenin geri kalanında not defterinde gördüğünüz içerikle aynı içerik yer almaktadır.The rest of this article contains the same content as you see in the notebook.

Kodu çalıştırırken okumak istiyorsanız, Jupyter not defterine şimdi geçin.Switch to the Jupyter notebook now if you want to read along as you run the code. Bir not defterinde tek bir kod hücresini çalıştırmak için, kod hücresine tıklayın ve SHIFT + entertuşuna basın.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Ya da tüm not defteri ' ni üstteki araç çubuğundan Çalıştır ' ı seçerek çalıştırın.Or, run the entire notebook by choosing Run all from the top toolbar.

Geliştirme ortamınızı ayarlamaSet up your development environment

Geliştirme çalışmanızdaki tüm kurulum bir Python not defterinde gerçekleştirilebilir.All the setup for your development work can be accomplished in a Python notebook. Kurulum aşağıdaki eylemleri içerir:Setup includes the following actions:

  • Python paketlerini içeri aktarın.Import Python packages.
  • Yerel bilgisayarınızın uzak kaynaklarla iletişim kurabilmesi için bir çalışma alanına bağlanın.Connect to a workspace, so that your local computer can communicate with remote resources.
  • Tüm çalıştırmalarınızı izlemek için bir deneme oluşturun.Create an experiment to track all your runs.
  • Eğitim için kullanmak üzere bir uzak işlem hedefi oluşturun.Create a remote compute target to use for training.

Paketleri içeri aktarmaImport packages

Bu oturumda ihtiyacınız olan Python paketlerini içeri aktarın.Import Python packages you need in this session. Azure Machine Learning SDK sürümünü de görüntüle:Also display the Azure Machine Learning SDK version:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

import azureml.core
from azureml.core import Workspace

# check core SDK version number
print("Azure ML SDK Version: ", azureml.core.VERSION)

Çalışma alanına bağlanConnect to a workspace

Mevcut çalışma alanından bir çalışma alanı nesnesi oluşturun.Create a workspace object from the existing workspace. Workspace.from_config(), config. JSON dosyasını okur ve wsadlı bir nesneye ayrıntıları yükler:Workspace.from_config() reads the file config.json and loads the details into an object named ws:

# load workspace configuration from the config.json file in the current folder.
ws = Workspace.from_config()
print(ws.name, ws.location, ws.resource_group, sep='\t')

Deneme oluşturmaCreate an experiment

Çalışma alanınızdaki çalıştırmaları izleyecek bir deneme oluşturun.Create an experiment to track the runs in your workspace. Bir çalışma alanı birden çok denemeleri içerebilir:A workspace can have multiple experiments:

from azureml.core import Experiment
experiment_name = 'sklearn-mnist'

exp = Experiment(workspace=ws, name=experiment_name)

Mevcut bir işlem hedefi oluşturun veya ekleyinCreate or attach an existing compute target

Yönetilen bir hizmet olan Azure Machine Learning Işlem kullanarak, veri bilimcileri, Azure sanal makinelerinin kümelerinde makine öğrenimi modellerini eğitebilir.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Örnek olarak GPU desteği olan VM 'Ler sayılabilir.Examples include VMs with GPU support. Bu öğreticide eğitim ortamınız olarak Azure Machine Learning Işlem oluşturursunuz.In this tutorial, you create Azure Machine Learning Compute as your training environment. Aşağıdaki kod, çalışma alanınızda zaten mevcut değilse sizin için işlem kümelerini oluşturur.The code below creates the compute clusters for you if they don't already exist in your workspace.

İşlem hedefinin oluşturulması yaklaşık beş dakika sürer.Creation of the compute target takes about five minutes. İşlem kaynağı zaten çalışma alanında ise, kod onu kullanır ve oluşturma işlemini atlar.If the compute resource is already in the workspace, the code uses it and skips the creation process.

from azureml.core.compute import AmlCompute
from azureml.core.compute import ComputeTarget
import os

# choose a name for your cluster
compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpucluster")
compute_min_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MIN_NODES", 0)
compute_max_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MAX_NODES", 4)

# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6
vm_size = os.environ.get("AML_COMPUTE_CLUSTER_SKU", "STANDARD_D2_V2")


if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('found compute target. just use it. ' + compute_name)
else:
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,
                                                                min_nodes=compute_min_nodes,
                                                                max_nodes=compute_max_nodes)

    # create the cluster
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # can poll for a minimum number of nodes and for a specific timeout.
    # if no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current AmlCompute status, use get_status()
    print(compute_target.get_status().serialize())

Artık bulutta bir modeli eğitmek için gerekli paketleriniz ve işlem kaynaklarınız vardır.You now have the necessary packages and compute resources to train a model in the cloud.

Verileri incelemeExplore data

Bir modeli eğitmadan önce, bunu eğitebilmek için kullandığınız verileri anlamanız gerekir.Before you train a model, you need to understand the data that you use to train it. Bu bölümde şunları nasıl yapabileceğinizi öğrenirsiniz:In this section you learn how to:

  • MNIST veri kümesini indirin.Download the MNIST dataset.
  • Örnek görüntüleri görüntüleyin.Display some sample images.

MNIST veri kümesini indirmeDownload the MNIST dataset

Ham veri dosyalarını almak için Azure açık veri kümelerini kullanın.Use Azure Open Datasets to get the raw MNIST data files. Azure açık veri kümeleri, daha doğru modeller için makine öğrenimi çözümlerine senaryoya özgü özellikler eklemek için kullanabileceğiniz, seçkin ortak veri kümeleridir.Azure Open Datasets are curated public datasets that you can use to add scenario-specific features to machine learning solutions for more accurate models. Her bir veri kümesi, verileri farklı yollarla almak için karşılık gelen bir sınıfa sahiptir, bu durumda MNIST.Each dataset has a corresponding class, MNIST in this case, to retrieve the data in different ways.

Bu kod, Datasetbir alt sınıfı olan FileDataset nesne olarak verileri alır.This code retrieves the data as a FileDataset object, which is a subclass of Dataset. FileDataset, veri Mağazalarınız veya genel URL 'lerinde herhangi bir biçimin tek veya birden çok dosyasına başvurur.A FileDataset references single or multiple files of any format in your datastores or public urls. Sınıfı, veri kaynağı konumuna yönelik bir başvuru oluşturarak dosyaları işlem dosyalarınıza indirme veya bağlama olanağı sağlar.The class provides you with the ability to download or mount the files to your compute by creating a reference to the data source location. Ayrıca, eğitim sırasında kolay bir şekilde almak için veri kümesini çalışma alanınıza kaydedersiniz.Additionally, you register the Dataset to your workspace for easy retrieval during training.

Veri kümeleri ve SDK kullanımları hakkında daha fazla bilgi edinmek için nasıl yapılır? konusunu izleyin.Follow the how-to to learn more about Datasets and their usage in the SDK.

from azureml.core import Dataset
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), 'data')
os.makedirs(data_folder, exist_ok=True)

mnist_file_dataset = MNIST.get_file_dataset()
mnist_file_dataset.download(data_folder, overwrite=True)

mnist_file_dataset = mnist_file_dataset.register(workspace=ws,
                                                 name='mnist_opendataset',
                                                 description='training and test dataset',
                                                 create_new_version=True)

Bazı örnek görüntüleri göstermeDisplay some sample images

Sıkıştırılmış dosyaları numpy dizilerine yükleyin.Load the compressed files into numpy arrays. Ardından matplotlib kullanarak, üst kısımlarında etiketleriyle veri kümesinden 30 rastgele görüntü çizin.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Bu adım, bir util.py dosyasına dahil edilen load_data bir işlev gerektirir.This step requires a load_data function that's included in an util.py file. Bu dosya örnek klasöründe bulunur.This file is included in the sample folder. Bu not defteriyle aynı klasöre yerleştirildiğinden emin olun.Make sure it's placed in the same folder as this notebook. load_data işlevi, sıkıştırılmış dosyaları yalnızca sayısal tuş takımı dizileri olarak ayrıştırır.The load_data function simply parses the compressed files into numpy arrays.

# make sure utils.py is in the same directory as this code
from utils import load_data

# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.
X_train = load_data(os.path.join(data_folder, "train-images-idx3-ubyte.gz"), False) / 255.0
X_test = load_data(os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"), False) / 255.0
y_train = load_data(os.path.join(data_folder, "train-labels-idx1-ubyte.gz"), True).reshape(-1)
y_test = load_data(os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"), True).reshape(-1)

# now let's show some randomly chosen images from the traininng set.
count = 0
sample_size = 30
plt.figure(figsize=(16, 6))
for i in np.random.permutation(X_train.shape[0])[:sample_size]:
    count = count + 1
    plt.subplot(1, sample_size, count)
    plt.axhline('')
    plt.axvline('')
    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)
    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)
plt.show()

Rastgele görüntü örnekleri gösterilir:A random sample of images displays:

Görüntülerin rastgele örneği

Artık bu görüntülerin nasıl göründüğü ve beklenen tahmin sonucu hakkında bir fikriniz oldu.Now you have an idea of what these images look like and the expected prediction outcome.

Uzak kümede eğitmeTrain on a remote cluster

Bu görev için, işi daha önce ayarlamış olduğunuz uzak eğitim kümesine gönderin.For this task, submit the job to the remote training cluster you set up earlier. İş göndermek için şunları yaparsınız:To submit a job you:

  • Dizin oluşturmaCreate a directory
  • Eğitim betiği oluşturmaCreate a training script
  • Bir tahmin aracı nesnesi oluşturmaCreate an estimator object
  • İşi göndermeSubmit the job

Dizin oluşturmaCreate a directory

Gerekli kodu bilgisayarınızdan uzak kaynağa teslim etmek için bir dizin oluşturun.Create a directory to deliver the necessary code from your computer to the remote resource.

script_folder = os.path.join(os.getcwd(), "sklearn-mnist")
os.makedirs(script_folder, exist_ok=True)

Eğitim betiği oluşturmaCreate a training script

İşi kümeye göndermek için, önce bir eğitim betiği oluşturun.To submit the job to the cluster, first create a training script. Aşağıdaki kodu çalıştırarak, az önce oluşturduğunuz dizinde train.py adlı eğitim betiğini oluşturun.Run the following code to create the training script called train.py in the directory you just created.

%%writefile $script_folder/train.py

import argparse
import os
import numpy as np
import glob

from sklearn.linear_model import LogisticRegression
from sklearn.externals import joblib

from azureml.core import Run
from utils import load_data

# let user feed in 2 parameters, the dataset to mount or download, and the regularization rate of the logistic regression model
parser = argparse.ArgumentParser()
parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
parser.add_argument('--regularization', type=float, dest='reg', default=0.01, help='regularization rate')
args = parser.parse_args()

data_folder = args.data_folder
print('Data folder:', data_folder)

# load train and test set into numpy arrays
# note we scale the pixel intensity values to 0-1 (by dividing it with 255.0) so the model can converge faster.
X_train = load_data(glob.glob(os.path.join(data_folder, '**/train-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
X_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
y_train = load_data(glob.glob(os.path.join(data_folder, '**/train-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)
y_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep = '\n')

# get hold of the current run
run = Run.get_context()

print('Train a logistic regression model with regularization rate of', args.reg)
clf = LogisticRegression(C=1.0/args.reg, solver="liblinear", multi_class="auto", random_state=42)
clf.fit(X_train, y_train)

print('Predict the test set')
y_hat = clf.predict(X_test)

# calculate accuracy on the prediction
acc = np.average(y_hat == y_test)
print('Accuracy is', acc)

run.log('regularization rate', np.float(args.reg))
run.log('accuracy', np.float(acc))

os.makedirs('outputs', exist_ok=True)
# note file saved in the outputs folder is automatically uploaded into experiment record
joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

Betiğin verileri nasıl aldığına ve modelleri nasıl kaydettiğine dikkat edin:Notice how the script gets data and saves models:

  • Eğitim betiği, verileri içeren dizini bulmak için bir bağımsız değişken okur.The training script reads an argument to find the directory that contains the data. Daha sonra işi gönderdiğinizde, bu bağımsız değişken için veri deposuna işaret edersiniz: parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')When you submit the job later, you point to the datastore for this argument: parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')

  • Eğitim betiği, modelinizi çıktılaradlı bir dizine kaydeder.The training script saves your model into a directory named outputs. Bu dizine yazılan her şey otomatik olarak çalışma alanınıza yüklenir.Anything written in this directory is automatically uploaded into your workspace. Modelinize bu dizinden daha sonra öğreticide erişirsiniz.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • Eğitim betiği dosya utils.py veri kümesini doğru bir şekilde yüklemesini gerektirir.The training script requires the file utils.py to load the dataset correctly. Aşağıdaki kod, script_folder, uzak kaynaktaki eğitim betiğinin yanı sıra dosyaya utils.py kopyalar.The following code copies utils.py into script_folder so that the file can be accessed along with the training script on the remote resource.

    import shutil
    shutil.copy('utils.py', script_folder)
    

Tahmin aracı oluşturmaCreate an estimator

Bir sköğrenme tahmin aracı nesnesi, çalıştırmayı göndermek için kullanılır.An SKLearn estimator object is used to submit the run. Bu öğeleri tanımlamak için aşağıdaki kodu çalıştırarak tahmin aracı 'nizi oluşturun:Create your estimator by running the following code to define these items:

  • Tahmin aracı nesnesinin adı, est.The name of the estimator object, est.
  • Betiklerinizi içeren dizin.The directory that contains your scripts. Bu dizindeki dosyaların tümü yürütülmek üzere küme düğümlerine yüklenir.All the files in this directory are uploaded into the cluster nodes for execution.
  • Bilgi işlem hedefi.The compute target. Bu durumda, oluşturduğunuz Azure Machine Learning işlem kümesini kullanırsınız.In this case, you use the Azure Machine Learning compute cluster you created.
  • Eğitim betiği adı, train.py.The training script name, train.py.
  • Eğitim betiğiyle gerekli parametreler.Parameters required from the training script.

Bu öğreticide, bu hedef AmlCompute ' dir.In this tutorial, this target is AmlCompute. Betik klasöründeki tüm dosyalar, çalışma için küme düğümlerine yüklenir.All files in the script folder are uploaded into the cluster nodes for run. Data_folder , veri kümesini kullanacak şekilde ayarlanır.The data_folder is set to use the dataset. İlk olarak, eğitim için gereken bağımlılıkları belirten bir ortam nesnesi oluşturun.First create an environment object that specifies the dependencies required for training.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

env = Environment('my_env')
cd = CondaDependencies.create(pip_packages=['azureml-sdk','scikit-learn','azureml-dataprep[pandas,fuse]>=1.1.14'])
env.python.conda_dependencies = cd

Ardından aşağıdaki kodla tahmin aracı oluşturun.Then create the estimator with the following code.

from azureml.train.sklearn import SKLearn

script_params = {
    '--data-folder': mnist_file_dataset.as_named_input('mnist_opendataset').as_mount(),
    '--regularization': 0.5
}

est = SKLearn(source_directory=script_folder,
              script_params=script_params,
              compute_target=compute_target,
              environment_definition=env, 
              entry_script='train.py')

İşi kümeye göndermeSubmit the job to the cluster

Tahmin aracı nesnesini göndererek denemeyi çalıştırın:Run the experiment by submitting the estimator object:

run = exp.submit(config=est)
run

Çağrı zaman uyumsuz olduğundan, iş başlatıldıktan hemen sonra bir hazırlık veya çalışma durumu döndürür.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Uzaktan çalıştırmayı izlemeMonitor a remote run

Toplam olarak, ilk çalıştırma yaklaşık 10 dakikasürer.In total, the first run takes about 10 minutes. Ancak, komut dosyası bağımlılıkları değişmedikçe, sonraki çalıştırmalar için aynı görüntü yeniden kullanılır.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. Bu nedenle kapsayıcı başlatma zamanı çok daha hızlıdır.So the container startup time is much faster.

Beklerken ne olur:What happens while you wait:

  • Görüntü oluşturma: Estimator tarafından belirtilen Python ortamıyla eşleşen bir Docker görüntüsü oluşturulur.Image creation: A Docker image is created that matches the Python environment specified by the estimator. Görüntü, çalışma alanına yüklenir.The image is uploaded to the workspace. Resim oluşturma ve karşıya yükleme yaklaşık beş dakikasürer.Image creation and uploading takes about five minutes.

    Kapsayıcı sonraki çalıştırmalar için önbelleğe alındığından, bu aşama her Python ortamı için bir kez gerçekleşir.This stage happens once for each Python environment because the container is cached for subsequent runs. Görüntü oluşturma sırasında, günlükler çalıştırma geçmişine aktarılır.During image creation, logs are streamed to the run history. Bu günlükleri kullanarak görüntü oluşturma ilerlemesini izleyebilirsiniz.You can monitor the image creation progress by using these logs.

  • Ölçeklendirme: uzak küme, çalışmayı Şu anda kullanılabilir olandan daha fazla düğüm gerektiriyorsa, ek düğümler otomatik olarak eklenir.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. Ölçeklendirme genellikle yaklaşık beş dakika sürer.Scaling typically takes about five minutes.

  • Çalışıyor: Bu aşamada, gerekli betikler ve dosyalar işlem hedefine gönderilir.Running: In this stage, the necessary scripts and files are sent to the compute target. Ardından veri depoları bağlanır veya kopyalanır.Then datastores are mounted or copied. Ve sonra entry_script çalıştırılır.And then the entry_script is run. İş çalışırken stdout ve ./logs dizini çalıştırma geçmişine akışla kaydedilir.While the job is running, stdout and the ./logs directory are streamed to the run history. Bu günlükleri kullanarak çalıştırmanın ilerlemesini izleyebilirsiniz.You can monitor the run's progress by using these logs.

  • Işlem sonrası: Bu sonuçlara erişebilmek için çalıştırmanın ./çıktılar dizini çalışma alanınızdaki çalışma geçmişine kopyalanır.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Çalışan bir işin ilerlemesini birkaç şekilde denetleyebilirsiniz.You can check the progress of a running job in several ways. Bu öğreticide bir jupi pencere öğesi ve bir wait_for_completion yöntemi kullanılmaktadır.This tutorial uses a Jupyter widget and a wait_for_completion method.

Jupyter pencere öğesiJupyter widget

Bir Jupyıter pencere öğesiile çalıştırmanın ilerlemesini izleyin.Watch the progress of the run with a Jupyter widget. Çalıştırma gönderimi gibi pencere öğesi zaman uyumsuzdur ve iş bitene kadar her 10 ila 15 saniye canlı güncelleştirmeler sağlar:Like the run submission, the widget is asynchronous and provides live updates every 10 to 15 seconds until the job finishes:

from azureml.widgets import RunDetails
RunDetails(run).show()

Pencere öğesi eğitimin sonunda aşağıdaki gibi görünür:The widget will look like the following at the end of training:

Not defteri pencere öğesi

Bir çalıştırmayı iptal etmeniz gerekirse, Bu yönergeleriizleyebilirsiniz.If you need to cancel a run, you can follow these instructions.

Tamamlandıktan sonra günlük sonuçlarını almaGet log results upon completion

Model eğitimi ve izlemesi arka planda yapılır.Model training and monitoring happen in the background. Daha fazla kod çalıştırmadan önce model eğitimi bitirene kadar bekleyin.Wait until the model has finished training before you run more code. Model eğitiminin ne zaman bittiğini göstermek için wait_for_completion kullanın:Use wait_for_completion to show when the model training is finished:

run.wait_for_completion(show_output=False)  # specify True for a verbose log

Çalıştırma sonuçlarını görüntülemeDisplay run results

Artık uzak düğümde eğitilmiş bir modeliniz vardır.You now have a model trained on a remote cluster. Modelin doğruluğunu alın:Retrieve the accuracy of the model:

print(run.get_metrics())

Çıktıda, uzak modelde 0,9204 doğruluğu görülmektedir:The output shows the remote model has accuracy of 0.9204:

{'regularization rate': 0.8, 'accuracy': 0.9204}

Sonraki öğreticide, bu modeli daha ayrıntılı bir şekilde araştırın.In the next tutorial, you explore this model in more detail.

Modeli kaydetmeRegister model

Eğitim betiğindeki son adım dosya outputs/sklearn_mnist_model.pkl, işin çalıştırıldığı kümenin VM 'sinde outputs adlı bir dizinde yazdı.The last step in the training script wrote the file outputs/sklearn_mnist_model.pkl in a directory named outputs in the VM of the cluster where the job is run. outputs, bu dizindeki tüm içeriğin çalışma alanınıza otomatik olarak yüklendiği özel bir dizindir.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Bu içerik çalışma alanınızın altında yer alan denemedeki çalıştırma kaydında gösterilir.This content appears in the run record in the experiment under your workspace. Bu nedenle model dosyası artık çalışma alanınızda de kullanılabilir.So the model file is now also available in your workspace.

Bu çalıştırma ile ilişkili dosyaları görebilirsiniz:You can see files associated with that run:

print(run.get_file_names())

Daha sonra bu modeli sorgulayabilir, inceleyebilir ve dağıtabilmeniz için modeli çalışma alanına kaydedin.Register the model in the workspace, so that you or other collaborators can later query, examine, and deploy this model:

# register model
model = run.register_model(model_name='sklearn_mnist',
                           model_path='outputs/sklearn_mnist_model.pkl')
print(model.name, model.id, model.version, sep='\t')

Kaynakları temizlemeClean up resources

Önemli

Oluşturduğunuz kaynaklar, diğer Azure Machine Learning öğreticileri ve nasıl yapılır makalelerinde önkoşul olarak kullanılabilir.The resources you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Oluşturduğunuz kaynakları kullanmayı planlamıyorsanız, hiçbir ücret ödemezsiniz:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Azure portalının en sol tarafındaki Kaynak gruplarını seçin.In the Azure portal, select Resource groups on the far left.

    Azure portal silme Delete in the Azure portal

  2. Listeden oluşturduğunuz kaynak grubunu seçin.From the list, select the resource group you created.

  3. Kaynak grubunu sil'i seçin.Select Delete resource group.

  4. Kaynak grubu adını girin.Enter the resource group name. Ardından Sil’i seçin.Then select Delete.

Yalnızca Azure Machine Learning Işlem kümesini de silebilirsiniz.You can also delete just the Azure Machine Learning Compute cluster. Ancak otomatik ölçeklendirme açıktır ve küme en az sıfırdır.However, autoscale is turned on, and the cluster minimum is zero. Bu nedenle, bu belirli kaynak kullanımda olmadığında ek işlem ücretleri oluşturmaz:So this particular resource won't incur additional compute charges when not in use:

# optionally, delete the Azure Machine Learning Compute cluster
compute_target.delete()

Sonraki adımlarNext steps

Bu Azure Machine Learning öğreticide, aşağıdaki görevler için Python kullandınız:In this Azure Machine Learning tutorial, you used Python for the following tasks:

  • Geliştirme ortamınızı ayarlayın.Set up your development environment.
  • Verilere erişin ve verileri inceleyin.Access and examine the data.
  • Popüler scikit-makine öğrenimi kitaplığını kullanarak uzak kümede birden çok modeli eğitmeTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Eğitim ayrıntılarını gözden geçirin ve en iyi modeli kaydedin.Review training details and register the best model.

Bu kayıtlı modeli, öğretici serisinin sonraki bölümündeki yönergeleri kullanarak dağıtmaya hazırsınız:You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: