Pijplijneindpunten upgraden naar SDK v2

Artikel
09/01/2024

Zodra u een pijplijn hebt die actief is, kunt u een pijplijn publiceren zodat deze wordt uitgevoerd met verschillende invoerwaarden. Dit werd gepubliceerde pijplijnen genoemd.

Wat is er veranderd?

Batch-eindpunt biedt een vergelijkbare maar krachtigere manier om meerdere assets te verwerken die worden uitgevoerd onder een duurzame API. Daarom is de functionaliteit voor gepubliceerde pijplijnen verplaatst naar implementaties van pijplijnonderdelen in batch-eindpunten.

Met Batch-eindpunten wordt de interface (eindpunt) losgekoppeld van de werkelijke implementatie (implementatie) en kan de gebruiker bepalen welke implementatie de standaardimplementatie van het eindpunt dient. Met implementaties van pijplijnonderdelen in batch-eindpunten kunnen gebruikers pijplijnonderdelen implementeren in plaats van pijplijnen, waardoor herbruikbare assets beter kunnen worden gebruikt voor organisaties die hun MLOps-praktijk willen stroomlijnen.

In de volgende tabel ziet u een vergelijking van elk van de concepten:

Concept	SDK v1	SDK v2
REST-eindpunt van pijplijn voor aanroep	Pijplijneindpunt	Batch-eindpunt
Specifieke versie van pijplijn onder het eindpunt	Gepubliceerde pijplijn	Implementatie van pijplijnonderdelen
Argumenten van pijplijn bij aanroep	Pijplijnparameter	Taakinvoer
Taak gegenereerd op basis van een gepubliceerde pijplijn	Pijplijntaak	Batchtaak

Zie Pijplijnen implementeren in Batch-eindpunten voor meer informatie over het maken van uw eerste pijplijnonderdeelimplementatie.

Verplaatsen naar batch-eindpunten

Gebruik de volgende richtlijnen voor meer informatie over het overstappen van SDK v1 naar SDK v2 met behulp van de concepten in Batch-eindpunten.

Een pijplijn publiceren

Vergelijk hoe het publiceren van een pijplijn is gewijzigd van v1 in v2:

SDK v1
SDK v2

Eerst moeten we de pijplijn ophalen die we willen publiceren:
```
pipeline1 = Pipeline(workspace=ws, steps=[step1, step2])
```

We kunnen de pijplijn als volgt publiceren:

from azureml.pipeline.core import PipelineEndpoint

endpoint_name = "PipelineEndpointTest"
pipeline_endpoint = PipelineEndpoint.publish(
    workspace=ws, 
    name=endpoint_name,
    pipeline=pipeline, 
    description="A hello world endpoint for component deployments"
)

Eerst moeten we de pijplijn definiëren die we willen publiceren.

@pipeline()
def pipeline(input_data: Input(type=AssetTypes.URI_FOLDER)):
    (...)

    return {
        (..)
    }

Batch-eindpunten implementeren geen pijplijnen, maar pijplijnonderdelen. Onderdelen stellen een betrouwbaardere manier voor voor het beheren van broncodebeheer van de assets die worden geïmplementeerd onder een eindpunt. We kunnen elke pijplijndefinitie als volgt converteren naar een pijplijnonderdeel:
```
pipeline_component = pipeline().component
```
Het wordt aanbevolen om pijplijnonderdelen te registreren, zodat u versiebeheer op een gecentraliseerde manier in de werkruimte of zelfs de gedeelde registers kunt behouden.
```
ml_client.components.create(pipeline_component)
```

Vervolgens moeten we het eindpunt maken dat als host fungeert voor alle pijplijnimplementaties:

endpoint_name = "PipelineEndpointTest"
endpoint = BatchEndpoint(
    name=endpoint_name,
    description="A hello world endpoint for component deployments",
)

ml_client.batch_endpoints.begin_create_or_update(endpoint)

Maak een implementatie voor het pijplijnonderdeel:

