Indústrias como assistência médica, mídia e plataformas de mídia social usam fluxos de trabalho de análise de imagem para identificar objetos e entidades nas imagens para entender toda a imagem. Por exemplo, um site de comércio eletrônico pode usar objetos presentes em uma imagem para exibir resultados de pesquisa relevantes. Às vezes, a análise da imagem pode ser difícil quando as imagens estão embaçadas ou com mais nuances. Nesses casos, você pode precisar de um humano para concluir o ciclo de aprendizado de máquina (ML) e aconselhar sobre a imagem usando seu julgamento humano.

Neste post, usamos Amazon Sage Maker para construir, treinar e implantar um modelo de ML para detecção e uso de objetos IA aumentada da Amazon (Amazon A2I) para criar e renderizar um modelo de trabalhador personalizado que permita aos revisores identificar ou revisar objetos encontrados em uma imagem. O Amazon SageMaker é um serviço totalmente gerenciado que fornece aos desenvolvedores e cientistas de dados a capacidade de criar, treinar e implantar modelos de ML rapidamente. O Amazon SageMaker remove o trabalho pesado de cada etapa do processo de ML para facilitar o desenvolvimento de modelos de alta qualidade. O Amazon A2I é um serviço totalmente gerenciado que ajuda a criar fluxos de trabalho de revisão humana para revisar e validar as previsões dos modelos de ML.

Você também pode usar Reconhecimento da Amazônia para a detecção de objetos para identificar objetos de um conjunto predefinido de classes ou use Etiquetas personalizadas do Amazon Rekogition para treinar seu modelo personalizado para detectar objetos e cenas em imagens específicas às suas necessidades comerciais, simplesmente trazendo seus próprios dados.

Alguns outros casos de uso comuns que podem exigir fluxos de trabalho humanos são moderação de conteúdo em imagens e vídeo, extração de texto e entidades de documentos, tradução e análise de sentimentos. Embora você possa usar modelos de ML para identificar conteúdo inapropriado ou extrair entidades, os humanos podem precisar validar as previsões do modelo com base no caso de uso. O Amazon A2I ajuda a criar rapidamente esses fluxos de trabalho humanos.

Você também pode usar o Amazon A2I para enviar uma amostra aleatória de previsões de ML a revisores humanos. Você pode usar esses resultados para informar as partes interessadas sobre o desempenho do modelo e auditar as previsões do modelo.

Pré-requisitos

Esta postagem requer que você tenha os seguintes pré-requisitos:

• Uma função do IAM - Para criar um fluxo de trabalho de revisão humana, é necessário fornecer um Gerenciamento de acesso e identidade da AWS (IAM) que concede permissão ao Amazon A2I para acessar Serviço de armazenamento simples da Amazon (Amazon S3) para ler objetos a serem renderizados em uma interface de usuário de tarefa manual e escrever os resultados. Essa função também precisa de uma política de confiança anexada para dar permissão ao Amazon SageMaker para assumir a função. Isso permite que o Amazon A2I execute ações de acordo com as permissões que você anexa à função. Para obter mais informações e exemplos de políticas, consulte Adicionar permissões à função do IAM usada para criar uma definição de fluxo.
• Caderno de treinamento de detecção de objetos que acompanha - Este post fornece uma caderno de acompanhamento para esta explicação passo a passo. Neste post, vamos nos concentrar no uso do Amazon A2I e na importância de trazer revisores humanos em loop. Portanto, usamos um modelo de detecção de objeto treinado em um bucket S3 e hospede-o em um terminal hospedado do Amazon SageMaker para previsão em tempo real. Para obter mais informações sobre o treinamento de um modelo de detecção de objeto usando o Amazon SageMaker interno Detector multibox de captura única (SSD) algoritmo com Conjunto de dados PASCAL VOC e hospedando-o para previsão em tempo real, consulte o GitHub repo. Se você estiver interessado em construir seu próprio modelo, siga o caderno de treinamento para detecção de objetos. Se você tiver um grande conjunto de dados sem Verdade no solo do Amazon SageMaker etiquetas, você pode usar a Ground Truth para rotular com eficiência suas imagens em escala.

Visão geral do passo a passo

Para implementar esta solução, execute as seguintes etapas:

