Zaawansowane skrypty wprowadzania

DOTYCZY:SDK v1 usługi Azure Machine Learning dla języka Python

W tym artykule wyjaśniono, jak pisać skrypty wejściowe dla wyspecjalizowanych przypadków użycia w usłudze Azure Machine Learning. Skrypt wejścia, nazywany również skryptem oceniania, akceptuje żądania, używa modelu do oceniania danych i zwraca odpowiedź.

Wymagania wstępne

Wytrenowany model uczenia maszynowego, który zamierzasz wdrożyć za pomocą usługi Azure Machine Learning. Aby uzyskać więcej informacji na temat wdrażania modelu, zobacz Wdrażanie modeli uczenia maszynowego na platformie Azure.

Automatyczne generowanie schematu struktury Swagger

Aby automatycznie wygenerować schemat dla usługi internetowej, podaj próbkę danych wejściowych lub wyjściowych w konstruktorze dla jednego ze zdefiniowanych obiektów typu. Typ i przykład służą do automatycznego tworzenia schematu. Usługa Azure Machine Learning tworzy następnie specyfikację interfejsu OpenAPI (wcześniej specyfikację struktury Swagger) dla usługi internetowej podczas wdrażania.

Obecnie obsługiwane są następujące typy:

• pandas
• numpy
• pyspark
• Standardowy obiekt języka Python

Aby użyć generowania schematu, dołącz pakiet open source inference-schema w wersji 1.1.0 lub nowszej w pliku zależności. Aby uzyskać więcej informacji na temat tego pakietu, zobacz InferenceSchema w witrynie GitHub. Aby wygenerować zgodny Swagger do zautomatyzowanego użycia usługi internetowej, run funkcja w skrypcie oceniania musi spełniać następujące warunki:

• Pierwszy parametr musi mieć typ StandardPythonParameterType, mieć nazwę Inputsi być zagnieżdżony.
• Musi istnieć opcjonalny drugi parametr typu StandardPythonParameterType o nazwie GlobalParameters.
• Funkcja musi zwracać słownik typu StandardPythonParameterType, o nazwie Results, który jest zagnieżdżony.

Zdefiniuj przykładowe formaty danych wejściowych i wyjściowych w sample_input zmiennych i sample_output , które reprezentują formaty żądania i odpowiedzi dla usługi internetowej. Użyj tych przykładów w dekoratorach funkcji wejściowych i wyjściowych w run funkcji. W scikit-learn przykładzie w poniższej sekcji użyto generowania schematu.

Punkt końcowy zgodny z usługą Power BI

W poniższym przykładzie pokazano, jak zdefiniować run funkcję zgodnie z instrukcjami w poprzedniej sekcji. Możesz użyć tego skryptu, gdy korzystasz z wdrożonej usługi internetowej za pomocą Power BI.

import os
import json
import pickle
import numpy as np
import pandas as pd
import azureml.train.automl
import joblib
from sklearn.linear_model import Ridge

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.standard_py_parameter_type import StandardPythonParameterType
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 the file name if needed.
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')
    # Deserialize the model file back into a sklearn model.
    model = joblib.load(model_path)


# Provide three sample inputs for schema generation.
numpy_sample_input = NumpyParameterType(np.array([[1,2,3,4,5,6,7,8,9,10],[10,9,8,7,6,5,4,3,2,1]],dtype='float64'))
pandas_sample_input = PandasParameterType(pd.DataFrame({'name': ['Sarah', 'John'], 'age': [25, 26]}))
standard_sample_input = StandardPythonParameterType(0.0)

# The following sample is a nested input sample. Any item wrapped by `ParameterType` is described by the schema.
sample_input = StandardPythonParameterType({'input1': numpy_sample_input, 
                                        'input2': pandas_sample_input, 
                                        'input3': standard_sample_input})

sample_global_parameters = StandardPythonParameterType(1.0) # This line is optional.
sample_output = StandardPythonParameterType([1.0, 1.0])
outputs = StandardPythonParameterType({'Results':sample_output}) # "Results" is case sensitive.

@input_schema('Inputs', sample_input) 
# "Inputs" is case sensitive.

@input_schema('GlobalParameters', sample_global_parameters) 
# The preceding line is optional. "GlobalParameters" is case sensitive.

@output_schema(outputs)

