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

Ş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.

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.

# 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.

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.

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.

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.

Ö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.

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.

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.

  

• 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

• 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