Há mais exemplos de AWS SDK disponíveis no repositório [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplos do Amazon Transcribe usando AWS CLI
<a name="cli_2_transcribe_code_examples"></a>

Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o Amazon Transcribe.

*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.

Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.

**Topics**
+ [Ações](#actions)

## Ações
<a name="actions"></a>

### `create-language-model`
<a name="transcribe_CreateLanguageModel_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `create-language-model`.

**AWS CLI**  
**Exemplo 1: criar um modelo de linguagem personalizado usando dados de treinamento e ajuste.**  
O exemplo `create-language-model` a seguir cria um modelo de idioma personalizado. Você pode usar um modelo de idioma personalizado para melhorar o desempenho da transcrição em domínios como jurídico, hotelaria e turismo, finanças e seguros. Em language-code, insira um código de idioma válido. Para base-model-name, especifique um modelo básico que seja mais adequado para a taxa de amostragem do áudio que você deseja transcrever com seu modelo de idioma personalizado. Em model-name, especifique o nome que você deseja chamar o modelo de idioma personalizado.  

```
aws transcribe create-language-model \
    --language-code language-code \
    --base-model-name base-model-name \
    --model-name cli-clm-example \
    --input-data-config S3Uri="s3://amzn-s3-demo-bucket/Amazon-S3-Prefix-for-training-data",TuningDataS3Uri="s3://amzn-s3-demo-bucket/Amazon-S3-Prefix-for-tuning-data",DataAccessRoleArn="arn:aws:iam::AWS-account-number:role/IAM-role-with-permissions-to-create-a-custom-language-model"
```
Saída:  

```
{
    "LanguageCode": "language-code",
    "BaseModelName": "base-model-name",
    "ModelName": "cli-clm-example",
    "InputDataConfig": {
        "S3Uri": "s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/",
        "TuningDataS3Uri": "s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/",
        "DataAccessRoleArn": "arn:aws:iam::AWS-account-number:role/IAM-role-with-permissions-create-a-custom-language-model"
    },
    "ModelStatus": "IN_PROGRESS"
}
```
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 2: criar um modelo de linguagem personalizado usando somente dados de treinamento.**  
O exemplo de `create-language-model` a seguir transcreve o arquivo de áudio. Você pode usar um modelo de idioma personalizado para melhorar o desempenho da transcrição em domínios como jurídico, hotelaria e turismo, finanças e seguros. Em language-code, insira um código de idioma válido. Para base-model-name, especifique um modelo básico que seja mais adequado para a taxa de amostragem do áudio que você deseja transcrever com seu modelo de idioma personalizado. Em model-name, especifique o nome que você deseja chamar o modelo de idioma personalizado.  

```
aws transcribe create-language-model \
    --language-code en-US \
    --base-model-name base-model-name \
    --model-name cli-clm-example \
    --input-data-config S3Uri="s3://amzn-s3-demo-bucket/Amazon-S3-Prefix-For-Training-Data",DataAccessRoleArn="arn:aws:iam::AWS-account-number:role/IAM-role-with-permissions-to-create-a-custom-language-model"
```
Saída:  

```
{
    "LanguageCode": "en-US",
    "BaseModelName": "base-model-name",
    "ModelName": "cli-clm-example",
    "InputDataConfig": {
        "S3Uri": "s3://amzn-s3-demo-bucket/Amazon-S3-Prefix-For-Training-Data/",
        "DataAccessRoleArn": "arn:aws:iam::your-AWS-account-number:role/IAM-role-with-permissions-to-create-a-custom-language-model"
    },
    "ModelStatus": "IN_PROGRESS"
}
```
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [CreateLanguageModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/create-language-model.html)em *Referência de AWS CLI Comandos*. 

### `create-medical-vocabulary`
<a name="transcribe_CreateMedicalVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `create-medical-vocabulary`.

**AWS CLI**  
**Para criar um vocabulário médico personalizado**  
O exemplo de `create-medical-vocabulary` a seguir cria um vocabulário personalizado. Para criar um vocabulário personalizado, você deve ter criado um arquivo de texto com todos os termos que deseja transcrever com mais precisão. Para vocabulary-file-uri, especifique o URI do Amazon Simple Storage Service (Amazon S3) desse arquivo de texto. Em language-code, especifique um código de idioma correspondente ao idioma do vocabulário personalizado. Em vocabulary-name, especifique como você deseja chamar seu vocabulário personalizado.  

```
aws transcribe create-medical-vocabulary \
    --vocabulary-name cli-medical-vocab-example \
    --language-code language-code \
    --vocabulary-file-uri https://amzn-s3-demo-bucket.AWS-Region.amazonaws.com/the-text-file-for-the-medical-custom-vocabulary.txt
```
Saída:  

```
{
    "VocabularyName": "cli-medical-vocab-example",
    "LanguageCode": "language-code",
    "VocabularyState": "PENDING"
}
```
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [CreateMedicalVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/create-medical-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `create-vocabulary-filter`
<a name="transcribe_CreateVocabularyFilter_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `create-vocabulary-filter`.

**AWS CLI**  
**Para criar um filtro de vocabulário**  
O exemplo `create-vocabulary-filter` a seguir cria um filtro de vocabulário que usa um arquivo de texto que contém uma lista de palavras que você não gostaria que aparecessem em uma transcrição. Em language-code, especifique o código de idioma correspondente ao idioma do seu filtro de vocabulário. Para vocabulary-filter-file-uri, especifique o URI do Amazon Simple Storage Service (Amazon S3) do arquivo de texto. Para vocabulary-filter-name, especifique o nome do seu filtro de vocabulário.  

```
aws transcribe create-vocabulary-filter \
    --language-code language-code \
    --vocabulary-filter-file-uri s3://amzn-s3-demo-bucket/vocabulary-filter.txt \
    --vocabulary-filter-name cli-vocabulary-filter-example
```
Saída:  

```
{
    "VocabularyFilterName": "cli-vocabulary-filter-example",
    "LanguageCode": "language-code"
}
```
Para obter mais informações, consulte [Como filtrar palavras indesejadas](https://docs.aws.amazon.com/transcribe/latest/dg/filter-unwanted-words.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [CreateVocabularyFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/create-vocabulary-filter.html)em *Referência de AWS CLI Comandos*. 

### `create-vocabulary`
<a name="transcribe_CreateVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `create-vocabulary`.

**AWS CLI**  
**Como criar um vocabulário personalizado**  
O exemplo de `create-vocabulary` a seguir cria um vocabulário personalizado. Para criar um vocabulário personalizado, você deve ter criado um arquivo de texto com todos os termos que deseja transcrever com mais precisão. Para vocabulary-file-uri, especifique o URI do Amazon Simple Storage Service (Amazon S3) desse arquivo de texto. Em language-code, especifique um código de idioma correspondente ao idioma do vocabulário personalizado. Em vocabulary-name, especifique como você deseja chamar seu vocabulário personalizado.  

```
aws transcribe create-vocabulary \
    --language-code language-code \
    --vocabulary-name cli-vocab-example \
    --vocabulary-file-uri s3://amzn-s3-demo-bucket/Amazon-S3-prefix/the-text-file-for-the-custom-vocabulary.txt
```
Saída:  

```
{
    "VocabularyName": "cli-vocab-example",
    "LanguageCode": "language-code",
    "VocabularyState": "PENDING"
}
```
Para obter mais informações, consulte [Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [CreateVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/create-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `delete-language-model`
<a name="transcribe_DeleteLanguageModel_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-language-model`.

**AWS CLI**  
**Para excluir um modelo de idioma personalizado**  
O exemplo `delete-language-model` a seguir exclui um modelo de idioma personalizado.  

```
aws transcribe delete-language-model \
    --model-name model-name
```
Este comando não produz saída.  
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [DeleteLanguageModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-language-model.html)em *Referência de AWS CLI Comandos*. 

### `delete-medical-transcription-job`
<a name="transcribe_DeleteMedicalTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-medical-transcription-job`.

**AWS CLI**  
**Como excluir um trabalho de transcrição médica**  
O exemplo de `delete-medical-transcription-job` a seguir exclui um trabalho de transcrição médica.  

```
aws transcribe delete-medical-transcription-job \
    --medical-transcription-job-name medical-transcription-job-name
```
Este comando não produz saída.  
Para obter mais informações, consulte [DeleteMedicalTranscriptionJob](https://docs.aws.amazon.com/transcribe/latest/dg/API_DeleteMedicalTranscriptionJob.html)o *Amazon Transcribe* Developer Guide.  
+  Para obter detalhes da API, consulte [DeleteMedicalTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-medical-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `delete-medical-vocabulary`
<a name="transcribe_DeleteMedicalVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-medical-vocabulary`.

**AWS CLI**  
**Para excluir um vocabulário médico personalizado**  
O exemplo `delete-medical-vocabulary` a seguir exclui um vocabulário médico personalizado. Em vocabulary-name, especifique o nome do vocabulário médico personalizado.  

```
aws transcribe delete-vocabulary \
    --vocabulary-name medical-custom-vocabulary-name
```
Este comando não produz saída.  
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [DeleteMedicalVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-medical-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `delete-transcription-job`
<a name="transcribe_DeleteTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-transcription-job`.

**AWS CLI**  
**Como excluir um dos trabalhos de transcrição**  
O exemplo de `delete-transcription-job` a seguir exclui um dos trabalhos de transcrição.  

```
aws transcribe delete-transcription-job \
    --transcription-job-name your-transcription-job
```
Este comando não produz saída.  
Para obter mais informações, consulte [DeleteTranscriptionJob](https://docs.aws.amazon.com/transcribe/latest/dg/API_DeleteTranscriptionJob.html)o *Amazon Transcribe* Developer Guide.  
+  Para obter detalhes da API, consulte [DeleteTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `delete-vocabulary-filter`
<a name="transcribe_DeleteVocabularyFilter_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-vocabulary-filter`.

**AWS CLI**  
**Para excluir um filtro de vocabulário**  
O exemplo `delete-vocabulary-filter` a seguir exclui um filtro de vocabulário personalizado.  

```
aws transcribe delete-vocabulary-filter \
    --vocabulary-filter-name vocabulary-filter-name
```
Este comando não produz saída.  
Para obter mais informações, consulte [Como filtrar palavras indesejadas](https://docs.aws.amazon.com/transcribe/latest/dg/filter-unwanted-words.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [DeleteVocabularyFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-vocabulary-filter.html)em *Referência de AWS CLI Comandos*. 

### `delete-vocabulary`
<a name="transcribe_DeleteVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `delete-vocabulary`.

**AWS CLI**  
**Como excluir um vocabulário personalizado**  
O exemplo de `delete-vocabulary` a seguir exclui um vocabulário personalizado.  

```
aws transcribe delete-vocabulary \
    --vocabulary-name vocabulary-name
```
Este comando não produz saída.  
Para obter mais informações, consulte [Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [DeleteVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/delete-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `describe-language-model`
<a name="transcribe_DescribeLanguageModel_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `describe-language-model`.

**AWS CLI**  
**Para obter informações sobre um modelo de linguagem personalizado específico**  
O exemplo `describe-language-model` a seguir coleta informações sobre um modelo de idioma personalizado específico. Por exemplo, abaixo, BaseModelName você pode ver se seu modelo é treinado usando um WideBand modelo NarrowBand ou. Modelos de linguagem personalizados com um modelo NarrowBand básico podem transcrever áudio com uma taxa de amostragem inferior a 16 kHz. Os modelos de linguagem que usam um modelo WideBand básico podem transcrever áudio com uma taxa de amostragem maior que 16 kHz. O parâmetro S3Uri indica o prefixo Amazon S3 que você usou para acessar os dados de treinamento para criar o modelo de idioma personalizado.  

```
aws transcribe describe-language-model \
    --model-name cli-clm-example
```
Saída:  

```
{
    "LanguageModel": {
        "ModelName": "cli-clm-example",
        "CreateTime": "2020-09-25T17:57:38.504000+00:00",
        "LastModifiedTime": "2020-09-25T17:57:48.585000+00:00",
        "LanguageCode": "language-code",
        "BaseModelName": "base-model-name",
        "ModelStatus": "IN_PROGRESS",
        "UpgradeAvailability": false,
        "InputDataConfig": {
            "S3Uri": "s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/",
            "TuningDataS3Uri": "s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/",
            "DataAccessRoleArn": "arn:aws:iam::AWS-account-number:role/IAM-role-with-permissions-to-create-a-custom-language-model"
        }
    }
}
```
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [DescribeLanguageModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/describe-language-model.html)em *Referência de AWS CLI Comandos*. 

### `get-medical-transcription-job`
<a name="transcribe_GetMedicalTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `get-medical-transcription-job`.

**AWS CLI**  
**Para obter informações sobre um trabalho de transcrição médica específico**  
O exemplo `get-medical-transcription-job` a seguir coleta informações sobre um trabalho de transcrição médica específico. Para acessar os resultados da transcrição, use o TranscriptFileUri parâmetro. Se você tiver habilitado atributos adicionais no trabalho de transcrição, é possível vê-los no objeto Configurações. O parâmetro Specialty mostra a especialidade médica do provedor. O parâmetro Type indica se a fala na tarefa de transcrição é de uma conversa médica ou de um ditado médico.  

```
aws transcribe get-medical-transcription-job \
    --medical-transcription-job-name vocabulary-dictation-medical-transcription-job
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "vocabulary-dictation-medical-transcription-job",
        "TranscriptionJobStatus": "COMPLETED",
        "LanguageCode": "en-US",
        "MediaSampleRateHertz": 48000,
        "MediaFormat": "mp4",
        "Media": {
            "MediaFileUri": "s3://Amazon-S3-Prefix/your-audio-file.file-extension"
        },
        "Transcript": {
            "TranscriptFileUri": "https://s3.Region.amazonaws.com/Amazon-S3-Prefix/vocabulary-dictation-medical-transcription-job.json"
        },
        "StartTime": "2020-09-21T21:17:27.045000+00:00",
        "CreationTime": "2020-09-21T21:17:27.016000+00:00",
        "CompletionTime": "2020-09-21T21:17:59.561000+00:00",
        "Settings": {
            "ChannelIdentification": false,
            "ShowAlternatives": false,
            "VocabularyName": "cli-medical-vocab-example"
        },
        "Specialty": "PRIMARYCARE",
        "Type": "DICTATION"
    }
}
```
Para obter mais informações, consulte [Transcrição em lotes](https://docs.aws.amazon.com/transcribe/latest/dg/batch-med-transcription.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [GetMedicalTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/get-medical-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `get-medical-vocabulary`
<a name="transcribe_GetMedicalVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `get-medical-vocabulary`.

**AWS CLI**  
**Para obter informações sobre um vocabulário médico personalizado**  
O exemplo `get-medical-vocabulary` a seguir coleta informações sobre um vocabulário médico personalizado. Você pode usar o VocabularyState parâmetro para ver o estado de processamento do vocabulário. Se estiver PRONTO, você poderá usá-lo na StartMedicalTranscriptionJob operação. :  

```
aws transcribe get-medical-vocabulary \
    --vocabulary-name medical-vocab-example
```
Saída:  

```
{
    "VocabularyName": "medical-vocab-example",
    "LanguageCode": "en-US",
    "VocabularyState": "READY",
    "LastModifiedTime": "2020-09-19T23:59:04.349000+00:00",
    "DownloadUri": "https://link-to-download-the-text-file-used-to-create-your-medical-custom-vocabulary"
}
```
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [GetMedicalVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/get-medical-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `get-transcription-job`
<a name="transcribe_GetTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `get-transcription-job`.

**AWS CLI**  
**Como obter informações sobre um trabalho de transcrição específico**  
O exemplo de `get-transcription-job` a seguir coleta informações sobre um trabalho de transcrição específico. Para acessar os resultados da transcrição, use o TranscriptFileUri parâmetro. Use o MediaFileUri parâmetro para ver qual arquivo de áudio você transcreveu com esse trabalho. É possível usar o objeto Configurações para ver os recursos opcionais habilitados no trabalho de transcrição.  

```
aws transcribe get-transcription-job \
    --transcription-job-name your-transcription-job
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "your-transcription-job",
        "TranscriptionJobStatus": "COMPLETED",
        "LanguageCode": "language-code",
        "MediaSampleRateHertz": 48000,
        "MediaFormat": "mp4",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.file-extension"
        },
        "Transcript": {
            "TranscriptFileUri": "https://Amazon-S3-file-location-of-transcription-output"
        },
        "StartTime": "2020-09-18T22:27:23.970000+00:00",
        "CreationTime": "2020-09-18T22:27:23.948000+00:00",
        "CompletionTime": "2020-09-18T22:28:21.197000+00:00",
        "Settings": {
            "ChannelIdentification": false,
            "ShowAlternatives": false
        },
        "IdentifyLanguage": true,
        "IdentifiedLanguageScore": 0.8672199249267578
    }
}
```
Para obter mais informações, consulte [Conceitos básicos (interface de linha de AWS comando)](https://docs.aws.amazon.com/transcribe/latest/dg/getting-started-cli.html) no Guia do *desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [GetTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/get-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `get-vocabulary-filter`
<a name="transcribe_GetVocabularyFilter_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `get-vocabulary-filter`.

**AWS CLI**  
**Para obter informações sobre um filtro de vocabulário**  
O exemplo `get-vocabulary-filter` a seguir coleta informações sobre um filtro de vocabulário. Você pode usar o DownloadUri parâmetro para obter a lista de palavras usadas para criar o filtro de vocabulário.  

```
aws transcribe get-vocabulary-filter \
    --vocabulary-filter-name testFilter
```
Saída:  

```
{
    "VocabularyFilterName": "testFilter",
    "LanguageCode": "language-code",
    "LastModifiedTime": "2020-05-07T22:39:32.147000+00:00",
    "DownloadUri": "https://Amazon-S3-location-to-download-your-vocabulary-filter"
}
```
Para obter mais informações, consulte [Filtrar palavras indesejadas](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [GetVocabularyFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/get-vocabulary-filter.html)em *Referência de AWS CLI Comandos*. 

### `get-vocabulary`
<a name="transcribe_GetVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `get-vocabulary`.

**AWS CLI**  
**Como obter informações sobre um vocabulário personalizado**  
O exemplo de `get-vocabulary` a seguir coleta informações sobre um vocabulário personalizado criado anteriormente.  

```
aws transcribe get-vocabulary \
    --vocabulary-name cli-vocab-1
```
Saída:  

```
{
    "VocabularyName": "cli-vocab-1",
    "LanguageCode": "language-code",
    "VocabularyState": "READY",
    "LastModifiedTime": "2020-09-19T23:22:32.836000+00:00",
    "DownloadUri": "https://link-to-download-the-text-file-used-to-create-your-custom-vocabulary"
}
```
Para obter mais informações, consulte [Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [GetVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/get-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `list-language-models`
<a name="transcribe_ListLanguageModels_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-language-models`.

**AWS CLI**  
**Para listar seus modelos de linguagem personalizados**  
O `list-language-models` exemplo a seguir lista os modelos de idioma personalizados associados à sua AWS conta e região. Você pode usar os parâmetros `S3Uri` e `TuningDataS3Uri` para encontrar os prefixos do Amazon S3 que você usou como dados de treinamento ou dados de ajuste. BaseModelName Informa se você usou um NarrowBand WideBand modelo ou para criar um modelo de linguagem personalizado. Você pode transcrever áudio com uma taxa de amostragem inferior a 16 kHz com um modelo de linguagem personalizado usando um modelo básico. NarrowBand Você pode transcrever áudio de 16 kHz ou mais com um modelo de idioma personalizado usando um modelo básico. WideBand O parâmetro `ModelStatus` mostra se você pode usar o modelo de idioma personalizado em um trabalho de transcrição. Se o valor for CONCLUÍDO, você poderá usá-lo em um trabalho de transcrição.  

```
aws transcribe list-language-models
```
Saída:  

```
{
    "Models": [
        {
            "ModelName": "cli-clm-2",
            "CreateTime": "2020-09-25T17:57:38.504000+00:00",
            "LastModifiedTime": "2020-09-25T17:57:48.585000+00:00",
            "LanguageCode": "language-code",
            "BaseModelName": "WideBand",
            "ModelStatus": "IN_PROGRESS",
            "UpgradeAvailability": false,
            "InputDataConfig": {
                "S3Uri": "s3://amzn-s3-demo-bucket/clm-training-data/",
                "TuningDataS3Uri": "s3://amzn-s3-demo-bucket/clm-tuning-data/",
                "DataAccessRoleArn": "arn:aws:iam::AWS-account-number:role/IAM-role-used-to-create-the-custom-language-model"
            }
        },
        {
            "ModelName": "cli-clm-1",
            "CreateTime": "2020-09-25T17:16:01.835000+00:00",
            "LastModifiedTime": "2020-09-25T17:16:15.555000+00:00",
            "LanguageCode": "language-code",
            "BaseModelName": "WideBand",
            "ModelStatus": "IN_PROGRESS",
            "UpgradeAvailability": false,
            "InputDataConfig": {
                "S3Uri": "s3://amzn-s3-demo-bucket/clm-training-data/",
                "DataAccessRoleArn": "arn:aws:iam::AWS-account-number:role/IAM-role-used-to-create-the-custom-language-model"
            }
        },
        {
            "ModelName": "clm-console-1",
            "CreateTime": "2020-09-24T19:26:28.076000+00:00",
            "LastModifiedTime": "2020-09-25T04:25:22.271000+00:00",
            "LanguageCode": "language-code",
            "BaseModelName": "NarrowBand",
            "ModelStatus": "COMPLETED",
            "UpgradeAvailability": false,
            "InputDataConfig": {
                "S3Uri": "s3://amzn-s3-demo-bucket/clm-training-data/",
                "DataAccessRoleArn": "arn:aws:iam::AWS-account-number:role/IAM-role-used-to-create-the-custom-language-model"
            }
        }
    ]
}
```
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [ListLanguageModels](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-language-models.html)em *Referência de AWS CLI Comandos*. 

### `list-medical-transcription-jobs`
<a name="transcribe_ListMedicalTranscriptionJobs_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-medical-transcription-jobs`.

**AWS CLI**  
**Para listar os trabalhos de transcrição médica**  
O `list-medical-transcription-jobs` exemplo a seguir lista os trabalhos de transcrição médica associados à sua AWS conta e região. Para obter mais informações sobre um trabalho de transcrição específico, copie o valor de um MedicalTranscriptionJobName parâmetro na saída da transcrição e especifique esse valor para a `MedicalTranscriptionJobName` opção do `get-medical-transcription-job` comando. Para ver mais trabalhos de transcrição, copie o valor do NextToken parâmetro, execute o `list-medical-transcription-jobs` comando novamente e especifique esse valor na `--next-token` opção.  

```
aws transcribe list-medical-transcription-jobs
```
Saída:  

```
{
    "NextToken": "3/PblzkiGhzjER3KHuQt2fmbPLF7cDYafjFMEoGn44ON/gsuUSTIkGyanvRE6WMXFd/ZTEc2EZj+P9eii/z1O2FDYli6RLI0WoRX4RwMisVrh9G0Kie0Y8ikBCdtqlZB10Wa9McC+ebOl+LaDtZPC4u6ttoHLRlEfzqstHXSgapXg3tEBtm9piIaPB6MOM5BB6t86+qtmocTR/qrteHZBBudhTfbCwhsxaqujHiiUvFdm3BQbKKWIW06yV9b+4f38oD2lVIan+vfUs3gBYAl5VTDmXXzQPBQOHPjtwmFI+IWX15nSUjWuN3TUylHgPWzDaYT8qBtu0Z+3UG4V6b+K2CC0XszXg5rBq9hYgNzy4XoFh/6s5DoSnzq49Q9xHgHdT2yBADFmvFK7myZBsj75+2vQZOSVpWUPy3WT/32zFAcoELHR4unuWhXPwjbKU+mFYfUjtTZ8n/jq7aQEjQ42A+X/7K6JgOcdVPtEg8PlDr5kgYYG3q3OmYXX37U3FZuJmnTI63VtIXsNnOU5eGoYObtpk00Nq9UkzgSJxqj84ZD5n+S0EGy9ZUYBJRRcGeYUM3Q4DbSJfUwSAqcFdLIWZdp8qIREMQIBWy7BLwSdyqsQo2vRrd53hm5aWM7SVf6pPq6X/IXR5+1eUOOD8/coaTT4ES2DerbV6RkV4o0VT1d0SdVX/MmtkNG8nYj8PqU07w7988quh1ZP6D80veJS1q73tUUR9MjnGernW2tAnvnLNhdefBcD+sZVfYq3iBMFY7wTy1P1G6NqW9GrYDYoX3tTPWlD7phpbVSyKrh/PdYrps5UxnsGoA1b7L/FfAXDfUoGrGUB4N3JsPYXX9D++g+6gV1qBBs/WfF934aKqfD6UTggm/zV3GAOWiBpfvAZRvEb924i6yGHyMC7y54O1ZAwSBupmI+FFd13CaPO4kN1vJlth6aM5vUPXg4BpyUhtbRhwD/KxCvf9K0tLJGyL1A==",
    "MedicalTranscriptionJobSummaries": [
        {
            "MedicalTranscriptionJobName": "vocabulary-dictation-medical-transcription-job",
            "CreationTime": "2020-09-21T21:17:27.016000+00:00",
            "StartTime": "2020-09-21T21:17:27.045000+00:00",
            "CompletionTime": "2020-09-21T21:17:59.561000+00:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "CUSTOMER_BUCKET",
            "Specialty": "PRIMARYCARE",
            "Type": "DICTATION"
        },
        {
            "MedicalTranscriptionJobName": "alternatives-dictation-medical-transcription-job",
            "CreationTime": "2020-09-21T21:01:14.569000+00:00",
            "StartTime": "2020-09-21T21:01:14.592000+00:00",
            "CompletionTime": "2020-09-21T21:01:43.606000+00:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "CUSTOMER_BUCKET",
            "Specialty": "PRIMARYCARE",
            "Type": "DICTATION"
        },
        {
            "MedicalTranscriptionJobName": "alternatives-conversation-medical-transcription-job",
            "CreationTime": "2020-09-21T19:09:18.171000+00:00",
            "StartTime": "2020-09-21T19:09:18.199000+00:00",
            "CompletionTime": "2020-09-21T19:10:22.516000+00:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "CUSTOMER_BUCKET",
            "Specialty": "PRIMARYCARE",
            "Type": "CONVERSATION"
        },
        {
            "MedicalTranscriptionJobName": "speaker-id-conversation-medical-transcription-job",
            "CreationTime": "2020-09-21T18:43:37.157000+00:00",
            "StartTime": "2020-09-21T18:43:37.265000+00:00",
            "CompletionTime": "2020-09-21T18:44:21.192000+00:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "CUSTOMER_BUCKET",
            "Specialty": "PRIMARYCARE",
            "Type": "CONVERSATION"
        },
        {
            "MedicalTranscriptionJobName": "multichannel-conversation-medical-transcription-job",
            "CreationTime": "2020-09-20T23:46:44.053000+00:00",
            "StartTime": "2020-09-20T23:46:44.081000+00:00",
            "CompletionTime": "2020-09-20T23:47:35.851000+00:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "CUSTOMER_BUCKET",
            "Specialty": "PRIMARYCARE",
            "Type": "CONVERSATION"
        }
    ]
}
```
*Para obter mais informações, consulte https://docs.aws.amazon.com/transcribe/ latest/dg/batch -med-transcription.html> no Guia do desenvolvedor do Amazon Transcribe.*  
+  Para obter detalhes da API, consulte [ListMedicalTranscriptionJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-medical-transcription-jobs.html)em *Referência de AWS CLI Comandos*. 

### `list-medical-vocabularies`
<a name="transcribe_ListMedicalVocabularies_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-medical-vocabularies`.

**AWS CLI**  
**Para listar os vocabulários médicos personalizados**  
O `list-medical-vocabularies` exemplo a seguir lista os vocabulários médicos personalizados associados à sua AWS conta e região. Para ter mais informações sobre um trabalho de transcrição específico, copie o valor de um parâmetro `MedicalTranscriptionJobName` na saída da transcrição e especifique esse valor na opção `MedicalTranscriptionJobName` do comando `get-medical-transcription-job`. Para ver mais dos seus trabalhos de transcrição, copie o valor do parâmetro `NextToken`, execute o comando `list-medical-transcription-jobs` novamente e especifique esse valor na opção `--next-token`.  

```
aws transcribe list-medical-vocabularies
```
Saída:  

```
{
    "Vocabularies": [
        {
            "VocabularyName": "cli-medical-vocab-2",
            "LanguageCode": "en-US",
            "LastModifiedTime": "2020-09-21T21:44:59.521000+00:00",
            "VocabularyState": "READY"
        },
        {
            "VocabularyName": "cli-medical-vocab-1",
            "LanguageCode": "en-US",
            "LastModifiedTime": "2020-09-19T23:59:04.349000+00:00",
            "VocabularyState": "READY"
        }
    ]
}
```
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [ListMedicalVocabularies](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-medical-vocabularies.html)em *Referência de AWS CLI Comandos*. 

### `list-transcription-jobs`
<a name="transcribe_ListTranscriptionJobs_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-transcription-jobs`.

**AWS CLI**  
**Para listar os trabalhos de transcrição**  
O `list-transcription-jobs` exemplo a seguir lista os trabalhos de transcrição associados à sua AWS conta e região.  

```
aws transcribe list-transcription-jobs
```
Saída:  

```
{
    "NextToken": "NextToken",
    "TranscriptionJobSummaries": [
        {
            "TranscriptionJobName": "speak-id-job-1",
            "CreationTime": "2020-08-17T21:06:15.391000+00:00",
            "StartTime": "2020-08-17T21:06:15.416000+00:00",
            "CompletionTime": "2020-08-17T21:07:05.098000+00:00",
            "LanguageCode": "language-code",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        },
        {
            "TranscriptionJobName": "job-1",
            "CreationTime": "2020-08-17T20:50:24.207000+00:00",
            "StartTime": "2020-08-17T20:50:24.230000+00:00",
            "CompletionTime": "2020-08-17T20:52:18.737000+00:00",
            "LanguageCode": "language-code",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        },
        {
            "TranscriptionJobName": "sdk-test-job-4",
            "CreationTime": "2020-08-17T20:32:27.917000+00:00",
            "StartTime": "2020-08-17T20:32:27.956000+00:00",
            "CompletionTime": "2020-08-17T20:33:15.126000+00:00",
            "LanguageCode": "language-code",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        },
        {
            "TranscriptionJobName": "Diarization-speak-id",
            "CreationTime": "2020-08-10T22:10:09.066000+00:00",
            "StartTime": "2020-08-10T22:10:09.116000+00:00",
            "CompletionTime": "2020-08-10T22:26:48.172000+00:00",
            "LanguageCode": "language-code",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        },
        {
            "TranscriptionJobName": "your-transcription-job-name",
            "CreationTime": "2020-07-29T17:45:09.791000+00:00",
            "StartTime": "2020-07-29T17:45:09.826000+00:00",
            "CompletionTime": "2020-07-29T17:46:20.831000+00:00",
            "LanguageCode": "language-code",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        }
    ]
}
```
Para obter mais informações, consulte [Conceitos básicos (interface de linha de AWS comando)](https://docs.aws.amazon.com/transcribe/latest/dg/getting-started-cli.html) no Guia do *desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [ListTranscriptionJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-transcription-jobs.html)em *Referência de AWS CLI Comandos*. 

### `list-vocabularies`
<a name="transcribe_ListVocabularies_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-vocabularies`.

**AWS CLI**  
**Para listar os vocabulários personalizados**  
O `list-vocabularies` exemplo a seguir lista os vocabulários personalizados associados à sua AWS conta e região.  

```
aws transcribe list-vocabularies
```
Saída:  

```
{
    "NextToken": "NextToken",
    "Vocabularies": [
        {
            "VocabularyName": "ards-test-1",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-04-27T22:00:27.330000+00:00",
            "VocabularyState": "READY"
        },
        {
            "VocabularyName": "sample-test",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-04-24T23:04:11.044000+00:00",
            "VocabularyState": "READY"
        },
        {
            "VocabularyName": "CRLF-to-LF-test-3-1",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-04-24T22:12:22.277000+00:00",
            "VocabularyState": "READY"
        },
        {
            "VocabularyName": "CRLF-to-LF-test-2",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-04-24T21:53:50.455000+00:00",
            "VocabularyState": "READY"
        },
        {
            "VocabularyName": "CRLF-to-LF-1-1",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-04-24T21:39:33.356000+00:00",
            "VocabularyState": "READY"
        }
    ]
}
```
Para obter mais informações, consulte [Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [ListVocabularies](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-vocabularies.html)em *Referência de AWS CLI Comandos*. 

### `list-vocabulary-filters`
<a name="transcribe_ListVocabularyFilters_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `list-vocabulary-filters`.

**AWS CLI**  
**Para listar seus filtros de vocabulário**  
O `list-vocabulary-filters` exemplo a seguir lista os filtros de vocabulário associados à sua AWS conta e região.  

```
aws transcribe list-vocabulary-filters
```
Saída:  

```
{
    "NextToken": "NextToken": [
        {
            "VocabularyFilterName": "testFilter",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-05-07T22:39:32.147000+00:00"
        },
        {
            "VocabularyFilterName": "testFilter2",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-05-21T23:29:35.174000+00:00"
        },
        {
            "VocabularyFilterName": "filter2",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-05-08T20:18:26.426000+00:00"
        },
        {
            "VocabularyFilterName": "filter-review",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-06-03T18:52:30.448000+00:00"
        },
        {
            "VocabularyFilterName": "crlf-filt",
            "LanguageCode": "language-code",
            "LastModifiedTime": "2020-05-22T19:42:42.737000+00:00"
        }
    ]
}
```
Para obter mais informações, consulte [Como filtrar palavras indesejadas](https://docs.aws.amazon.com/transcribe/latest/dg/filter-unwanted-words.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [ListVocabularyFilters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/list-vocabulary-filters.html)em *Referência de AWS CLI Comandos*. 

### `start-medical-transcription-job`
<a name="transcribe_StartMedicalTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `start-medical-transcription-job`.

**AWS CLI**  
**Exemplo 1: como transcrever um ditado médico armazenado como um arquivo de áudio**  
O exemplo de `start-medical-transcription-job` a seguir transcreve um arquivo de áudio. Especifique o local da saída da transcrição no parâmetro `OutputBucketName`.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://myfile.json
```
Conteúdo de `myfile.json`:  

```
{
    "MedicalTranscriptionJobName": "simple-dictation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "DICTATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
    }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "simple-dictation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-20T00:35:22.256000+00:00",
        "CreationTime": "2020-09-20T00:35:22.218000+00:00",
        "Specialty": "PRIMARYCARE",
        "Type": "DICTATION"
    }
}
```
Para obter mais informações, consulte [Batch Transcription Overview](https://docs.aws.amazon.com/transcribe/latest/dg/batch-med-transcription.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 2: como transcrever um diálogo entre médico e paciente armazenado como um arquivo de áudio**  
O exemplo de `start-medical-transcription-job` a seguir transcreve um arquivo de áudio contendo um diálogo entre médico e paciente. Você especifica a localização da saída da transcrição no OutputBucketName parâmetro.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://mysecondfile.json
```
Conteúdo de `mysecondfile.json`:  

```
{
    "MedicalTranscriptionJobName": "simple-dictation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "CONVERSATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
    }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "simple-conversation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-20T23:19:49.965000+00:00",
        "CreationTime": "2020-09-20T23:19:49.941000+00:00",
        "Specialty": "PRIMARYCARE",
        "Type": "CONVERSATION"
    }
}
```
Para obter mais informações, consulte [Batch Transcription Overview](https://docs.aws.amazon.com/transcribe/latest/dg/batch-med-transcription.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 3: como transcrever um arquivo de áudio multicanal de um diálogo entre médico e paciente**  
O exemplo de `start-medical-transcription-job` a seguir transcreve o áudio de cada canal no arquivo de áudio e mescla as transcrições separadas de cada canal em uma única saída de transcrição. Especifique o local da saída da transcrição no parâmetro `OutputBucketName`.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://mythirdfile.json
```
Conteúdo de `mythirdfile.json`:  

```
{
    "MedicalTranscriptionJobName": "multichannel-conversation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "CONVERSATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
        "Media": {
          "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "Settings":{
          "ChannelIdentification": true
        }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "multichannel-conversation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-20T23:46:44.081000+00:00",
        "CreationTime": "2020-09-20T23:46:44.053000+00:00",
        "Settings": {
            "ChannelIdentification": true
        },
        "Specialty": "PRIMARYCARE",
        "Type": "CONVERSATION"
    }
}
```
Para obter mais informações, consulte [Channel Identification](https://docs.aws.amazon.com/transcribe/latest/dg/how-channel-id-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 4: como transcrever um arquivo de áudio de um diálogo entre médico e paciente e identificar quem está falando na saída da transcrição**  
O exemplo de `start-medical-transcription-job` a seguir transcreve um arquivo de áudio e rotula a fala de cada locutor na saída da transcrição. Especifique o local da saída da transcrição no parâmetro `OutputBucketName`.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://myfourthfile.json
```
Conteúdo de `myfourthfile.json`:  

```
{
    "MedicalTranscriptionJobName": "speaker-id-conversation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "CONVERSATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
    "Settings":{
        "ShowSpeakerLabels": true,
        "MaxSpeakerLabels": 2
        }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "speaker-id-conversation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-21T18:43:37.265000+00:00",
        "CreationTime": "2020-09-21T18:43:37.157000+00:00",
        "Settings": {
            "ShowSpeakerLabels": true,
            "MaxSpeakerLabels": 2
        },
        "Specialty": "PRIMARYCARE",
        "Type": "CONVERSATION"
    }
}
```
Para obter mais informações, consulte [Identifying Speakers](https://docs.aws.amazon.com/transcribe/latest/dg/diarization-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 5: como transcrever uma conversa médica armazenada como um arquivo de áudio com até duas alternativas de transcrição**  
O exemplo de `start-medical-transcription-job` a seguir cria até duas transcrições alternativas de um único arquivo de áudio. Cada transcrição tem um nível de confiança associado a ela. Por padrão, o Amazon Transcribe retorna a transcrição com o maior nível de confiança. É possível especificar que o Amazon Transcribe retorne transcrições adicionais com níveis de confiança mais baixos. Especifique o local da saída da transcrição no parâmetro `OutputBucketName`.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://myfifthfile.json
```
Conteúdo de `myfifthfile.json`:  

```
{
    "MedicalTranscriptionJobName": "alternatives-conversation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "CONVERSATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
    },
    "Settings":{
        "ShowAlternatives": true,
        "MaxAlternatives": 2
    }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "alternatives-conversation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-21T19:09:18.199000+00:00",
        "CreationTime": "2020-09-21T19:09:18.171000+00:00",
        "Settings": {
            "ShowAlternatives": true,
            "MaxAlternatives": 2
        },
        "Specialty": "PRIMARYCARE",
        "Type": "CONVERSATION"
    }
}
```
Para obter mais informações, consulte [Alternative Transcriptions](https://docs.aws.amazon.com/transcribe/latest/dg/how-alternatives-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 6: como transcrever um arquivo de áudio de um ditado médico com até duas transcrições alternativas**  
O exemplo de `start-medical-transcription-job` a seguir transcreve um arquivo de áudio e usa um filtro de vocabulário para mascarar qualquer palavra indesejada. Você especifica a localização da saída da transcrição no OutputBucketName parâmetro.  

```
aws transcribe start-medical-transcription-job \
    --cli-input-json file://mysixthfile.json
```
Conteúdo de `mysixthfile.json`:  

```
{
    "MedicalTranscriptionJobName": "alternatives-conversation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "DICTATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
    },
    "Settings":{
          "ShowAlternatives": true,
          "MaxAlternatives": 2
    }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "alternatives-dictation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-21T21:01:14.592000+00:00",
        "CreationTime": "2020-09-21T21:01:14.569000+00:00",
        "Settings": {
            "ShowAlternatives": true,
            "MaxAlternatives": 2
        },
        "Specialty": "PRIMARYCARE",
        "Type": "DICTATION"
    }
}
```
Para obter mais informações, consulte [Alternative Transcriptions](https://docs.aws.amazon.com/transcribe/latest/dg/how-alternatives-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 7: como transcrever um arquivo de áudio de um ditado médico com maior precisão usando um vocabulário personalizado**  
O exemplo de `start-medical-transcription-job` a seguir transcreve um arquivo de áudio e usa um vocabulário médico personalizado que você criou anteriormente para aumentar a precisão da transcrição. Especifique o local da saída da transcrição no parâmetro `OutputBucketName`.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myseventhfile.json
```
Conteúdo de `mysixthfile.json`:  

```
{
    "MedicalTranscriptionJobName": "vocabulary-dictation-medical-transcription-job",
    "LanguageCode": "language-code",
    "Specialty": "PRIMARYCARE",
    "Type": "DICTATION",
    "OutputBucketName":"amzn-s3-demo-bucket",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
    },
    "Settings":{
        "VocabularyName": "cli-medical-vocab-1"
    }
}
```
Saída:  

```
{
    "MedicalTranscriptionJob": {
        "MedicalTranscriptionJobName": "vocabulary-dictation-medical-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.extension"
        },
        "StartTime": "2020-09-21T21:17:27.045000+00:00",
        "CreationTime": "2020-09-21T21:17:27.016000+00:00",
        "Settings": {
            "VocabularyName": "cli-medical-vocab-1"
        },
        "Specialty": "PRIMARYCARE",
        "Type": "DICTATION"
    }
}
```
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary-med.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [StartMedicalTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/start-medical-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `start-transcription-job`
<a name="transcribe_StartTranscriptionJob_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `start-transcription-job`.

**AWS CLI**  
**Exemplo 1: como transcrever um arquivo de áudio**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myfile.json
```
Conteúdo de `myfile.json`:  

```
{
    "TranscriptionJobName": "cli-simple-transcription-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    }
}
```
Para obter mais informações, consulte [Conceitos básicos (interface de linha de AWS comando)](https://docs.aws.amazon.com/transcribe/latest/dg/getting-started-cli.html) no Guia do *desenvolvedor do Amazon Transcribe*.  
**Exemplo 2: como transcrever um arquivo de áudio multicanal**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio multicanal.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://mysecondfile.json
```
Conteúdo de `mysecondfile.json`:  

```
{
    "TranscriptionJobName": "cli-channelid-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    },
    "Settings":{
        "ChannelIdentification":true
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-channelid-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "the-language-of-your-transcription-job",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
        },
        "StartTime": "2020-09-17T16:07:56.817000+00:00",
        "CreationTime": "2020-09-17T16:07:56.784000+00:00",
        "Settings": {
            "ChannelIdentification": true
        }
    }
}
```
Para obter mais informações, consulte [Transcribing Multi-Channel Audio](https://docs.aws.amazon.com/transcribe/latest/dg/channel-id.html) no *Guia do desenvolvedor do Amazon Transcribe.*  
**Exemplo 3: como transcrever um arquivo de áudio e identificar quem está falando**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e identifica os locutores na saída da transcrição.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://mythirdfile.json
```
Conteúdo de `mythirdfile.json`:  

```
{
    "TranscriptionJobName": "cli-speakerid-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    },
    "Settings":{
    "ShowSpeakerLabels": true,
    "MaxSpeakerLabels": 2
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-speakerid-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "the-language-of-your-transcription-job",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
        },
        "StartTime": "2020-09-17T16:22:59.696000+00:00",
        "CreationTime": "2020-09-17T16:22:59.676000+00:00",
        "Settings": {
            "ShowSpeakerLabels": true,
            "MaxSpeakerLabels": 2
        }
    }
}
```
Para obter mais informações, consulte [Identifying Speakers](https://docs.aws.amazon.com/transcribe/latest/dg/diarization.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 4: como transcrever um arquivo de áudio e mascarar palavras indesejadas na saída da transcrição**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e usa um filtro de vocabulário que você criou anteriormente para mascarar palavras indesejadas.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myfourthfile.json
```
Conteúdo de `myfourthfile.json`:  

```
{
    "TranscriptionJobName": "cli-filter-mask-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
          "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    },
    "Settings":{
        "VocabularyFilterName": "your-vocabulary-filter",
        "VocabularyFilterMethod": "mask"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-filter-mask-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "the-language-of-your-transcription-job",
        "Media": {
            "MediaFileUri": "s3://Amazon-S3-Prefix/your-media-file.file-extension"
        },
        "StartTime": "2020-09-18T16:36:18.568000+00:00",
        "CreationTime": "2020-09-18T16:36:18.547000+00:00",
        "Settings": {
            "VocabularyFilterName": "your-vocabulary-filter",
            "VocabularyFilterMethod": "mask"
        }
    }
}
```
Para obter mais informações, consulte [Filtering Transcriptions](https://docs.aws.amazon.com/transcribe/latest/dg/filter-transcriptions.html) o *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 5: como transcrever um arquivo de áudio e remover palavras indesejadas na saída da transcrição**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e usa um filtro de vocabulário que você criou anteriormente para mascarar palavras indesejadas.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myfifthfile.json
```
Conteúdo de `myfifthfile.json`:  

```
{
    "TranscriptionJobName": "cli-filter-remove-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    },
    "Settings":{
        "VocabularyFilterName": "your-vocabulary-filter",
        "VocabularyFilterMethod": "remove"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-filter-remove-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "the-language-of-your-transcription-job",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
        },
        "StartTime": "2020-09-18T16:36:18.568000+00:00",
        "CreationTime": "2020-09-18T16:36:18.547000+00:00",
        "Settings": {
            "VocabularyFilterName": "your-vocabulary-filter",
            "VocabularyFilterMethod": "remove"
        }
    }
}
```
Para obter mais informações, consulte [Filtering Transcriptions](https://docs.aws.amazon.com/transcribe/latest/dg/filter-transcriptions.html) o *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 6: como transcrever um arquivo de áudio com maior precisão usando um vocabulário personalizado**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e usa um filtro de vocabulário que você criou anteriormente para mascarar palavras indesejadas.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://mysixthfile.json
```
Conteúdo de `mysixthfile.json`:  

```
{
    "TranscriptionJobName": "cli-vocab-job",
    "LanguageCode": "the-language-of-your-transcription-job",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    },
    "Settings":{
        "VocabularyName": "your-vocabulary"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-vocab-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "the-language-of-your-transcription-job",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
        },
        "StartTime": "2020-09-18T16:36:18.568000+00:00",
        "CreationTime": "2020-09-18T16:36:18.547000+00:00",
        "Settings": {
            "VocabularyName": "your-vocabulary"
        }
    }
}
```
Para obter mais informações, consulte [Filtering Transcriptions](https://docs.aws.amazon.com/transcribe/latest/dg/filter-transcriptions.html) o *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 7: como identificar o idioma de um arquivo de áudio e transcrevê-lo**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e usa um filtro de vocabulário que você criou anteriormente para mascarar palavras indesejadas.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myseventhfile.json
```
Conteúdo de `myseventhfile.json`:  

```
{
    "TranscriptionJobName": "cli-identify-language-transcription-job",
    "IdentifyLanguage": true,
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-identify-language-transcription-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/Amazon-S3-prefix/your-media-file-name.file-extension"
        },
        "StartTime": "2020-09-18T22:27:23.970000+00:00",
        "CreationTime": "2020-09-18T22:27:23.948000+00:00",
        "IdentifyLanguage": true
    }
}
```
Para obter mais informações, consulte [Identifying the Language](https://docs.aws.amazon.com/transcribe/latest/dg/auto-lang-id.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 8: como transcrever um arquivo de áudio com informações de identificação pessoal censuradas**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio e oculta qualquer informação de identificação pessoal na saída da transcrição.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myeighthfile.json
```
Conteúdo de `myeigthfile.json`:  

```
{
    "TranscriptionJobName": "cli-redaction-job",
    "LanguageCode": "language-code",
    "Media": {
        "MediaFileUri": "s3://Amazon-S3-Prefix/your-media-file.file-extension"
    },
    "ContentRedaction": {
        "RedactionOutput":"redacted",
        "RedactionType":"PII"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-redaction-job",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://Amazon-S3-Prefix/your-media-file.file-extension"
        },
        "StartTime": "2020-09-25T23:49:13.195000+00:00",
        "CreationTime": "2020-09-25T23:49:13.176000+00:00",
        "ContentRedaction": {
            "RedactionType": "PII",
            "RedactionOutput": "redacted"
        }
    }
}
```
Para obter mais informações, consulte [Automatic Content Redaction](https://docs.aws.amazon.com/transcribe/latest/dg/content-redaction.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 9: como gerar uma transcrição com informações de identificação pessoal (PII) censuradas e uma transcrição não censurada**  
O exemplo de `start-transcription-job` a seguir gera duas transcrições do arquivo de áudio, uma com as informações de identificação pessoal editadas e a outra sem nenhuma edição.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://myninthfile.json
```
Conteúdo de `myninthfile.json`:  

```
{
    "TranscriptionJobName": "cli-redaction-job-with-unredacted-transcript",
    "LanguageCode": "language-code",
    "Media": {
          "MediaFileUri": "s3://Amazon-S3-Prefix/your-media-file.file-extension"
        },
    "ContentRedaction": {
        "RedactionOutput":"redacted_and_unredacted",
        "RedactionType":"PII"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-redaction-job-with-unredacted-transcript",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://Amazon-S3-Prefix/your-media-file.file-extension"
        },
        "StartTime": "2020-09-25T23:59:47.677000+00:00",
        "CreationTime": "2020-09-25T23:59:47.653000+00:00",
        "ContentRedaction": {
            "RedactionType": "PII",
            "RedactionOutput": "redacted_and_unredacted"
        }
    }
}
```
Para obter mais informações, consulte [Automatic Content Redaction](https://docs.aws.amazon.com/transcribe/latest/dg/content-redaction.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
**Exemplo 10: como usar um modelo de linguagem personalizado criado anteriormente para transcrever um arquivo de áudio.**  
O exemplo de `start-transcription-job` a seguir transcreve o arquivo de áudio com um modelo de idioma personalizado que você criou anteriormente.  

```
aws transcribe start-transcription-job \
    --cli-input-json file://mytenthfile.json
```
Conteúdo de `mytenthfile.json`:  

```
{
    "TranscriptionJobName": "cli-clm-2-job-1",
    "LanguageCode": "language-code",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.file-extension"
    },
    "ModelSettings": {
        "LanguageModelName":"cli-clm-2"
    }
}
```
Saída:  

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "cli-clm-2-job-1",
        "TranscriptionJobStatus": "IN_PROGRESS",
        "LanguageCode": "language-code",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/your-audio-file.file-extension"
        },
        "StartTime": "2020-09-28T17:56:01.835000+00:00",
        "CreationTime": "2020-09-28T17:56:01.801000+00:00",
        "ModelSettings": {
            "LanguageModelName": "cli-clm-2"
        }
    }
}
```
Para obter mais informações, consulte [Improving Domain-Specific Transcription Accuracy with Custom Language Models](https://docs.aws.amazon.com/transcribe/latest/dg/custom-language-models.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [StartTranscriptionJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/start-transcription-job.html)em *Referência de AWS CLI Comandos*. 

### `update-medical-vocabulary`
<a name="transcribe_UpdateMedicalVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `update-medical-vocabulary`.

**AWS CLI**  
**Para atualizar um vocabulário médico personalizado com novos termos.**  
O exemplo `update-medical-vocabulary` a seguir substitui os termos usados em um vocabulário médico personalizado por novos. Pré-requisito: para substituir os termos em um vocabulário médico personalizado, você precisa de um arquivo com novos termos.  

```
aws transcribe update-medical-vocabulary \
    --vocabulary-file-uri s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/medical-custom-vocabulary.txt \
    --vocabulary-name medical-custom-vocabulary \
    --language-code language
```
Saída:  

```
{
    "VocabularyName": "medical-custom-vocabulary",
    "LanguageCode": "en-US",
    "VocabularyState": "PENDING"
}
```
Para obter mais informações, consulte [Medical Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [UpdateMedicalVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/update-medical-vocabulary.html)em *Referência de AWS CLI Comandos*. 

### `update-vocabulary-filter`
<a name="transcribe_UpdateVocabularyFilter_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `update-vocabulary-filter`.

**AWS CLI**  
**Para substituir as palavras em um filtro de vocabulário**  
O exemplo `update-vocabulary-filter` a seguir substitui as palavras em um filtro de vocabulário por novas. Pré-requisito: para atualizar um filtro de vocabulário com as novas palavras, você deve salvá-las como um arquivo de texto.  

```
aws transcribe update-vocabulary-filter \
    --vocabulary-filter-file-uri s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/your-text-file-to-update-your-vocabulary-filter.txt \
    --vocabulary-filter-name vocabulary-filter-name
```
Saída:  

```
{
    "VocabularyFilterName": "vocabulary-filter-name",
    "LanguageCode": "language-code",
    "LastModifiedTime": "2020-09-23T18:40:35.139000+00:00"
}
```
Para obter mais informações, consulte [Como filtrar palavras indesejadas](https://docs.aws.amazon.com/transcribe/latest/dg/filter-unwanted-words.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [UpdateVocabularyFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/update-vocabulary-filter.html)em *Referência de AWS CLI Comandos*. 

### `update-vocabulary`
<a name="transcribe_UpdateVocabulary_cli_2_topic"></a>

O código de exemplo a seguir mostra como usar `update-vocabulary`.

**AWS CLI**  
**Como atualizar um vocabulário personalizado com novos termos.**  
O exemplo de `update-vocabulary` a seguir substitui os termos usados para criar o vocabulário personalizado pelos novos termos fornecidos. Pré-requisito: para substituir os termos em um vocabulário personalizado, você precisa de um arquivo com novos termos.  

```
aws transcribe update-vocabulary \
    --vocabulary-file-uri s3://amzn-s3-demo-bucket/Amazon-S3-Prefix/custom-vocabulary.txt \
    --vocabulary-name custom-vocabulary \
    --language-code language-code
```
Saída:  

```
{
    "VocabularyName": "custom-vocabulary",
    "LanguageCode": "language",
    "VocabularyState": "PENDING"
}
```
Para obter mais informações, consulte [Custom Vocabularies](https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html) no *Guia do desenvolvedor do Amazon Transcribe*.  
+  Para obter detalhes da API, consulte [UpdateVocabulary](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/update-vocabulary.html)em *Referência de AWS CLI Comandos*.