Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Registro de los eventos en tiempo real para influir en las recomendaciones
Un *evento* es una interacción entre un usuario y el catálogo. Puede ser una interacción con un *elemento*, como un usuario que compra un artículo o ve un vídeo, o se puede realizar una *acción*, como solicitar una tarjeta de crédito o registrarse en un programa de miembros.
Amazon Personalize puede hacer recomendaciones basadas únicamente en datos de eventos en tiempo real, únicamente en datos históricos de eventos o en una combinación de ambos. Registre los eventos en tiempo real a medida que los clientes interactúan con las recomendaciones. De esta forma, se construyen los datos de las interacciones y se mantienen actualizados. Además, se informa a Amazon Personalize sobre los intereses actuales del usuario, lo que puede mejorar la relevancia de las recomendaciones.
Si el caso de uso o la receta personalizada de su dominio admiten la [personalización en tiempo real](use-case-recipe-features.md#about-real-time-personalization), Amazon Personalize utiliza eventos en tiempo real para actualizar y adaptar las recomendaciones según los intereses cambiantes del usuario.
La forma de registrar los eventos en tiempo real depende del tipo de datos de interacciones que importe:
+ En el caso de las *interacciones de elementos*, se registran eventos en tiempo real con la operación de la API [PutEvents](API_UBS_PutEvents.md). Amazon Personalize adjunta estos datos a los datos [de interacciones de acción](interactions-datasets.md) en el grupo de conjuntos de datos. Para obtener más información, consulte [Registro de eventos de interacción de elemento en tiempo real](recording-item-interaction-events.md).
+ En el caso de las *interacciones de acción*, se registran eventos en tiempo real con la operación de la API [PutActionInteractions](API_UBS_PutActionInteractions.md). Amazon Personalize anexa estos datos al [conjunto de datos de interacciones de acción](action-interactions-datasets.md) en su grupo de conjuntos de datos. Solo las recetas PERSONALIZED\$1ACTIONS utilizan datos de interacciones de acción. Para obtener más información, consulte [Registro de eventos de interacción de acciones en tiempo realRegistro de eventos de interacción de acciones](recording-action-interaction-events.md).
**Topics**
+ [Influencia de los eventos en tiempo real en las recomendaciones](#recorded-events-influence-recommendations)
+ [Registro de eventos de interacción de elemento en tiempo real](recording-item-interaction-events.md)
+ [Registro de eventos de interacción de acciones en tiempo real](recording-action-interaction-events.md)
+ [Registro de eventos para usuarios anónimos](#recording-anonymous-user-events)
+ [Servicios de seguimiento de eventos de terceros](#record-events-third-parties)
+ [Implementaciones de ejemplo](#recording-events-sample-architecture)
## Influencia de los eventos en tiempo real en las recomendaciones
Si su receta admite la personalización en tiempo real, después de crear un recomendador o una campaña personalizada, Amazon Personalize utiliza los nuevos datos de eventos registrados para los elementos o acciones existentes segundos después de la importación. Los siguientes casos de uso y recetas permiten la personalización en tiempo real:
+ [Recomendaciones (caso de uso de ECOMMERCE)](ECOMMERCE-use-cases.md#recommended-for-you-use-case)
+ [Mejores opciones (caso de uso de VIDEO\$1ON\$1DEMAND)](VIDEO_ON_DEMAND-use-cases.md#top-picks-use-case)
+ [Receta User-Personalization-v2](native-recipe-user-personalization-v2.md)
+ [Receta User-Personalization](native-recipe-new-item-USER_PERSONALIZATION.md)
+ [Receta Personalized-Ranking-v2](native-recipe-personalized-ranking-v2.md)
+ [Receta Personalized-Ranking](native-recipe-search.md)
+ [Next-Best-Action receta](native-recipe-next-best-action.md)
Si utiliza la receta Trending-Now, Amazon Personalize tiene en cuenta automáticamente los elementos de los datos de nuevos eventos en intervalos configurables. No tiene que crear una nueva versión de la solución. Para obtener más información, consulte [Receta Trending-Now](native-recipe-trending-now.md).
Si el elemento, la acción o el usuario del evento es nuevo, la forma en que Amazon Personalize utilice los datos dependerá de su caso de uso o receta. Para obtener más información, consulte [Actualización de datos en conjuntos de datos después del entrenamiento](updating-datasets.md).
# Registro de eventos de interacción de elemento en tiempo real
Un *evento de interacción de elementos* es una interacción entre un usuario y un elemento del catálogo. Por ejemplo, un usuario que compra zapatos o ve una película.
Registre eventos de interacción de elementos en tiempo real al mostrar recomendaciones de elementos a los clientes. De esta forma, se construyen los datos de las interacciones y se mantienen actualizados. Además, se informa a Amazon Personalize sobre los intereses actuales del usuario, lo que puede mejorar la relevancia de las recomendaciones.
Los eventos de interacción de elementos se registran con la operación de la API [PutEvents](API_UBS_PutEvents.md). Amazon Personalize anexa los datos del evento al *conjunto de datos de interacciones de elementos* en su grupo de conjuntos de datos. Si registra dos eventos con exactamente la misma marca de tiempo y propiedades idénticas, Amazon Personalize solo conserva uno de ellos. Puede grabar los eventos de interacción entre elementos mediante AWS Amplify o AWS Command Line Interface ()AWS CLI. AWS SDKs
Si usa Apache Kafka, puede utilizar el *conector Kafka para Amazon Personalize* a fin de transmitir interacciones de elementos en tiempo real a Amazon Personalize. Para obtener más información, consulte [Kafka Connector for Amazon Personalize](https://github.com/aws/personalize-kafka-connector/blob/main/README.md) en el repositorio de *personalize-kafka-connector*Github.
AWS Amplify incluye una JavaScript biblioteca para grabar eventos de interacción de elementos desde aplicaciones de cliente web y una biblioteca para grabar eventos en el código del servidor. Para obtener más información, consulte [Documentación de Amplify](https://docs.amplify.aws/).
**Topics**
+ [Requisitos para registrar eventos de interacción de elementos y entrenar un modelo](#recording-events-requirements)
+ [Creación de un rastreador de eventos de interacción de elementos](event-get-tracker.md)
+ [Registro de un solo evento de interacción de elementos](putevents-example.md)
+ [Registro de varios eventos de interacción de elementos con datos de valores de eventos](recording-events-example-event-value.md)
+ [Registro de eventos de interacción de elemento con datos de impresiones](putevents-including-impressions-data.md)
+ [Informes de atribución y métricas de eventos](event-metrics.md)
## Requisitos para registrar eventos de interacción de elementos y entrenar un modelo
Para registrar eventos de interacción de elementos, necesita lo siguiente:
+ Un grupo de conjuntos de datos que incluya un conjunto de datos `Item interactions`, que puede estar vacío. Si ha realizado los procedimientos de la guía de [Tutoriales de introducción](getting-started.md), puede utilizar el mismo grupo de conjuntos de datos y el conjunto de datos que ha creado. Para obtener información sobre cómo crear un grupo de conjuntos de datos y un conjunto de datos, consulte [Importación de datos de entrenamiento directamente a conjuntos de datos de Amazon Personalize](import-data.md).
+ Un rastreador de eventos.
+ Una llamada a la operación de la API [PutEvents](API_UBS_PutEvents.md).
+ Si utiliza una AWS Lambda función para llamar a la PutEvents operación, el rol de ejecución de la función debe tener permiso para realizar la `personalize:PutEvents` acción con el comodín `*` en el `Resource` elemento.
Puede empezar con un conjunto de datos de interacciones de elementos vacío y, cuando haya registrado suficientes datos, entrenar el modelo utilizando únicamente los nuevos eventos registrados. Para todos los casos de uso (grupos de conjuntos de datos de dominio) y recetas (grupos de recetas personalizadas), sus datos de interacciones deben tener lo siguiente antes del entrenamiento:
+ Como mínimo, 1000 registros de interacciones de elementos de los usuarios que interactúan con los elementos de su catálogo. Estas interacciones pueden provenir de importaciones masivas, de eventos transmitidos o ambos.
+ Al menos 25 usuarios únicos IDs con al menos dos interacciones entre elementos para cada uno.
Para obtener recomendaciones de calidad, le sugerimos que tenga al menos 50 000 interacciones de elementos de al menos 1000 usuarios, con dos o más interacciones de elementos cada uno.
# Creación de un rastreador de eventos de interacción de elementos
Antes de poder registrar eventos de interacción de elementos, debe crear un rastreador de eventos de este tipo. Un *rastreador de eventos* dirige los datos de eventos nuevos al *conjunto de datos de interacciones de elementos* de su grupo de conjuntos de datos.
Puede crear un rastreador de eventos con la consola de Amazon Personalize o la operación de la API [CreateEventTracker](API_CreateEventTracker.md). Debe pasar como parámetro el nombre de recurso de Amazon (ARN) del grupo de conjuntos de datos que contiene el conjunto de datos de interacciones de elementos de destino. Para obtener instrucciones sobre cómo crear un rastreador de eventos con la consola de Amazon Personalize, consulte [Creación de un rastreador de eventos (consola)](importing-interactions.md#event-tracker-console).
Un rastreador de eventos incluye un *identificador de seguimiento*, que se transfiere como parámetro cuando se utiliza la [PutEvents](https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html)operación. A continuación, Amazon Personalize anexa los datos del nuevo evento al conjunto de datos de interacciones de elementos del grupo de conjuntos de datos que especifique en el rastreador de eventos.
**nota**
Solo puede crear un rastreador de eventos de interacciones de elementos para un grupo de conjuntos de datos.
------
#### [ 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'])
```
Se muestran el ARN del rastreador de eventos y el ID de seguimiento, por ejemplo:
```
{
"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
```
Se muestran el ARN del rastreador de eventos y el ID de seguimiento, por ejemplo:
```
{
"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;
}
```
------
# Registro de un solo evento de interacción de elementos
Después de crear un *conjunto de datos de interacciones de elementos* y un [rastreador de eventos](event-get-tracker.md) para su grupo de conjuntos de datos, estará listo para registrar los eventos de interacción de elementos. En el ejemplo siguiente se muestra una operación `PutEvents` que pasa un evento de interacción de elementos. Se muestra el esquema correspondiente, junto con una fila de ejemplo del conjunto de datos de interacciones de elementos.
La aplicación genera un `sessionId` único cuando un usuario visita por primera vez su sitio web o utiliza su aplicación. Debe usar el mismo `sessionId` en todos los eventos de la sesión. Amazon Personalize usa `sessionId` para asociar eventos con el usuario antes de que inicie sesión (es anónimo). Para obtener más información, consulte [Registro de eventos para usuarios anónimos](recording-events.md#recording-anonymous-user-events).
La lista de eventos es una matriz de objetos [Event](API_UBS_Event.md). Se requiere `eventType` para cada evento. Si no tiene datos de tipo de evento, puede proporcionar un valor de marcador de posición para cumplir el requisito.
`trackingId` proviene del rastreador de eventos que creó en [Creación de un rastreador de eventos de interacción de elementos](event-get-tracker.md). Los parámetros `userId`, `itemId` y `sentAt` se asignan a los campos USER\$1ID, ITEM\$1ID y TIMESTAMP de un conjunto de datos `Interactions` histórico correspondiente. Para obtener más información, consulte [Creación de archivos JSON de esquema para los esquemas de Amazon Personalize](how-it-works-dataset-schema.md).
**Columnas del conjunto de datos correspondientes**
```
Dataset columns: USER_ID, ITEM_ID, TIMESTAMP, EVENT_TYPE
Example data: user123, item-xyz, 1543631760, click
```
**Ejemplo de código**
------
#### [ 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());
}
}
```
------
# Registro de varios eventos de interacción de elementos con datos de valores de eventos
Después de crear un *conjunto de datos de interacciones de elementos* y un [rastreador de eventos](event-get-tracker.md) para su grupo de conjuntos de datos, estará listo para registrar los eventos de interacción de elementos. En el ejemplo siguiente se muestra cómo registrar varios eventos de interacción de elementos con diferentes tipos y valores de eventos.
Al configurar una solución, si su *conjunto de datos de interacciones de elementos* incluye los campos EVENT\$1TYPE y EVENT\$1VALUE, puede establecer un valor específico como umbral para excluir registros del entrenamiento. Para obtener más información, consulte [Elección de los datos de interacciones de elementos utilizados para el entrenamiento](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**
Las claves de propiedades utilizan nombres con la inicial en minúsculas que coinciden con los campos del esquema Interactions. Por ejemplo, si el campo “NUM\$1RATINGS” está definido en el esquema de interacciones, la clave de la propiedad debería ser `numRatings`.
# Registro de eventos de interacción de elemento con datos de impresiones
Si usa la [User-Personalization](native-recipe-new-item-USER_PERSONALIZATION.md) receta o agrega el campo IMPRESIONES a su esquema para un conjunto de datos de un grupo de conjuntos de datos de dominio, puede registrar los datos de impresiones en su PutEvents operación. Las impresiones son listas de elementos que estaban visibles para un usuario cuando interactuaba con un elemento concreto (por ejemplo, al hacer clic o verlo). Amazon Personalize utiliza los datos de impresiones para guiar la exploración, donde las recomendaciones incluyen elementos con menos interacciones, datos o relevancia. Para obtener información sobre las impresiones *implícitas* y *explícitas* que Amazon Personalize puede modelar, consulte [Datos de impresiones](interactions-datasets.md#interactions-impressions-data).
**importante**
Si proporciona datos de impresiones implícitas y explícitas contradictorios en sus solicitudes de `PutEvents`. Amazon Personalize utiliza las impresiones explícitas de forma predeterminada.
Para registrar las recomendaciones de Amazon Personalize que muestra a sus usuarios como datos de impresiones, incluya `recommendationId` en su solicitud [PutEvents](API_UBS_PutEvents.md) y Amazon Personalize obtiene las impresiones implícitas en función de los datos de sus recomendaciones.
Para registrar manualmente los datos de impresiones de un evento, enumere las impresiones en el parámetro de entrada `impression` del comando [PutEvents](API_UBS_PutEvents.md). En el siguiente ejemplo de código se muestra cómo incluir un `recommendationId` y un `impression` en una PutEvents operación con el SDK para Python (Boto3) o el SDK para Java 2.x. Si incluyes ambos, Amazon Personalize utiliza las impresiones explícitas de forma predeterminada.
------
#### [ 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 ]
Utilice el siguiente método `putEvents` para registrar un evento con datos de impresiones y un recommendationId. Para el parámetro de impresiones, pasa la lista de ItemIDs como. 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());
}
}
```
------
# Informes de atribución y métricas de eventos
Para supervisar el tipo y la cantidad de eventos enviados a Amazon Personalize, utilice CloudWatch las métricas de Amazon. Para obtener más información, consulte [Supervisión de Amazon Personalize con Amazon CloudWatch](personalize-monitoring.md).
Para generar CloudWatch informes que muestren el impacto de las recomendaciones, cree una atribución métrica y registre las interacciones de los usuarios con recomendaciones en tiempo real. Para obtener información sobre cómo crear una atribución de métricas, consulte. [Medición del impacto de las recomendaciones de Amazon Personalize](measuring-recommendation-impact.md)
Para cada evento, incluya el ID de recomendación de las recomendaciones que mostró al usuario. O incluya el origen del evento, como un tercero. Importe estos datos para comparar diferentes campañas, recomendadores y terceros. Puede importar como máximo 100 fuentes de atribución de eventos.
+ Si proporciona `recommendationId`, Amazon Personalize determina automáticamente la campaña o el recomendador de origen y lo identificará en los informes de una columna EVENT\$1ATTRIBUTION\$1SOURCE.
+ Si proporciona ambos atributos, Amazon Personalize utilizará únicamente `eventAttributionSource`.
+ Si no proporciona un origen, Amazon Personalize etiqueta el origen `SOURCE_NAME_UNDEFINED` en los informes.
El siguiente código muestra cómo proporcionar una `eventAttributionSource` para un evento en una PutEvents operación.
```
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)
```
El código siguiente muestra cómo proporcionar un `recommendationId` para un evento en una PutEvents operación.
```
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)
```
# Registro de eventos de interacción de acciones en tiempo real
Un evento de *interacción de acciones* es una interacción entre un usuario y una *acción*. Por ejemplo, un usuario que se inscribe en un programa para miembros o que solicita una tarjeta de crédito.
Si usa una receta personalizada PERSONALIZED\$1ACTIONS, registre los eventos de interacción de acciones en tiempo real a medida que sus clientes interactúan con las recomendaciones de acción. De esta forma, se construyen los datos de las interacciones y se mantienen actualizados. También se informa a Amazon Personalize sobre los intereses actuales del usuario, lo que puede mejorar la relevancia de las recomendaciones. Solo las recetas personalizadas PERSONALIZED\$1ACTIONS utilizan datos de interacción de acciones.
Los eventos de interacción de acciones se registran con la operación de la API [PutActionInteractions](API_UBS_PutActionInteractions.md). Amazon Personalize anexa estos datos al [conjunto de datos de interacciones de acción](action-interactions-datasets.md) en su grupo de conjuntos de datos.
Un evento de interacción de acciones debe tener un atributo de tipo de evento, que puede ser uno de los siguientes:
+ Realizado: registre los eventos como *Realizado* cuando un usuario realice una acción recomendada.
+ No realizado: registre los eventos como *No realizado* cuando el usuario decida deliberadamente no realizar la acción después de verla. Por ejemplo, si elige *No* al mostrarle la acción. Los eventos de tipo *No realizado* pueden indicar que el cliente no está interesado en la acción.
+ Visto: registre los eventos como *Visto* cuando muestre una acción al usuario antes de que tome la decisión de realizarla o no. Amazon Personalize utiliza los eventos *Visto* para obtener información sobre los intereses de los usuarios. Por ejemplo, si un usuario ve una acción pero no la realiza, puede que al usuario no le interese esta acción en el futuro.
Puede grabar eventos en tiempo real con AWS SDKs, o AWS Command Line Interface (AWS CLI). Si registra dos eventos con exactamente la misma marca de tiempo y propiedades idénticas, Amazon Personalize solo conserva uno de ellos.
**Topics**
+ [Requisitos para registrar eventos de interacción de acciones](#recording-action-interaction-requirements)
+ [Búsqueda del ID de su rastreador de eventos de interacción de acciones](action-interaction-tracker-id.md)
+ [Registro de un solo evento de interacción de acciones](record-single-action-interaction.md)
+ [Registro de varios eventos de interacción de acciones](recording-multiple-action-interactions.md)
## Requisitos para registrar eventos de interacción de acciones
Para registrar eventos de interacción de acciones en tiempo real, necesita lo siguiente:
+ Un grupo de conjuntos de datos que incluya un `Action interactions dataset`, que puede estar vacío. Para obtener información sobre cómo crear un grupo de conjuntos de datos y un conjunto de datos, consulte [Importación de datos de entrenamiento directamente a conjuntos de datos de Amazon Personalize](import-data.md).
+ ID de su rastreador de eventos. Este identificador se especifica en la PutActionInteractions operación. Cuando crea un conjunto de datos de interacciones de acción, Amazon Personalize crea un rastreador de eventos de las interacciones de acción de forma automática. Para obtener más información, consulte [Búsqueda del ID de su rastreador de eventos de interacción de acciones](action-interaction-tracker-id.md).
+ Una llamada a la operación [PutActionInteractions](API_UBS_PutActionInteractions.md).
# Búsqueda del ID de su rastreador de eventos de interacción de acciones
Cuando crea un conjunto de datos de interacciones de acción, Amazon Personalize crea un rastreador de eventos de las *interacciones de acción* de forma automática. El ID del rastreador se especifica en la operación de la PutActionInteractions API. Amazon Personalize lo usa para dirigir los nuevos datos al *conjunto de datos de interacciones de acción* en su grupo de conjuntos de datos.
Puede encontrar el ID del rastreador de eventos en la página de detalles del conjunto de datos de interacciones de acción en la consola de Amazon Personalize. Y puedes encontrar el ID llamando a la operación de la DescribeDataset API. El siguiente código Python imprime el ID de seguimiento de un conjunto de datos de interacciones de acción.
```
import boto3
personalize = boto3.client(service_name='personalize')
response = personalize.describe_dataset(
datasetArn="Action interactions dataset ARN"
)
print(response['trackingId'])
```
# Registro de un solo evento de interacción de acciones
Después de crear un conjunto de datos de interacciones de acción, ya puede registrar los eventos de interacción de acciones con la operación [PutActionInteractions](API_UBS_PutActionInteractions.md). En el siguiente código se muestra una operación `PutActionInteractions` que pasa un evento TAKEN. Puede registrar este evento cuando muestre a un usuario recomendaciones de Amazon Personalize y este realice alguna acción, como solicitar su tarjeta de crédito.
`actionInteractions`Es un conjunto de ActionInteraction objetos. El valor `trackingId` proviene del rastreador de eventos que Amazon Personalize generó al crear el usuario el conjunto de datos de interacciones de acción. Para obtener más información, consulte [Búsqueda del ID de su rastreador de eventos de interacción de acciones](action-interaction-tracker-id.md).
La aplicación genera un `sessionId` único cuando un usuario visita por primera vez su sitio web o utiliza su aplicación. Debe usar el mismo `sessionId` en todos los eventos de la sesión. Amazon Personalize usa `sessionId` para asociar eventos con el usuario antes de que inicie sesión (es anónimo). Para obtener más información, consulte [Registro de eventos para usuarios anónimos](recording-events.md#recording-anonymous-user-events).
Los parámetros `userId`, `actionId` y `sentAt` se asignan a los campos USER\$1ID, ACTION\$1ID, EVENT\$1TYPE y TIMESTAMP del conjunto de datos de interacciones de acción.
**Conjunto de datos de interacciones de acción correspondiente**
```
USER_ID, ACTION_ID, TIMESTAMP, EVENT_TYPE
user123, action-xyz, 1543631760, TAKEN
```
**Ejemplo de código**
------
#### [ 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'
}]
)
```
------
# Registro de varios eventos de interacción de acciones
El código siguiente muestra cómo registrar varios eventos de interacción de acciones para el mismo usuario con el mismo valor de sessionId.
**Conjunto de datos de interacciones de acción correspondiente**
```
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'
}]
)
```
------
## Registro de eventos para usuarios anónimos
**importante**
Si no registra al menos un evento con un usuario `sessionId` y `userId` para un usuario, Amazon Personalize no utilizará la actividad rastreada únicamente hasta `sessionId` durante el entrenamiento. Y una vez finalizado el entrenamiento, las recomendaciones ya no se basarán en la actividad rastreada hasta `sessionId`. Esto creará un historial de eventos continuo para los ID de usuario antes y después de que inicien sesión.
Puede registrar eventos de interacción de elementos o de acciones para los usuarios antes de que creen una cuenta. Registre eventos para usuarios anónimos para crear un historial de eventos continuo con eventos anteriores y posteriores al inicio de sesión. Esto proporciona a Amazon Personalize más datos de interacciones sobre el usuario, lo que puede ayudar a generar recomendaciones más relevantes.
Para registrar eventos de usuarios anónimos (usuarios que no han iniciado sesión), especifique solo un `sessionId` para cada evento. La aplicación genera un `sessionId` único cuando un usuario visita por primera vez su sitio web o utiliza su aplicación. Debe usar el mismo `sessionId` en todos los eventos de la sesión. Amazon Personalize usa el `sessionId` para asociar eventos con el usuario antes de que inicie sesión.
Amazon Personalize no utiliza eventos de usuarios anónimos durante el entrenamiento hasta que los asocie a `userId`. Para obtener más información, consulte [Creación de un historial de eventos continuo para usuarios anónimos](#recording-events-building-continuous-event-history).
Para proporcionar una [personalización en tiempo real](use-case-recipe-features.md#about-real-time-personalization) a los usuarios anónimos, especifique el SessionID como el UserID en su solicitud o solicitud. [GetRecommendations](API_RS_GetRecommendations.md) GetActionRecommendations
+ Para ver ejemplos de código que muestran cómo registrar eventos de interacción de elementos con la PutEvents operación y un SessionID y un UserID, consulte. [Registro de un solo evento de interacción de elementos](putevents-example.md)
+ Para ver ejemplos de código que muestran cómo registrar eventos de interacción de acciones con la PutActionInteractions operación y un SessionID y un UserID, consulte. [Registro de un solo evento de interacción de acciones](record-single-action-interaction.md)
### Creación de un historial de eventos continuo para usuarios anónimos
Para crear un historial de eventos para un usuario anónimo y hacer que Amazon Personalize utilice sus eventos durante el entrenamiento, registre al menos un evento con `sessionId` y `userId`. A continuación, puede registrar cualquier número de eventos para `userId`. Después de comenzar a proporcionar `userId`, `sessionId` puede cambiar. Durante el siguiente reentrenamiento completo, Amazon Personalize asocia `userId` con el historial de usuarios anónimos rastreado al `sessionId` original.
Una vez finalizado el reentrenamiento, las recomendaciones se basarán en la actividad rastreada tanto de `sessionId` de los eventos anónimos como de cualquier evento rastreado hasta su `userId`.
**nota**
Si el usuario no ha creado una cuenta y quiere que Amazon Personalize utilice los datos durante el entrenamiento, puede utilizar `sessionId` como `userId` en los eventos. Sin embargo, si el usuario finalmente crea una cuenta, no podrá asociar los eventos de su navegación anónima con el nuevo `userId`.
## Servicios de seguimiento de eventos de terceros
Las siguientes plataformas de datos de clientes (CDPs) pueden ayudarle a recopilar datos de eventos de su solicitud y enviarlos a Amazon Personalize.
+ **Amplitude**: puede utilizar Amplitude para realizar un seguimiento de las acciones de los usuarios y así comprender su comportamiento. Para obtener información sobre el uso de Amplitude y Amazon Personalize, consulte la siguiente entrada del blog de la red de socios (APN) de AWS : [Medición de la eficacia de la personalización con Amplitude y Amazon Personalize](https://aws.amazon.com/blogs/apn/measuring-the-effectiveness-of-personalization-with-amplitude-and-amazon-personalize/).
+ **Segment**: puede usar Segment para enviar sus datos a Amazon Personalize. Para obtener más información sobre la integración de Segment con Amazon Personalize, consulte [Destino de Amazon Personalize](https://segment.com/docs/connections/destinations/catalog/amazon-personalize/).
## Implementaciones de ejemplo
**Para ver un ejemplo de bloc de notas de Jupyter que muestra cómo usar Amazon Personalize para reaccionar ante el comportamiento en tiempo real de los usuarios que utilizan un rastreador de eventos y la [PutEvents](API_UBS_PutEvents.md) operación, consulte [2.view\$1Campaign\$1and\$1Interactions.ipynb en la carpeta getting\$1started](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/notebooks/2.View_Campaign_And_Interactions.ipynb) del repositorio. [amazon-personalize-samples](https://github.com/aws-samples/amazon-personalize-samples)** GitHub
Para ver un ejemplo que muestre cómo transmitir eventos de usuarios que interactúan con las recomendaciones, consulte [streaming\$1events](https://github.com/aws-samples/amazon-personalize-samples/tree/master/next_steps/operations/streaming_events) en el repositorio de muestras de Amazon Personalize. GitHub
Para ver un ejemplo completo que contiene el código fuente y los archivos auxiliares para la implementación en tiempo real APIs que se encuentran entre los recursos de Amazon Personalize y las aplicaciones cliente, consulte [Personalización APIs en tiempo real](https://github.com/aws-samples/personalization-apis) en el GitHub repositorio de AWS muestras. Este proyecto incluye cómo implementar lo siguiente:
+ Contexto de usuario y recopilación de eventos de usuario
+ Almacenamiento en caché de respuestas
+ Recomendaciones de decoración basadas en los metadatos de los elementos
+ Pruebas A/B
+ Autenticación de API