Självstudie: Power BI-integrering – Skapa förutsägelsemodellen med en Jupyter Notebook (del 1 av 2)

GÄLLER FÖR:Python SDK azureml v1

I del 1 av den här självstudien tränar och distribuerar du en förutsägelsemodell för maskininlärning med hjälp av kod i en Jupyter Notebook. Du skapar också ett bedömningsskript för att definiera indata- och utdataschemat för modellen för integrering i Power BI. I del 2 använder du modellen för att förutsäga resultat i Microsoft Power BI.

I den här kursen får du:

  • Skapa en Jupyter Notebook.
  • Skapa en Azure Machine Learning-beräkningsinstans.
  • Träna en regressionsmodell med hjälp av scikit-learn.
  • Skriv ett bedömningsskript som definierar indata och utdata för enkel integrering i Microsoft Power BI.
  • Distribuera modellen till en slutpunkt för bedömning i realtid.

Förutsättningar

  • En Azure-prenumeration. Om du inte redan har en prenumeration kan du använda en kostnadsfri utvärderingsversion.
  • En Azure Machine Learning-arbetsyta. Om du inte redan har en arbetsyta kan du läsa Skapa arbetsyteresurser.
  • Introduktionskunskaper om Python-språk- och maskininlärningsarbetsflöden.

Skapa en notebook-fil och beräkning

På startsidan för Azure Machine Learning Studio väljer du Skapa ny>anteckningsbok:

Skärmbild som visar hur du skapar en anteckningsbok.

På sidan Skapa en ny fil :

  1. Ge anteckningsboken namnet (till exempel my_model_notebook).
  2. Ändra filtyp till Notebook.
  3. Välj Skapa.

Om du vill köra kodceller skapar du sedan en beräkningsinstans och kopplar den till anteckningsboken. Börja med att välja plusikonen överst i anteckningsboken:

Skärmbild som visar hur du skapar en beräkningsinstans.

På sidan Skapa beräkningsinstans :

  1. Välj en storlek på den virtuella processordatorn. I den här självstudien kan du välja en Standard_D11_v2 med 2 kärnor och 14 GB RAM-minne.
  2. Välj Nästa.
  3. På sidan Konfigurera inställningar anger du ett giltigt beräkningsnamn. Giltiga tecken är versaler och gemener, siffror och bindestreck (-).
  4. Välj Skapa.

I notebook-filen kanske du ser cirkeln bredvid Compute som har blivit cyan. Den här färgändringen anger att beräkningsinstansen skapas:

Skärmbild som visar en beräkning som skapas.

Anteckning

Det kan ta 2 till 4 minuter att etablera beräkningsinstansen.

När beräkningen har etablerats kan du använda notebook-filen för att köra kodceller. I cellen kan du till exempel skriva följande kod:

import numpy as np

np.sin(3)

Välj sedan Skift + Retur (eller välj Kontroll + Retur eller välj knappen Spela upp bredvid cellen). Du bör se följande utdata:

Skärmbild som visar utdata från en cell.

Nu är du redo att skapa en maskininlärningsmodell.

Skapa en modell med hjälp av scikit-learn

I den här självstudien använder du datauppsättningen Diabetes. Den här datauppsättningen är tillgänglig i Azure Open Datasets.

Importera data

Om du vill importera dina data kopierar du följande kod och klistrar in den i en ny kodcell i anteckningsboken.

from azureml.opendatasets import Diabetes

diabetes = Diabetes.get_tabular_dataset()
X = diabetes.drop_columns("Y")
y = diabetes.keep_columns("Y")
X_df = X.to_pandas_dataframe()
y_df = y.to_pandas_dataframe()
X_df.info()

Pandas-dataramen X_df innehåller 10 baslinjeindatavariabler. Dessa variabler inkluderar ålder, kön, kroppsmasseindex, genomsnittligt blodtryck och sex blodserummätningar. Pandas-dataramen y_df är målvariabeln. Den innehåller ett kvantitativt mått på sjukdomsförloppet ett år efter baslinjen. Dataramen innehåller 442 poster.

Träna modellen

Skapa en ny kodcell i anteckningsboken . Kopiera sedan följande kod och klistra in den i cellen. Det här kodfragmentet konstruerar en regressionsmodell för åsen och serialiserar modellen med hjälp av Python Pickle-formatet.

import joblib
from sklearn.linear_model import Ridge

model = Ridge().fit(X_df,y_df)
joblib.dump(model, 'sklearn_regression_model.pkl')

Registrera modellen

Förutom innehållet i själva modellfilen lagrar den registrerade modellen metadata. Metadata innehåller modellbeskrivning, taggar och ramverksinformation.

Metadata är användbara när du hanterar och distribuerar modeller på din arbetsyta. Med hjälp av taggar kan du till exempel kategorisera dina modeller och använda filter när du listar modeller på din arbetsyta. Om du markerar den här modellen med scikit-learn-ramverket förenklar du distributionen som en webbtjänst.