1. Hospede um modelo de detecção de objeto no Amazon SageMaker.
2. Crie um modelo de tarefa do trabalhador.
3. Crie uma equipe de trabalho privada.
4. Crie um fluxo de trabalho de revisão humana.
5. Ligue para o endpoint do Amazon SageMaker.
6. Complete a revisão humana.
7. Processe a saída JSON para treinamento incremental.

Para este post, fizemos o passo a passo em us-east-1, mas o Amazon A2I está disponível em várias regiões. Para mais informações, veja Tabela Região.

Etapa 1: Hospedar um modelo de detecção de objeto no Amazon SageMaker

Esta etapa está disponível no caderno Jupyter que acompanha. Para configurar seu endpoint, digite o seguinte código Python (isso pode levar alguns minutos):

# provided trained model in the public bucket
source_model_data_s3_uri = 's3://aws-sagemaker-augmented-ai-example/model/model.tar.gz' !aws s3 cp {source_model_data_s3_uri} {MODEL_PATH}/model.tar.gz model_data_s3_uri = f'{MODEL_PATH}/model.tar.gz' timestamp = time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
endpoint_name = 'DEMO-object-detection-augmented-ai-' + timestamp # the docker image for the SageMaker built-in object detection algorithm
image = sagemaker.amazon.amazon_estimator.get_image_uri(region, 'object-detection', repo_version='latest') # loading up a Model object from the provided trained model model = sagemaker.model.Model(model_data_s3_uri, image, role = role, predictor_cls = sagemaker.predictor.RealTimePredictor, sagemaker_session = sess)
# deploying the model into one ml.m4.xlarge instance
object_detector = model.deploy(initial_instance_count = 1, instance_type = 'ml.m4.xlarge', endpoint_name = endpoint_name)
# defining the input content type. We will be sending images of jpeg format to the endpoint. object_detector.content_type = 'image/jpeg' 

Quando o terminal estiver em funcionamento, você deverá ver o InService status no Console do Amazon SageMaker. (Observe que o URL leva você ao console em us-east-1, onde fizemos a demonstração, mas o Amazon A2I está disponível em muitos outros Regiões. Certifique-se de mudar para a sua região.)

Para ver como é a detecção de objetos, digite o código a seguir. A classe prevista e a probabilidade de previsão são visualizadas, juntamente com a caixa delimitadora, usando as funções auxiliares visualize_detection e load_and_predict definido no caderno Jupyter que acompanha.

test_photos_index = ['980382', '276517', '1571457'] if not os.path.isdir('sample-a2i-images'): os.mkdir('sample-a2i-images') for ind in test_photos_index: !curl https://images.pexels.com/photos/{ind}/pexels-photo-{ind}.jpeg > sample-a2i-images/pexels-photo-{ind}.jpeg test_photos = ['sample-a2i-images/pexels-photo-980382.jpeg', # motorcycle 'sample-a2i-images/pexels-photo-276517.jpeg', # bicycle 'sample-a2i-images/pexels-photo-1571457.jpeg'] # sofa results, detection_filtered, f = load_and_predict(test_photos[1], object_detector, threshold=0.2) 

A captura de tela a seguir mostra a saída de uma imagem com um rótulo e uma caixa delimitadora.

Treinamos pouco esse modelo de SSD para fins de demonstração no caderno de treinamento para detecção de objetos. Embora o modelo identifique uma bicicleta na imagem, uma probabilidade de 0.245 é considerada baixa como uma previsão confiável na visão computacional moderna. Além disso, a localização do objeto não é muito precisa; a caixa delimitadora não cobre a roda dianteira e a sela. No entanto, esse modelo pouco treinado serve como um exemplo perfeito de trazer revisores humanos quando um modelo não faz uma previsão com alta confiança.

Etapa 2: criar um modelo de tarefa do trabalhador

Você pode usar o Amazon A2I para incorporar uma revisão humana a qualquer fluxo de trabalho de ML. Nesta postagem, para integrar o Amazon A2I ao terminal hospedado do Amazon SageMaker, você precisa criar uma tarefa personalizada. Ao usar um tipo de tarefa personalizado, você cria e inicia um loop humano usando a API do Amazon A2I Runtime para enviar os dados que requerem revisão usando um modelo de tarefa do trabalhador. Para mais informações, veja Use o Amazon Augmented AI com tipos de tarefas personalizadas.

