Como criar uma solução serverless de análise de sinistro de carros usando reconhecimento de imagens

Por Andreza Cruz, Solutions Architect
Ana Cunha, Solutions Architect, AWS
Evandro Franco, Solutions Architect, AWS
Hermes Pimentel, Solutions Architect, AWS
Luis Miguel Flores dos Santos, Solutions Architect, AWS

Nos últimos anos, com o rápido aumento do uso de aplicativos de mensagens e o crescimento das tecnologias de inteligência artificial e aprendizado de máquina, os chatbots começaram a ter um expressivo valor de mercado principalmente aqueles capazes de manter uma conversação de forma natural, intuitiva e trazer ao usuário uma boa experiência de uso. O principal desafio é ser capaz de criar um chatbot com essas características. Neste blog post iremos cobrir um caso de uso específico: a análise de sinistro de carros.

As centrais de atendimentos de seguradoras de carros enfrentam diariamente uma alta demanda de solicitações de análises de sinistro referentes a colisões entre veículos. Nesse cenário é comum haver demora nas resoluções de problemas. Essa situação pode ser remediada com a automatização destes atendimentos através da avaliação inicial de imagens de batidas de carro usando reconhecimento de imagens.

Vamos demonstrar como integrar uma solução de chatbot usando os serviços serverless da AWS como AWS Lambda, Amazon API Gateway, Amazon Simple Storage Service (S3), Amazon DynamoDB, Amazon SQS e os serviços de Machine Learning, como o Amazon Lex, para criação de bots usando linguagem natural e o Amazon Rekognition. Usaremos o Amazon Rekognition Custom Labels para fazer o reconhecimento de imagens através de um modelo personalizado de aprendizado de máquina para fazer a análise de batidas de carro.

Visão geral da solução

O diagrama de arquitetura abaixo mostra a solução sugerida para cobrir o caso de uso proposto acima, utilizando dos serviços serverless da AWS para criar uma arquitetura escalável, desacoplada e altamente disponível, usando serviços de aprendizado de máquina gerenciados.

Figura 1: Visão geral da arquitetura da solução

O fluxo de mensagens se inicia a partir de uma requisição do usuário através de uma rota configurada em uma API HTTP do Amazon API Gateway, a requisição é então processada por uma função do AWS Lambda.

A função AWS Lambda é responsável por identificar a rota e validar o json recebido. Ao identificar uma requisição de mensagem, a função validará o conteúdo e criará uma solicitação de intenção (intent) ao Amazon Lex. Após processar a intent o Amazon Lex retornará à função Lambda uma resposta (response) contendo o texto de retorno ao usuário. Para aprender como construir chatbots usando o Amazon Lex, veja: Como construir Chatbots complexos encadeando intents no Amazon Lex (Chain Intents).

Quando a rota de upload de imagem é acionada, é iniciado um fluxo assíncrono, que armazenará a imagem no Amazon Simple Storage Service (S3) e adicionará uma mensagem em uma fila padrão do

Amazon SQS contendo as informações da imagem a ser processada.

O Amazon SQS acionará então a segunda função do AWS Lambda que buscará a imagem a ser processada no bucket S3 e fará a inferência no modelo customizado de aprendizado de máquina que foi previamente treinado no Amazon Rekognition Custom Labels.

Após a análise da imagem ser realizada, o modelo retornará um objeto json com os resultados da análise. A função Lambda então armazenará esse resultado em uma tabela do Amazon DynamoDB e os resultados ficarão disponíveis para consulta através de uma rota da API HTTP.

O Amazon DynamoDB também é responsável por armazenar os logs transacionais e informações de usuários, além dos resultados das análises.

Criando a solução automatizada

Para testar a solução final funcionando, foi criado um template do AWS CloudFormation para o provisionamento da arquitetura da aplicação. No entanto, você precisa ter um modelo treinado de Rekognition para que seja possível identificar e realizar as análises. Veja como criar seu modelo personalizado do Amazon Rekognition na seção de Links.

Para executar a solução é preciso acessar o serviço do AWS CloudFormation no console AWS e usar o template disponibilizado no repositório do projeto.

Siga os pré-requisitos contidos no README do projeto.

Após esta etapa, na página inicial do CloudFormation, clique em Create stack.

Em seguida, em Prerequisite – Prepare template, selecione Template is Ready.

Em Specify template selecione Upload a template file.

Utilize o arquivo .yaml disponível aqui.

Clique em Next

Avance pra o passo 2 e em Specify stack details adicione os seguintes parâmetros:

