Azure Machine Learning modelleri dağıtmaDeploy models with Azure Machine Learning

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

Machine Learning modelinizi bir Web hizmeti olarak Azure bulutu 'nda veya Azure IoT Edge cihazlarda dağıtmayı öğrenin.Learn how to deploy your machine learning model as a web service in the Azure cloud or to Azure IoT Edge devices.

İş akışı modelinize nereden dağıttığınız her ne kadar benzerdir:The workflow is similar no matter where you deploy your model:

  1. Modeli kaydedin.Register the model.
  2. Dağıtmaya hazırlanın.Prepare to deploy. (Varlıkları, kullanımı, işlem hedefini belirtin.)(Specify assets, usage, compute target.)
  3. Modeli işlem hedefine dağıtın.Deploy the model to the compute target.
  4. Web hizmeti olarak da bilinen dağıtılan modeli test edin.Test the deployed model, also called a web service.

Dağıtım iş akışında yer alan kavramlar hakkında daha fazla bilgi için bkz. Azure Machine Learning modelleri yönetme, dağıtma ve izleme.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

ÖnkoşullarPrerequisites

Çalışma alanınıza bağlanınConnect to your workspace

Aşağıdaki kod, yerel geliştirme ortamında önbelleğe alınan bilgileri kullanarak bir Azure Machine Learning çalışma alanına bağlanmayı gösterir:The following code shows how to connect to an Azure Machine Learning workspace by using information cached to the local development environment:

  • SDK 'Yı kullanmaUsing the SDK

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

    Bir çalışma alanına bağlanmak için SDK 'Yı kullanma hakkında daha fazla bilgi için bkz. Python için Azure MACHINE LEARNING SDK belgeleri.For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python documentation.

  • CLı 'yi kullanmaUsing the CLI

    CLı kullanırken, komut için çalışma alanını belirtmek üzere -w veya --workspace-name parametresini kullanın.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

  • VS Code kullanmaUsing VS Code

    VS Code kullandığınızda, bir grafik arabirim kullanarak çalışma alanını seçersiniz.When you use VS Code, you select the workspace by using a graphical interface. Daha fazla bilgi için bkz. VS Code uzantısı belgelerindeki modelleri dağıtma ve yönetme .For more information, see Deploy and manage models in the VS Code extension documentation.

Modelinizi kaydetmeRegister your model

Kayıtlı bir model, modelinizi oluşturan bir veya daha fazla dosya için mantıksal bir kapsayıcıdır.A registered model is a logical container for one or more files that make up your model. Örneğin, birden çok dosyada depolanan bir modeliniz varsa, bunları çalışma alanına tek bir model olarak kaydedebilirsiniz.For example, if you have a model that's stored in multiple files, you can register them as a single model in the workspace. Dosyaları kaydettikten sonra, kayıtlı modeli indirebilir veya dağıtabilir ve kaydettiğiniz tüm dosyaları alabilirsiniz.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

İpucu

Bir modeli kaydettiğinizde, bir bulut konumunun (bir eğitim çalıştırmasında) ya da yerel bir dizinin yolunu sağlarsınız.When you register a model, you provide the path of either a cloud location (from a training run) or a local directory. Bu yol, kayıt işleminin bir parçası olarak karşıya yüklenecek dosyaları bulmak için yeterlidir.This path is just to locate the files for upload as part of the registration process. Giriş betiğinde kullanılan yol ile eşleşmesi gerekmez.It doesn't need to match the path used in the entry script. Daha fazla bilgi için bkz. giriş betiğinizdeki model dosyalarını bulma.For more information, see Locate model files in your entry script.

Machine Learning modelleri Azure Machine Learning çalışma alanınıza kaydedilir.Machine learning models are registered in your Azure Machine Learning workspace. Model Azure Machine Learning veya herhangi bir yerden gelebilir.The model can come from Azure Machine Learning or from somewhere else. Aşağıdaki örneklerde bir modelin nasıl kaydedileceği gösterilmektedir.The following examples demonstrate how to register a model.

Deneme çalıştırmasında bir modeli kaydetmeRegister a model from an experiment run

Bu bölümdeki kod parçacıkları, bir eğitim çalıştırmasının nasıl bir model kaydedeceğinizi göstermektedir:The code snippets in this section demonstrate how to register a model from a training run:

Önemli

Bu kod parçacıklarını kullanmak için, daha önce bir eğitim çalışması gerçekleştirdiyseniz ve Run nesnesine (SDK örneği) veya çalıştırma KIMLIĞI değerine (CLı örneği) erişiminizin olması gerekir.To use these snippets, you need to have previously performed a training run and you need to have access to the Run object (SDK example) or the run ID value (CLI example). Eğitim modelleri hakkında daha fazla bilgi için bkz. model eğitimi için işlem hedeflerini ayarlama.For more information on training models, see Set up compute targets for model training.

  • SDK 'Yı kullanmaUsing the SDK

    Bir modeli eğitebilmeniz için SDK 'yı kullandığınızda, modeli eğitidiğinize bağlı olarak bir Run nesnesi ya da bir oto mlrun nesnesi alabilirsiniz.When you use the SDK to train a model, you can receive either a Run object or an AutoMLRun object, depending on how you trained the model. Her nesne, bir deneme çalıştırması tarafından oluşturulan bir modeli kaydetmek için kullanılabilir.Each object can be used to register a model created by an experiment run.

    • azureml.core.Run nesnesinden model kaydetme:Register a model from an azureml.core.Run object:

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

      model_path parametresi, modelin bulut konumunu ifade eder.The model_path parameter refers to the cloud location of the model. Bu örnekte, tek bir dosyanın yolu kullanılır.In this example, the path of a single file is used. Model kaydına birden çok dosya eklemek için model_path, dosyaları içeren bir klasörün yoluna ayarlayın.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. Daha fazla bilgi için bkz . Run. register_model belgeleri.For more information, see the Run.register_model documentation.

    • azureml.train.automl.run.AutoMLRun nesnesinden model kaydetme:Register a model from an azureml.train.automl.run.AutoMLRun object:

          description = 'My AutoML Model'
          model = run.register_model(description = description)
      
          print(run.model_id)
      

      Bu örnekte metric ve iteration parametreleri belirtilmediği için en iyi birincil ölçüye sahip yineleme kaydedilir.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. Çalışma alanından döndürülen model_id değeri bir model adı yerine kullanılır.The model_id value returned from the run is used instead of a model name.

      Daha fazla bilgi için bkz. oto Mlrun. register_model belgeleri.For more information, see the AutoMLRun.register_model documentation.

  • CLı 'yi kullanmaUsing the CLI

    az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --run-id myrunid
    

    İpucu

    Ml uzantısının yüklenmediğini belirten bir hata iletisi alırsanız, yüklemek için aşağıdaki komutu kullanın:If you get an error message stating that the ml extension isn't installed, use the following command to install it:

    az extension add -n azure-cli-ml
    

    --asset-path parametresi, modelin bulut konumunu ifade eder.The --asset-path parameter refers to the cloud location of the model. Bu örnekte, tek bir dosyanın yolu kullanılır.In this example, the path of a single file is used. Model kaydına birden çok dosya eklemek için --asset-path, dosyaları içeren bir klasörün yoluna ayarlayın.To include multiple files in the model registration, set --asset-path to the path of a folder that contains the files.

  • VS Code kullanmaUsing VS Code

    Vs Code uzantısını kullanarak model dosyalarını veya klasörleri kullanarak modelleri kaydedin.Register models using any model files or folders by using the VS Code extension.

Yerel dosyadan model kaydetmeRegister a model from a local file

Modelin yerel yolunu sağlayarak bir modeli kaydedebilirsiniz.You can register a model by providing the local path of the model. Bir klasörün ya da tek bir dosyanın yolunu sağlayabilirsiniz.You can provide the path of either a folder or a single file. Bu yöntemi, Azure Machine Learning eğitilen ve daha sonra indirilen modelleri kaydetmek için kullanabilirsiniz.You can use this method to register models trained with Azure Machine Learning and then downloaded. Bu yöntemi, Azure Machine Learning dışında eğitilen modelleri kaydetmek için de kullanabilirsiniz.You can also use this method to register models trained outside of Azure Machine Learning.

Önemli