Multidão de elementos HTML são componentes da web que fornecem vários widgets de tarefas e elementos de design que você pode adaptar à pergunta que deseja fazer. Você pode usar esses elementos de multidão para criar um modelo de trabalhador personalizado e integrá-lo a um fluxo de trabalho de revisão humana do Amazon A2I para personalizar o console e as instruções do trabalhador. Fornecemos mais de 60 modelos de tarefas personalizadas de amostra no GitHub repo que você pode usar como está ou como ponto de partida para personalizar seus próprios modelos. Para um caso de uso de detecção de objeto, o revisor normalmente precisa selecionar rótulos e desenhar caixas delimitadoras. Nesta postagem, você usa um dos modelos de tarefa de amostra, caixa delimitadora.liquid.html, do repositório e faça algumas personalizações. Este modelo inclui instruções de rotulagem, funcionalidade de rotulagem (desenhar, aumentar e diminuir o zoom e pesquisa de rótulos) e lê uma imagem de um determinado caminho do Amazon S3. Você também pode personalizar o modelo para exibir as caixas delimitadoras com um initial-value para que os trabalhadores possam começar com uma caixa delimitadora prevista pelo modelo de ML em vez de desenhar a caixa delimitadora do zero.

Esta etapa está disponível no caderno Jupyter que acompanha. Para criar um modelo de trabalhador personalizado no console do Amazon A2I, execute as seguintes etapas:

1. Navegar para Modelos de tarefas do trabalhador.
2. Escolha Criar modelo.
3. Escolha Nome do modelo, insira um nome exclusivo na região em sua conta; por exemplo, a2i-demo-object-detection-ui.
4. Escolha Tipo de modelo, escolha Personalizadas.
5. No Editor de modelos, insira os modelos HTML da tarefa de amostra em caixa delimitadora.liquid.html.
   1. Modifique o labels variável no editor de acordo com as classes incluídas no conjunto de dados PASCAL VOC e no modelo de detecção de objeto: ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat','chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person','pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
6. Escolha Crie.
   

Etapa 3: criar uma equipe de trabalho privada

Você pode rotear facilmente as análises para sua força de trabalho privada com o Amazon A2I. Você também pode acessar uma força de trabalho de mais de 500,000 contratados independentes que já estão executando tarefas relacionadas à ML através de Amazon Mechanical Turk. Como alternativa, se seus dados exigirem confidencialidade ou habilidades especiais, você poderá usar fornecedores de força de trabalho com experiência em projetos de revisão e pré-selecionados pela AWS para procedimentos de qualidade e segurança.

Qualquer que seja o tipo de força de trabalho que você escolher, o Amazon A2I se encarrega de enviar tarefas aos trabalhadores. Para esta postagem, você cria uma equipe de trabalho usando uma força de trabalho privada e se adiciona à equipe para visualizar o fluxo de trabalho do Amazon A2I.

Você cria e gerencia sua força de trabalho privada no Página Rotulando forças de trabalho no console do Amazon SageMaker. Ao seguir as instruções, você pode criar uma força de trabalho privada digitando e-mails de trabalhadores ou importando uma força de trabalho preexistente de um Amazon Cognito pool de usuários.

Se você já possui uma equipe de trabalho criada para o Amazon SageMaker Ground Truth, pode usar a mesma equipe de trabalho com o Amazon A2I e pular para a seção a seguir.

Esta etapa não está disponível no bloco de anotações Jupyter que o acompanha.

Para criar sua equipe de trabalho particular, execute as seguintes etapas:

1. No console do Amazon SageMaker, navegue até o Forças de trabalho de rotulagem
2. No Privado guia, escolha Criar equipe particular.
   
3. Escolha Convide novos funcionários por email.
4. Para esta postagem, digite seu endereço de e-mail para trabalhar nas tarefas de processamento de documentos.

Você pode inserir uma lista de até 50 endereços de e-mail, separados por vírgulas, no Endereço de email caixa.

5. Digite o nome da organização e o email de contato.
6. Escolha Criar equipe particular.
   

Depois de criar a equipe privada, você recebe um convite por email. A captura de tela a seguir mostra um exemplo de email.

Depois de clicar no link e alterar sua senha, você está registrado como um trabalhador verificado para esta equipe. A captura de tela a seguir mostra as informações atualizadas no Privado aba.

Sua equipe de uma pessoa está pronta e você pode criar um fluxo de trabalho de revisão humana.

