Avancerade inmatningsskript

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

Den här artikeln beskriver hur du skriver inmatningsskript för specialiserade användningsfall i Azure Machine Learning. Ett inmatningsskript, som även kallas för ett bedömningsskript, accepterar begäranden, använder en modell för att poängsätta data och returnerar ett svar.

Förutsättningar

En tränad maskininlärningsmodell som du tänker distribuera med Azure Machine Learning. Mer information om modelldistribution finns i Distribuera maskininlärningsmodeller till Azure.

Generera ett Swagger-schema automatiskt

Om du vill generera ett schema för webbtjänsten automatiskt anger du ett exempel på indata eller utdata i konstruktorn för ett av de definierade typobjekten. Typen och exemplet används för att automatiskt skapa schemat. Azure Machine Learning skapar sedan en OpenAPI-specifikation (tidigare en Swagger-specifikation) för webbtjänsten under distributionen.

Följande typer stöds för närvarande:

• pandas
• numpy
• pyspark
• Python-standardobjekt

Om du vill använda schemagenerering inkluderar du paketversion 1.1.0 med öppen källkod inference-schema eller senare i din beroendefil. Mer information om det här paketet finns i InferenceSchema på GitHub. För att generera standardmässig Swagger för användning i automatiserade webbtjänster måste funktionen run i bedömningsskriptet uppfylla följande villkor:

• Den första parametern måste ha typen StandardPythonParameterType, namnges Inputsoch kapslas.
• Det måste finnas en valfri andra parameter av typen StandardPythonParameterType som heter GlobalParameters.
• Funktionen måste returnera en ordlista av typen StandardPythonParameterType som heter Results och är kapslad.

Definiera indata- och utdataexempelformaten i variablerna sample_input och sample_output som representerar formaten för begäran och svar för webbtjänsten. Använd dessa exempel i funktionsdekoratörerna för indata och utdata i run funktionen. I scikit-learn exemplet i följande avsnitt används schemagenerering.

Power BI-kompatibel slutpunkt

I följande exempel visas hur du definierar run funktionen enligt anvisningarna i föregående avsnitt. Du kan använda det här skriptet när du använder din distribuerade webbtjänst från 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

Binär bilddata

Om din modell accepterar binära data, till exempel en avbildning, måste du ändra den score.py fil som distributionen använder så att den accepterar råa HTTP-begäranden. Om du vill acceptera rådata använder du AMLRequest klassen i ditt postskript och lägger till dekoratören @rawhttp i run funktionen.

Följande score.py skript accepterar binära data:

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

När du använder AMLRequest klassen kan du bara komma åt rådata som publicerats i filen score.py. Det finns ingen komponent på klientsidan. Från en klient kan du publicera data som vanligt. Följande Python-kod läser till exempel en bildfil och publicerar data:

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)

Delning av resurser över ursprung

Resursdelning mellan ursprung (CORS) är ett sätt för resurser på en webbsida att begäras från en annan domän. CORS fungerar via HTTP-huvuden som skickas med klientbegäran och returneras med tjänstsvaret. Mer information om CORS och giltiga rubriker finns i Resursdelning mellan ursprung.

Om du vill konfigurera modelldistributionen så att den AMLResponse stöder CORS använder du klassen i ditt inmatningsskript. När du använder den här klassen kan du ange rubrikerna för svarsobjektet.

I följande exempel anges Access-Control-Allow-Origin rubriken för svaret från postskriptet:

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

Läsa in registrerade modeller

Det finns två sätt att hitta modeller i ditt startskript:

• AZUREML_MODEL_DIR: En miljövariabel som innehåller sökvägen till modellplatsen
• Model.get_model_path: Ett API som returnerar sökvägen till modellfilen med hjälp av det registrerade modellnamnet

AZUREML_MODEL_DIR

AZUREML_MODEL_DIR är en miljövariabel som skapas under tjänstdistributionen. Du kan använda den här miljövariabeln för att hitta platsen för distribuerade modeller.

I följande tabell beskrivs möjliga värden AZUREML_MODEL_DIR för för ett varierande antal distribuerade modeller:

Under modellregistrering och distribution placeras modeller i AZUREML_MODEL_DIR sökvägen och deras ursprungliga filnamn bevaras.

Om du vill hämta sökvägen till en modellfil i ditt inmatningsskript kombinerar du miljövariabeln med den filsökväg du letar efter.

Enskild modell

I följande exempel visas hur du hittar sökvägen när du har en enda modell:

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

Flera modeller

I följande exempel visas hur du hittar sökvägen när du har flera modeller. I det här scenariot registreras två modeller med arbetsytan:

• my_first_model: Den här modellen innehåller en fil, my_first_model.pkl, och har en version, 1.
• my_second_model: Den här modellen innehåller en fil, my_second_model.pkl, och har två versioner och 12.

När du distribuerar tjänsten anger du båda modellerna i distributionsåtgärden:

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)

I Docker-avbildningen som är värd för tjänsten AZUREML_MODEL_DIR innehåller miljövariabeln mappen där modellerna finns. I den här mappen finns varje modell i mappsökvägen <model-name>/<version>. I den här sökvägen <model-name> är namnet på den registrerade modellen och <version> är modellens version. Filerna som utgör den registrerade modellen lagras i dessa mappar.

Sökvägen till den första modellen är $AZUREML_MODEL_DIR/my_first_model/1/my_first_model.pkl i det här exemplet. Sökvägen till den andra modellen är $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')

hämta_modellens_sökväg

När du registrerar en modell anger du ett modellnamn som används för att hantera modellen i registret. Du använder det här namnet med Model.get_model_path metoden för att hämta sökvägen till modellfilen eller filerna i det lokala filsystemet. Om du registrerar en mapp eller en samling filer returnerar det här API:et sökvägen till mappen som innehåller filerna.

När du registrerar en modell ger du den ett namn. Namnet motsvarar var modellen placeras, antingen lokalt eller under tjänstdistributionen.

Ramverksspecifika exempel

Fler exempel på inmatningsskript för specifika användningsfall för maskininlärning finns i följande artiklar:

• PyTorch
• TensorFlow
• Keras
• Automatiserad maskininlärning

Relaterat innehåll

• Felsöka distribution av fjärrmodeller
• Konsumera en Azure Machine Learning-modell som distribuerats som en webbtjänst
• Uppdatera en distribuerad webbtjänst (v1)