Samouczek: integracja Power BI — tworzenie modelu predykcyjnego przy użyciu 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 Power BI. W części 2 użyjesz modelu 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 Машинное обучение Azure.
- 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
- Subskrypcja platformy Azure. Jeśli nie masz jeszcze subskrypcji, możesz użyć bezpłatnej wersji próbnej.
- Obszar roboczy usługi Azure Machine Learning. Jeśli nie masz jeszcze obszaru roboczego, zobacz Tworzenie obszarów roboczych Машинное обучение Azure i zarządzanie nimi.
- Wstępna wiedza na temat języka Python i przepływów pracy uczenia maszynowego.
Tworzenie notesu i obliczeń
Na stronie głównej programu Машинное обучение Azure Studio wybierz pozycję Utwórz nowy>notes:
Na stronie Tworzenie nowego pliku :
- Nadaj notesowi nazwę (na przykład my_model_notebook).
- Zmień typ pliku na Notes.
- 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:
Na stronie Tworzenie wystąpienia obliczeniowego :
- 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.
- Wybierz opcję Dalej.
- Na stronie Konfigurowanie ustawień podaj prawidłową nazwę obliczeniową. Prawidłowe znaki to wielkie i małe litery, cyfry i łączniki (-).
- 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:
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:
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)
Model można również wyświetlić w programie Машинное обучение Azure Studio. W menu po lewej stronie wybierz pozycję Modele:
Definiowanie skryptu oceniania
Podczas wdrażania modelu, który zostanie zintegrowany z 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 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"
Usługę można również wyświetlić w programie Машинное обучение Azure Studio. W menu po lewej stronie wybierz pozycję Punkty końcowe:
Zalecamy przetestowanie usługi internetowej, aby upewnić się, że działa zgodnie z oczekiwaniami. Aby zwrócić notes, w programie Машинное обучение Azure 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 Power BI. W następnej części dowiesz się, jak korzystać z tego modelu w raporcie Power BI.