Stack Name: CarInsurance
LexBotAlias: dev
LexBotName: OctankBot
RekognitionModel: ARN do seu modelo

Figura 2: Exemplo de configuração

Após essa etapa, avance com as propriedades padrões e na etapa de revisão selecione os seguintes checkboxes conforme a imagem abaixo:

Figura 3: Revisão

Aguarde o provisionamento, pode demorar alguns minutos.

Projeto

Na primeira etapa desse blog post, focaremos em como criar e configurar os serviços, usando snippets de código para exemplificar a utilização dos recursos e retorno dos métodos.

Rotas de API
Para esse projeto, usaremos as três rotas de API a seguir:

POST /sendMessage
POST /uploadImage
GET /getResults

POST /sendMessage

Esta chamada de API será responsável por interagir com o chatbot Lex, através de intents e responder de volta ao usuário uma resposta (mensagem).

POST /uploadImage

Esta chamada de API fará o upload de uma imagem binary base64 ao bucket do S3 criado para este projeto. Os Content-Type aceitos são ‘image/png’, ‘image/jpg’, ‘image/jpeg’.

GET /getResults

Esta chamada de API será responsável por obter os resultados da análise feita pelo modelo do Amazon Rekognition Custom Labels armazenados em uma tabela do Amazon DynamoDB. A requisição retorna ao usuário uma mensagem contendo o rótulo da imagem e a taxa de confiança da predição, ou em caso de resposta nula ou erro, retornará ao usuário uma mensagem para refazer a solicitação.

AWS IAM

AWS Identity & Access Management (IAM) é o serviço que possibilita o gerenciamento e acesso a serviços e recursos da AWS de forma segura. Através da criação de usuários e grupos, é possível conceder ou negar permissões aos recursos.

Durante este blog, usaremos uma função (role) IAM para definir as políticas e permissões aos serviços e recursos que serão usados durante o projeto. Veja um guia para ajudar na Criação de uma função do IAM (console).

Para esta função precisaremos de permissão para os seguintes serviços:

Managed Policies:

AWSLambdaDynamoDBExecutionRole

AWSLambdaExecute

AWSLambdaSQSQueueExecutionRole

AmazonLexRunBotsOnly

AWSLambdaRole

TranslateReadOnly

AmazonS3ObjectLambdaExecutionRolePolicy

Inline Policies:

APIGatewayPolicy

CloudWatchLambdaPolicy

DynamoDBGetPutPolicy

RekognitionGetCustomLabelsPolicy

SQSWriteOnlyPolicy

Observações importantes: É recomendado como boa prática utilizar o princípio do menor privilégio (least privilege) em ambientes reais de desenvolvimento, teste e produção.

Amazon Rekognition e Amazon Lex

Uma das partes chaves deste projeto é a utilização de aprendizado de máquina para desenvolvimento do modelo de reconhecimento de imagens de batidas de carro, usando o Amazon Rekognition Custom Labels e o Amazon Lex, para criação da interface de conversação usando linguagem natural.

Criando o chatbot no Amazon Lex

Antes de começar, você deve verificar se a função gerenciada AWSServiceRoleForLexBots foi criada. Caso contrário, crie-a e certifique-se de que recebeu permissão para chamar o serviço Amazon Polly e o Amazon Comprehend. A documentação a seguir irá guiá-lo sobre isso: Create a Service-Linked Role (AWS CLI).

Para criação do chatbot é preciso criar um json contendo as informações necessárias como metadata, resource, intents, slots e sampleUtterances.Veja JSON Format for Importing and Exporting que exemplifica a estrutura json para exportar e importar tipos de slot, intenções e bots em formato do Amazon Lex.

Para usar o json, utilize o menu do console do Amazon Lex (Lex V1), clique em Bots e a seguir clique em Actions e Import.

Em Upload File selecione o arquivo compactado e clique em Browse. Clique em Import.

Observações importantes: Na data de publicação deste texto o Amazon Lex V1 não possui suporte nativo da língua portuguesa. No entanto, a V2 do Amazon Lex já traz suporte nativo a diversos idiomas dentre eles o Português Brasileiro (pt_BR). Veja a lista de idiomas suportados em Idiomas suportados V2 e Idiomas suportados V1.

Amazon Rekognition

Neste projeto, o Amazon Rekognition Custom Labels é utilizado para fazer o reconhecimento de imagens através de inferência a um modelo personalizado de aprendizado de máquina treinado para realizar a análise de batidas de carro.

Utilizamos um conjunto de dados (dataset) contendo aproximadamente 104 imagens de carros com os seguintes rótulos (labels):

