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.
# Aufzeichnung von Ereignissen in Echtzeit zur Beeinflussung von Empfehlungen
Ein *Ereignis* ist eine Interaktion zwischen einem Benutzer und Ihrem Katalog. Dabei kann es sich um eine Interaktion mit einem *Artikel* handeln, z. B. wenn ein Benutzer einen Artikel kauft oder sich ein Video anschaut, oder es kann sich um eine *Aktion handeln*, z. B. um die Beantragung einer Kreditkarte oder die Registrierung für ein Mitgliedschaftsprogramm.
Amazon Personalize kann Empfehlungen nur auf der Grundlage von Echtzeitereignisdaten, nur historischen Ereignisdaten oder einer Mischung aus beidem aussprechen. Zeichnen Sie Ereignisse in Echtzeit auf, während Ihre Kunden mit Empfehlungen interagieren. Dadurch 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.
Wenn Ihr Domain-Anwendungsfall oder Ihr benutzerdefiniertes Rezept [Personalisierung in Echtzeit](use-case-recipe-features.md#about-real-time-personalization) unterstützt, verwendet Amazon Personalize Ereignisse in Echtzeit, um Empfehlungen zu aktualisieren und an das sich ändernde Interesse eines Benutzers anzupassen.
Wie Sie Ereignisse in Echtzeit aufzeichnen, hängt von der Art der Interaktionsdaten ab, die Sie importieren:
+ Bei *Artikelinteraktionen* zeichnen Sie Ereignisse in Echtzeit mit dem [PutEvents](API_UBS_PutEvents.md) API-Vorgang auf. Amazon Personalize hängt diese Daten an die [Artikelinteraktionsdaten](interactions-datasets.md) in Ihrer Datensatzgruppe an. Weitere Informationen finden Sie unter [Aufzeichnen von Artikelinteraktionsereignissen in Echtzeit](recording-item-interaction-events.md).
+ Bei *Aktionsinteraktionen* zeichnen Sie Ereignisse in Echtzeit mit dem [PutActionInteractions](API_UBS_PutActionInteractions.md) API-Vorgang auf. Amazon Personalize hängt diese Daten an den Datensatz [Aktionsinteraktionen in Ihrer Datensatzgruppe](action-interactions-datasets.md) an. Nur die PERSONALIZED\$1ACTIONS-Rezepte verwenden Daten zu Aktionsinteraktionen. Weitere Informationen finden Sie unter [Aufzeichnung von Action-Interaktionsereignissen in EchtzeitAufzeichnen von Aktionsereignissen](recording-action-interaction-events.md).
**Topics**
+ [Wie Ereignisse in Echtzeit Empfehlungen beeinflussen](#recorded-events-influence-recommendations)
+ [Aufzeichnen von Artikelinteraktionsereignissen in Echtzeit](recording-item-interaction-events.md)
+ [Aufzeichnung von Action-Interaktionsereignissen in Echtzeit](recording-action-interaction-events.md)
+ [Ereignisse für anonyme Benutzer aufzeichnen](#recording-anonymous-user-events)
+ [Event-Tracking-Dienste von Drittanbietern](#record-events-third-parties)
+ [Beispielimplementierungen](#recording-events-sample-architecture)
## Wie Ereignisse in Echtzeit Empfehlungen beeinflussen
Wenn Ihr Rezept Personalisierung in Echtzeit unterstützt, verwendet Amazon Personalize nach dem Erstellen einer Empfehlung oder einer benutzerdefinierten Kampagne innerhalb von Sekunden nach dem Import neue aufgezeichnete Eventdaten für bestehende Artikel oder Aktionen. Die folgenden Anwendungsfälle und Rezepte unterstützen die Personalisierung in Echtzeit:
+ [Für Sie empfohlen (E-COMMERCE-Anwendungsfall)](ECOMMERCE-use-cases.md#recommended-for-you-use-case)
+ [Top-Tipps für Sie (Anwendungsfall VIDEO\$1ON\$1DEMAND)](VIDEO_ON_DEMAND-use-cases.md#top-picks-use-case)
+ [Rezept für Benutzerpersonalisierung V2](native-recipe-user-personalization-v2.md)
+ [Rezept für Benutzerpersonalisierung](native-recipe-new-item-USER_PERSONALIZATION.md)
+ [Personalisiertes Ranking-V2-Rezept](native-recipe-personalized-ranking-v2.md)
+ [Rezept für personalisiertes Ranking](native-recipe-search.md)
+ [Next-Best-Action Rezept](native-recipe-next-best-action.md)
Wenn Sie das Trending-Now-Rezept verwenden, berücksichtigt Amazon Personalize in konfigurierbaren Intervallen automatisch Artikel aus neuen Ereignisdaten. Sie müssen keine neue Lösungsversion erstellen. Weitere Informationen finden Sie unter [Trending-Now-Rezept](native-recipe-trending-now.md).
Wenn der Artikel, die Aktion oder der Benutzer in der Veranstaltung neu ist, hängt die Art und Weise, wie Amazon Personalize die Daten verwendet, von Ihrem Anwendungsfall oder Rezept ab. Weitere Informationen finden Sie unter [Aktualisierung von Daten in Datensätzen nach dem Training](updating-datasets.md).
# 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)
```
# Aufzeichnung von Action-Interaktionsereignissen in Echtzeit
*Ein *Aktionsereignis* ist eine Interaktion zwischen einem Benutzer und einer Aktion.* Zum Beispiel ein Benutzer, der sich für ein Mitgliedschaftsprogramm anmeldet oder eine Kreditkarte beantragt.
Wenn Sie ein benutzerdefiniertes Rezept für PERSONALIZED\$1ACTIONS verwenden, zeichnen Sie Aktionsereignisse in Echtzeit auf, während Ihre Kunden mit Handlungsempfehlungen interagieren. Dadurch werden Ihre Interaktionsdaten erweitert und Ihre Daten auf dem neuesten Stand gehalten. Es informiert Amazon Personalize auch über die aktuellen Interessen Ihres Benutzers, wodurch die Relevanz von Empfehlungen verbessert werden kann. Nur die benutzerdefinierten Rezepte von PERSONALIZED\$1ACTIONS verwenden Daten zu Aktionsinteraktionen.
Sie zeichnen Aktionsereignisse mit dem API-Vorgang auf. [PutActionInteractions](API_UBS_PutActionInteractions.md) Amazon Personalize hängt diese Daten an den Datensatz „[Aktionsinteraktionen“ in Ihrer Datensatzgruppe](action-interactions-datasets.md) an.
Ein Aktions-Interaktionsereignis muss über ein Ereignistyp-Attribut verfügen, das eines der folgenden sein kann:
+ Ergriffen — *Erlegene* Ereignisse aufzeichnen, wenn ein Benutzer eine empfohlene Maßnahme ergreift.
+ Nicht ausgeführt — Ereignisse, die *nicht ausgeführt wurden*, aufzeichnen, wenn Ihr Benutzer sich bewusst dafür entscheidet, die Aktion nicht auszuführen, nachdem er sich die Aktion angesehen hat. Zum Beispiel, wenn sie *Nein* wählen, wenn Sie ihnen die Aktion zeigen. Ereignisse, die *nicht durchgeführt wurden*, können darauf hinweisen, dass der Kunde an der Aktion nicht interessiert ist.
+ Angesehen — *Angesehene* Ereignisse aufzeichnen, wenn Sie einem Benutzer eine Aktion zeigen, bevor er sich entscheidet, ob er eine Aktion ausführt oder nicht. Amazon Personalize verwendet *View-Ereignisse*, um mehr über die Interessen Ihrer Benutzer zu erfahren. Wenn ein Benutzer beispielsweise eine Aktion betrachtet, sie aber nicht ausführt, ist dieser Benutzer möglicherweise in future nicht an dieser Aktion interessiert.
Mit dem, oder AWS Command Line Interface (AWS CLI) können Sie Ereignisse in Echtzeit aufzeichnen. AWS SDKs Wenn Sie zwei Ereignisse mit exakt demselben Zeitstempel und identischen Eigenschaften aufzeichnen, speichert Amazon Personalize nur eines der Ereignisse.
**Topics**
+ [Anforderungen für die Aufzeichnung von Ereignissen im Zusammenhang mit Aktionen](#recording-action-interaction-requirements)
+ [Finden Sie die ID Ihres Action-Interaktions-Event-Trackers](action-interaction-tracker-id.md)
+ [Aufzeichnen eines einzelnen Aktionsinteraktionsereignisses](record-single-action-interaction.md)
+ [Aufzeichnen mehrerer Aktionsinteraktionsereignisse](recording-multiple-action-interactions.md)
## Anforderungen für die Aufzeichnung von Ereignissen im Zusammenhang mit Aktionen
Um Aktionsereignisse in Echtzeit aufzuzeichnen, benötigen Sie Folgendes:
+ Eine Datensatzgruppe, die eine enthält`Action interactions dataset`, die leer sein kann. Hinweise zum Erstellen einer Datensatzgruppe und eines Datensatzes finden Sie unter[Trainingsdaten in Amazon Personalize Personalize-Datensätze importieren](import-data.md).
+ Die ID Ihres Event-Trackers. Sie geben diese ID in der PutActionInteractions Operation an. Wenn Sie einen Action-Interaction-Datensatz erstellen, erstellt Amazon Personalize automatisch einen Action-Interaktions-Event-Tracker für Sie. Weitere Informationen finden Sie unter [Finden Sie die ID Ihres Action-Interaktions-Event-Trackers](action-interaction-tracker-id.md).
+ Einen Aufruf der [PutActionInteractions](API_UBS_PutActionInteractions.md)-Operation.
# Finden Sie die ID Ihres Action-Interaktions-Event-Trackers
Wenn Sie einen Action-Interaction-Datensatz erstellen, erstellt Amazon Personalize automatisch einen *Action-Interaktions-Event-Tracker* für Sie. Sie geben die ID des Trackers im PutActionInteractions API-Vorgang an. Amazon Personalize leitet damit neue Daten an den Datensatz „*Aktionsinteraktionen“ in Ihrer Datensatzgruppe* weiter.
Sie finden die ID Ihres Event-Trackers auf der Detailseite Ihres Action-Interaktions-Datensatzes in der Amazon Personalize Personalize-Konsole. Und Sie können die ID finden, indem Sie den DescribeDataset API-Vorgang aufrufen. Der folgende Python-Code druckt die Tracking-ID für einen Datensatz mit Aktionsinteraktionen.
```
import boto3
personalize = boto3.client(service_name='personalize')
response = personalize.describe_dataset(
datasetArn="Action interactions dataset ARN"
)
print(response['trackingId'])
```
# Aufzeichnen eines einzelnen Aktionsinteraktionsereignisses
Nachdem Sie einen Datensatz mit Aktionsinteraktionen erstellt haben, können Sie Aktionsereignisse mit der [PutActionInteractions](API_UBS_PutActionInteractions.md) Operation aufzeichnen. Der folgende Code zeigt eine `PutActionInteractions` Operation, die ein TAKEN-Ereignis übergibt. Sie können dieses Ereignis aufzeichnen, wenn Sie einem Benutzer Empfehlungen von Amazon Personalize anzeigen und dieser eine Maßnahme ergreift, z. B. Ihre Kreditkarte beantragt.
Das `actionInteractions` ist eine Reihe von ActionInteraction Objekten. Das `trackingId` stammt aus dem Event-Tracker Amazon Personalize, den Sie bei der Erstellung Ihres Action-Interaktions-Datensatzes erstellt haben. Weitere Informationen finden Sie unter [Finden Sie die ID Ihres Action-Interaktions-Event-Trackers](action-interaction-tracker-id.md).
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 `sentAt` Parameter `userId``actionId`, und sind den Feldern USER\$1ID, ACTION\$1ID, EVENT\$1TYPE und TIMESTAMP des Action-Interaktions-Datensatzes zugeordnet.
**Entsprechender Datensatz „Action-Interaktionen“**
```
USER_ID, ACTION_ID, TIMESTAMP, EVENT_TYPE
user123, action-xyz, 1543631760, TAKEN
```
**Code-Beispiel**
------
#### [ AWS CLI ]
```
aws personalize-events put-action-interactions \
--tracking-id 12345678-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
--action-interactions '[{
"userId": "user123",
"sessionId": "abcdefg",
"timestamp": 1543631760,
"eventType": "TAKEN",
"actionId": "action-xyz"}]'
```
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize_events = boto3.client(service_name='personalize-events')
response = personalize_events.put_action_interactions(
trackingId='12345678-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
actionInteractions=[{
'userId': 'user123',
'sessionId': 'abcdefg',
'timestamp': 1543631760,
'eventType': 'Taken',
'actionId': 'action-xyz'
}]
)
```
------
# Aufzeichnen mehrerer Aktionsinteraktionsereignisse
Der folgende Code zeigt, wie mehrere Aktionsinteraktionsereignisse für denselben Benutzer mit derselben sessionId aufgezeichnet werden.
**Entsprechender Datensatz „Aktionsinteraktionen“**
```
USER_ID, ACTION_ID, EVENT_TYPE, TIMESTAMP
user123, action123, Taken, 1543531139
user123, action345, Not Taken, 1543531139
```
------
#### [ AWS CLI ]
```
aws personalize-events put-action-interactions \
--tracking-id 6ddfe6b7-cd83-4dd4-b09d-4c35ecbacfe1 \
--action-interactions '[{
"userId": "user123",
"sessionId": "abcdefg",
"timestamp": 1543531139,
"eventType": "Taken",
"actionId": "action123"
},
{
"userId": "user123",
"sessionId": "abcdefg",
"timestamp": 1543531139,
"eventType": "Not Taken",
"actionId": "action345"}]'
```
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize_events = boto3.client(service_name='personalize-events')
response = personalize_events.put_action_interactions(
trackingId='12345678-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
actionInteractions=[{
'userId': 'user123',
'sessionId': 'abcdefg',
'timestamp': 1697848587,
'eventType': 'Taken',
'actionId': 'action123'
},
{
'userId': 'user123',
'sessionId': 'abcdefg',
'timestamp': 1697848622,
'eventType': 'Not Taken',
'actionId': 'action345'
}]
)
```
------
## Ereignisse für anonyme Benutzer aufzeichnen
**Wichtig**
Wenn Sie nicht mindestens ein Ereignis mit einem `sessionId` und `userId` für einen Benutzer aufzeichnen, verwendet Amazon Personalize die aufgezeichnete Aktivität nicht nur für das `sessionId` Training. Und nach Abschluss der Schulung basieren die Empfehlungen nicht mehr auf Aktivitäten, die `sessionId` bis zum erfasst wurden. Dadurch wird ein kontinuierlicher Ereignisverlauf für Benutzer-IDs vor und nach der Anmeldung erstellt.
Sie können Artikelinteraktionen oder Aktionsereignisse für Benutzer aufzeichnen, bevor diese ein Konto erstellen. Zeichnen Sie Ereignisse für anonyme Benutzer auf, um einen kontinuierlichen Ereignisverlauf mit Ereignissen vor und nach der Anmeldung zu erstellen. Dadurch erhält Amazon Personalize mehr Interaktionsdaten über den Benutzer, was dazu beitragen kann, relevantere Empfehlungen zu generieren.
Um Ereignisse für anonyme Benutzer (Benutzer, die sich nicht angemeldet haben) aufzuzeichnen, geben Sie für jedes Ereignis nur a `sessionId` an. 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 die`sessionId`, um Ereignisse mit dem Benutzer zu verknüpfen, bevor er sich anmeldet.
Amazon Personalize verwendet beim Training keine Ereignisse von anonymen Benutzern, bis Sie sie mit einem `userId` verknüpfen. Weitere Informationen finden Sie unter [Aufbau eines kontinuierlichen Ereignisverlaufs für anonyme Benutzer](#recording-events-building-continuous-event-history).
Um anonyme Benutzer [in Echtzeit zu personalisieren](use-case-recipe-features.md#about-real-time-personalization), geben Sie die SessionID als userId in Ihrer OR-Anfrage an. [GetRecommendations](API_RS_GetRecommendations.md) GetActionRecommendations
+ Codebeispiele, die zeigen, wie Elementinteraktionsereignisse mit dem PutEvents Vorgang und einer SessionID und userId aufgezeichnet werden, finden Sie unter. [Aufzeichnen eines Interaktionsereignisses mit einem einzelnen Objekt](putevents-example.md)
+ Codebeispiele, die zeigen, wie Aktionsereignisse mit dem PutActionInteractions Vorgang und einer SessionID und userId aufgezeichnet werden, finden Sie unter. [Aufzeichnen eines einzelnen Aktionsinteraktionsereignisses](record-single-action-interaction.md)
### Aufbau eines kontinuierlichen Ereignisverlaufs für anonyme Benutzer
Um einen Ereignisverlauf für einen anonymen Benutzer zu erstellen und Amazon Personalize seine Ereignisse beim Training verwenden zu lassen, zeichnen Sie mindestens ein Ereignis mit a `sessionId` und a `userId` auf. Anschließend können Sie eine beliebige Anzahl von Ereignissen für die `userId` aufzeichnen. Nachdem Sie mit der Bereitstellung von begonnen haben`userId`, `sessionId` können sie sich ändern. Bei der nächsten vollständigen Umschulung verknüpft Amazon Personalize den `userId` mit dem anonymen Benutzerverlauf, der bis zum Original zurückverfolgt wurde. `sessionId`
Nach Abschluss der Umschulung basieren die Empfehlungen auf Aktivitäten, die sowohl von den anonymen Ereignissen als auch `sessionId` von allen Ereignissen, die bis zu ihren Ereignissen verfolgt wurden. `userId`
**Anmerkung**
Wenn Ihr Benutzer kein Konto erstellt und Sie möchten, dass Amazon Personalize die Daten beim Training verwendet, können Sie das `sessionId` als Ereignis `userId` verwenden. Wenn der Benutzer jedoch irgendwann ein Konto erstellt, können Sie die Ereignisse aus seinem anonymen Surfen nicht mit seinem neuen `userId` Konto verknüpfen.
## Event-Tracking-Dienste von Drittanbietern
Die folgenden Kundendatenplattformen (CDPs) können Ihnen helfen, Ereignisdaten aus Ihrer Anwendung zu sammeln und an Amazon Personalize zu senden.
+ **Amplitude** — Sie können Amplitude verwenden, um Benutzeraktionen zu verfolgen und so das Verhalten Ihrer Benutzer besser zu verstehen. Informationen zur Verwendung von Amplitude und Amazon Personalize finden Sie im folgenden Blogbeitrag des AWS Partner Network (APN): [Measuring the Effectiveness of Personalization with Amplitude and](https://aws.amazon.com/blogs/apn/measuring-the-effectiveness-of-personalization-with-amplitude-and-amazon-personalize/) Amazon Personalize.
+ **Segment** — Sie können Segment verwenden, um Ihre Daten an Amazon Personalize zu senden. Weitere Informationen zur Integration von Segment mit Amazon Personalize finden Sie unter [Amazon Personalize](https://segment.com/docs/connections/destinations/catalog/amazon-personalize/) Destination.
## Beispielimplementierungen
**Ein Beispiel für ein Jupyter-Notizbuch, das zeigt, wie Amazon Personalize verwendet wird, um auf das Echtzeitverhalten von Benutzern zu reagieren, die einen Event Tracker und den [PutEvents](API_UBS_PutEvents.md) Vorgang verwenden, finden Sie unter [2.view\$1campaign\$1and\$1interactions.ipynb im Ordner getting\$1started](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/notebooks/2.View_Campaign_And_Interactions.ipynb) des Repositorys. [amazon-personalize-samples](https://github.com/aws-samples/amazon-personalize-samples)** GitHub
Ein Beispiel, das zeigt, wie Ereignisse von Benutzern gestreamt werden, die mit Empfehlungen interagieren, finden Sie unter [streaming\$1events](https://github.com/aws-samples/amazon-personalize-samples/tree/master/next_steps/operations/streaming_events) im Amazon Personalize Personalize-Beispiel-Repository. GitHub
Ein vollständiges Beispiel, das den Quellcode und die unterstützenden Dateien für die Echtzeitbereitstellung enthält APIs , die sich zwischen Ihren Amazon Personalize Personalize-Ressourcen und Client-Anwendungen befinden, finden Sie unter [Real-Time Personalization APIs](https://github.com/aws-samples/personalization-apis) im AWS GitHub Beispiel-Repository. Dieses Projekt beinhaltet die Implementierung von Folgendem:
+ Erfassung von Benutzerkontext und Benutzerereignissen
+ Zwischenspeichern von Antworten
+ Dekorationsempfehlungen auf der Grundlage von Artikelmetadaten
+ A/B-Tests
+ API-Authentifizierung