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à.
# Misurazione dell'impatto delle raccomandazioni con un'attribuzione metrica
Per misurare l'impatto dei consigli sugli articoli, puoi creare un'attribuzione metrica. Un'*attribuzione metrica* crea report basati sulle interazioni tra gli articoli e sui dati degli articoli importati e sulle metriche specificate. Ad esempio, la durata totale dei film guardati dagli utenti o il numero totale di clic. Amazon Personalize aggrega i calcoli in una finestra di 15 minuti. Per i dati di interazione in streaming e i dati di massa incrementali, Amazon Personalize invia automaticamente report sulle metriche ad Amazon. CloudWatch Per i dati di massa, puoi scegliere di pubblicare report in un bucket Amazon S3.
Per ogni interazione che importi, includi i dati di origine per confrontare diverse campagne, suggerimenti e terze parti. Puoi includere l'ID dei consigli che hai mostrato all'utente o la fonte dell'evento, ad esempio una terza parte.
Ad esempio, potresti avere un'app di streaming video che mostra i consigli sui film di due diversi programmi di raccomandazione di Amazon Personalize. Se desideri vedere quale programma di raccomandazione genera gli eventi più visti, puoi creare un'attribuzione metrica che tenga traccia del numero totale di eventi di visualizzazione. Quindi puoi registrare gli eventi di visualizzazione man mano che gli utenti interagiscono con i consigli e includerli `recommendationId` in ogni evento. Amazon Personalize utilizza il `recommendationId` per identificare ogni consulente. Man mano che registri gli eventi, puoi visualizzare i totali degli eventi di visualizzazione aggregati ogni 15 minuti per entrambi i consigliatori. CloudWatch Per esempi di codice che mostrano come includere un `recommendationId` o un `eventAttributionSource` per un evento, consulta. [Metriche degli eventi e rapporti sull'attribuzione](event-metrics.md)
**Topics**
+ [Linee guida e requisiti per l'attribuzione di una metrica](metric-attribution-requirements.md)
+ [Creazione di un'attribuzione dei parametri Amazon Personalize](creating-metric-attribution.md)
+ [Aggiornamento di un'attribuzione di parametri Amazon Personalize](updating-metric-attribution.md)
+ [Eliminazione di un'attribuzione di parametri Amazon Personalize](deleting-metric-attribution.md)
+ [Visualizzazione dei grafici dei dati metrici in CloudWatch](metric-attribution-results-cloudwatch.md)
+ [Pubblicazione di report di attribuzione delle metriche su Amazon S3](metric-attribution-results-s3.md)
# Linee guida e requisiti per l'attribuzione di una metrica
Amazon Personalize inizia a calcolare e riportare l'impatto dei consigli solo dopo aver creato un'attribuzione delle metriche. Per creare una cronologia più completa, ti consigliamo di creare un'attribuzione metrica prima di importare i dati delle interazioni. Quando crei un processo di importazione di set di dati per un set di dati sulle interazioni tra articoli con la console Amazon Personalize, hai la possibilità di creare un'attribuzione di metriche in una nuova scheda. Quindi puoi tornare al processo di importazione per completarlo.
Dopo aver creato un'attribuzione di una metrica e registrato gli eventi o importato dati di massa incrementali, dovrai sostenere un costo mensile per metrica. CloudWatch Per informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/). Per interrompere l'invio delle metriche a CloudWatch, [elimina l'attribuzione della metrica](deleting-metric-attribution.md).
Per vedere l'impatto dei consigli nel tempo, continua a importare i dati man mano che i clienti interagiscono con i consigli. Se hai già importato dati, puoi comunque creare un'attribuzione metrica e iniziare a misurare l'impatto delle raccomandazioni. Tuttavia, Amazon Personalize non genererà report sui dati che hai importato prima di crearli.
Di seguito sono riportate le linee guida e i requisiti per la generazione di report con un'attribuzione metrica:
+ Devi concedere ad Amazon Personalize l'autorizzazione ad accedere e inserire dati. CloudWatch Per esempi di policy, consulta [Offrire ad Amazon Personalize l'accesso a CloudWatch](#metric-attribution-cw-permissions).
+ Per pubblicare i parametri su Amazon S3, autorizza Amazon Personalize a scrivere nel tuo bucket. Inoltre, devi fornire il percorso del bucket nell'attribuzione delle metriche. Per esempi di policy, consulta [Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3](#metric-attribution-s3-permissions).
+ Per pubblicare le metriche su CloudWatch, i record devono avere meno di 14 giorni. Se i tuoi dati sono più vecchi, questi record non verranno inclusi nei calcoli o nei report.
+ L'importazione di eventi duplicati (eventi che corrispondono esattamente a tutti gli attributi) può portare a comportamenti imprevisti, tra cui metriche imprecise. Si consiglia di rimuovere i record duplicati da qualsiasi dato di massa prima dell'importazione ed evitare di importare eventi duplicati con l'operazione. `PutEvents`
+ Il set di dati sulle interazioni tra oggetti deve avere una colonna. `EVENT_TYPE`
+ Non puoi creare report metrici per i dati in un set di dati di interazioni Action.
+ Puoi creare al massimo un'attribuzione di metriche per gruppo di set di dati. Ogni attribuzione metrica può avere al massimo 10 metriche.
Per confrontare le fonti, ogni evento di interazione deve includere un o. `recommendationId` `eventAttributionSource` Puoi fornire al massimo 100 fonti di attribuzione degli eventi uniche. Per alcuni esempi di codice `PutEvents`, consulta [Metriche degli eventi e rapporti sull'attribuzione](event-metrics.md).
+ 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.
**Topics**
+ [Offrire ad Amazon Personalize l'accesso a CloudWatch](#metric-attribution-cw-permissions)
+ [Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3](#metric-attribution-s3-permissions)
## Offrire ad Amazon Personalize l'accesso a CloudWatch
**Importante**
Quando concedi le autorizzazioni, Amazon Personalize inserisce e convalida una piccola quantità di dati. CloudWatch Ciò comporterà un costo una tantum inferiore a 0,30 USD. Per ulteriori informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
Per consentire ad Amazon Personalize di accedere a CloudWatch, allega una nuova policy AWS Identity and Access Management (IAM) al tuo ruolo di servizio Amazon Personalize che conceda al ruolo l'autorizzazione a utilizzare l'Action for. `PutMetricData` CloudWatch Il seguente esempio di politica concede le autorizzazioni. `PutMetricData`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
}
```
------
## Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3
Per consentire ad Amazon Personalize di accedere al tuo bucket Amazon S3:
+ Allega una policy IAM al tuo ruolo di servizio Amazon Personalize che conceda al ruolo l'autorizzazione a utilizzare l'`PutObject`Action on your 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/*"
]
}
]
}
```
------
+ Allega una policy bucket al tuo bucket Amazon S3 di output che conceda, in base al principio Amazon Personalize, l'autorizzazione a utilizzare le Actions. `PutObject`
Se utilizzi AWS Key Management Service (AWS KMS) per la crittografia, devi concedere ad Amazon Personalize e al tuo ruolo di servizio Amazon Personalize IAM l'autorizzazione a usare la tua chiave. Per ulteriori informazioni, consulta [Autorizzazione all'uso del codice da parte di Amazon Personalize AWS KMS](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/*"
]
}
]
}
```
------
# Creazione di un'attribuzione dei parametri Amazon Personalize
**Importante**
Dopo aver creato un'attribuzione di una metrica e registrato gli eventi o importato dati di massa incrementali, dovrai sostenere un costo mensile per metrica. CloudWatch Per informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/). Per interrompere l'invio delle metriche a CloudWatch, [elimina l'attribuzione della metrica](deleting-metric-attribution.md).
Per iniziare a generare report sulle metriche, crei un'attribuzione metrica e importi i dati sulle interazioni. Quando crei un'attribuzione metrica, specifichi un elenco di tipi di eventi su cui generare report. Per ogni tipo di evento, specifichi una funzione che Amazon Personalize applica durante la raccolta dei dati. Le funzioni disponibili includono `SUM(DatasetType.COLUMN_NAME)` e. `SAMPLECOUNT()`
Ad esempio, potresti avere un'app di streaming video online e voler tenere traccia di due parametri: la percentuale di clic per i consigli e la durata totale dei film guardati, dove ogni video nel set di dati Items include un attributo. `LENGTH` Puoi creare un'attribuzione metrica e aggiungere due metriche, ognuna con un tipo e una funzione di evento. La prima potrebbe riguardare il tipo di `Click` evento con una funzione. `SAMPLECOUNT()` Il secondo potrebbe riguardare il tipo di `Watch` evento con una `SUM(Items.LENGTH)` funzione.
È possibile applicare `SUM()` le funzioni solo alle colonne numeriche dei set di dati Items e Item Interactions. Per applicare una `SUM()` funzione a una colonna in un set di dati Items, devi prima importare i metadati degli elementi.
Puoi creare un'attribuzione metrica con la console AWS Command Line Interface Amazon Personalize o gli SDK. AWS
**Topics**
+ [Creazione di un'attribuzione metrica (console)](#create-metric-attribution-console)
+ [Creazione di un'attribuzione metrica ()AWS CLI](#create-metric-attribution-cli)
+ [Creazione di un'attribuzione metrica ()AWS SDKs](#create-metric-attribution-sdk)
## Creazione di un'attribuzione metrica (console)
**Per creare un'attribuzione metrica con la console Amazon Personalize, accedi alla pagina di attribuzione Metric e **scegli Crea attribuzione metrica**.** Quando crei un'attribuzione di metriche, specifichi un bucket path Amazon S3 opzionale, il ruolo del servizio Amazon Personalize IAM e un elenco di parametri su cui generare report.
Quando crei un processo di importazione del set di dati sulle interazioni degli articoli con la console Amazon Personalize, hai la possibilità di creare un'attribuzione metrica in una nuova scheda. Quindi puoi tornare al processo di importazione per completarlo. Se sei già nella pagina **Configura l'attribuzione delle metriche**, puoi andare al passaggio 4.
**Per creare un'attribuzione metrica**
1. Apri la console Amazon Personalize a [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e accedi al tuo account.
1. Scegli il tuo gruppo di set di dati.
1. Nel riquadro di navigazione, in **Risorse personalizzate**, scegli Attribuzione **metrica**.
1. **Nei **dettagli dell'attribuzione delle metriche, scegli Crea** attribuzione metrica.**
1. Nella pagina **Configura l'attribuzione della metrica, assegna un nome all'attribuzione** della metrica.
1. Se desideri pubblicare i parametri sul percorso di **output dei dati di Amazon S3 per Amazon S3**, inserisci il bucket Amazon S3 di destinazione. Ciò consente di pubblicare parametri ogni volta che si crea un processo di importazione di set di dati. Utilizzare la seguente sintassi:
**s3://amzn-s3-demo-bucket/ path>**
1. Se utilizzi AWS KMS per la crittografia, per la **chiave KMS ARN**, inserisci l'Amazon Resource Name (ARN) per la chiave. AWS KMS Devi concedere ad Amazon Personalize e al tuo ruolo di servizio Amazon Personalize IAM l'autorizzazione a usare la tua chiave. Per ulteriori informazioni, consulta [Autorizzazione all'uso del codice da parte di Amazon Personalize AWS KMS](granting-personalize-key-access.md).
1. Nel **ruolo IAM**, scegli di creare un nuovo ruolo di servizio o di utilizzarne uno esistente. Il ruolo che scegli deve avere le `PutMetricData` autorizzazioni per CloudWatch cui hai scelto. Se desideri pubblicare su Amazon S3, il ruolo deve disporre delle `PutObject` autorizzazioni per il tuo bucket Amazon S3.
Per utilizzare il ruolo in cui hai creato[Creazione di un ruolo IAM per Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), potresti dover aggiungere politiche per CloudWatch Amazon S3.
Per esempi di policy, consulta [Offrire ad Amazon Personalize l'accesso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) e[Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Definisci gli attributi delle metriche**, scegli come definire le metriche. Scegli **Crea attributi metrici** per utilizzare lo strumento Builder. Scegli **Input metric attributes** per inserire le metriche in formato JSON.
+ Se scegli **Crea attributi metrici**, per ogni metrica fornisci un nome, un tipo di evento e scegli una funzione. Per `SUM()` le funzioni, scegli il nome della colonna. Scegli **Aggiungi attributo metrico** per aggiungere metriche aggiuntive.
+ Se scegli **Input metric attributes**, inserisci ogni metrica in formato JSON. Di seguito viene illustrato come formattare una metrica.
```
{
"EventType": "watch",
"MetricName": "MinutesWatchedTracker",
"MetricMathExpression": "SUM(Items.LENGTH)"
}
```
1. Scegli **Next (Successivo)**.
1. Nella **pagina Rivedi e crea**, esamina i dettagli per la nuova attribuzione della metrica. Per apportare modifiche, scegliere **Previous (Precedente)**. **Per creare l'attribuzione della metrica, scegli Crea.** Quando l'attribuzione della metrica è attiva, puoi iniziare a importare dati e visualizzare i risultati. Per informazioni sulla visualizzazione dei risultati, consulta. [Visualizzazione dei grafici dei dati metrici in CloudWatch](metric-attribution-results-cloudwatch.md) Per informazioni sulla pubblicazione dei risultati su Amazon S3, consulta. [Pubblicazione di report di attribuzione delle metriche su Amazon S3](metric-attribution-results-s3.md)
## Creazione di un'attribuzione metrica ()AWS CLI
Il codice seguente mostra come creare un'attribuzione metrica con. AWS Command Line Interface Il ruolo specificato deve avere `PutMetricData` le autorizzazioni CloudWatch e, in caso di pubblicazione su Amazon S3`PutObject`, le autorizzazioni per il tuo bucket Amazon S3. Per utilizzare il ruolo in cui hai creato[Creazione di un ruolo IAM per Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), potresti dover aggiungere politiche per CloudWatch Amazon S3. Per esempi di policy, consulta [Offrire ad Amazon Personalize l'accesso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) e[Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
Per ogni metrica, specifica un nome, un tipo di evento e un'espressione (una funzione). Le funzioni disponibili includono `SUM(DatasetType.COLUMN_NAME)` e. `SAMPLECOUNT()` Per le funzioni SUM (), specificate il tipo di set di dati e il nome della colonna. Ad esempio, `SUM(Items.LENGTH)`. Per informazioni su ciascun parametro, vedere[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\"
}]"
```
## Creazione di un'attribuzione metrica ()AWS SDKs
Il codice seguente mostra come creare un'attribuzione metrica con l'SDK for Python (Boto3). Il ruolo specificato deve avere `PutMetricData` le autorizzazioni CloudWatch e, in caso di pubblicazione su Amazon S3`PutObject`, le autorizzazioni per il tuo bucket Amazon S3. Per utilizzare il ruolo in cui hai creato[Creazione di un ruolo IAM per Amazon Personalize](set-up-required-permissions.md#set-up-create-role-with-permissions), potresti dover aggiungere politiche per CloudWatch Amazon S3. Per esempi di policy, consulta [Offrire ad Amazon Personalize l'accesso a CloudWatch](metric-attribution-requirements.md#metric-attribution-cw-permissions) e[Offrire ad Amazon Personalize l'accesso al tuo bucket Amazon S3](metric-attribution-requirements.md#metric-attribution-s3-permissions).
Per ogni metrica, specifica un nome, un tipo di evento e un'espressione (una funzione). Le funzioni disponibili includono `SUM(DatasetType.COLUMN_NAME)` e. `SAMPLECOUNT()` Per le funzioni SUM (), specificate il tipo di set di dati e il nome della colonna. Ad esempio, `SUM(Items.LENGTH)`. Per informazioni su ciascun parametro, vedere[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();
```
------
# Aggiornamento di un'attribuzione di parametri Amazon Personalize
Quando aggiorni l'attribuzione di una metrica, puoi aggiungere e rimuovere metriche e modificarne la configurazione di output. Puoi aggiornare l'attribuzione di una metrica con la console AWS Command Line Interface Amazon Personalize o gli SDK. AWS
**Topics**
+ [Aggiornamento di un'attribuzione metrica (console)](#updating-metric-attribution-console)
+ [Aggiornamento di un'attribuzione metrica ()AWS CLI](#updating-metric-attribution-cli)
+ [Aggiornamento di un'attribuzione metrica (SDK)AWS](#updating-metric-attribution-sdk)
## Aggiornamento di un'attribuzione metrica (console)
**Per aggiornare l'attribuzione di una metrica con la console Amazon Personalize, apporta le modifiche nella pagina di attribuzione di Metric.**
**Per aggiornare un'attribuzione metrica**
1. Apri la console Amazon Personalize a [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e accedi al tuo account.
1. Scegli il tuo gruppo di set di dati.
1. Nel riquadro di navigazione, scegli Attribuzione **metrica**.
1. Nella sezione inferiore, scegli la scheda **Attributi della metrica** o la scheda **Configurazione dell'attribuzione delle metriche** per iniziare ad apportare modifiche.
+ **Per aggiungere o rimuovere metriche, scegli la scheda **Attributi della metrica e scegli Modifica attributi**.** Apporta le modifiche nella pagina **Modifica gli attributi delle metriche** e scegli **Aggiorna** per salvare le modifiche.
+ **Per apportare modifiche al bucket di output di Amazon S3 o al ruolo del servizio IAM, scegli la scheda **Modifica configurazione di attribuzione dei parametri e apporta le modifiche nella pagina Modifica configurazione** di attribuzione.** Scegli **Update (Aggiorna)** per salvare le modifiche.
## Aggiornamento di un'attribuzione metrica ()AWS CLI
Dopo aver creato un'attribuzione di metrica, puoi utilizzare AWS Command Line Interface (AWS CLI) per aggiungere e rimuovere metriche e modificarne la configurazione di output. Il codice seguente mostra come rimuovere le metriche con il comando: `update-metric-attribution`
```
aws personalize update-metric-attribution \
--metric-attribution-arn metric attribution arn \
--remove-metrics metricName1 metricName2
```
Il codice seguente mostra come aggiungere una metrica aggiuntiva e specificare una nuova configurazione di output:
```
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\"
}]"
```
In caso di successo, Amazon Personalize restituisce l'ARN dell'attribuzione della metrica che hai aggiornato. Per un elenco completo di tutti i parametri, consulta. [UpdateMetricAttribution](API_UpdateMetricAttribution.md)
## Aggiornamento di un'attribuzione metrica (SDK)AWS
Dopo aver creato un'attribuzione di metriche, puoi aggiungere o rimuovere metriche e modificarne la configurazione di output. Il codice seguente mostra come rimuovere le metriche da un'attribuzione metrica.
------
#### [ 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();
```
------
Il codice seguente mostra come aggiungere una metrica aggiuntiva e specificare una nuova configurazione di output:
------
#### [ 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();
```
------
In caso di successo, Amazon Personalize restituisce l'ARN dell'attribuzione della metrica che hai aggiornato. Per un elenco completo di tutti i parametri, consulta. [UpdateMetricAttribution](API_UpdateMetricAttribution.md)
# Eliminazione di un'attribuzione di parametri Amazon Personalize
Se non desideri più generare report, puoi eliminare un'attribuzione metrica. L'eliminazione di un'attribuzione di una metrica elimina tutte le relative metriche e la configurazione di output.
Se elimini un'attribuzione di una metrica, Amazon Personalize interrompe l'invio automatico di report relativi PutEvents a dati di massa incrementali a. CloudWatch I dati già inviati CloudWatch o pubblicati su Amazon S3 non sono interessati. Puoi eliminare un'attribuzione di metrica con la console AWS Command Line Interface Amazon Personalize o gli SDK. AWS
**Topics**
+ [Eliminazione di un'attribuzione metrica (console)](#deleting-metric-attribution-console)
+ [Eliminazione di un'attribuzione metrica ()AWS CLI](#deleting-metric-attribution-cli)
+ [Eliminazione di un'attribuzione metrica ()AWS SDKs](#deleting-metric-attribution-sdk)
## Eliminazione di un'attribuzione metrica (console)
Elimini un'attribuzione metrica nella pagina di panoramica relativa all'attribuzione della metrica.
**Per eliminare un'attribuzione metrica**
1. Apri la console Amazon Personalize a [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e accedi al tuo account.
1. Scegli il tuo gruppo di set di dati.
1. Nel riquadro di navigazione, scegli Attribuzione **metrica**.
1. Scegli **Elimina**, quindi conferma l'eliminazione.
## Eliminazione di un'attribuzione metrica ()AWS CLI
Per eliminare un'attribuzione metrica con AWS CLI, utilizzate il comando come segue. `delete-metric-attribution`
```
aws personalize delete-metric-attribution --metric-attribution-arn metric attribution ARN
```
## Eliminazione di un'attribuzione metrica ()AWS SDKs
Il codice seguente mostra come eliminare un'attribuzione di metrica con l'SDK for 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();
```
------
# Visualizzazione dei grafici dei dati metrici in CloudWatch
**Importante**
Dopo aver creato un'attribuzione di una metrica e registrato gli eventi o importato dati di massa incrementali, dovrai sostenere un costo mensile per metrica. CloudWatch Per informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/). Per interrompere l'invio delle metriche a CloudWatch, [elimina l'attribuzione della metrica](deleting-metric-attribution.md).
Dopo aver creato un'attribuzione di metriche, Amazon Personalize invia automaticamente le metriche [PutEvents](API_UBS_PutEvents.md) e i dati in blocco incrementali ad Amazon. CloudWatch Puoi selezionare le metriche e creare grafici dei dati metrici utilizzando la console. CloudWatch Questi grafici possono aiutarti a ispezionare visivamente e confrontare le prestazioni e l'impatto di diversi consigli o campagne.
Per confrontare le fonti, ogni evento di interazione deve includere un o. `recommendationId` `eventAttributionSource` Per esempi di codice che mostrano come includere questi dati in un evento, vedi[Metriche degli eventi e rapporti sull'attribuzione](event-metrics.md).
Per visualizzare le metriche in CloudWatch, completa la procedura riportata in [Rappresentazione grafica di una](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph_a_metric.html) metrica. Puoi visualizzare i dati a diversi livelli di dettaglio. Il **periodo** minimo che puoi rappresentare graficamente è di 15 minuti. Puoi visualizzare i dati di Amazon Personalize delle 2 settimane precedenti CloudWatch : i dati più vecchi vengono ignorati. Per il termine di ricerca, specifica il nome che hai assegnato alla metrica quando hai creato l'attribuzione della metrica.
Di seguito è riportato un esempio di come potrebbe apparire una metrica in. CloudWatch La metrica mostra la percentuale di clic ogni 15 minuti per due diversi consiglieri.
![\[Mostra un grafico della percentuale di clic ogni 15 minuti per due diversi consiglieri.\]](http://docs.aws.amazon.com/it_it/personalize/latest/dg/images/metric-attribution-cw-example.png)
# Pubblicazione di report di attribuzione delle metriche su Amazon S3
Per tutti i dati in blocco, se fornisci un bucket Amazon S3 quando crei l'attribuzione delle metriche, puoi scegliere di pubblicare report sui parametri nel tuo bucket Amazon S3 ogni volta che crei un processo di importazione del set di dati per i dati delle interazioni.
Per pubblicare i parametri su Amazon S3, fornisci un percorso al tuo bucket Amazon S3 nell'attribuzione dei parametri. Quindi pubblichi report su Amazon S3 quando crei un processo di importazione di set di dati. Al termine del processo, puoi trovare i parametri nel tuo bucket Amazon S3. Ogni volta che pubblichi parametri, Amazon Personalize crea un nuovo file nel tuo bucket Amazon S3. Il nome del file include il metodo e la data di importazione come segue:
`AggregatedAttributionMetrics - ImportMethod - Timestamp.csv`
Di seguito è riportato un esempio di come potrebbero apparire le prime righe di un file CSV di un report metrico. La metrica in questo esempio riporta i clic totali di due diversi consiglieri su intervalli di 15 minuti. Ogni raccomandatore è identificato dal relativo Amazon Resource Name (ARN) nella colonna 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
......
.....
```
## Pubblicazione di metriche per dati di massa su Amazon S3 (console)
**Per pubblicare i parametri in un bucket Amazon S3 con la console Amazon Personalize, crea un processo di importazione del set di dati e **scegli Pubblica metriche per questo processo di importazione in Pubblica metriche** degli eventi su S3.**
step-by-stepPer [Creazione di un processo di importazione del set di dati (console)](bulk-data-import-step.md#bulk-data-import-console) istruzioni, consulta.
## Pubblicazione di metriche per dati di massa su Amazon S3 ()AWS CLI
Per pubblicare i parametri in un bucket Amazon S3 con AWS CLI(), usa AWS Command Line Interface il codice seguente per creare un processo di importazione del set di dati e fornire il flag. `publishAttributionMetricsToS3` Se non desideri pubblicare i parametri per un particolare lavoro, ometti il flag. Per informazioni su ciascun parametro, consulta. [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
```
## Pubblicazione di metriche per dati di massa su Amazon S3 ()AWS SDKs
Per pubblicare i parametri in un bucket Amazon S3 con, crea un processo di importazione AWS SDKs del set di dati e impostalo su true. `publishAttributionMetricsToS3` Per informazioni su ciascun parametro, consulta. [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();
```
------