ML modellerini ve tahminlerini açıklamak için Python yorumlanabilirlik paketini kullanma (önizleme)

  • Makale

ŞUNUN IÇIN GEÇERLIDIR:Python SDK azureml v1

Bu nasıl yapılır kılavuzunda, aşağıdaki görevleri gerçekleştirmek için Azure Machine Learning Python SDK'sının yorumlanabilirlik paketini kullanmayı öğreneceksiniz:

  • Kişisel makinenizdeki model davranışının tamamını veya bireysel tahminleri yerel olarak açıklayın.

  • Mühendislik özellikleri için yorumlanabilirlik tekniklerini etkinleştirin.

  • Azure'da modelin tamamına ve tek tek tahminlere ilişkin davranışı açıklama.

  • Açıklamaları Azure Machine Learning Çalıştırma Geçmişi'ne yükleyin.

  • Hem Jupyter Notebook'ta hem de Azure Machine Learning stüdyosu model açıklamalarınızla etkileşime geçmek için görselleştirme panosu kullanın.

  • Çıkarım sırasında açıklamaları gözlemlemek için modelinizle birlikte bir puanlama açıklaması dağıtın.

Önemli

Bu özellik şu anda genel önizlemededir. Bu önizleme sürümü hizmet düzeyi sözleşmesi olmadan sağlanır ve üretim iş yükleri için bu sürümü önermeyiz. Bazı özellikler desteklenmiyor olabileceği gibi özellikleri sınırlandırılmış da olabilir.

Daha fazla bilgi için bkz. Microsoft Azure Önizlemeleri Ek Kullanım Koşulları.

Desteklenen yorumlanabilirlik teknikleri ve makine öğrenmesi modelleri hakkında daha fazla bilgi için bkz . Azure Machine Learning'de model yorumlanabilirliği ve örnek not defterleri.

Otomatik makine öğrenmesi ile eğitilen modeller için yorumlanabilirliği etkinleştirme yönergeleri için bkz . Yorumlanabilirlik: otomatik makine öğrenmesi modelleri için model açıklamaları (önizleme).

Kişisel makinenizde özellik önem değeri oluşturma

Aşağıdaki örnekte, Azure hizmetleriyle iletişim kurmadan kişisel makinenizde yorumlanabilirlik paketinin nasıl kullanılacağı gösterilmektedir.

  1. azureml-interpret paketini yükleyin.

    pip install azureml-interpret

  2. Yerel Jupyter Notebook'ta örnek modeli eğitin.

    # load breast cancer dataset, a well-known small dataset that comes with scikit-learn
from sklearn.datasets import load_breast_cancer
from sklearn import svm
from sklearn.model_selection import train_test_split
breast_cancer_data = load_breast_cancer()
classes = breast_cancer_data.target_names.tolist()

# split data into train and test
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data,            
                                                    breast_cancer_data.target,  
                                                    test_size=0.2,
                                                    random_state=0)
clf = svm.SVC(gamma=0.001, C=100., probability=True)
model = clf.fit(x_train, y_train)

  3. Açıklayıcıyı yerel olarak arayın.

    • Bir açıklama nesnesi başlatmak için modelinizi ve bazı eğitim verilerini açıklama oluşturucusunun öğesine geçirin.
    • Açıklamalarınızı ve görselleştirmelerinizi daha bilgilendirici hale getirmek için, sınıflandırma yapıyorsanız özellik adlarını ve çıkış sınıfı adlarını geçirmeyi seçebilirsiniz.

    Aşağıdaki kod blokları, , MimicExplainerve PFIExplainer yerel olarak bir açıklayıcı nesnesinin TabularExplainernasıl örneklendireceğini gösterir.

    • TabularExplainer altındaki üç SHAP açıklamasından birini (TreeExplainer, DeepExplainerveya KernelExplainer) çağırır.
    • TabularExplainer otomatik olarak kullanım örneğiniz için en uygun olanı seçer, ancak temel alınan üç açıklamayı doğrudan çağırabilirsiniz.
    from interpret.ext.blackbox import TabularExplainer

