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.
# Medición del impacto de las recomendaciones con una atribución de métricas
Para medir el impacto de las recomendaciones de elementos, puede crear una atribución de métricas. Una *atribución de métricas* crea informes basados en los datos e interacciones de elementos que importe, así como en las métricas que especifique. Por ejemplo, la duración total de las películas vistas por los usuarios o el número total de eventos de clic. Amazon Personalize agrega los cálculos en un período de 15 minutos. Para los datos de interacciones transmitidos y los datos masivos incrementales, Amazon Personalize envía automáticamente informes de métricas a Amazon CloudWatch. Para los datos masivos, puede optar por publicar informes en un bucket de Amazon S3.
Para cada interacción que importe, incluya datos de origen para comparar diferentes campañas, generadores de recomendaciones y terceros. Puede incluir el ID de recomendación de las recomendaciones que mostró al usuario o al origen de eventos, por ejemplo, a un tercero.
Por ejemplo, es posible que tenga una aplicación de streaming de vídeo que muestre recomendaciones de películas de dos generadores de recomendaciones diferentes de Amazon Personalize. Si desea ver qué generador de recomendaciones genera el mayor número de eventos de visualización, puede crear una atribución de métricas que realice un seguimiento del número total de eventos de visualización. A continuación, podría registrar los eventos de visualización a medida que los usuarios interactúen con las recomendaciones e incluir `recommendationId` en cada evento. Amazon Personalize utiliza el `recommendationId` para identificar a cada generador de recomendaciones. A medida que grabas los eventos, puedes ver los totales de los eventos vistos acumulados cada 15 minutos para los dos usuarios que realizaron la recomendación. CloudWatch Para ver ejemplos de código que muestran cómo incluir un `recommendationId` o un `eventAttributionSource` para un evento, consulte [Informes de atribución y métricas de eventos](event-metrics.md).
**Topics**
+ [Directrices y requisitos para una atribución de métricas](metric-attribution-requirements.md)
+ [Creación de una atribución de métricas de Amazon Personalize](creating-metric-attribution.md)
+ [Actualización de una atribución de métricas de Amazon Personalize](updating-metric-attribution.md)
+ [Eliminación de una atribución de métricas de Amazon Personalize](deleting-metric-attribution.md)
+ [Visualización de gráficos de datos métricos en CloudWatch](metric-attribution-results-cloudwatch.md)
+ [Publicación de informes de atribución de métricas en Amazon S3](metric-attribution-results-s3.md)
# Directrices y requisitos para una atribución de métricas
Amazon Personalize comienza a calcular e informar del impacto de las recomendaciones solo después de crear una atribución de métricas. Para crear el historial más completo, le recomendamos que cree una atribución de métricas antes de importar sus datos de interacciones. Al crear un trabajo de importación de conjuntos de datos para un conjunto de datos de interacciones de elementos con la consola de Amazon Personalize, tiene la opción de crear una atribución de métricas en una pestaña nueva. A continuación, puede volver al trabajo de importación para completarlo.
Tras crear una atribución métrica y registrar los eventos o importar datos masivos incrementales, incurrirás en un coste mensual CloudWatch por métrica. Para obtener información sobre CloudWatch los precios, consulta la página de [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/). Para dejar de enviar métricas a CloudWatch, [elimina la atribución de métricas](deleting-metric-attribution.md).
Para ver el impacto de las recomendaciones a lo largo del tiempo, siga importando datos a medida que los clientes interactúen con recomendaciones. Si ya ha importado datos, puede seguir creando una atribución de métricas y empezar a medir el impacto de las recomendaciones. Sin embargo, Amazon Personalize no informará sobre los datos que haya importado antes de crearlos.
A continuación se indican las directrices y los requisitos para generar informes con una atribución de métricas:
+ Debes conceder permiso a Amazon Personalize para acceder a los datos y colocarlos CloudWatch. Para ver ejemplos de políticas, consulte [Dar a Amazon Personalize acceso a CloudWatch](#metric-attribution-cw-permissions).
+ Para publicar métricas en Amazon S3, conceda permiso a Amazon Personalize para escribir en su bucket. También debe proporcionar la ruta del bucket en la atribución de métricas. Para ver ejemplos de políticas, consulte [Concesión de acceso a Amazon Personalize para su bucket de Amazon S3](#metric-attribution-s3-permissions).
+ Para publicar las métricas en CloudWatch, los registros deben tener menos de 14 días de antigüedad. Si sus datos son más antiguos, estos registros no se incluirán en los cálculos ni en los informes.
+ La importación de eventos duplicados (eventos que coinciden exactamente con todos los atributos) puede provocar un comportamiento inesperado, como métricas imprecisas. Recomendamos eliminar los registros duplicados de los datos masivos antes de importarlos, y evitar importar eventos duplicados con la operación `PutEvents`.
+ El conjunto de datos de interacciones de elementos debe tener una columna `EVENT_TYPE`.
+ No puede crear informes de métricas para los datos de un conjunto de datos de interacciones de acción.
+ Puede crear una atribución de métricas como máximo por grupo de conjuntos de datos. Cada atribución de métricas puede tener 10 métricas como máximo.
Para comparar los orígenes, cada evento de interacción debe incluir una `recommendationId` o`eventAttributionSource`. Puede importar como máximo 100 orígenes de atribución de eventos únicos. Para obtener ejemplos de código de `PutEvents`, consulte [Informes de atribución y métricas de eventos](event-metrics.md).
+ 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.
**Topics**
+ [Dar a Amazon Personalize acceso a CloudWatch](#metric-attribution-cw-permissions)
+ [Concesión de acceso a Amazon Personalize para su bucket de Amazon S3](#metric-attribution-s3-permissions)
## Dar a Amazon Personalize acceso a CloudWatch
**importante**
Cuando concedes permisos, Amazon Personalize coloca y valida una pequeña cantidad de datos. CloudWatch Esto conllevará un coste único de menos de 0,30 \$1. Para obtener más información sobre CloudWatch los precios, consulta la página de [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/).
Para dar acceso a Amazon Personalize CloudWatch, adjunta una nueva política AWS Identity and Access Management (IAM) a tu rol de servicio Amazon Personalize que otorgue al rol permiso para CloudWatch usar la `PutMetricData` Acción. La siguiente política de ejemplo concede permisos de `PutMetricData`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
}
```
------
## Concesión de acceso a Amazon Personalize para su bucket de Amazon S3
Para conceder acceso a Amazon Personalize para su bucket de Amazon S3:
+ Asocie una política de IAM a su rol de servicio de Amazon Personalize que conceda al rol permiso para usar la acción `PutObject` en su bucket.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PersonalizeS3BucketAccessPolicy",
"Statement": [
{
"Sid": "PersonalizeS3BucketAccessPolicy",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
+ Asocie una política de buckets a su bucket de salida de Amazon S3 que conceda permiso de principio de Amazon Personalize para usar las acciones de `PutObject`.
Si utilizas AWS Key Management Service (AWS KMS) para el cifrado, debes conceder permiso a Amazon Personalize y a tu rol de servicio Amazon Personalize IAM para usar tu clave. Para obtener más información, consulte [Otorgar permiso a Amazon Personalize para usar tu AWS KMS clave](granting-personalize-key-access.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PersonalizeS3BucketAccessPolicy",
"Statement": [
{
"Sid": "PersonalizeS3BucketAccessPolicy",
"Effect": "Allow",
"Principal": {
"Service": "personalize.amazonaws.com"
},
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
# Creación de una atribución de métricas de Amazon Personalize
**importante**
Tras crear una atribución de métrica y registrar los eventos o importar datos masivos incrementales, incurrirá en un CloudWatch coste mensual por métrica. Para obtener información sobre CloudWatch los precios, consulta la página de [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/). Para dejar de enviar métricas a CloudWatch, [elimina la atribución de métricas](deleting-metric-attribution.md).
Para empezar a generar informes de métricas, debe crear una atribución de métricas e importar los datos de interacciones. Al crear una atribución de métricas, se especifica una lista de tipos de eventos sobre los que informar. Para cada tipo de evento, debe especificar una función que Amazon Personalize aplique a medida que recopila los datos. Entre las funciones disponibles se incluyen `SUM(DatasetType.COLUMN_NAME)` y `SAMPLECOUNT()`.
Por ejemplo, es posible que tenga una aplicación de streaming de vídeo en línea y desee realizar un seguimiento de dos métricas: la tasa de clics para recomendaciones y la duración total de las películas vistas, donde cada vídeo del conjunto de datos de elementos incluye un atributo `LENGTH`. Debería crear una atribución de métricas y añadir dos métricas, cada una de ellas con un tipo de evento y una función. La primera podría ser para el tipo de evento `Click` con una función `SAMPLECOUNT()`. La segunda podría ser para el tipo de evento `Watch` con una función `SUM(Items.LENGTH)`.
Puede aplicar funciones `SUM()` solo a las columnas numéricas de los conjuntos de datos de elementos y de interacciones de elementos. Para aplicar una función `SUM()` a una columna de un conjunto de datos de elementos, primero debe importar los metadatos de los elementos.
Puede crear una atribución de métricas con la consola Amazon Personalize o AWS Command Line Interface los AWS SDK.
**Topics**
+ [Creación de una atribución de métricas (consola)](#create-metric-attribution-console)
+ [Creación de una atribución de métricas (AWS CLI)](#create-metric-attribution-cli)
+ [Creación de una atribución de métricas (AWS SDKs)](#create-metric-attribution-sdk)
## Creación de una atribución de métricas (consola)
Para crear una atribución de métricas con la consola de Amazon Personalize, vaya a la página **Atribución de métricas** y elija **Crear atribución de métricas**. Cuando cree una atribución de métricas, debe especificar una ruta de bucket de Amazon S3 opcional, su rol de servicio de IAM de Amazon Personalize y una lista de métricas sobre las que informar.
Al crear un trabajo de importación de conjuntos de datos de interacciones de elementos con la consola de Amazon Personalize, tiene la opción de crear una atribución de métricas en una pestaña nueva. A continuación, puede volver al trabajo de importación para completarlo. Si ya se encuentra en la página **Configurar atribución de métricas**, puede ir directamente al paso 4.
**Para crear una atribución de métricas**
1. Abre la consola Amazon Personalize en [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e inicia sesión en tu cuenta.
1. Elija su grupo de conjuntos de datos.
1. En el panel de navegación, en **Recursos personalizados**, elija **Atribución de métricas**.
1. En **Detalles de atribución de métricas**, elija **Crear atribución de métricas**.
1. En la página **Configurar atribución de métricas**, asigne un nombre a la atribución de métricas.
1. Si desea publicar métricas en Amazon S3 para la **Ruta de salida de datos de Amazon S3**, especifique el bucket de Amazon S3 de destino. Esto habilita la opción de publicar métricas cada vez que cree un trabajo de importación de conjuntos de datos. Utilice la siguiente sintaxis:
**s3://amzn-s3-demo-bucket/ path>**
1. Si lo utiliza AWS KMS para el cifrado, para el **ARN de la clave de KMS**, introduzca el nombre de recurso de Amazon (ARN) de la clave. AWS KMS Debe conceder permiso a Amazon Personalize y a su rol de servicio de IAM de Amazon Personalize para usar su clave. Para obtener más información, consulte [Otorgar permiso a Amazon Personalize para usar tu AWS KMS clave](granting-personalize-key-access.md).
1. En **Rol de IAM**, elija entre crear un rol de servicio nuevo o usar uno que ya exista. El rol que elija debe tener `PutMetricData` permisos. CloudWatch Si desea publicar en Amazon S3, el rol debe tener permisos de `PutObject` para su bucket de Amazon S3.
Para usar el rol en el que creó[Creación de un rol de IAM para Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), es posible que tenga que añadir políticas para CloudWatch Amazon S3.
Para ver más ejemplos de política, consulte [Dar a Amazon Personalize acceso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) y [Concesión de acceso a Amazon Personalize para su bucket de Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
1. Elija **Siguiente**.
1. En la página **Definir atributos de métricas**, elija cómo definir las métricas. Elija **Crear atributos de métricas** para usar la herramienta del compilador. Elija **Introducir atributos de métrica** para introducir las métricas en formato JSON.
+ Si eliges **Crear atributos de métrica**, proporcione un nombre, un tipo de evento y elija una función para cada métrica. Para las funciones `SUM()`, elija el nombre de la columna. Seleccione **Añadir atributo de métrica** para añadir métricas adicionales.
+ Si elige **Introducir atributos de métricas**, introduzca cada métrica en formato JSON. A continuación se muestra cómo dar formato a una métrica.
```
{
"EventType": "watch",
"MetricName": "MinutesWatchedTracker",
"MetricMathExpression": "SUM(Items.LENGTH)"
}
```
1. Elija **Siguiente**.
1. En la página **Revisar y crear página**, revise los detalles de la nueva atribución de métricas. Para realizar cambios, seleccione **Previous (Anterior)**. Para crear la atribución de métricas, elija **Crear.** Cuando la atribución de métricas esté activa, puede empezar a importar datos y ver los resultados. Para obtener más información acerca de la visualización de resultados, consulte [Visualización de gráficos de datos métricos en CloudWatch](metric-attribution-results-cloudwatch.md). Para obtener información sobre la publicación de resultados en Amazon S3, consulte [Publicación de informes de atribución de métricas en Amazon S3](metric-attribution-results-s3.md).
## Creación de una atribución de métricas (AWS CLI)
El código siguiente muestra cómo crear una atribución de métricas con AWS Command Line Interface. El rol que especifique debe tener `PutMetricData` permisos CloudWatch y, si publica en Amazon S3, `PutObject` permisos para su bucket de Amazon S3. Para usar el rol en el que creó[Creación de un rol de IAM para Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), es posible que tenga que añadir políticas para CloudWatch Amazon S3. Para ver más ejemplos de política, consulte [Dar a Amazon Personalize acceso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) y [Concesión de acceso a Amazon Personalize para su bucket de Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
Para cada métrica, especifique un nombre, un tipo de evento y una expresión (una función). Entre las funciones disponibles se incluyen `SUM(DatasetType.COLUMN_NAME)` y `SAMPLECOUNT()`. Para las funciones SUM(), especifique el tipo de conjunto de datos y el nombre de la columna. Por ejemplo, `SUM(Items.LENGTH)`. Para obtener información acerca de cada parámetro, consulte [CreateMetricAttribution](API_CreateMetricAttribution.md).
```
aws personalize create-metric-attribution \
--name metric attribution name \
--dataset-group-arn dataset group arn \
--metrics-output-config "{\"roleArn\": \"Amazon Personalize service role ARN\", \"s3DataDestination\":{\"kmsKeyArn\":\"kms key ARN\",\"path\":\"s3://amzn-s3-demo-bucket/folder-name/\"}}" \
--metrics "[{
\"eventType\": \"event type\",
\"expression\": \"SUM(DatasetType.COLUMN_NAME)\",
\"metricName\": \"metric name\"
}]"
```
## Creación de una atribución de métricas (AWS SDKs)
El código siguiente muestra cómo crear una atribución de métricas con el SDK para Python (Boto3). El rol que especifique debe tener `PutMetricData` permisos CloudWatch y, si publica en Amazon S3, `PutObject` permisos para su bucket de Amazon S3. Para usar el rol en el que creó[Creación de un rol de IAM para Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), es posible que tenga que añadir políticas para CloudWatch Amazon S3. Para ver más ejemplos de política, consulte [Dar a Amazon Personalize acceso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) y [Concesión de acceso a Amazon Personalize para su bucket de Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
Para cada métrica, especifique un nombre, un tipo de evento y una expresión (una función). Entre las funciones disponibles se incluyen `SUM(DatasetType.COLUMN_NAME)` y `SAMPLECOUNT()`. Para las funciones SUM(), especifique el tipo de conjunto de datos y el nombre de la columna. Por ejemplo, `SUM(Items.LENGTH)`. Para obtener información acerca de cada parámetro, consulte [CreateMetricAttribution](API_CreateMetricAttribution.md).
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize = boto3.client('personalize')
metricsList = [{
"eventType": "event type",
"expression": "SUM(DatasetType.COLUMN_NAME)",
"metricName": "metric name"
}]
outputConfig = {
"roleArn": "Amazon Personalize service role ARN",
"s3DataDestination": {
"kmsKeyArn": "key ARN",
"path": "s3://amzn-s3-demo-bucket/"
}
}
response = personalize.create_metric_attribution(
name = 'metric attribution name',
datasetGroupArn = 'dataset group arn',
metricsOutputConfig = outputConfig,
metrics = metricsList
)
metric_attribution_arn = response['metricAttributionArn']
print ('Metric attribution ARN: ' + metric_attribution_arn)
description = personalize.describe_metric_attribution(
metricAttributionArn = metric_attribution_arn)['metricAttribution']
print('Name: ' + description['name'])
print('ARN: ' + description['metricAttributionArn'])
print('Status: ' + description['status'])
```
------
#### [ SDK for Java 2.x ]
```
public static String createMetricAttribution(PersonalizeClient personalizeClient,
String eventType,
String expression,
String metricName,
String metricAttributionName,
String roleArn,
String s3Path,
String kmsKeyArn,
String datasetGroupArn) {
String metricAttributionArn = "";
try {
MetricAttribute attribute = MetricAttribute.builder()
.eventType(eventType)
.expression(expression)
.metricName(metricName)
.build();
ArrayList metricAttributes = new ArrayList<>();
metricAttributes.add(attribute);
S3DataConfig s3DataDestination = S3DataConfig.builder()
.kmsKeyArn(kmsKeyArn)
.path(s3Path)
.build();
MetricAttributionOutput outputConfig = MetricAttributionOutput.builder()
.roleArn(roleArn)
.s3DataDestination(s3DataDestination)
.build();
CreateMetricAttributionRequest createMetricAttributionRequest = CreateMetricAttributionRequest.builder()
.name(metricAttributionName)
.datasetGroupArn(datasetGroupArn)
.metrics(metricAttributes)
.metricsOutputConfig(outputConfig)
.build();
CreateMetricAttributionResponse createMetricAttributionResponse = personalizeClient.createMetricAttribution(createMetricAttributionRequest);
metricAttributionArn = createMetricAttributionResponse.metricAttributionArn();
System.out.println("Metric attribution ARN: " + metricAttributionArn);
return metricAttributionArn;
} catch (PersonalizeException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
return "";
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients and commands using ES6 syntax.
import { CreateMetricAttributionCommand, PersonalizeClient } from
"@aws-sdk/client-personalize";
// create personalizeClient
const personalizeClient = new PersonalizeClient({
region: "REGION"
});
// set the metric attribution param
export const createMetricAttributionParam = {
name: "METRIC_ATTRIBUTION_NAME", /* required */
datasetGroupArn: "DATASET_GROUP_ARN", /* required */
metricsOutputConfig: {
roleArn: "ROLE_ARN", /* required */
s3DataDestination: {
kmsKeyArn: "KEY_ARN", /* optional */
path: "s3://amzn-s3-demo-bucket//", /* optional */
},
},
metrics: [
{
eventType: "EVENT_TYPE", /* required for each metric */
expression: "SUM(DatasetType.COLUMN_NAME)", /* required for each metric */
metricName: "METRIC_NAME", /* required for each metric */
}
]
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateMetricAttributionCommand(createMetricAttributionParam)
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
# Actualización de una atribución de métricas de Amazon Personalize
Al actualizar una atribución de métricas, puede añadir y eliminar métricas, así como modificar su configuración de salida. Puede actualizar la atribución de una métrica con la consola Amazon Personalize o AWS Command Line Interface los AWS SDK.
**Topics**
+ [Actualización de una atribución de métricas (consola)](#updating-metric-attribution-console)
+ [Actualización de una atribución de métricas (AWS CLI)](#updating-metric-attribution-cli)
+ [Actualizar una atribución de métricas (SDK)AWS](#updating-metric-attribution-sdk)
## Actualización de una atribución de métricas (consola)
Para actualizar una atribución de métricas con la consola de Amazon Personalize, realice los cambios en la página **Atribución de métricas**.
**Para actualizar una atribución de métricas**
1. Abre la consola Amazon Personalize en [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e inicia sesión en tu cuenta.
1. Elija su grupo de conjuntos de datos.
1. En el panel de navegación, elija **Métricas**.
1. En la sección inferior, elija la pestaña **Atributos de métricas** o la pestaña **Configuración de atribuciones de métricas** para empezar a realizar cambios.
+ Para añadir o eliminar métricas, seleccione la pestaña **Atributos de métricas** y elija **Editar atributos**. Realice los cambios en la página **Editar atributos de métricas** y elija **Actualizar** para guardar los cambios.
+ Para realizar cambios en el bucket de salida de Amazon S3 o en el rol de servicio de IAM, seleccione la pestaña **Editar configuración de atribución de métricas** y realice los cambios en la página **Editar configuración de atribuciones**. Elija **Actualizar** para guardar los cambios.
## Actualización de una atribución de métricas (AWS CLI)
Después de crear una atribución de métricas, puede usar AWS Command Line Interface (AWS CLI) para añadir y eliminar métricas y modificar su configuración de salida. El código siguiente muestra cómo eliminar métricas con el comando `update-metric-attribution`:
```
aws personalize update-metric-attribution \
--metric-attribution-arn metric attribution arn \
--remove-metrics metricName1 metricName2
```
El siguiente código muestra cómo añadir una métrica adicional y especificar una nueva configuración de salida:
```
aws personalize update-metric-attribution \
--metric-attribution-arn metric attribution arn \
--metrics-output-config "{\"roleArn\": \"new role ARN\", \"s3DataDestination\":{\"kmsKeyArn\":\"kms key ARN\",\"path\":\"s3://amzn-s3-demo-bucket2/new-folder-name/\"}}" \
--add-metrics "[{
\"eventType\": \"event type\",
\"expression\": \"SUM(DatasetType.COLUMN_NAME)\",
\"metricName\": \"metric name\"
}]"
```
Si se ejecuta correctamente, Amazon Personalize devuelve el ARN de la atribución de métricas que ha actualizado. Para obtener un listado completo de todos los parámetros, consulte [UpdateMetricAttribution](API_UpdateMetricAttribution.md).
## Actualizar una atribución de métricas (SDK)AWS
Después de crear una atribución de métricas, puede agregar o quitar métricas, así como modificar su configuración de salida. El código siguiente muestra cómo eliminar métricas de una atribución de métricas.
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize = boto3.client('personalize')
metricsToRemove = ["metricName1", "metricName2"]
response = personalize.update_metric_attribution(
metricAttributionArn = "metric attribution ARN",
removeMetrics = metricsToRemove
)
```
------
#### [ SDK for Java 2.x ]
```
public static void removeMetrics(PersonalizeClient client,
String metricAttributionArn,
String metric1Name,
String metric2Name) {
ArrayList metricsToRemove = new ArrayList<>(Arrays.asList(metric1Name, metric2Name));
try {
UpdateMetricAttributionRequest request = UpdateMetricAttributionRequest.builder()
.metricAttributionArn(metricAttributionArn)
.removeMetrics(metricsToRemove)
.build();
UpdateMetricAttributionResponse response = client.updateMetricAttribution(request);
System.out.println(response);
} catch (PersonalizeException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients and commands using ES6 syntax.
import {UpdateMetricAttributionCommand, PersonalizeClient } from
"@aws-sdk/client-personalize";
// create personalizeClient
const personalizeClient = new PersonalizeClient({
region: "REGION"
});
// set the update request param
export const updateMetricAttributionParam = {
metricAttributionArn: "METRIC_ATTRIBUTION_ARN", /* required */
removeMetrics: ["METRIC_NAME_1", "METRIC_NAME_2"] /* specify list of names of metrics to delete */
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new UpdateMetricAttributionCommand(updateMetricAttributionParam)
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
El siguiente código muestra cómo añadir una métrica adicional y especificar una nueva configuración de salida:
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize = boto3.client('personalize')
newMetrics = [{
"eventType": "event type",
"expression": "SUM(DatasetType.COLUMN_NAME)",
"metricName": "metric name"
}]
newOutputConfig = {
"roleArn": "Amazon Personalize service role ARN",
"s3DataDestination": {
"kmsKeyArn": "key ARN",
"path": "s3://amzn-s3-demo-bucket/"
}
}
response = personalize.update_metric_attribution(
metricAttributionArn = "metric attribution arn",
metricsOutputConfig = newOutputConfig,
addMetrics = newMetrics
)
```
------
#### [ SDK for Java 2.x ]
```
public static void addMetricsAndUpdateOutputConfig(PersonalizeClient personalizeClient,
String metricAttributionArn,
String newMetric1EventType,
String newMetric1Expression,
String newMetric1Name,
String newMetric2EventType,
String newMetric2Expression,
String newMetric2Name,
String roleArn,
String s3Path,
String kmsKeyArn) {
try {
MetricAttribute newAttribute = MetricAttribute.builder()
.eventType(newMetric1EventType)
.expression(newMetric1Expression)
.metricName(newMetric1Name)
.build();
MetricAttribute newAttribute2 = MetricAttribute.builder()
.eventType(newMetric2EventType)
.expression(newMetric2Expression)
.metricName(newMetric2Name)
.build();
ArrayList newAttributes = new ArrayList<>(Arrays.asList(newAttribute, newAttribute2));
S3DataConfig newDataDestination = S3DataConfig.builder()
.kmsKeyArn(kmsKeyArn)
.path(s3Path)
.build();
MetricAttributionOutput newOutputConfig = MetricAttributionOutput.builder()
.roleArn(roleArn)
.s3DataDestination(newDataDestination)
.build();
UpdateMetricAttributionRequest request = UpdateMetricAttributionRequest.builder()
.metricAttributionArn(metricAttributionArn)
.metricsOutputConfig(newOutputConfig)
.addMetrics(newAttributes)
.build();
UpdateMetricAttributionResponse response = personalizeClient.updateMetricAttribution(request);
System.out.println("New metrics added!");
System.out.println(response);
} catch (PersonalizeException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients and commands using ES6 syntax.
import {UpdateMetricAttributionCommand, PersonalizeClient } from
"@aws-sdk/client-personalize";
// create personalizeClient
const personalizeClient = new PersonalizeClient({
region: "REGION"
});
export const updateMetricAttributionParam = {
metricAttributionArn: "METRIC_ATTRIBUTION_ARN",
addMetrics: [
{
eventType: "EVENT_TYPE", /* required for each metric */
expression: "SUM(DatasetType.COLUMN_NAME)", /* required for each metric */
metricName: "METRIC_NAME", /* required for each metric */
}
],
metricsOutputConfig: {
roleArn: "ROLE_ARN", /* required */
s3DataDestination: {
kmsKeyArn: "KEY_ARN", /* optional */
path: "s3://amzn-s3-demo-bucket//", /* optional */
},
}
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new UpdateMetricAttributionCommand(updateMetricAttributionParam)
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
Si se ejecuta correctamente, Amazon Personalize devuelve el ARN de la atribución de métricas que ha actualizado. Para obtener un listado completo de todos los parámetros, consulte [UpdateMetricAttribution](API_UpdateMetricAttribution.md).
# Eliminación de una atribución de métricas de Amazon Personalize
Si ya no desea generar informes, puede eliminar una atribución de métricas. Al eliminar una atribución de métricas, se eliminan todas sus métricas y su configuración de salida.
Si eliminas una atribución de métrica, Amazon Personalize deja de enviar automáticamente los informes relacionados con los datos masivos incrementales PutEvents y a CloudWatch ellos. Los datos ya enviados CloudWatch o publicados en Amazon S3 no se ven afectados. Puedes eliminar una atribución de métrica con la consola Amazon Personalize o AWS Command Line Interface los AWS SDK.
**Topics**
+ [Eliminación de una atribución de métricas (consola)](#deleting-metric-attribution-console)
+ [Eliminación de una atribución de métricas (AWS CLI)](#deleting-metric-attribution-cli)
+ [Eliminación de una atribución de métricas (AWS SDKs)](#deleting-metric-attribution-sdk)
## Eliminación de una atribución de métricas (consola)
Elimine una atribución de métricas en la página de información general para su atribución de métricas.
**Para eliminar una atribución de métricas**
1. Abre la consola Amazon Personalize en [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e inicia sesión en tu cuenta.
1. Elija su grupo de conjuntos de datos.
1. En el panel de navegación, elija **Métricas**.
1. Elija **Eliminar** y, a continuación, confirme la eliminación.
## Eliminación de una atribución de métricas (AWS CLI)
Para eliminar una atribución de métrica con el AWS CLI, usa el `delete-metric-attribution` comando de la siguiente manera.
```
aws personalize delete-metric-attribution --metric-attribution-arn metric attribution ARN
```
## Eliminación de una atribución de métricas (AWS SDKs)
El código siguiente muestra cómo eliminar una atribución de métricas con el SDK para Python (Boto3):
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize = boto3.client('personalize')
response = personalize.delete_metric_attribution(
metricAttributionArn = 'metric attribution ARN'
)
```
------
#### [ SDK for Java 2.x ]
```
public static void deleteMetricAttribution(PersonalizeClient client, String metricAttributionArn) {
try {
DeleteMetricAttributionRequest request = DeleteMetricAttributionRequest.builder()
.metricAttributionArn(metricAttributionArn)
.build();
DeleteMetricAttributionResponse response = client.deleteMetricAttribution(request);
if (response.sdkHttpResponse().statusCode() == 200) {
System.out.println("Metric attribution deleted!");
}
} catch (PersonalizeException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients and commands using ES6 syntax.
import { DeleteMetricAttributionCommand, PersonalizeClient } from
"@aws-sdk/client-personalize";
// create personalizeClient
const personalizeClient = new PersonalizeClient({
region: "REGION"
});
export const deleteMetricAttributionParam = {
metricAttributionArn: "METRIC_ATTRIBUTION_ARN",
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new DeleteMetricAttributionCommand(deleteMetricAttributionParam)
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------
# Visualización de gráficos de datos métricos en CloudWatch
**importante**
Tras crear una atribución de métricas y registrar los eventos o importar datos incrementales de forma masiva, incurrirás en un CloudWatch coste mensual por métrica. Para obtener información sobre CloudWatch los precios, consulta la página de [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/). Para dejar de enviar métricas a CloudWatch, [elimina la atribución de métricas](deleting-metric-attribution.md).
Tras crear una atribución de métricas, Amazon Personalize envía automáticamente las métricas [PutEvents](API_UBS_PutEvents.md) y los datos incrementales masivos a Amazon CloudWatch. Puede seleccionar métricas y crear gráficos de los datos de las métricas mediante la CloudWatch consola. Estos gráficos pueden ayudarlo a inspeccionar visualmente y comparar el rendimiento y el impacto de diferentes recomendadores o campañas.
Para comparar los orígenes, cada evento de interacción debe incluir una `recommendationId` o`eventAttributionSource`. Para ver muestras de código que presentan cómo incluir estos en un evento, consulte [Informes de atribución y métricas de eventos](event-metrics.md).
Para ver las métricas CloudWatch, complete el procedimiento que se encuentra en [Graficar una métrica](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph_a_metric.html). Puede ver los datos con diferentes niveles de detalle. El **Período** mínimo que puede representar en una gráfica es de 15 minutos. Puede ver los datos de Amazon Personalize de las 2 semanas anteriores en CloudWatch ; los datos más antiguos se ignoran. Para el término de búsqueda, especifique el nombre que le dio a la métrica cuando creó la atribución de métricas.
A continuación se muestra un ejemplo de cómo puede aparecer una métrica en CloudWatch. La métrica muestra la tasa de clics por cada 15 minutos para dos generadores de recomendaciones diferentes.
![\[Representa un gráfico de la tasa de clics por cada 15 minutos para dos recomendadores diferentes.\]](http://docs.aws.amazon.com/es_es/personalize/latest/dg/images/metric-attribution-cw-example.png)
# Publicación de informes de atribución de métricas en Amazon S3
Para todos los datos masivos, si proporciona un bucket de Amazon S3 al crear su atribución de métricas, puede optar por publicar informes de métricas en su bucket de Amazon S3 cada vez que cree un trabajo de importación de conjuntos de datos para los datos de interacciones.
Para publicar métricas en Amazon S3, debe proporcionar una ruta a su bucket de Amazon S3 en la atribución de métricas. A continuación, publique los informes en Amazon S3 cuando cree un trabajo de importación de conjuntos de datos. Cuando se complete el trabajo, podrá encontrar las métricas en su bucket de Amazon S3. Cada vez que publique métricas, Amazon Personalize crea un archivo nuevo en su bucket de Amazon S3. El nombre del archivo incluye el método de importación y la fecha de la siguiente manera:
`AggregatedAttributionMetrics - ImportMethod - Timestamp.csv`
A continuación se muestra un ejemplo de cómo pueden aparecer las primeras filas de un archivo CSV de informe de métricas. La métrica de este ejemplo indica el total de clics de dos generadores de recomendaciones diferentes en intervalos de 15 minutos. Cada generador de recomendaciones se identifica por su nombre de recurso de Amazon (ARN) en la columna EVENT\$1ATTRIBUTION\$1SOURCE.
```
METRIC_NAME,EVENT_TYPE,VALUE,MATH_FUNCTION,EVENT_ATTRIBUTION_SOURCE,TIMESTAMP
COUNTWATCHES,WATCH,12.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender1Name,1666925124
COUNTWATCHES,WATCH,112.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender2Name,1666924224
COUNTWATCHES,WATCH,10.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender1Name,1666924224
COUNTWATCHES,WATCH,254.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender2Name,1666922424
COUNTWATCHES,WATCH,112.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender1Name,1666922424
COUNTWATCHES,WATCH,100.0,samplecount,arn:aws:personalize:us-west-2:acctNum:recommender/recommender2Name,1666922424
......
.....
```
## Publicación de métricas para datos masivos en Amazon S3 (consola)
Para publicar métricas en un bucket de Amazon S3 con la consola de Amazon Personalize, cree un trabajo de importación de conjuntos de datos y elija **Publicar métricas para este trabajo de importación** en **Publicar métricas de eventos en S3**.
Para step-by-step obtener instrucciones, consulte[Creación de un trabajo de exportación de conjuntos de datos (consola)](bulk-data-import-step.md#bulk-data-import-console).
## Publicación de métricas para datos masivos en Amazon S3 (AWS CLI)
Para publicar métricas en un bucket de Amazon S3 con AWS Command Line Interface (AWS CLI), utilice el siguiente código para crear un trabajo de importación de conjuntos de datos y proporcionar la `publishAttributionMetricsToS3` marca. Si no desea publicar métricas para un trabajo en concreto, omita la marca. Para obtener información acerca de cada parámetro, consulte [CreateDatasetImportJob](API_CreateDatasetImportJob.md).
```
aws personalize create-dataset-import-job \
--job-name dataset import job name \
--dataset-arn dataset arn \
--data-source dataLocation=s3://amzn-s3-demo-bucket/filename \
--role-arn roleArn \
--import-mode INCREMENTAL \
--publish-attribution-metrics-to-s3
```
## Publicación de métricas para datos masivos en Amazon S3 (AWS SDKs)
Para publicar métricas en un bucket de Amazon S3 con AWS SDKs, cree un trabajo de importación de conjuntos de datos y `publishAttributionMetricsToS3` establézcalo en true. Para obtener información acerca de cada parámetro, consulte [CreateDatasetImportJob](API_CreateDatasetImportJob.md).
------
#### [ SDK for Python (Boto3) ]
```
import boto3
personalize = boto3.client('personalize')
response = personalize.create_dataset_import_job(
jobName = 'YourImportJob',
datasetArn = 'dataset_arn',
dataSource = {'dataLocation':'s3://amzn-s3-demo-bucket/file.csv'},
roleArn = 'role_arn',
importMode = 'INCREMENTAL',
publishAttributionMetricsToS3 = True
)
dsij_arn = response['datasetImportJobArn']
print ('Dataset Import Job arn: ' + dsij_arn)
description = personalize.describe_dataset_import_job(
datasetImportJobArn = dsij_arn)['datasetImportJob']
print('Name: ' + description['jobName'])
print('ARN: ' + description['datasetImportJobArn'])
print('Status: ' + description['status'])
```
------
#### [ SDK for Java 2.x ]
```
public static String createPersonalizeDatasetImportJob(PersonalizeClient personalizeClient,
String jobName,
String datasetArn,
String s3BucketPath,
String roleArn,
ImportMode importMode,
boolean publishToS3) {
long waitInMilliseconds = 60 * 1000;
String status;
String datasetImportJobArn;
try {
DataSource importDataSource = DataSource.builder()
.dataLocation(s3BucketPath)
.build();
CreateDatasetImportJobRequest createDatasetImportJobRequest = CreateDatasetImportJobRequest.builder()
.datasetArn(datasetArn)
.dataSource(importDataSource)
.jobName(jobName)
.roleArn(roleArn)
.importMode(importMode)
.publishAttributionMetricsToS3(publishToS3)
.build();
datasetImportJobArn = personalizeClient.createDatasetImportJob(createDatasetImportJobRequest)
.datasetImportJobArn();
DescribeDatasetImportJobRequest describeDatasetImportJobRequest = DescribeDatasetImportJobRequest.builder()
.datasetImportJobArn(datasetImportJobArn)
.build();
long maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;
while (Instant.now().getEpochSecond() < maxTime) {
DatasetImportJob datasetImportJob = personalizeClient
.describeDatasetImportJob(describeDatasetImportJobRequest)
.datasetImportJob();
status = datasetImportJob.status();
System.out.println("Dataset import job status: " + status);
if (status.equals("ACTIVE") || status.equals("CREATE FAILED")) {
break;
}
try {
Thread.sleep(waitInMilliseconds);
} catch (InterruptedException e) {
System.out.println(e.getMessage());
}
}
return datasetImportJobArn;
} catch (PersonalizeException e) {
System.out.println(e.awsErrorDetails().errorMessage());
}
return "";
}
```
------
#### [ SDK for JavaScript v3 ]
```
// Get service clients and commands using ES6 syntax.
import { CreateDatasetImportJobCommand, PersonalizeClient } from
"@aws-sdk/client-personalize";
// create personalizeClient
const personalizeClient = new PersonalizeClient({
region: "REGION"
});
// Set the dataset import job parameters.
export const datasetImportJobParam = {
datasetArn: 'DATASET_ARN', /* required */
dataSource: {
dataLocation: 's3://amzn-s3-demo-bucket//.csv' /* required */
},
jobName: 'NAME', /* required */
roleArn: 'ROLE_ARN', /* required */
importMode: "FULL", /* optional, default is FULL */
publishAttributionMetricsToS3: true /* set to true to publish metrics to Amazon S3 bucket */
};
export const run = async () => {
try {
const response = await personalizeClient.send(new CreateDatasetImportJobCommand(datasetImportJobParam));
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
------