def run(Inputs, GlobalParameters): 
    # The parameters in the preceding line have to match those in the decorator. "Inputs" and 
    # "GlobalParameters" are case sensitive.
    try:
        data = Inputs['input1']
        # The data gets converted to the target format.
        assert isinstance(data, np.ndarray)
        result = model.predict(data)
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

output_sample = pd.DataFrame(data=[{"a1": 5, "a2": 6}])
@output_schema(PandasParameterType(output_sample))
...
result = model.predict(data)
return result

Dane binarne (obraz)

Jeśli model akceptuje dane binarne, takie jak obraz, należy zmodyfikować plik score.py używany przez wdrożenie, aby akceptował nieprzetworzone żądania HTTP. Aby zaakceptować nieprzetworzone dane, użyj AMLRequest klasy w skry skrywcie wpisu i dodaj @rawhttp dekorator do run funkcji.

Poniższy skrypt score.py akceptuje dane binarne:

from azureml.contrib.services.aml_request import AMLRequest, rawhttp
from azureml.contrib.services.aml_response import AMLResponse
from PIL import Image
import json

def init():
    print("This is init()")

@rawhttp
def run(request):
    print("This is run()")
    
    if request.method == 'GET':
        # For this example, return the URL for GET requests.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        file_bytes = request.files["image"]
        image = Image.open(file_bytes).convert('RGB')
        # For a real-world solution, load the data from the request body
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example returns the size of the image as the response.
        return AMLResponse(json.dumps(image.size), 200)
    else:
        return AMLResponse("bad request", 500)

pip install azureml-contrib-services

W przypadku korzystania z AMLRequest klasy można uzyskać dostęp tylko do nieprzetworzonych danych opublikowanych w pliku score.py. Nie ma składnika po stronie klienta. Możesz wysyłać dane od klienta w zwykły sposób. Na przykład następujący kod w języku Python odczytuje plik obrazu i publikuje dane:

import requests

uri = service.scoring_uri
image_path = 'test.jpg'
files = {'image': open(image_path, 'rb').read()}
response = requests.post(uri, files=files)

print(response.json)

Współużytkowanie zasobów między źródłami

Współużytkowanie zasobów między źródłami (CORS) umożliwia zażądanie zasobów na stronie internetowej z innej domeny. Mechanizm CORS działa za pośrednictwem nagłówków HTTP, które są wysyłane z żądaniem klienta i zwracane z odpowiedzią usługi. Aby uzyskać więcej informacji na temat mechanizmu CORS i prawidłowych nagłówków, zobacz Współużytkowanie zasobów między źródłami (CORS).

Aby skonfigurować wdrożenie modelu w celu obsługi mechanizmu CORS, użyj AMLResponse klasy w skrytecie wejściowym. W przypadku korzystania z tej klasy można ustawić nagłówki w obiekcie odpowiedzi.

Poniższy przykład ustawia Access-Control-Allow-Origin nagłówek odpowiedzi ze skryptu wpisu:

from azureml.contrib.services.aml_request import AMLRequest, rawhttp
from azureml.contrib.services.aml_response import AMLResponse


def init():
    print("This is init()")

@rawhttp
def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GET.
        # For a real-world solution, you would load the data from URL params or headers
        # and send it to the model. Then return the response.
        respBody = str.encode(request.full_path)
        resp = AMLResponse(respBody, 200)
        resp.headers["Allow"] = "OPTIONS, GET, POST"
        resp.headers["Access-Control-Allow-Methods"] = "OPTIONS, GET, POST"
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        resp.headers['Access-Control-Allow-Headers'] = "*"
        return resp
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.
        resp = AMLResponse(reqBody, 200)
        resp.headers["Allow"] = "OPTIONS, GET, POST"
        resp.headers["Access-Control-Allow-Methods"] = "OPTIONS, GET, POST"
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        resp.headers['Access-Control-Allow-Headers'] = "*"
        return resp
    elif request.method == 'OPTIONS':
        resp = AMLResponse("", 200)
        resp.headers["Allow"] = "OPTIONS, GET, POST"
        resp.headers["Access-Control-Allow-Methods"] = "OPTIONS, GET, POST"
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        resp.headers['Access-Control-Allow-Headers'] = "*"
        return resp
    else:
        return AMLResponse("bad request", 400)

pip install azureml-contrib-services

Ładowanie zarejestrowanych modeli

