Samouczek: integracja usługi Power BI — tworzenie modelu predykcyjnego za pomocą Jupyter Notebook (część 1 z 2)

DOTYCZY:Zestaw SDK języka Python w wersji 1

W części 1 tego samouczka wytrenujesz i wdrożysz model uczenia maszynowego predykcyjnego przy użyciu kodu w Jupyter Notebook. Utworzysz również skrypt oceniania, aby zdefiniować schemat danych wejściowych i wyjściowych modelu na potrzeby integracji z usługą Power BI. W części 2 model służy do przewidywania wyników w usłudze Microsoft Power BI.

W tym samouczku zostały wykonane następujące czynności:

  • Tworzenie notesu Jupyter
  • Utwórz wystąpienie obliczeniowe usługi Azure Machine Learning.
  • Trenowanie modelu regresji przy użyciu biblioteki scikit-learn.
  • Napisz skrypt oceniania, który definiuje dane wejściowe i wyjściowe w celu łatwej integracji z usługą Microsoft Power BI.
  • Wdróż model w punkcie końcowym oceniania w czasie rzeczywistym.

Wymagania wstępne

Tworzenie notesu i obliczeń

Na stronie głównej usługi Azure Machine Learning Studio wybierz pozycję Utwórz nowy>notes:

Zrzut ekranu przedstawiający sposób tworzenia notesu.

Na stronie Tworzenie nowego pliku :

  1. Nadaj notesowi nazwę (na przykład my_model_notebook).
  2. Zmień typ pliku na Notes.
  3. Wybierz przycisk Utwórz.

Następnie, aby uruchomić komórki kodu, utwórz wystąpienie obliczeniowe i dołącz je do notesu. Zacznij od wybrania ikony plus w górnej części notesu:

Zrzut ekranu przedstawiający sposób tworzenia wystąpienia obliczeniowego.

Na stronie Tworzenie wystąpienia obliczeniowego :

  1. Wybierz rozmiar maszyny wirtualnej procesora CPU. Na potrzeby tego samouczka możesz wybrać Standard_D11_v2 z 2 rdzeniami i 14 GB pamięci RAM.
  2. Wybierz opcję Dalej.
  3. Na stronie Konfigurowanie ustawień podaj prawidłową nazwę obliczeniową. Prawidłowe znaki to wielkie i małe litery, cyfry i łączniki (-).
  4. Wybierz przycisk Utwórz.

W notesie możesz zauważyć okrąg obok pozycji Obliczenia zamienił się na cyjan. Ta zmiana koloru wskazuje, że wystąpienie obliczeniowe jest tworzone:

Zrzut ekranu przedstawiający tworzenie zasobów obliczeniowych.

Uwaga

Aprowizowania wystąpienia obliczeniowego może potrwać od 2 do 4 minut.

Po aprowizacji zasobów obliczeniowych możesz użyć notesu do uruchamiania komórek kodu. Na przykład w komórce można wpisać następujący kod:

import numpy as np

np.sin(3)

Następnie wybierz pozycję Shift + Enter (lub wybierz pozycję Kontrolka + Wprowadź lub wybierz przycisk Odtwórz obok komórki). Powinny zostać wyświetlone następujące dane wyjściowe:

Zrzut ekranu przedstawiający dane wyjściowe komórki.

Teraz możesz przystąpić do tworzenia modelu uczenia maszynowego.

Tworzenie modelu przy użyciu biblioteki scikit-learn

W tym samouczku użyjesz zestawu danych Diabetes. Ten zestaw danych jest dostępny w usłudze Azure Open Datasets.

Importowanie danych

Aby zaimportować dane, skopiuj poniższy kod i wklej go do nowej komórki kodu w notesie.

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

Ramka X_df danych biblioteki pandas zawiera 10 zmiennych wejściowych punktu odniesienia. Zmienne te obejmują wiek, płeć, wskaźnik masy ciała, średnie ciśnienie krwi i sześć pomiarów krwi. Ramka y_df danych biblioteki pandas jest zmienną docelową. Zawiera on ilościową miarę postępu choroby rok po punkcie odniesienia. Ramka danych zawiera 442 rekordy.

