Abfragen von Lineage-Entitäten - Amazon SageMaker
Erste Schritte

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Abfragen von Lineage-Entitäten

Amazon generiert SageMaker automatisch Diagramme von Lineage-Entitäten, während Sie sie verwenden. Sie können diese Daten abfragen, um eine Vielzahl von Fragen zu beantworten. Sie können Ihre Lineage-Entitäten abfragen, um:

  • Rufen Sie alle Datensätze ab, die bei der Erstellung eines Modells verwendet wurden.

  • Ruft alle Aufträge ab, die zur Erstellung eines Endpunkts verwendet wurden.

  • Rufen Sie alle Modelle ab, die einen Datensatz verwenden.

  • Ruft alle Endpunkte ab, die ein Modell verwenden.

  • Rufen Sie ab, welche Endpunkte aus einem bestimmten Datensatz abgeleitet wurden.

  • Rufen Sie die Pipeline-Ausführung ab, die einen Trainingsauftrag erstellt hat.

  • Rufen Sie die Beziehungen zwischen Entitäten zur Untersuchung, Steuerung und Reproduzierbarkeit ab.

  • Rufen Sie alle nachgeschalteten Studien ab, die das Artefakt verwenden.

  • Ruft alle Upstream-Versuche ab, die das Artefakt verwenden.

  • Ruft eine Liste von Artefakten ab, die die angegebene S3-URI verwenden.

  • Ruft Upstream-Artefakte ab, die das Datensatz-Artefakt verwenden.

  • Ruft Downstream-Artefakte ab, die das Datensatz-Artefakt verwenden.

  • Ruft Datensätze ab, die das Bildartefakt verwenden.

  • Rufen Sie Aktionen ab, die den Kontext verwenden.

  • Rufen Sie Verarbeitungsaufträge ab, die den Endpunkt verwenden.

  • Rufen Sie Transformationsaufträge ab, die den Endpunkt verwenden.

  • Rufen Sie Testkomponenten ab, die den Endpunkt verwenden.

  • Rufen Sie die Paketgruppe ARN für die Pipeline-Ausführung ab, die der Modellpaketgruppe zugeordnet ist.

  • Ruft alle Artefakte ab, die die Aktion verwenden.

  • Ruft alle Upstream-Datensätze ab, die die Aktion zur Genehmigung des Modellpakets verwenden.

  • Rufen Sie das Modellpaket aus der Aktion zur Genehmigung von Modellpaketen ab.

  • Ruft Downstream-Endpunktkontexte ab, die den Endpunkt verwenden.

  • Rufen Sie die ARN für die Pipeline-Ausführung, die der Testkomponente zugeordnet ist, ab.

  • Rufen Sie Datensätze ab, die die Testkomponente verwenden.

  • Rufen Sie Modelle ab, die die Testkomponente verwenden.

  • Erkunden Sie Ihre Herkunft zur Veranschaulichung.

Einschränkungen

  • Die Abfrage der Herkunft ist in den folgenden Regionen nicht verfügbar:

    • Afrika (Kapstadt) – af-south

    • Asien-Pazifik (Jakarta) – ap-southeast-3

    • Asien-Pazifik (Osaka) – ap-northeast-3

    • Europa (Mailand) – eu-south-1

    • Europa (Spanien) — eu-south-2

    • Israel (Tel Aviv) – il-central-1

  • Die maximale Tiefe der zu entdeckenden Beziehungen ist derzeit auf 10 begrenzt.

  • Die Filterung ist auf die folgenden Eigenschaften beschränkt: Datum der letzten Änderung, Erstellungsdatum, Typ und Entitätstyp der Herkunft.

Erste Schritte mit dem Abfragen von Lineage-Entitäten

Der einfachste Weg, um loszulegen, ist entweder über:

Die folgenden Beispiele zeigen, wie Sie mit LineageQuery und Abfragen erstellen können LineageFilterAPIs, um Fragen zum Lineage Graph zu beantworten und Entitätsbeziehungen für einige Anwendungsfälle zu extrahieren.