Substituir 'SUA_EQUIPE DE TRABALHO_ARN' no caderno Jupyter que acompanha com o ARN da equipe de trabalho que você criou:

WORKTEAM_ARN = 'YOUR_WORKTEAM_ARN'

Etapa 4: criar um fluxo de trabalho de revisão humana

Um fluxo de trabalho de revisão humana também é chamado de definição de fluxo. Você usa a definição de fluxo para configurar sua equipe de trabalho humana e fornecer informações sobre como realizar a tarefa de revisão. Você pode usar uma definição de fluxo para criar vários loops humanos.

Esta etapa está disponível no caderno Jupyter que acompanha. Para fazer isso no console do Amazon A2I, execute as seguintes etapas:

1. Navegar ao Fluxos de trabalho de revisão humana
2. Escolha Criar fluxo de trabalho de revisão humana.
   
3. No Configurações de fluxo de trabalho seção, para Nome, insira um nome exclusivo para o fluxo de trabalho; por exemplo, a21-demo-1.
4. Escolha Caçamba S3, insira o intervalo S3 em que deseja armazenar os resultados da revisão humana.

O bucket deve estar localizado na mesma região que o fluxo de trabalho. Por exemplo, se você criar um bloco chamado a2i-demos, insira o caminho s3://a2i-demos/.

5. Escolha Papel do IAM, escolha Crie uma nova função No menu suspenso.

O Amazon A2I pode criar uma função automaticamente para você.

6. Escolha Depósitos S3 que você especificar, selecione Caçambas S3 específicas.
7. Digite o bucket S3 que você especificou anteriormente; por exemplo, a2i-demos.
8. Escolha Crie.
   

Você vê uma confirmação quando a criação da função é concluída e sua função agora é preenchida previamente no Papel do IAM menu suspenso.

9. Escolha Tipo de tarefa, selecione Personalizadas.
   

Nas próximas etapas, você seleciona o modelo de interface do usuário criado anteriormente.

10. No Modelo de tarefa do trabalhador seção, selecione Use seu próprio modelo.
11. Escolha Modelo, escolha o modelo que você criou.
12. Escolha Descrição da tarefa, insira uma breve descrição da tarefa.
    
13. No Trabalhadores seção, selecione Privado.
14. Escolha Equipas privadas, escolha a equipe de trabalho que você criou anteriormente.
15. Escolha Crie.
    

Você é redirecionado para o Fluxos de trabalho de revisão humana página e veja uma mensagem de confirmação semelhante à captura de tela a seguir.

Registre seu novo ARN de fluxo de trabalho de revisão humana, que você usa para configurar seu loop humano na próxima seção.

Etapa 5: chamar o ponto de extremidade do Amazon SageMaker

Agora que você configurou seu fluxo de trabalho de revisão humana do Amazon A2I, está pronto para ligar para o terminal de detecção de objetos no Amazon SageMaker e iniciar seus loops humanos. Para este caso de uso, você só deseja iniciar um loop humano se a maior pontuação de probabilidade de previsão retornada pelo seu modelo para objetos detectados for menor que 50% (SCORE_THREHOLD) Com um pouco de lógica (consulte o código a seguir), você pode verificar a resposta para cada chamada para o terminal do Amazon SageMaker usando o load_and_predict função auxiliar, e se a maior pontuação de probabilidade de previsão for menor que 50%, você cria um loop humano.

Você usa um loop humano para iniciar seu fluxo de trabalho de revisão humana. Quando um loop humano é acionado, as tarefas de revisão humana são enviadas aos trabalhadores, conforme especificado na definição de fluxo.

Esta etapa está disponível no caderno Jupyter que acompanha.

human_loops_started = []
SCORE_THRESHOLD = .50
for fname in test_photos: # Call SageMaker endpoint and not display any object detected with probability lower than 0.4. response, score_filtered, fig = load_and_predict(fname, object_detector, threshold=0.4) # Sort by prediction score so that the first item has the highest probability score_filtered.sort(key=lambda x: x[1], reverse=True) # Our condition for triggering a human review # if the highest probability is lower than the threshold, send it to human review # otherwise proceed to the next image if (score_filtered[0][1] < SCORE_THRESHOLD): s3_fname='s3://%s/a2i-results/%s' % (BUCKET, fname) print(s3_fname) humanLoopName = str(uuid.uuid4()) inputContent = { "initialValue": score_filtered[0][0], "taskObject": s3_fname # the s3 object will be passed to the worker task UI to render } # start an a2i human review loop with an input start_loop_response = a2i.start_human_loop( HumanLoopName=humanLoopName, FlowDefinitionArn=flowDefinitionArn, HumanLoopInput={ "InputContent": json.dumps(inputContent) } ) human_loops_started.append(humanLoopName) print(f'Object detection Confidence Score of %s is less than the threshold of %.2f' % (score_filtered[0][0], SCORE_THRESHOLD)) print(f'Starting human loop with name: {humanLoopName} n') else: print(f'Object detection Confidence Score of %s is above than the threshold of %.2f' % (score_filtered[0][0], SCORE_THRESHOLD)) print('No human loop created. n')