# "features" and "classes" fields are optional
explainer = TabularExplainer(model, 
                             x_train, 
                             features=breast_cancer_data.feature_names, 
                             classes=classes)

    veya

    
from interpret.ext.blackbox import MimicExplainer

# you can use one of the following four interpretable models as a global surrogate to the black box model

from interpret.ext.glassbox import LGBMExplainableModel
from interpret.ext.glassbox import LinearExplainableModel
from interpret.ext.glassbox import SGDExplainableModel
from interpret.ext.glassbox import DecisionTreeExplainableModel

# "features" and "classes" fields are optional
# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns.
# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.
# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel
explainer = MimicExplainer(model, 
                           x_train, 
                           LGBMExplainableModel, 
                           augment_data=True, 
                           max_num_of_augmentations=10, 
                           features=breast_cancer_data.feature_names, 
                           classes=classes)

    veya

    from interpret.ext.blackbox import PFIExplainer

# "features" and "classes" fields are optional
explainer = PFIExplainer(model,
                         features=breast_cancer_data.feature_names, 
                         classes=classes)

Model davranışının tamamını açıklama (genel açıklama)

Toplam (genel) özellik önem değerlerini almanıza yardımcı olması için aşağıdaki örne bakın.


# you can use the training data or the test data here, but test data would allow you to use Explanation Exploration
global_explanation = explainer.explain_global(x_test)

# if you used the PFIExplainer in the previous step, use the next line of code instead
# global_explanation = explainer.explain_global(x_train, true_labels=y_train)

# sorted feature importance values and feature names
sorted_global_importance_values = global_explanation.get_ranked_global_values()
sorted_global_importance_names = global_explanation.get_ranked_global_names()
dict(zip(sorted_global_importance_names, sorted_global_importance_values))

# alternatively, you can print out a dictionary that holds the top K feature names and values
global_explanation.get_feature_importance_dict()

Tek bir tahmini açıklama (yerel açıklama)

Tek bir örneğin veya bir örnek grubunun açıklamalarını çağırarak farklı veri noktalarının özellik önem değerlerini alın.

Dekont

PFIExplainer yerel açıklamaları desteklemez.

# get explanation for the first data point in the test set
local_explanation = explainer.explain_local(x_test[0:5])

# sorted feature importance values and feature names
sorted_local_importance_names = local_explanation.get_ranked_local_names()
sorted_local_importance_values = local_explanation.get_ranked_local_values()

Ham özellik dönüştürmeleri

Mühendislik özellikleri yerine ham, çevrilmemiş özellikler açısından açıklama almayı tercih edebilirsiniz. Bu seçenek için, içindeki açıklamaya train_explain.pyözellik dönüştürme işlem hattınızı geçirirsiniz. Aksi takdirde, açıklayıcı mühendislik özellikleri açısından açıklamalar sağlar.

Desteklenen dönüştürmelerin biçimi, sklearn-pandas içinde açıklananla aynıdır. Genel olarak, tüm dönüştürmeler tek bir sütunda çalıştıkları sürece desteklenir ve böylece bire çok oldukları anlaşılır.

Uygun transformatör tanımlama demetlerinin listesiyle veya kullanarak sklearn.compose.ColumnTransformer ham özellikler için bir açıklama alın. Aşağıdaki örnekte kullanılır sklearn.compose.ColumnTransformer.

from sklearn.compose import ColumnTransformer

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

# append classifier to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', preprocessor),
                      ('classifier', LogisticRegression(solver='lbfgs'))])


# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=preprocessor)

Uygun transformatör demetlerinin listesiyle örneği çalıştırmak istiyorsanız aşağıdaki kodu kullanın:

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn_pandas import DataFrameMapper

# assume that we have created two arrays, numerical and categorical, which holds the numerical and categorical feature names

numeric_transformations = [([f], Pipeline(steps=[('imputer', SimpleImputer(
    strategy='median')), ('scaler', StandardScaler())])) for f in numerical]

categorical_transformations = [([f], OneHotEncoder(
    handle_unknown='ignore', sparse=False)) for f in categorical]

transformations = numeric_transformations + categorical_transformations

# append model to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),
                      ('classifier', LogisticRegression(solver='lbfgs'))])

# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=transformations)

