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
<a name="querying-lineage-entities"></a>

Amazon SageMaker AI generiert automatisch Diagramme von Lineage-Entitäten, während Sie sie verwenden. Sie können diese Daten abfragen, um eine Vielzahl von Fragen zu beantworten. Im Folgenden finden Sie Anweisungen zur Abfrage dieser Daten im SDK für Python. 

Informationen zum Anzeigen einer registrierten Modelllinie in Amazon SageMaker Studio finden Sie unter[Details zur Modellabstammung in Studio anzeigen](model-registry-lineage-view-studio.md).

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 Trainingsjob 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 den 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 den ARN für die Pipeline-Ausführung ab, die der Testkomponente zugeordnet ist.
+ 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. 

**Topics**
+ [Erste Schritte mit dem Abfragen von Lineage-Entitäten](#querying-lineage-entities-getting-started)

## Erste Schritte mit dem Abfragen von Lineage-Entitäten
<a name="querying-lineage-entities-getting-started"></a>

Der einfachste Weg, um loszulegen, ist entweder über:
+ [Amazon SageMaker AI SDK für Python](https://github.com/aws/sagemaker-python-sdk/blob/master/src/sagemaker/lineage/artifact.py#L397), das viele gängige Anwendungsfälle definiert hat.
+ [Ein Notizbuch, das demonstriert, wie SageMaker AI Lineage verwendet wird, APIs um Beziehungen im Lineage-Diagramm abzufragen, finden Sie unter sagemaker-lineage-multihop-queries .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-lineage/sagemaker-lineage-multihop-queries.ipynb)

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

**Example Verwenden der `LineageQuery` API zum Auffinden von Entitätszuordnungen**  

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

**Example 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)
```

**Example 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)
```

**Example 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)
```

**Example Ä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)
```

**Example `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 Trainingsjob zweimal ausgeführt wird und beide durch den Trainingsjob 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)
```

**Example Anweisungen in `LineageQuery` – `ASCENDANTS` vs. `DESCENDANTS`**  
Um die Richtung im Lineage Graph zu verstehen, verwenden Sie das folgende Entitätsbeziehungsdiagramm: Datensatz -> Trainingsjob -> 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)
```

**Example SDK-Hilfsfunktionen zur Vereinfachung von Abstammungsabfragen**  
Die Klassen `EndpointContext`, `ModelArtifact` und `DatasetArtifact` verfügen über Hilfsfunktionen, die die `LineageQuery` API überlagern, um die Nutzung bestimmter Abstammungsabfragen zu vereinfachen. 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)
```

**Example Holen Sie sich eine Visualisierung eines Lineage-Diagramms**  
Im Beispiel-Notebook [visualizer.py](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-lineage/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 `StartArns` Visualisierung gehen die Beziehungen zu den anderen Abstammungsentitäten hervor, die in der `query_lineage` API-Aktion zurückgegeben wurden.  

```
# 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")
```