Az értelmezhetőségi csomaggal ismertetheti a gépi tanulási modelleket és & Pythonban (előzetes verzió)

Ebben az útmutatóban megismerheti, hogyan használhatja az Azure Machine Learning Python SDK értelmezhetőségi csomagját a következő feladatok végrehajtásához:

  • A modell teljes viselkedésének vagy a személyes gép egyéni előrejelzésének helyi magyarázata.

  • Értelmezhetőségi technikák engedélyezése a tervezett funkciókhoz.

  • A teljes modell és az azure-beli egyéni előrejelzések viselkedésének magyarázata.

  • Vizualizációs irányítópulton használhatja a modell magyarázatát.

  • Üzembe helyezhet egy pontozási magyarázót a modell mellett, hogy megfigyelje a magyarázatokat a következtetés során.

A támogatott értelmezhetőségi technikákkal és gépi tanulási modellekkel kapcsolatos további információkért lásd: Modellértelmezhetőség Azure Machine Learning notebookok esetében.

Útmutatás az automatizált gépi tanulással betanított modellek értelmezhetőségének engedélyezéséhez: Értelmezhetőség: modell magyarázatai automatizált gépi tanulási modellekhez (előzetes verzió).

Funkció fontosságértékének létrehozása a személyes gépen

Az alábbi példa bemutatja, hogyan használható az értelmezhetőségi csomag a személyes gépen anélkül, hogy kapcsolatba lép az Azure-szolgáltatásokkal.

  1. Telepítse az azureml-interpret csomagot.

    pip install azureml-interpret
    
  2. Betanít egy mintamodellt egy helyi 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. Hívja meg helyileg az magyarázót.

    • Egy magyarázó objektum inicializálásához adja át a modellt és néhány betanításadatot az magyarázó konstruktorának.
    • A magyarázatok és vizualizációk informatívabb megjelenítéséhez besorolás esetén megadhatja a szolgáltatásneveket és a kimeneti osztályneveket.

    A következő kódblokkok azt mutatják be, hogyan példányosulhat egy magyarázó objektum a TabularExplainer , a és a helyi MimicExplainer PFIExplainer objektummal.

    • TabularExplainer az alatta lévő három SHAP-magyarázó TreeExplainer (, DeepExplainer , vagy ) valamelyikét hívja KernelExplainer meg.
    • TabularExplainer A automatikusan kiválasztja a legmegfelelőbbet az Adott esethez, de a három mögöttes magyarázó mindegyikét közvetlenül is meg lehet hívni.
    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)
    

    vagy

    
    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)
    

    vagy

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

A modell teljes viselkedésének magyarázata (globális magyarázat)

Az alábbi példában az összesített (globális) funkciók fontosságértékeinek lekért értékeit mutatjuk be.


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

Egyéni előrejelzés magyarázata (helyi magyarázat)

A különböző adatpontok egyéni fontosságértékének lehívása egy adott példány vagy példánycsoport magyarázatainak hívása segítségével.

Megjegyzés

PFIExplainer nem támogatja a helyi magyarázatokat.

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

Nyers jellemzőátalakítások

Dönthet úgy, hogy a magyarázatokat nyers, nem átformált funkciókkal, és nem tervezett funkciókkal szeretné lehozni. Ehhez a lehetőséghez át kell adni a funkcióátalakítási folyamatot a magyarázónak train_explain.py a következőben: . Ellenkező esetben a magyarázó a megtervezett jellemzőkre vonatkozó magyarázatokat ad meg.

A támogatott átalakítások formátuma megegyezik az sklearn-pandas fájlban leírt formátummal. Az átalakítások általában akkor támogatottak, ha egyetlen oszlopon működnek, így egyértelmű, hogy egy a többhez vannak.

A nyers jellemzők magyarázatát a vagy az illeszthető transzformátor-jelölések listájával sklearn.compose.ColumnTransformer lehet lehozni. Az alábbi példa a következőt sklearn.compose.ColumnTransformer használja: .

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)

Ha a példát az illeszthető transzformátor-lista listájával szeretné futtatni, használja a következő kódot:

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)

Fontosságértékek létrehozása távoli futtatásokkal

