Użyj pakietu interpretowania języka Python, aby wyjaśnić przewidywania modeli & uczenia maszynowego (wersja zapoznawcza)

DOTYCZY:Zestaw SDK języka Python w wersji 1

W tym przewodniku z instrukcjami dowiesz się, jak używać pakietu do interpretowania zestawu SDK języka Python usługi Azure Machine Learning, aby wykonać następujące zadania:

  • Wyjaśnij całe zachowanie modelu lub indywidualne przewidywania na komputerze osobistym lokalnie.

  • Włącz techniki interpretowania dla funkcji zaprojektowanych.

  • Wyjaśnienie zachowania całego modelu i poszczególnych przewidywań na platformie Azure.

  • Przekaż wyjaśnienia do historii uruchamiania usługi Azure Machine Learning.

  • Użyj pulpitu nawigacyjnego wizualizacji, aby korzystać z wyjaśnień modelu, zarówno w Jupyter Notebook, jak i w Azure Machine Learning studio.

  • Wdróż wyjaśnienie oceniania obok modelu, aby obserwować wyjaśnienia podczas wnioskowania.

Aby uzyskać więcej informacji na temat obsługiwanych technik interpretacji i modeli uczenia maszynowego, zobacz Interpretacja modelu w usłudze Azure Machine Learning i przykładowe notesy.

Aby uzyskać wskazówki dotyczące włączania interpretacji modeli wytrenowanych za pomocą zautomatyzowanego uczenia maszynowego, zobacz Interpretowanie: wyjaśnienia modeli zautomatyzowanego uczenia maszynowego (wersja zapoznawcza).

Generowanie wartości ważności funkcji na komputerze osobistym

W poniższym przykładzie pokazano, jak używać pakietu do interpretowania na komputerze osobistym bez kontaktu z usługami platformy Azure.

  1. Zainstaluj pakiet azureml-interpret.

    pip install azureml-interpret
    
  2. Trenowanie przykładowego modelu w lokalnym Jupyter Notebook.

    # 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. Wywołaj objaśnienie lokalnie.

    • Aby zainicjować obiekt objaśnienia, przekaż model i niektóre dane treningowe do konstruktora objaśnienia.
    • Aby wyjaśnić i wizualizacje bardziej informacyjne, możesz przekazać nazwy funkcji i nazwy klas wyjściowych w przypadku klasyfikacji.

    W poniższych blokach kodu pokazano, jak utworzyć wystąpienie obiektu objaśnienia za pomocą TabularExplainerpolecenia , MimicExplaineri PFIExplainer lokalnie.

    • TabularExplainer wywołuje jeden z trzech objaśnień SHAP poniżej (TreeExplainer, DeepExplainer, lub KernelExplainer).
    • TabularExplainer automatycznie wybiera najbardziej odpowiedni przypadek użycia, ale można bezpośrednio wywołać każde z trzech podstawowych wyjaśnień.
    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)
    

    lub

    
    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)
    

    lub

    from interpret.ext.blackbox import PFIExplainer
    
    # "features" and "classes" fields are optional
    explainer = PFIExplainer(model,
                             features=breast_cancer_data.feature_names, 
                             classes=classes)
    

Wyjaśnienie całego zachowania modelu (wyjaśnienie globalne)

Zapoznaj się z poniższym przykładem, aby ułatwić uzyskanie wartości ważności funkcji agregującej (globalnej).


# 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()

Wyjaśnienie indywidualnego przewidywania (wyjaśnienie lokalne)

Uzyskaj poszczególne wartości ważności funkcji różnych punktów danych, wywołując wyjaśnienia dla pojedynczego wystąpienia lub grupy wystąpień.

Uwaga

PFIExplainer nie obsługuje lokalnych wyjaśnień.

# 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()

Nieprzetworzone przekształcenia funkcji

Możesz zdecydować się na uzyskanie wyjaśnień w zakresie nieprzetworzonych, nieprzetworzonych funkcji, a nie funkcji zaprojektowanych. W przypadku tej opcji przekazujesz potok przekształcania funkcji do objaśnienia w pliku train_explain.py. W przeciwnym razie objaśnienie zawiera wyjaśnienia dotyczące funkcji zaprojektowanych.