Są dwa sposoby lokalizowania modeli w skrypcie wejściowym:

• AZUREML_MODEL_DIR: zmienna środowiskowa zawierająca ścieżkę do lokalizacji modelu
• Model.get_model_path: interfejs API, który zwraca ścieżkę do pliku modelu przy użyciu zarejestrowanej nazwy modelu

AZUREML_MODEL_DIR

AZUREML_MODEL_DIR jest zmienną środowiskową utworzoną podczas wdrażania usługi. Za pomocą tej zmiennej środowiskowej można znaleźć lokalizację wdrożonych modeli.

W poniższej tabeli opisano możliwe wartości AZUREML_MODEL_DIR dla różnej liczby wdrożonych modeli:

Podczas rejestracji i wdrażania modelu modele są umieszczane w ścieżce AZUREML_MODEL_DIR , a ich oryginalne nazwy plików są zachowywane.

Aby uzyskać ścieżkę do pliku modelu w skrybacie wejściowym, połącz zmienną środowiskową ze ścieżką pliku, której szukasz.

Pojedynczy model

W poniższym przykładzie pokazano, jak znaleźć ścieżkę w przypadku pojedynczego modelu:

import os

# In the following example, the model is a file.
model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')

# In the following example, the model is a folder that contains a file.
file_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'my_model_folder', 'sklearn_regression_model.pkl')

Wiele modeli

W poniższym przykładzie pokazano, jak znaleźć ścieżkę w przypadku wielu modeli. W tym scenariuszu dwa modele są rejestrowane w obszarze roboczym:

• my_first_model: Ten model zawiera jeden plik, my_first_model.pkl i ma jedną wersję: 1.
• my_second_model: Ten model zawiera jeden plik, my_second_model.pkl i ma dwie wersje: 1 i 2.

Podczas wdrażania usługi należy podać oba modele w operacji wdrażania:

from azureml.core import Workspace, Model

# Get a handle to the workspace.
ws = Workspace.from_config()

first_model = Model(ws, name="my_first_model", version=1)
second_model = Model(ws, name="my_second_model", version=2)
service = Model.deploy(ws, "myservice", [first_model, second_model], inference_config, deployment_config)

Na obrazie platformy Docker hostujący usługę zmienna AZUREML_MODEL_DIR środowiskowa zawiera folder, w którym znajdują się modele. W tym folderze każdy model znajduje się w ścieżce <model-name>/<version>folderu . W tej ścieżce <model-name> jest nazwą zarejestrowanego modelu i <version> jest wersją modelu. Pliki tworzące zarejestrowany model są przechowywane w tych folderach.

W tym przykładzie ścieżka pierwszego modelu to $AZUREML_MODEL_DIR/my_first_model/1/my_first_model.pkl. Ścieżka drugiego modelu to $AZUREML_MODEL_DIR/my_second_model/2/my_second_model.pkl.

# In the following example, the model is a file, and the deployment contains multiple models.
first_model_name = 'my_first_model'
first_model_version = '1'
first_model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), first_model_name, first_model_version, 'my_first_model.pkl')
second_model_name = 'my_second_model'
second_model_version = '2'
second_model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), second_model_name, second_model_version, 'my_second_model.pkl')

get_model_path

Podczas rejestrowania modelu należy podać nazwę modelu, która jest używana do zarządzania modelem w rejestrze. Ta nazwa służy do Model.get_model_path pobierania ścieżki pliku lub plików modelu w lokalnym systemie plików. Jeśli zarejestrujesz folder lub kolekcję plików, ten interfejs API zwróci ścieżkę folderu zawierającego te pliki.

Podczas rejestrowania modelu należy nadać mu nazwę. Nazwa odpowiada miejscu umieszczania modelu lokalnie lub podczas wdrażania usługi.

Przykłady specyficzne dla platformy

Aby uzyskać więcej przykładów skryptów wejściowych dla konkretnych przypadków użycia uczenia maszynowego, zobacz następujące artykuły:

• PyTorch
• TensorFlow
• Keras
• Zautomatyzowane uczenie maszynowe

Powiązana zawartość

• Rozwiązywanie problemów z wdrażaniem modelu zdalnego
• Korzystanie z modelu usługi Azure Machine Learning wdrożonego jako usługa internetowa
• Aktualizowanie wdrożonej usługi internetowej (wersja 1)