O código anterior usa uma instrução if-else simples, mas para condições dinâmicas, você também pode usar AWS Lambda avaliar se um objeto precisa de uma revisão humana. Ao decidir que uma revisão humana é necessária, você pode criar um loop humano usando a2i.start_human_loop.

Etapa 6: concluindo uma revisão humana

Depois de enviar as imagens com baixa probabilidade de previsão para o Amazon A2I via start_human_loop chamada, você ou a pessoa designada como revisor pode fazer login no portal de etiquetas para revisar as imagens. Você pode encontrar o URL no console do Amazon SageMaker, no Privado guia do Rotular a força de trabalho página. Você também pode recuperar programaticamente o URL com o seguinte código:

print('https://' + sagemaker_client.describe_workteam(WorkteamName=workteamName)['Workteam']['SubDomain'])

Para esta postagem, nome da equipe de trabalho is a2i-demo-1.

Para concluir uma revisão humana, execute as seguintes etapas:

1. Ao navegar para o portal, você será solicitado a fazer login com seu nome de usuário e senha (se for a primeira vez que você acessa o portal, é necessário criar uma nova senha).

Você pode ver um novo emprego para você no Empregos seção.

2. Escolha Demonstração a2i de detecção de objetos.
3. Escolha Comece a trabalhar.

A página contém um painel de instruções personalizável, a imagem e os rótulos disponíveis.

4. Na barra de ferramentas, escolha Caixa.
5. Debaixo Rótulos, escolha bicicleta.
6. Desenhe sua caixa delimitadora em torno do objeto.
7. Escolha Submeter.

Depois de concluir todas as revisões de imagem, você pode analisar a saída do loop humano. O Amazon A2I armazena os resultados no seu bucket S3 e envia a você um Amazon CloudWatch evento.

Seus resultados devem estar disponíveis no caminho de saída do Amazon S3 especificado na definição de fluxo de trabalho de revisão humana quando todo o trabalho estiver concluído. A resposta humana, o rótulo e a caixa delimitadora são retornados e salvos no arquivo JSON. O código a seguir mostra um arquivo JSON de saída do Amazon A2I de amostra:

{'flowDefinitionArn': 'arn:aws:sagemaker:us-east-1:xxxxxxxx:flow-definition/fd-sagemaker-object-detection-demo-2020-05-01-18-08-47', 'humanAnswers': [{'answerContent': { 'annotatedResult': { 'boundingBoxes': [{'height': 1801, 'label': 'bicycle', 'left': 1042, 'top': 627, 'width': 2869}], 'inputImageProperties': {'height': 2608, 'width': 3911}}}, 'submissionTime': '2020-05-01T18:24:53.742Z', 'workerId': 'xxxxxxxxxx'}], 'humanLoopName': 'xxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxxx', 'inputContent': {'initialValue': 'bicycle', 'taskObject': 's3://sagemaker-us-east-1-xxxxxxx/a2i-results/sample-a2i-images/pexels-photo-276517.jpeg'}}

Você pode recuperar essas informações e analisá-las para análises adicionais. Na próxima etapa, mostraremos como usar esses dados revisados ​​por humanos para a próxima iteração de reciclagem do seu modelo.

Etapa 7: Processando a Saída JSON para Treinamento Incremental

No caderno de treinamento para detecção de objetos, você usou o algoritmo de detecção de objetos integrado do Amazon SageMaker para treinar a primeira versão do modelo. Você usou o modelo para gerar previsões em algumas imagens aleatórias fora da amostra e obteve uma previsão insatisfatória (baixa probabilidade). Você também usou o Amazon A2I para revisar e rotular a imagem com base em seus critérios personalizados (limite de pontuação de confiança <50%). A próxima etapa em um ciclo de vida típico de ML é incluir os casos com os quais o modelo teve problemas no próximo lote de dados de treinamento para fins de retreinamento. Dessa forma, o modelo pode aprender com um conjunto de novos dados de treinamento para melhoria contínua. Em ML, isso é chamado treinamento incremental.