Yalnızca bir güvenilen kaynaktan oluşturduğunuz veya aldığınız modelleri kullanmanız gerekir.You should use only models that you create or obtain from a trusted source. Bir dizi popüler biçimde güvenlik açıkları bulunduğundan, serileştirilmiş modelleri kod olarak değerlendirmelisiniz.You should treat serialized models as code, because security vulnerabilities have been discovered in a number of popular formats. Ayrıca, modeller taraflı veya hatalı çıktılar sağlamak üzere kötü amaçlı olarak kötü amaçlı olarak eğitilmiş olabilir.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • SDK ve ONNX kullanmaUsing the SDK and ONNX

    import os
    import urllib.request
    from azureml.core.model import Model
    # Download model
    onnx_model_url = "https://www.cntk.ai/OnnxModels/mnist/opset_7/mnist.tar.gz"
    urllib.request.urlretrieve(onnx_model_url, filename="mnist.tar.gz")
    os.system('tar xvzf mnist.tar.gz')
    # Register model
    model = Model.register(workspace = ws,
                            model_path ="mnist/model.onnx",
                            model_name = "onnx_mnist",
                            tags = {"onnx": "demo"},
                            description = "MNIST image classification CNN from ONNX Model Zoo",)
    

    Model kaydına birden çok dosya eklemek için model_path, dosyaları içeren bir klasörün yoluna ayarlayın.To include multiple files in the model registration, set model_path to the path of a folder that contains the files.

  • CLı 'yi kullanmaUsing the CLI

    az ml model register -n onnx_mnist -p mnist/model.onnx
    

    Model kaydına birden çok dosya eklemek için -p, dosyaları içeren bir klasörün yoluna ayarlayın.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

Tahmini süre: yaklaşık 10 saniye.Time estimate: Approximately 10 seconds.

Daha fazla bilgi için model sınıfınayönelik belgelere bakın.For more information, see the documentation for the Model class.

Azure Machine Learning dışında eğitilen modellerle çalışma hakkında daha fazla bilgi için bkz. var olan bir modeli dağıtma.For more information on working with models trained outside Azure Machine Learning, see How to deploy an existing model.

İşlem hedefi seçinChoose a compute target

Web hizmeti dağıtımınızı barındırmak için aşağıdaki işlem hedeflerini veya işlem kaynaklarını kullanabilirsiniz:You can use the following compute targets, or compute resources, to host your web service deployment:

İşlem hedefiCompute target Kullanıldığı yerlerUsed for GPU desteğiGPU support FPGA desteğiFPGA support AçıklamaDescription
Yerel Web hizmetiLocal web service Test/hata ayıklamaTesting/debugging     Sınırlı test ve sorun giderme için kullanın.Use for limited testing and troubleshooting. Donanım hızlandırma, yerel sistemdeki kitaplıkların kullanımına bağlıdır.Hardware acceleration depends on use of libraries in the local system.
 Web hizmeti Azure Machine Learning işlem örneğiAzure Machine Learning compute instance web service Test/hata ayıklamaTesting/debugging     Sınırlı test ve sorun giderme için kullanın.Use for limited testing and troubleshooting.
Azure Kubernetes Service (AKS)Azure Kubernetes Service (AKS) Gerçek zamanlı çıkarımReal-time inference Evet (Web hizmeti dağıtımı)Yes (web service deployment) EvetYes Yüksek ölçekli üretim dağıtımları için kullanın.Use for high-scale production deployments. Dağıtılan hizmetin hızlı yanıt süresini ve otomatik ölçeklendirilmesini sağlar.Provides fast response time and autoscaling of the deployed service. Küme otomatik ölçeklendirme, Azure Machine Learning SDK aracılığıyla desteklenmez.Cluster autoscaling isn't supported through the Azure Machine Learning SDK. AKS kümesindeki düğümleri değiştirmek için Azure portal AKS kümeniz için Kullanıcı arabirimini kullanın.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. AKS, tasarımcı için kullanılabilen tek seçenektir.AKS is the only option available for the designer.
Azure Container InstancesAzure Container Instances Test veya geliştirmeTesting or development     48 GB 'den az RAM gerektiren düşük ölçekli CPU tabanlı iş yükleri için kullanın.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
İşlem kümelerini Azure Machine LearningAzure Machine Learning compute clusters Önizle Batch çıkarımı(Preview) Batch inference Evet (Machine Learning işlem hattı)Yes (machine learning pipeline)   Batch Puanlama 'nı sunucusuz işlem üzerinde çalıştırın.Run batch scoring on serverless compute. Normal ve düşük öncelikli VM 'Leri destekler.Supports normal and low-priority VMs.
Azure İşlevleriAzure Functions Önizle Gerçek zamanlı çıkarım(Preview) Real-time inference      
Azure IoT EdgeAzure IoT Edge Önizle IoT modülü(Preview) IoT module     IoT cihazlarında ML modellerini dağıtın ve sunun.Deploy and serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge IoT Edge aracılığıylaVia IoT Edge   YesYes IoT cihazlarında ML modellerini dağıtın ve sunun.Deploy and serve ML models on IoT devices.

Not

Yerel, Azure Machine Learning işlem örneği gibi işlem hedefleri ve Azure Machine Learning işlem kümeleri eğitim ve deneme için GPU 'YU desteklese de, Web hizmeti olarak dağıtıldığında , yalnızca Azure Kubernetes hizmetinde desteklenir.Although compute targets like local, Azure Machine Learning compute instance, and Azure Machine Learning compute clusters support GPU for training and experimentation, using GPU for inference when deployed as a web service is supported only on Azure Kubernetes Service.

Makine öğrenimi ardışık düzenine sahip Puanlama yalnızca Azure Machine Learning işlem sırasında desteklenirken çıkarımı için GPU kullanımı desteklenir.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

Dağıtmaya hazırlanmaPrepare to deploy

Modeli dağıtmak için aşağıdaki öğeler gereklidir:To deploy the model, you need the following items:

  • Bir giriş betiği.An entry script. Bu betik istekleri kabul eder, modeli kullanarak istekleri puan eder ve sonuçları döndürür.This script accepts requests, scores the requests by using the model, and returns the results.

    Önemli

    • Giriş betiği modelinize özeldir.The entry script is specific to your model. Gelen istek verilerinin biçimini, modelinizde beklenen verilerin biçimini ve istemcilere döndürülen verilerin biçimini anlamalıdır.It must understand the format of the incoming request data, the format of the data expected by your model, and the format of the data returned to clients.

      İstek verileri modelinize uygun olmayan bir biçimdeyse, komut dosyası bunu kabul edilebilir bir biçime dönüştürebilir.If the request data is in a format that's not usable by your model, the script can transform it into an acceptable format. Ayrıca, yanıtı istemciye döndürmeden önce dönüştürebilir.It can also transform the response before returning it to the client.

    • Azure Machine Learning SDK, Web Hizmetleri veya IoT Edge dağıtımlarının veri deponuza veya veri kümelerine erişmesi için bir yol sağlamaz.The Azure Machine Learning SDK doesn't provide a way for web services or IoT Edge deployments to access your data store or datasets. Dağıtılmış modelinizin, bir Azure depolama hesabındaki veriler gibi dağıtım dışında depolanan verilere erişmesi gerekiyorsa, ilgili SDK 'yı kullanarak özel bir kod çözümü geliştirmeniz gerekir.If your deployed model needs to access data stored outside the deployment, like data in an Azure storage account, you must develop a custom code solution by using the relevant SDK. Örneğin, Python Için Azure depolama SDK 'sı.For example, the Azure Storage SDK for Python.

      Senaryonuz için işe yönelik bir alternatif, Puanlama sırasında veri depolarına erişim sağlayan toplu tahmindir.An alternative that might work for your scenario is batch prediction, which does provide access to data stores during scoring.

  • Giriş betiğini veya modelini çalıştırmak için gereken yardımcı betikler veya Python/Conda paketleri gibi Bağımlılıklar.Dependencies, like helper scripts or Python/Conda packages required to run the entry script or model.

  • Dağıtılan modeli barındıran işlem hedefi için dağıtım yapılandırması .The deployment configuration for the compute target that hosts the deployed model. Bu yapılandırma, modeli çalıştırmak için gereken bellek ve CPU gereksinimleri gibi şeyleri açıklar.This configuration describes things like memory and CPU requirements needed to run the model.

Bu öğeler bir çıkarım yapılandırmasına ve bir dağıtım yapılandırmasınakapsüllenir.These items are encapsulated into an inference configuration and a deployment configuration. Çıkarım yapılandırması, giriş betiğine ve diğer bağımlılıklara başvurur.The inference configuration references the entry script and other dependencies. Dağıtımı gerçekleştirmek için SDK 'Yı kullandığınızda bu konfigürasyonları programlama yoluyla tanımlarsınız.You define these configurations programmatically when you use the SDK to perform the deployment. CLı kullandığınızda bunları JSON dosyalarında tanımlarsınız.You define them in JSON files when you use the CLI.

1. giriş betiğinizi ve bağımlılıklarınızı tanımlayın1. Define your entry script and dependencies

Giriş betiği dağıtılan bir Web hizmetine gönderilen verileri alır ve modele geçirir.The entry script receives data submitted to a deployed web service and passes it to the model. Ardından model tarafından döndürülen yanıtı alır ve istemciye döndürür.It then takes the response returned by the model and returns that to the client. Betik, modelinize özeldir.The script is specific to your model. Modelin beklediği ve döndürdüğü verileri anlaması gerekir.It must understand the data that the model expects and returns.