Flat Tire (Pneu Furado) onde foram utilizadas 48 imagens.
Front Car Crash (Batida Frontal de Carro) onde utilizamos 56 imagens de batidas de carro.

O modelo apresentou um F1 Score, valor que demonstra o desempenho médio obtido com as imagens treinadas, de 0.978 o que indica um bom funcionamento e performance do modelo. Procure sempre obter um alto nível de precisão e acurácia dos resultados utilizando um conjunto de dados (dataset) rico e diverso de imagens em seus cenários reais de produção. Veja o documento a seguir para consultar as melhores praticas de utilização do serviço Amazon Rekognition Custom Labels: Guidelines and quotas in Amazon Rekognition Custom Labels.

Figura 4: Resultados da avaliação do reconhecimento de imagens

Criando as funções do AWS Lambda

Para este blog post foram utilizadas duas funções AWS Lambda:

carInsuranceBot 
carInsuranceBotImageProcess

Para ambas funções foi utilizado Python 3.9

carInsuranceBot

Figura 5: Visão geral da função Lambda carInsuranceBot

A função carInsuranceBot é responsável por reter a lógica principal do projeto. Esta função recebe o gatilho (trigger) do Amazon API Gateway e redireciona para os demais serviços da arquitetura conforme a solicitação recebida. Suas principais responsabilidades são de interceptar as requisições de sendMessage, uploadImage e getResults, assim como armazenar todas as interações com o bot no Amazon DynamoDB para fins de registro de logs transacionais, armazenamento de informações e resultados.

Veja como Criar uma função do Lambda com o console.

O método sendMessage é responsável por identificar a requisição /sendMessage no payload.
O método valida e envia a mensagem para o Amazon Lex que identifica a Intent e retorna à função uma mensagem contendo a resposta ao usuário. Todo o conteúdo de envio e retorno são registrados em uma tabela do Amazon DynamoDB.

Quando a função identifica que o usuário está realizando um upload, aciona o método uploadImage. Este método verifica o conteúdo dos headers que é utilizado para detectar o tipo do arquivo recebido e o body que contém o conteúdo da imagem em binário de base64. Os tipos de arquivos aceitos no projeto são: ‘image/png’, ‘image/jpg’, ‘image/jpeg’.

É necessário decodificar a imagem usando image = base64.b64decode(body) antes de escrever a imagem no bucket S3 utilizando o S3().write_on_s3(image, file_key). Uma mensagem é então colocada na fila SQS que acionará o gatilho da segunda função Lambda do projeto. Após finalizar o processamento, o log é escrito na tabela do Amazon DynamoDB e é retornado a API um json com status de sucesso e um token para consulta posterior do resultado da análise da imagem.

Ainda na função Lambda principal, o método de getResults receberá o token da imagem a ser consultada. O token image_token será utilizado para consultar o resultado do processamento da análise feita pelo o Amazon Rekognition Custom Labels. O método read_on_dynamo executa o seguinte código para recuperar o resultado da tabela:

        # get item that matches image_token value

        response = table.get_item(

            Key={

                'image_token': image_token

            }

        )

carInsuranceBotImageProcess

Figura 6: Visão geral da função Lambda carInsuranceBotImageProcess

A função carInsuranceBotImageProcess é responsável por receber o gatilho (trigger) da fila do Amazon SQS proveniente da função Lambda carInsuranceBot, identificar a imagem e através do get_prediction fazer a inferência no modelo de aprendizado de máquina para analisar a imagem.

O código iniciará identificando os valores do conteúdo do evento recebido e o prefixo da imagem que foi armazenada no S3, que será utilizado para enviar ao Amazon Rekognition.

O método de get_prediction usado para invocar o Amazon Rekognition Custom Labels possui o seguinte comportamento:

        def get_prediction(self, s3_prefix):


            image = S3().read_from_s3(s3_prefix)           

            prediction = self.client.detect_custom_labels(Image={'S3Object': {'Bucket': self.S3_BUCKET_NAME, 'Name': s3_prefix}},

                # MinConfidence=min_confidence,

                ProjectVersionArn=self.REKOGNITION_MODEL)



            return prediction

O valor do prediction[‘CustomLabels‘] é armazenado na variável values_prediction e então é validado o seu conteúdo, caso nenhum rótulo seja identificado na imagem o código retornará uma mensagem de falha e caso seja identificado algum rótulo reconhecido pelo modelo pré-treinado o código a seguir será executado:

            prediction_name = values_prediction[0]["Name"]

            prediction_confidence = values_prediction[0]["Confidence"]

                  

            response_message = 'Foi detectado: {} com probabilidade de {}. Confirma?'.format(

                prediction_name.lower(), round(prediction_confidence, 2)

            )