Esta etapa está disponível no caderno Jupyter que acompanha.

Você pode fornecer os dados da imagem e a anotação para o algoritmo de detecção de objeto de três maneiras diferentes. Para mais informações, veja Interface de entrada / saída para o algoritmo de detecção de objetos. Para este post, treinamos nosso modelo original com o Formato RecordIO porque convertemos as imagens e anotações do PASCAL VOC no formato RecordIO. Para obter instruções sobre como criar dados RecordIO personalizados, consulte Preparar conjuntos de dados personalizados para detecção de objetos.

Como alternativa, o algoritmo de detecção de objeto também aceita um arquivo JSON como entrada. Você pode criar um arquivo JSON por imagem ou tirar vantagem de Modo de tubo usando um manifesto aumentado arquivo como o formato de entrada. O modo Pipe acelera o tempo geral de treinamento do modelo em até 35%, transmitindo os dados para o algoritmo de treinamento enquanto ele está sendo executado, em vez de copiar dados para o Loja de blocos elásticos da Amazon (Amazon EBS) anexado à instância de treinamento. Você pode construir um arquivo de manifesto aumentado a partir da saída do Amazon A2I com o seguinte código:

object_categories_dict = {str(i): j for i, j in enumerate(object_categories)} def convert_a2i_to_augmented_manifest(a2i_output): annotations = [] confidence = [] for i, bbox in enumerate(a2i_output['humanAnswers'][0]['answerContent']['annotatedResult']['boundingBoxes']): object_class_key = [key for (key, value) in object_categories_dict.items() if value == bbox['label']][0] obj = {'class_id': int(object_class_key), 'width': bbox['width'], 'top': bbox['top'], 'height': bbox['height'], 'left': bbox['left']} annotations.append(obj) confidence.append({'confidence': 1}) augmented_manifest={'source-ref': a2i_output['inputContent']['taskObject'], 'a2i-retraining': {'annotations': annotations, 'image_size': [{'width': a2i_output['humanAnswers'][0]['answerContent']['annotatedResult']['inputImageProperties']['width'], 'depth':3, 'height': a2i_output['humanAnswers'][0]['answerContent']['annotatedResult']['inputImageProperties']['height']}]}, 'a2i-retraining-metadata': {'job-name': 'a2i/%s' % a2i_output['humanLoopName'], 'class-map': object_categories_dict, 'human-annotated':'yes', 'objects': confidence, 'creation-date': a2i_output['humanAnswers'][0]['submissionTime'], 'type':'groundtruth/object-detection'}} return augmented_manifest

Isso resulta em um objeto JSON como o código a seguir, compatível com a maneira como o Ground Truth gera o resultado e como o algoritmo de detecção de objeto interno do SageMaker espera a entrada:

{ 'source-ref': 's3://sagemaker-us-east-1-xxxxxxx/a2i-results/sample-a2i-images/pexels-photo-276517.jpeg', 'a2i-retraining': { 'annotations': [ { 'class_id': 1, 'height': 1801, 'left': 1042, 'top': 627, 'width': 2869}], 'image_size': [ { 'depth': 3, 'height': 2608, 'width': 3911}]}, 'a2i-retraining-metadata': { 'class-map': { '0': 'aeroplane', '1': 'bicycle', '2': 'bird', '3': 'boat', '4': 'bottle', '5': 'bus', '6': 'car', '7': 'cat', '8': 'chair', '9': 'cow' '10': 'diningtable', '11': 'dog', '12': 'horse', '13': 'motorbike', '14': 'person', '15': 'pottedplant', '16': 'sheep', '17': 'sofa', '18': 'train', '19': 'tvmonitor',}, 'creation-date': '2020-05-01T18:24:53.742Z', 'human-annotated': 'yes', 'job-name': 'a2i/fc3cea7e-ead8-4c5c-b52d-166ff6147ff0', 'objects': [{'confidence': 1}], 'type': 'groundtruth/object-detection'}}