Beispiel Verwenden von LineageQueryAPI, um Entitätszuordnungen zu finden
from sagemaker.lineage.context import Context, EndpointContext
from sagemaker.lineage.action import Action
from sagemaker.lineage.association import Association
from sagemaker.lineage.artifact import Artifact, ModelArtifact, DatasetArtifact

from sagemaker.lineage.query import (
    LineageQuery,
    LineageFilter,
    LineageSourceEnum,
    LineageEntityEnum,
    LineageQueryDirectionEnum,
)
# Find the endpoint context and model artifact that should be used for the lineage queries.

contexts = Context.list(source_uri=endpoint_arn)
context_name = list(contexts)[0].context_name
endpoint_context = EndpointContext.load(context_name=context_name)
Beispiel Finden Sie alle Datensätze, die einem Endpunkt zugeordnet sind
# Define the LineageFilter to look for entities of type `ARTIFACT` and the source of type `DATASET`.

query_filter = LineageFilter(
    entities=[LineageEntityEnum.ARTIFACT], sources=[LineageSourceEnum.DATASET]
)

# Providing this `LineageFilter` to the `LineageQuery` constructs a query that traverses through the given context `endpoint_context`
# and find all datasets.

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[endpoint_context.context_arn],
    query_filter=query_filter,
    direction=LineageQueryDirectionEnum.ASCENDANTS,
    include_edges=False,
)

# Parse through the query results to get the lineage objects corresponding to the datasets
dataset_artifacts = []
for vertex in query_result.vertices:
    dataset_artifacts.append(vertex.to_lineage_object().source.source_uri)

pp.pprint(dataset_artifacts)
Beispiel Finden Sie die Modelle, die einem Endpunkt zugeordnet sind
# Define the LineageFilter to look for entities of type `ARTIFACT` and the source of type `MODEL`.

query_filter = LineageFilter(
    entities=[LineageEntityEnum.ARTIFACT], sources=[LineageSourceEnum.MODEL]
)

# Providing this `LineageFilter` to the `LineageQuery` constructs a query that traverses through the given context `endpoint_context`
# and find all datasets.

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[endpoint_context.context_arn],
    query_filter=query_filter,
    direction=LineageQueryDirectionEnum.ASCENDANTS,
    include_edges=False,
)

# Parse through the query results to get the lineage objects corresponding to the model
model_artifacts = []
for vertex in query_result.vertices:
    model_artifacts.append(vertex.to_lineage_object().source.source_uri)

# The results of the `LineageQuery` API call return the ARN of the model deployed to the endpoint along with
# the S3 URI to the model.tar.gz file associated with the model
pp.pprint(model_artifacts)
Beispiel Finden Sie die zum Endpunkt gehörenden Komponenten der Studie
# Define the LineageFilter to look for entities of type `TRIAL_COMPONENT` and the source of type `TRAINING_JOB`.

query_filter = LineageFilter(
    entities=[LineageEntityEnum.TRIAL_COMPONENT],
    sources=[LineageSourceEnum.TRAINING_JOB],
)

# Providing this `LineageFilter` to the `LineageQuery` constructs a query that traverses through the given context `endpoint_context`
# and find all datasets.

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[endpoint_context.context_arn],
    query_filter=query_filter,
    direction=LineageQueryDirectionEnum.ASCENDANTS,
    include_edges=False,
)

# Parse through the query results to get the ARNs of the training jobs associated with this Endpoint
trial_components = []
for vertex in query_result.vertices:
    trial_components.append(vertex.arn)

pp.pprint(trial_components)
Beispiel Änderung des Schwerpunkts der Abstammung

Der LineageQuery kann so geändert werden, dass er einen unterschiedlichen start_arns hat, wodurch sich der Schwerpunkt der Abstammung ändert. Darüber hinaus kann LineageFilter mehrere Quellen und Entitäten verwenden, um den Umfang der Abfrage zu erweitern.

Im Folgenden verwenden wir das Modell als Abstammungsschwerpunkt und ermitteln die damit verbundenen Endpunkte und Datensätze.

# Get the ModelArtifact