Sendo assim, os valores nome do rótulo e a porcentagem de confiança obtidos da predição são usados para retornar ao usuário. A resposta é escrita na tabela do DynamoDB e ficará disponível para consulta através da chamada /getResults.

Configurando a API HTTP no Amazon API Gateway

Para configurar o Amazon API Gateway, seguiremos o seguinte passo-a-passo:

No console do serviço, selecionaremos API HTTP e Compilar:

Na próxima janela, selecionar para Integrações: Lambda, a região e a função Lambda criada anteriormente.

Para nome de API adicionar um nome.

Após preencher as informações selecionar Avançar.

A seguir, em Configurar rotas, adicionar os métodos descritos anteriormente em Rotas de API conforme a imagem:

Clique em Avançar.

Em Configurar estágios deixe os valores padrões e clique em Avançar.

Na tela seguinte revise as informações inseridas e clique em Criar.

Após a criação da API, anote o valor Invoke URL, essa informação será usada mais adiante para realizar as chamadas às rotas da API.

Observações importantes: Por motivos de simplicidade estamos adicionando todos os métodos na mesma função Lambda.

Criando um bucket no Amazon S3

Utilizaremos um bucket no Amazon S3 para armazenar as imagens de batidas de carro recebidas dos usuários.

O guia a seguir, exemplifica como criar um bucket no Amazon S3 usando o Console, SDK ou AWS CLI:

Criação de um bucket

Criando uma fila padrão SQS

No menu do serviço Amazon SQS dentro do console AWS, clique em Criar fila.

Para criar a fila SQS, seguir o passo-a-passo:

Selecione Padrão.

Insira um nome.

Em Configuração usaremos os valores padrões.

Em Política de acesso selecione Avançado e insira o seguinte json:

{

  "Version": "2008-10-17",

  "Id": "__default_policy_ID",

  "Statement": [

    {

      "Sid": "__owner_statement",

      "Effect": "Allow",

      "Principal": {

        "AWS": "*"

      },

      "Action": [

        "SQS:*"

      ],

      "Resource": <ARN da fila>,

      "Condition": {

      "StringEquals": {

             "aws:SourceAccount": <ID da conta do usuário>

        },

        "ArnLike": {

          "aws:SourceArn": <ARN do bucket S3>

        }

      }

    }

  ]

}

Em “Resource”, use o ARN da fila criado pelo próprio serviço.

Para “aws:SourceAccount”, adicione seu ID de conta.

E em “ArnLike”: { “aws:SourceArn” }, utilize o ARN do bucket S3 criado na etapa anterior. Para achar o valor, selecione o bucket criado no menu do Amazon S3, selecione Propriedades e copie o valor do ARN em Visão geral do bucket.

Deixe as demais configurações padrões e clique em Criar Fila.

Criando as tabelas

Para este projeto usaremos duas tabelas InsuranceBot e InsuranceResults.

A tabela de InsuranceBot será responsável por armazenar todas as mensagens recebidas e enviadas ao usuário. Essa tabela também funcionará como log para registrar as interações entre bot-usuário.

A tabela de InsuranceResults armazenará os resultados recebidos pela análise do modelo.

Para criar as tabelas, no console AWS, procure por DynamoDB e na página principal do serviço selecione Criar tabela.

Preencha o nome da tabela e a Chave de partição. Deixe Chave de classificação em branco.

Para a primeira tabela utilize:

Nome: InsuranceBot
Chave de partição: ts (String)

Para os valores de Configurações e Tags deixe conforme padrão. Clique em Criar tabela.

Repita o passo-a-passo para criar outra tabela.
Para esta segunda tabela, utilize:

Nome: InsuranceResults
Chave de partição: image_token (String)

Integrando os serviços e testando o projeto

Após a criação e inicialização de todos os serviços necessários para executar o projeto, utilizaremos uma plataforma pra testar as rotas da API.

A ordem de chamadas é a seguinte:

POST https://<invoke-URL>/sendMessage
POST https://<invoke-URL>/uploadImage
GET https://<invoke-URL>/getResults

Observações importantes: A Invoke-URL pode ser encontrada nos detalhes da API anteriormente criada no menu do serviço de API Gateway.

O diagrama de sequência abaixo demonstra o fluxo de mensagens e requisições da aplicação:

Figura 7: Diagrama de sequência da solução