deployment_name = "hello-batch-dpl"
deployment = BatchPipelineComponentDeployment(
    name=deployment_name,
    description="A hello world deployment with a single step.",
    endpoint_name=endpoint.name,
    component=pipeline_component
)

ml_client.batch_deployments.begin_create_or_update(deployment)

Een taak verzenden naar een pijplijneindpunt

SDK v1
SDK v2

Als u de standaardversie van de pijplijn wilt aanroepen, kunt u het volgende gebruiken:

pipeline_endpoint = PipelineEndpoint.get(workspace=ws, name="PipelineEndpointTest")
run_id = pipeline_endpoint.submit("PipelineEndpointExperiment")

job = ml_client.batch_endpoints.invoke(
    endpoint_name=batch_endpoint, 
)

Gebruik inputs dit om de invoer van de taak aan te geven, indien nodig. Zie Taken en invoergegevens maken voor batch-eindpunten voor een gedetailleerdere uitleg over het aangeven van invoer en uitvoer.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=batch_endpoint,
    inputs={
        "input_data": Input(type=AssetTypes.URI_FOLDER, path="./my_local_data")
    }
)

U kunt ook een taak verzenden naar een specifieke versie:

SDK v1
SDK v2

run_id = pipeline_endpoint.submit(endpoint_name, pipeline_version="0")

In batch-eindpunten worden implementaties niet geversied. U kunt echter meerdere versies van pijplijnonderdelen implementeren onder hetzelfde eindpunt. In dit opzicht komt elke pijplijnversie in v1 overeen met een andere versie van het pijplijnonderdeel en de bijbehorende implementatie onder het eindpunt.

Vervolgens kunt u een specifieke implementatie implementeren die wordt uitgevoerd onder het eindpunt als die implementatie de versie uitvoert waarin u geïnteresseerd bent.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name, 
    deployment_name=deployment_name, 
)

all_pipelines = PublishedPipeline.get_all(ws)

De volgende code bevat alle eindpunten die in de werkruimte bestaan:

all_endpoints = ml_client.batch_endpoints.list()

Houd er echter rekening mee dat batcheindpunten implementaties kunnen hosten die pijplijnen of modellen operationeel maken. Als u een lijst wilt ophalen met alle implementaties die pijplijnen hosten, kunt u het volgende doen:

all_deployments = []

for endpoint in all_endpoints:
    all_deployments.extend(ml_client.batch_deployments.list(endpoint_name=endpoint.name))

all_pipeline_deployments = filter(all_endpoints, lamdba x: x is BatchPipelineComponentDeployment)

De REST API gebruiken

U kunt taken maken op basis van de eindpunten met behulp van de REST API van de aanroep-URL. Zie de volgende voorbeelden om te zien hoe aanroep is gewijzigd van v1 in v2.

SDK v1
SDK v2

pipeline_endpoint = PipelineEndpoint.get(workspace=ws, name=endpoint_name)
rest_endpoint = pipeline_endpoint.endpoint

response = requests.post(
    rest_endpoint, 
    headers=aad_token, 
    json={
        "ExperimentName": "PipelineEndpointExperiment",
        "RunSource": "API",
        "ParameterAssignments": {"argument1": "united", "argument2":45}
    }
)

Batch-eindpunten ondersteunen meerdere invoertypen. In het volgende voorbeeld ziet u hoe u twee verschillende invoer van het type string en numeric. Zie Taken maken en invoergegevens voor batcheindpunten (REST) voor gedetailleerdere voorbeelden:

batch_endpoint = ml_client.batch_endpoints.get(endpoint_name)
rest_endpoint = batch_endpoint.invocation_url

response = requests.post(
    rest_endpoint, 
    headers=aad_token, 
    json={
        "properties": {
            "InputData": {
                "argument1": {
                    "JobInputType": "Literal",
                    "Value": "united"
                },
                "argument2": {
                    "JobInputType": "Literal",
                    "Value": 45
                }
            }
        }
    }
)

Delen via