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á.
# Transforme dados não estruturados em insights significativos usando a automação Amazon Bedrock de dados
## O que é a Automação de Dados do Bedrock?
A Automação de Dados do Bedrock (BDA) é um serviço baseado em nuvem que simplifica o processo de extração de insights úteis de conteúdo não estruturado, como documentos, imagens, vídeo e áudio. A BDA utiliza IA generativa para automatizar a transformação de dados multimodais em formatos estruturados, permitindo que os desenvolvedores criem aplicações e automatizem fluxos de trabalho complexos com maior velocidade e precisão.
Veja a seguir estão alguns casos de uso de exemplo:
+ **Processamento de documentos:** a BDA permite automatizar fluxos de trabalho de processamento de documentos inteligente (IDP) em grande escala sem a necessidade de orquestrar tarefas complexas de processamento de documentos, como classificação, extração, normalização ou validação. Isso ajuda a transformar documentos não estruturados em saídas de dados estruturados específicos da empresa. É possível personalizar a saída da BDA para se integrar aos seus sistemas e fluxos de trabalho em vigor.
+ **Análise de mídia:** adicione insights significativos a vídeos não estruturados. Crie resumos de cada cena, ajude a identificar conteúdo não seguro ou explícito, extraia o texto que aparece no vídeo e classifique o conteúdo com base em anúncios ou marcas. Em seguida, você pode utilizar esses insights para permitir a pesquisa inteligente de vídeos, melhorar o posicionamento contextual de anúncios e contribuir para a segurança e conformidade da marca.
+ **Assistentes de IA generativa:** aprimore o desempenho de suas aplicações de resposta a perguntas baseadas em geração aumentada via recuperação (RAG) fornecendo representações de dados detalhadas e específicas da modalidade, extraídas de documentos, imagens, vídeo e áudio.
A BDA oferece uma experiência unificada e orientada por API que permite processar conteúdo multimodal por meio de uma única interface, eliminando a necessidade de gerenciar e orquestrar vários modelos e serviços de IA. Com proteções integradas, como pontuações de fundamentação visual e de confiança, a BDA ajuda a melhorar a precisão e a confiabilidade dos insights extraídos, facilitando a integração aos fluxos de trabalho da sua empresa.
# Como funciona a Automação de Dados do Bedrock
A Automação de Dados do Bedrock (BDA) permite que você configure a saída com base nas suas necessidades de processamento para um tipo de dados específico: documentos, imagens, vídeo ou áudio. A BDA pode gerar saída padrão ou saída personalizada. Abaixo são apresentados alguns conceitos importantes para entender como a BDA funciona. Se você for iniciante, comece com as informações sobre a saída padrão.
+ Saída padrão: enviar um arquivo à BDA sem nenhuma outra informação exibe a saída padrão, que consiste em informações normalmente necessárias com base no tipo de dados. Os exemplos incluem transcrições de áudio, resumos de cenas para vídeo e resumos de documentos. Essas saídas podem ser ajustadas ao seu caso de uso usando projetos para modificá-las. Para obter mais informações, consulte [Saída padrão na Automação de Dados do Bedrock](bda-standard-output.md).
+ Saída personalizada: somente para documentos, áudio e imagens. Escolha a saída personalizada para definir exatamente quais informações você deseja extrair usando um esquema. Um esquema consiste em uma lista dos campos esperados que você deseja recuperar de um arquivo. Cada campo representa uma informação que precisa ser extraída para atender ao seu caso de uso específico. Você pode criar seus próprios esquemas ou selecionar esquemas predefinidos no catálogo de esquemas da BDA. Para obter mais informações, consulte [Saída e esquemas personalizados](bda-custom-output-idp.md).
+ Projetos: um projeto é um recurso da BDA que permite modificar e organizar as configurações de saída. Cada projeto pode conter configurações de saída padrão para documentos, imagens, vídeo e áudio, bem como esquemas de saída personalizada para documentos, áudio e imagens. Os projetos são referidos na chamada de API `InvokeDataAutomationAsync` para instruir a BDA sobre como processar os arquivos. Para ter mais informações sobre projetos e os respectivos casos de uso, consulte [Projetos da Automação de Dados do Bedrock](bda-projects.md).
# Projetos da Automação de Dados do Bedrock
Uma forma de processar arquivos usando a Automação de Dados do Amazon Bedrock (BDA) é criar um projeto. Um projeto é um agrupamento de configurações de saída padrão personalizadas. Nos projetos, as saídas padrão são necessárias, mas as saídas personalizadas são opcionais. Quando você chama a API `InvokeDataAutomationAsync` com um ARN de projeto, o arquivo é processado automaticamente usando as configurações definidas nesse projeto. A saída é então gerada com base na configuração do projeto.
Um projeto pode receber uma etapa, `LIVE` ou `DEVELOPMENT`. Cada estágio é uma versão única e mutável do projeto. Isso significa que é possível editar ou testar por meio do estágio `DEVELOPMENT` e processar as solicitações dos clientes usando o estágio `LIVE`. Os projetos `DEVELOPMENT` não podem ser acessados no console e devem ser alterados e invocados por meio da API.
Um projeto permite que você use um único recurso para vários tipos de arquivo. Por exemplo, um arquivo de áudio enviado à BDA usando o nome de projeto ABC será processado usando a configuração de saída padrão de áudio do projeto ABC. Um documento enviado à BDA usando o nome de projeto ABC será processado usando a configuração de saída padrão do documento do projeto ABC.
Os projetos oferecem maior flexibilidade ao configurar saídas padrão. Cada saída padrão tem seu próprio conjunto de opções configuráveis, como transcrições ou resumos, e os projetos permitem que você altere essas opções para que atendam melhor ao seu caso de uso. Para definir uma saída personalizada, também é possível configurar um projeto com esquemas para documentos, áudio e imagens. Um projeto configurado para gerar uma saída personalizada também gerará uma saída padrão automaticamente.
As seções a seguir apresentarão alguns exemplos de uso de projeto.
## Usar projetos com saída padrão
Vamos considerar um caso de uso no qual você só queira extrair resumos de transcrições dos arquivos completos de áudio e vídeo. Por padrão, ao enviar arquivos de áudio e vídeo à BDA, você recebe os resumos da transcrição com as transcrições completas, resumos em nível de cena, texto detectado e outras informações. Nesse caso de uso, você provavelmente não quer gastar tempo nem recursos extras para coletar informações desnecessárias. Para esse caso de uso, você pode configurar um projeto de saída padrão para habilitar somente o recurso de resumo para arquivos de áudio e vídeo.
Para fazer isso usando a API ou o console, crie um projeto e modifique as configurações de saída padrão para áudio e vídeo. Para vídeo, habilite **Resumo de vídeo completo**, mas observe que outras extrações (p. ex., transcrição de áudio completo, resumos de cenas, moderação de conteúdo etc.) estejam desabilitadas. Repita essa configuração para áudio. Depois de configurar o projeto para gerar somente resumos, salve-o e anote o nome do recurso da Amazon (ARN) do projeto. Esse ARN pode ser usado para a operação `InvokeDataAutomationAsync` para processar os arquivos em grande escala. Ao transmitir um arquivo de áudio ou vídeo à BDA e especificar o ARN desse projeto, você receberá uma saída somente dos resumos de cada um dos arquivos. Observe que, neste exemplo, não foi realizada nenhuma configuração para documentos ou imagens. Isso significa que, se você transmitir uma imagem ou documento à BDA usando o ARN desse projeto, receberá a saída padrão para esses arquivos.
## Usar projetos com saída personalizada e saída padrão
Para esse caso de uso, vamos supor que você queira gerar resumos de saída padrão para documentos e arquivos de áudio e também extrair campos personalizados dos documentos. Depois de criar um projeto, configure a saída padrão para áudio para habilitar o **Resumo de áudio completo** e garanta que as outras extrações não estejam habilitadas. Repita essa configuração de saída padrão para documentos. Em seguida, você pode configurar a saída personalizada para documentos adicionando um esquema novo ou preexistente do catálogo global da BDA. Os documentos transmitidos à BDA usando o ARN desse projeto gerarão a saída padrão, resumos do documento completo e a saída do esquema para os campos personalizados definidos. Os arquivos de áudio transmitidos à BDA usando o ARN desse projeto gerarão resumos completos.
Ao processar documentos, talvez você queira usar vários esquemas para diferentes tipos de documento que são transmitidos ao projeto. Um projeto pode ter até quarenta esquemas de documentos anexados. A BDA combina automaticamente os documentos com o esquema apropriado que está configurado em seu projeto e gera resultados personalizados usando esse esquema. Além disso, você pode transmitir documentos em massa. Se você transmitir um arquivo que contém vários documentos, poderá optar por dividir o documento ao criar seu projeto. Se você optar por fazer isso, a BDA digitalizará o arquivo e o dividirá em documentos individuais com base no contexto. Esses documentos individuais são então compatibilizados com o esquema correto para processamento.
No momento, as imagens permitem apenas uma definição de esquema por projeto. Os tipos de arquivo de imagem JPG e PNG podem ser tratados como imagens ou documentos digitalizados com base no respectivo conteúdo. Recomendamos que você crie um esquema personalizado para imagens ao processar a saída personalizada para documentos. Desse modo, a BDA fornecerá a saída desejada para arquivos de imagem que contenham texto.
Os arquivos de áudio também permitem apenas a uma definição de esquema por projeto.
# Dividir documentos ao usar projetos
Amazon Bedrock A automação de dados (BDA) suporta a divisão de documentos ao usar a API. Amazon Bedrock Quando habilitada, a divisão permite que a BDA utilize um PDF que contenha vários documentos lógicos e o divida em documentos separados para processamento.
Após a conclusão da divisão, cada segmento do documento dividido será processado de forma independente. Isso significa que um documento de entrada pode conter diferentes tipos de documento. Por exemplo, se você tivesse um PDF contendo três extratos bancários e um W2, a divisão tentaria dividi-lo em quatro documentos separados, os quais seriam processados individualmente.
A divisão automática da BDA permite arquivos com até 3 mil páginas e documentos individuais de até 20 páginas cada.
A opção de dividir documentos está desativada por padrão, mas pode ser ativada ao usar a API. Veja abaixo um exemplo de como criar um projeto com o divisor habilitado. As reticências representam esquemas adicionais fornecidas ao projeto.
```
response = client.create_data_automation_project(
projectName=project_name,
projectDescription="Provide a project description",
projectStage='LIVE',
standardOutputConfiguration=output_config,
customOutputConfiguration={
'blueprints': [
{
'blueprintArn': Blueprint ARN,
'blueprintStage': 'LIVE'
},
...
]
},
overrideConfiguration={'document': {'splitter': {'state': 'ENABLED'}}}
)
```
A parte que permite o processo de divisão é a linha overrideConfiguration. Essa linha configura o divisor e permite que você transmita vários documentos no mesmo arquivo.
Os documentos são divididos pelos respectivos limites semânticos.
A divisão de documentos ocorre independentemente da aplicação de esquemas, e os documentos divididos serão combinados com o esquema mais próximo. Para ter mais informações sobre como a BDA combina esquemas, consulte [Noções básicas sobre a correspondência de esquema](#bda-blueprint-matching).
## Noções básicas sobre a correspondência de esquema
A correspondência de esquema baseia-se nos seguintes elementos:
+ Nome do esquema
+ Descrição do esquema
+ Campos do esquema
Ao processar documentos, você pode fornecer vários esquemas para verificar a correspondência. Isso permite processar diferentes tipos de documento com esquemas apropriados. Você pode fornecer vários planos IDs ao invocar a API de automação de dados, e o BDA tentará combinar cada documento com o esquema mais adequado. Isso permite processar tipos de documento mistos em um único lote. Isso é útil quando se espera que os documentos sejam de tipos diferentes (p. ex., extratos bancários, faturas e passaportes).
Se você precisar de esquemas separados porque os formatos dos documentos são muito diferentes ou exigem prompts especializados, criar um esquema por tipo de documento pode ajudar a compatibilizar. Para ter mais informações sobre como criar esquemas úteis, consulte [Práticas recomendadas para criar esquemas](#bda-blueprint-best-practices).
## Práticas recomendadas para criar esquemas
Siga as práticas recomendadas abaixo para aproveitar ao máximo seus esquemas:
+ Atribua nomes e descrições explícitos e detalhados aos projetos para ajudar na correspondência.
+ Forneça vários projetos relevantes para que a BDA selecione a melhor combinação. Crie esquemas separados para formatos de documento significativamente diferentes.
+ Considere criar esquemas especializados para cada vendor/document fonte, se você precisar de máxima precisão
+ Não inclua dois esquemas do mesmo tipo em um projeto (p. ex., dois esquemas de W2). Como as informações do documento em si e do esquema são usadas para processar documentos, incluir vários esquemas do mesmo tipo em um projeto prejudicará o desempenho.
Ao utilizar a divisão de documentos e a correspondência entre vários esquemas, a BDA consegue lidar com conjuntos de documentos variados de forma mais flexível, aplicando a lógica de extração mais apropriada a cada documento.
# Desabilitar modalidades e tipos de arquivo de roteamento
Por padrão, os projetos na BDA processam tipos de arquivo compatíveis, classificando-os em diferentes modalidades semânticas. Ao criar ou editar seu projeto, você pode modificar quais modalidades serão processadas e quais tipos de arquivo serão enviados a quais modalidades. Nesta seção, abordaremos a habilitação e desabilitação de diferentes modalidades, o roteamento de arquivos para modalidades específicas e o procedimento de roteamento padrão para a BDA.
## Desabilitar o processamento de modalidades
Ao criar um projeto, talvez você tenha em mente um caso de uso que não inclua o processamento de todos os tipos de arquivo. Por exemplo, talvez você queira processar somente documentos e arquivos de áudio. Se for esse o caso, você não quer que o BDA envie um JPEG para ser processado como uma imagem ou um MP4 para ser processado como um vídeo. A habilitação da modalidade permite que você desative determinadas modalidades em um projeto, selecionando as respostas do processamento da BDA.
**Desabilitar modalidades com o console da BDA**
Ao usar o console da BDA, a habilitação da modalidade é feita por uma lista de verificação, na qual você pode simplesmente selecionar ou desmarcar cada modalidade ao editar ou criar seu projeto. Essas opções estão localizadas na guia “Configurações avançadas”. Pelo menos uma modalidade deve ser selecionada para um projeto.
![\[Modality enablement options with checkboxes for document, image, video, and audio.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/modalityenableconsole.png)
**Desabilitar modalidades com a API da BDA**
Ao usar a API da BDA, a habilitação da modalidade é feita pelo elemento de solicitação `overrideConfiguration`, localizado na operação `CreateDataAutomation`. Cada modalidade tem uma seção associada em que você pode declarar a modalidade `ENABLED` ou `DISABLED`. Abaixo é apresentado um exemplo do elemento `overrideConfiguration` somente com as modalidades de documento e áudio habilitadas. O sinalizador `modalityProcessing` assume como padrão `ENABLED`.
```
"overrideConfiguration" : {
"document": {
"splitter": {
"state": ENABLED
},
"modalityProcessing": {
"state": ENABLED
},
},
"image": {
"modalityProcessing": {
"state": DISABLED
}
},
"video": {
"modalityProcessing": {
"state": DISABLED
}
},
"audio": {
"modalityProcessing": {
"state": ENABLED
}
},
...
}
```
As reticências no final desta seção indicam a remoção do elemento `modalityRouting`, que discutiremos mais na próxima seção.
## Rotear arquivos para determinados tipos de processamento
Certos tipos de arquivo podem ser roteados para diferentes modalidades, com base em vários fatores. Com o roteamento por modalidade, você pode definir determinados tipos de arquivo para rotear manualmente para determinado processamento de modalidade. JPEGs e PNGs pode ser roteado para processamento de documentos ou imagens. MP4s e MOVs pode ser roteado para processamento de vídeo ou áudio.
**Rotear por meio do console da BDA**
Enquanto estiver na guia “Configurações avançadas” ao criar ou editar um esquema, você pode optar por adicionar um novo roteamento de modalidade manual. Isso permite selecionar um dos quatro tipos de arquivo disponíveis e, em seguida, para qual modalidade de processamento eles serão roteados. Abaixo é apresentada uma captura de tela do console, com um roteamento de modalidade manual que envia arquivos PNG à modalidade de processamento de documentos.
**nota**
As configurações dos arquivos JPEG se aplicam aos arquivos “.jpeg” e “.jpg”. As MP4 configurações se aplicam aos dois arquivos “.mp4" “.m4v”.
![\[Uma imagem do Console da AWS mostrando dois menus suspensos rotulados como tipo de arquivo e destino da modalidade, selecionados como “PNG” e “Document”.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/manualrouting.png)
**Rotear por meio da API da BDA**
De modo semelhante à habilitação de modalidade, o roteamento de modalidade é tratado por meio do elemento de solicitação `overrideConfiguration`. Abaixo é apresentado um exemplo da parte `modalityRouting` de `overrideConfiguration`. Este exemplo pressupõe que todas as modalidades estão habilitadas e roteia arquivos JPEG e PNG para a modalidade de documento MP4 e arquivos MOV para a modalidade de áudio.
```
...
"modalityRouting": {
"jpeg": DOCUMENT,
"png": DOCUMENT,
"mp4": AUDIO,
"mov": AUDIO
}
}
```
As reticências no início do exemplo indicam a remoção do restante de `overrideConfiguration`, o que é discutido mais detalhadamente na seção sobre habilitação de modalidades e a funcionalidade de divisor de documentos.
## Roteamento padrão para a API InvokeDataAutomationAsync
Se você não configurar seus próprios procedimentos de roteamento, a BDA usará um conjunto padrão de procedimentos com base no tipo de arquivo para determinar para qual modalidade a BDA será roteada. Os procedimentos padrão estão listados na tabela abaixo.
PNGs e JPEGs liste o Classificador Semântico como um comportamento padrão. Isso significa que a BDA usará modelos internos para analisar os indicadores, para ver se um arquivo enviado é ou não uma imagem ou um documento, e executará o roteamento automaticamente.
| Tipos de arquivo | Comportamento do roteamento padrão |
| --- | --- |
| PNG | Classificador semântico (imagem ou documento) |
| JPEG | Classificador semântico (imagem ou documento) |
| PDF, TIFF | Documento |
| MP4, MOV | Vídeo |
| ARM, FLAC, M4A, OGG, WEBM MP3, WAV | Áudio |
## Roteamento padrão para a API InvokeDataAutomation
A [InvokeDataAutomation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomation.html)API também analisará os indicadores de se um arquivo PNG ou JPEG enviado é uma imagem ou um documento usando modelos internos e executará o roteamento automaticamente. Os procedimentos padrão estão listados na tabela abaixo.
PNGs e JPEGs liste o Classificador Semântico como um comportamento padrão. Isso significa que a BDA usará modelos internos para analisar os indicadores, para ver se um arquivo enviado é ou não uma imagem ou um documento, e executará o roteamento automaticamente. Os arquivos PDF e TIFF serão encaminhados para a modalidade Documentos para processamento. InvokeDataAutomation Atualmente, a API não oferece suporte a arquivos de áudio e vídeo.
| Tipos de arquivo | Comportamento do roteamento padrão |
| --- | --- |
| PNG | Classificador semântico (imagem ou documento) |
| JPEG | Classificador semântico (imagem ou documento) |
| PDF, TIFF | Documento |
# Suporte entre regiões necessário para a Automação de Dados do Bedrock
A BDA exige que os usuários usem o suporte à inferência entre regiões ao processar arquivos. Com a inferência entre regiões, a Automação de Dados do Amazon Bedrock selecionará automaticamente a região ideal em sua área geográfica (conforme mostrado na tabela abaixo) para processar sua solicitação de inferência, maximizando os recursos de computação disponíveis e a disponibilidade do modelo e fornecendo a melhor experiência ao cliente. Não há custo adicional para usar a inferência entre regiões. As solicitações de inferência entre regiões são mantidas nas Regiões da AWS que fazem parte da área geográfica nas quais os dados originalmente residem. Por exemplo, uma solicitação feita nos EUA é mantida nas Regiões da AWS nos EUA. Embora os dados permaneçam armazenados somente na região de origem, ao usar a inferência entre regiões, suas solicitações e resultados de saída podem sair da sua região primária. Todos os dados serão criptografados enquanto forem transmitidos pela rede segura da Amazon.
A tabela a seguir inclui os ARNs para diferentes perfis de inferência. Substitua o ID da conta pelo ID da conta que você está usando.
| Região de origem | Nome de recurso da Amazon (ARN) | Regiões com suporte |
| --- | --- | --- |
| Leste dos EUA (Norte da Virgínia) | arn:aws:bedrock:us-east-1:*account id*:data-automation-profile/us.data-automation-v1 | us-east-1 us-east-2 us-west-1 us-west-2 |
| Oeste dos EUA (Oregon) | arn:aws:bedrock:us-west-2:*account id*:data-automation-profile/us.data-automation-v1 | us-east-1 us-east-2 us-west-1 us-west-2 |
| Europa (Frankfurt) | arn:aws:bedrock:eu-central-1:*account id*:data-automation-profile/eu.data-automation-v1 | eu-central-1 eu-north-1 eu-south-1 eu-south-2 eu-west-1 eu-west-3 |
| Europa (Irlanda) | arn:aws:bedrock:eu-west-1:*account id*:data-automation-profile/eu.data-automation-v1 | eu-central-1 eu-north-1 eu-south-1 eu-south-2 eu-west-1 eu-west-3 |
| Europa (Londres) | arn:aws:bedrock:eu-west-2:*account id*:data-automation-profile/eu.data-automation-v1 | eu-west-2 |
| Ásia-Pacífico (Mumbai) | arn:aws:bedrock:ap-south-1:*account id*:data-automation-profile/apac.data-automation-v1 | ap-northeast-1 ap-northeast-2 ap-northeast-3 ap-south-1 ap-south-2 ap-southeast-1 ap-southeast-2 ap-southeast-4 |
| Ásia-Pacífico (Sydney) | arn:aws:bedrock:ap-southeast-2:*account id*:data-automation-profile/apac.data-automation-v1 | ap-northeast-1 ap-northeast-2 ap-northeast-3 ap-south-1 ap-south-2 ap-southeast-1 ap-southeast-2 ap-southeast-4 |
| AWS GovCloud (Oeste dos EUA) | arn:aws:bedrock:gov-cloud:*account id*:data-automation-profile/us-gov.data-automation-v1 | us-gov-west-1 |
Abaixo é apresentado um exemplo de política do IAM para processar documentos com a inferência entre regiões (CRIS) habilitada para a `us-east-1` ou a `us-west-2`.
```
{"Effect": "Allow",
"Action": ["bedrock:InvokeDataAutomationAsync"],
"Resource": [
"arn:aws:bedrock:us-east-1:account_id:data-automation-profile/us.data-automation-v1",
"arn:aws:bedrock:us-east-2:account_id:data-automation-profile/us.data-automation-v1",
"arn:aws:bedrock:us-west-1:account_id:data-automation-profile/us.data-automation-v1",
"arn:aws:bedrock:us-west-2:account_id:data-automation-profile/us.data-automation-v1"]}
```
# Saída padrão na Automação de Dados do Bedrock
A saída padrão é a forma padrão de interagir com a Automação de Amazon Bedrock Dados (BDA). Se você transmitir um documento à API da BDA sem um esquema ou projeto estabelecido, ela exibirá a saída padrão para esse tipo de arquivo. A saída padrão pode ser modificada usando projetos, que armazenam informações de configuração para cada tipo de dados. Você pode ter uma configuração de saída padrão por tipo de dados para cada projeto. A BDA sempre fornece uma resposta de saída padrão, mesmo que acompanhada de uma resposta de saída personalizada.
Cada tipo de dados tem diferentes opções de saída padrão. Algumas dessas opções fazem parte da resposta padrão da Automação de Dados do Bedrock, enquanto outras existem apenas como opções para trabalhar com o tipo de dados em um projeto. As seções a seguir abordam as opções de resposta exclusivas de cada tipo de dados, observando quais são padrões e quais são opcionais.
# Documentos do
A saída padrão para documentos permite definir a granularidade da resposta pela qual você tem interesse, bem como estabelecer o formato de saída e o formato de texto na saída. Abaixo são apresentadas algumas das saídas que você pode habilitar.
**nota**
A BDA pode processar arquivos DOCX. Para processar arquivos DOCX, eles são convertidos em PDFs. Isso significa que o mapeamento do número da página não funcionará para arquivos DOCX. As imagens do convertido PDFs serão enviadas para seu bucket de saída se a opção JSON\$1 e a granularidade da página estiverem selecionadas.
## Granularidade da resposta
A granularidade da resposta determina o tipo de resposta que você deseja receber da extração do texto do documento. Cada nível de granularidade fornece respostas cada vez mais distintas. A página apresenta todo o texto extraído em conjunto e a palavra apresenta cada palavra como uma resposta separada. Os níveis de granularidade disponíveis são:
+ Granularidade em nível de página: está habilitado por padrão. A granularidade em nível de página apresenta cada página do documento no formato de saída de texto de sua preferência. Se você estiver processando um PDF, ao habilitar esse nível de granularidade, serão detectados e exibidos hiperlinks incorporados.
+ Granularidade em nível de elemento (layout): está habilitado por padrão. Apresenta o texto do documento no formato de saída de sua preferência, separado em elementos diferentes. Esses elementos são figuras, tabelas ou parágrafos. Eles são exibidos em ordem de leitura lógica com base na estrutura do documento. Se você estiver processando um PDF, ao habilitar esse nível de granularidade, serão detectados e exibidos hiperlinks incorporados.
+ Granularidade em nível de palavra: apresenta informações sobre palavras individuais sem usar uma análise de contexto mais ampla. Apresenta cada palavra e a respectiva localização na página.
## Configurações da saída
As configurações de saída determinam a forma como os resultados baixados serão estruturados. Essa configuração é exclusiva para o console. As opções para configurações de saída são:
+ JSON: a estrutura de saída padrão para análise de documentos. Apresenta um arquivo de saída JSON com as informações de suas configurações.
+ API assíncrona: a saída JSON para a [InvokeDataAutomationAsync](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomationAsync.html)API assíncrona é somente S3.
+ [InvokeDataAutomation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomation.html)API de sincronização: a saída JSON pode ser definida como S3 ou em linha por meio da alavancagem. `outputconfiguration` Se S3 for selecionado, o JSON de saída será direcionado somente para o S3 (não embutido). Se o S3 não for fornecido, a saída da API de sincronização suportará somente JSON embutido.
+ JSON\$1Files — Disponível somente para API assíncrona. [InvokeDataAutomationAsync](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomationAsync.html) O uso dessa configuração gera uma saída JSON e arquivos que correspondem a saídas diferentes. Por exemplo, essa configuração fornece um arquivo de texto para a extração geral do texto, um arquivo Markdown para o texto com marcação estrutural e arquivos CSV para cada tabela encontrada no texto. As figuras localizadas dentro de um documento serão salvas, bem como recortes de figuras e imagens retificadas. Além disso, se você estiver processando um arquivo DOCX e tiver essa opção selecionada, o PDF convertido do seu arquivo DOCX estará na pasta de saída. Essas saídas estão localizadas em `standard_output/logical_doc_id/assets/` na sua pasta de saída.
**nota**
A API de sincronização não gera nenhum arquivo adicional além do JSON. O JSON de saída contém somente o formato de texto selecionado como parte do formato de texto de saída padrão. A API de sincronização não produzirá recortes de figuras ou imagens retificadas.
DocX não é compatível com a API de sincronização.
## Formato de texto
O formato do texto determina os diferentes tipos de texto que serão fornecidos por meio de várias operações de extração. Selecione qualquer uma das opções a seguir para o formato de texto.
+ Texto simples: essa configuração apresenta uma saída somente de texto sem formatação ou outros elementos Markdown anotados.
+ Texto com Markdown: a configuração de saída padrão para saída padrão. Fornece texto com elementos Markdown integrados.
+ Texto com HTML: fornece texto com elementos HTML integrados na resposta.
+ CSV: fornece uma saída estruturada em CSV para tabelas dentro do documento. Isso apresentará uma resposta apenas para tabelas e não para outros elementos do documento.
## Caixas delimitadoras e campos generativos
Para documentos, há duas opções de resposta que alteram a respectiva saída com base na granularidade selecionada. As caixas delimitadoras e os campos generativos. Selecionar caixas delimitadoras fornecerá um esboço visual do elemento ou palavra em que você clica no menu suspenso de respostas do console. Isso permite que você rastreie elementos específicos da resposta com maior facilidade. As caixas delimitadoras são exibidas em JSON como as coordenadas dos quatro cantos da caixa.
Ao selecionar “Campos generativos”, é gerado um resumo do documento, que pode ser uma versão de 10 palavras ou de 250 palavras. Em seguida, se você selecionar elementos como uma granularidade de resposta, será gerada uma legenda descritiva de cada figura detectada no documento. As figuras incluem elementos como tabelas, grafos e imagens.
------
#### [ Async ]
Esta seção se concentra nos diferentes objetos de resposta que você recebe ao executar a operação da API InvokeDataAutomationAsync em um arquivo de documento. Detalharemos abaixo cada seção do objeto de resposta e, em seguida, veremos uma resposta completa e preenchida para um documento de exemplo. A primeira seção que receberemos é `metadata`.
```
"metadata":{
"logical_subdocument_id":"XXXX-XXXX-XXXX-XXXX",
"semantic_modality":"DOCUMENT",
"s3_bucket":"bucket",
"s3_prefix":"prefix"
},
```
A primeira seção acima fornece uma visão geral dos metadados associados ao documento. Com as informações do S3, essa seção também informa qual modalidade foi selecionada para sua resposta.
```
"document":{
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"description":"document text",
"summary":"summary text",
"statistics":{
"element_count":5,
"table_count":1,
"figure_count":1,
"word_count":1000,
"line_count":32
}
},
```
A seção acima fornece informações de granularidade em nível de documento. As seções de descrição e resumo são os campos gerados com base no documento. A seção de representação fornece o conteúdo real do documento com vários estilos de formatação. Finalmente, as estatísticas contêm informações sobre o conteúdo real do documento, como quantos elementos semânticos existem, quantas figuras, palavras, linhas etc.
Essas são as informações de uma entidade de tabela. Para solicitações InvokeDataAutomationAsync (assíncronas), além das informações de localização, dos diferentes formatos de texto, tabelas e ordem de leitura, eles retornam especificamente informações csv e imagens recortadas da tabela nos buckets do S3. As informações de CSV mostram os diferentes cabeçalhos, rodapés e títulos. As imagens serão roteadas para o bucket s3 do prefixo definido na solicitação. InvokeDataAutomationAsync Para solicitações InvokeDataAutomation (de sincronização), csv e imagem recortada da tabela em buckets do S3 não são compatíveis.
Ao processar um PDF, a seção de estatísticas da resposta também conterá informações de `hyperlinks_count`, que indica quantos hiperlinks existem no documento.
```
{
"id":"entity_id",
"type":"TEXT",
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"reading_order":2,
"page_indices":[
0
],
"locations":[
{
"page_index":0,
"bounding_box":{
"left":0.0,
"top":0.0,
"width":0.05,
"height":0.5
}
}
],
"sub_type":"TITLE/SECTION_TITLE/HEADER/FOOTER/PARAGRAPH/LIST/PAGE_NUMBER"
},
```
Essa é a entidade usada para texto em um documento, indicada pela linha `TYPE` na resposta. Além disso, a representação mostra o texto em formatos diferentes. `reading_order` mostra quando um leitor veria logicamente o texto. Essa é uma ordem semântica baseada em chaves e valores associados. Por exemplo, os títulos de parágrafo são associados aos respectivos parágrafos em ordem de leitura. `page_indices` informa em quais páginas o texto está. Em seguida, estão as informações de localização, com uma caixa delimitadora de texto aplicada, se ela tiver sido habilitada na resposta. Finalmente, temos o subtipo de entidade. Esse subtipo fornece informações mais detalhadas sobre o tipo de texto que está sendo detectado. Para ver uma lista completa de subtipos, consulte a “Referência de API”.
```
{
"id":"entity_id",
"type":"TABLE",
"representation":{
"html":"table.../table",
"markdown":"| header | ...",
"text":"header \t header",
"csv":"header, header, header\n..."
},
"csv_s3_uri":"s3://",
"headers":[
"date",
"amount",
"description",
"total"
],
"reading_order":3,
"title":"Title of the table",
"footers":[
"the footers of the table"
],
"crop_images":[
"s3://bucket/prefix.png",
"s3://bucket/prefix.png"
],
"page_indices":[
0,
1
],
"locations":[
{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
},
{
"page_index":1,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
],
"sub_type":"TITLE/SECTION_TITLE/HEADER/FOOTER/PARAGRAPH/LIST/PAGE_NUMBER"
},
```
Essas são as informações de uma entidade de tabela. Além das informações de localização, dos diferentes formatos de texto, das tabelas e da ordem de leitura, são exibidas especificamente informações de CSV e imagens recortadas da tabela nos buckets do S3. As informações de CSV mostram os diferentes cabeçalhos, rodapés e títulos. As imagens serão roteadas para o bucket s3 do prefixo definido na solicitação. InvokeDataAutomation
```
{
"id":"entity_id",
"type":"FIGURE",
"summary":"",
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"crop_images":[
"s3://bucket/prefix.png",
"s3://bucket/prefix.png"
],
"locations":[
{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
],
"sub_type":"CHART",
"title":"figure title",
"rai_flag":"APPROVED/REDACTED/REJECTED",
"reading_order":1,
"page_indices":[
0
]
}
,
```
Essa é a entidade usada para figuras, como em grafos e tabelas de documentos. De modo semelhante às tabelas, essas figuras serão recortadas, enquanto as imagens enviadas ao bucket do S3 serão configuradas em seu prefixo. Além disso, você receberá uma resposta `sub_type` e uma resposta do título da figura para o texto do título e uma indicação do tipo de figura.
```
"pages":[
{
"id":"page_id",
"page_index":0,
"detected_page_number":1,
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"statistics":{
"element_count":5,
"table_count":1,
"figure_count":1,
"word_count":1000,
"line_count":32
},
"asset_metadata":{
"rectified_image":"s3://bucket/prefix.png",
"rectified_image_width_pixels":1700,
"rectified_image_height_pixels":2200
}
}
],
```
A última das entidades que extraímos por meio da saída padrão são páginas. As páginas são iguais às entidades de texto, mas também contêm números de página, cujos números detectados estão na página.
```
"text_lines":[
{
"id":"line_id",
"text":"line text",
"reading_order":1,
"page_index":0,
"locations":{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
}
],
```
```
"text_words":[
{
"id":"word_id",
"text":"word text",
"line_id":"line_id",
"reading_order":1,
"page_index":0,
"locations":{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
}
]
```
Esses dois elementos finais são para partes de texto individuais. A granularidade em nível de palavra exibe uma resposta para cada palavra, enquanto a saída padrão relata somente linhas de texto.
------
#### [ Sync ]
Esta seção se concentra nos diferentes objetos de resposta que você recebe ao executar a operação da API InvokeDataAutomation em um arquivo de documento. Detalharemos abaixo cada seção do objeto de resposta e, em seguida, veremos uma resposta completa e preenchida para um documento de exemplo. A primeira seção que receberemos é `metadata`.
```
"metadata": {
"logical_subdocument_id": "1",
"semantic_modality": "DOCUMENT",
"number_of_pages": X,
"start_page_index": "1",
"end_page_index": X,
"file_type": "PDF"
},
```
A primeira seção acima fornece uma visão geral dos metadados associados ao documento. Como a InvokeDataAutomation API síncrona atualmente não oferece suporte à divisão de documentos, logical\$1subdocument\$1id é sempre igual a 1.
```
"document":{
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"description":"document text",
"summary":"summary text",
"statistics":{
"element_count":5,
"table_count":1,
"figure_count":1,
"word_count":1000,
"line_count":32
}
},
```
A seção acima fornece informações de granularidade em nível de documento. As seções de descrição e resumo são os campos gerados com base no documento. A seção de representação fornece o conteúdo real do documento com vários estilos de formatação. Finalmente, as estatísticas contêm informações sobre o conteúdo real do documento, como quantos elementos semânticos existem, quantas figuras, palavras, linhas etc.
Observação: ao contrário da solicitação assíncrona, a InvokeDataAutomationAsync InvokeDataAutomation solicitação síncrona não oferece suporte ao retorno de informações csv e imagens recortadas da tabela nos buckets do S3.
```
{
"id":"entity_id",
"type":"TEXT",
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"reading_order":2,
"page_indices":[
0
],
"locations":[
{
"page_index":0,
"bounding_box":{
"left":0.0,
"top":0.0,
"width":0.05,
"height":0.5
}
}
],
"sub_type":"TITLE/SECTION_TITLE/HEADER/FOOTER/PARAGRAPH/LIST/PAGE_NUMBER"
},
```
Essa é a entidade usada para texto em um documento, indicada pela linha TYPE na resposta. Novamente, a representação mostra o texto em formatos diferentes. reading\$1order mostra quando um leitor veria logicamente o texto. Essa é uma ordem semântica baseada em chaves e valores associados. Por exemplo, ele associa títulos de parágrafos aos respectivos parágrafos em ordem de leitura. page\$1indices informa em quais páginas o texto está. Em seguida, estão as informações de localização, com uma caixa delimitadora de texto aplicada, se ela tiver sido habilitada na resposta. Finalmente, temos o subtipo de entidade. Esse subtipo fornece informações mais detalhadas sobre o tipo de texto que está sendo detectado. Para ver uma lista completa de subtipos, consulte a “Referência de API”.
```
{
"id": "entity_id",
"type": "TABLE",
"representation": {
"html": "table.../table",
"markdown": "| header | ...",
"text": "header \t header",
"csv": "header, header, header\n..."
},
"headers": ["date", "amount", "description", "total"],
"reading_order": 3,
"title": "Title of the table",
"footers": ["the footers of the table"],
"page_indices": [0, 1],
"locations": [{
"page_index": 0,
"bounding_box": {
"left": 0,
"top": 0,
"width": 1,
"height": 1
}
}, {
"page_index": 1,
"bounding_box": {
"left": 0,
"top": 0,
"width": 1,
"height": 1
}
}]
},
```
Essas são as informações de uma entidade de tabela. As informações de CSV mostram os diferentes cabeçalhos, rodapés e títulos.
```
{
"id": "entity_id",
"type": "FIGURE",
"summary": "",
"representation": {
"text": "document text",
"html": "document title document content",
"markdown": "# text"
},
"locations": [
{
"page_index": 0,
"bounding_box": {
"left": 0,
"top": 0,
"width": 1,
"height": 1
}
}
],
"sub_type": "CHART",
"title": "figure title",
"reading_order": 1,
"page_indices": [
0
]
},
```
Essa é a entidade usada para figuras, como em grafos e tabelas de documentos. Você receberá uma resposta do título `sub_type` e uma figura para o texto do título e uma indicação do tipo de figura.
```
"pages":[
"pages":[
{
"id":"page_id",
"page_index":0,
"detected_page_number":1,
"representation":{
"text":"document text",
"html":"document title document content",
"markdown":"# text"
},
"statistics":{
"element_count":5,
"table_count":1,
"figure_count":1,
"word_count":1000,
"line_count":32
},
"asset_metadata":{
"rectified_image":"s3://bucket/prefix.png",
"rectified_image_width_pixels":1700,
"rectified_image_height_pixels":2200
}
}
],
```
A última das entidades que extraímos por meio da saída padrão são páginas. As páginas são iguais às entidades de texto, mas também contêm números de página, cujos números detectados estão na página.
```
"text_lines":[
{
"id":"line_id",
"text":"line text",
"reading_order":1,
"page_index":0,
"locations":{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
}
],
```
```
"text_words":[
{
"id":"word_id",
"text":"word text",
"line_id":"line_id",
"reading_order":1,
"page_index":0,
"locations":{
"page_index":0,
"bounding_box":{
"left":0,
"top":0,
"width":1,
"height":1
}
}
}
]
```
Esses dois elementos finais são para partes de texto individuais. A granularidade em nível de palavra exibe uma resposta para cada palavra, enquanto a saída padrão relata somente linhas de texto.
------
## Metadados adicionais de formato de arquivo JSON
Ao receber seus arquivos adicionais do sinalizador de formatos de arquivo adicionais, você receberá um arquivo JSON para todas as imagens retificadas extraídas. A BDA retifica imagens rotacionadas usando uma homografia para girar a imagem em um ângulo de 90 graus. Veja este exemplo JSON:
```
"asset_metadata": {
"rectified_image": "s3://bucket/prefix.png",
"rectified_image_width_pixels": 1700,
"rectified_image_height_pixels": 2200,
"corners": [
[
0.006980135689736235,
-0.061692718505859376
],
[
1.10847711439684,
0.00673927116394043
],
[
0.994479346419327,
1.050548828125
],
[
-0.11249661383904497,
0.9942819010416667
]
]
}
```
Os cantos representam os cantos detectados de uma imagem, usados para formar uma homografia do documento. Essa homografia é usada para girar a imagem enquanto mantém suas outras propriedades.
# Imagens
O recurso Automação de Dados do Amazon Bedrock (BDA) oferece um conjunto abrangente de saídas padrão para processar imagens e gerar insights com base nelas. Você pode usar esses insights para habilitar uma ampla variedade de aplicações e casos de uso, como descoberta de conteúdo, posicionamento contextual de anúncios e segurança da marca. Veja abaixo uma visão geral de cada tipo de operação disponível como parte das saídas padrão para imagens:
## Resumo de imagem
O resumo da imagem gera uma legenda descritiva para uma imagem. Esse recurso é automaticamente habilitado na configuração de saída padrão.
## Taxonomia do IAB
A classificação do Interactive Advertising Bureau (IAB) aplica uma taxonomia de publicidade padrão para classificar o conteúdo da imagem. Na versão prévia, a BDA atenderá a 24 categorias de nível superior (L1) e 85 categorias de nível secundário (L2). Para baixar a lista de categorias do IAB atendias pela BDA, clique [aqui](samples/iab-taxonomy.zip);
## Detecção de logotipo
Esse recurso identifica logotipos em uma imagem e fornece informações sobre a caixa delimitadora, indicando as coordenadas de cada logotipo detectado na imagem e as pontuações de confiança. Esse recurso não está habilitado por padrão.
## Detecção de texto de imagem
Esse recurso detecta e extrai o texto que aparece visualmente em uma imagem e fornece informações sobre a caixa delimitadora, indicando as coordenadas de cada elemento de texto detectado na imagem e as pontuações de confiança. Esse recurso é automaticamente habilitado na configuração de saída padrão.
## Moderação de conteúdo
A moderação de conteúdo detecta conteúdo impróprio, indesejado ou ofensivo em uma imagem. Na versão prévia, a BDA atenderá a sete categorias de moderação: nudez explícita e não explícita de partes íntimas e beijos, roupas de banho ou roupas íntimas, violência, drogas e tabaco, álcool e símbolos de ódio. O texto explícito nas imagens não é sinalizado.
As caixas delimitadoras e as pontuações de confiança associadas podem ser habilitadas ou desabilitadas para recursos relevantes, como detecção de texto, para fornecer coordenadas de localização na imagem. Por padrão, o resumo de imagem e a detecção de texto de imagem estão habilitados.
## Saída de imagem padrão
Veja a seguir um exemplo de saída padrão para imagem processada por meio da BDA. Cada seção foi reduzida e separada com uma explicação.
```
{
"metadata": {
"id": "image_123",
"semantic_modality": "IMAGE",
"s3_bucket": "my-s3-bucket",
"s3_prefix": "images/",
"image_width_pixels": 1920,
"image_height_pixels": 1080,
"color_depth": 24,
"image_encoding": "JPEG"
},
```
A primeira parte de uma resposta são os metadados de uma imagem. São fornecidos o nome do arquivo, o tipo de codificação, a localização do bucket do S3 e mais informações sobre o conteúdo.
```
"image": {
"summary": "Lively party scene with decorations and supplies",
```
O resumo generativo da imagem está no início da resposta.
```
"iab_categories": [
{
"id": "iab_12345",
"type": "IAB",
"category": "Party Supplies",
"confidence": 0.9,
"parent_name": "Events & Attractions",
"taxonomy_level": 2
},
{
"id": "iab_67890",
"type": "IAB",
"category": "Decorations",
"confidence": 0.8,
"parent_name": "Events & Attractions",
"taxonomy_level": 1
}
],
```
A seguir, vemos as categorias do IAB anexadas a uma resposta. Elas representam diferentes tipos de classificação de publicidade, usando a taxonomia padrão do IAB. Cada uma tem uma pontuação de confiança, taxonomy\$1level e parent\$1name para a categoria geral de alto nível.
```
"content_moderation": [
{
"id": "mod_12345",
"type": "MODERATION",
"category": "Drugs & Tobacco Paraphernalia & Use",
"confidence": 0.7,
"parent_name": "Drugs & Tobacco",
"taxonomy_level": 2
}
],
...
```
A moderação de conteúdo contém informações sobre possíveis conteúdos explícitos em uma imagem. Cada uma delas tem uma pontuação de confiança e uma categoria, alinhadas com as categorias de moderação de conteúdo discutidas anteriormente nesta seção.
```
"text_words": [
{
"id": "word_1",
"text": "lively",
"confidence": 0.9,
"line_id": "line_1",
"locations": [
{
"bounding_box": {
"left": 100,
"top": 200,
"width": 50,
"height": 20
},
"polygon": [
{"x": 100, "y": 200},
{"x": 150, "y": 200},
{"x": 150, "y": 220},
{"x": 100, "y": 220}
]
}
]
},
...
```
Esta seção divide cada palavra detectada em uma imagem, incluindo confiança e uma localização na tela dentro da imagem. Também sinaliza em qual linha a palavra está, usando `line_id`.
```
"text_lines": [
{
"id": "line_1",
"text": "lively party",
"confidence": 0.9,
"locations": [
{
"bounding_box": {
"left": 100,
"top": 200,
"width": 200,
"height": 20
},
"polygon": [
{"x": 100, "y": 200},
{"x": 300, "y": 200},
{"x": 300, "y": 220},
{"x": 100, "y": 220}
]
}
]
}
]
},
```
Aqui, as palavras são detectadas nas linhas coletivas, com pontuação de confiança e caixa delimitadora.
```
"statistics": {
"entity_count": 7,
"object_count": 3,
"line_count": 2,
"word_count": 9
}
}
```
Finalmente, temos estatísticas. Todo conteúdo de uma imagem é apresentado separadamente, inclusive o objeto.
# Vídeos
A BDA oferece um conjunto de saídas padrão para processar e gerar insights para vídeos. Veja abaixo uma visão detalhada de cada tipo de operação:
## Resumo de vídeo completo
O resumo de vídeo completo gera um resumo geral de todo o vídeo. Essa operação extrai os principais temas, eventos e informações apresentados ao longo do vídeo e oferece um resumo conciso. O resumo de vídeo completo é otimizado para conteúdo com diálogos descritivos, como visões gerais de produtos, treinamentos, noticiários, programas de entrevistas e documentários. A BDA tentará fornecer um nome para cada locutor exclusivo com base em sinais de áudio (p. ex., o locutor se apresenta) ou sinais visuais (p. ex., um slide de apresentação mostra o nome do locutor) no resumo de vídeo completo e no resumo de cena. Quando o nome de um locutor exclusivo não for resolvido, ele será representado por um número exclusivo (p. ex., speaker\$10).
## Resumo de capítulos
O resumo de capítulos de vídeo fornece resumos descritivos de cenas individuais em um vídeo. Um capítulo de vídeo é uma sequência de cenas que formam uma unidade coerente de ação ou narrativa dentro do vídeo. Esse recurso divide o vídeo em segmentos significativos com base em sinais visuais e sonoros, fornece carimbos de data/hora para esses segmentos e resume cada um.
## Taxonomia do IAB
A classificação do Interactive Advertising Bureau (IAB) aplica uma taxonomia de publicidade padrão para classificar cenas de vídeo com base em elementos visuais e de áudio. Na versão prévia, a BDA atenderá a 24 categorias de nível superior (L1) e 85 categorias de nível secundário (L2). Para baixar a lista de categorias do IAB atendias pela BDA, clique [aqui](samples/iab-taxonomy.zip);
## Transcrição de áudio completo
A transcrição de áudio completo oferece uma representação de texto completa de toda a fala no arquivo de áudio. Esse recurso usa tecnologia avançada de reconhecimento de fala para transcrever com precisão diálogos, narrações e outros elementos de áudio. A transcrição inclui a identificação do locutor, facilitando o processo de pesquisa do conteúdo de áudio com base no locutor.
## Texto em vídeo
Esse recurso detecta e extrai o texto que aparece visualmente no vídeo. Ele pode identificar texto estático (como títulos ou legendas) e texto dinâmico (como texto em movimento em elementos gráficos). De modo semelhante à detecção de texto de imagem, o recurso fornece informações da caixa delimitadora para cada elemento de texto detectado, permitindo uma localização precisa em quadros de vídeo.
## Detecção de logotipo
Esse recurso identifica logotipos em um vídeo e fornece informações sobre a caixa delimitadora, indicando as coordenadas de cada logotipo detectado no quadro de vídeo e as pontuações de confiança. Esse recurso não está habilitado por padrão.
## Moderação de conteúdo
A moderação de conteúdo detecta conteúdo impróprio, indesejado ou ofensivo em um vídeo. A BDA atenderá a sete categorias de moderação: nudez explícita e não explícita de partes íntimas e beijos, roupas de banho ou roupas íntimas, violência, drogas e tabaco, álcool e símbolos de ódio. O texto explícito em vídeos não é sinalizado.
As caixas delimitadoras e as pontuações de confiança associadas podem ser habilitadas ou desabilitadas para recursos relevantes, como detecção de texto, para fornecer coordenadas de localização no arquivo de vídeo. Por padrão, o resumo de vídeo completo, o resumo de cena e a detecção de texto de vídeo estão habilitados.
**nota**
Só é possível aplicar o recurso a uma faixa de áudio por vídeo. Não é possível usar formatos de arquivo de legenda (p. ex., SRT, VTT etc.).
## Saída de vídeo padrão
Veja a seguir um exemplo de saída padrão para um vídeo processada por meio da BDA.
```
{
"metadata": {
"asset_id": "0",
"semantic_modality": "VIDEO",
"s3_bucket": "bedrock-data-automation-gamma-assets-us-east-1",
"s3_key": "demo-assets/Video/MakingTheCut.mp4",
"format": "QuickTime / MOV",
"frame_rate": 30,
"codec": "h264",
"duration_millis": 378233,
"frame_width": 852,
"frame_height": 480
},
```
Esta seção inicial discute as informações de metadados referentes ao vídeo. Isso inclui a localização do bucket, o formato, a taxa de quadros e outras informações importantes.
```
"shots": [ ...
{
"shot_index": 3,
"start_timecode_smpte": "00:00:08:19",
"end_timecode_smpte": "00:00:09:25",
"start_timestamp_millis": 8633,
"end_timestamp_millis": 9833,
"start_frame_index": 259,
"end_frame_index": 295,
"duration_smpte": "00:00:01:06",
"duration_millis": 1200,
"duration_frames": 36,
"confidence": 0.9956437242589935,
"chapter_indices": [
1
]
},
```
Este é um exemplo de uma tomada de vídeo em uma resposta. As tomadas representam pequenas partes de um vídeo, normalmente associadas a uma edição ou corte no vídeo. As tomadas contêm elementos iniciais e finais, além de um elemento chapter\$1indicies. Esse elemento indica de qual seção maior do vídeo, chamada de capítulo, a tomada faz parte.
```
"chapters": [
{
"start_timecode_smpte": "00:00:00:00",
"end_timecode_smpte": "00:00:08:18",
"start_timestamp_millis": 0,
"end_timestamp_millis": 8600,
"start_frame_index": 0,
"end_frame_index": 258,
"duration_millis": 8600,
"shot_indices": [
0,
1,
2
],
"summary": "At an elegant outdoor venue, a man in a suit and a woman in a patterned dress stand on a raised platform overlooking a reflective pool. The setting is adorned with palm trees and lush greenery, creating a tropical atmosphere. The man initiates the event by asking if they should begin, to which the woman responds affirmatively. As the scene progresses, the focus shifts to a woman wearing a distinctive black and white patterned coat, her hair styled in a bun. She stands alone in a dimly lit room, facing away from the camera. The narrative then moves to a formal setting where a man in a dark suit stands before a curtain backdrop, suggesting he may be about to address an audience or perform. The scene concludes with a view of the entire venue, showcasing its tropical charm with a swimming pool surrounded by palm trees and decorative lighting, indicating it's prepared for a special occasion.",
```
Os capítulos são partes maiores de um vídeo. Portanto, contêm informações de início e fim, como tomadas e um elemento shot\$1indicies. Os shot\$1indicies informam quais tomadas estão dentro de um capítulo. Finalmente, o elemento de resumo oferece um resumo gerado do conteúdo do capítulo.
```
"frames": [...
{
"timecode_smpte": "00:00:03:15",
"timestamp_millis": 3500,
"frame_index": 105,
"content_moderation": [],
"text_words": [
{
"id": "266db64a-a7dc-463c-b710-7a178a2cc4cc",
"type": "TEXT_WORD",
"confidence": 0.99844897,
"text": "ANDREA",
"locations": [
{
"bounding_box": {
"left": 0.1056338,
"top": 0.7363281,
"width": 0.19806337,
"height": 0.068359375
},
"polygon": [
{
"x": 0.1056338,
"y": 0.7363281
},
{
"x": 0.30369717,
"y": 0.7363281
},
{
"x": 0.30369717,
"y": 0.8046875
},
{
"x": 0.1056338,
"y": 0.8046875
}
]
}
],
"line_id": "57b760fc-c410-418e-aee3-7c7ba58a71c2"
},
```
A menor granularidade de um vídeo é um quadro, representando uma única imagem dentro de um vídeo. Vale observar que os quadros têm dois elementos de resposta, content\$1moderation e text\$1words. A primeira, content\$1moderation, fornece informações com base nas categorias de moderação de conteúdo do quadro, se alguma for detectada. A segunda, text\$1words, fornece uma localização e informações sobre qualquer texto que apareça em um vídeo, como legendas ocultas.
```
"statistics": {
"shot_count": 148,
"chapter_count": 11,
"speaker_count": 11
}
}
```
Por fim, as estatísticas fornecem um detalhamento das informações sobre a detecção, como o número de tomadas, locutores e capítulos em um determinado vídeo.
# Áudio
O recurso Automação de Dados do Amazon Bedrock (BDA) oferece um conjunto de saídas padrão para processar e gerar insights para arquivos de áudio. Veja abaixo uma visão detalhada de cada tipo de operação:
## Resumo de áudio completo
O resumo de áudio completo gera um resumo geral de todo o áudio. Essa operação extrai os principais temas, eventos e informações apresentados ao longo do áudio e oferece um resumo conciso.
## Transcrição de áudio completo
O recurso de transcrição de áudio completo oferece uma representação de texto completa de todo o conteúdo falado no áudio. Esse recurso usa tecnologia avançada de reconhecimento de fala para transcrever com precisão diálogos, narrações e outros elementos de áudio. A transcrição inclui carimbo de data/hora, facilitando o processo de pesquisa do conteúdo de áudio com base nas palavras proferidas.
### Rotulagem de locutor e canal
Para a transcrição gerada, você pode ativar a rotulagem do and/or alto-falante do canal. Isso dará a cada canal ou locutor um número e, em seguida, indicará na transcrição quando um canal está sendo usado e um locutor específico está falando. Esse rótulo aparece na resposta como “spk\$1” seguido de um número exclusivo para cada locutor (até trinta locutores). O primeiro locutor seria “spk\$10", “spk\$11” e assim por diante. Os canais de áudio são indicados de forma semelhante com o primeiro canal rotulado como “ch\$10”, mas só podem ser rotulados em dois canais.
## Resumo de tópico
O resumo de tópico de áudio separa o arquivo de áudio em seções chamadas tópicos e as resume para fornecer informações importantes. Esses tópicos recebem carimbos de data/hora para ajudar a colocá-los no arquivo de áudio como um todo. Esse recurso não está habilitado por padrão.
## Moderação de conteúdo
A moderação de conteúdo usa dicas baseadas em áudio e texto para identificar e classificar conteúdo tóxico com base em voz em sete categorias diferentes:
+ ****Palavrões:**** discurso que contém palavras, frases ou acrônimos que são indelicados, vulgares ou ofensivos.
+ ****Discurso de ódio:**** discurso que critica, insulta, denuncia ou desumaniza uma pessoa ou grupo com base em uma identidade (como raça, etnia, gênero, religião, orientação sexual, capacidade e nacionalidade).
+ ****Sexual: ****discurso que indica interesse, atividade ou excitação sexual usando referências diretas ou indiretas a partes do corpo, características físicas ou sexo.
+ ****Insultos:**** discurso que inclui linguagem degradante, humilhante, zombeteira, insultante ou depreciativa. Esse tipo de linguagem também é chamado de bullying.
+ ****Violência ou ameaça: ****discurso que inclui ameaças com o objetivo de infligir dor, lesão ou hostilidade a uma pessoa ou grupo.
+ ****Gráfico:**** discurso que usa imagens visualmente descritivas e desagradavelmente vívidas. Em geral, esse tipo de linguagem é intencionalmente prolixo para ampliar o desconforto do destinatário.
+ ****Assédio ou abuso:**** discurso destinado a afetar o bem-estar psicológico do destinatário, incluindo termos humilhantes e objetificantes. Esse tipo de linguagem também é chamado de assédio.
## Saída padrão de áudio
Esta seção se concentra nos diferentes objetos de resposta que você recebe ao executar a operação da API InvokeDataAutomation em um arquivo de áudio. Detalharemos abaixo cada seção do objeto de resposta e, em seguida, veremos uma resposta completa e preenchida para um documento de exemplo. A primeira seção que receberemos é `metadata`.
```
"metadata": {
"asset_id": "0",
"semantic_modality": "AUDIO",
"s3_bucket": "bedrock-data-automation-gamma-assets-us-east-1",
"s3_key": "demo-assets/Audio/AWS_TCA-Call-Recording-2.wav",
"sample_rate": 8000,
"bitrate": 256000,
"number_of_channels": 2,
"codec": "pcm_s16le",
"duration_millis": 237560,
"format": "wav",
"dominant_asset_language": "EN",
"generative_output_language": "DEFAULT/EN"
}
```
Esta seção detalha as informações sobre o arquivo, como local do S3, taxa de bits, canais de áudio e formato. Em seguida, analisamos `audio_items`.
`dominant_asset_language`indica qual idioma está mais presente em uma peça de áudio com base na duração em segundos. `generative_output_language`indica em qual idioma a saída da resposta estará. Quando definido como “DEFAULT”, ele usará o idioma dominante.
```
"audio_items": [
{
"item_index": 0,
"audio_segment_index": 0,
"content": "Auto",
"start_timestamp_millis": 9,
"end_timestamp_millis": 119
},
...
]
```
A seção de itens inclui um detalhamento do arquivo de áudio, som por som. Cada item geralmente tem o tamanho de uma palavra. O item\$1index indica a posição do item nos índices audio\$1items e o audio\$1segment\$1index indica onde ele está nos índices de segmentos, o que discutiremos a seguir.
```
"audio_segments": [
{
"start_timestamp_millis": 0,
"end_timestamp_millis": 1970,
"segment_index": 0,
"type": "TRANSCRIPT",
"text": "Auto sales, Cherry speaking. How can I help you?",
"speaker": {
"speaker_label": "spk_0"
},
"channel": {
"channel_label": "ch_0"
},
"audio_item_indices": [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11
],
"language": "EN"
},
...
]
```
Aqui, obtemos um detalhamento do arquivo com base em períodos mais longos, em que cada segmento é igual a aproximadamente uma frase. Ele nos indica quais itens de áudio estão incluídos no segmento e o texto do próprio segmento. A seguir, vamos analisar a moderação de conteúdo.
Com a rotulagem de locutor e canal habilitada, é possível ver as seções `speaker_label` e `channel_label` que indicam qual locutor e canal estão presentes nesse segmento.
```
"content_moderation": [
{
"id": "93068e72-290d-4aad-8717-a2cd0e02b0d0",
"type": "AUDIO_MODERATION",
"confidence": 0.0476,
"start_timestamp_millis": 0,
"end_timestamp_millis": 1970,
"moderation_categories": [
{
"category": "profanity",
"confidence": 0.1582
},
...
]
},
...
]
```
A seção de moderação de conteúdo examina cada segmento e o analisa em relação qualquer uma das sete categorias de moderação, fornecendo pontuações de confiança para cada seção. Nossa próxima seção é sobre tópicos.
```
"topics": [
{
"topic_index": 0,
"start_timestamp_millis": 0,
"end_timestamp_millis": 36790,
"summary": "As follows:\n\nSuzanne, a customer, recently had her Hyundai serviced at the auto sales shop where Carrie works. Suzanne had a 3 p.m. appointment and got her car serviced, which included an oil change and filter changes. However, when Suzanne left the shop, her oil light was still on, which she found concerning. Carrie acknowledged that this sometimes happens, even after a service visit, and assured Suzanne that she would look into the issue further.",
"transcript": {
"representation": {
"text": "Auto sales, Cherry speaking. How can I help you? Yeah, hi Carrie, um, my name is Suzanne. I literally just left your shop. Um, I just went in and got my Hyundai service. Um, it just was, it just needed like filter error changes oil change and all that kind of stuff, um, but. When I left and my oil light is still on and I don't know why. Got it. You just got it serviced here, but when you drove off the light was still on. Is that what happened? Yeah, yeah, yeah, like I literally like I had a 3 p.m. appointment and I just got it, you know, believe it or not, this, this happens."
}
},
"audio_segment_indices": [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
]
},
...
]
```
As seções de tópico são o próximo nível de granularidade dos segmentos. Os tópicos são agrupamentos de segmentos divididos por conceitos de uma maneira aproximada. Cada tópico vem com um resumo gerado do tópico e o teste exato do tópico. Nossa parte final em uma resposta são as estatísticas.
```
"statistics": {
"word_count": 749,
"topic_count": 4
}
```
Esta seção resume as informações sobre o arquivo de áudio. Isso inclui a contagem de palavras e o total de tópicos.
# Saída e esquemas personalizados
Ao usar a Automação de Dados do Amazon Bedrock (BDA), você pode ajustar ainda mais suas extrações usando a configuração de saída personalizada. As saídas personalizadas são configuradas com artefatos chamados esquemas. Os esquemas são uma lista de instruções sobre como extrair informações de um arquivo, permitindo a transformação e o ajuste da saída. Para ver informações e uma demonstração detalhada de um esquema, consulte [Esquemas](bda-blueprint-info.md).
A configuração de saída personalizada também funciona com projetos. Quando você transmite um arquivo à BDA e faz referência a um projeto com esquemas configurados, a BDA processa o arquivo usando o esquema apropriado. Isso funciona para até 40 esquemas de documentos, um plano de imagem, um plano de áudio e um plano de vídeo. and/or Ao trabalhar com vários esquemas, a BDA tenta enviar documentos ao esquema que melhor corresponda ao layout esperado. Para ter mais informações sobre projetos e saída personalizada, consulte [Projetos da Automação de Dados do Bedrock](bda-projects.md).
**nota**
Todos os arquivos processados pela saída personalizada devem seguir as restrições de arquivo da BDA. Para ter informações sobre restrições de arquivo, consulte “Pré-requisitos da BDA”.
# Esquemas
Os esquemas são artefatos que podem ser usados para configurar a lógica de negócios do processamento de arquivos. Cada esquema consiste em uma lista de nomes de campo que você pode extrair, no formato de dados no qual você deseja que a resposta do campo seja extraída, como string, número ou booliano, e no contexto de linguagem natural para cada campo que você pode usar para especificar regras de normalização e validação de dados. É possível criar um esquema para cada classe de arquivo que você deseja processar, como um W2, um contracheque ou uma carteira de identidade. Os esquemas podem ser criados no console ou usando a API. Cada blueprint que você cria é um AWS recurso com seu próprio ID de blueprint e ARN.
Ao usar um esquema para extração, é possível usar um esquema de catálogo ou um esquema personalizado já criado. Se você já sabe qual tipo de arquivo deseja extrair, os esquemas do catálogo são um ponto de partida predefinido. É possível criar esquemas personalizados para arquivos que não estão no catálogo. Ao criar um esquema, você pode usar vários métodos, como usar um esquema gerado por meio do prompt do esquema, criá-lo manualmente adicionando campos individuais ou criar o JSON de um esquema usando o editor JSON. Esses esquemas podem ser salvos em sua conta e compartilhados.
**nota**
Os esquemas de áudio não podem ser criados por meio de prompts do esquema.
O tamanho máximo de um esquema é 100 mil caracteres, formatado em JSON. Para blueprints que devem ser usados com a [InvokeDataAutomationAsync](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomationAsync.html)API, o máximo de campos por blueprint é 100. Para blueprints que devem ser usados com a [InvokeDataAutomation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomation.html)API, o máximo de campos por blueprint é 15.
**nota**
Ao usar esquemas, é possível usar prompts, seja em campos ou para a criação de esquemas. Permita que somente fontes confiáveis controlem a entrada do prompt. Amazon Bedrock não é responsável por validar a intenção do plano.
## Demonstração de um esquema
Vamos dar um exemplo de um documento de identificação, como um passaporte, e analisar um esquema para esse documento.
![\[Exemplo de passaporte com campos padrão, demonstrando o layout e os campos de dados que serão extraídos.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/passport2.png)
Veja aqui um exemplo de esquema para esse documento de identificação criado no console.
![\[Layout da tabela das definições dos campos do passaporte, com várias categorias, mostrando um exemplo de esquema.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bdapassport.png)
Em essência, um esquema é uma estrutura de dados que contém campos, que, por sua vez, contêm as informações extraídas pela saída personalizada da BDA. Na tabela de extração, há dois tipos de campo, explícitos e implícitos. As extrações explícitas são usadas para obter informações claramente definidas que podem ser vistas no documento. As extrações implícitas são usadas para informações que precisam ser transformadas de acordo com a forma como aparecem no documento. Por exemplo, você pode remover os traços de um número de previdência social, convertendo 111-22-3333 em 111223333. Os campos contêm determinados componentes básicos:
+ Nome do campo: um nome que você pode fornecer para cada campo que deseja extrair do documento. É possível usar o nome que você usa para o campo em seu sistema subsequente, como `Place_Birth` ou `Place_of_birth`.
+ Descrição: é uma entrada que oferece contexto em linguagem natural para cada campo no esquema para descrever as regras de normalização ou validação de dados a serem seguidas. Por exemplo, `Date of birth in YYYY-MM-DD format` ou `Is the year of birth before 1992?`. Também é possível usar o prompt como uma forma de iterar no esquema e melhorar a precisão da resposta da BDA. Fornecer um prompt detalhado que descreva o campo do que você precisa ajuda os modelos subjacentes a melhorar a respectiva precisão. Os prompts podem ter até 300 caracteres.
+ Resultados: as informações extraídas pela BDA com base no prompt e no nome do campo.
+ Tipo: o formato de dados que você deseja que a resposta do campo use. Nós permitimos string, número, booliano, matriz de string e matriz de números.
+ Pontuação de confiança: a porcentagem de certeza que a BDA tem de que sua extração é precisa. Os esquemas de áudio e imagem não retornam uma pontuação de confiança.
+ Tipos de extração: o tipo de extração, explícita ou inferida.
+ Número da página: em qual página do documento o resultado foi encontrado. Os esquemas de áudio e vídeo não exibem o número da página.
Além dos campos simples, a saída personalizada da BDA oferece várias opções para casos de uso que você pode encontrar na extração de documentos: campos de tabela, grupos e tipos personalizados.
**Campos da tabela**
Ao criar um campo, você pode optar por criar um campo de tabela em vez de um campo básico. Você pode nomear o campo e fornecer um prompt, como ocorre com outros campos. Também é possível fornecer campos de coluna. Esses campos têm nome, descrição e tipo de coluna. Quando mostrado na tabela de extração, um campo de tabela tem os resultados da coluna agrupados abaixo do nome da tabela. Os campos de tabela podem ter no máximo 15 subcampos.
**Groups (Grupos)**
Um grupo é uma estrutura usada para organizar vários resultados em um único local dentro da extração. Ao criar um grupo, você atribui um nome a ele e pode criar e colocar campos nele. Esse grupo, que está marcado na tabela de extrações, lista os respectivos campos abaixo dele.
**Tipos personalizados**
Você pode criar um tipo personalizado ao editar um esquema no playground de esquemas. Qualquer campo pode ser de um tipo personalizado. Esse tipo tem um nome exclusivo e solicita a criação dos campos que compõem a detecção. Um exemplo seria criar um tipo personalizado chamado “Address” e incluir nele os campos “zip\$1code”, “city\$1name”, “street\$1name” e “state”. Em seguida, ao processar um documento, você pode usar o tipo personalizado em um campo “company\$1address”. Esse campo exibe então todas as informações agrupadas em linhas abaixo do tipo personalizado. É possível ter até trinta campos de tipo personalizado por esquema.
# Criar esquemas
## Como criar esquemas para saídas personalizadas
Amazon Bedrock O Data Automation (BDA) permite que você crie esquemas personalizados para qualquer tipo de arquivo que o BDA possa extrair. É possível usar esquemas para definir o formato de saída e a lógica de extração desejados para os arquivos de entrada. Ao criar projetos personalizados, você pode personalizar a saída da BDA para atender a seus requisitos específicos.
Em um projeto, você pode aplicar:
+ Vários esquemas de documentos (até 40). Isso permite processar diferentes tipos de documento no mesmo projeto, cada um com uma lógica de extração personalizada.
+ Uma imagem de esquema. Isso garante consistência no processamento de imagens em um projeto.
+ Um esquema de áudio.
+ Um esquema de vídeo.
### Criar esquemas
Há dois métodos para criar esquemas na BDA:
+ Usar o prompt do esquema
+ Criar o esquema manualmente
#### Usar o prompt do esquema
O prompt do esquema oferece uma interface guiada e baseada em linguagem natural para criar esquemas. Para criar um esquema usando o prompt:
1. Navegue até a seção **Esquemas** no console da BDA.
1. Clique em **Criar esquema** e selecione **Use o prompt do esquema**.
1. Escolha o tipo de dados (documento, imagem, áudio ou vídeo) para o esquema.
1. Descreva os campos e os dados que você deseja extrair em linguagem natural. Por exemplo: “Extraia o nome do fornecedor, o número da fatura e o valor total das faturas”.
1. O prompt gerará um esquema com base na sua descrição.
1. Analise o esquema gerado e faça os ajustes necessários. Os prompts do esquema baseiam-se em um único turno, o que significa que você precisará inserir novamente todas as informações para alterar o prompt, não apenas novas informações.
1. Salve e dê um nome ao esquema.
##### Exemplo de prompt de esquema
A seção a seguir mostra um exemplo de prompt de esquema para um esquema de áudio. Para esse caso de uso, queremos criar um esquema para extrair informações de uma conversa entre um cliente e um representante de atendimento ao cliente. A captura de tela abaixo mostra a janela de prompt no console.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/audio-bpa-prompt.png)
Na parte inferior da captura de tela, você pode ver o prompt gerado por IA com base na entrada na caixa. Podemos ver como os campos que mencionamos são processados. Em seguida, podemos ver o esquema criado com base no prompt.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/audio-bpa-example.png)
Aqui, podemos ver as informações que esperamos processar da conversa. Se achar que os campos estão adequados, você pode começar a processar um arquivo de áudio imediatamente. Se quiser editar o esquema, precisará criar uma duplicata em vez de editar diretamente. Também é possível ajustar o prompt para outros resultados.
#### Criar esquemas manualmente
Para usuários mais avançados ou aqueles que precisam de controle refinado, é possível criar esquemas manualmente:
1. Navegue até a seção **Esquemas** no console da BDA.
1. Clique em **Criar esquema** e selecione **Criar manualmente**.
1. Escolha o tipo de dados (documento, imagem, áudio ou vídeo) para o esquema.
1. Defina os campos que você deseja extrair, especificando tipos de dados, formatos e quaisquer regras de validação.
1. Defina configurações adicionais, como divisão de documentos ou ajuste de layout.
1. Salve e dê um nome ao esquema.
Também é possível usar o editor JSON de esquemas para criar ou modificar um esquema. Isso permite que você ajuste o JSON do esquema diretamente por meio do editor de texto.
### Adicionar esquemas a projetos
Os projetos servem como contêineres para os fluxos de trabalho de processamento de conteúdo multimodais, enquanto os esquemas definem a lógica de extração desses fluxos de trabalho. Você adiciona esquemas aos projetos para aplicá-los aos arquivos processados com esses projetos.
Para adicionar um esquema a um projeto:
1. Navegue até a seção **Projetos** no console da BDA.
1. Selecione o projeto ao qual deseja adicionar o esquema.
1. Clique em **Adicionar esquema** ou **Gerenciar esquemas**.
1. Escolha o esquema que você deseja adicionar na lista de esquemas disponíveis.
1. Defina todas as configurações específicas do projeto para o esquema.
1. Salve as alterações em seu projeto.
### Definir campos
Para começar, você pode criar um campo para identificar as informações que deseja extrair ou gerar, como product\$1type. Para cada campo, você precisa fornecer descrição, tipo de dados e tipo de inferência.
Para definir um campo, especifique os seguintes parâmetros:
+ *Description:* fornece uma explicação em linguagem natural sobre o que o campo representa. Essa descrição ajuda a entender o contexto e a finalidade do campo, contribuindo para a extração precisa dos dados.
+ *Type*: especifica o tipo de dados do valor do campo. A BDA permite os seguintes tipos:
+ string: para valores baseados em texto.
+ número: para valores numéricos.
+ booliano: valores verdadeiros ou falsos.
+ matriz: para campos que podem ter vários valores do mesmo tipo (p. ex., uma matriz de strings ou uma matriz de números).
+ *Inference Type:* instrui a BDA sobre como lidar com a geração de resposta do valor do campo. Para imagens, a BDA permite apenas o tipo de inferência inferida. Isso significa que a BDA infere o valor do campo com base nas informações presentes na imagem.
Para vídeo, os campos também contêm a opção de granularidade. Para ter mais informações sobre essa característica, consulte “Criar esquemas para vídeos”.
A imagem a seguir mostra o módulo “Adicionar campos” no Amazon Bedrock console com os seguintes exemplos de campos e valores:
+ Nome do campo: product\$1type
+ Tipo: string
+ Instrução: qual é o principal produto ou serviço anunciado; por exemplo, roupas, eletrônicos, alimentos e bebidas etc.?
+ Tipo de extração: inferido.
![\[Amazon Bedrock UI mostrando menus suspensos e campo de texto para especificar campos de imagem.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-console-add-fields-new.png)
Veja abaixo um exemplo da aparência dessa mesma definição de campo em um esquema JSON para a API:
```
"product_type":{
"type": "string",
"inferenceType": "inferred",
"description": "What is the primary product or service being advertised, e.g., Clothing, Electronics, Food & Beverage, etc.?"
}
```
Neste exemplo:
+ O tipo está definido como string, indicando que o valor do campo product\$1type deve ser baseado em texto.
+ inferenceType está definido como inferido, instruindo a BDA a inferir o valor com base nas informações presentes na imagem.
+ A descrição fornece contexto adicional, esclarecendo que o campo deve identificar o tipo de produto na imagem. Os valores de exemplo para o campo product\$1type são: roupas, eletrônicos e alimentos ou bebidas.
Ao especificar esses parâmetros para cada campo, você fornece à BDA as informações necessárias para extrair e gerar insights de suas imagens.
### Criar versões do projeto
Ao trabalhar com projetos, você pode criar uma versão de um esquema. Uma versão é um snapshot imutável de um esquema, preservando as respectivas configurações atuais e a lógica de extração. Essa versão do esquema pode ser transmitida em uma solicitação para iniciar o processamento de dados, garantindo que a BDA processe os documentos de acordo com a lógica especificada no esquema no momento em que a versão foi criada.
É possível criar uma versão usando a operação `CreateBlueprintVersion`.
O console do Amazon Bedrock também permite que você crie e salve esquemas. Ao salvar um esquema, um ID é atribuído a ele. Em seguida, você pode publicar o esquema, o que cria uma versão de snapshot desse esquema que não pode ser editada. Por exemplo, se o blueprint associado ao seu projeto for “DocBlueprint”, a versão do projeto criado será “DocBlueprint\$11”. Você não poderá fazer mais alterações em “DocBlueprint\$11”, mas ainda poderá editar o blueprint básico. Se você fizer alterações no blueprint e publicar novamente, uma nova versão será criada, como “DocBlueprint\$12”. As versões do esquema podem ser duplicadas e usadas como base para um novo esquema.
# Utilizar esquemas para realizar diferentes tarefas de IDP
Os esquemas são uma ferramenta extremamente versátil para processamento de documentos. As seções a seguir abordam a criação de esquemas com várias metas de processamento de documentos inteligente (IDP) em mente. Além disso, esta seção oferece uma visão mais detalhada das particularidades da criação de esquemas para documentos em geral.
# Criar esquemas para classificação
Com a BDA, é possível classificar documentos atribuindo uma classe de documentos e fornecendo uma descrição ao criar um esquema. A classe de documentos serve como uma categorização abrangente do tipo de documento, enquanto a descrição fornece detalhes mais granulares sobre o conteúdo e os elementos esperados dentro dessa classe de documentos. Recomendamos que a descrição especifique o tipo usual de dados encontrados nos documentos, bem como outras informações relevantes, como a finalidade do documento e as entidades esperadas.
Exemplos de classes de documentos e das respectivas descrições:
| Classe de documentos | Descrição |
| --- | --- |
| Fatura | Uma fatura é um documento que contém a lista de serviços prestados ou itens comprados de uma empresa por uma pessoa ou outra empresa. Ela contém determinados detalhes, como quando o pagamento vence e quanto é devido. |
| Contracheque | Esse documento emitido pelo empregador ao funcionário contém salários recebidos pelo funcionário por um determinado período. Geralmente contém o detalhamento de cada um dos itens de dedução fiscal e de renda. |
| Recibos | Um documento confirmando que uma pessoa recebeu dinheiro ou bens em pagamento após uma venda ou outra transferência de bens ou prestação de serviço. Todos os recibos devem conter a data da compra. |
| W2 | Um formulário fiscal para registrar a renda pessoal recebida de um empregador em um ano fiscal. |
Depois de criar os campos do esquema, siga estas etapas:
1. Na página “Criar esquema”, escolha **Salvar e sair do prompt do esquema**.
1. Em “Nome do esquema”, insira um nome para o esquema.
1. Em “Classe do documento”, insira um nome de classe que represente o tipo de documento que você deseja classificar.
1. No campo “Descrição”, forneça uma descrição detalhada do tipo de documento. Inclua informações sobre os tipos de dados e elementos comumente encontrados nesses documentos, como pessoa, empresa, endereços, detalhes do produto ou qualquer outra informação relevante.
1. Escolha “Publicar esquema”.
Depois de criar o esquema, você pode usá-lo para classificar documentos durante a inferência fornecendo um ou mais IDs de esquema na solicitação de API InvokeDataAutomationAsync.
A BDA usa a classe e a descrição do documento fornecidas em cada um dos esquemas para categorizar e processar os documentos com precisão. Quando você envia um documento para processamento, a BDA analisa o conteúdo e o compara com a lista de esquemas fornecidos. O documento é então classificado e processado com base nas instruções do campo do esquema para produzir a saída na estrutura desejada.
# Criar esquemas para extração
A BDA permite que você defina os campos de dados específicos que você deseja extrair de seus documentos ao criar um esquema. Isso funciona como um conjunto de instruções que orientam a BDA sobre quais informações procurar e como interpretá-las.
**Definir campos**
Para começar, você pode criar uma propriedade para cada campo que exija extração, como employee\$1id ou product\$1name. Para cada campo, você precisa fornecer descrição, tipo de dados e tipo de inferência.
Para definir um campo para extração, você precisa especificar os seguintes parâmetros:
+ Nome do campo: fornece uma explicação legível sobre o que o campo representa. Essa descrição ajuda a entender o contexto e a finalidade do campo, contribuindo para a extração precisa dos dados.
+ Instrução: oferece uma explicação em linguagem natural do que o campo representa. Essa descrição ajuda a entender o contexto e a finalidade do campo, contribuindo para a extração precisa dos dados.
+ Type: especifica o tipo de dados do valor do campo. A BDA aceita os seguintes tipos de dados:
+ string: para valores baseados em texto.
+ número: para valores numéricos.
+ boolean: Para valores true/false
+ matriz: para campos que podem ter vários valores do mesmo tipo (p. ex., uma matriz de strings ou uma matriz de números).
+ Tipo de inferência: instrui a BDA sobre como lidar com a extração do valor do campo. Os tipos de inferência aceitos são:
+ Explícito: a BDA deve extrair o valor diretamente do documento.
+ Inferido: a BDA deve inferir o valor com base nas informações presentes no documento.
Veja abaixo um exemplo de definição de campo:
------
#### [ Console ]
![\[Console mostrando como adicionar “Nome do campo” e “Instrução”. “Type” está definido como “String” e “Extraction type” está definido como “Explicit”.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bdaadd.png)
------
#### [ API ]
```
"product_name":{
"type":"string",
"inferenceType":"Explicit",
"description":"The short name of the product without any extra details"
}
```
------
Neste exemplo:
+ O tipo está definido como string, indicando que o valor do campo product\$1name deve ser baseado em texto.
+ inferenceType está definido como Explicit, instruindo a BDA a extrair o valor diretamente do documento sem nenhuma transformação ou validação.
+ A instrução fornece contexto adicional, esclarecendo que o campo deve conter o nome curto do produto sem detalhes adicionais.
Ao especificar esses parâmetros para cada campo, você fornece à BDA as informações necessárias para extrair e interpretar com precisão os dados desejados de seus documentos.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| ApplicantsName | Nome completo do candidato | Explícito | string |
| DateOfBirth | Data de nascimento do funcionário | Explícito | string |
| Vendas | Receitas brutas ou vendas | Explícito | número |
| Statement\$1starting\$1balance | Saldo no início do período | Explícito | número |
**Campos de vários valores**
Nos casos em que um campo pode conter vários valores, é possível definir matrizes ou tabelas.
**Lista de campos**
Para campos que contêm uma lista de valores, é possível definir matriz como tipo de dados.
Neste exemplo, "OtherExpenses" é definido como uma matriz de sequências de caracteres, permitindo que o BDA extraia vários itens de despesas para esse campo.
------
#### [ Console ]
![\[Console mostrando como adicionar “Nome do campo” e “Instrução”. “Type” está definido como “String” e “Extraction type” está definido como “Explicit”.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bdaarray.png)
------
#### [ API ]
```
"OtherExpenses":{
"type":"array",
"inferenceType":"Explicit",
"description":"Other business expenses not included in fields 8-26 or field 30",
"items":{
"type":"string"
}
}
```
------
**Tabelas**
Se o documento contiver dados tabulares, você poderá definir uma estrutura de tabela dentro do esquema.
Neste exemplo, “SERVICES\$1TABLE” é definido como um tipo de tabela, com determinados campos de coluna, como nome do produto, descrição, quantidade, preço unitário e valor.
------
#### [ Console ]
![\[Console mostrando como adicionar “Nome do campo” e “Instrução”. “Type” está definido como “Table”, “Extraction type” está definido como “Explicit” e os campos específicos da coluna que são adicionados são mostrados.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bdatable.png)
------
#### [ API ]
```
"definitions":{
"LINEITEM":{
"properties":{
"quantity":{
"type":"number",
"inferenceType":"Explicit"
},
"unit price":{
"type":"number",
"inferenceType":"Explicit"
},
"amount":{
"type":"number",
"inferenceType":"Explicit",
"description":"Unit Price * Quantity"
},
"product name":{
"type":"string",
"inferenceType":"Explicit",
"description":"The short name of the product without any extra details"
},
"product description":{
"type":"string",
"inferenceType":"Explicit",
"description":"The full item list description text"
}
}
}
},
"properties":{
"SERVICES_TABLE":{
"type":"array",
"description":"Line items table listing all the items / services charged in the invoice including quantity, price, amount, product / service name and description.",
"items":{
"$ref":"#/definitions/LINEITEM"
}
},
"...
..."
]
```
------
Ao definir esquemas abrangentes com descrições de campo, tipos de dados e tipos de inferência apropriados, você pode garantir que a BDA extraia com precisão as informações desejadas dos documentos, independentemente de variações na formatação ou representação.
# Criar esquemas para normalização
A BDA oferece recursos de normalização que permitem converter e padronizar os dados extraídos de acordo com seus requisitos específicos. Essas tarefas de normalização podem ser categorizadas em normalização de chaves e normalização de valores.
**Normalização de chaves**
Em muitos casos, os campos do documento podem ter variações na forma como são representados ou rotulados. Por exemplo, o campo “Cadastro de Pessoa Física” pode aparecer como “CPF”, “Identidade fiscal”, “número de identificação de contribuinte fiscal” ou outras variações semelhantes. Para enfrentar esse desafio, a BDA oferece a normalização de chaves, que permite que você forneça instruções sobre as variações em suas definições de campo.
Ao utilizar a normalização de chaves, você pode orientar a BDA a reconhecer e mapear diferentes representações do mesmo campo em uma chave padronizada. Esse recurso garante que os dados sejam extraídos e organizados de forma consistente, independentemente das variações presentes nos documentos originais.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| LastName | Sobrenome da pessoa. | Explícito | String |
| BirthNum | Número do documento ou número do arquivo da certidão de nascimento. | Explícito | String |
| OtherIncome | Outra renda, incluindo crédito ou reembolso de imposto federal e estadual sobre gasolina ou combustível. | Explícito | Número |
| BusinessName | Nome da empresa, contratante ou entidade que declara imposto de renda. | Explícito | String |
| power factor | Fator de potência ou multiplicador usado para esse item de linha de uso. | Explícito | String |
| BirthPlace | Nome do hospital ou da instituição onde a pessoa nasceu. | Explícito | String |
| Cause of Injury | Causa da lesão ou doença ocupacional e como ela está relacionada ao trabalho. | Explícito | String |
Para campos com conjuntos de valores ou enumerações predefinidos, você pode fornecer os valores ou intervalos esperados na instrução do campo. Recomendamos que você inclua as variações entre aspas, conforme mostrado nos exemplos.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| LICENSE\$1CLASS | O código de classe com uma única letra, como “A”, “B” ou “C.” | Explícito | String |
| sex | O sexo. “M” ou “F”. | Explícito | String |
| InformantType | O tipo de informação. “Pais” ou “Outro”. | Explícito | String |
| INFORMATION COLLECTION CHANNEL | UMA DAS SEGUINTES: “ENTREVISTA PRESENCIAL”, “ENTREVISTA POR TELEFONE”, “FAX OU CORREIO”, “E-MAIL OU INTERNET”. | Explícito | String |
**Normalização de valores**
A normalização de valores é uma tarefa fundamental nos pipelines de processamento de dados, em que os dados extraídos precisam ser transformados em um formato consistente e padronizado. Esse processo garante que os sistemas posteriores possam consumir e processar os dados sem problemas de compatibilidade ou ambiguidades.
Usando os recursos de normalização da BDA, você pode padronizar formatos, converter unidades de medida e converter valores em tipos de dados específicos.
Para tarefas de normalização de valores, o tipo extração inferida deve ser usado, pois o valor pode não corresponder exatamente ao texto bruto ou ao OCR do documento depois de normalizado. Por exemplo, um valor de data como “06/25/2022" que precisa ser formatado como “AAAA-MM-DD” será extraído como “2022-06-25" após a normalização, não correspondendo, portanto, à saída de OCR do documento.
Padronizar formatos: você pode converter valores em formatos predefinidos, como códigos abreviados, esquemas de numeração ou formatos de data específicos. Isso permite que você garanta a consistência na representação de dados aderindo aos padrões do setor ou a convenções organizacionais.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| ssn | O SSN, formatado como XXX-XX-XXX | Inferido | String |
| STATE | O código de duas letras do estado. | Inferido | String |
| EXPIRATION\$1DATE | A data de expiração no formato YYYY-MM-DD | Inferido | String |
| DATE\$1OF\$1BIRTH | A data de nascimento do motorista em YYYY-MM-DD formato | Inferido | String |
| CHECK\$1DATE | A data em que o cheque foi assinado. Reformatar para YYYY-MM-DD | Inferido | String |
| PurchaseDate | Data de compra do veículo em mm/dd/yy formato | Inferido | String |
Você também pode converter valores em uma unidade de medida padrão ou em um tipo de dados específico ao lidar com determinados cenários, como não aplicável.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| WEIGHT | Peso convertido em libras. | Inferido | Número |
| HEIGHT | Altura convertida em polegadas. | Inferido | Número |
| nonqualified\$1plans\$1income | O valor no campo 11. 0 se N/A. | Inferido | Número |
# Criar esquemas para transformação
A BDA permite que você divida e reestruture campos de dados de acordo com requisitos específicos. Esse recurso permite que você transforme os dados extraídos em um formato que se alinhe melhor com seus sistemas subsequentes ou necessidades analíticas.
Em muitos casos, os documentos podem conter campos que combinam várias informações em um único campo. A BDA permite que você divida esses campos em campos independentes e individuais para facilitar a manipulação e análise de dados. Por exemplo, se um documento contiver o nome de uma pessoa como um único campo, você poderá dividi-lo em campos separados para nome, segundo nome, sobrenome e sufixo.
Para tarefas de transformação, o tipo de extração pode ser definido como explícito ou inferido, dependendo se o valor precisa ser normalizado.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| FIRST\$1NAME | O nome. | Explícito | String |
| MIDDLE\$1NAME | O segundo nome ou inicial. | Explícito | String |
| LAST\$1NAME | O sobrenome do motorista. | Explícito | String |
| SUFFIX | O sufixo, como PhD, MSc. etc | Explícito | String |
Outro exemplo é com blocos de endereço que podem aparecer como um único campo.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| Rua | Qual é o endereço da rua | Explícito | String |
| Cidade | Qual é a cidade | Explícito | String |
| Estado | Qual é o estado? | Explícito | String |
| ZipCode | Qual é o código postal do endereço? | Explícito | String |
É possível definir esses campos como campos completamente individuais ou criar um tipo personalizado. Os tipos personalizados são aqueles que você pode reutilizar em campos diferentes. No exemplo abaixo, criamos um tipo personalizado “NameInfo”, que usamos para “EmployeeName” e “ManagerName”.
![\[Console mostrando como adicionar detalhes do tipo personalizado. Mostra também as subpropriedades adicionadas ao tipo personalizado.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bdacustomtype.png)
# Criar esquemas para validação
A Automação de Dados do Bedrock (BDA) permite que você defina regras de validação para garantir a precisão dos dados extraídos. Essas regras de validação podem ser incorporadas aos seus esquemas, permitindo que a BDA realize várias verificações nos dados extraídos. A BDA permite que você crie validações personalizadas adaptadas aos requisitos específicos de sua empresa ou setor. Veja a seguir alguns exemplos de validação para mostrar o alcance desse recurso.
**Validações numéricas**
As validações numéricas são usadas para verificar se os dados numéricos extraídos estão dentro de um intervalo especificado de valores ou atendem a determinados critérios. Essas validações podem ser aplicadas a determinados campos, como valores, quantidades ou qualquer outro dado numérico.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| BalanceGreaterCheck | O saldo anterior é superior a \$1 1.000? | Inferido | Booliano |
| O lucro bruto é igual à diferença entre vendas e COGS? | Pergunta de validação | Inferido | Booliano |
| is\$1gross\$1pay\$1valid | O salário bruto no acumulado do ano é o valor monetário mais alto no contracheque? | Inferido | Booliano |
**Validações de data/hora**
As validações de data/hora são usadas para verificar se os dados de data/hora extraídos estão dentro de um intervalo especificado de valores ou atendem a determinados critérios. Essas validações podem ser aplicadas a determinados campos, como prazos, datas de expiração ou vencimento ou quaisquer outros dados relacionados a data/hora.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| was\$1injury\$1reported\$1after\$11\$1month | A lesão foi relatada ao empregador mais de um mês após a data da lesão? | Inferido | Booliano |
| is\$1overdue | A declaração está atrasada? O prazo do pagamento do saldo expirou? | Inferido | Booliano |
| is\$1delivery\$1date\$1valid | A data de entrega será nos próximos trinta dias? | Inferido | Booliano |
**Validações de string/formato**
As validações de string/formato são usadas para verificar se os dados extraídos aderem a um formato específico ou correspondem a padrões predefinidos. Essas validações podem ser aplicadas a determinados campos, como nomes, endereços ou qualquer outro dado textual que exija validação de formato.
| Campo | Instrução | Tipo de extração | Tipo |
| --- | --- | --- | --- |
| routing\$1number\$1valid | Verdadeiro se o número de roteamento bancário tiver nove dígitos. | Inferido | Booliano |
| Is\$1NumMeterIDsListed | Há mais de cinco IDs de medição listados na fatura? | Inferido | Booliano |
Com os recursos de validação personalizados da BDA, você pode criar regras de validação complexas que combinam várias condições, cálculos ou operações lógicas para garantir que os dados extraídos atendam aos critérios desejados. Essas validações podem envolver verificações em vários campos, cálculos ou qualquer outra lógica personalizada específica para seus processos de negócios ou requisitos regulatórios.
Ao incorporar essas regras de validação em seus esquemas, a BDA pode validar automaticamente os dados extraídos, garantindo a precisão e conformidade com seus requisitos específicos. Esse recurso permite que você acione análises humanas quando as validações falharem.
# Criar esquemas para imagens
A Automação de Dados do Amazon Bedrock (BDA) permite que você crie esquemas personalizados para modalidades de imagem. É possível usar esquemas para definir o formato de saída e a lógica de extração desejados para os arquivos de entrada. Ao criar projetos personalizados, você pode personalizar a saída da BDA para atender a seus requisitos específicos. Em um projeto, é possível aplicar um único esquema de imagem.
## Definir campos de dados para imagens
A BDA permite que você crie um esquema para definir os campos específicos que deseja identificar em suas imagens. Isso funciona como um conjunto de instruções que orientam o BDA sobre quais informações extrair e gerar de suas imagens.
### Exemplos de campos de esquema para imagens de anúncios
Veja a seguir alguns exemplos de campos de esquema para analisar imagens de anúncios.
| | | | |
| --- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo |
| product\$1type | Qual é o principal produto ou serviço anunciado? Ex: roupas, eletrônicos, alimentos e bebidas | inferida | string |
| colocação\$1de\$1produto | Como o produto é colocado na imagem do anúncio, por exemplo, centralizado, em segundo plano, segurado por uma pessoa etc.? | inferida | string |
| tamanho\$1do\$1produto | O tamanho do produto é pequeno se o tamanho for menor que 30% da imagem, médio se estiver entre 30 a 60% e grande se for maior que 60% da imagem | inferida | string |
| estilo\$1de\$1imagem | Classifique o estilo da imagem do anúncio. Por exemplo, imagem do produto, estilo de vida, retrato, retrô, infográfico, nenhuma das opções acima. | inferida | string |
| fundo da imagem | O fundo pode ser “cor sólida, paisagem natural, interno, externo ou abstrato. | inferida | string |
| oferta\$1promocional | O anúncio inclui descontos, ofertas ou mensagens promocionais? | inferida | booleano |
### Exemplos de campos de esquema para pesquisa de mídia
Veja a seguir alguns exemplos de campos de esquema para gerar metadados de imagens para pesquisa de mídia.
| | | | |
| --- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo |
| contagem de pessoas | Quantas pessoas estão na imagem? | inferida | número |
| classificação interna\$1externa | A imagem é interna ou externa? | inferida | string |
| classificação\$1de\$1cena | Classifique a configuração ou o ambiente da imagem. Ex: Espaços urbanos, rurais, naturais, históricos, residenciais, comerciais, recreativos, públicos | inferida | string |
| identificação\$1animal | A imagem contém algum animal? | inferida | booleano |
| tipo\$1animal | Que tipo de animais estão presentes na imagem? | inferida | string |
| identificação\$1de\$1cor | A imagem é colorida ou em preto e branco? | inferida | string |
| identificação\$1veículo | Há algum veículo visível na imagem? | inferida | string |
| tipo\$1de\$1veículo | Que tipo de veículo está presente na imagem? | inferida | string |
| identificação\$1de\$1marca d'água | Há alguma marca d'água visível na imagem? | inferida | booleano |
# Criar esquemas para áudio
De modo semelhante aos esquemas de imagem, só é possível ter um esquema de áudio por projeto.
Abaixo são apresentados alguns exemplos de campo para processamento de áudio.
## Exemplos de campos de esquema para arquivos de áudio
| | | | |
| --- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo |
| transcript\$1summary | Generate a concise abstractive summary of the conversation, focusing on the main topics and key themes. Ensure accuracy by summarizing only what is explicitly discussed, without adding specific details not present in the conversation. Keeping the response within 100 words. | inferred | string |
| topics | The main topics of the audio transcript, listed as single words. | inferred | [string] (Array of strings) |
| category | The category of the audio (not the topic). Choose from General conversation, Media, Hospitality, Speeches, Meetings, Education, Financial, Public sector, Healthcare, Sales, Audiobooks, Podcasts, 911 calls, Other. | inferred | string |
| spoken\$1named\$1entities | Any named entities (typically proper nouns) explicitly mentioned in the audio transcript including locations, brand names, company names, product names, services, events, organizations, etc. Do not include names of people, email addresses or common nouns. | extractive | [string] (Array of strings) |
## Exemplos de campos de esquema para analytics conversacional
| | | | |
| --- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo |
| call\$1summary | Summarize the caller-agent conversation in under 100 words. Start with the caller's request, then the agent's response and actions, ending with outcomes or follow-ups. Include key details like emails, links, or callbacks. For multiple issues, summarize each with its outcome and next steps. | inferred | string |
| call\$1categories | The category (or categories) of the call. Choose one or more from Billing, Tech support, Customer service, Account support, Sales, Complaints, Product issues, Service issues, General inquiries, Other. | inferred | [string] (Array of strings) |
| spoken\$1locations | Locations explicitly mentioned in the conversation, including cities, states, and countries. | extractive | [string] |
| call\$1opening | Did the agent greet the caller and introduce themselves at the beginning of the call? | extractive | boolean |
# Criar esquemas para vídeo
Os esquemas para arquivos de vídeo têm algumas qualidades exclusivas em comparação com outros esquemas, principalmente com relação à criação de campos. Os esquemas de vídeo têm um parâmetro chamado granularidade, que permite definir um campo como vídeo ou capítulo. Quando o campo estiver definido como vídeo, ele será detectado em todo o vídeo. Por exemplo, se você quiser um resumo de todo o clipe, defina a granularidade desse campo como vídeo.
Já um campo com granularidade definida como capítulo exibirá uma resposta para cada capítulo do vídeo. O campo exibirá um valor para cada capítulo do vídeo. Dando continuidade ao exemplo anterior, se você quisesse um resumo de cada parte de um vídeo, você definiria a granularidade como capítulo.
Ao criar um campo de granularidade de capítulo, é possível definir um tipo de dados exclusivo, uma matriz de entidades. Por exemplo, se você quiser detectar os objetos visualmente proeminentes em seu vídeo, é possível criar um campo chamado `key-visual-objects` e definir o tipo como uma matriz de entidades. Esse campo então exibiria o nome das entidades em um objeto de matriz.
Abaixo são apresentados alguns exemplos de campo para processamento de vídeo. Todos os campos nos esquemas de vídeo são considerados inferidos, exceto entidades e matrizes de entidades.
## Exemplos de campos de esquema para pesquisa de mídia
| | | | | |
| --- |--- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo | Granularity |
| key-visual-objects | Please detect all the visually prominent objects in the video | extractive | Array of entities | [ "chapter" ] |
| keywords | Searchable terms that capture key themes, cast, plot elements, and notable aspects of TV shows and movies to enhance content discovery. | inferred | Array of strings | ["video"] |
| genre | The genre of the content. | inferred | string | ["video"] |
| video-type | Identify the type of video content | inferred | enums: ["Movie", "TV series", "News", "Others"] | [ "video" ] |
## Exemplos de campos de esquema para destaques de palestra principal
| | | | | |
| --- |--- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo | Granularity |
| broadcast-setting | The physical setting or environment where the broadcast or training session is taking place. | inferred | enums["conference hall", "classroom", "outdoor venue", "Others", "Not applicable to the video"] | [ "video" ] |
| broadcast-audience-engagement | The level of engagement or interaction between the speakers and the audience. | inferred | enums["interactive", "passive", "Not applicable to the video"] | ["video"] |
| broadcast-visual-aids | A list of notable visual aids or materials used during the presentation, such as slides, diagrams, or demonstrations. | inferred | Array of strings | ["video"] |
| broadcast-audience-size | The size of the audience present at the event. | inferred | enums["large crowd", "medium crowd", "small group", "Not applicable to this video"] | [ "chapter" ] |
| broadcast-presentation-topics | A list of key topics, subjects, or themes covered in the presentation or training session. | inferred | enums: ["Movie", "TV series", "News", "Others"] | [ "video" ] |
## Exemplos de campos de esquema para análise de anúncios
| | | | | |
| --- |--- |--- |--- |--- |
| Campo | Instrução | Tipo de extração | Tipo | Granularity |
| ads-video-ad-categories | The ad categories for the video | inferred | enums["Health and Beauty", "Weight Loss", "Food and Beverage", "Restaurants", "Political", "Cryptocurrencies and NFT", "Money Lending and Finance", "Tobacco", "Other", "Video is not an advertisement"] | [ "video" ] |
| ads-video-language | The primary language of the advertisement | inferred | string | ["video"] |
| ads-video-primary-brand | The main brand or company being advertised in the video. | inferred | string | ["video"] |
| ads-video-main-message | The primary message or tagline conveyed in the advertisement | inferred | string | [ "video" ] |
| ads-video-message-clarity | How clear and understandable the main message of the advertisement is | inferred | enums: ["clear", "ambiguous", "Not applicable to the video"] | [ "video" ] |
| ads-video-target-audience-interests | Specific interests or hobbies that the target audience is likely to have | inferred | Array of strings | [ "video" ] |
| ads-video-product-type | The category or type of product being advertised | inferred | enums: ["electronics", "apparel", "food\$1and\$1beverage", "automotive", "home\$1appliances", "other", "Not applicable to the video"] | [ "video" ] |
| ads-video-product-placement | The way the product is positioned or showcased in the advertisement | inferred | enums: ["front\$1and\$1center", "background", "held\$1by\$1person", "other", "Not applicable to the video"] | [ "video" ] |
| ads-video-product-features | The key features or specifications of the advertised product highlighted in the video | inferred | Array of strings | [ "video" ] |
| ads-video-number-of-products | The number of distinct products or variations featured in the advertisement | inferred | number | [ "video" ] |
O vídeo também permite uma variedade de tipos de entidade, o que ajuda a identificar e localizar entidades específicas no conteúdo do vídeo. Esse recurso exibe uma matriz de entidades detectadas. Abaixo é apresentado um exemplo de uma matriz de entidades no esquema de um cliente:
```
"field_name": {
"items": {
"$ref": "bedrock-data-automation#/definitions/Entity"
},
"type": "array",
"instruction": "Please detect all the visually prominent objects in the video",
"granularity": [
"chapter"
]
}
```
**nota**
`bedrock-data-automation#/definitions/Entity` é um tipo de serviço pertencente à BDA. Para analisar os resultados, use o esquema a seguir.
```
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "bedrock-data-automation",
"type": "object",
"definitions": {
"BoundingBox": {
"type": "object",
"additionalProperties": false,
"properties": {
"left": {
"type": "number"
},
"top": {
"type": "number"
},
"width": {
"type": "number"
},
"height": {
"type": "number"
}
}
},
"Entity": {
"type": "object",
"additionalProperties": false,
"properties": {
"label": {
"type": "string"
},
"bounding_box": {
"$ref": "bedrock-data-automation#/definitions/BoundingBox"
},
"confidence": {
"type": "number"
}
}
}
},
"properties": {}
}
```
# Otimize seus projetos com a verdade fundamental
Você pode melhorar a precisão do blueprint fornecendo exemplos de ativos de conteúdo com os resultados corretos esperados. **A otimização de instruções do Blueprint usa seus exemplos para refinar as instruções em linguagem natural nos campos do blueprint, o que melhora a precisão dos resultados da inferência.**
A otimização de instruções do Blueprint funciona melhor quando você precisa extrair valores específicos que aparecem diretamente em seus documentos, como números de faturas, valores de contratos ou campos de formulários fiscais. Recomendamos fornecer de 3 a 10 exemplos de ativos que representem os documentos que você processa na produção, especialmente aqueles em que você encontrou desafios de precisão.
**Como funciona a otimização de instruções do blueprint**
A otimização de instruções do Blueprint analisa as diferenças entre os resultados esperados e os resultados iniciais da inferência. O serviço refina iterativamente as instruções em linguagem natural para cada campo do seu plano até que as instruções produzam resultados mais precisos em seus ativos de exemplo. Esse processo é concluído em minutos, sem exigir nenhum treinamento ou ajuste fino do modelo.
Ao iniciar o processo de otimização, você fornece seus recursos de exemplo e os dados reais fundamentais correspondentes — os valores corretos que você espera extrair para cada campo. A otimização de instruções do Blueprint compara esses valores com os resultados da inferência e ajusta as descrições dos campos para melhorar a precisão. Após a conclusão da otimização, você recebe métricas de precisão que mostram a melhoria da precisão, incluindo taxas de correspondência exatas e pontuações de F1 medidas em relação à sua verdade básica.
**O que você precisa antes de começar a otimizar seus projetos**
**Um plano com campos definidos**. Crie um blueprint usando o console ou a API. Seu blueprint deve incluir os nomes dos campos e as descrições iniciais dos dados que você deseja extrair.
**Exemplo de ativos de conteúdo**. Reúna de 3 a 10 ativos de documentos que representem sua carga de trabalho de produção em documentos. Escolha exemplos que contenham todos os campos em seu blueprint.
**Resultados esperados para seus exemplos**. Prepare os valores corretos que você deseja extrair de cada ativo de exemplo. Você pode inserir esses valores manualmente durante a otimização ou carregá-los usando um arquivo de manifesto.
**Uma localização do bucket S3**. Especifique um bucket do S3 onde você deseja armazenar seus ativos de exemplo e dados reais fundamentais. Você pode fornecer seu próprio bucket ou permitir que o serviço crie um para você.
**Step-by-step processo para otimizar seu plano**
Para otimizar seu blueprint, comece na página de detalhes do blueprint no console Amazon Bedrock Data Automation. Observe que isso só está disponível para sua modalidade de documento.
Etapa 1. Selecione **Otimizar blueprint** para iniciar o fluxo de trabalho de otimização.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-blueprint-optimize-button.png)
Etapa 2. **Faça upload de seus recursos de exemplo**. Escolha até 10 ativos de conteúdo do seu dispositivo local ou de um local do S3. O serviço carrega seus ativos e exibe miniaturas de cada arquivo. Se você otimizou esse blueprint anteriormente, poderá adicionar novos exemplos ou remover os existentes.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-optimize-files-selector.png)
Etapa 3. **Forneça a verdade básica para cada ativo**. Selecione um ativo para abrir o editor Ground Truth. O editor exibe a visualização prévia do documento à esquerda e uma tabela simplificada dos campos do blueprint à direita. Para cada campo, insira o valor correto que você espera extrair na coluna Ground Truth.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-optimize-files-ground-truth.png)
Etapa 4: ****Para acelerar a entrada da verdade fundamental, selecione **Preenchimento automático** para executar a inferência inicial em seus ativos e preencher automaticamente a coluna Verdade Fundamental a partir dos valores em sua coluna Resultados.**** Edite todos os valores incorretos antes de continuar.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-optimize-ground-truth-edit.png)
Etapa 5. **Inicie a otimização**. Depois de concluir a entrada da verdade básica para todos os ativos selecionados, escolha **Iniciar otimização**. A automação de dados analisa seus exemplos e refina as instruções em linguagem natural para cada campo. Um indicador de progresso mostra o status da otimização com mensagens como “Lendo seus ativos” e “Iterando as instruções em linguagem natural do esquema”.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-start-optimization-button.png)
Etapa 6. **Analise as métricas de avaliação**. Quando a otimização for concluída, a seção **Métricas** exibirá métricas de precisão para seu blueprint. As métricas comparam o desempenho antes e depois da otimização. Analise a pontuação geral da F1, a pontuação de confiança e a taxa de correspondência exata para avaliar se o plano atende aos seus requisitos de precisão.
A guia **Métricas por arquivo de amostra** mostra a precisão em nível de campo para cada ativo de exemplo. Use essas métricas para identificar quais campos melhoraram e quais campos podem precisar de exemplos adicionais ou refinamento manual.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/bda-optimize-metrics.png)
Etapa 7. **Otimização completa**. Se as métricas de avaliação atenderem aos seus requisitos, selecione **Salvar plano otimizado** para promover o plano otimizado para produção. Seu blueprint agora usa as instruções refinadas de linguagem natural para todas as futuras solicitações de inferência.
**Reotimize seu plano**
Você pode reotimizar um plano a qualquer momento para melhorar ainda mais a precisão. Volte para a página de detalhes do blueprint e selecione **Otimizar blueprint**. O serviço exibe os ativos que você usou anteriormente para otimização, juntamente com seus valores reais básicos.
Para reotimizar, você pode adicionar novos exemplos de ativos, editar valores reais básicos para ativos existentes ou remover ativos que não representam mais sua carga de trabalho. Quando você **seleciona Iniciar otimização**, a otimização da instrução do blueprint é calculada em relação às suas instruções atuais do blueprint versus às novas instruções.
**Editar um blueprint após a otimização**
Se você adicionar ou remover campos de um blueprint otimizado, o serviço removerá o histórico de otimização e os exemplos de ativos associados. Antes de editar, baixe o arquivo de manifesto que contém a localização dos ativos e os rótulos de verdade básica. O arquivo de manifesto usa o formato JSON e inclui todos os campos e valores reais básicos de sua otimização anterior. Para preservar seu trabalho de otimização, faça o upload do arquivo de manifesto ao reotimizar o blueprint editado. A automação de dados aplica automaticamente valores reais básicos aos campos correspondentes. Os campos que não existem mais no blueprint são removidos do manifesto. Novos campos não têm valores reais básicos até que você os forneça.
**Gerencie os custos de otimização**
A otimização de instruções do Blueprint consome incorre nos custos de inferência da mesma forma que você faria se editasse manualmente suas instruções em linguagem natural e as testasse iterativamente em cada documento de amostra. Para um cálculo aproximado, o número de páginas que você fornecer como exemplos será o número de páginas que serão cobradas à medida que você otimiza seu plano. Cada execução de otimização processa seus ativos de exemplo várias vezes para refinar as instruções. Para minimizar os custos, comece com 3 a 5 exemplos para sua otimização inicial. Adicione mais exemplos ao inspecionar as métricas de avaliação e achar que precisa de melhorias adicionais na precisão.
Além disso, as instruções otimizadas em linguagem natural tendem a ser mais longas e detalhadas do que as instruções originais, o que pode aumentar os custos de inferência em tempo de execução.
# Usar o console da Automação de Dados da Bedrock
Na Automação de Dados do Amazon Bedrock (BDA), dois artefatos principais são usados ao processar informações. Projetos, que armazenam configurações de saída, e esquemas, que permitem personalizar o formato de saída e a lógica de extração de conteúdo não estruturado.
Esta seção aborda a criação de projetos e esquemas no console da BDA. Para ter mais informações sobre como os projetos funcionam na BDA, consulte [Projetos da Automação de Dados do Bedrock](bda-projects.md). Para saber mais sobre esquemas na BDA, consulte [Como criar esquemas para saídas personalizadas](bda-idp.md#how-to-create-blueprints).
## Projetos no console da BDA
No console da BDA, é possível criar e gerenciar projetos. Os projetos permitem controlar quais saídas padrão são recuperadas ao executar uma operação de inferência e como as saídas personalizadas são tratadas durante a inferência.
Para criar um projeto:
1. Navegue até o serviço Amazon Bedrock. Ali, selecione “Automação de dados” no menu da barra lateral.
1. Selecione “Criar projeto”.
1. Dê um nome ao projeto e selecione “Criar projeto” novamente.
1. Isso levará você à página “Detalhes do projeto”, na qual você poderá ver quais saídas padrão estão habilitadas pelo seu projeto. Em seguida, você pode controlar as saídas personalizadas selecionando a guia “Saída personalizada” e escolhendo a opção “Criar esquema”. Além disso, você pode adicionar um esquema existente ao projeto.
## Criar esquemas no console da BDA
Também é possível selecionar “Automação de dados” no menu da barra lateral e navegar diretamente até “Configuração de saída personalizada”. No painel da BDA, localize e clique na guia “Configuração de saída personalizada”. Isso levará você à página de “Gerenciamento de esquemas”.
## Começar a criar um esquema
1. Clique no botão “Criar esquema” para iniciar o processo de criação de um esquema.
1. Selecione “Fazer upload do computador” ou “Importar do S3" e forneça um arquivo representativo dos arquivos que você deseja processar.
1. Insira um prompt de esquema para gerar um esquema. Ao inserir um prompt, você pode especificar quaisquer campos que você espera encontrar no documento carregado. Também é possível especificar normalizações ou validações de dados.
1. Selecione “Gerar esquema”.
1. Dê um nome ao esquema e escolha “Criar esquema”.
1. Na seção “Esquemas personalizados”, selecione o botão “Criar esquema”.
1. Seu esquema será criado e você poderá ver as extrações que foram identificadas com base no prompt fornecido.
## Visualizar uma apresentação prévia do esquema
Use o recurso de apresentação prévia para testar o esquema com dados de exemplo. Isso permite verificar se a extração e a formatação estão funcionando conforme o esperado.
Selecione “Salvar e sair do prompt do esquema” para salvar o esquema como um recurso.
## Gerenciar esquemas
Após a criação, você pode gerenciar os esquemas no painel “Esquemas”. Entre as opções estão:
+ Editar esquemas existentes
+ Duplicar esquemas
+ Excluir esquemas
+ Visualizar o histórico de versões de esquema
Também é possível adicionar um esquema a um projeto selecionando o menu suspenso “Adicionar ao projeto” e escolhendo um projeto que você criou.
## Usar seu esquema
Depois de criado, você pode usar o esquema em projetos na BDA ou diretamente em chamadas de API para processar conteúdo não estruturado. Para usar um esquema:
+ Ao fazer chamadas de API, inclua o ARN do esquema nos parâmetros da solicitação. Para ter mais informações, consulte a seção sobre como chamar a API.
+ Ao fazer uma chamada de API, inclua o ARN do projeto que contém o esquema. Para ter mais informações, consulte a seção sobre como chamar a API.
## Processar documentos com o console
O console da BDA também permite que você teste e visualize facilmente os insights que a BDA pode extrair de conteúdo não estruturado. Esses testes só podem ser executados em um documento por vez. Para processar vários documentos, consulte a seção sobre como usar a API. Você pode fazer upload de arquivos de exemplo de documentos, imagens, vídeos ou áudio, e o console exibirá os insights padrão que a BDA pode gerar, bem como a opção de aplicar qualquer esquema personalizado que você tenha criado.
É possível testar um esquema criado e aplicado a um projeto acessando a seção “Projetos” da Automação de Dados e selecionando um projeto.
Quando estiver na página de detalhes do projeto, selecione “Testar”. Na página “Testar”, você poderá selecionar um arquivo e optar por processá-lo com a saída padrão ou com um esquema criado por você.
# Usar a API da Automação de Dados do Bedrock
O recurso Amazon Bedrock Data Automation (BDA) fornece um fluxo de trabalho de API simplificado para processar seus dados. Para todas as modalidades, esse fluxo de trabalho consiste em três etapas principais: criar um projeto, invocar a análise e recuperar os resultados. Para recuperar a saída personalizada para seus dados processados, forneça o ARN do esquema ao invocar a operação de análise.
## Criar um projeto de automação de dados
Para começar a processar arquivos com a BDA, primeiro é necessário criar um projeto de automação de dados. Isso pode ser feito de duas maneiras, com a CreateDataAutomationProject operação ou com o Amazon Amazon Bedrock Console.
### Usar a API
Ao usar a API para criar um projeto, você invoca o. CreateDataAutomationProject Ao criar um projeto, é necessário definir as configurações para o tipo de arquivo que você tende a processar (a modalidade que pretende usar). Veja um exemplo de como é possível configurar a saída padrão para imagens:
```
{
"standardOutputConfiguration": {
"image": {
"state": "ENABLED",
"extraction": {
"category": {
"state": "ENABLED",
"types": [
"CONTENT_MODERATION",
"TEXT_DETECTION"
]
},
"boundingBox": {
"state": "ENABLED"
}
},
"generativeField": {
"state": "ENABLED",
"types": [
"IMAGE_SUMMARY",
"IAB"
]
}
}
}
}
```
A API valida a configuração de entrada. Ela cria um projeto com um ARN exclusivo. As configurações do projeto são armazenadas para uso futuro. Se um projeto for criado sem parâmetros, serão aplicadas as configurações padrão. Por exemplo, ao processar imagens, o resumo de imagens e a detecção de texto serão habilitados por padrão.
Há um limite para o número de projetos que podem ser criados por AWS conta. Determinadas combinações de configurações podem não ser permitidas ou exigir permissões adicionais.
------
#### [ Async ]
**Invoque a automação de dados assíncrona**
Você tem um projeto configurado, pode começar a processar imagens usando a [InvokeDataAutomationAsync](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomationAsync.html)operação. Se estiver usando a saída personalizada, só poderá enviar um único ARN do esquema por solicitação.
Essa chamada de API inicia o processamento assíncrono dos arquivos em um bucket especificado do S3. A API aceita o ARN do projeto e o arquivo a ser processado e, em seguida, inicia o trabalho de processamento assíncrono. Um ID do trabalho é exibido para rastrear o processo. Serão gerados erros se o projeto não existir, se o chamador não tiver as permissões necessárias ou se os arquivos de entrada não estiverem em um formato compatível.
Abaixo é apresentada a estrutura da solicitação JSON:
```
{
{
"blueprints": [
{
"blueprintArn": "string",
"stage": "string",
"version": "string"
}
],
"clientToken": "string",
"dataAutomationConfiguration": {
"dataAutomationProjectArn": "string",
"stage": "string"
},
"dataAutomationProfileArn": "string",
"encryptionConfiguration": {
"kmsEncryptionContext": {
"string" : "string"
},
"kmsKeyId": "string"
},
"inputConfiguration": {
"assetProcessingConfiguration": {
"video": {
"segmentConfiguration": { ... }
}
"s3Uri": "string"
},
"notificationConfiguration": {
"eventBridgeConfiguration": {
"eventBridgeEnabled": boolean
}
},
"outputConfiguration": {
"s3Uri": "string"
},
"tags": [
{
"key": "sstring",
"value": "string"
}
]
}
}
```
Ao executar `InvokeDataAutomationAsync` em um arquivo de vídeo, é possível definir uma seção de 5 minutos ou mais de um vídeo que será tratada como um vídeo completo para a extração de dados. Esse tempo é definido com um carimbo de data/hora do milissegundo inicial e do milissegundo final. Essas informações são adicionadas ao elemento `assetProcessingConfiguration`.
------
#### [ Sync ]
**Invoque a automação de dados**
Como alternativa, você pode usar a [InvokeDataAutomation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_data-automation-runtime_InvokeDataAutomation.html)operação. A `InvokeDataAutomation` operação só oferece suporte ao processamento de imagens.
Essa chamada de API inicia o processamento síncrono do fornecido por meio de uma referência do S3 ou na carga útil. A API aceita o ARN do projeto e o arquivo a ser processado e retorna os insights estruturados na resposta. Serão gerados erros se o projeto não existir, se o chamador não tiver as permissões necessárias ou se os arquivos de entrada não estiverem em um formato compatível. Se a imagem analisada for classificada semanticamente como um documento, isso também será gerado como um erro, pois a InvokeDataAutomation única suporta imagens. Para evitar esse erro, você pode usar o Roteamento de Modalidade em seu projeto para forçar o roteamento de todos os tipos de arquivos de imagem como Imagens (consulte). [Desabilitar modalidades e tipos de arquivo de roteamento](bda-routing-enablement.md)
Aqui está a estrutura da solicitação JSON para imagem e documento. A solicitação da API de sincronização é compatível com bytes de imagem e bucket do S3. Para usar bytes de imagem, basta substituir `“s3Uri”: “string”` na seção “InputConfiguration” por `“bytes“: “base64-encoded string“` `outputConfiguration` é opcional e o padrão é a saída embutida. Se o uri do S3 for fornecido como OutputConfiguration, a saída criptografada será colocada no bucket do S3 especificado.
```
{
{
"blueprints": [
{
"blueprintArn": "string", //use for image
"stage": "string",
"version": "string"
}
],
"dataAutomationConfiguration": {
"dataAutomationProjectArn": "string",
"stage": "string"
},
"dataAutomationProfileArn": "string",
"inputConfiguration": {
"s3Uri": "string"
},
"outputConfiguration": {
"s3Uri": "string"
}
}
}
```
A saída inclui estruturas exclusivas, dependendo do arquivo, das operações e da configuração de saída personalizada especificadas na chamada para InvokeDataAutomation. Observe que essa resposta inclui as respostas de saída padrão e personalizadas.
------
Aqui está a estrutura da resposta JSON com configuração de saída padrão e personalizada:
```
{
"semanticModality": "IMAGE",
"outputSegments": [
{
"customOutputStatus": "MATCH",
"standardOutput": {
"image": {
"summary": "This image shows a white Nike running shoe with a black Nike swoosh logo on the side. The shoe has a modern design with a thick, cushioned sole and a sleek upper part. The word \"ROUKEA\" is visible on the sole of the shoe, repeated twice. The shoe appears to be designed for comfort and performance, suitable for running or athletic activities. The background is plain and dark, highlighting the shoe.",
"iab_categories": [
{
"category": "Style and Fashion",
"confidence": 0.9890000000000001,
"taxonomy_level": 1,
"parent_name": "",
"id": "0ebe86c8-e9af-43f6-a7bb-182a61d2e1fd",
"type": "IAB"
},
{
"category": "Men's Fashion",
"confidence": 0.9890000000000001,
"taxonomy_level": 2,
"parent_name": "Style and Fashion",
"id": "13bd456a-3e1b-4681-b0dd-f42a8d5e5ad5",
"type": "IAB"
},
{
"category": "Style and Fashion",
"confidence": 0.853,
"taxonomy_level": 1,
"parent_name": "",
"id": "177b29a1-0e40-45c1-8540-5f49a3d7ded3",
"type": "IAB"
},
{
"category": "Women's Fashion",
"confidence": 0.853,
"taxonomy_level": 2,
"parent_name": "Style and Fashion",
"id": "f0197ede-3ba6-498b-8f7b-43fecc5735ef",
"type": "IAB"
}
],
"content_moderation": [],
"logos": [
{
"id": "2e109eb6-39f5-4782-826f-911b62d277fb",
"type": "LOGOS",
"confidence": 0.9170872209665809,
"name": "nike",
"locations": [
{
"bounding_box": {
"left": 0.3977411523719743,
"top": 0.4922481227565456,
"width": 0.2574246356942061,
"height": 0.15461772197001689
}
}
]
}
],
"text_words": [
{
"id": "f70301df-5725-405e-b50c-612e352467bf",
"type": "TEXT_WORD",
"confidence": 0.10091366487951722,
"text": "ROUKEA",
"locations": [
{
"bounding_box": {
"left": 0.6486002310163024,
"top": 0.6783271480251003,
"width": 0.13219473954570082,
"height": 0.05802226710963898
},
"polygon": [
{
"x": 0.6486002310163024,
"y": 0.7025876947351404
},
{
"x": 0.7760931467045249,
"y": 0.6783271480251003
},
{
"x": 0.7807949705620032,
"y": 0.7120888684246991
},
{
"x": 0.6533020989743271,
"y": 0.7363494151347393
}
]
}
],
"line_id": "9147fec0-d869-4d58-933e-93eb7164c404"
}
],
"text_lines": [
{
"id": "9147fec0-d869-4d58-933e-93eb7164c404",
"type": "TEXT_LINE",
"confidence": 0.10091366487951722,
"text": "ROUKEA",
"locations": [
{
"bounding_box": {
"left": 0.6486002310163024,
"top": 0.6783271480251003,
"width": 0.13219473954570082,
"height": 0.05802226710963898
},
"polygon": [
{
"x": 0.6486002310163024,
"y": 0.7025876947351404
},
{
"x": 0.7760931467045249,
"y": 0.6783271480251003
},
{
"x": 0.7807949705620032,
"y": 0.7120888684246991
},
{
"x": 0.6533020989743271,
"y": 0.7363494151347393
}
]
}
]
}
]
},
"statistics": {
"iab_category_count": 4,
"content_moderation_count": 0,
"logo_count": 1,
"line_count": 1,
"word_count": 1
},
"metadata": {
"semantic_modality": "IMAGE",
"image_width_pixels": 173,
"image_height_pixels": 148,
"image_encoding": "jpeg",
"s3_bucket": "test-bucket",
"s3_key": "uploads/test-image.jpeg"
}
},
"customOutput": {
"matched_blueprint": {
"arn": "arn:aws:bedrock:us-east-1:123456789012:blueprint/test",
"version": "1",
"name": "test-blueprint",
"confidence": 1.0
},
"inference_result": {
"product_details": {
"product_category": "footwear"
},
"image_sentiment": "Positive",
"image_background": "Solid color",
"image_style": "Product image",
"image_humor": false
}
}
}
]
}
```
## Obter o status da automação de dados
Para verificar o status do seu trabalho de processamento e recuperar os resultados, use GetDataAutomationStatus.
A GetDataAutomationStatus API permite que você monitore o progresso do seu trabalho e acesse os resultados após a conclusão do processamento. A API aceita o ARN de invocação retornado por. InvokeDataAutomationAsync Ela verifica o status atual do trabalho e exibe informações relevantes. Depois que o trabalho é concluído, ela fornece o local dos resultados no S3.
Se o trabalho ainda estiver em andamento, ele retornará o estado atual (por exemplo, "InProgress“). Se o trabalho for concluído, ela exibirá “Success” com o local dos resultados no S3. Se houver um erro, ele retornará "ServiceError" ou "ClientError" com detalhes do erro.
Abaixo é apresentado o formato da solicitação JSON:
```
{
"InvocationArn": "string" // Arn
}
```
## Resposta de saída assíncrona
Os resultados do processamento do arquivo são armazenados no bucket do S3 configurado para as imagens de entrada. A saída inclui estruturas exclusivas, dependendo da modalidade do arquivo e dos tipos de operação especificados na chamada para InvokeDataAutomationAsync.
Para ter informações sobre as saídas padrão para uma determinada modalidade, consulte [Saída padrão na Automação de Dados do Bedrock](bda-standard-output.md).
Como exemplo, para imagens, ela pode incluir informações sobre o seguinte:
+ Resumo da imagem: um resumo descritivo ou legenda da imagem.
+ Classificação do IAB: categorização baseada na taxonomia do IAB.
+ Detecção de texto de imagem: texto extraído com informações da caixa delimitadora.
+ Moderação de conteúdo: detecta conteúdo impróprio, indesejado ou ofensivo em uma imagem.
Veja abaixo um trecho de exemplo de saída para processamento de imagem:
```
{
"metadata": {
"id": "image_123",
"semantic_modality": "IMAGE",
"s3_bucket": "my-s3-bucket",
"s3_prefix": "images/",
"image_width_pixels": 1920,
"image_height_pixels": 1080
},
"image": {
"summary": "A lively party scene with colorful decorations and supplies",
"iab_categories": [
{
"category": "Party Supplies",
"confidence": 0.9,
"parent_name": "Events & Attractions"
}
],
"content_moderation": [
{
"category": "Drugs & Tobacco Paraphernalia & Use",
"confidence": 0.7
}
],
"text_words": [
{
"id": "word_1",
"text": "lively",
"confidence": 0.9,
"line_id": "line_1",
"locations": [
{
"bounding_box": {
"left": 100,
"top": 200,
"width": 50,
"height": 20
},
"polygon": [
{
"x": 100,
"y": 200
},
{
"x": 150,
"y": 200
},
{
"x": 150,
"y": 220
},
{
"x": 100,
"y": 220
}
]
}
]
}
]
}
}
```
Essa saída estruturada permite fácil integração com aplicações subsequentes e análises adicionais.
## Otimização do blueprint APIs
### InvokeBlueprintOptimizationAsync
Você pode melhorar a precisão do blueprint fornecendo exemplos de ativos de conteúdo com os resultados corretos esperados. *A otimização de instruções do Blueprint usa seus exemplos para refinar as instruções em linguagem natural nos campos do blueprint, o que melhora a precisão dos resultados da inferência.*
Para um blueprint, você pode chamar a InvokeBlueprintOptimizationAsync API que inicia o trabalho de otimização assíncrona para melhorar as instruções de campo do Blueprint com base em dados reais básicos.
**Corpo da Solicitação**
```
{
"blueprint": {
"blueprintArn": "arn:aws:bedrock:us-east-1:123456789012:blueprint/my-document-processor",
"stage": "DEVELOPMENT"
},
"samples": [
{
"assetS3Object": {
"s3Uri": "s3://my-optimization-bucket/samples/document1.pdf"
},
"groundTruthS3Object": {
"s3Uri": "s3://my-optimization-bucket/ground-truth/document1-expected.json"
}
}
],
"outputConfiguration": {
"s3Object": {
"s3Uri": "s3://my-optimization-bucket/results/optimization-output"
}
},
"dataAutomationProfileArn": "arn:aws:bedrock:us-east-1:123456789012:data-automation-profile/my-profile"
}
```
**Resposta**
```
{
"invocationArn": "arn:aws:bedrock:us-east-1:123456789012:blueprint-optimization-invocation/opt-12345abcdef"
}
```
**Importante**
Salve o InvocationARN para monitorar o status do trabalho de otimização.
### GetBlueprintOptimizationStatus
Recupera o status atual e os resultados de um trabalho de otimização de blueprint gerado chamando a API assíncrona. InvokeBlueprintOptimizationAsync GetBlueprintOptimizationStatus aceita o ARN de invocação retornado por. InvokeBlueprintOptimizationAsync
**Resposta**
```
{
"status": "Success",
"outputConfiguration": {
"s3Object": {
"s3Uri": "s3://my-optimization-bucket/results/optimization-output"
}
}
}
```
**Valores do status:**
+ Criado - O trabalho foi criado
+ InProgress - A otimização está em execução
+ Sucesso - Otimização concluída com sucesso
+ ServiceError - Ocorreu um erro de serviço interno
+ ClientError - Parâmetros de solicitação inválidos
### CopyBlueprintStage
Copia o Blueprint do estágio de origem para o estágio de destino (por exemplo. (estágio de DESENVOLVIMENTO até estágio AO VIVO). Isso será usado para sincronizar toda a configuração, incluindo o campo OptimizationSamples, entre os estágios.
**Corpo da Solicitação**
```
{
"blueprintArn": "arn:aws:bedrock:us-east-1:123456789012:blueprint/my-document-processor",
"sourceStage": "DEVELOPMENT",
"targetStage": "LIVE"
}
```
**Valores do estágio:**
+ DESENVOLVIMENTO - Development/testing estágio
+ LIVE - Etapa de produção
**Resposta**
```
{}
```
**Atenção**
Essa operação substitui a configuração do estágio de destino e não pode ser facilmente desfeita. Garanta testes completos antes de copiar para o palco AO VIVO.
# Marcar inferências e recursos na Automação de Dados do Bedrock
Para ajudar a gerenciar recursos e inferências da BDA, é possível atribuir metadados a ambos como tags. Tag é um rótulo que você atribui a um recurso da AWS, como um projeto ou um esquema. Cada tag consiste em uma chave e um valor.
A marcação de recursos permite categorizar os recursos da AWS de diferentes formas, por exemplo, por finalidade, por proprietário ou por aplicação. A marcação de inferências funciona de uma forma um pouco diferente. Esse tipo de marcação permite categorizar não apenas projetos ou esquemas, mas chamadas específicas da API da BDA. Para obter mais informações, consulte Marcar AWS recursos.
Além da categorização, você pode usar tags de inferência para ver as alocações de custos a cada mês. Para ter mais informações, consulte “Usar tags de alocação de custos” no “Guia do usuário do Gerenciamento de Faturamento e Custos da AWS”.
As tags ajudam você a fazer o seguinte:
+ Identificar e organizar seus recursos da AWS. Muitos recursos da AWS oferecem suporte à marcação, portanto, é possível atribuir a mesma tag a recursos em diferentes serviços para indicar que os recursos são iguais.
+ Controle o acesso aos seus recursos. É possível usar tags com o Amazon Bedrock para criar políticas para controlar o acesso aos recursos do Amazon Bedrock. Essas políticas podem ser anexadas a um perfil ou a um usuário do IAM para habilitar o controle de acesso baseado em tags.
+ Alocar custos. É possível ativar as tags no painel do Gerenciamento de Faturamento e Custos da AWS. A AWS usa as tags para categorizar seus custos e entregar um relatório mensal de alocação de custos para você. Utilizável somente com marcação de inferência.
Para ter mais informações sobre a marcação de recursos e inferências para saber, por exemplo, como usar as operações de marcação de API, consulte [Marcação de recursos do Amazon Bedrock](tagging.md).
# Pré-requisitos para usar a Automação de Dados do Bedrock
Os arquivos para a BDA precisam atender a determinados requisitos para serem processados. As tabelas a seguir mostram quais são esses requisitos para diferentes tipos de arquivo.
------
#### [ Async ]
**Requisitos de arquivo de documento assíncrono**
As tabelas a seguir mostram os requisitos para arquivos processados usando a API Invoke Data Automation Async.
**Requisitos de arquivo de documentos**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| (Console) Número máximo de páginas por arquivo de documento | 20 |
| Número máximo de páginas por documento enquanto o divisor está habilitado | 3000 |
| (Console) Tamanho máximo do arquivo (MB) | 200 |
| Tamanho máximo do arquivo (MB) | 500 |
| Formatos de arquivo compatíveis | PDF, TIFF, JPEG, PNG, DOCX |
| Limites específicos de PDF | A altura e a largura máximas são de 40 polegadas e 9000 pontos. PDFs não pode ser protegido por senha. PDFs pode conter imagens formatadas em JPEG 2000. |
| Rotação do documento e tamanho da imagem | A BDA permite todas as rotações de documento no plano; por exemplo, rotação no plano de 45 graus. A BDA permite imagens com resolução menor ou igual a 10.000 pixels em todos os lados. |
| Alinhamento de texto | O texto pode ser alinhado horizontalmente dentro do documento. O texto disposto horizontalmente pode ser lido de modo independente do grau de rotação de um documento. A BDA não permite o alinhamento vertical de texto no documento (texto escrito verticalmente, como é comum em idiomas como japonês e chinês). |
| Tamanho do caractere | A altura mínima para que o texto seja detectado é 15 pixels. Com 150 DPI, isso seria o mesmo que uma fonte de 8 pontos. |
| Tipos de caractere | A BDA permite reconhecimento de caracteres manuscritos e impressos. |
**nota**
Para processar arquivos DOCX, eles são convertidos em PDFs. Isso significa que o mapeamento do número da página não funcionará para arquivos DOCX. As imagens do convertido PDFs serão enviadas para seu bucket de saída se a opção JSON\$1 e a granularidade da página forem selecionadas.
A otimização de instruções do Blueprint suporta todos os limites acima para documentos com as seguintes diferenças:
+ Um total de 10 exemplos de ativos de documentos
+ Exemplo de 20 páginas por ativo de documento no console e na API
+ Exemplo de 200 MB para o ativo total do documento
+ Somente formatos de arquivo de documento PDF, DOCX e TIFF
------
#### [ Sync ]
**Requisitos de sincronização de arquivos de documentos**
As tabelas a seguir mostram os requisitos para arquivos processados usando a API Invoke Data Automation.
**Requisitos de arquivo de documentos**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| (Console) Número máximo de páginas por arquivo de documento | 10 |
| Número máximo de páginas por arquivo de documento (o divisor não está disponível) | 10 |
| (Console) Tamanho máximo do arquivo (MB) | 50 |
| Tamanho máximo do arquivo (MB) | 50 |
| Formatos de arquivo compatíveis | PDF, TIFF, JPEG, PNG |
| Limites específicos de PDF | A altura e a largura máximas são de 40 polegadas e 9000 pontos. PDFs não pode ser protegido por senha. PDFs pode conter imagens formatadas em JPEG 2000. |
| Rotação do documento e tamanho da imagem | A BDA permite todas as rotações de documento no plano; por exemplo, rotação no plano de 45 graus. A BDA permite imagens com resolução menor ou igual a 10.000 pixels em todos os lados. |
| Alinhamento de texto | O texto pode ser alinhado horizontalmente dentro do documento. O texto disposto horizontalmente pode ser lido de modo independente do grau de rotação de um documento. A BDA não permite o alinhamento vertical de texto no documento (texto escrito verticalmente, como é comum em idiomas como japonês e chinês). |
| Tamanho do caractere | A altura mínima para que o texto seja detectado é 15 pixels. Com 150 DPI, isso seria o mesmo que uma fonte de 8 pontos. |
| Tipos de caractere | A BDA permite reconhecimento de caracteres manuscritos e impressos. |
**nota**
A legenda de figuras funciona em 20 imagens por documento de 10 páginas (sincronizado) e 20 imagens por página (assíncrono).
**dica**
Dicas para acelerar o processamento da API de sincronização:
Desative os campos generativos, a menos que seja absolutamente necessário.
Selecione somente a granularidade e o formato de texto de saída necessários (em vez de selecionar vários).
Simplifique seu Blueprint para reduzir o máximo possível o número de campos extraídos.
Reduza o número de campos de tabela e lista em seu blueprint sempre que possível.
------
**Requisitos do Blueprint**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| Número máximo de plantas por projeto | 40 |
| Número máximo de projetos por conta | 100 |
| Número máximo de plantas por conta | 1000 |
| Número máximo de versões do blueprint | 100 |
| Número máximo de campos de folha do blueprint | 100 |
| Número máximo de campos de folha da lista de esquemas | 30 |
| Tamanho máximo do nome do blueprint | 60 caracteres |
| Tamanho máximo da descrição do campo do blueprint | 600 caracteres (documento), 500 caracteres (image/video/audio) |
| Tamanho máximo do nome do campo do blueprint | 60 caracteres |
| Tamanho máximo do blueprint | 100.000 caracteres (formatado em JSON) |
**Requisitos de arquivo de imagens**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| Tamanho máximo do arquivo (MB) | 5 |
| Resolução máxima | 8k |
| Formatos de arquivo compatíveis | JPEG, PNG |
**Requisitos de arquivo de vídeo**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| Tamanho máximo do arquivo (MB) | 10240 |
| Duração máxima do vídeo (minutos) | 240 |
| Formatos de arquivo compatíveis | MP4, formatos de contêiner MOV, AVI, MKV ou WEBM com codecs de vídeo visual H.264, H.265/HEVC,,, ou MPEG-4 VP8 VP9 AV1 |
| Máximo de esquemas de vídeo por projeto | 1 |
| Máximo de esquemas de vídeo por solicitação para iniciar referência | 1 |
| Resolução mínima | 224 |
| Resolução máxima | 7680 |
| Taxa de quadros mínima (quadros por segundo) | 1 |
| Taxa de quadros máxima (quadros por segundo) | 60 |
**Requisitos de arquivo de áudio**
| Descrição do requisito | Detalhes do requisito |
| --- | --- |
| Idiomas de entrada suportados | Inglês, Alemanha, espanhol, francês, italiano, português, japonês, coreano, chinês, taiwanês e cantonês. *\$1Todas as localidades são suportadas nos idiomas acima.* |
| Idiomas de saída suportados | Inglês, ou o idioma dominante do áudio. |
| Taxa mínima de amostragem de áudio (Hz) | 8000 |
| Taxa máxima de amostragem de áudio (Hz) | 48000 |
| Tamanho máximo do arquivo (MB) | 2048 |
| Duração máxima do áudio (minutos) | 240 |
| Duração mínima de áudio (milissegundos) | 500 |
| Formatos de arquivo compatíveis | AMR, FLAC, M4A, Ogg, MP3 WAV |
| Máximo de esquemas de áudio por projeto | 1 |
| Máximo de esquemas de áudio por solicitação para iniciar inferência | 1 |
| Máximo de canais de áudio para arquivos de áudio | 2 |
# Usando a CLI Amazon Bedrock de automação de dados
O recurso Amazon Bedrock Data Automation (BDA) fornece um fluxo de trabalho CLI simplificado para processar seus dados. Para todas as modalidades, esse fluxo de trabalho consiste em três etapas principais: criar um projeto, criar esquemas para saída personalizada e processar documentos. Este guia mostra os principais comandos da CLI para trabalhar com a BDA.
## Criar seu primeiro projeto de automação de dados
Para começar a trabalhar com a BDA, primeiro crie um projeto usando o comando `create-data-automation-project`.
Considere este exemplo de passaporte que processaremos:
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/passport2.png)
Ao criar um projeto, é necessário definir as configurações para o tipo de arquivo que você tende a processar. O seguinte comando representa um exemplo prático mínimo para criar um projeto de processamento de imagem:
```
aws bedrock-data-automation create-data-automation-project \
--project-name "ImageProcessingProject" \
--standard-output-configuration '{
"image": {
"extraction": {
"category": {
"state": "ENABLED",
"types": ["TEXT_DETECTION"]
},
"boundingBox": {
"state": "ENABLED"
}
},
"generativeField": {
"state": "ENABLED"
}
}
}'
```
O comando valida a configuração de entrada e cria um projeto com um ARN exclusivo. Uma resposta inclui o ARN do projeto e o estágio:
```
{
"projectArn": "Amazon Resource Name (ARN)",
"projectStage": "DEVELOPMENT",
"status": "IN_PROGRESS"
}
```
Se um projeto for criado sem parâmetros, serão aplicadas as configurações padrão. Por exemplo, ao processar imagens, o resumo de imagens e a detecção de texto serão habilitados por padrão.
## Referência de parâmetro completa
A seguinte tabela mostra todos os parâmetros disponíveis para o comando `create-data-automation-project`:
**Parâmetros para create-data-automation-project**
| Parâmetro | Obrigatório | Padrão | Description |
| --- | --- | --- | --- |
| --project-name | Sim | N/D | Nome do projeto de automação de dados |
| --project-type | Não | O tipo do projeto define com qual API de processamento de tempo de execução ele pode ser usado. ASYNCprojetos só podem ser usados com a invoke-bedrock-data-automation-async API, enquanto SYNC projetos só podem ser usados com a invoke-bedrock-data-automation API. |
| --project-stage | Não | AO VIVO | Estágio do esquema (DEVELOPMENT ou LIVE) |
| --standard-output-configuration | Sim | N/D | Configuração JSON para processamento de saída padrão |
| --custom-output-configuration | Não | N/D | Configuração JSON para processamento de saída personalizada |
| --encryption-configuration | Não | N/D | Configurações de criptografia para o projeto |
| --client-token | Não | Gerado automaticamente | Identificador exclusivo de idempotência da solicitação |
## Criar um esquema
Depois de criar um projeto, você pode criar um esquema para definir a estrutura do processamento de dados usando o comando `create-blueprint`.
Veja aqui um exemplo prático mínimo para criar um esquema personalizado para o processamento de passaportes:
```
aws bedrock-data-automation create-blueprint \
--blueprint-name "passport-blueprint" \
--type "IMAGE" \
--blueprint-stage "DEVELOPMENT" \
--schema '{
"class": "Passport",
"description": "Blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
}
}
}'
```
O comando cria um esquema com o esquema especificado. Em seguida, você pode usar esse esquema ao processar documentos para extrair dados estruturados de acordo com o esquema definido.
## Usar seu esquema
### Adicionar um esquema a um projeto
Para adicionar um esquema ao seu projeto, use o comando `update-data-automation-project`:
```
aws bedrock-data-automation update-data-automation-project \
--project-arn "Amazon Resource Name (ARN)" \
--standard-output-configuration '{
"image": {
"extraction": {
"category": {
"state": "ENABLED",
"types": ["TEXT_DETECTION"]
},
"boundingBox": {
"state": "ENABLED"
}
},
"generativeField": {
"state": "ENABLED",
"types": ["IMAGE_SUMMARY"]
}
}
}' \
--custom-output-configuration '{
"blueprints": [
{
"blueprintArn": "Amazon Resource Name (ARN)",
"blueprintVersion": "1",
"blueprintStage": "LIVE"
}
]
}'
```
### Verificar a integração do esquema
É possível verificar a integração do esquema usando o comando `get-data-automation-project`:
```
aws bedrock-data-automation get-data-automation-project \
--project-arn "Amazon Resource Name (ARN)"
```
### Gerenciar vários esquemas
Use o comando `list-blueprints` para visualizar todos os seus esquemas:
```
aws bedrock-data-automation list-blueprints
```
## Processar documentos de forma assíncrona
Antes de processar documentos com o BDA, você deve primeiro carregar seus documentos em um bucket do S3. Depois de configurar um projeto, você pode processar documentos usando o comando: `invoke-data-automation-async`
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/invoice-123.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bda-documents/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
O comando exibe um ARN de invocação que você pode usar para verificar o status do processamento:
```
{
"invocationArn": "Amazon Resource Name (ARN)"
}
```
## Verificar o status do processamento
Para verificar o status do trabalho de processamento, use o comando `get-data-automation-status`.
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
O comando exibe o status atual de um trabalho de processamento:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-09T12:34:56.789Z",
"lastModifiedTime": "2025-07-09T12:45:12.345Z",
"outputLocation": "s3://my-bda-documents/output/efgh5678/"
}
```
Os valores de status possíveis incluem:
+ `IN_PROGRESS`: o trabalho de processamento está sendo executado no momento.
+ `COMPLETED`: o trabalho de processamento foi concluído com êxito.
+ `FAILED`: o trabalho de processamento falhou. Verifique a resposta para ver os detalhes do erro.
+ `STOPPED`: o trabalho de processamento foi interrompido manualmente.
## Recuperar resultados
Quando o processamento for concluído, será possível listar os arquivos de saída no bucket do S3:
```
aws s3 ls s3://my-bda-documents/output/efgh5678/
```
Para fazer download dos resultados sua máquina local:
```
aws s3 cp s3://my-bda-documents/output/efgh5678/ ~/Downloads/bda-results/ --recursive
```
A saída inclui dados estruturados com base na configuração do projeto e em todos os esquemas que você aplicou.
## Processar documentos de forma síncrona
Antes de processar documentos com o BDA, você deve primeiro carregar seus documentos em um bucket do S3. A API de sincronização interrompe a entrada via bucket do S3 ou bytes de imagem (ou seja, o processamento de documentos sem o S3). O comando retorna dados estruturados com base na configuração do seu projeto e em todos os Blueprints que você aplicou:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/invoice-123.pdf"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
## Processar imagens de forma síncrona
O comando retorna dados estruturados com base na configuração do seu projeto e em todos os Blueprints que você aplicou:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/advertisement_latest.jpeg"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
# CLI de operações do esquema
Este guia aborda as operações do Blueprint disponíveis por meio da AWS Command Line Interface (CLI) Amazon Bedrock para automação de dados (BDA).
## Criar esquemas
Os esquemas definem a estrutura e as propriedades dos dados que você deseja extrair de arquivos de documentos, imagens, áudio ou vídeo. Use o comando create-blueprint para definir um novo esquema.
O comando a seguir cria um esquema personalizado para extrair dados de uma imagem de passaporte.
**Sintaxe**
```
aws bedrock-data-automation create-blueprint \
--blueprint-name "passport-blueprint" \
--type "IMAGE" \
--blueprint-stage "DEVELOPMENT" \
--schema '{
"class": "Passport",
"description": "Blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
},
"expiration_date": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport expiration date"
}
}
}'
```
## Referência de parâmetro completa
A seguinte tabela mostra todos os parâmetros disponíveis para o comando `create-blueprint`:
**Parâmetros de create-blueprint**
| Parâmetro | Obrigatório | Padrão | Description |
| --- | --- | --- | --- |
| --blueprint-name | Sim | N/D | Nome do esquema |
| --type | Sim | N/D | Tipo de conteúdo (IMAGE, DOCUMENT, AUDIO, VIDEO) |
| --blueprint-stage | Não | AO VIVO | Etapa do esquema (DEVELOPMENT ou LIVE) |
| --schema | Sim | N/D | Esquema JSON definindo a estrutura do esquema |
| --client-token | Não | Gerado automaticamente | Identificador exclusivo de idempotência da solicitação |
## Visualizar configurações do esquema
**Listar todos os esquemas**
Use o comando list-blueprints para recuperar uma lista de todos os esquemas associados à sua conta.
**Sintaxe**
```
aws bedrock-data-automation list-blueprints
```
**Visualizar detalhes do esquema**
Para ver informações detalhadas sobre um esquema específico, inclusive o respectivo esquema e configuração, use o comando get-blueprint.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Inspecionar uma versão específica**
Ao trabalhar com esquemas versionados, use o comando get-blueprint com a opção --blueprint-version para visualizar uma versão específica.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-version "version-number"
```
**Inspecionar um estágio específico**
Para visualizar os esquemas no estágio DEVELOPMENT ou LIVE, use:
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
## Editar especificações do esquema
**Atualizar configurações do esquema**
Para modificar o esquema ou as propriedades de um esquema existente, use o comando update-blueprint.
**Sintaxe**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--schema '{
"class": "Passport",
"description": "Updated blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
},
"expiration_date": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport expiration date"
}
}
}'
```
**Observação:** ao atualizar um esquema, você deve fornecer o esquema completo, mesmo para campos que não estão sendo alterados.
**Promover para LIVE**
Para mover um esquema do estágio DEVELOPMENT para o estágio LIVE para produção, use o comando update-blueprint com a opção --blueprint-stage.
**Sintaxe**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
**Controlar a versão do esquema**
Crie uma nova versão do seu Blueprint para preservar seu estado atual antes de fazer alterações significativas usando o create-blueprint-version comando.
**Sintaxe**
```
aws bedrock-data-automation create-blueprint-version \
--blueprint-arn "Amazon Resource Name (ARN)"
```
## Gerenciar as tags do esquema
As tags ajudam os usuários a organizar e categorizar os esquemas para simplificar o gerenciamento.
**Adicionar tags**
Aplique metadados ao esquema adicionando tags.
**Sintaxe**
```
aws bedrock-data-automation tag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tags '{"Department":"Finance","Project":"PassportProcessing"}'
```
**Remover etiquetas**
Remova tags específicas do esquema com o comando untag-resource.
**Sintaxe**
```
aws bedrock-data-automation untag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tag-keys '["Department","Project"]'
```
**Exibir tags**
Liste todas as tags associadas ao seu Blueprint usando o list-tags-for-resource comando.
**Sintaxe**
```
aws bedrock-data-automation list-tags-for-resource \
--resource-arn "Amazon Resource Name (ARN)"
```
## Excluir esquemas
**Excluir um esquema inteiro**
Use o comando delete-blueprint para remover permanentemente um esquema e todas as respectivas versões.
**Sintaxe**
```
aws bedrock-data-automation delete-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Cuidado:** esse comando exclui permanentemente um esquema e não é possível recuperá-lo.
**Importante:** não é possível excluir um esquema que esteja sendo usado no momento por algum projeto. Antes de excluir, verifique se não há referência ao esquema na configuração de saída personalizada de algum projeto.
## Otimização do blueprint
### Invocando a otimização do Blueprint
Inicie um trabalho assíncrono de otimização do blueprint para melhorar as instruções do blueprint de cada um dos campos do blueprint e a precisão dos resultados.
**Sintaxe**
```
aws bedrock-data-automation invoke-blueprint-optimization-async \
--blueprint blueprintArn="arn:aws:bedrock:::blueprint/",stage="DEVELOPMENT" \
--samples '[
{
"assetS3Object": {
"s3Uri": "s3://my-optimization-bucket/samples/document1.pdf"
},
"groundTruthS3Object": {
"s3Uri": "s3://my-optimization-bucket/ground-truth/document1-expected.json"
}
}
]' \
--output-configuration s3Object='{s3Uri="s3://my-optimization-bucket/results/optimization-output"}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
### Verificando o status de otimização do Blueprint
Monitore o progresso e os resultados de um trabalho de otimização do plano.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint-optimization-status \
--invocation-arn "arn:aws:bedrock:::blueprint-optimization-invocation/opt-12345abcdef"
```
Use esse comando para rastrear o status do trabalho de otimização. A resposta inclui o status atual (Criado InProgress ServiceError, Sucesso ou ClientError) e os detalhes da configuração de saída quando concluída.
### Copiando estágios do Blueprint
Copiar um blueprint de um estágio para outro
**Sintaxe**
```
aws bedrock-data-automation copy-blueprint-stage \
--blueprint-arn "arn:aws:bedrock:::blueprint/" \
--source-stage "DEVELOPMENT" \
--target-stage "LIVE"
```
**Cuidado:** esse comando copia toda a configuração do Blueprint do estágio de origem para o estágio de destino, substituindo qualquer configuração existente no estágio de destino.
**Importante:** Certifique-se de que o Blueprint seja completamente testado no estágio de origem antes de copiar para o estágio de produção (AO VIVO). Essa operação não pode ser desfeita com facilidade.
# Processar por meio da CLI
Antes de processar documentos com a BDA, você deve primeiro fazer upload dos documentos em um bucket do S3:
**Sintaxe**
```
aws s3 cp [--options]
```
Exemplo:
```
aws s3 cp /local/path/document.pdf s3://my-bda-bucket/input/document.pdf
```
------
#### [ Async ]
**Estrutura básica de comando de processamento**
Use o comando `invoke-data-automation-async` para processar arquivos:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--output-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Estrutura avançada de comando de processamento**
**Processamento de vídeo com segmentos de tempo**
Para arquivos de vídeo, você pode especificar segmentos de tempo a serem processados:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/video.mp4",
"assetProcessingConfiguration": {
"video": {
"segmentConfiguration": {
"timestampSegment": {
"startTimeMillis": 0,
"endTimeMillis": 300000
}
}
}
}
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Usar esquemas personalizados**
É possível especificar esquemas personalizados diretamente no comando:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--blueprints '[
{
"blueprintArn": "Amazon Resource Name (ARN)",
"version": "1",
"stage": "LIVE"
}
]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Adicionar configuração de criptografia**
Para aumentar a segurança, você pode adicionar a configuração de criptografia:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--encryption-configuration '{
"kmsKeyId": "Amazon Resource Name (ARN)",
"kmsEncryptionContext": {
"Department": "Finance",
"Project": "DocumentProcessing"
}
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Notificações de eventos**
Ative EventBridge as notificações para a conclusão do processamento:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--notification-configuration '{
"eventBridgeConfiguration": {
"eventBridgeEnabled": true
}
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Verificando o status do processamento**
Use o comando `get-data-automation-status` para verificar o status do trabalho de processamento:
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
A resposta incluirá o status atual:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-24T12:34:56.789Z",
"lastModifiedTime": "2025-07-24T12:45:12.345Z",
"outputLocation": "s3://my-bucket/output/abcd1234/"
}
```
**Recupere os resultados do processamento**
**Localizar arquivos de saída no S3**
Liste os arquivos de saída no bucket do S3:
```
aws s3 ls s3://amzn-s3-demo-bucket/output/
```
Faça download dos resultados sua máquina local:
```
aws s3 cp s3://amzn-s3-demo-bucket/output/ ~/Downloads/bda-results/ --recursive
```
**Noções básicas sobre a estrutura de saída**
A saída normalmente inclui:
+ `standard-output.json`: contém resultados de extração padrão.
+ `custom-output.json`: contém resultados de esquemas personalizados.
+ `metadata.json`: contém metadados de processamento e pontuações de confiança.
**Campos de resposta comuns**
A saída padrão normalmente inclui:
+ `extractedData`: as principais informações extraídas.
+ `confidence`: pontuações de confiança para cada campo extraído.
+ `metadata`: processamento de informações, como carimbos de data/hora e detalhes do modelo.
+ `boundingBoxes`: informações de localização dos elementos detectados (se habilitado).
**Tratamento de erros e solução de problemas**
Cenários e soluções de erro comuns:
+ **URI inválido do S3**: verifique se o bucket do S3 existe e se você tem as permissões adequadas.
+ **Ausente data-automation-profile-arn**: esse parâmetro é obrigatório para todas as solicitações de processamento
+ **Projeto não encontrado**: verifique se o ARN do projeto está correto e se o projeto existe.
+ **Formato de arquivo não compatível**: verifique se o formato do arquivo é compatível com a BDA.
**Adicionar tags às tarefas de processamento**
Você pode adicionar tags para ajudar a organizar e rastrear seus trabalhos de processamento:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--tags '[
{
"key": "Department",
"value": "Finance"
},
{
"key": "Project",
"value": "InvoiceProcessing"
}
]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
------
#### [ Sync ]
**Estrutura básica de comando de processamento**
Use o comando `invoke-data-automation` para processar arquivos:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
**Estrutura avançada de comando de processamento**
Saída para o bucket S3
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--output-configuration '{"s3Uri": "s3://amzn-s3-demo-bucket/output/" }' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region" //document only
```
Use entrada de bytes
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"bytes": #blob input
}' \
--output-configuration '{"s3Uri": "s3://amzn-s3-demo-bucket/output/" }' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
**nota**
**Bytes**
Um blob de bytes de documentos codificados em base64. O tamanho máximo de um documento fornecido em um blob de bytes é de 50 MB. O tipo deve ser um objeto de dados binários codificado em Base64.
**Use plantas personalizadas (somente para imagem)**
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--blueprints '[{"blueprintArn": "Amazon Resource Name (ARN)", "version": "1", "stage": "LIVE" } ]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
------
# Processar casos de uso
A Automação de Dados do Amazon Bedrock permite que você processe documentos, imagens, áudio e vídeo por meio da interface de linha de comandos (CLI). Para cada modalidade, o fluxo de trabalho consiste em criar um projeto, invocar a análise e recuperar o resultado.
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Documents ]
**Extrair dados de um W2**
![\[Exemplo do formulário W2 com campos padrão, demonstrando o layout e os campos de dados que serão extraídos.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/W2.png)
Ao processar um formulário W2, um exemplo de esquema seria o seguinte:
```
{
"class": "W2TaxForm",
"description": "Simple schema for extracting key information from W2 tax forms",
"properties": {
"employerName": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employer's company name"
},
"employeeSSN": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employee's Social Security Number (SSN)"
},
"employeeName": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employee's full name"
},
"wagesAndTips": {
"type": "number",
"inferenceType": "explicit",
"instruction": "Wages, tips, other compensation (Box 1)"
},
"federalIncomeTaxWithheld": {
"type": "number",
"inferenceType": "explicit",
"instruction": "Federal income tax withheld (Box 2)"
},
"taxYear": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The tax year for this W2 form"
}
}
}
```
O comando para invocar o processamento do W2 seria semelhante ao seguinte:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://w2-processing-bucket-301678011486/input/W2.png"
}' \
--output-configuration '{
"s3Uri": "s3://w2-processing-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Um exemplo da saída esperada é:
```
{
"documentType": "W2TaxForm",
"extractedData": {
"employerName": "The Big Company",
"employeeSSN": "123-45-6789",
"employeeName": "Jane Doe",
"wagesAndTips": 48500.00,
"federalIncomeTaxWithheld": 6835.00,
"taxYear": "2014"
},
"confidence": {
"employerName": 0.99,
"employeeSSN": 0.97,
"employeeName": 0.99,
"wagesAndTips": 0.98,
"federalIncomeTaxWithheld": 0.97,
"taxYear": 0.99
},
"metadata": {
"processingTimestamp": "2025-07-23T23:15:30Z",
"documentId": "w2-12345",
"modelId": "amazon.titan-document-v1",
"pageCount": 1
}
}
```
------
#### [ Images ]
**Exemplo de anúncio de viagem**
![\[Imagem de exemplo, demonstrando como os usuários podem extrair informações de anúncios.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/TravelAdvertisement.jpg)
Um exemplo de esquema para anúncios de viagens seria o seguinte:
```
{
"class": "TravelAdvertisement",
"description": "Schema for extracting information from travel advertisement images",
"properties": {
"destination": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The name of the travel destination being advertised"
},
"tagline": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main promotional text or tagline in the advertisement"
},
"landscapeType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of landscape shown (e.g., mountains, beach, forest, etc.)"
},
"waterFeatures": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of any water features visible in the image (ocean, lake, river, etc.)"
},
"dominantColors": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The dominant colors present in the image"
},
"advertisementType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of travel advertisement (e.g., destination promotion, tour package, etc.)"
}
}
}
```
O comando para invocar o processamento do anúncio de viagem seria semelhante ao seguinte:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://travel-ads-bucket-301678011486/input/TravelAdvertisement.jpg"
}' \
--output-configuration '{
"s3Uri": "s3://travel-ads-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Um exemplo da saída esperada é:
```
{
"documentType": "TravelAdvertisement",
"extractedData": {
"destination": "Kauai",
"tagline": "Travel to KAUAI",
"landscapeType": "Coastal mountains with steep cliffs and valleys",
"waterFeatures": "Turquoise ocean with white surf along the coastline",
"dominantColors": "Green, blue, turquoise, brown, white",
"advertisementType": "Destination promotion"
},
"confidence": {
"destination": 0.98,
"tagline": 0.99,
"landscapeType": 0.95,
"waterFeatures": 0.97,
"dominantColors": 0.96,
"advertisementType": 0.92
},
"metadata": {
"processingTimestamp": "2025-07-23T23:45:30Z",
"documentId": "travel-ad-12345",
"modelId": "amazon.titan-image-v1",
"imageWidth": 1920,
"imageHeight": 1080
}
}
```
------
#### [ Audio ]
**Transcrever uma chamada telefônica**
Um exemplo de esquema para uma chamada telefônica seria o seguinte:
```
{
"class": "AudioRecording",
"description": "Schema for extracting information from AWS customer call recordings",
"properties": {
"callType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of call (e.g., technical support, account management, consultation)"
},
"participants": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The number and roles of participants in the call"
},
"mainTopics": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main topics or AWS services discussed during the call"
},
"customerIssues": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Any customer issues or pain points mentioned during the call"
},
"actionItems": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Action items or next steps agreed upon during the call"
},
"callDuration": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The duration of the call"
},
"callSummary": {
"type": "string",
"inferenceType": "explicit",
"instruction": "A brief summary of the entire call"
}
}
}
```
O comando para invocar o processamento de uma chamada telefônica seria semelhante ao seguinte:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://audio-analysis-bucket-301678011486/input/AWS_TCA-Call-Recording-2.wav"
}' \
--output-configuration '{
"s3Uri": "s3://audio-analysis-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Um exemplo da saída esperada é:
```
{
"documentType": "AudioRecording",
"extractedData": {
"callType": "Technical consultation",
"participants": "3 participants: AWS Solutions Architect, AWS Technical Account Manager, and Customer IT Director",
"mainTopics": "AWS Bedrock implementation, data processing pipelines, model fine-tuning, and cost optimization",
"customerIssues": "Integration challenges with existing ML infrastructure, concerns about latency for real-time processing, questions about data security compliance",
"actionItems": [
"AWS team to provide documentation on Bedrock data processing best practices",
"Customer to share their current ML architecture diagrams",
"Schedule follow-up meeting to review implementation plan",
"AWS to provide cost estimation for proposed solution"
],
"callDuration": "45 minutes and 23 seconds",
"callSummary": "Technical consultation call between AWS team and customer regarding implementation of AWS Bedrock for their machine learning workloads. Discussion covered integration approaches, performance optimization, security considerations, and next steps for implementation planning."
},
"confidence": {
"callType": 0.94,
"participants": 0.89,
"mainTopics": 0.92,
"customerIssues": 0.87,
"actionItems": 0.85,
"callDuration": 0.99,
"callSummary": 0.93
},
"metadata": {
"processingTimestamp": "2025-07-24T00:30:45Z",
"documentId": "audio-12345",
"modelId": "amazon.titan-audio-v1",
"audioDuration": "00:45:23",
"audioFormat": "WAV",
"sampleRate": "44.1 kHz"
},
"transcript": {
"segments": [
{
"startTime": "00:00:03",
"endTime": "00:00:10",
"speaker": "Speaker 1",
"text": "Hello everyone, thank you for joining today's call about implementing AWS Bedrock for your machine learning workloads."
},
{
"startTime": "00:00:12",
"endTime": "00:00:20",
"speaker": "Speaker 2",
"text": "Thanks for having us. We're really interested in understanding how Bedrock can help us streamline our document processing pipeline."
},
{
"startTime": "00:00:22",
"endTime": "00:00:35",
"speaker": "Speaker 3",
"text": "Yes, and specifically we'd like to discuss integration with our existing systems and any potential latency concerns for real-time processing requirements."
}
// Additional transcript segments would continue here
]
}
}
```
------
#### [ Video ]
**Processar um vídeo**
Um exemplo de esquema para vídeos seria o seguinte:
```
{
"class": "VideoContent",
"description": "Schema for extracting information from video content",
"properties": {
"title": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The title or name of the video content"
},
"contentType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of content (e.g., tutorial, competition, documentary, advertisement)"
},
"mainSubject": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main subject or focus of the video"
},
"keyPersons": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Key people appearing in the video (hosts, participants, etc.)"
},
"keyScenes": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of important scenes or segments in the video"
},
"audioElements": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of notable audio elements (music, narration, dialogue)"
},
"summary": {
"type": "string",
"inferenceType": "explicit",
"instruction": "A brief summary of the video content"
}
}
}
```
O comando para invocar o processamento do vídeo seria semelhante ao seguinte:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://video-analysis-bucket-301678011486/input/MakingTheCut.mp4",
"assetProcessingConfiguration": {
"video": {
"segmentConfiguration": {
"timestampSegment": {
"startTimeMillis": 0,
"endTimeMillis": 300000
}
}
}
}
}' \
--output-configuration '{
"s3Uri": "s3://video-analysis-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Um exemplo da saída esperada é:
```
{
"documentType": "VideoContent",
"extractedData": {
"title": "Making the Cut",
"contentType": "Fashion design competition",
"mainSubject": "Fashion designers competing to create the best clothing designs",
"keyPersons": "Heidi Klum, Tim Gunn, and various fashion designer contestants",
"keyScenes": [
"Introduction of the competition and contestants",
"Design challenge announcement",
"Designers working in their studios",
"Runway presentation of designs",
"Judges' critique and elimination decision"
],
"audioElements": "Background music, host narration, contestant interviews, and design feedback discussions",
"summary": "An episode of 'Making the Cut' fashion competition where designers compete in a challenge to create innovative designs. The episode includes the challenge announcement, design process, runway presentation, and judging."
},
"confidence": {
"title": 0.99,
"contentType": 0.95,
"mainSubject": 0.92,
"keyPersons": 0.88,
"keyScenes": 0.90,
"audioElements": 0.87,
"summary": 0.94
},
"metadata": {
"processingTimestamp": "2025-07-24T00:15:30Z",
"documentId": "video-12345",
"modelId": "amazon.titan-video-v1",
"videoDuration": "00:45:23",
"analyzedSegment": "00:00:00 - 00:05:00",
"resolution": "1920x1080"
},
"transcript": {
"segments": [
{
"startTime": "00:00:05",
"endTime": "00:00:12",
"speaker": "Heidi Klum",
"text": "Welcome to Making the Cut, where we're searching for the next great global fashion brand."
},
{
"startTime": "00:00:15",
"endTime": "00:00:25",
"speaker": "Tim Gunn",
"text": "Designers, for your first challenge, you'll need to create a look that represents your brand and can be sold worldwide."
}
// Additional transcript segments would continue here
]
}
}
```
------