Utilize uma ferramenta de consulta de APIs para testar as rotas respeitando a ordem das chamadas.

Exemplos:

Inicie a conversa com o chatbot fazendo chamada POST https://<invoke-URL>/sendMessage:

Após a troca de mensagens, utilize a rota POST https://<invoke-URL>/uploadImage para iniciar o fluxo de reconhecimento de imagens:

E a seguir recupere o resultado chamando a rota de GET https://<invoke-URL>/getResults passando o token recebido na etapa anterior:

Caso aconteça algum erro na chamada ou informação inválida, a API retornará uma mensagem de erro ou Internal Server Error.

Integração com outras aplicações

É possível integrar a solução de chatbot com outras aplicações através da API criada, fazendo modificações a depender do serviço utilizado.

Em aplicações web, mobile ou até mesmo aplicativos de mensagens, tais quais como: Telegram, WhatsApp Business, dentre outros.

Um exemplo de integração da solução com um aplicativo de mensagens é utilizando o Telegram através do BotFather e da Bot API que possibilita a construção de bots para o aplicativo.

O BotFather permite que bots sejam criados com o comando:

/newbot

E inicializados com o comando:

/start

Após a criação, ele fornece um token de acesso que poderá ser usado para controlar o bot, integrar com APIs e fazer requests utilizando o web-hook do Telegram:

curl --request POST \

 --url https://api.telegram.org/bot<TOKEN>/setWebhook \

 --header 'content-type: application/json' \

 --data '{"url": "<YOUR-API-GW-KEY>"}'

É necessário alterar o valor YOUR-API-GW-KEY pela Invoke-URL do Amazon API Gateway e modificar a função Lambda para dar suporte a integração com a API do Telegram.

Remoção de Recursos

Ao final dos testes com o projeto, lembre-se de deletar o ambiente e os serviços utilizados neste blog post:

Amazon API Gateway
AWS Lambda
Amazon Lex
Amazon Simple Storage Service (S3)
Amazon SQS
Amazon DynamoDB
Amazon Rekognition

Conclusão

Conforme ilustrado nesse blog post, demonstramos na prática como implementar e testar uma solução de chatbot usando os serviços da AWS, assim como ferramentas de implementação e aprendizado de máquina. Com ele é possível testar a integração entre diversos serviços e aplicações para criar seus próprios workloads de chatbots e reconhecimento de imagem para solucionar problemas de análise de batidas de carros.

Links

Caso deseje criar seu próprio dataset, a série de vídeos a seguir demonstra o passo a passo de como criar datasets utilizando o Amazon Rekognition Custom Labels:

Referências

Sobre os autores

Andreza Cruz é uma Arquiteta de Soluções que trabalha com TI construindo soluções e ajudando clientes em suas jornadas de nuvem. Nos últimos anos tem se especializado em inteligência artificial e aprendizado de máquina (AI/ML).

Ana Cunha é Developer Advocate na Amazon Web Services para a América Latina. Trabalha ajudando desenvolvedores e comunidades a fazer o melhor uso da nuvem.

Evandro Franco é um Arquiteto de Soluções do time de Startups na Amazon Web Services. Em sua função, ele ajuda as Startups a superar os desafios de negócio utilizando a plataforma da AWS. Ele tem mais de 15 anos de experiência na área de tecnologia. Em seu tempo livre, gosta de correr e passar tempo com sua família.

Hermes Pimentel é Arquiteto de Soluções na AWS. Ele ajuda os clientes a usar os serviços da AWS para projetar aplicativos escaláveis, seguros e resilientes. Além disso, tem se especializado em inteligência artificial e aprendizado de máquina (AI/ML). Como hobby, gosta de ler livros, jogar video game e cozinhar.

Luis Miguel Flores dos Santos é arquiteto de soluções na AWS. Ele possui mais de 10 anos de experiência em arquitetura de soluções desde soluções on-prem e cloud, com foco em resiliência, performance e automação. Hoje está se especializando em computação serverless. No seu tempo livre gosta de ler, jogar um bom vídeo game e passar tempo com a família e amigos.

Sobre os revisores

Yan Marim é Arquiteto de Soluções na AWS sendo seu principal tópico de interesse Inteligência Artificial e Machine Learning. Ele ajuda clientes Enterprise nas suas jornadas de transformação digital utilizando a plataforma da AWS.

Tiago Simão é arquiteto de soluções na AWS. Trabalha ajudando clientes de Mídia & Entretenimento em suas jornadas para a nuvem e tem se especializado em inteligência artificial e aprendizado de máquina (AI/ML).

O blog da AWS