Trenowanie modelu

Utwórz nową komórkę kodu w notesie. Następnie skopiuj poniższy kod i wklej go do komórki. Ten fragment kodu tworzy model regresji grzbietu i serializuje model przy użyciu formatu pickle języka Python.

import joblib
from sklearn.linear_model import Ridge

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

Rejestrowanie modelu

Oprócz zawartości samego pliku modelu zarejestrowany model będzie przechowywać metadane. Metadane zawierają opis, tagi i informacje o strukturze modelu.

Metadane są przydatne podczas zarządzania modelami i wdrażania ich w obszarze roboczym. Na przykład przy użyciu tagów można kategoryzować modele i stosować filtry podczas wyświetlania listy modeli w obszarze roboczym. Ponadto, jeśli oznaczysz ten model za pomocą struktury scikit-learn, uprościsz wdrażanie go jako usługę internetową.

Skopiuj poniższy kod, a następnie wklej go do nowej komórki kodu w notesie.

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)

Możesz również wyświetlić model w usłudze Azure Machine Learning Studio. W menu po lewej stronie wybierz pozycję Modele:

Zrzut ekranu przedstawiający sposób wyświetlania modelu.

Definiowanie skryptu oceniania

Podczas wdrażania modelu, który zostanie zintegrowany z usługą Power BI, należy zdefiniować skrypt oceniania języka Python i środowisko niestandardowe. Skrypt oceniania zawiera dwie funkcje:

  • Funkcja init() jest uruchamiana po uruchomieniu usługi. Ładuje model (który jest automatycznie pobierany z rejestru modeli) i deserializuje go.
  • Funkcja run(data) jest uruchamiana, gdy wywołanie usługi zawiera dane wejściowe, które należy ocenić.

Uwaga

Dekoratory języka Python w poniższym kodzie definiują schemat danych wejściowych i wyjściowych, co jest ważne dla integracji z usługą Power BI.

Skopiuj poniższy kod i wklej go do nowej komórki kodu w notesie. Poniższy fragment kodu ma magię komórki, która zapisuje kod w pliku o nazwie 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

Definiowanie środowiska niestandardowego

Następnie zdefiniuj środowisko, aby ocenić model. W środowisku zdefiniuj pakiety języka Python, takie jak pandas i scikit-learn, że skrypt oceniania (score.py) wymaga.

Aby zdefiniować środowisko, skopiuj następujący kod i wklej go do nowej komórki kodu w notesie.

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)

Wdrażanie modelu

Aby wdrożyć model, skopiuj następujący kod i wklej go do nowej komórki kodu w notesie:

service_name = 'my-diabetes-model'

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

Uwaga

Wdrożenie usługi może potrwać od 2 do 4 minut.

Jeśli usługa zostanie pomyślnie wdrożona, powinny zostać wyświetlone następujące dane wyjściowe:

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"

Możesz również wyświetlić usługę w usłudze Azure Machine Learning Studio. W menu po lewej stronie wybierz pozycję Punkty końcowe:

Zrzut ekranu przedstawiający sposób wyświetlania usługi.

Zalecamy przetestowanie usługi internetowej, aby upewnić się, że działa zgodnie z oczekiwaniami. Aby zwrócić notes, w usłudze Azure Machine Learning Studio w menu po lewej stronie wybierz pozycję Notesy. Następnie skopiuj poniższy kod i wklej go do nowej komórki kodu w notesie, aby przetestować usługę.

import json

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

output = service.run(input_payload)

print(output)

Dane wyjściowe powinny wyglądać podobnie do tej struktury JSON: {'predict': [[205.59], [68.84]]}.

Następne kroki

W tym samouczku pokazano, jak skompilować i wdrożyć model, aby mógł być używany przez usługę Power BI. W następnej części dowiesz się, jak korzystać z tego modelu w raporcie usługi Power BI.