Format obsługiwanych przekształceń jest taki sam jak w artykule sklearn-pandas. Ogólnie rzecz biorąc, wszystkie przekształcenia są obsługiwane tak długo, jak działają one w jednej kolumnie, aby było jasne, że są one jeden do wielu.

Zapoznaj się z wyjaśnieniem pierwotnych cech przy użyciu elementu sklearn.compose.ColumnTransformer lub z listą dopasowanych krotki transformatora. W poniższym przykładzie użyto metody 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)

Jeśli chcesz uruchomić przykład z listą dopasowanych krotki transformatorów, użyj następującego kodu:

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)

Generowanie wartości ważności funkcji za pośrednictwem przebiegów zdalnych

W poniższym przykładzie pokazano, jak można użyć ExplanationClient klasy , aby umożliwić interpretowanie modelu dla przebiegów zdalnych. Jest ona koncepcyjnie podobna do procesu lokalnego, z wyjątkiem:

  • Użyj polecenia ExplanationClient w zdalnym uruchomieniu, aby przekazać kontekst możliwości interpretacji.
  • Pobierz kontekst później w środowisku lokalnym.
  1. Zainstaluj pakiet azureml-interpret.

    pip install azureml-interpret
    
  2. Utwórz skrypt trenowania w lokalnym Jupyter Notebook. Na przykład 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. Skonfiguruj usługę Azure Machine Learning Compute jako obiekt docelowy obliczeniowy i prześlij przebieg trenowania. Aby uzyskać instrukcje, zobacz Tworzenie klastrów obliczeniowych usługi Azure Machine Learning i zarządzanie nimi . Przydatne mogą być również przykładowe notesy .

  4. Pobierz wyjaśnienie w lokalnym Jupyter Notebook.

    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))
    

Wizualizacje

Po pobraniu wyjaśnień w lokalnym Jupyter Notebook możesz użyć wizualizacji na pulpicie nawigacyjnym wyjaśnień, aby zrozumieć i interpretować model. Aby załadować widżet pulpitu nawigacyjnego wyjaśnień w Jupyter Notebook, użyj następującego kodu:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Wizualizacje obsługują wyjaśnienia dotyczące funkcji zaprojektowanych i pierwotnych. Nieprzetworzone wyjaśnienia są oparte na funkcjach z oryginalnego zestawu danych, a objaśnienia inżynieryjne są oparte na funkcjach z zestawu danych z zastosowaniem inżynierii cech.

Podczas próby zinterpretowania modelu w odniesieniu do oryginalnego zestawu danych zaleca się użycie pierwotnych wyjaśnień, ponieważ każda ważność funkcji będzie odpowiadać kolumnie z oryginalnego zestawu danych. Jednym ze scenariuszy, w którym zaprojektowane wyjaśnienia mogą być przydatne, jest zbadanie wpływu poszczególnych kategorii z funkcji kategorii. Jeśli kodowanie jedno-gorące jest stosowane do funkcji kategorycznej, wynikowe objaśnienia inżynierów będą zawierać inną wartość ważności na kategorię, jedną na jedno gorącą funkcję zaprojektowaną. To kodowanie może być przydatne podczas zawężania, która część zestawu danych jest najbardziej informacyjna dla modelu.

Uwaga

Objaśnienia inżynierów i nieprzetworzonych są obliczane sekwencyjnie. Najpierw zostanie utworzone wyjaśnienie zaprojektowane na podstawie potoku modelu i cechowania. Następnie pierwotne wyjaśnienie jest tworzone na podstawie tego zaprojektowanego wyjaśnienia, agregując znaczenie zaprojektowanych cech, które pochodzą z tej samej pierwotnej funkcji.

Tworzenie, edytowanie i wyświetlanie kohort zestawów danych

Górna wstążka przedstawia ogólne statystyki dotyczące modelu i danych. Dane można podzielić i podzielić na kohorty zestawów danych lub podgrupy, aby zbadać lub porównać wydajność i wyjaśnienia modelu w tych zdefiniowanych podgrupach. Porównując statystyki i wyjaśnienia zestawu danych w tych podgrupach, możesz zrozumieć, dlaczego możliwe błędy występują w jednej grupie w porównaniu z innymi.

