

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à.

# Tutorial: visualizzazione delle chiamate all'assistenza clienti con OpenSearch Service e dashboard OpenSearch
<a name="walkthrough"></a>

Questo capitolo è un'analisi completa della seguente situazione: un'azienda riceve un numero di chiamate al servizio di assistenza clienti e desidera analizzarle. Qual è l'argomento di ogni chiamata? Quante sono state positive? Quante sono state negative? In che modo i responsabili possono cercare o analizzare le trascrizioni di queste chiamate?

Un flusso di lavoro manuale potrebbe coinvolgere dipendenti che ascoltano le registrazioni, annotano l'oggetto di ciascuna chiamata e decidono se l'interazione con il cliente è stata positiva.

Tale processo sarebbe estremamente impegnativo. Considerando un tempo medio di 10 minuti per chiamata, ogni dipendente potrebbe ascoltare solo 48 chiamate al giorno. Ad eccezione di eventuali distorsioni umane, i dati generati sarebbero altamente accurati, ma la *quantità* di dati sarebbe minima: solo l'oggetto della chiamata e un Boolean se il cliente è soddisfatto oppure no. Qualcosa di più complesso, come una trascrizione completa, potrebbe richiedere una grande quantità di tempo.

Utilizzando [Amazon S3](https://aws.amazon.com/s3/), Amazon [Transcribe[, Amazon](https://aws.amazon.com/comprehend/)](https://aws.amazon.com/transcribe/) Comprehend e Amazon Service OpenSearch , puoi automatizzare un processo simile con pochissimo codice e ottenere molti più dati. Ad esempio, è possibile ottenere una trascrizione completa della chiamata, le parole chiave dalla trascrizione e un "sentiment" della chiamata (positivo, negativo, neutro o misto). Quindi puoi utilizzare OpenSearch e OpenSearch Dashboards per cercare e visualizzare i dati.

Sebbene sia possibile utilizzare questa procedura dettagliata così com'è, l'intento è quello di stimolare idee su come arricchire i documenti JSON prima di indicizzarli in Service. OpenSearch 

**Costi stimati**

In generale, l'esecuzione della procedura indicata in questo scenario avrebbe un costo inferiore a \$12. La procedura guidata utilizza le risorse seguenti:
+ Bucket S3 con meno di 100 MB trasferiti e memorizzati

  Per ulteriori informazioni, consultare [Amazon S3 Pricing](https://aws.amazon.com/s3/pricing/).
+ OpenSearch Dominio di servizio con un'`t2.medium`istanza e 10 GiB di storage EBS per diverse ore

  Per ulteriori informazioni, consulta la pagina [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/elasticsearch-service/pricing/).
+ Chiamate multiple ad Amazon Transcribe

  Per ulteriori informazioni, consultare [Prezzi di Amazon Transcribe](https://aws.amazon.com/transcribe/pricing/).
+ Diverse chiamate di elaborazione del linguaggio naturale ad Amazon Comprehend

  Per ulteriori informazioni, consultare [Prezzi di Amazon Comprehend](https://aws.amazon.com/comprehend/pricing/).

**Topics**
+ [Fase 1: Configurazione dei prerequisiti](#walkthrough-prereq)
+ [Fase 2: Copia del codice di esempio](#walkthrough-script)
+ [(Facoltativo) Fase 3: Indicizzazione dei dati di esempio](#walkthrough-sample-data)
+ [Fase 4: Analisi e visualizzazione dei dati](#walkthrough-analysis)
+ [Fase 5: Pulizia delle risorse e fasi successive](#walkthrough-next-steps)

## Fase 1: Configurazione dei prerequisiti
<a name="walkthrough-prereq"></a>

Prima di procedere, devi disporre delle risorse indicate di seguito.


****  

| Prerequisito | Description | 
| --- | --- | 
| Bucket Amazon S3 | Per ulteriori informazioni, consulta [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella Guida per l'utente di Amazon Simple Storage Service. | 
| OpenSearch Dominio del servizio | Destinazione per i dati. Per ulteriori informazioni, consulta [Creazione di domini OpenSearch di servizio](createupdatedomains.md#createdomains). | 

Se non si dispone già di queste risorse, è possibile crearle utilizzando i comandi AWS CLI seguenti:

```
aws s3 mb s3://my-transcribe-test --region us-west-2
```

```
aws opensearch create-domain --domain-name my-transcribe-test --engine-version OpenSearch_1.0 --cluster-config  InstanceType=t2.medium.search,InstanceCount=1 --ebs-options EBSEnabled=true,VolumeType=standard,VolumeSize=10 --access-policies '{"Version": "2012-10-17",		 	 	 "Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::123456789012:root"},"Action":"es:*","Resource":"arn:aws:es:us-west-2:123456789012:domain/my-transcribe-test/*"}]}' --region us-west-2
```

**Nota**  
Questi comandi utilizzano la regione `us-west-2`, ma è possibile usare qualsiasi regione supportata da Amazon Comprehend. Per ulteriori informazioni consulta [Riferimenti generali di AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html#comprehend_region).

## Fase 2: Copia del codice di esempio
<a name="walkthrough-script"></a>

1. Copiare e incollare il seguente codice di esempio Python 3 in un nuovo file denominato `call-center.py`:

   ```
   import boto3
   import datetime
   import json
   import requests
   from requests_aws4auth import AWS4Auth
   import time
   import urllib.request
   
   # Variables to update
   audio_file_name = '' # For example, 000001.mp3
   bucket_name = '' # For example, my-transcribe-test
   domain = '' # For example, https://search-my-transcribe-test-12345.us-west-2.es.amazonaws.com
   index = 'support-calls'
   type = '_doc'
   region = 'us-west-2'
   
   # Upload audio file to S3.
   s3_client = boto3.client('s3')
   
   audio_file = open(audio_file_name, 'rb')
   
   print('Uploading ' + audio_file_name + '...')
   response = s3_client.put_object(
       Body=audio_file,
       Bucket=bucket_name,
       Key=audio_file_name
   )
   
   # # Build the URL to the audio file on S3.
   # # Only for the us-east-1 region.
   # mp3_uri = 'https://' + bucket_name + '.s3.amazonaws.com/' + audio_file_name
   
   # Get the necessary details and build the URL to the audio file on S3.
   # For all other regions.
   response = s3_client.get_bucket_location(
       Bucket=bucket_name
   )
   bucket_region = response['LocationConstraint']
   mp3_uri = 'https://' + bucket_name + '.s3-' + bucket_region + '.amazonaws.com/' + audio_file_name
   
   # Start transcription job.
   transcribe_client = boto3.client('transcribe')
   
   print('Starting transcription job...')
   response = transcribe_client.start_transcription_job(
       TranscriptionJobName=audio_file_name,
       LanguageCode='en-US',
       MediaFormat='mp3',
       Media={
           'MediaFileUri': mp3_uri
       },
       Settings={
           'ShowSpeakerLabels': True,
           'MaxSpeakerLabels': 2 # assumes two people on a phone call
       }
   )
   
   # Wait for the transcription job to finish.
   print('Waiting for job to complete...')
   while True:
       response = transcribe_client.get_transcription_job(TranscriptionJobName=audio_file_name)
       if response['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
           break
       else:
           print('Still waiting...')
       time.sleep(10)
   
   transcript_uri = response['TranscriptionJob']['Transcript']['TranscriptFileUri']
   
   # Open the JSON file, read it, and get the transcript.
   response = urllib.request.urlopen(transcript_uri)
   raw_json = response.read()
   loaded_json = json.loads(raw_json)
   transcript = loaded_json['results']['transcripts'][0]['transcript']
   
   # Send transcript to Comprehend for key phrases and sentiment.
   comprehend_client = boto3.client('comprehend')
   
   # If necessary, trim the transcript.
   # If the transcript is more than 5 KB, the Comprehend calls fail.
   if len(transcript) > 5000:
       trimmed_transcript = transcript[:5000]
   else:
       trimmed_transcript = transcript
   
   print('Detecting key phrases...')
   response = comprehend_client.detect_key_phrases(
       Text=trimmed_transcript,
       LanguageCode='en'
   )
   
   keywords = []
   for keyword in response['KeyPhrases']:
       keywords.append(keyword['Text'])
   
   print('Detecting sentiment...')
   response = comprehend_client.detect_sentiment(
       Text=trimmed_transcript,
       LanguageCode='en'
   )
   
   sentiment = response['Sentiment']
   
   # Build the Amazon OpenSearch Service URL.
   id = audio_file_name.strip('.mp3')
   url = domain + '/' + index + '/' + type + '/' + id
   
   # Create the JSON document.
   json_document = {'transcript': transcript, 'keywords': keywords, 'sentiment': sentiment, 'timestamp': datetime.datetime.now().isoformat()}
   
   # Provide all details necessary to sign the indexing request.
   credentials = boto3.Session().get_credentials()
   awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, 'opensearchservice', session_token=credentials.token)
   
   # Index the document.
   print('Indexing document...')
   response = requests.put(url, auth=awsauth, json=json_document, headers=headers)
   
   print(response)
   print(response.json())
   ```

1. Aggiornare le prime sei variabili.

1. Installare i pacchetti necessari utilizzando i comandi seguenti:

   ```
   pip install boto3
   pip install requests
   pip install requests_aws4auth
   ```

1. Inserisci il tuo MP3 nella stessa directory `call-center.py` ed esegui lo script. Di seguito è riportato un output di esempio:

   ```
   $ python call-center.py
   Uploading 000001.mp3...
   Starting transcription job...
   Waiting for job to complete...
   Still waiting...
   Still waiting...
   Still waiting...
   Still waiting...
   Still waiting...
   Still waiting...
   Still waiting...
   Detecting key phrases...
   Detecting sentiment...
   Indexing document...
   <Response [201]>
   {u'_type': u'call', u'_seq_no': 0, u'_shards': {u'successful': 1, u'failed': 0, u'total': 2}, u'_index': u'support-calls4', u'_version': 1, u'_primary_term': 1, u'result': u'created', u'_id': u'000001'}
   ```

`call-center.py` esegue una serie di operazioni:

1. Lo script carica un file audio (in questo caso, un MP3, ma Amazon Transcribe supporta diversi formati) nel tuo bucket S3.

1. Invia l'URL del file audio ad Amazon Transcribe e attende il completamento del processo di trascrizione.

   Il tempo necessario per completare il processo di trascrizione dipende dalla durata del file audio. Supponiamo siano minuti, non secondi.
**Suggerimento**  
Per migliorare la qualità della trascrizione, è possibile configurare un [vocabolario personalizzato](https://docs.aws.amazon.com/transcribe/latest/dg/API_CreateVocabulary.html) per Amazon Transcribe.

1. Una volta completato il processo di trascrizione, lo script estrae la trascrizione, la riduce a 5.000 caratteri e la invia ad Amazon Comprehend per l'analisi del sentiment e delle parole chiave.

1. Infine, lo script aggiunge la trascrizione completa, le parole chiave, il sentimento e il timestamp corrente a un documento JSON e lo indicizza in Service. OpenSearch 

**Suggerimento**  
[LibriVox](https://librivox.org/)dispone di audiolibri di dominio pubblico che puoi usare per i test.

## (Facoltativo) Fase 3: Indicizzazione dei dati di esempio
<a name="walkthrough-sample-data"></a>

Se non si dispone di un gruppo di registrazioni di chiamate (chi le ha, effettivamente?) è possibile [indicizzare](indexing.md) i documenti campione in [sample-calls.zip](samples/sample-calls.zip), con un risultato simile a quello prodotto da `call-center.py`.

1. Creare un file denominato `bulk-helper.py`:

   ```
   import boto3
   from opensearchpy import OpenSearch, RequestsHttpConnection
   import json
   from requests_aws4auth import AWS4Auth
   
   host = '' # For example, my-test-domain.us-west-2.es.amazonaws.com
   region = '' # For example, us-west-2
   service = 'es'
   
   bulk_file = open('sample-calls.bulk', 'r').read()
   
   credentials = boto3.Session().get_credentials()
   awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
   
   search = OpenSearch(
       hosts = [{'host': host, 'port': 443}],
       http_auth = awsauth,
       use_ssl = True,
       verify_certs = True,
       connection_class = RequestsHttpConnection
   )
   
   response = search.bulk(bulk_file)
   print(json.dumps(response, indent=2, sort_keys=True))
   ```

1. Aggiornare le prime due variabili per `host` e `region`.

1. Installare il pacchetto necessario utilizzando il seguente comando:

   ```
   pip install opensearch-py
   ```

1. Scaricare e decomprimere [sample-calls.zip](samples/sample-calls.zip).

1. Posizionare `sample-calls.bulk` nella stessa directory di `bulk-helper.py` ed eseguire lo script helper. Di seguito è riportato un output di esempio:

   ```
   $ python bulk-helper.py
   {
     "errors": false,
     "items": [
       {
         "index": {
           "_id": "1",
           "_index": "support-calls",
           "_primary_term": 1,
           "_seq_no": 42,
           "_shards": {
             "failed": 0,
             "successful": 1,
             "total": 2
           },
           "_type": "_doc",
           "_version": 9,
           "result": "updated",
           "status": 200
         }
       },
       ...
     ],
     "took": 27
   }
   ```

## Fase 4: Analisi e visualizzazione dei dati
<a name="walkthrough-analysis"></a>

Ora che hai alcuni dati in OpenSearch Service, puoi visualizzarli utilizzando i dashboard. OpenSearch 

1. Accedi a `https://search-domain.region.es.amazonaws.com/_dashboards`.

1. Prima di poter utilizzare le OpenSearch dashboard, è necessario un modello di indice. Dashboards usa modelli di indice per limitare l'analisi a uno o più indici. Per abbinare l'indice `support-calls` creato da `call-center.py`, passare a **Gestione degli stack**, **Modelli di indice** e definire un modello di indice di `support*`, quindi scegliere **Approfondimenti**.

1. In **Time Filter field name (Nome campo Filtro tempo)**, scegliere **timestamp**.

1. Ora è possibile iniziare a creare le visualizzazioni. Scegliere **Visualize (Visualizza)**, quindi aggiungere una nuova visualizzazione.

1. Scegliere il grafico a torta e il modello dell'indice `support*`.

1. La visualizzazione predefinita è di base, quindi scegliere **Split Slices (Dividi sezioni)** per creare una visualizzazione più interessante.

   Per **Aggregation (Aggregazione)** scegliere **Terms (Termini)**. In **Field (Campo)**, scegliere **sentiment.keyword**. Quindi selezionare **Apply changes (Applica modifiche)** e poi **Save (Salva)**.  
![\[Configurazione di esempio per un grafico a torta di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/sentiment-pie-chart.png)

1. Tornare alla pagina **Visualize (Visualizza)** e aggiungere un'altra visualizzazione. Questa volta, scegliere il grafico a barre orizzontali.

1. Scegliere **Split Series (Dividi serie)**.

   Per **Aggregation (Aggregazione)** scegliere **Terms (Termini)**. In **Field (Campo)**, scegliere **keywords.keyword** e modificare **Size (Dimensioni)** in 20. Quindi selezionare **Apply Changes (Applica modifiche)** e poi **Save (Salva)**.  
![\[Configurazione di esempio per un grafico a barre orizzontali di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/keyword-bar-chart.png)

1. Tornare alla pagina **Visualize (Visualizza)** e aggiungere una visualizzazione finale, un grafico a barre verticali.

1. Scegliere **Split Series (Dividi serie)**. In **Aggregation (Aggregazione)**, scegliere **Date Histogram (Istogramma date)**. In **Field (Campo)**, scegliere **timestamp** e modificare **Interval (Intervallo)** in **Daily (Giornaliero)**.

1. Scegliere **Metrics & Axes (Parametri e assi)** e cambiare **Mode (Modalità)** in **normal (normale)**.

1. Selezionare **Apply Changes (Applica modifiche)** e poi **Save (Salva)**.  
![\[Configurazione di esempio per un grafico a barre verticali di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/timestamp-bar-chart-2.png)

1. Ora che si dispone di tre visualizzazioni, è possibile aggiungerle a una visualizzazione di Dashboards. Scegliere **Dashboard (Pannello di controllo)**, creare un pannello di controllo e aggiungere le visualizzazioni.  
![\[Visualizzazione di Dashboards di esempio.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/dashboard-2.png)

## Fase 5: Pulizia delle risorse e fasi successive
<a name="walkthrough-next-steps"></a>

Per evitare addebiti inutili, elimina il bucket S3 e OpenSearch il dominio di servizio. Per ulteriori informazioni, consulta [Delete a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html#delete-bucket) nella *Amazon Simple Storage Service User Guide* e [Delete an OpenSearch Service domain](gsgdeleting.md) in questa guida.

Le trascrizioni richiedono molto meno spazio su disco rispetto ai file. MP3 Potresti riuscire ad abbreviare il MP3 periodo di conservazione, ad esempio da tre mesi di registrazioni delle chiamate a un mese, conservare anni di trascrizioni e comunque risparmiare sui costi di archiviazione.

Puoi anche automatizzare il processo di trascrizione utilizzando and AWS Step Functions Lambda, aggiungere metadati aggiuntivi prima dell'indicizzazione o creare visualizzazioni più complesse per adattarle al tuo caso d'uso esatto.