Az alábbi példa bemutatja, hogyan engedélyezheti a modell értelmezhetőségét a ExplanationClient távoli futtatásokkal a osztály használatával. Ez fogalmilag hasonló a helyi folyamathoz, kivéve a következőt:

  • Az ExplanationClient értelmezhetőségi környezet feltöltése a távoli futtatásban a használatával.
  • Töltse le a környezetet később egy helyi környezetben.
  1. Telepítse az azureml-interpret csomagot.

    pip install azureml-interpret
    
  2. Hozzon létre egy betanító szkriptet egy helyi Jupyter Notebook. Például: 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. Állítson be egy számítási Azure Machine Learning számítási célként, és küldje el a betanítás futtatását. Útmutatásért lásd Azure Machine Learning számítási fürtök létrehozása és kezelése. Hasznosnak találhatja a példajegyzetfüzeteket is.

  4. Töltse le a magyarázatot a helyi 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))
    

Vizualizációk

Miután letöltötte a magyarázatokat a helyi Jupyter Notebook, a magyarázatok irányítópulton található vizualizációk segítségével megértheti és értelmezheti a modellt. A magyarázatok irányítópult-vezérlő betöltéséhez Jupyter Notebook a következő kódot:

from interpret_community.widget import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

A vizualizációk mind a tervezett, mind a nyers jellemzőkre vonatkozó magyarázatokat támogatnak. A nyers magyarázatok az eredeti adatkészlet jellemzőin alapulnak, a megtervezett magyarázatok pedig az adatkészlet funkcióin alapulnak, és jellemzőkitervezést alkalmaznak.

Amikor az eredeti adatkészletre vonatkozó modellt próbál értelmezni, javasoljuk, hogy nyers magyarázatokat használjon, mivel minden funkció fontossága az eredeti adatkészlet egy oszlopának felel meg. Az egyik forgatókönyv, ahol a megtervezett magyarázatok hasznosak lehetnek, ha megvizsgáljuk az egyes kategóriák hatását egy kategorikus jellemzőből. Ha egy one-hot kódolást alkalmaznak egy kategorikus jellemzőre, akkor az eredményül kapott megtervezett magyarázatok kategóriánként eltérő fontosságértéket fognak tartalmazni, egy one-hot-ként megtervezett jellemzőt. Ez akkor lehet hasznos, ha leszűkíti, hogy az adatkészlet mely része a leginkább informatív a modell számára.

Megjegyzés

A kitervezett és nyers magyarázatok számítása egymást követő módon történt. Először a modell és a featurizálási folyamat alapján hozunk létre egy részletes magyarázatot. Ezt követően a nyers magyarázat a megtervezett magyarázat alapján lesz létrehozva, az ugyanazon nyers jellemzőből származó megtervezett jellemzők fontosságának összesítésével.

Adatkészletek kohorszok létrehozása, szerkesztése és megtekintése

A felső menüszalag a modell és az adatok általános statisztikáit jeleníti meg. Az adatokat adatcsoport-kohorszokra vagy alcsoportokra szeletelheti és szeletelheti, így megvizsgálhatja vagy összehasonlíthatja a modell teljesítményét és magyarázatát ezekben a meghatározott alcsoportokban. Ha összehasonlítja az adatkészlet statisztikáit és magyarázatát az egyes alcsoportokban, azzal érzékeltetheti, hogy miért történnek lehetséges hibák az egyik csoportban a másikkal szemben.

Adatkészletek kohorszai létrehozása, szerkesztése és megtekintése

A modell teljes viselkedésének magyarázata (globális magyarázat)

A magyarázatok irányítópultjának első három lapja átfogó elemzést nyújt a betanított modellről, valamint annak előrejelzéseit és magyarázatait.

A modell teljesítménye

A modell teljesítményének kiértékeléséhez vizsgálja meg az előrejelzési értékek eloszlását és a modell teljesítménymetrikák értékeit. A modell további vizsgálathoz megvizsgálhatja az adatkészlet különböző kohorszai vagy alcsoportjai teljesítményének összehasonlító elemzését. A különböző dimenziók közötti átvágáshoz válassza az y-value és az x-value mentén lévő szűrőket. Megtekintheti az olyan metrikákat, mint a pontosság, a pontosság, a felidézés, a téves pozitív arány (FPR) és a téves negatív arány (FNR).

Modellteljesítmény lap a magyarázatvizualizációban

Dataset Explorer

Az adatok különböző dimenziókra való szeletelése érdekében az X, az Y és a szín tengely mentén különböző szűrők kiválasztásával tárja fel az adatkészlet statisztikáit. Hozzon létre fent adatkészlet-kohorszokat az adatkészlet-statisztikák elemzéséhez olyan szűrőkkel, mint az előrejelzett eredmény, az adatkészlet jellemzői és a hibacsoportok. A diagram jobb felső sarkában található fogaskerék ikonnal módosíthatja a gráftípusokat.