O código anterior é apenas uma imagem. Para criar uma coorte de imagens de treinamento de todas as imagens rotuladas novamente por revisores humanos no console do Amazon A2I, você pode percorrer toda a saída do Amazon A2I, converter o arquivo JSON e concatená-los em um arquivo JSON Lines, com cada linha representa os resultados de uma imagem. Veja o seguinte código:

with open('augmented.manifest', 'w') as outfile: for resp in completed_human_loops: # completed_human_loops contains a list of responses from a2i.describe_human_loop() calls splitted_string = re.split('s3://' + BUCKET + '/', resp['HumanLoopOutput']['OutputS3Uri']) output_bucket_key = splitted_string[1] response = s3.get_object(Bucket=BUCKET, Key=output_bucket_key) content = response["Body"].read() json_output = json.loads(content) augmented_manifest = convert_a2i_to_augmented_manifest(json_output) json.dump(augmented_manifest, outfile) outfile.write('n')
!head -n2 augmented.manifest
{"source-ref": "s3://sagemaker-us-east-1-xxxxxxx/a2i-results/sample-a2i-images/pexels-photo-276517.jpeg", "a2i-retraining": {"annotations": [{"class_id": 1, "width": 2869, "top": 627, "height": 1801, "left": 1042}], "image_size": [{"width": 3911, "depth": 3, "height": 2608}]}, "a2i-retraining-metadata": {"job-name": "a2i/fc3cea7e-ead8-4c5c-b52d-166ff6147ff0", "class-map": {"0": "aeroplane", "1": "bicycle", "2": "bird", "3": "boat", "4": "bottle", "5": "bus", "6": "car", "7": "cat", "8": "chair", "9": "cow", "10": "diningtable", "11": "dog", "12": "horse", "13": "motorbike", "14": "person", "15": "pottedplant", "16": "sheep", "17": "sofa", "18": "train", "19": "tvmonitor"}, "human-annotated": "yes", "objects": [{"confidence": 1}], "creation-date": "2020-05-21T18:36:33.834Z", "type": "groundtruth/object-detection"}}
{"source-ref": "s3://sagemaker-us-east-1-xxxxxxx/a2i-results/sample-a2i-images/pexels-photo-1571457.jpeg", "a2i-retraining": {"annotations": [{"class_id": 17, "width": 1754, "top": 1285, "height": 1051, "left": 657}], "image_size": [{"width": 3500, "depth": 3, "height": 2336}]}, "a2i-retraining-metadata": {"job-name": "a2i/8241d6e4-8078-4036-b065-ccdd5ebf955f", "class-map": {"0": "aeroplane", "1": "bicycle", "2": "bird", "3": "boat", "4": "bottle", "5": "bus", "6": "car", "7": "cat", "8": "chair", "9": "cow", "10": "diningtable", "11": "dog", "12": "horse", "13": "motorbike", "14": "person", "15": "pottedplant", "16": "sheep", "17": "sofa", "18": "train", "19": "tvmonitor"}, "human-annotated": "yes", "objects": [{"confidence": 1}], "creation-date": "2020-05-21T18:36:22.268Z", "type": "groundtruth/object-detection"}}

Depois de coletar pontos de dados suficientes, você pode construir um novo Estimator para treinamento incremental. Para mais informações, veja Treine facilmente modelos usando conjuntos de dados rotulados pelo Amazon SageMaker Ground Truth. Neste blog, usamos os hiperparâmetros exatamente da mesma forma como o primeiro modelo foi treinado no caderno de treinamento para detecção de objetos, com a exceção de usar os pesos do modelo treinado em vez dos pesos pré-treinados que acompanham o algoritmo (use_pretrained_model=0).

O exemplo de código a seguir demonstra treinamento incremental com um ou dois novos exemplos. Como analisamos apenas duas imagens neste post, isso não gera um modelo com melhorias significativas.