Betik, modeli yükleyen ve çalıştıran iki işlev içerir:The script contains two functions that load and run the model:

  • init(): Bu işlev genellikle modeli genel bir nesneye yükler.init(): Typically, this function loads the model into a global object. Bu işlev, Web hizmetiniz için Docker kapsayıcısı başlatıldığında yalnızca bir kez çalıştırılır.This function is run only once, when the Docker container for your web service is started.

  • run(input_data): Bu işlev, giriş verilerine göre bir değeri tahmin etmek için modeli kullanır.run(input_data): This function uses the model to predict a value based on the input data. Çalıştırmanın giriş ve çıkışları genellikle serileştirme ve seri durumundan çıkarma için JSON kullanır.Inputs and outputs of the run typically use JSON for serialization and deserialization. Ham ikili verilerle de çalışabilirsiniz.You can also work with raw binary data. Verileri modele göndermeden önce veya istemciye döndürmeden önce dönüştürebilirsiniz.You can transform the data before sending it to the model or before returning it to the client.

Giriş betiğinizdeki model dosyalarını bulunLocate model files in your entry script

Giriş betiğinizdeki modelleri bulmanın iki yolu vardır:There are two ways to locate models in your entry script:

  • AZUREML_MODEL_DIR: model konumunun yolunu içeren bir ortam değişkeni.AZUREML_MODEL_DIR: An environment variable containing the path to the model location.
  • Model.get_model_path: kayıtlı model adı kullanılarak model dosyasının yolunu döndüren bir API.Model.get_model_path: An API that returns the path to model file using the registered model name.
AZUREML_MODEL_DIRAZUREML_MODEL_DIR

AZUREML_MODEL_DIR, hizmet dağıtımı sırasında oluşturulan bir ortam değişkenidir.AZUREML_MODEL_DIR is an environment variable created during service deployment. Dağıtılan model konumunu bulmak için bu ortam değişkenini kullanabilirsiniz.You can use this environment variable to find the location of the deployed model(s).

Aşağıdaki tabloda, dağıtılan modellerin sayısına bağlı olarak AZUREML_MODEL_DIR değeri açıklanmaktadır:The following table describes the value of AZUREML_MODEL_DIR depending on the number of models deployed:

DağıtımDeployment Ortam değişkeni değeriEnvironment variable value
Tek modelSingle model Modeli içeren klasörün yolu.The path to the folder containing the model.
Birden çok modelMultiple models Tüm modelleri içeren klasörün yolu.The path to the folder containing all models. Modeller bu klasördeki ad ve sürüm ile bulunur ($MODEL_NAME/$VERSION)Models are located by name and version in this folder ($MODEL_NAME/$VERSION)

Bir modeldeki bir dosyanın yolunu almak için, ortam değişkenini aradığınız dosya adıyla birleştirin.To get the path to a file in a model, combine the environment variable with the filename you're looking for. Model dosyalarının dosya adları kayıt ve dağıtım sırasında korunur.The filenames of the model files are preserved during registration and deployment.

Tek model örneğiSingle model example

model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')

Birden çok model örneğiMultiple model example

model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_model/1/sklearn_regression_model.pkl')
get_model_pathget_model_path

Bir modeli kaydettiğinizde, kayıt defterinde modeli yönetmek için kullanılan bir model adı sağlarsınız.When you register a model, you provide a model name that's used for managing the model in the registry. Bu adı model dosyasının veya yerel dosya sistemindeki dosyaların yolunu almak için model. get_model_path () yöntemiyle birlikte kullanırsınız.You use this name with the Model.get_model_path() method to retrieve the path of the model file or files on the local file system. Bir klasörü veya dosya koleksiyonunu kaydettiğinizde, bu API bu dosyaları içeren dizinin yolunu döndürür.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Bir modeli kaydettiğinizde, buna bir ad verirsiniz.When you register a model, you give it a name. Ad, modelin yerel olarak ya da hizmet dağıtımı sırasında yerleştirildiği yere karşılık gelir.The name corresponds to where the model is placed, either locally or during service deployment.

Önemli

Bir modeli eğitebilmeniz için otomatik makine öğrenimi kullandıysanız, model adı olarak model_id bir değer kullanılır.If you used automated machine learning to train a model, a model_id value is used as the model name. Otomatik makine öğrenimi ile eğitilen bir modeli kaydetme ve dağıtmayla ilgili bir örnek için bkz. GitHub 'da Azure/Machinelearningnot defterleri .For an example of registering and deploying a model trained with automated machine learning, see Azure/MachineLearningNotebooks on GitHub.

Aşağıdaki örnek, sklearn_mnist_model.pkl adlı tek bir dosyanın yolunu döndürür (sklearn_mnistadı ile kaydedilir):The following example will return a path to a single file called sklearn_mnist_model.pkl (which was registered with the name sklearn_mnist):

model_path = Model.get_model_path('sklearn_mnist')

Seçim Otomatik şema oluşturma(Optional) Automatic schema generation

Web hizmetiniz için otomatik olarak bir şema oluşturmak üzere, tanımlı tür nesnelerinden biri için kurucudaki girişin ve/veya çıktının bir örneğini sağlayın.To automatically generate a schema for your web service, provide a sample of the input and/or output in the constructor for one of the defined type objects. Tür ve örnek, otomatik olarak şemayı oluşturmak için kullanılır.The type and sample are used to automatically create the schema. Azure Machine Learning, dağıtım sırasında Web hizmeti için bir Openapı (Swagger) belirtimi oluşturur.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Bu türler Şu anda destekleniyor:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • Standart Python nesnesiStandard Python object

Şema oluşturmayı kullanmak için, inference-schema paketini Conda ortam dosyanıza ekleyin.To use schema generation, include the inference-schema package in your Conda environment file. Bu paket hakkında daha fazla bilgi için bkz. https://github.com/Azure/InferenceSchema.For more information on this package, see https://github.com/Azure/InferenceSchema.

Örnek bağımlılıklar dosyasıExample dependencies file

Aşağıdaki YAML, çıkarım için Conda Dependencies bir dosya örneğidir:The following YAML is an example of a Conda dependencies file for inference:

name: project_environment
dependencies:
  - python=3.6.2
  - scikit-learn=0.20.0
  - pip:
    - azureml-defaults
    - inference-schema[numpy-support]

Önemli

Eğer koda ve PIP (PyPi) ile bağımlılığı varsa Microsoft, Conda 'in, daha güvenilir bir şekilde yükleme yapan önceden oluşturulmuş ikili dosyalarla birlikte geldiğinden, Conda sürümünün kullanılmasını önerir.If your dependency is available through both Conda and pip (from PyPi), Microsoft recommends using the Conda version, as Conda packages typically come with pre-built binaries that make installation more reliable.

Daha fazla bilgi için bkz. Conda ve PIP 'Yi anlama.For more information, see Understanding Conda and Pip.

Bağımlılarınızın Conda ile kullanılabilir olup olmadığını denetlemek için conda search <package-name> komutunu kullanın veya https://anaconda.org/anaconda/repo ve https://anaconda.org/conda-forge/repopaket dizinlerini kullanın.To check if your dependency is available through Conda, use the conda search <package-name> command, or use the package indexes at https://anaconda.org/anaconda/repo and https://anaconda.org/conda-forge/repo.

Otomatik şema oluşturmayı kullanmak istiyorsanız, giriş betiğinizin inference-schema paketlerini içeri aktarması gerekir.If you want to use automatic schema generation, your entry script must import the inference-schema packages.

Web hizmetinin istek ve yanıt biçimlerini temsil eden input_sample ve output_sample değişkenlerinde giriş ve çıkış örnek biçimlerini tanımlayın.Define the input and output sample formats in the input_sample and output_sample variables, which represent the request and response formats for the web service. Bu örnekleri, run() işlevindeki giriş ve çıkış işlevi dekoratlarını kullanın.Use these samples in the input and output function decorators on the run() function. Aşağıdaki scikit-örnek, şema oluşturmayı kullanır.The following scikit-learn example uses schema generation.

Örnek giriş betiğiExample entry script

Aşağıdaki örnek, JSON verilerinin nasıl kabul edileceği ve geri dönebileceğinizi göstermektedir:The following example demonstrates how to accept and return JSON data:

#Example: scikit-learn and Swagger
import json
import numpy as np
import os
from sklearn.externals import joblib
from sklearn.linear_model import Ridge

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType


def init():
    global model
    # AZUREML_MODEL_DIR is an environment variable created during deployment. Join this path with the filename of the model file.
    # It holds the path to the directory that contains the deployed model (./azureml-models/$MODEL_NAME/$VERSION).
    # If there are multiple models, this value is the path to the directory containing all deployed models (./azureml-models).
    # Alternatively: model_path = Model.get_model_path('sklearn_mnist')
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_mnist_model.pkl')
    # Deserialize the model file back into a sklearn model
    model = joblib.load(model_path)