Uzak çalıştırmalar aracılığıyla özellik önem değerleri oluşturma

Aşağıdaki örnekte, uzak çalıştırmalar ExplanationClient için model yorumlanabilirliğini etkinleştirmek için sınıfını nasıl kullanabileceğiniz gösterilmektedir. Siz hariç kavramsal olarak yerel işleme benzer:

  • Yorumlanabilirlik bağlamını ExplanationClient karşıya yüklemek için uzaktan çalıştırmada öğesini kullanın.
  • Bağlamı daha sonra yerel bir ortamda indirin.

  1. azureml-interpret paketini yükleyin.

    pip install azureml-interpret

  2. Yerel bir Jupyter Not Defteri'nde eğitim betiği oluşturun. Örneğin, train_explain.py.

    from azureml.interpret import ExplanationClient
from azureml.core.run import Run
from interpret.ext.blackbox import TabularExplainer

run = Run.get_context()
client = ExplanationClient.from_run(run)

# write code to get and split your data into train and test sets here
# write code to train your model here 

# explain predictions on your local machine
# "features" and "classes" fields are optional
explainer = TabularExplainer(model, 
                             x_train, 
                             features=feature_names, 
                             classes=classes)

# explain overall model predictions (global explanation)
global_explanation = explainer.explain_global(x_test)

# uploading global model explanation data for storage or visualization in webUX
# the explanation can then be downloaded on any compute
# multiple explanations can be uploaded
client.upload_model_explanation(global_explanation, comment='global explanation: all features')
# or you can only upload the explanation object with the top k feature info
#client.upload_model_explanation(global_explanation, top_k=2, comment='global explanation: Only top 2 features')

  3. İşlem hedefiniz olarak bir Azure Machine Learning İşlemi ayarlayın ve eğitim çalıştırmanızı gönderin. Yönergeler için bkz . Azure Machine Learning işlem kümeleri oluşturma ve yönetme. Örnek not defterlerini de yararlı bulabilirsiniz.

  4. Açıklamayı yerel Jupyter Not Defterinize indirin.

    from azureml.interpret import ExplanationClient

client = ExplanationClient.from_run(run)

# get model explanation data
explanation = client.download_model_explanation()
# or only get the top k (e.g., 4) most important features with their importance values
explanation = client.download_model_explanation(top_k=4)

global_importance_values = explanation.get_ranked_global_values()
global_importance_names = explanation.get_ranked_global_names()
print('global importance values: {}'.format(global_importance_values))
print('global importance names: {}'.format(global_importance_names))

Görselleştirmeler

Açıklamaları yerel Jupyter Not Defterinize indirdikten sonra, modelinizi anlamak ve yorumlamak için açıklamalar panosundaki görselleştirmeleri kullanabilirsiniz. Jupyter Notebook'unuza açıklamalar panosu pencere öğesini yüklemek için aşağıdaki kodu kullanın:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Görselleştirmeler hem mühendislik hem de ham özelliklerle ilgili açıklamaları destekler. Ham açıklamalar özgün veri kümesindeki özellikleri temel alır ve mühendislikle yapılan açıklamalar, özellik mühendisliği uygulanmış veri kümesindeki özellikleri temel alır.

Modeli özgün veri kümesiyle ilgili olarak yorumlamaya çalışırken, her özelliğin önemi özgün veri kümesindeki bir sütuna karşılık geldiğinden ham açıklamaların kullanılması önerilir. Kategorik bir özellikten tek tek kategorilerin etkisini incelerken, mühendislik açıklamalarının yararlı olabileceği bir senaryodur. Kategorik bir özelliğe bir sık erişimli kodlama uygulanırsa, sonuçta elde edilen mühendislikle yapılan açıklamalar kategori başına farklı bir önem değeri (bir sık erişimli mühendislik özelliği için bir tane) içerir. Bu kodlama, veri kümesinin hangi bölümünün model için en bilgilendirici olduğunu daraltırken yararlı olabilir.

Dekont

Mühendislik ve ham açıklamalar sıralı olarak hesaplanır. İlk olarak modele ve özellik kazandırma işlem hattına göre tasarlanmış bir açıklama oluşturulur. Ardından ham açıklama, aynı ham özellikten gelen mühendislik özelliklerin önemi toplanarak bu mühendislik açıklaması temel alınarak oluşturulur.