Tworzenie, edytowanie i wyświetlanie kohort zestawów danych

Omówienie całego zachowania modelu (wyjaśnienie globalne)

Pierwsze trzy karty pulpitu nawigacyjnego wyjaśnienia zawierają ogólną analizę wytrenowanego modelu wraz z jego przewidywaniami i wyjaśnieniami.

Wydajność modelu

Oceń wydajność modelu, eksplorując rozkład wartości przewidywania i wartości metryk wydajności modelu. Możesz dokładniej zbadać model, przeglądając analizę porównawczą jej wydajności w różnych kohortach lub podgrupach zestawu danych. Wybierz filtry wzdłuż wartości y i x-value, aby wyciąć różne wymiary. Wyświetl metryki, takie jak dokładność, precyzja, kompletność, współczynnik fałszywie dodatni (FPR) i współczynnik fałszywie ujemny (FNR).

Karta Wydajność modelu w wizualizacji objaśnień

Eksplorator zestawu danych

Eksploruj statystyki zestawu danych, wybierając różne filtry wzdłuż osi X, Y i kolorów, aby podzielić dane na różne wymiary. Utwórz kohorty zestawów danych powyżej, aby analizować statystyki zestawu danych z filtrami, takimi jak przewidywany wynik, funkcje zestawu danych i grupy błędów. Użyj ikony koła zębatego w prawym górnym rogu grafu, aby zmienić typy grafów.

Karta Eksploratora zestawów danych w wizualizacji objaśnień

Zagregowanie znaczenia funkcji

Zapoznaj się z najważniejszymi funkcjami, które mają wpływ na ogólne przewidywania modelu (nazywane również globalnym wyjaśnieniem). Użyj suwaka, aby wyświetlić malejące wartości ważności funkcji. Wybierz maksymalnie trzy kohorty, aby zobaczyć ich wartości ważności funkcji obok siebie. Wybierz dowolny słupek funkcji na wykresie, aby zobaczyć, jak wartości przewidywania modelu wpływu wybranej funkcji na wykres zależności poniżej.

Karta Agregacja ważności funkcji w wizualizacji wyjaśnienia

Omówienie poszczególnych przewidywań (wyjaśnienie lokalne)

Czwarta karta objaśnienia umożliwia przechodzenie do szczegółów poszczególnych punktów danych i ich indywidualnych ważności funkcji. Można załadować pojedynczy wykres ważności funkcji dla dowolnego punktu danych, klikając dowolny z poszczególnych punktów danych na głównym wykresie punktowym lub wybierając konkretny punkt danych w kreatorze panelu po prawej stronie.

Działka Opis
Ważność poszczególnych funkcji Przedstawia najważniejsze funkcje dla indywidualnego przewidywania. Pomaga zilustrować lokalne zachowanie bazowego modelu w określonym punkcie danych.
analiza What-If Umożliwia zmianom wartości funkcji wybranego rzeczywistego punktu danych i obserwowaniu wynikowych zmian wartości przewidywania przez wygenerowanie hipotetycznego punktu danych z nowymi wartościami funkcji.
Indywidualne oczekiwania warunkowe (ICE) Umożliwia zmianę wartości funkcji z wartości minimalnej na maksymalną. Pomaga zilustrować zmiany przewidywania punktu danych po zmianie funkcji.

Ważność poszczególnych funkcji i karta Analizy co-jeżeli na pulpicie nawigacyjnym wyjaśnienia

Uwaga

Są to wyjaśnienia oparte na wielu przybliżeniach i nie są "przyczyną" przewidywań. Bez ścisłej matematycznej niezawodności wnioskowania przyczynowego nie zalecamy użytkownikom podejmowania rzeczywistych decyzji w oparciu o zakłócenia funkcji narzędzia What-If. To narzędzie służy przede wszystkim do zrozumienia modelu i debugowania.

Wizualizacja w Azure Machine Learning studio