input_sample = np.array([[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]])
output_sample = np.array([3726.995])


@input_schema('data', NumpyParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Aşağıdaki örnek, veri çerçevesini kullanarak giriş verilerinin bir <key: value> sözlüğü olarak nasıl tanımlanacağını göstermektedir.The following example demonstrates how to define the input data as a <key: value> dictionary by using a DataFrame. Bu yöntem, dağıtılan Web hizmetinin Power BI tüketmesi için desteklenir.This method is supported for consuming the deployed web service from Power BI. (Power BI Web hizmetini kullanma hakkında daha fazla bilgi edinin.)(Learn more about how to consume the web service from Power BI.)

import json
import pickle
import numpy as np
import pandas as pd
import azureml.train.automl
from sklearn.externals import joblib
from azureml.core.model import Model

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType
from inference_schema.parameter_types.pandas_parameter_type import PandasParameterType


def init():
    global model
    # Replace filename if needed.
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'model_file.pkl')
    # Deserialize the model file back into a sklearn model.
    model = joblib.load(model_path)


input_sample = pd.DataFrame(data=[{
    # This is a decimal type sample. Use the data type that reflects this column in your data.
    "input_name_1": 5.1,
    # This is a string type sample. Use the data type that reflects this column in your data.
    "input_name_2": "value2",
    # This is an integer type sample. Use the data type that reflects this column in your data.
    "input_name_3": 3
}])

# This is an integer type sample. Use the data type that reflects the expected result.
output_sample = np.array([0])