Veri kümesi kohortlarını oluşturma, düzenleme ve görüntüleme

Üst şeritte modeliniz ve verilerinizle ilgili genel istatistikler gösterilir. Modelinizin performansını ve açıklamalarını bu tanımlı alt gruplar arasında araştırmak veya karşılaştırmak için verilerinizi dilimleyebilir ve veri kümesi kohortlarına veya alt gruplara ayırabilirsiniz. Veri kümesi istatistiklerinizi ve açıklamalarınızı bu alt gruplar arasında karşılaştırarak, olası hataların neden bir grupta ve başka bir grupta olduğunu anlayabilirsiniz.

Creating, editing, and viewing dataset cohorts

Model davranışının tamamını anlama (genel açıklama)

Açıklama panosunun ilk üç sekmesi, eğitilen modelin tahminleri ve açıklamaları ile birlikte genel bir analizini sağlar.

Model performansı

Tahmin değerlerinizin dağılımını ve model performansı ölçümlerinizin değerlerini inceleyerek modelinizin performansını değerlendirin. Veri kümenizin farklı kohortlarında veya alt gruplarında performansının karşılaştırmalı analizine bakarak modelinizi daha fazla araştırabilirsiniz. Farklı boyutlarda kesmek için y ve x değeri boyunca filtreleri seçin. Doğruluk, duyarlık, yakalama, hatalı pozitif hız (FPR) ve hatalı negatif oran (FNR) gibi ölçümleri görüntüleyin.

Model performance tab in the explanation visualization

Veri kümesi gezgini

Verilerinizi farklı boyutlarda dilimleme amacıyla X, Y ve renk eksenleri boyunca farklı filtreler seçerek veri kümesi istatistiklerinizi keşfedin. Tahmin edilen sonuç, veri kümesi özellikleri ve hata grupları gibi filtrelerle veri kümesi istatistiklerini analiz etmek için yukarıda veri kümesi kohortları oluşturun. Grafik türlerini değiştirmek için grafiğin sağ üst köşesindeki dişli simgesini kullanın.

Dataset explorer tab in the explanation visualization

Özellik önem düzeyini toplama

Genel model tahminlerinizi etkileyen en önemli k önemli özellikleri keşfedin (genel açıklama olarak da bilinir). Azalan özellik önem değerlerini göstermek için kaydırıcıyı kullanın. Özellik önem değerlerini yan yana görmek için en fazla üç kohort seçin. Aşağıdaki bağımlılık çiziminde seçili özellik değerlerinin model tahminini nasıl etkilediğini görmek için grafikteki özellik çubuklarından herhangi birini seçin.

Aggregate feature importance tab in the explanation visualization

Tek tek tahminleri anlama (yerel açıklama)

Açıklama sekmesinin dördüncü sekmesi, tek bir veri noktasında ve bunların özellik önem derecelerinde detaya gitmenizi sağlar. Ana dağılım çizimindeki tek tek veri noktalarından herhangi birine tıklayarak veya sağdaki panel sihirbazında belirli bir veri noktasını seçerek herhangi bir veri noktası için tek tek özellik önem çizimini yükleyebilirsiniz.

Çizim Açıklama
Bireysel özellik önemi Tek bir tahmin için en önemli özellikleri gösterir. Belirli bir veri noktasında temel alınan modelin yerel davranışını göstermeye yardımcı olur.
Durum analizi Seçilen gerçek veri noktasının özellik değerlerinde yapılan değişikliklere izin verir ve yeni özellik değerleriyle varsayımsal bir veri noktası oluşturarak tahmin değerinde ortaya çıkan değişiklikleri gözlemler.
Bireysel Koşullu Beklenti (ICE) Özellik değerinin en düşük değerden maksimum değere değiştirilmesine izin verir. Bir özellik değiştiğinde veri noktasının tahmininin nasıl değiştiğini göstermeye yardımcı olur.

Individual feature importance and What-if tab in explanation dashboard

Dekont

