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.
# Aufzeichnen von Artikelinteraktionsereignissen in Echtzeit
Ein *Artikelinteraktionsereignis* ist eine Interaktion zwischen einem Benutzer und einem Artikel in Ihrem Katalog. Zum Beispiel ein Benutzer, der Schuhe kauft oder sich einen Film ansieht.
Zeichnen Sie Interaktionen mit Artikeln in Echtzeit auf, während Sie Ihren Kunden Artikelempfehlungen zeigen. Auf diese Weise werden Ihre Interaktionsdaten erweitert und Ihre Daten auf dem neuesten Stand gehalten. Und es informiert Amazon Personalize über die aktuellen Interessen Ihrer Nutzer, wodurch die Relevanz von Empfehlungen verbessert werden kann.
Sie zeichnen Interaktionsereignisse mit Artikeln im Rahmen des [PutEvents](API_UBS_PutEvents.md) API-Vorgangs auf. Amazon Personalize hängt die Ereignisdaten an den Datensatz *Artikelinteraktionen in Ihrer Datensatzgruppe* an. Wenn Sie zwei Ereignisse mit exakt demselben Zeitstempel und identischen Eigenschaften aufzeichnen, speichert Amazon Personalize nur eines der Ereignisse. Sie können Interaktionsereignisse mit Objekten aufzeichnen AWS SDKs, indem AWS Sie Amplify oder AWS Command Line Interface (AWS CLI) verwenden.
Wenn Sie Apache Kafka verwenden, können Sie den *Kafka-Konnektor für Amazon Personalize* verwenden, um Artikelinteraktionen in Echtzeit an Amazon Personalize zu streamen. Weitere Informationen finden Sie unter [Kafka Connector for Amazon Personalize](https://github.com/aws/personalize-kafka-connector/blob/main/README.md) im *personalize-kafka-connector*Github-Repository.
AWS Amplify umfasst eine JavaScript Bibliothek zum Aufzeichnen von Objektinteraktionsereignissen aus Webclient-Anwendungen und eine Bibliothek zum Aufzeichnen von Ereignissen im Servercode. Weitere Informationen finden Sie in der [Amplify-Dokumentation](https://docs.amplify.aws/).
**Topics**
+ [Anforderungen für die Aufzeichnung von Interaktionsereignissen mit Objekten und das Trainieren eines Modells](#recording-events-requirements)
+ [Einen Event-Tracker für Artikelinteraktionen erstellen](event-get-tracker.md)
+ [Aufzeichnen eines Interaktionsereignisses mit einem einzelnen Objekt](putevents-example.md)
+ [Aufzeichnen mehrerer Artikelinteraktionsereignisse mit Ereigniswertdaten](recording-events-example-event-value.md)
+ [Aufzeichnen von Interaktionsereignissen mit Artikeldaten](putevents-including-impressions-data.md)
+ [Ereignismetriken und Attributionsberichte](event-metrics.md)
## Anforderungen für die Aufzeichnung von Interaktionsereignissen mit Objekten und das Trainieren eines Modells
Um Interaktionsereignisse mit Objekten aufzuzeichnen, benötigen Sie Folgendes:
+ Eine Dataset-Gruppe, die ein `Item interactions`-Dataset umfasst, das leer sein kann. Wenn Sie die [Tutorials für die ersten Schritte](getting-started.md) Anleitung gelesen haben, können Sie dieselbe Datensatzgruppe und denselben Datensatz verwenden, den Sie erstellt haben. Informationen zum Erstellen einer Datensatzgruppe und eines Datensatzes finden Sie unter[Trainingsdaten in Amazon Personalize Personalize-Datensätze importieren](import-data.md).
+ Einen Ereignis-Tracker.
+ Ein Aufruf der [PutEvents](API_UBS_PutEvents.md) API-Operation.
+ Wenn Sie eine AWS Lambda Funktion verwenden, um den PutEvents Vorgang aufzurufen, muss die Ausführungsrolle Ihrer Funktion über die Berechtigung verfügen, die `personalize:PutEvents` Aktion mit dem Platzhalter `*` im `Resource` Element auszuführen.
Sie können mit einem leeren Datensatz für Artikelinteraktionen beginnen und, wenn Sie genügend Daten aufgezeichnet haben, das Modell nur mit neu aufgezeichneten Ereignissen trainieren. Für alle Anwendungsfälle (Domain-Datensatzgruppen) und Rezepte (benutzerdefinierte Datensatzgruppen) müssen Ihre Interaktionsdaten vor dem Training Folgendes aufweisen:
+ Mindestens 1000 Datensätze zu Artikelinteraktionen von Benutzern, die mit Artikeln in Ihrem Katalog interagieren. Diese Interaktionen können aus Massenimporten, gestreamten Ereignissen oder beidem stammen.
+ Mindestens 25 eindeutige Benutzer IDs mit jeweils mindestens zwei Artikelinteraktionen.
Für Qualitätsempfehlungen empfehlen wir, mindestens 50.000 Artikelinteraktionen von mindestens 1.000 Benutzern mit jeweils zwei oder mehr Artikelinteraktionen durchzuführen.
# Einen Event-Tracker für Artikelinteraktionen erstellen
Bevor Sie Ereignisse zur Artikelinteraktion aufzeichnen können, müssen Sie einen Event-Tracker für Artikelinteraktionen erstellen. Ein *Event-Tracker* leitet neue Ereignisdaten an den *Datensatz Artikelinteraktionen* in Ihrer Datensatzgruppe weiter.
Sie erstellen einen Event-Tracker mit der Amazon Personalize Personalize-Konsole oder dem [CreateEventTracker](API_CreateEventTracker.md) API-Vorgang. Sie übergeben als Parameter den Amazon-Ressourcennamen (ARN) der Datensatzgruppe, die den Zieldatensatz „Artikelinteraktionen“ enthält. Anweisungen zum Erstellen eines Event-Trackers mit der Amazon Personalize Personalize-Konsole finden Sie unter[Einen Event-Tracker (Konsole) erstellen](importing-interactions.md#event-tracker-console).
Ein Event-Tracker enthält eine *Tracking-ID*, die Sie als Parameter übergeben, wenn Sie den [PutEvents](https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html)Vorgang verwenden. Amazon Personalize hängt dann die neuen Ereignisdaten an den Datensatz Artikelinteraktionen der Datensatzgruppe an, die Sie in Ihrem Event-Tracker angeben.
**Anmerkung**
Sie können nur einen Event-Tracker für Artikelinteraktionen für eine Datensatzgruppe erstellen.
------
#### [ Python ]
```
import boto3
personalize = boto3.client('personalize')
response = personalize.create_event_tracker(
name='MovieClickTracker',
datasetGroupArn='arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieClickGroup'
)
print(response['eventTrackerArn'])
print(response['trackingId'])
```
Der Event-Tracker ARN und die Tracking-ID werden angezeigt, zum Beispiel:
```
{
"eventTrackerArn": "arn:aws:personalize:us-west-2:acct-id:event-tracker/MovieClickTracker",
"trackingId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}
```
------
#### [ AWS CLI ]
```
aws personalize create-event-tracker \
--name MovieClickTracker \
--dataset-group-arn arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieClickGroup
```
Der Event-Tracker ARN und die Tracking-ID werden angezeigt, zum Beispiel:
```
{
"eventTrackerArn": "arn:aws:personalize:us-west-2:acct-id:event-tracker/MovieClickTracker",
"trackingId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients module and commands using ES6 syntax.
import { CreateEventTrackerCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
// Set the event tracker's parameters.
export const createEventTrackerParam = {
datasetGroupArn: "DATASET_GROUP_ARN" /* required */,
name: "NAME" /* required */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateEventTrackerCommand(createEventTrackerParam),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
#### [ SDK for Java 2.x ]
```
public static String createEventTracker(PersonalizeClient personalizeClient,
String eventTrackerName,
String datasetGroupArn) {
String eventTrackerId = null;
String eventTrackerArn = null;
long maxTime = 3 * 60 * 60;
long waitInMilliseconds = 30 * 1000;
String status;
try {
CreateEventTrackerRequest createEventTrackerRequest = CreateEventTrackerRequest.builder()
.name(eventTrackerName)
.datasetGroupArn(datasetGroupArn)
.build();
CreateEventTrackerResponse createEventTrackerResponse =
personalizeClient.createEventTracker(createEventTrackerRequest);
eventTrackerArn = createEventTrackerResponse.eventTrackerArn();
eventTrackerId = createEventTrackerResponse.trackingId();
System.out.println("Event tracker ARN: " + eventTrackerArn);
System.out.println("Event tracker ID: " + eventTrackerId);
maxTime = Instant.now().getEpochSecond() + maxTime;
DescribeEventTrackerRequest describeRequest = DescribeEventTrackerRequest.builder()
.eventTrackerArn(eventTrackerArn)
.build();
while (Instant.now().getEpochSecond() < maxTime) {
status = personalizeClient.describeEventTracker(describeRequest).eventTracker().status();
System.out.println("EventTracker status: " + status);
if (status.equals("ACTIVE") || status.equals("CREATE FAILED")) {
break;
}
try {
Thread.sleep(waitInMilliseconds);
} catch (InterruptedException e) {
System.out.println(e.getMessage());
}
}
return eventTrackerId;
}
catch (PersonalizeException e){
System.out.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return eventTrackerId;
}
```
------
# Aufzeichnen eines Interaktionsereignisses mit einem einzelnen Objekt
Nachdem Sie einen *Datensatz mit Artikelinteraktionen* und einen [Event-Tracker](event-get-tracker.md) für Ihre Datensatzgruppe erstellt haben, sind Sie bereit, Artikelinteraktionsereignisse aufzuzeichnen. Das folgende Beispiel zeigt einen `PutEvents` Vorgang, bei dem ein Interaktionsereignis mit einem Element übergeben wird. Das entsprechende Schema wird zusammen mit einer Beispielzeile aus dem Datensatz Artikelinteraktionen angezeigt.
Ihre Anwendung generiert ein eindeutiges Zeichen`sessionId`, wenn ein Benutzer Ihre Website zum ersten Mal besucht oder Ihre Anwendung verwendet. Sie müssen während der gesamten Sitzung `sessionId` bei allen Veranstaltungen dasselbe verwenden. Amazon Personalize verwendet das`sessionId`, um Ereignisse mit dem Benutzer zu verknüpfen, bevor er sich anmeldet (ist anonym). Weitere Informationen finden Sie unter [Ereignisse für anonyme Benutzer aufzeichnen](recording-events.md#recording-anonymous-user-events).
Die Ereignisliste ist ein Array von [Event](API_UBS_Event.md)-Objekten. Für jedes Ereignis `eventType` ist ein erforderlich. Wenn Sie keine Daten zum Ereignistyp haben, können Sie einen Platzhalterwert angeben, um die Anforderung zu erfüllen.
Der `trackingId` stammt aus dem Event-Tracker, in [Einen Event-Tracker für Artikelinteraktionen erstellen](event-get-tracker.md) dem Sie ihn erstellt haben. Die `userId`-, `itemId`- und `sentAt`-Parameter stimmen mit den USER\$1ID-, ITEM\$1ID- und TIMESTAMP-Feldern eines entsprechenden historischen `Interactions`-Datasets überein. Weitere Informationen finden Sie unter [JSON-Schema-Dateien für Amazon Personalize Personalize-Schemas erstellen](how-it-works-dataset-schema.md).
**Entsprechende Datensatzspalten**
```
Dataset columns: USER_ID, ITEM_ID, TIMESTAMP, EVENT_TYPE
Example data: user123, item-xyz, 1543631760, click
```
**Code-Beispiel**
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize_events = boto3.client(service_name='personalize-events')
personalize_events.put_events(
trackingId = 'tracking_id',
userId= 'USER_ID',
sessionId = 'session_id',
eventList = [{
'sentAt': 1719511760,
'eventType': 'click',
'itemId': 'ITEM_ID'
}]
)
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients module and commands using ES6 syntax.
import { PutEventsCommand } from "@aws-sdk/client-personalize-events";
import { personalizeEventsClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeEventsClient = new PersonalizeEventsClient({ region: "REGION"});
// Convert your UNIX timestamp to a Date.
const sentAtDate = new Date(1613443801 * 1000); // 1613443801 is a testing value. Replace it with your sentAt timestamp in UNIX format.
// Set put events parameters.
const putEventsParam = {
eventList: [
/* required */
{
eventType: "EVENT_TYPE" /* required */,
sentAt: sentAtDate /* required, must be a Date with js */,
eventId: "EVENT_ID" /* optional */,
itemId: "ITEM_ID" /* optional */,
},
],
sessionId: "SESSION_ID" /* required */,
trackingId: "TRACKING_ID" /* required */,
userId: "USER_ID" /* required */,
};
export const run = async () => {
try {
const response = await personalizeEventsClient.send(
new PutEventsCommand(putEventsParam),
);
console.log("Success!", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
#### [ AWS CLI ]
```
aws personalize-events put-events \
--tracking-id tracking_id \
--user-id USER_ID \
--session-id session_id \
--event-list '[{
"sentAt": 1719511760,
"eventType": "click",
"itemId": "ITEM_ID"
}]'
```
------
#### [ SDK for Java 2.x ]
```
public static void putEvents(PersonalizeEventsClient personalizeEventsClient,
String trackingId,
String sessionId,
String userId,
String itemId,
String eventType) {
try {
Event event = Event.builder()
.sentAt(Instant.ofEpochMilli(System.currentTimeMillis() + 10 * 60 * 1000))
.itemId(itemId)
.eventType(eventType)
.build();
PutEventsRequest putEventsRequest = PutEventsRequest.builder()
.trackingId(trackingId)
.userId(userId)
.sessionId(sessionId)
.eventList(event)
.build();
int responseCode = personalizeEventsClient.putEvents(putEventsRequest)
.sdkHttpResponse()
.statusCode();
System.out.println("Response code: " + responseCode);
} catch (PersonalizeEventsException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
# Aufzeichnen mehrerer Artikelinteraktionsereignisse mit Ereigniswertdaten
Nachdem Sie einen *Datensatz mit Artikelinteraktionen* und einen [Event-Tracker](event-get-tracker.md) für Ihre Datensatzgruppe erstellt haben, können Sie Ereignisse im Zusammenhang mit Artikelinteraktionen aufzeichnen. Das folgende Beispiel zeigt, wie Sie mehrere Artikelinteraktionsereignisse mit unterschiedlichen Ereignistypen und unterschiedlichen Ereigniswerten aufzeichnen.
Wenn Sie eine Lösung konfigurieren und Ihr *Datensatz mit Artikelinteraktionen* die Felder EVENT\$1TYPE und EVENT\$1VALUE enthält, können Sie einen bestimmten Wert als Schwellenwert festlegen, um Datensätze vom Training auszuschließen. Weitere Informationen finden Sie unter [Auswahl der für das Training verwendeten Artikelinteraktionsdaten](event-values-types.md).
------
#### [ Python ]
```
import boto3
import json
personalize_events = boto3.client(service_name='personalize-events')
personalize_events.put_events(
trackingId = 'tracking_id',
userId= 'user555',
sessionId = 'session1',
eventList = [{
'eventId': 'event1',
'sentAt': 1553631760,
'eventType': 'like',
'properties': json.dumps({
'itemId': 'choc-panama',
'eventValue': 4
})
}, {
'eventId': 'event2',
'sentAt': 1553631782,
'eventType': 'rating',
'properties': json.dumps({
'itemId': 'movie_ten',
'eventValue': 3
})
}]
)
```
------
#### [ AWS CLI ]
```
aws personalize-events put-events \
--tracking-id tracking_id \
--user-id user555 \
--session-id session1 \
--event-list '[{
"eventId": "event1",
"sentAt": 1553631760,
"eventType": "like",
"properties": "{\"itemId\": \"choc-panama\", \"eventValue\": \"true\"}"
}, {
"eventId": "event2",
"sentAt": 1553631782,
"eventType": "rating",
"properties": "{\"itemId\": \"movie_ten\", \"eventValue\": \"4\", \"numRatings\": \"13\"}"
}]'
```
------
#### [ SDK for Java 2.x ]
```
public static void putMultipleEvents(PersonalizeEventsClient personalizeEventsClient,
String trackingId,
String sessionId,
String userId,
String event1Type,
Float event1Value,
String event1ItemId,
int event1NumRatings,
String event2Type,
Float event2Value,
String event2ItemId,
int event2NumRatings) {
ArrayList eventList = new ArrayList();
try {
Event event1 = Event.builder()
.eventType(event1Type)
.sentAt(Instant.ofEpochMilli(System.currentTimeMillis() + 10 * 60 * 1000))
.itemId(event1ItemId)
.eventValue(event1Value)
.properties("{\"numRatings\": "+ event1NumRatings +"}")
.build();
eventList.add(event1);
Event event2 = Event.builder()
.eventType(event2Type)
.sentAt(Instant.ofEpochMilli(System.currentTimeMillis() + 10 * 60 * 1000))
.itemId(event2ItemId)
.eventValue(event2Value)
.properties("{\"numRatings\": "+ event2NumRatings +"}")
.build();
eventList.add(event2);
PutEventsRequest putEventsRequest = PutEventsRequest.builder()
.trackingId(trackingId)
.userId(userId)
.sessionId(sessionId)
.eventList(eventList)
.build();
int responseCode = personalizeEventsClient.putEvents(putEventsRequest)
.sdkHttpResponse()
.statusCode();
System.out.println("Response code: " + responseCode);
} catch (PersonalizeEventsException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
**Anmerkung**
Die Eigenschaftenschlüssel verwenden Binnenmajuskel-Benennungen, die den Feldern im Interaktionsschema entsprechen. Wenn beispielsweise das Feld 'NUM\$1RATINGS' im Interactions-Schema definiert ist, sollte der Eigenschaftsschlüssel wie folgt definiert sein. `numRatings`
# Aufzeichnen von Interaktionsereignissen mit Artikeldaten
Wenn Sie das [Personalisierung durch Benutzer](native-recipe-new-item-USER_PERSONALIZATION.md) Rezept verwenden oder das Feld IMPRESSIONS zu Ihrem Schema für einen Datensatz in einer Domain-Datensatzgruppe hinzufügen, können Sie Impressionsdaten in Ihrem PutEvents Vorgang aufzeichnen. Impressionen sind Listen von Elementen, die für einen Benutzer sichtbar waren, wenn er mit einem bestimmten Element interagierte (z. B. darauf klickte oder es sich ansah). Amazon Personalize verwendet Impressionsdaten als Leitfaden für die Erkundung, wobei Empfehlungen Artikel mit weniger Interaktionsdaten oder Relevanz enthalten. Informationen zu den *impliziten* und *expliziten* Impressionen, die Amazon Personalize modellieren kann, finden Sie unter. [Daten zu Eindrücken](interactions-datasets.md#interactions-impressions-data)
**Wichtig**
Wenn Sie widersprüchliche implizite und explizite Impressionsdaten in Ihren `PutEvents` Anfragen angeben, verwendet Amazon Personalize standardmäßig die expliziten Impressionen.
Um die Amazon Personalize-Empfehlungen aufzuzeichnen, die Sie Ihrem Nutzer als Impressionsdaten anzeigen, fügen Sie diese `recommendationId` in Ihre [PutEvents](API_UBS_PutEvents.md) Anfrage ein und Amazon Personalize leitet die impliziten Impressionen auf der Grundlage Ihrer Empfehlungsdaten ab.
Um Impressionsdaten für ein Ereignis manuell aufzuzeichnen, listen Sie die Impressionen im Eingabeparameter des [PutEvents](API_UBS_PutEvents.md) Befehls auf. `impression` Das folgende Codebeispiel zeigt, wie Sie a `recommendationId` und an `impression` in eine PutEvents Operation mit dem SDK for Python (Boto3) oder dem SDK for Java 2.x einbeziehen. Wenn Sie beide angeben, verwendet Amazon Personalize standardmäßig die expliziten Impressionen.
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize_events = boto3.client(service_name='personalize-events')
personalize_events.put_events(
trackingId = 'tracking_id',
userId= 'userId',
sessionId = 'sessionId',
eventList = [{
'eventId': 'event1',
'eventType': 'rating',
'sentAt': 1553631760,
'itemId': 'item id',
'recommendationId': 'recommendation id',
'impression': ['itemId1', 'itemId2', 'itemId3']
}]
)
```
------
#### [ SDK for Java 2.x ]
Verwenden Sie die folgende `putEvents` Methode, um ein Ereignis mit Impressionsdaten und einer RecommendationID aufzuzeichnen. Übergeben Sie für den Impressions-Parameter die Liste der ItemIDs als. ArrayList
```
public static void putEvents(PersonalizeEventsClient personalizeEventsClient,
String trackingId,
String sessionId,
String userId,
String eventType,
Float eventValue,
String itemId,
ArrayList impressions,
String recommendationId) {
try {
Event event = Event.builder()
.eventType(eventType)
.sentAt(Instant.ofEpochMilli(System.currentTimeMillis() + 10 * 60 * 1000))
.itemId(itemId)
.eventValue(eventValue)
.impression(impressions)
.recommendationId(recommendationId)
.build();
PutEventsRequest putEventsRequest = PutEventsRequest.builder()
.trackingId(trackingId)
.userId(userId)
.sessionId(sessionId)
.eventList(event)
.build();
int responseCode = personalizeEventsClient.putEvents(putEventsRequest)
.sdkHttpResponse()
.statusCode();
System.out.println("Response code: " + responseCode);
} catch (PersonalizeEventsException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
# Ereignismetriken und Attributionsberichte
Verwenden Sie CloudWatch Amazon-Metriken, um die Art und Anzahl der an Amazon Personalize gesendeten Ereignisse zu überwachen. Weitere Informationen finden Sie unter [Überwachung von Amazon Personalize mit Amazon CloudWatch](personalize-monitoring.md).
Um CloudWatch Berichte zu erstellen, die die Wirkung von Empfehlungen aufzeigen, erstellen Sie eine Metrik-Zuordnung und zeichnen Sie Benutzerinteraktionen mit Empfehlungen in Echtzeit auf. Informationen zum Erstellen einer metrischen Zuordnung finden Sie unter. [Messung der Wirkung von Amazon Personalize Personalize-Empfehlungen](measuring-recommendation-impact.md)
Geben Sie für jedes Ereignis die Empfehlungs-ID der Empfehlungen an, die Sie dem Benutzer gezeigt haben. Oder geben Sie die Ereignisquelle an, z. B. eine dritte Partei. Importieren Sie diese Daten, um verschiedene Kampagnen, Empfehlungsgeber und Drittanbieter zu vergleichen. Sie können maximal 100 Quellen für die Zuordnung von Ereignissen importieren.
+ Wenn Sie eine angeben`recommendationId`, bestimmt Amazon Personalize automatisch die Quellkampagne oder den Empfehlungsgeber und identifiziert ihn in Berichten in einer EVENT\$1ATTRIBUTION\$1SOURCE-Spalte.
+ Wenn Sie beide Attribute angeben, verwendet Amazon Personalize nur die`eventAttributionSource`.
+ Wenn Sie keine Quelle angeben, kennzeichnet Amazon Personalize die Quelle `SOURCE_NAME_UNDEFINED` in Berichten.
Der folgende Code zeigt, wie ein `eventAttributionSource` für ein Ereignis in einem PutEvents Vorgang bereitgestellt wird.
```
response = personalize_events.put_events(
trackingId = 'eventTrackerId',
userId= 'userId',
sessionId = 'sessionId123',
eventList = [{
'eventId': 'event1',
'eventType': 'watch',
'sentAt': '1667260945',
'itemId': '123',
'metricAttribution': {
'eventAttributionSource': 'thirdPartyServiceXYZ'
}
}]
)
statusCode = response['ResponseMetadata']['HTTPStatusCode']
print(statusCode)
```
Der folgende Code zeigt, wie ein `recommendationId` für ein Ereignis in einer PutEvents Operation bereitgestellt wird.
```
response = personalize_events.put_events(
trackingId = 'eventTrackerId',
userId= 'userId',
sessionId = 'sessionId123',
eventList = [{
'eventId': 'event1',
'eventType': 'watch',
'sentAt': '1667260945',
'itemId': '123',
'recommendationId': 'RID-12345678-1234-1234-1234-abcdefghijkl'
}]
)
statusCode = response['ResponseMetadata']['HTTPStatusCode']
print(statusCode)
```