Kopiera följande kod och klistra sedan in den i en ny kodcell i anteckningsboken.

import sklearn

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

ws = Workspace.from_config()

model = Model.register(workspace=ws,
                       model_name='my-sklearn-model',                # Name of the registered model in your workspace.
                       model_path='./sklearn_regression_model.pkl',  # Local file to upload and register as a model.
                       model_framework=Model.Framework.SCIKITLEARN,  # Framework used to create the model.
                       model_framework_version=sklearn.__version__,  # Version of scikit-learn used to create the model.
                       sample_input_dataset=X,
                       sample_output_dataset=y,
                       resource_configuration=ResourceConfiguration(cpu=2, memory_in_gb=4),
                       description='Ridge regression model to predict diabetes progression.',
                       tags={'area': 'diabetes', 'type': 'regression'})

print('Name:', model.name)
print('Version:', model.version)

Du kan också visa modellen i Azure Machine Learning Studio. I menyn till vänster väljer du Modeller:

Skärmbild som visar hur du visar en modell.

Definiera bedömningsskriptet

När du distribuerar en modell som ska integreras i Power BI måste du definiera ett Python-bedömningsskript och en anpassad miljö. Bedömningsskriptet innehåller två funktioner:

  • Funktionen init() körs när tjänsten startas. Den läser in modellen (som laddas ned automatiskt från modellregistret) och deserialiserar den.
  • Funktionen run(data) körs när ett anrop till tjänsten innehåller indata som måste poängsätts.

Anteckning

Python-dekoratörerna i koden nedan definierar schemat för in- och utdata, vilket är viktigt för integrering i Power BI.

Kopiera följande kod och klistra in den i en ny kodcell i anteckningsboken. Följande kodfragment har cellmagi som skriver koden till en fil med namnet score.py.

%%writefile score.py

import json
import pickle
import numpy as np
import pandas as pd
import os
import joblib
from azureml.core.model import Model

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


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


input_sample = pd.DataFrame(data=[{
    "AGE": 5,
    "SEX": 2,
    "BMI": 3.1,
    "BP": 3.1,
    "S1": 3.1,
    "S2": 3.1,
    "S3": 3.1,
    "S4": 3.1,
    "S5": 3.1,
    "S6": 3.1
}])

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

# To indicate that we support a variable length of data input,
# set enforce_shape=False
@input_schema('data', PandasParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        print("input_data....")
        print(data.columns)
        print(type(data))
        result = model.predict(data)
        print("result.....")
        print(result)
    # You can return any data type, as long as it can be serialized by JSON.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Definiera den anpassade miljön

Definiera sedan miljön för att poängsätta modellen. I miljön definierar du De Python-paket, till exempel Pandas och scikit-learn, som bedömningsskriptet (score.py) kräver.

Om du vill definiera miljön kopierar du följande kod och klistrar in den i en ny kodcell i anteckningsboken .

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

environment = Environment('my-sklearn-environment')
environment.python.conda_dependencies = CondaDependencies.create(pip_packages=[
    'azureml-defaults',
    'inference-schema[numpy-support]',
    'joblib',
    'numpy',
    'pandas',
    'scikit-learn=={}'.format(sklearn.__version__)
])

inference_config = InferenceConfig(entry_script='./score.py',environment=environment)

Distribuera modellen

Om du vill distribuera modellen kopierar du följande kod och klistrar in den i en ny kodcell i anteckningsboken :

service_name = 'my-diabetes-model'

service = Model.deploy(ws, service_name, [model], inference_config, overwrite=True)
service.wait_for_deployment(show_output=True)

Anteckning

Det kan ta 2 till 4 minuter att distribuera tjänsten.

Om tjänsten har distribuerats bör du se följande utdata:

Tips: You can try get_logs(): https://aka.ms/debugimage#dockerlog or local deployment: https://aka.ms/debugimage#debug-locally to debug if deployment takes longer than 10 minutes.
Running......................................................................................
Succeeded
ACI service creation operation finished, operation "Succeeded"

Du kan också visa tjänsten i Azure Machine Learning Studio. I menyn till vänster väljer du Slutpunkter:

Skärmbild som visar hur du visar tjänsten.

Vi rekommenderar att du testar webbtjänsten så att den fungerar som förväntat. Om du vill returnera anteckningsboken går du till Azure Machine Learning Studio och väljer Notebooks på menyn till vänster. Kopiera sedan följande kod och klistra in den i en ny kodcell i anteckningsboken för att testa tjänsten.

import json

input_payload = json.dumps({
    'data': X_df[0:2].values.tolist()
})

output = service.run(input_payload)

print(output)

Utdata bör se ut som den här JSON-strukturen: {'predict': [[205.59], [68.84]]}.

Nästa steg

I den här självstudien såg du hur du skapar och distribuerar en modell så att den kan användas av Power BI. I nästa del får du lära dig hur du använder den här modellen i en Power BI-rapport.