Jeśli wykonasz kroki zdalnego interpretowania (przekazywanie wygenerowanych wyjaśnień do historii uruchamiania usługi Azure Machine Learning), możesz wyświetlić wizualizacje na pulpicie nawigacyjnym wyjaśnień w Azure Machine Learning studio. Ten pulpit nawigacyjny jest prostszą wersją widżetu pulpitu nawigacyjnego wygenerowanego w Jupyter Notebook. What-If generowanie punktów danych i wykresy ICE są wyłączone, ponieważ w Azure Machine Learning studio nie ma aktywnych obliczeń, które mogą wykonywać obliczenia w czasie rzeczywistym.

Jeśli dostępne są wyjaśnienia dotyczące zestawu danych, globalnego i lokalnego, dane wypełniają wszystkie karty. Jeśli jednak dostępne jest tylko globalne wyjaśnienie, karta Ważność poszczególnych funkcji zostanie wyłączona.

Wykonaj jedną z tych ścieżek, aby uzyskać dostęp do pulpitu nawigacyjnego wyjaśnień w Azure Machine Learning studio:

  • Okienko Eksperymenty (wersja zapoznawcza)

    1. Wybierz pozycję Eksperymenty w okienku po lewej stronie, aby wyświetlić listę eksperymentów uruchomionych w usłudze Azure Machine Learning.
    2. Wybierz konkretny eksperyment, aby wyświetlić wszystkie przebiegi w tym eksperymencie.
    3. Wybierz przebieg, a następnie kartę Wyjaśnienia na pulpicie nawigacyjnym wizualizacji wyjaśnienia.

    Pulpit nawigacyjny wizualizacji z zagregowanym znaczeniem funkcji w programie AzureML Studio w eksperymentach

  • Okienko Modele

    1. Jeśli zarejestrowano oryginalny model, wykonując kroki opisane w temacie Wdrażanie modeli za pomocą usługi Azure Machine Learning, możesz wybrać pozycję Modele w okienku po lewej stronie, aby go wyświetlić.
    2. Wybierz model, a następnie kartę Wyjaśnienia , aby wyświetlić pulpit nawigacyjny wyjaśnień.

Możliwość interpretacji w czasie wnioskowania

Możesz wdrożyć objaśnienie wraz z oryginalnym modelem i użyć go w czasie wnioskowania, aby podać poszczególne wartości ważności funkcji (wyjaśnienie lokalne) dla dowolnego nowego punktu danych. Oferujemy również wyjaśnienia w zakresie oceny lżejszej wagi, aby zwiększyć wydajność interpretowania w czasie wnioskowania, który jest obecnie obsługiwany tylko w zestawie SDK usługi Azure Machine Learning. Proces wdrażania objaśnienia oceniania o lżejszej wadze jest podobny do wdrażania modelu i obejmuje następujące kroki:

  1. Utwórz obiekt wyjaśnienia. Można na przykład użyć polecenia TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer
    
    
    explainer = TabularExplainer(model, 
                                 initialization_examples=x_train, 
                                 features=dataset_feature_names, 
                                 classes=dataset_classes, 
                                 transformations=transformations)
    
  2. Utwórz objaśnienie oceniania z obiektem wyjaśnienia.

    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. Konfigurowanie i rejestrowanie obrazu korzystającego z modelu objaśnienia oceniania.

    # 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. Opcjonalnie możesz pobrać objaśnienie oceniania z chmury i przetestować wyjaśnienia.

    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. Wdróż obraz w docelowym obiekcie obliczeniowym, wykonując następujące kroki:

    1. W razie potrzeby zarejestruj oryginalny model przewidywania, wykonując kroki opisane w temacie Wdrażanie modeli za pomocą usługi Azure Machine Learning.

    2. Utwórz plik oceniania.

      %%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. Zdefiniowanie konfiguracji wdrożenia.

      Ta konfiguracja zależy od wymagań modelu. W poniższym przykładzie zdefiniowano konfigurację, która używa jednego rdzenia procesora CPU i jednego GB pamięci.

      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. Utwórz plik z zależnościami środowiska.

      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. Utwórz niestandardowy plik dockerfile z zainstalowanym językiem g++.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. Wdróż utworzony obraz.

      Ten proces trwa około pięciu minut.

      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. Przetestuj wdrożenie.

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

    Aby usunąć wdrożona usługę internetową, użyj polecenia service.delete().