s3_train_data = 's3://bucket/path/to/training/augmented.manifest'
s3_validation_data = 's3://bucket/path/to/validation/augmented.manifest'
s3_output_location = 's3://bucket/path/to/incremental-training/'
num_training_samples = 1234 from sagemaker.amazon.amazon_estimator import get_image_uri
training_image = get_image_uri(region, 'object-detection', repo_version='latest') # Create a model object set to using "Pipe" mode because we are inputing augmented manifest files.
new_od_model = sagemaker.estimator.Estimator(training_image, role, train_instance_count=1, train_instance_type='ml.p3.2xlarge', train_volume_size = 50, train_max_run = 360000, input_mode = 'Pipe', output_path=s3_output_location, sagemaker_session=sess) # the hyperparameters are the same from how the original model is trained new_od_model.set_hyperparameters(base_network='resnet-50', use_pretrained_model=0, num_classes=20, mini_batch_size=32, epochs=1, lr_scheduler_step='3,6', lr_scheduler_factor=0.1, optimizer='sgd', momentum=0.9, weight_decay=0.0005, overlap_threshold=0.5, nms_threshold=0.45, image_shape=300, label_width=350, num_training_samples=num_training_samples) train_data = sagemaker.session.s3_input(s3_train_data, distribution='FullyReplicated', content_type='application/x-recordio', record_wrapping='RecordIO', s3_data_type='AugmentedManifestFile', attribute_names=['source-ref', 'a2i-retraining'])
validation_data = sagemaker.session.s3_input(s3_validation_data, distribution='FullyReplicated', content_type='application/x-recordio', record_wrapping='RecordIO', s3_data_type='AugmentedManifestFile', attribute_names=['source-ref', 'a2i-retraining'])
# Use the output model from the previous job. model_data = sagemaker.session.s3_input(model_data_s3_uri, distribution='FullyReplicated', content_type='application/x-sagemaker-model', s3_data_type='S3Prefix', input_mode = 'File') data_channels = {'train': train_data, 'validation': validation_data, 'model': model_data} new_od_model.fit(inputs=data_channels, logs=True)

Após o treinamento, você obtém um novo modelo no s3_output_location. Você pode implantar esse modelo em um novo terminal de inferência ou atualizar um terminal existente. Não há perda de disponibilidade quando você atualiza um terminal existente. Para atualizar um terminal, é necessário fornecer uma nova configuração de terminal. Para mais informações, veja Ponto final de atualização.

Limpando

Para evitar incorrer em cobranças futuras, exclua recursos como o terminal Amazon SageMaker, a instância do notebook e os artefatos de modelo no Amazon S3 quando não estiverem em uso.

Conclusão

Esta postagem apenas arranhou a superfície do que o Amazon A2I pode fazer em um ciclo de vida típico de ML. Demonstramos como configurar tudo o que você precisa para ter um humano em funcionamento na estrutura do loop: uma interface de modelo de tarefa de trabalhador do Amazon A2I, um fluxo de trabalho de revisão humana e uma equipe de trabalho. Também mostramos como disparar um loop humano do Amazon A2I programaticamente após um ponto de extremidade de detecção de objeto hospedado do Amazon SageMaker retornar uma inferência de baixa confiança. Por fim, orientamos você sobre como trabalhar com o arquivo JSON de saída Amazon A2I para criar um novo lote de dados de treinamento em um formato de manifesto aumentado para treinamento incremental usando o algoritmo de detecção de objeto integrado do Amazon SageMaker.

Para apresentações em vídeo, amostra de blocos de anotações Jupyter ou mais informações sobre casos de uso, como processamento de documentos, moderação de conteúdo, análise de sentimentos, tradução de texto e outros, consulte Recursos de IA aumentada da Amazon.

Referências

• Everingham, Mark, et al. "O desafio das classes de objetos visuais pascal: uma retrospectiva." Revista internacional de visão computacional 111.1 (2015): 98-136.
• Liu, Wei e outros. “SSD: detector multibox de captura única.” Conferência europeia sobre visão computacional. Springer, Cham, 2016.

Sobre os autores

Michael Hsieh é o arquiteto sênior de soluções especializadas em AI / ML. Ele trabalha com os clientes para avançar na jornada de ML com uma combinação de ofertas da AWS ML e seu conhecimento de domínio de ML. Como transplante de Seattle, ele adora explorar a grande mãe natureza que a cidade tem a oferecer, como trilhas para caminhadas, passeios de caiaque na SLU e o pôr do sol na Baía Shilshole.

Anuj Gupta é gerente de produto sênior da Amazon Augmented AI. Ele se concentra no fornecimento de produtos que facilitam a adoção de aprendizado de máquina pelos clientes. Nas horas vagas, ele gosta de viajar e assistir à Fórmula 1.

Fonte: https://aws.amazon.com/blogs/machine-learning/object-detection-and-model-retraining-with-amazon-sagemaker-and-amazon-augmented-ai/