model_artifact_summary = list(Artifact.list(source_uri=model_package_arn))[0]
model_artifact = ModelArtifact.load(artifact_arn=model_artifact_summary.artifact_arn)
query_filter = LineageFilter(
    entities=[LineageEntityEnum.ARTIFACT],
    sources=[LineageSourceEnum.ENDPOINT, LineageSourceEnum.DATASET],
)

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[model_artifact.artifact_arn],  # Model is the starting artifact
    query_filter=query_filter,
    # Find all the entities that descend from the model, i.e. the endpoint
    direction=LineageQueryDirectionEnum.DESCENDANTS,
    include_edges=False,
)

associations = []
for vertex in query_result.vertices:
    associations.append(vertex.to_lineage_object().source.source_uri)

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[model_artifact.artifact_arn],  # Model is the starting artifact
    query_filter=query_filter,
    # Find all the entities that ascend from the model, i.e. the datasets
    direction=LineageQueryDirectionEnum.ASCENDANTS,
    include_edges=False,
)

for vertex in query_result.vertices:
    associations.append(vertex.to_lineage_object().source.source_uri)

pp.pprint(associations)
Beispiel LineageQueryDirectionEnum.BOTH wird verwendet, um aufsteigende und absteigende Beziehungen zu finden

Wenn die Richtung auf BOTH eingestellt ist, durchläuft die Abfrage den Graphen, um Beziehungen zwischen aufsteigenden und untergeordneten Werten zu finden. Diese Durchquerung erfolgt nicht nur vom Startknoten aus, sondern auch von jedem Knoten aus, der besucht wird. Beispiel: Wenn ein Trainingsauftrag zweimal ausgeführt wird und beide durch den Trainingsauftrag generierten Modelle auf Endpunkten bereitgestellt werden, BOTH zeigt das Ergebnis der Abfrage mit eingeschalteter Richtung beide Endpunkte an. Das liegt daran, dass dasselbe Bild für das Training und die Bereitstellung des Modells verwendet wird. Da das Bild dem Modell gemeinsam ist, erscheinen das start_arn und die beiden Endpunkte im Abfrageergebnis.

query_filter = LineageFilter(
    entities=[LineageEntityEnum.ARTIFACT],
    sources=[LineageSourceEnum.ENDPOINT, LineageSourceEnum.DATASET],
)

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[model_artifact.artifact_arn],  # Model is the starting artifact
    query_filter=query_filter,
    # This specifies that the query should look for associations both ascending and descending for the start
    direction=LineageQueryDirectionEnum.BOTH,
    include_edges=False,
)

associations = []
for vertex in query_result.vertices:
    associations.append(vertex.to_lineage_object().source.source_uri)

pp.pprint(associations)
Beispiel Anweisungen in LineageQuery – ASCENDANTS vs. DESCENDANTS

Um die Richtung im Lineage Graph zu verstehen, verwenden Sie das folgende Entitätsbeziehungsdiagramm: Datensatz -> Trainingsauftrag -> Modell -> Endpunkt

Der Endpunkt ist ein Nachkomme des Modells, und das Modell ist ein Nachkomme des Datensatzes. In ähnlicher Weise ist das Modell ein Aszendent des Endpunkts. Der direction Parameter kann verwendet werden, um anzugeben, ob die Abfrage Entitäten zurückgeben soll, die von der Entität in start_arns abstammen oder aufsteigend sind. Wenn der start_arns ein Modell enthält und die Richtung DESCENDANTS lautet, gibt die Abfrage den Endpunkt zurück. Wenn die Richtung ASCENDANTS lautet, gibt die Abfrage den Datensatz zurück.

# In this example, we'll look at the impact of specifying the direction as ASCENDANT or DESCENDANT in a `LineageQuery`.

query_filter = LineageFilter(
    entities=[LineageEntityEnum.ARTIFACT],
    sources=[
        LineageSourceEnum.ENDPOINT,
        LineageSourceEnum.MODEL,
        LineageSourceEnum.DATASET,
        LineageSourceEnum.TRAINING_JOB,
    ],
)

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[model_artifact.artifact_arn],
    query_filter=query_filter,
    direction=LineageQueryDirectionEnum.ASCENDANTS,
    include_edges=False,
)

ascendant_artifacts = []