@input_schema('data', PandasParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Daha fazla örnek için aşağıdaki betiklerine bakın:For more examples, see the following scripts:

İkili verilerBinary data

Modeliniz bir görüntü gibi ikili verileri kabul ediyorsa, dağıtımınız için kullanılan score.py dosyasını ham HTTP isteklerini kabul edecek şekilde değiştirmeniz gerekir.If your model accepts binary data, like an image, you must modify the score.py file used for your deployment to accept raw HTTP requests. Ham verileri kabul etmek için, giriş betiğinizdeki AMLRequest sınıfını kullanın ve @rawhttp dekoratörü run() işlevine ekleyin.To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

İkili verileri kabul eden bir score.py örneği aşağıda verilmiştir:Here's an example of a score.py that accepts binary data:

from azureml.contrib.services.aml_request import AMLRequest, rawhttp
from azureml.contrib.services.aml_response import AMLResponse


def init():
    print("This is init()")


@rawhttp
def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example just returns the posted data as the response.
        return AMLResponse(reqBody, 200)
    else:
        return AMLResponse("bad request", 500)

Önemli

AMLRequest sınıfı azureml.contrib ad alanıdır.The AMLRequest class is in the azureml.contrib namespace. Bu ad alanındaki varlıklar, hizmeti geliştirmek için çalışmamız sırasında sıklıkla değişir.Entities in this namespace change frequently as we work to improve the service. Bu ad alanındaki her türlü şey, Microsoft tarafından tam olarak desteklenmeyen bir önizleme olarak düşünülmelidir.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Bunu yerel geliştirme ortamınızda test etmeniz gerekirse, aşağıdaki komutu kullanarak bileşenleri yükleyebilirsiniz:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

Çıkış noktaları arası kaynak paylaşımı (CORS)Cross-origin resource sharing (CORS)

Çıkış noktaları arası kaynak paylaşımı, bir Web sayfasındaki kaynakların başka bir etki alanından istenmesinin izin vermesinin bir yoludur.Cross-origin resource sharing is a way to allow resources on a web page to be requested from another domain. CORS, istemci isteğiyle gönderilen ve hizmet yanıtıyla döndürülen HTTP üstbilgileri aracılığıyla çalışmaktadır.CORS works via HTTP headers sent with the client request and returned with the service response. CORS ve geçerli üstbilgiler hakkında daha fazla bilgi için bkz. Vikipde çıkış noktaları arası kaynak paylaşma .For more information on CORS and valid headers, see Cross-origin resource sharing in Wikipedia.

Model dağıtımınızı CORS 'yi destekleyecek şekilde yapılandırmak için giriş betiğinizdeki AMLResponse sınıfını kullanın.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Bu sınıf, yanıt nesnesindeki üst bilgileri ayarlamanıza olanak sağlar.This class allows you to set the headers on the response object.

Aşağıdaki örnek, giriş betiğinin yanıt için Access-Control-Allow-Origin üst bilgisini ayarlar:The following example sets the Access-Control-Allow-Origin header for the response from the entry script:

from azureml.contrib.services.aml_response import AMLResponse

def init():
    print("This is init()")

def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example
        # adds a header and returns the request body.
        resp = AMLResponse(reqBody, 200)
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        return resp
    else:
        return AMLResponse("bad request", 500)

Önemli

AMLResponse sınıfı azureml.contrib ad alanıdır.The AMLResponse class is in the azureml.contrib namespace. Bu ad alanındaki varlıklar, hizmeti geliştirmek için çalışmamız sırasında sıklıkla değişir.Entities in this namespace change frequently as we work to improve the service. Bu ad alanındaki her türlü şey, Microsoft tarafından tam olarak desteklenmeyen bir önizleme olarak düşünülmelidir.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Bunu yerel geliştirme ortamınızda test etmeniz gerekirse, aşağıdaki komutu kullanarak bileşenleri yükleyebilirsiniz:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

2. ınısenceconfig 'nizi tanımlayın2. Define your InferenceConfig

Çıkarım yapılandırması, tahmine dayalı hale getirmek üzere modelin nasıl yapılandırılacağını açıklar.The inference configuration describes how to configure the model to make predictions. Bu yapılandırma giriş betiğinizin bir parçası değil.This configuration isn't part of your entry script. Giriş betiğine başvurur ve dağıtım için gerekli tüm kaynakları bulmak için kullanılır.It references your entry script and is used to locate all the resources required by the deployment. Modeli dağıtırken daha sonra kullanılır.It's used later, when you deploy the model.

Çıkarım yapılandırması, dağıtımınız için gereken yazılım bağımlılıklarını tanımlamak için Azure Machine Learning ortamlar kullanabilir.Inference configuration can use Azure Machine Learning environments to define the software dependencies needed for your deployment. Ortamlar, eğitim ve dağıtım için gereken yazılım bağımlılıklarını oluşturmanıza, yönetmenize ve yeniden kullanmanıza olanak tanır.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. Aşağıdaki örnek, çalışma alanınızdan bir ortamı yüklemeyi ve ardından çıkarım yapılandırmasıyla kullanmayı gösterir:The following example demonstrates loading an environment from your workspace and then using it with the inference configuration:

from azureml.core import Environment
from azureml.core.model import InferenceConfig

deploy_env = Environment.get(workspace=ws,name="myenv",version="1")
inference_config = InferenceConfig(entry_script="x/y/score.py",
                                   environment=deploy_env)

Ortamlar hakkında daha fazla bilgi için bkz. eğitim ve dağıtım için ortamları oluşturma ve yönetme.For more information on environments, see Create and manage environments for training and deployment.

Ayrıca, bir ortamı kullanmadan bağımlılıkları doğrudan belirtebilirsiniz.You can also directly specify the dependencies without using an environment. Aşağıdaki örnek, bir Conda dosyasından yazılım bağımlılıklarını yükleyen bir çıkarım yapılandırmasının nasıl oluşturulacağını gösterir:The following example demonstrates how to create an inference configuration that loads software dependencies from a Conda file:

from azureml.core.model import InferenceConfig

inference_config = InferenceConfig(runtime="python",
                                   entry_script="x/y/score.py",
                                   conda_file="env/myenv.yml")

Daha fazla bilgi için bkz. ınenceconfig sınıfı belgeleri.For more information, see the InferenceConfig class documentation.

Bir çıkarım yapılandırmasıyla özel bir Docker görüntüsü kullanma hakkında daha fazla bilgi için bkz. özel bir Docker görüntüsü kullanarak model dağıtma.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

Inenceconfig CLı örneğiCLI example of InferenceConfig

inferenceconfig.json belgesindeki girdiler, ınenceconfig sınıfının parametreleriyle eşlenir.The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. Aşağıdaki tabloda, JSON belgesindeki varlıklar ve yöntemin parametreleri arasındaki eşleme açıklanmaktadır:The following table describes the mapping between entities in the JSON document and the parameters for the method:

JSON varlığıJSON entity Yöntem parametresiMethod parameter AçıklamaDescription
entryScript entry_script Görüntüde çalıştırılacak kodu içeren yerel bir dosyanın yolu.Path to a local file that contains the code to run for the image.
runtime runtime Görüntü için kullanılacak çalışma zamanı.Which runtime to use for the image. Desteklenen geçerli çalışma zamanları spark-py ve python.Current supported runtimes are spark-py and python.
condaFile conda_file İsteğe bağlı.Optional. Görüntü için kullanılacak Conda ortam tanımını içeren yerel bir dosyanın yolu.Path to a local file that contains a Conda environment definition to use for the image.
extraDockerFileSteps extra_docker_file_steps İsteğe bağlı.Optional. Görüntüyü ayarlarken çalıştırılacak ek Docker adımlarını içeren yerel bir dosyanın yolu.Path to a local file that contains additional Docker steps to run when setting up the image.
sourceDirectory source_directory İsteğe bağlı.Optional. Görüntüyü oluşturmak için tüm dosyaları içeren klasörlerin yolu.Path to folders that contain all files to create the image.
enableGpu enable_gpu İsteğe bağlı.Optional. Görüntüde GPU desteğinin etkinleştirilip etkinleştirilmeyeceğini belirtir.Whether to enable GPU support in the image. GPU görüntüsünün Azure Container Instances, Azure Machine Learning Işlem, Azure sanal makineleri ve Azure Kubernetes hizmeti gibi bir Azure hizmetinde kullanılması gerekir.The GPU image must be used on an Azure service, like Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. Varsayılan değer false 'dur.The default is False.
baseImage base_image İsteğe bağlı.Optional. Temel görüntü olarak kullanılacak özel görüntü.Custom image to be used as a base image. Hiçbir temel görüntü sağlanmazsa, görüntü, belirtilen çalışma zamanı parametresini temel alır.If no base image is provided, the image will be based on the provided runtime parameter.
baseImageRegistry base_image_registry İsteğe bağlı.Optional. Temel görüntüyü içeren görüntü kayıt defteri.Image registry that contains the base image.
cudaVersion cuda_version İsteğe bağlı.Optional. GPU desteği gerektiren görüntüler için yüklenecek CUDA sürümü.Version of CUDA to install for images that need GPU support. GPU görüntüsünün Azure Container Instances, Azure Machine Learning Işlem, Azure sanal makineleri ve Azure Kubernetes hizmeti gibi bir Azure hizmetinde kullanılması gerekir.The GPU image must be used on an Azure service, like Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. Desteklenen sürümler 9,0, 9,1 ve 10,0.Supported versions are 9.0, 9.1, and 10.0. enable_gpu ayarlandıysa, varsayılan değer 9,1 ' dir.If enable_gpu is set, the default is 9.1.
description description Görüntü için bir açıklama.A description for the image.

Aşağıdaki JSON, CLı ile kullanılacak örnek bir çıkarım yapılandırması örneğidir:The following JSON is an example inference configuration for use with the CLI:

{
    "entryScript": "score.py",
    "runtime": "python",
    "condaFile": "myenv.yml",
    "extraDockerfileSteps": null,
    "sourceDirectory": null,
    "enableGpu": false,
    "baseImage": null,
    "baseImageRegistry": null
}

Aşağıdaki komut, CLı kullanarak bir modelin nasıl dağıtılacağını göstermektedir:The following command demonstrates how to deploy a model by using the CLI:

az ml model deploy -n myservice -m mymodel:1 --ic inferenceconfig.json

Bu örnekte, yapılandırma aşağıdaki ayarları belirtir:In this example, the configuration specifies the following settings:

  • Model Python gerektirir.That the model requires Python.
  • Dağıtılan hizmete gönderilen Web isteklerini işlemek için kullanılan giriş betiği.The entry script, which is used to handle web requests sent to the deployed service.
  • Çıkarımı için gereken Python paketlerini açıklayan Conda dosyası.The Conda file that describes the Python packages needed for inference.

Bir çıkarım yapılandırmasıyla özel bir Docker görüntüsü kullanma hakkında daha fazla bilgi için bkz. özel bir Docker görüntüsü kullanarak model dağıtma.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

3. dağıtım yapılandırmanızı tanımlayın3. Define your deployment configuration

Modelinizi dağıtılmadan önce dağıtım yapılandırmasını tanımlamanız gerekir.Before deploying your model, you must define the deployment configuration. Dağıtım yapılandırması, Web hizmetini barındıracak işlem hedefine özgüdür.The deployment configuration is specific to the compute target that will host the web service. Örneğin, bir modeli yerel olarak dağıttığınızda, hizmetin istekleri kabul ettiği bağlantı noktasını belirtmeniz gerekir.For example, when you deploy a model locally, you must specify the port where the service accepts requests. Dağıtım yapılandırması, giriş betiğinizin bir parçası değil.The deployment configuration isn't part of your entry script. Model ve giriş betiğini barındıracak işlem hedefinin özelliklerini tanımlamak için kullanılır.It's used to define the characteristics of the compute target that will host the model and entry script.

Ayrıca, çalışma alanınız ile ilişkili bir Azure Kubernetes Service (AKS) örneğiniz yoksa, işlem kaynağını oluşturmanız da gerekebilir.You might also need to create the compute resource, if, for example, you don't already have an Azure Kubernetes Service (AKS) instance associated with your workspace.

Aşağıdaki tabloda her işlem hedefi için bir dağıtım yapılandırması oluşturma örneği verilmiştir:The following table provides an example of creating a deployment configuration for each compute target:

Hedef işlemCompute target Dağıtım yapılandırma örneğiDeployment configuration example
YerelLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Azure Container InstancesAzure Container Instances deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Azure Kubernetes ServiceAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

Yerel, Azure Container Instances ve AKS Web Hizmetleri için sınıflar azureml.core.webserviceiçeri aktarılabilir:The classes for local, Azure Container Instances, and AKS web services can be imported from azureml.core.webservice:

from azureml.core.webservice import AciWebservice, AksWebservice, LocalWebservice

Profil OluşturmaProfiling

Modelinizi bir hizmet olarak dağıtmadan önce en iyi CPU ve bellek gereksinimlerini öğrenmek için profili oluşturmanız gerekebilir.Before you deploy your model as a service, you might want to profile it to determine optimal CPU and memory requirements. Modelinizin profilini eklemek için SDK veya CLı kullanabilirsiniz.You can use either the SDK or the CLI to profile your model. Aşağıdaki örnekler SDK kullanarak bir modelin profilini oluşturmayı gösterir.The following examples show how to profile a model by using the SDK.

Önemli

Profil oluşturma kullandığınızda, sağladığınız çıkarım yapılandırması bir Azure Machine Learning ortamına başvuramaz.When you use profiling, the inference configuration that you provide can't reference an Azure Machine Learning environment. Bunun yerine, InferenceConfig nesnesinin conda_file parametresini kullanarak yazılım bağımlılıklarını tanımlayın.Instead, define the software dependencies by using the conda_file parameter of the InferenceConfig object.

import json
test_sample = json.dumps({'data': [
    [1,2,3,4,5,6,7,8,9,10]
]})

profile = Model.profile(ws, "profilemymodel", [model], inference_config, test_data)
profile.wait_for_profiling(True)
profiling_results = profile.get_results()
print(profiling_results)

Bu kod, aşağıdaki çıktıya benzer bir sonuç görüntüler:This code displays a result similar to the following output:

{'cpu': 1.0, 'memoryInGB': 0.5}

Model profil oluşturma sonuçları Run nesne olarak dağıtılır.Model profiling results are emitted as a Run object.

CLı 'dan profil oluşturmayı kullanma hakkında daha fazla bilgi için, bkz. az ml model profili.For information on using profiling from the CLI, see az ml model profile.

Daha fazla bilgi için aşağıdaki belgelere bakın:For more information, see these documents:

Hedefe dağıtDeploy to target

Dağıtım, modelleri dağıtmak için çıkarım yapılandırma dağıtımı yapılandırmasını kullanır.Deployment uses the inference configuration deployment configuration to deploy the models. Dağıtım işlemi, işlem hedefi ne olursa olsun benzerdir.The deployment process is similar regardless of the compute target. Aks kümesine bir başvuru sağlamanız gerektiğinden AKS 'e dağıtım biraz farklıdır.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

SSL ile dağıtımları güvenli hale getirmeSecuring deployments with SSL

Bir Web hizmeti dağıtımının güvenliğini sağlama hakkında daha fazla bilgi için bkz. Web hizmetini güvenli hale getirmek IÇIN SSL kullanma.For more information on how to secure a web service deployment, see Use SSL to secure a web service.

Yerel dağıtımLocal deployment

Bir modeli yerel olarak dağıtmak için, yerel makinenizde Docker yüklü olmalıdır.To deploy a model locally, you need to have Docker installed on your local machine.

SDK’yı kullanarakUsing the SDK

ZZSzzs

from azureml.core.webservice import LocalWebservice, Webservice

deployment_config = LocalWebservice.deploy_configuration(port=8890)
service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config)
service.wait_for_deployment(show_output = True)
print(service.state)

Daha fazla bilgi için bkz. Localwebservice, model. deploy ()ve WebServicebelgeleri.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

CLı 'yi kullanmaUsing the CLI