A magyarázatvizualizáció Adatkészlet-böngésző lapja

A funkció fontosságának összesítése

Ismerje meg a legfontosabb jellemzőket, amelyek hatással vannak az általános modell-előrejelzésekre (más néven globális magyarázat). A csúszkával a jellemző fontossága csökkenő értékeit mutathatja. Legfeljebb három kohorsz kiválasztásával egymás mellett láthatja a fontosságukat. Kattintson a diagram bármelyik jellemzősávjére, hogy lássa, hogy a kiválasztott jellemzőértékek hogyan befolyásolják a modell előrejelzését az alábbi függőségi diagramon.

A funkció fontosságának összesítése lap a magyarázatok vizualizációban

Az egyéni előrejelzések magyarázata (helyi magyarázat)

A magyarázat lap negyedik lapján részletesen is megtekintheti az egyes adatpontokat és azok egyes funkciók fontosságát. Az egyes adatpontok fontosságdiagramját betöltheti úgy, hogy a fő pontdiagram bármelyik adatpontjára kattint, vagy kiválaszt egy adott adatpontot a jobb oldalon található panel varázslóban.

Telek Description
Az egyes funkciók fontossága Egy adott előrejelzés legfontosabb jellemzőit jeleníti meg. Segít az alapul szolgáló modell helyi viselkedésének szemléltetésére egy adott adatponton.
What-If elemzése Lehetővé teszi a kiválasztott valós adatpont jellemzőértékének módosításait, és megfigyelheti az előrejelzési érték változásait egy feltételezett adatpont létrehozásával az új jellemzőértékekkel.
Egyéni feltételes elvárás (ICE) Lehetővé teszi a funkció értékének minimálisról maximális értékre való változását. Bemutatja, hogyan változik az adatpont előrejelzése, amikor egy funkció megváltozik.

Az egyes funkciók fontossága és a lehetőség leírása irányítópult what-if (lehetőség) lapja

Megjegyzés

Ezek számos közelítésen alapuló magyarázatok, és nem az előrejelzések "oka". Az okozati következtetés szigorú matematikai robusztussága nélkül nem javasoljuk a felhasználóknak, hogy valós döntéseket hozzanak az eszköz What-If alapján. Ez az eszköz elsősorban a modell és a hibakeresés megértésére használható.

Vizualizáció Azure Machine Learning stúdió

Ha befejezte a távoli értelmezhetőségi lépéseket (a létrehozott magyarázatok feltöltése a Azure Machine Learning Futtatás előzményeibe), a magyarázatok irányítópultján megtekintheti a vizualizációkat a Azure Machine Learning stúdió. Ez az irányítópult a Jupyter notebookban létrehozott irányítópult-widget egyszerűbb verziója. What-If adatpontok létrehozása és az ICE-ábrázolások le vannak tiltva, mivel nincs olyan aktív számítási Azure Machine Learning stúdió amely képes lenne valós idejű számításokat végezni.

Ha az adatkészlet, a globális és a helyi magyarázatok elérhetők, az adatok az összes lapot kitöltik. Ha csak globális magyarázat érhető el, az Egyéni funkció fontossága lap le lesz tiltva.

Kövesse az alábbi elérési utak valamelyikét a magyarázatok irányítópultjának Azure Machine Learning stúdió:

  • Kísérletek panel (előzetes verzió)

    1. A bal oldali panelen válassza a Kísérletek lehetőséget a bal oldalon futtatott kísérletek listájának Azure Machine Learning.
    2. Válasszon ki egy adott kísérletet a kísérlet összes futtatásának megtekintéséhez.
    3. Válasszon ki egy futtatás, majd a Magyarázatok lapot a magyarázatvizualizációs irányítópulton.

    Vizualizációs irányítópult a funkciók összesített fontosságával az AzureML Studióban kísérletekben

  • Modellek panel

    1. Ha az eredeti modellt a Deploy models with Azure Machine Learning(Modellek üzembe helyezése a Azure Machine Learning használatával) lépésekkel regisztrálta, a bal oldali panelen a Modellek lehetőséget választva megtekintheti.
    2. Válasszon ki egy modellt, majd a Magyarázatok lapot a magyarázatok irányítópultjának megtekintéséhez.

Értelmezhetőség dedokenciaidőben