# The lineage entity returned for the Training Job is a TrialComponent which can't be converted to a
# lineage object using the method `to_lineage_object()` so we extract the TrialComponent ARN.
for vertex in query_result.vertices:
    try:
        ascendant_artifacts.append(vertex.to_lineage_object().source.source_uri)
    except:
        ascendant_artifacts.append(vertex.arn)

print("Ascendant artifacts : ")
pp.pprint(ascendant_artifacts)

query_result = LineageQuery(sagemaker_session).query(
    start_arns=[model_artifact.artifact_arn],
    query_filter=query_filter,
    direction=LineageQueryDirectionEnum.DESCENDANTS,
    include_edges=False,
)

descendant_artifacts = []
for vertex in query_result.vertices:
    try:
        descendant_artifacts.append(vertex.to_lineage_object().source.source_uri)
    except:
        # Handling TrialComponents.
        descendant_artifacts.append(vertex.arn)

print("Descendant artifacts : ")
pp.pprint(descendant_artifacts)
Beispiel SDKHilfsfunktionen zur Vereinfachung von Abstammungsabfragen

Die Klassen EndpointContextModelArtifact, und DatasetArtifact verfügen über Hilfsfunktionen, die als Wrapper dienen, LineageQuery API um die Nutzung bestimmter Abstammungsabfragen zu erleichtern. Das folgende Beispiel zeigt, wie diese Hilfsfunktionen verwendet werden können.

# Find all the datasets associated with this endpoint

datasets = []
dataset_artifacts = endpoint_context.dataset_artifacts()
for dataset in dataset_artifacts:
    datasets.append(dataset.source.source_uri)
print("Datasets : ", datasets)

# Find the training jobs associated with the endpoint
training_job_artifacts = endpoint_context.training_job_arns()
training_jobs = []
for training_job in training_job_artifacts:
    training_jobs.append(training_job)
print("Training Jobs : ", training_jobs)

# Get the ARN for the pipeline execution associated with this endpoint (if any)
pipeline_executions = endpoint_context.pipeline_execution_arn()
if pipeline_executions:
    for pipeline in pipelines_executions:
        print(pipeline)

# Here we use the `ModelArtifact` class to find all the datasets and endpoints associated with the model

dataset_artifacts = model_artifact.dataset_artifacts()
endpoint_contexts = model_artifact.endpoint_contexts()

datasets = [dataset.source.source_uri for dataset in dataset_artifacts]
endpoints = [endpoint.source.source_uri for endpoint in endpoint_contexts]

print("Datasets associated with this model : ")
pp.pprint(datasets)

print("Endpoints associated with this model : ")
pp.pprint(endpoints)

# Here we use the `DatasetArtifact` class to find all the endpoints hosting models that were trained with a particular dataset
# Find the artifact associated with the dataset

dataset_artifact_arn = list(Artifact.list(source_uri=training_data))[0].artifact_arn
dataset_artifact = DatasetArtifact.load(artifact_arn=dataset_artifact_arn)

# Find the endpoints that used this training dataset
endpoint_contexts = dataset_artifact.endpoint_contexts()
endpoints = [endpoint.source.source_uri for endpoint in endpoint_contexts]

print("Endpoints associated with the training dataset {}".format(training_data))
pp.pprint(endpoints)
Beispiel Holen Sie sich eine Visualisierung eines Lineage-Diagramms

Im Beispiel-Notebook visualizer.py steht eine Hilfsklasse Visualizer zur Verfügung, die beim Zeichnen des Liniendiagramms hilft. Wenn die Abfrageantwort gerendert wird, wird ein Diagramm mit den Abstammungsbeziehungen von StartArns angezeigt. Aus der Visualisierung StartArns gehen die Beziehungen zu den anderen Abstammungseinheiten hervor, die in der Aktion zurückgegeben wurden. query_lineage API

# Graph APIs
# Here we use the boto3 `query_lineage` API to generate the query response to plot.

from visualizer import Visualizer

query_response = sm_client.query_lineage(
    StartArns=[endpoint_context.context_arn], Direction="Ascendants", IncludeEdges=True
)

viz = Visualizer()
viz.render(query_response, "Endpoint")
        
        query_response = sm_client.query_lineage(
    StartArns=[model_artifact.artifact_arn], Direction="Ascendants", IncludeEdges=True
)
viz.render(query_response, "Model")