Bunlar birçok tahmine dayalı açıklamalardır ve tahminlerin "nedeni" değildir. Nedensel çıkarımın katı matematiksel sağlamlığı olmadan, kullanıcılara What-If aracının özellik pertürbasyonlarına göre gerçek hayatta kararlar almalarını önermeyiz. Bu araç öncelikle modelinizi anlamak ve hata ayıklamak içindir.

Azure Machine Learning stüdyosu görselleştirme

Uzaktan yorumlanabilirlik adımlarını tamamlarsanız (oluşturulan açıklamaları Azure Machine Learning Çalıştırma Geçmişi'ne yüklerseniz), görselleştirmeleri Azure Machine Learning stüdyosu açıklamalar panosunda görüntüleyebilirsiniz. Bu pano, Jupyter Not Defterinizde oluşturulan pano pencere öğesinin daha basit bir sürümüdür. What-If veri noktası oluşturma ve ICE çizimleri, Azure Machine Learning stüdyosu gerçek zamanlı hesaplamalarını gerçekleştirebilecek etkin işlem olmadığından devre dışı bırakılır.

Veri kümesi, genel ve yerel açıklamalar varsa, veriler tüm sekmeleri doldurur. Ancak, yalnızca genel bir açıklama varsa Bireysel özellik önem sekmesi devre dışı bırakılır.

Azure Machine Learning stüdyosu açıklama panosuna erişmek için şu yollardan birini izleyin:

  • Denemeler bölmesi (Önizleme)

    1. Azure Machine Learning'de çalıştırdığınız denemelerin listesini görmek için sol bölmede Denemeler'i seçin.
    2. Bu denemedeki tüm çalıştırmaları görüntülemek için belirli bir denemeyi seçin.
    3. Bir çalıştırma seçin ve ardından Açıklamalar sekmesiyle açıklama görselleştirme panosuna gidin.

    Visualization Dashboard with Aggregate Feature Importance in Azure Machine Learning studio in experiments

  • Modeller bölmesi

    1. Azure Machine Learning ile model dağıtma bölümünde yer alan adımları izleyerek özgün modelinizi kaydettiyseniz, sol bölmede Modeller'i seçerek görüntüleyebilirsiniz.
    2. Bir model seçin ve açıklamalar panosunu görüntülemek için Açıklamalar sekmesini seçin.

Çıkarım zamanında yorumlanabilirlik

Açıklayıcıyı özgün modelle birlikte dağıtabilir ve çıkarım zamanında kullanarak herhangi bir yeni veri noktası için ayrı özellik önem değerleri (yerel açıklama) sağlayabilirsiniz. Şu anda yalnızca Azure Machine Learning SDK'sında desteklenen çıkarım zamanında yorumlanabilirlik performansını geliştirmek için daha hafif puanlama açıklayıcıları da sunuyoruz. Daha hafif bir puanlama açıklaması dağıtma işlemi, modeli dağıtmaya benzer ve aşağıdaki adımları içerir:

  1. Bir açıklama nesnesi oluşturun. Örneğin, kullanabilirsiniz TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer


explainer = TabularExplainer(model, 
                             initialization_examples=x_train, 
                             features=dataset_feature_names, 
                             classes=dataset_classes, 
                             transformations=transformations)

  2. Açıklama nesnesiyle bir puanlama açıklaması açıklaması oluşturun.

    from azureml.interpret.scoring.scoring_explainer import KernelScoringExplainer, save

# create a lightweight explainer at scoring time
scoring_explainer = KernelScoringExplainer(explainer)

# pickle scoring explainer
# pickle scoring explainer locally
OUTPUT_DIR = 'my_directory'
save(scoring_explainer, directory=OUTPUT_DIR, exist_ok=True)

  3. Puanlama açıklama modelini kullanan bir görüntüyü yapılandırın ve kaydedin.

    # register explainer model using the path from ScoringExplainer.save - could be done on remote compute
# scoring_explainer.pkl is the filename on disk, while my_scoring_explainer.pkl will be the filename in cloud storage
run.upload_file('my_scoring_explainer.pkl', os.path.join(OUTPUT_DIR, 'scoring_explainer.pkl'))

scoring_explainer_model = run.register_model(model_name='my_scoring_explainer', 
                                             model_path='my_scoring_explainer.pkl')
print(scoring_explainer_model.name, scoring_explainer_model.id, scoring_explainer_model.version, sep = '\t')

  4. İsteğe bağlı bir adım olarak, puanlama açıklayıcısını buluttan alabilir ve açıklamaları test edebilirsiniz.

    from azureml.interpret.scoring.scoring_explainer import load

# retrieve the scoring explainer model from cloud"
scoring_explainer_model = Model(ws, 'my_scoring_explainer')
scoring_explainer_model_path = scoring_explainer_model.download(target_dir=os.getcwd(), exist_ok=True)

# load scoring explainer from disk
scoring_explainer = load(scoring_explainer_model_path)

# test scoring explainer locally
preds = scoring_explainer.explain(x_test)
print(preds)

  5. Aşağıdaki adımları izleyerek görüntüyü bir işlem hedefine dağıtın:

    1. Gerekirse, Azure Machine Learning ile modelleri dağıtma bölümünde yer alan adımları izleyerek özgün tahmin modelinizi kaydedin.

    2. Puanlama dosyası oluşturun.

      %%writefile score.py
import json
import numpy as np
import pandas as pd
import os
import pickle
from sklearn.externals import joblib
from sklearn.linear_model import LogisticRegression
from azureml.core.model import Model

def init():

   global original_model
   global scoring_model

   # retrieve the path to the model file using the model name
   # assume original model is named original_prediction_model
   original_model_path = Model.get_model_path('original_prediction_model')
   scoring_explainer_path = Model.get_model_path('my_scoring_explainer')

   original_model = joblib.load(original_model_path)
   scoring_explainer = joblib.load(scoring_explainer_path)

def run(raw_data):
   # get predictions and explanations for each data point
   data = pd.read_json(raw_data)
   # make prediction
   predictions = original_model.predict(data)
   # retrieve model explanations
   local_importance_values = scoring_explainer.explain(data)
   # you can return any data type as long as it is JSON-serializable
   return {'predictions': predictions.tolist(), 'local_importance_values': local_importance_values}

    3. Dağıtım yapılandırmasını tanımlayın.

      Bu yapılandırma, modelinizin gereksinimlerine bağlıdır. Aşağıdaki örnek, bir CPU çekirdeği ve bir GB bellek kullanan bir yapılandırmayı tanımlar.

      from azureml.core.webservice import AciWebservice

 aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
                                           memory_gb=1,
                                           tags={"data": "NAME_OF_THE_DATASET",
                                                 "method" : "local_explanation"},
                                           description='Get local explanations for NAME_OF_THE_PROBLEM')

    4. Ortam bağımlılıklarıyla bir dosya oluşturun.

      from azureml.core.conda_dependencies import CondaDependencies

# WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)

azureml_pip_packages = ['azureml-defaults', 'azureml-core', 'azureml-telemetry', 'azureml-interpret']


# specify CondaDependencies obj
myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas'],
                                 pip_packages=['sklearn-pandas'] + azureml_pip_packages,
                                 pin_sdk_version=False)


with open("myenv.yml","w") as f:
   f.write(myenv.serialize_to_string())

with open("myenv.yml","r") as f:
   print(f.read())

    5. g++ yüklü özel bir dockerfile oluşturun.

      %%writefile dockerfile
RUN apt-get update && apt-get install -y g++

    6. Oluşturulan görüntüyü dağıtın.

      Bu işlem yaklaşık beş dakika sürer.

      from azureml.core.webservice import Webservice
from azureml.core.image import ContainerImage

# use the custom scoring, docker, and conda files we created above
image_config = ContainerImage.image_configuration(execution_script="score.py",
                                                docker_file="dockerfile",
                                                runtime="python",
                                                conda_file="myenv.yml")

# use configs and models generated above
service = Webservice.deploy_from_model(workspace=ws,
                                    name='model-scoring-service',
                                    deployment_config=aciconfig,
                                    models=[scoring_explainer_model, original_model],
                                    image_config=image_config)

service.wait_for_deployment(show_output=True)

  6. Dağıtımı test edin.

    import requests