Üzembe helyezheti az magyarázót az eredeti modellel együtt, és a következtetéskor használhatja az új adatpontok egyedi fontosságértékének (helyi magyarázatának) a megadáshoz. Emellett könnyebb pontozási magyarázókat is kínálunk, amelyek javítják az értelmezhetőségi teljesítményt a dedukenciaidőben, ami jelenleg csak az SDK-ban Azure Machine Learning támogatott. A kisebb súlyozású pontozók üzembe helyezésének folyamata hasonló a modell üzembe helyezéséhez, és a következő lépéseket tartalmazza:

  1. Magyarázatobjektum létrehozása. Használhatja például a TabularExplainer következőt:

     from interpret.ext.blackbox import TabularExplainer
    
    
    explainer = TabularExplainer(model, 
                                 initialization_examples=x_train, 
                                 features=dataset_feature_names, 
                                 classes=dataset_classes, 
                                 transformations=transformations)
    
  2. Hozzon létre egy pontozó magyarázót a magyarázat objektummal.

    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. Konfigurálhat és regisztrálhat egy olyan képet, amely a pontozás magyarázó modelljét használja.

    # 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. Választható lépésként lekérheti a pontozási magyarázó adatokat a felhőből, és tesztelheti a magyarázatokat.

    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. Telepítse a rendszerképet egy számítási célon az alábbi lépésekkel:

    1. Ha szükséges, regisztrálja az eredeti előrejelzési modellt a Következővel: Modellek üzembe helyezése az Azure Machine Learning.

    2. Pontozófájl létrehozása.

      %%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. Az üzembe helyezési konfiguráció meghatározása.

      Ez a konfiguráció a modell követelményeitől függ. Az alábbi példa egy olyan konfigurációt határoz meg, amely egy processzormagot és egy GB memóriát használ.

      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. Hozzon létre egy fájlt környezeti függőségekkel.

      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. Hozzon létre egy egyéni dockerfile-t a g++ telepítéssel.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. A létrehozott rendszerkép üzembe helyezése.

      Ez a folyamat körülbelül öt percet vesz igénybe.

      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. Az üzembe helyezés tesztelése.

    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. A tisztítás.

    Az üzembe helyezett webszolgáltatás törléséhez használja a service.delete() parancsot.

Hibaelhárítás

  • Ritka adatok nem támogatottak: A modell magyarázatának irányítópultja sok funkcióval jelentősen leomlik/lelassul, ezért jelenleg nem támogatjuk a ritka adatformátumokat. Emellett nagy méretű adatkészletekkel és sok jellemzővel kapcsolatos általános memória-problémák merülnek fel.

  • A modell magyarázatai által nem támogatott előrejelzési modellek: Az értelmezhetőség, a legjobb modell magyarázata nem érhető el az AutoML-előrejelzési kísérletekhez, amelyek a következő algoritmusokat ajánlják a legjobb modellként: TCNForecaster, AutoArima, Following, ExponentialSmomuting, Average, Naive, Seasonal Naive és Seasonal Naive. Az AutoML-előrejelzés olyan regressziós modellekkel rendelkezik, amelyek támogatják a magyarázatokat. A magyarázatok irányítópultján azonban az "Egyéni funkciók fontossága" lap csak az adat-folyamatok összetettsége miatt nem támogatott az előrejelzéshez.

  • Az adatindex helyi magyarázata: A magyarázat-irányítópult nem támogatja a helyi fontosságértékek és az eredeti érvényesítési adatkészlet sorazonosítójának a 5000 adatpontnál nagyobb adatpontokkal való összepárosítését, mivel az irányítópult véletlenszerűen lefelé mintavétele az adatokat. Az irányítópult azonban nyers adat adatkészlet-funkciók értékeit jeleníti meg az irányítópultnak az Egyéni funkció fontossága lapon átadott egyes adatpontokhoz. A felhasználók a nyers adatkészlet jellemzőértékeivel leképezhetik a helyi fontosságokat az eredeti adatkészletre. Ha az érvényesítési adatkészlet mérete 5000-esnél kisebb, akkor az AzureML Studio szolgáltatása megfelel az ellenőrzési adatkészletben lévő index indexnek.

  • A What-if/ICE-ábrázolás nem támogatott a Studióban: az What-If és az egyéni feltételes elvárás (ICE) ábrázolásai a Magyarázatok lapon nem támogatottak a Azure Machine Learning stúdió-ban, mivel a feltöltött magyarázatnak aktív számításra van szüksége az előrejelzések újraszámítása és a zavarba került funkciók valószínűségének újraszámítása érdekében. A Jupyter-notebookok jelenleg ezt támogatják, ha az SDK-t használó widgetként futnak.

Következő lépések

További információ a modell értelmezhetőségével kapcsolatban

Tekintse meg az Azure Machine Learning mintákat tartalmazó jegyzetfüzeteket