CLı kullanarak bir modeli dağıtmak için aşağıdaki komutu kullanın.To deploy a model by using the CLI, use the following command. mymodel:1, kayıtlı modelin adı ve sürümüyle değiştirin:Replace mymodel:1 with the name and version of the registered model:

az ml model deploy -m mymodel:1 --ic inferenceconfig.json --dc deploymentconfig.json

deploymentconfig.json belgesindeki girdiler Localwebservice. deploy_configurationparametreleriyle eşlenir.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. Aşağıdaki tabloda, JSON belgesindeki varlıklar ve yöntemin parametreleri arasındaki eşleme açıklanmaktadır:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

JSON varlığıJSON entity Yöntem parametresiMethod parameter AçıklamaDescription
computeType NANA Bilgi işlem hedefi.The compute target. Yerel hedefler için değerin localolması gerekir.For local targets, the value must be local.
port port Hizmetin HTTP uç noktasının sergilebileceği yerel bağlantı noktası.The local port on which to expose the service's HTTP endpoint.

Bu JSON, CLı ile kullanılacak örnek bir dağıtım yapılandırması örneğidir:This JSON is an example deployment configuration for use with the CLI:

{
    "computeType": "local",
    "port": 32267
}

Daha fazla bilgi için bkz. az ml model Deploy belgeleri.For more information, see the az ml model deploy documentation.

Not defteri VM Web hizmeti (geliştirme/test)Notebook VM web service (dev/test)

Bkz. Azure Machine Learning Not DEFTERI VM 'sine model dağıtma.See Deploy a model to Azure Machine Learning Notebook VM.

Azure Container Instances (geliştirme/test)Azure Container Instances (dev/test)

Bkz. Azure Container Instances dağıtma.See Deploy to Azure Container Instances.

Azure Kubernetes hizmeti (geliştirme/test ve üretim)Azure Kubernetes Service (dev/test and production)

Bkz. Azure Kubernetes hizmetine dağıtma.See Deploy to Azure Kubernetes Service.

Web hizmetlerini kullanmaConsume web services

Dağıtılan her Web hizmeti, çeşitli programlama dillerinde istemci uygulamaları oluşturabilmeniz için bir REST API sağlar.Every deployed web service provides a REST API, so you can create client applications in a variety of programming languages. Hizmetiniz için anahtar kimlik doğrulamasını etkinleştirdiyseniz, istek üst bilgisinde belirteç olarak bir hizmet anahtarı sağlamanız gerekir.If you've enabled key authentication for your service, you need to provide a service key as a token in your request header. Hizmetiniz için belirteç kimlik doğrulamasını etkinleştirdiyseniz, istek üst bilgisinde taşıyıcı belirteci olarak bir Azure Machine Learning JWT belirteci sağlamanız gerekir.If you've enabled token authentication for your service, you need to provide an Azure Machine Learning JWT token as a bearer token in your request header.

İpucu

Hizmeti dağıttıktan sonra şema JSON belgesini alabilirsiniz.You can retrieve the schema JSON document after you deploy the service. Yerel Web hizmetinin Swagger dosyasına URI 'yi almak için dağıtılan Web hizmetindeki swagger_uri özelliğini kullanın (örneğin, service.swagger_uri).Use the swagger_uri property from the deployed web service (for example, service.swagger_uri) to get the URI to the local web service's Swagger file.

İstek-yanıt tüketimiRequest-response consumption

Aşağıda, Python 'da hizmetinizin nasıl çağrılcağına dair bir örnek verilmiştir:Here's an example of how to invoke your service in Python:

import requests
import json

headers = {'Content-Type': 'application/json'}

if service.auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_keys()[0]
elif service.token_auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_token()[0]

print(headers)

test_sample = json.dumps({'data': [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
]})

response = requests.post(
    service.scoring_uri, data=test_sample, headers=headers)
print(response.status_code)
print(response.elapsed)
print(response.json())

Daha fazla bilgi için bkz. Web hizmetlerini kullanmak için istemci uygulamaları oluşturma.For more information, see Create client applications to consume web services.

Web hizmeti şeması (Openapı belirtimi)Web service schema (OpenAPI specification)

Dağıtımınızla otomatik şema oluşturma kullandıysanız, swagger_uri özelliğinikullanarak hizmetin openapı belirtiminin adresini alabilirsiniz.If you used automatic schema generation with your deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. (Örneğin, print(service.swagger_uri).) Belirtimi almak için bir GET isteği kullanın veya bir tarayıcıda URI 'yi açın.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Aşağıdaki JSON belgesi, bir dağıtım için oluşturulan bir şemanın (Openapı belirtimi) bir örneğidir:The following JSON document is an example of a schema (OpenAPI specification) generated for a deployment:

{
    "swagger": "2.0",
    "info": {
        "title": "myservice",
        "description": "API specification for Azure Machine Learning myservice",
        "version": "1.0"
    },
    "schemes": [
        "https"
    ],
    "consumes": [
        "application/json"
    ],
    "produces": [
        "application/json"
    ],
    "securityDefinitions": {
        "Bearer": {
            "type": "apiKey",
            "name": "Authorization",
            "in": "header",
            "description": "For example: Bearer abc123"
        }
    },
    "paths": {
        "/": {
            "get": {
                "operationId": "ServiceHealthCheck",
                "description": "Simple health check endpoint to ensure the service is up at any given point.",
                "responses": {
                    "200": {
                        "description": "If service is up and running, this response will be returned with the content 'Healthy'",
                        "schema": {
                            "type": "string"
                        },
                        "examples": {
                            "application/json": "Healthy"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        },
        "/score": {
            "post": {
                "operationId": "RunMLService",
                "description": "Run web service's model and get the prediction output",
                "security": [
                    {
                        "Bearer": []
                    }
                ],
                "parameters": [
                    {
                        "name": "serviceInputPayload",
                        "in": "body",
                        "description": "The input payload for executing the real-time machine learning service.",
                        "schema": {
                            "$ref": "#/definitions/ServiceInput"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "The service processed the input correctly and provided a result prediction, if applicable.",
                        "schema": {
                            "$ref": "#/definitions/ServiceOutput"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "ServiceInput": {
            "type": "object",
            "properties": {
                "data": {
                    "type": "array",
                    "items": {
                        "type": "array",
                        "items": {
                            "type": "integer",
                            "format": "int64"
                        }
                    }
                }
            },
            "example": {
                "data": [
                    [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
                ]
            }
        },
        "ServiceOutput": {
            "type": "array",
            "items": {
                "type": "number",
                "format": "double"
            },
            "example": [
                3726.995
            ]
        },
        "ErrorResponse": {
            "type": "object",
            "properties": {
                "status_code": {
                    "type": "integer",
                    "format": "int32"
                },
                "message": {
                    "type": "string"
                }
            }
        }
    }
}

Daha fazla bilgi için bkz. Openapı belirtimi.For more information, see OpenAPI specification.

Belirtiden istemci kitaplıkları oluşturabileceğiniz bir yardımcı program için bkz. Swagger-CodeGen.For a utility that can create client libraries from the specification, see swagger-codegen.

Toplu çıkarımBatch inference

Azure Machine Learning Işlem hedefleri Azure Machine Learning tarafından oluşturulur ve yönetilir.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. Bunlar, Azure Machine Learning işlem hatlarından toplu tahmin için kullanılabilirler.They can be used for batch prediction from Azure Machine Learning pipelines.

Azure Machine Learning Işlem ile Batch çıkarımı hakkında yönergeler için bkz. Batch öngörülerini çalıştırma.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

IoT Edge çıkarımıIoT Edge inference

Kenara dağıtım desteği önizleme aşamasındadır.Support for deploying to the edge is in preview. Daha fazla bilgi için bkz. Azure Machine Learning IoT Edge modül olarak dağıtma.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Web hizmetlerini güncelleştirmeUpdate web services

Bir Web hizmetini güncelleştirmek için update yöntemi kullanın.To update a web service, use the update method. Web hizmetini yeni bir model, yeni bir giriş betiği veya bir çıkarım yapılandırmasında belirtime yeni bağımlılıklar kullanacak şekilde güncelleştirebilirsiniz.You can update the web service to use a new model, a new entry script, or new dependencies that can be specified in an inference configuration. Daha fazla bilgi için, bkz. WebService. Updatebelgeleri.For more information, see the documentation for Webservice.update.

Önemli

Bir modelin yeni bir sürümünü oluşturduğunuzda, kullanmak istediğiniz her hizmeti el ile güncelleştirmeniz gerekir.When you create a new version of a model, you must manually update each service that you want to use it.

SDK 'Yı kullanmaUsing the SDK

Aşağıdaki kod, bir Web hizmeti için model, ortam ve giriş betiğini güncelleştirmek üzere SDK 'nın nasıl kullanılacağını gösterir:The following code shows how to use the SDK to update the model, environment, and entry script for a web service:

from azureml.core import Environment
from azureml.core.webservice import Webservice
from azureml.core.model import Model, InferenceConfig

# Register new model.
new_model = Model.register(model_path="outputs/sklearn_mnist_model.pkl",
                           model_name="sklearn_mnist",
                           tags={"key": "0.1"},
                           description="test",
                           workspace=ws)

# Use version 3 of the environment.
deploy_env = Environment.get(workspace=ws,name="myenv",version="3")
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=deploy_env)

service_name = 'myservice'
# Retrieve existing service.
service = Webservice(name=service_name, workspace=ws)



# Update to new model(s).
service.update(models=[new_model], inference_config=inference_config)
print(service.state)
print(service.get_logs())

CLı 'yi kullanmaUsing the CLI

Ayrıca, ML CLı kullanarak bir Web hizmetini güncelleştirebilirsiniz.You can also update a web service by using the ML CLI. Aşağıdaki örnek, yeni bir modeli kaydetmeyi ve sonra bir Web hizmetini yeni modeli kullanacak şekilde güncelleştirmeyi gösterir:The following example demonstrates registering a new model and then updating a web service to use the new model:

az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --output-metadata-file modelinfo.json
az ml service update -n myservice --model-metadata-file modelinfo.json

İpucu

Bu örnekte, kayıt komutundan model bilgilerini Update komutuna iletmek için bir JSON belgesi kullanılır.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Hizmeti yeni bir giriş betiği veya ortamı kullanacak şekilde güncelleştirmek için bir çıkarım yapılandırma dosyası oluşturun ve ic parametresiyle belirtin.To update the service to use a new entry script or environment, create an inference configuration file and specify it with the ic parameter.

Daha fazla bilgi için, az ml Service Update belgelerine bakın.For more information, see the az ml service update documentation.

Modelleri sürekli dağıtContinuously deploy models

Azure DevOpsiçin Machine Learning uzantısını kullanarak, modelleri sürekli olarak dağıtabilirsiniz.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. Yeni bir makine öğrenimi modeli bir Azure Machine Learning çalışma alanına kaydedildiğinde bir dağıtım işlem hattı tetiklemek için Azure DevOps Machine Learning uzantısını kullanabilirsiniz.You can use the Machine Learning extension for Azure DevOps to trigger a deployment pipeline when a new machine learning model is registered in an Azure Machine Learning workspace.

  1. Azure Pipelinesiçin kaydolun, bu, uygulamanızı sürekli tümleştirme ve mümkün olan herhangi bir platforma veya buluta teslim eden bir uygulamadır.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. (Azure Pipelines Machine Learning işlem hatlarıile aynı olmadığını unutmayın.)(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

  2. Azure DevOps projesi oluşturun.Create an Azure DevOps project.

  3. Azure Pipelines için Machine Learning uzantısınıyükler.Install the Machine Learning extension for Azure Pipelines.

  4. Yapılarınıza erişebilmek için Azure Machine Learning çalışma alanınıza bir hizmet sorumlusu bağlantısı kurmak üzere hizmet bağlantıları 'nı kullanın.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Proje Ayarları ' na gidin, hizmet bağlantıları' nı seçin ve ardından Azure Resource Manager' yi seçin:Go to project settings, select Service connections, and then select Azure Resource Manager:

    Azure Resource Manager seçinSelect Azure Resource Manager

  5. Kapsam düzeyi listesinde AzureMLWorkspace' ı seçin ve ardından kalan değerleri girin:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    AzureMLWorkspace seçin

  6. Makine öğrenimi modelinizi Azure Pipelines kullanarak sürekli olarak dağıtmak için, işlem hatları altında yayın' ı seçin.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Yeni bir yapıt ekleyin ve ardından daha önce oluşturduğunuz AzureML model yapıtını ve hizmet bağlantısını seçin.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. Bir dağıtımı tetiklemek için modeli ve sürümü seçin:Select the model and version to trigger a deployment:

    AzureML modeli seçinSelect AzureML Model

  7. Model yapıtında model tetikleyiciyi etkinleştirin.Enable the model trigger on your model artifact. Tetikleyiciyi açtığınızda, söz konusu modelin belirtilen sürümü (yani, en yeni sürümü) çalışma alanınıza kaydedildiğinde, bir Azure DevOps sürümü işlem hattı tetiklenir.When you turn on the trigger, every time the specified version (that is, the newest version) of that model is registered in your workspace, an Azure DevOps release pipeline is triggered.

    Model tetikleyiciyi etkinleştirmek Enable the model trigger

Daha fazla örnek proje ve örnek için GitHub 'daki Şu örnek depolara bakın:For more sample projects and examples, see these sample repos in GitHub:

Model indirmeDownload a model

Modelinizi kendi yürütme ortamınızda kullanmak üzere indirmek isterseniz, bunu aşağıdaki SDK/CLı komutlarıyla yapabilirsiniz:If you want to download your model to use it in your own execution environment, you can do so with the following SDK / CLI commands:

'SıNıNSDK:

model_path = Model(ws,'mymodel').download()

CLıCLI:

az ml model download --model-id mymodel:1 --target-dir model_folder

Önizle Kod olmayan model dağıtımı(Preview) No-code model deployment

Şu anda önizleme aşamasında olan kod modeli dağıtımı yok ve şu makine öğrenimi çerçevelerini destekliyor:No-code model deployment is currently in preview and supports the following machine learning frameworks:

TensorFlow SavedModel biçimiTensorflow SavedModel format

from azureml.core import Model

model = Model.register(workspace=ws,
                       model_name='flowers',                        # Name of the registered model in your workspace.
                       model_path='./flowers_model',                # Local Tensorflow SavedModel folder to upload and register as a model.
                       model_framework=Model.Framework.TENSORFLOW,  # Framework used to create the model.
                       model_framework_version='1.14.0',            # Version of Tensorflow used to create the model.
                       description='Flowers model')

service_name = 'tensorflow-flower-service'
service = Model.deploy(ws, service_name, [model])

ONNX modelleriONNX models

ONNX model kaydı ve dağıtımı herhangi bir ONNX çıkarım grafiği için desteklenir.ONNX model registration and deployment is supported for any ONNX inference graph. Ön işlem ve postprocess adımları şu anda desteklenmiyor.Preprocess and postprocess steps are not currently supported.

Bir MNIST ONNX modelinin nasıl kaydedileceği ve dağıtılacağı hakkında bir örnek aşağıda verilmiştir:Here is an example of how to register and deploy an MNIST ONNX model:

from azureml.core import Model

model = Model.register(workspace=ws,
                       model_name='mnist-sample',                  # Name of the registered model in your workspace.
                       model_path='mnist-model.onnx',              # Local ONNX model to upload and register as a model.
                       model_framework=Model.Framework.ONNX ,      # Framework used to create the model.
                       model_framework_version='1.3',              # Version of ONNX used to create the model.
                       description='Onnx MNIST model')

service_name = 'onnx-mnist-service'
service = Model.deploy(ws, service_name, [model])

Scikit-modelleri öğrenmeScikit-learn models

Tüm yerleşik scikit-öğrenme model türleri için hiçbir kod modeli dağıtımı desteklenmez.No code model deployment is supported for all built-in scikit-learn model types.

Ek kod olmadan bir sköğren modelinin nasıl kaydedileceği ve dağıtıldığı hakkında bir örnek aşağıda verilmiştir:Here is an example of how to register and deploy a sklearn model with no extra code:

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = Model.register(workspace=ws,
                       model_name='my-sklearn-model',                # Name of the registered model in your workspace.
                       model_path='./sklearn_regression_model.pkl',  # Local file to upload and register as a model.
                       model_framework=Model.Framework.SCIKITLEARN,  # Framework used to create the model.
                       model_framework_version='0.19.1',             # Version of scikit-learn used to create the model.
                       resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5),
                       description='Ridge regression model to predict diabetes progression.',
                       tags={'area': 'diabetes', 'type': 'regression'})
                       
service_name = 'my-sklearn-service'
service = Model.deploy(ws, service_name, [model])

NOTE: Bu bağımlılıklar önceden oluşturulmuş sköğren çıkarımı kapsayıcısına dahil edilmiştir:NOTE: These dependencies are included in the prebuilt sklearn inference container:

    - azureml-defaults
    - inference-schema[numpy-support]
    - scikit-learn
    - numpy

Paket modelleriPackage models

Bazı durumlarda, modeli dağıtmadan bir Docker görüntüsü oluşturmak isteyebilirsiniz (örneğin, Azure App Service dağıtmayıplanlıyorsanız).In some cases, you might want to create a Docker image without deploying the model (if, for example, you plan to deploy to Azure App Service). Ya da görüntüyü indirmek ve yerel bir Docker yüklemesinde çalıştırmak isteyebilirsiniz.Or you might want to download the image and run it on a local Docker installation. Görüntüyü oluşturmak, incelemek, değiştirmek ve görüntüyü el ile oluşturmak için kullanılan dosyaları da indirmek isteyebilirsiniz.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

Model paketleme, bu işlemleri yapmanızı sağlar.Model packaging enables you to do these things. Bir modeli Web hizmeti olarak barındırmak için gereken tüm varlıkları paketler ve tamamen oluşturulmuş bir Docker görüntüsünü ya da bir tane oluşturmak için gereken dosyaları indirmelerini sağlar.It packages all the assets needed to host a model as a web service and allows you to download either a fully built Docker image or the files needed to build one. Model paketlemeyi kullanmanın iki yolu vardır:There are two ways to use model packaging:

Paketlenmiş bir model indirin: Modeli ve bir Web hizmeti olarak barındırmak için gereken diğer dosyaları içeren bir Docker görüntüsü indirin.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Dockerfile oluştur: Docker görüntüsü oluşturmak için gereken Dockerfile, model, giriş betiği ve diğer varlıkları indirin.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. Görüntüyü yerel olarak oluşturmadan önce dosyaları inceleyebilir veya değişiklik yapabilirsiniz.You can then inspect the files or make changes before you build the image locally.

Her iki paket de yerel bir Docker görüntüsü almak için kullanılabilir.Both packages can be used to get a local Docker image.

İpucu

Bir paket oluşturmak, model dağıtmaya benzer.Creating a package is similar to deploying a model. Kayıtlı bir model ve çıkarım yapılandırmasını kullanırsınız.You use a registered model and an inference configuration.

Önemli

Tamamen oluşturulmuş bir görüntüyü indirmek veya yerel olarak bir görüntü oluşturmak için, geliştirme ortamınızda Docker 'ın yüklü olması gerekir.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Paketlenmiş model indirmeDownload a packaged model

Aşağıdaki örnek, çalışma alanınız için Azure Container Registry 'de kayıtlı olan bir görüntü oluşturur:The following example builds an image, which is registered in the Azure container registry for your workspace:

package = Model.package(ws, [model], inference_config)
package.wait_for_creation(show_output=True)

Bir paket oluşturduktan sonra, görüntüyü yerel Docker ortamınıza çekmek için package.pull() kullanabilirsiniz.After you create a package, you can use package.pull() to pull the image to your local Docker environment. Bu komutun çıktısı görüntünün adını görüntüler.The output of this command will display the name of the image. Örneğin:For example:

Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338.Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338.

Modeli indirdikten sonra, yerel görüntüleri listelemek için docker images komutunu kullanın:After you download the model, use the docker images command to list the local images:

REPOSITORY                               TAG                 IMAGE ID            CREATED             SIZE
myworkspacef78fd10.azurecr.io/package    20190822181338      7ff48015d5bd        4 minutes ago       1.43GB

Bu görüntüye göre yerel bir kapsayıcı başlatmak için, Shell veya komut satırından adlandırılmış bir kapsayıcı başlatmak üzere aşağıdaki komutu kullanın.To start a local container based on this image, use the following command to start a named container from the shell or command line. <imageid> değerini docker images komutu tarafından döndürülen görüntü KIMLIĞIYLE değiştirin.Replace the <imageid> value with the image ID returned by the docker images command.

docker run -p 6789:5001 --name mycontainer <imageid>

Bu komut, myimageadlı görüntünün en son sürümünü başlatır.This command starts the latest version of the image named myimage. Yerel bağlantı noktası 6789 ' i Web hizmetinin dinlediği kapsayıcıda bağlantı noktasına eşler (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Ayrıca, kapsayıcıya daha kolay durmayı kolaylaştıran mycontainer adı kapsayıcıya atar.It also assigns the name mycontainer to the container, which makes the container easier to stop. Kapsayıcı başlatıldıktan sonra, http://localhost:6789/scoreistek gönderebilirsiniz.After the container is started, you can submit requests to http://localhost:6789/score.

Dockerfile ve bağımlılıklar oluşturmaGenerate a Dockerfile and dependencies

Aşağıdaki örnek, bir görüntüyü yerel olarak oluşturmak için gereken Dockerfile, model ve diğer varlıkların nasıl indirileceği gösterilmektedir.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. generate_dockerfile=True parametresi, tam olarak oluşturulmuş bir görüntü değil, dosyaları istediğinizi belirtir.The generate_dockerfile=True parameter indicates that you want the files, not a fully built image.

package = Model.package(ws, [model], inference_config, generate_dockerfile=True)
package.wait_for_creation(show_output=True)
# Download the package.
package.save("./imagefiles")
# Get the Azure container registry that the model/Dockerfile uses.
acr=package.get_container_registry()
print("Address:", acr.address)
print("Username:", acr.username)
print("Password:", acr.password)

Bu kod, imagefiles dizinine görüntü oluşturmak için gereken dosyaları indirir.This code downloads the files needed to build the image to the imagefiles directory. Kayıtlı dosyalara eklenen Dockerfile, bir Azure Container Registry 'de depolanan bir temel görüntüye başvurur.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Yerel Docker yüklemenizde görüntüyü oluştururken, kayıt defterinde kimlik doğrulamak için adresi, Kullanıcı adını ve parolayı kullanmanız gerekir.When you build the image on your local Docker installation, you need to use the address, user name, and password to authenticate to the registry. Yerel bir Docker yüklemesi kullanarak görüntüyü derlemek için aşağıdaki adımları kullanın:Use the following steps to build the image by using a local Docker installation:

  1. Bir kabuk veya komut satırı oturumundan, Azure Container Registry ile Docker kimlik doğrulaması yapmak için aşağıdaki komutu kullanın.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. <address>, <username>ve <password> package.get_container_registry()tarafından alınan değerlerle değiştirin.Replace <address>, <username>, and <password> with the values retrieved by package.get_container_registry().

    docker login <address> -u <username> -p <password>
    
  2. Görüntüyü oluşturmak için aşağıdaki komutu kullanın.To build the image, use the following command. <imagefiles>, dosyaları package.save() kaydedildiği dizinin yoluyla değiştirin.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Bu komut, görüntü adını myimageolarak ayarlar.This command sets the image name to myimage.

Görüntünün derlendiğini doğrulamak için docker images komutunu kullanın.To verify that the image is built, use the docker images command. myimage görüntüsünü listede görmeniz gerekir:You should see the myimage image in the list:

REPOSITORY      TAG                 IMAGE ID            CREATED             SIZE
<none>          <none>              2d5ee0bf3b3b        49 seconds ago      1.43GB
myimage         latest              739f22498d64        3 minutes ago       1.43GB

Bu görüntüye göre yeni bir kapsayıcı başlatmak için aşağıdaki komutu kullanın:To start a new container based on this image, use the following command:

docker run -p 6789:5001 --name mycontainer myimage:latest

Bu komut, myimageadlı görüntünün en son sürümünü başlatır.This command starts the latest version of the image named myimage. Yerel bağlantı noktası 6789 ' i Web hizmetinin dinlediği kapsayıcıda bağlantı noktasına eşler (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Ayrıca, kapsayıcıya daha kolay durmayı kolaylaştıran mycontainer adı kapsayıcıya atar.It also assigns the name mycontainer to the container, which makes the container easier to stop. Kapsayıcı başlatıldıktan sonra, http://localhost:6789/scoreistek gönderebilirsiniz.After the container is started, you can submit requests to http://localhost:6789/score.

Yerel kapsayıcıyı test eden örnek istemciExample client to test the local container

Aşağıdaki kod, kapsayıcında kullanılabilecek bir Python istemcisi örneğidir:The following code is an example of a Python client that can be used with the container:

import requests
import json

# URL for the web service.
scoring_uri = 'http://localhost:6789/score'

# Two sets of data to score, so we get two results back.
data = {"data":
        [
            [ 1,2,3,4,5,6,7,8,9,10 ],
            [ 10,9,8,7,6,5,4,3,2,1 ]
        ]
        }
# Convert to JSON string.
input_data = json.dumps(data)

# Set the content type.
headers = {'Content-Type': 'application/json'}

# Make the request and display the response.
resp = requests.post(scoring_uri, input_data, headers=headers)
print(resp.text)

Örneğin, diğer programlama dillerinde istemciler için bkz. Web Hizmetleri olarak dağıtılan modellerikullanma.For example clients in other programming languages, see Consume models deployed as web services.

Docker kapsayıcısını durdurStop the Docker container

Kapsayıcıyı durdurmak için, farklı bir kabuktan veya komut satırından aşağıdaki komutu kullanın:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

Kaynakları temizlemeClean up resources

Dağıtılan bir Web hizmetini silmek için service.delete()kullanın.To delete a deployed web service, use service.delete(). Kayıtlı bir modeli silmek için model.delete()kullanın.To delete a registered model, use model.delete().

Daha fazla bilgi için bkz. WebService. Delete () ve model. Delete ()belgeleri.For more information, see the documentation for WebService.delete() and Model.delete().

Sonraki adımlarNext steps