# create data to test service with
examples = x_list[:4]
input_data = examples.to_json()

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

# send request to service
resp = requests.post(service.scoring_uri, input_data, headers=headers)

print("POST to url", service.scoring_uri)
# can covert back to Python objects from json string if desired
print("prediction:", resp.text)

  7. Temizlemek.

    Dağıtılan bir web hizmetini silmek için kullanın service.delete().

Sorun giderme

  • Seyrek veriler desteklenmiyor: Model açıklaması panosu çok sayıda özellik ile önemli ölçüde bozulur/yavaşlar, bu nedenle şu anda seyrek veri biçimini desteklemiyoruz. Ayrıca, büyük veri kümelerinde ve çok sayıda özellikte genel bellek sorunları ortaya çıkar.

  • Desteklenen açıklamalar özellikler matrisi

Desteklenen açıklama sekmesi Ham özellikler (yoğun) Ham özellikler (seyrek) Mühendislik özellikleri (yoğun) Mühendislik özellikleri (seyrek)
Model performansı Desteklenir (tahmin yapılmaz) Desteklenir (tahmin yapılmaz) Desteklenir Desteklenir
Veri kümesi gezgini Desteklenir (tahmin yapılmaz) Desteklenmiyor. Seyrek veriler karşıya yüklenmediğinden ve kullanıcı arabiriminde seyrek verileri işleme sorunları olduğundan. Desteklenir Desteklenmiyor. Seyrek veriler karşıya yüklenmediğinden ve kullanıcı arabiriminde seyrek verileri işleme sorunları olduğundan.
Özellik önem düzeyini toplama Desteklenir Desteklenir Desteklenir Desteklenir
Bireysel özellik önemi Desteklenir (tahmin yapılmaz) Desteklenmiyor. Seyrek veriler karşıya yüklenmediğinden ve kullanıcı arabiriminde seyrek verileri işleme sorunları olduğundan. Desteklenir Desteklenmiyor. Seyrek veriler karşıya yüklenmediğinden ve kullanıcı arabiriminde seyrek verileri işleme sorunları olduğundan.

  • Model açıklamalarıyla desteklenmeyen tahmin modelleri: Yorumlanabilirlik, en iyi model açıklaması, en iyi model olarak aşağıdaki algoritmaları öneren AutoML tahmin denemeleri için kullanılamaz: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Mevsimsel Ortalama ve Mevsimsel Naive. AutoML Tahmin regresyon modelleri açıklamaları destekler. Ancak açıklama panosunda veri işlem hatlarındaki karmaşıklık nedeniyle "Bireysel özellik önemi" sekmesi tahmin için desteklenmez.

  • Veri dizini için yerel açıklama: Pano verileri rastgele aşağı örneklediğinden, veri kümesi 5000 veri noktasından büyükse, açıklama panosu özgün doğrulama veri kümesindeki bir satır tanımlayıcısıyla yerel önem değerleriyle ilgili bilgileri desteklemez. Ancak pano, Tek tek özellik önem sekmesi altında panoya geçirilen her veri noktası için ham veri kümesi özellik değerlerini gösterir. Kullanıcılar, ham veri kümesi özellik değerlerini eşleştirerek yerel önemleri özgün veri kümesine geri eşleyebilir. Doğrulama veri kümesi boyutu 5000'den az örnekse, index Azure Machine Learning stüdyosu özelliği doğrulama veri kümesindeki dizine karşılık gelir.

  • What-if/ICE çizimleri stüdyoda desteklenmiyor: What-If ve Individual Koşullu Beklenti (ICE) çizimleri, Azure Machine Learning stüdyosu Açıklamalar sekmesinin altında desteklenmez çünkü karşıya yüklenen açıklamanın tahminleri ve dayanıklı özelliklerin olasılıklarını yeniden hesaplamak için etkin bir işlem gerekir. Şu anda SDK kullanılarak pencere öğesi olarak çalıştırıldığında Jupyter not defterlerinde desteklenmektedir.

Sonraki adımlar

Azure Machine Learning'de model yorumlanabilirliği teknikleri

Azure Machine Learning yorumlanabilirlik örnek not defterlerine göz atın