Rozwiązywanie problemów

  • Dane rozrzedłe nie są obsługiwane: pulpit nawigacyjny objaśnienia modelu przerywa/spowalnia znacznie z dużą liczbą funkcji, dlatego obecnie nie obsługujemy rozrzednia formatu danych. Ponadto wystąpią ogólne problemy z pamięcią w przypadku dużych zestawów danych i dużej liczby funkcji.

  • Macierz obsługiwanych wyjaśnień

Obsługiwana karta wyjaśnienia Surowe funkcje (gęste) Nieprzetworzone funkcje (rozrzedzone) Funkcje zaprojektowane (gęste) Funkcje zaprojektowane (rozrzedzone)
Wydajność modelu Obsługiwane (nie prognozowanie) Obsługiwane (nie prognozowanie) Obsługiwane Obsługiwane
Eksplorator zestawów danych Obsługiwane (nie prognozowanie) Nieobsługiwane. Ponieważ rozrzedzone dane nie są przekazywane, a interfejs użytkownika ma problemy z renderowaniem rozrzedzone dane. Obsługiwane Nieobsługiwane. Ponieważ rozrzedzone dane nie są przekazywane, a interfejs użytkownika ma problemy z renderowaniem rozrzedzone dane.
Zagregowanie ważności funkcji Obsługiwane Obsługiwane Obsługiwane Obsługiwane
Ważność poszczególnych funkcji Obsługiwane (nie prognozowanie) Nieobsługiwane. Ponieważ rozrzedzone dane nie są przekazywane, a interfejs użytkownika ma problemy z renderowaniem rozrzedzone dane. Obsługiwane Nieobsługiwane. Ponieważ rozrzedzone dane nie są przekazywane, a interfejs użytkownika ma problemy z renderowaniem rozrzedzone dane.
  • Modele prognozowania nie są obsługiwane w przypadku wyjaśnień modelu: Możliwość interpretacji, najlepsze wyjaśnienie modelu, nie jest dostępna w przypadku eksperymentów prognozowania automatycznego uczenia maszynowego, które zalecają następujące algorytmy jako najlepszy model: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Seasonal Average i Seasonal Naive. Modele regresji prognozowania automatycznego uczenia maszynowego obsługują wyjaśnienia. Jednak na pulpicie nawigacyjnym wyjaśnienia karta "Ważność poszczególnych funkcji" nie jest obsługiwana w przypadku prognozowania ze względu na złożoność potoków danych.

  • Lokalne wyjaśnienie indeksu danych: Pulpit nawigacyjny wyjaśnienia nie obsługuje wiązania wartości o znaczeniu lokalnym z identyfikatorem wiersza z oryginalnego zestawu danych sprawdzania poprawności, jeśli ten zestaw danych jest większy niż 5000 punktów danych, ponieważ pulpit nawigacyjny losowo wyłącza próbkowanie danych. Jednak na pulpicie nawigacyjnym są wyświetlane nieprzetworzone wartości funkcji zestawu danych dla każdego punktu danych przekazanego do pulpitu nawigacyjnego na karcie Ważność poszczególnych funkcji. Użytkownicy mogą mapować lokalne znaczenie z powrotem na oryginalny zestaw danych, pasując do nieprzetworzonych wartości funkcji zestawu danych. Jeśli rozmiar zestawu danych weryfikacji jest mniejszy niż 5000 przykładów, index funkcja w usłudze AzureML Studio będzie odpowiadać indeksowi w zestawie danych weryfikacji.

  • Wykresy warunkowe/ICE nie są obsługiwane w studio: wykresy What-If i indywidualne oczekiwania warunkowe (ICE) nie są obsługiwane w Azure Machine Learning studio na karcie Wyjaśnienia, ponieważ przekazane wyjaśnienie wymaga aktywnego obliczenia w celu ponownego obliczenia przewidywań i prawdopodobieństwa zwabionych funkcji. Jest ona obecnie obsługiwana w notesach Jupyter w przypadku uruchamiania jako widżetu przy użyciu zestawu SDK.

Następne kroki

Techniki interpretowania modelu w usłudze Azure ML

Zapoznaj się z przykładowymi notesami możliwości interpretacji usługi Azure Machine Learning