Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Registrazione di eventi di interazione tra articoli in tempo reale
Un *evento di interazione tra un articolo* è un'interazione tra un utente e un articolo del tuo catalogo. Ad esempio, un utente che acquista scarpe o guarda un film.
Registra gli eventi di interazione con gli articoli in tempo reale mentre mostri ai clienti i consigli sugli articoli. Questo amplia i dati sulle interazioni e li mantiene aggiornati. Inoltre, comunica ad Amazon Personalize gli interessi attuali dell'utente, il che può migliorare la pertinenza dei consigli.
Registri gli eventi di interazione degli elementi con il funzionamento dell'[PutEvents](API_UBS_PutEvents.md)API. Amazon Personalize aggiunge i dati degli eventi al set di dati *sulle interazioni degli elementi nel tuo gruppo di set* di dati. Se registri due eventi con esattamente lo stesso timestamp e proprietà identiche, Amazon Personalize conserva solo uno degli eventi. È possibile registrare gli eventi di interazione con gli elementi utilizzando AWS SDKs, AWS Amplify o (). AWS Command Line Interface AWS CLI
Se usi Apache Kafka, puoi utilizzare il connettore *Kafka per Amazon Personalize per trasmettere le interazioni tra gli articoli in tempo reale ad Amazon Personalize*. Per informazioni, consulta [Kafka Connector per Amazon Personalize](https://github.com/aws/personalize-kafka-connector/blob/main/README.md) nel *personalize-kafka-connector*repository Github.
AWS Amplify include JavaScript una libreria per la registrazione degli eventi di interazione degli elementi dalle applicazioni client Web e una libreria per la registrazione degli eventi nel codice server. Per ulteriori informazioni, consulta la documentazione di [Amplify.](https://docs.amplify.aws/)
**Topics**
+ [Requisiti per la registrazione degli eventi di interazione tra gli elementi e l'addestramento di un modello](#recording-events-requirements)
+ [Creazione di un tracker degli eventi relativi all'interazione tra gli elementi](event-get-tracker.md)
+ [Registrazione di un evento di interazione con un singolo elemento](putevents-example.md)
+ [Registrazione di più eventi di interazione tra elementi con dati sui valori degli eventi](recording-events-example-event-value.md)
+ [Registrazione degli eventi di interazione tra gli elementi con i dati sulle impressioni](putevents-including-impressions-data.md)
+ [Metriche degli eventi e rapporti sull'attribuzione](event-metrics.md)
## Requisiti per la registrazione degli eventi di interazione tra gli elementi e l'addestramento di un modello
Per registrare gli eventi di interazione tra gli elementi, è necessario quanto segue:
+ Un gruppo di set di dati che include un set di dati `Item interactions` che può essere vuoto. Se hai seguito la [Tutorial introduttivi](getting-started.md) guida, puoi utilizzare lo stesso gruppo di set di dati e lo stesso set di dati che hai creato. Per informazioni sulla creazione di un gruppo di set di dati e di un set di dati, vedere. [Importazione di dati di formazione nei set di dati di Amazon Personalize](import-data.md)
+ Un tracciatore di eventi.
+ Una chiamata all'operazione [PutEvents](API_UBS_PutEvents.md) API.
+ Se si utilizza una AWS Lambda funzione per chiamare l' PutEvents operazione, il ruolo di esecuzione della funzione deve disporre del permesso di eseguire l'`personalize:PutEvents`azione con il carattere jolly `*` nell'`Resource`elemento.
Potete iniziare con un set di dati sulle interazioni tra oggetti vuoto e, una volta registrati abbastanza dati, addestrare il modello utilizzando solo i nuovi eventi registrati. Per tutti i casi d'uso (gruppi di set di dati di dominio) e le ricette (gruppi di set di dati personalizzati), i dati di interazione devono avere quanto segue prima dell'addestramento:
+ Almeno 1000 record di interazioni tra articoli da parte degli utenti che interagiscono con gli articoli del tuo catalogo. Queste interazioni possono derivare da importazioni in blocco, eventi in streaming o entrambi.
+ Almeno 25 utenti unici IDs con almeno due interazioni tra elementi per ciascuno.
Per consigli sulla qualità, ti consigliamo di avere almeno 50.000 interazioni tra articoli da parte di almeno 1.000 utenti con due o più interazioni con gli articoli ciascuna.
# Creazione di un tracker degli eventi relativi all'interazione tra gli elementi
Prima di poter registrare gli eventi di interazione tra gli articoli, devi creare un tracker degli eventi di interazione tra articoli. Un *tracker di eventi* indirizza i nuovi dati degli eventi al set di dati *sulle interazioni degli elementi nel gruppo di set* di dati.
Puoi creare un tracker di eventi con la console Amazon Personalize o [CreateEventTracker](API_CreateEventTracker.md) il funzionamento dell'API. Passi come parametro l'Amazon Resource Name (ARN) del gruppo di set di dati che contiene il set di dati sulle interazioni degli articoli di destinazione. Per istruzioni sulla creazione di un tracker di eventi utilizzando la console Amazon Personalize, consulta. [Creazione di un tracker di eventi (console)](importing-interactions.md#event-tracker-console)
Un tracker di eventi include un *ID di tracciamento*, che passi come parametro quando utilizzi l'operazione. [PutEvents](https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html) Amazon Personalize aggiunge quindi i nuovi dati sugli eventi al set di dati sulle interazioni tra oggetti del gruppo di set di dati specificato nel tracker degli eventi.
**Nota**
Puoi creare un solo tracker di eventi di interazione tra elementi per un gruppo di set di dati.
------
#### [ 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'])
```
L'ARN del tracker di eventi e l'ID di tracciamento vengono visualizzati, ad esempio:
```
{
"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
```
L'ARN del tracker di eventi e l'ID di tracciamento vengono visualizzati, ad esempio:
```
{
"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;
}
```
------
# Registrazione di un evento di interazione con un singolo elemento
Dopo aver creato un *set di dati sulle interazioni tra elementi* e un [tracker di eventi](event-get-tracker.md) per il gruppo di set di dati, sei pronto per registrare gli eventi di interazione tra gli elementi. L'esempio seguente mostra un'`PutEvents`operazione che trasmette un evento di interazione tra elementi. Viene mostrato lo schema corrispondente, insieme a una riga di esempio del set di dati Item interaction.
L'applicazione genera un codice univoco `sessionId` quando un utente visita per la prima volta il sito Web o utilizza l'applicazione. È necessario utilizzare lo stesso `sessionId` in tutti gli eventi durante la sessione. Amazon Personalize lo utilizza `sessionId` per associare gli eventi all'utente prima che effettui l'accesso (è anonimo). Per ulteriori informazioni, consulta [Registrazione di eventi per utenti anonimi](recording-events.md#recording-anonymous-user-events).
L'elenco degli eventi è un array di oggetti [Event](API_UBS_Event.md). Un `eventType` è obbligatorio per ogni evento. Se non disponi di dati sul tipo di evento, puoi fornire un valore segnaposto per soddisfare il requisito.
`trackingId`Viene dal tracker di eventi in cui hai creato. [Creazione di un tracker degli eventi relativi all'interazione tra gli elementi](event-get-tracker.md) I parametri `userId`, `itemId` e `sentAt` sono mappati ai campi USER\$1ID, ITEM\$1ID e TIMESTAMP di un corrispondente set di dati `Interactions` storico. Per ulteriori informazioni, consulta [Creazione di file JSON di schema per schemi Amazon Personalize](how-it-works-dataset-schema.md).
**Colonne corrispondenti del set di dati**
```
Dataset columns: USER_ID, ITEM_ID, TIMESTAMP, EVENT_TYPE
Example data: user123, item-xyz, 1543631760, click
```
**Esempio di codice**
------
#### [ 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());
}
}
```
------
# Registrazione di più eventi di interazione tra elementi con dati sui valori degli eventi
Dopo aver creato un *set di dati sulle interazioni tra elementi* e un [tracker di eventi](event-get-tracker.md) per il gruppo di set di dati, sei pronto per registrare gli eventi di interazione tra elementi. L'esempio seguente mostra come registrare più eventi di interazione tra elementi con diversi tipi di eventi e valori di evento diversi.
Quando configurate una soluzione, se il *set di dati sulle interazioni degli oggetti* include i campi EVENT\$1TYPE e EVENT\$1VALUE, potete impostare un valore specifico come soglia per escludere i record dall'addestramento. Per ulteriori informazioni, consulta [Scelta dei dati di interazione tra gli oggetti utilizzati per l'allenamento](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());
}
}
```
------
**Nota**
Le chiavi delle proprietà usano nomi con notazione a cammello (camel case) che corrispondono ai campi nello schema Interactions. Ad esempio, se il campo 'NUM\$1RATINGS' è definito nello schema Interactions, la chiave di proprietà dovrebbe essere. `numRatings`
# Registrazione degli eventi di interazione tra gli elementi con i dati sulle impressioni
Se usi la [Personalizzazione dell'utente](native-recipe-new-item-USER_PERSONALIZATION.md) ricetta o aggiungi il campo IMPRESSIONS allo schema per un set di dati in un gruppo di set di dati di Domain, puoi registrare i dati sulle impressioni durante l'operazione. PutEvents Le impressioni sono elenchi di elementi che erano visibili a un utente quando interagiva con (ad esempio, faceva clic o guardava) un particolare elemento. Amazon Personalize utilizza i dati sulle impressioni per guidare l'esplorazione, laddove i consigli includono elementi con meno dati o rilevanza sulle interazioni. Per informazioni sulle impressioni *implicite ed esplicite* *che* Amazon Personalize può modellare, consulta. [Dati sulle impressioni](interactions-datasets.md#interactions-impressions-data)
**Importante**
Se fornisci dati di impressione impliciti ed espliciti in conflitto nelle tue `PutEvents` richieste, Amazon Personalize utilizza le impressioni esplicite per impostazione predefinita.
Per registrare i consigli di Amazon Personalize che mostri ai tuoi utenti come dati sulle impressioni, includili `recommendationId` nella [PutEvents](API_UBS_PutEvents.md) richiesta e Amazon Personalize ricava le impressioni implicite in base ai dati delle tue raccomandazioni.
Per registrare manualmente i dati sulle impressioni per un evento, elenca le impressioni nel parametro di input del comando. [PutEvents](API_UBS_PutEvents.md) `impression` Il seguente esempio di codice mostra come includere a `recommendationId` e an `impression` in un' PutEvents operazione con SDK for Python (Boto3) o SDK for Java 2.x. Se includi entrambi, Amazon Personalize utilizza le impressioni esplicite per impostazione predefinita.
------
#### [ 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 ]
Utilizza il seguente `putEvents` metodo per registrare un evento con dati sulle impressioni e un RecommendationID. Per il parametro impressions, passa l'elenco di ItemID come. 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());
}
}
```
------
# Metriche degli eventi e rapporti sull'attribuzione
Per monitorare il tipo e il numero di eventi inviati ad Amazon Personalize, utilizza i parametri di Amazon CloudWatch . Per ulteriori informazioni, consulta [Monitoraggio di Amazon Personalize con Amazon CloudWatch](personalize-monitoring.md).
Per generare CloudWatch report che mostrino l'impatto dei consigli, crea un'attribuzione metrica e registra le interazioni degli utenti con consigli in tempo reale. Per informazioni sulla creazione di un'attribuzione metrica, consulta. [Misurazione dell'impatto dei consigli di Amazon Personalize](measuring-recommendation-impact.md)
Per ogni evento, includi l'ID dei consigli che hai mostrato all'utente. Oppure includi la fonte dell'evento, ad esempio una terza parte. Importa questi dati per confrontare diverse campagne, consigli e terze parti. Puoi importare al massimo 100 fonti di attribuzione degli eventi.
+ Se fornisci un`recommendationId`, Amazon Personalize determina automaticamente la campagna o il programma di riferimento di origine e lo identifica nei report in una colonna EVENT\$1ATTRIBUTION\$1SOURCE.
+ Se fornisci entrambi gli attributi, Amazon Personalize utilizza solo. `eventAttributionSource`
+ Se non fornisci una fonte, Amazon Personalize etichetta la fonte `SOURCE_NAME_UNDEFINED` nei report.
Il codice seguente mostra come fornire un messaggio `eventAttributionSource` per un evento in un' PutEvents operazione.
```
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)
```
Il codice seguente mostra come fornire un valore `recommendationId` per un evento in un' PutEvents operazione.
```
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)
```