Pipeline de aumento de imagem para o Amazon Lookout for Vision

Amazon Lookout para Visão fornece um serviço de detecção de anomalias baseado em aprendizado de máquina (ML) para identificar imagens normais (ou seja, imagens de objetos sem defeitos) vs imagens anômalas (ou seja, imagens de objetos de defeitos), tipos de anomalias (por exemplo, falta de peça) e a localização dessas anomalias. Portanto, o Lookout for Vision é popular entre os clientes que buscam soluções automatizadas para inspeção de qualidade industrial (por exemplo, detecção de produtos anormais). No entanto, os conjuntos de dados dos clientes geralmente enfrentam dois problemas:

1. O número de imagens com anomalias pode ser muito baixo e pode não atingir o mínimo de anomalias/defeitos imposto pelo Lookout for Vision (~20).
2. As imagens normais podem não ter diversidade suficiente e podem resultar na falha do modelo quando as condições ambientais, como a iluminação, mudam na produção

Para superar esses problemas, este post apresenta um pipeline de aumento de imagem que visa ambos os problemas: Ele fornece uma maneira de gerar imagens anômalas sintéticas removendo objetos em imagens e gera imagens normais adicionais introduzindo aumento controlado, como ruído gaussiano, matiz, saturação, pixel escala de valor, etc. Usamos o imagem biblioteca para introduzir aumento para gerar imagens anômalas e normais adicionais para o segundo problema. Nós usamos Verdade fundamental do Amazon Sagemaker para gerar máscaras de remoção de objetos e o Lama algoritmo para remover objetos para o primeiro problema usando técnicas de pintura interna de imagens (remoção de objetos).

O restante do post está organizado da seguinte forma. Na Seção 3, apresentamos o pipeline de aumento de imagem para imagens normais. Na Seção 4, apresentamos o pipeline de aumento de imagem para imagens anormais (também conhecidas como geração de defeitos sintéticos). A Seção 5 ilustra os resultados do treinamento Lookout for Vision usando o conjunto de dados aumentado. A Seção 6 demonstra como o modelo Lookout for Vision treinado em dados sintéticos funciona em relação a defeitos reais. Na Seção 7, falamos sobre estimativa de custo para esta solução. Todo o código que usamos para este post pode ser acessado SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

1. Visão geral da solução

Diagrama ML

Veja a seguir o diagrama do pipeline de aumento de imagem proposto para o treinamento do modelo de localização de anomalias Lookout for Vision:

O diagrama acima começa coletando uma série de imagens (etapa 1). Aumentamos o conjunto de dados aumentando as imagens normais (etapa 3) e usando algoritmos de remoção de objetos (etapas 2, 5-6). Em seguida, empacotamos os dados em um formato que pode ser consumido pelo Amazon Lookout for Vision (etapas 7 a 8). Por fim, na etapa 9, usamos os dados empacotados para treinar um modelo de localização do Lookout for Vision.

Esse pipeline de aumento de imagem oferece aos clientes flexibilidade para gerar defeitos sintéticos no conjunto de dados de amostra limitado, além de adicionar mais quantidade e variedade a imagens normais. Isso aumentaria o desempenho do serviço Lookout for Vision, resolvendo o problema de falta de dados do cliente e tornando o processo de inspeção de qualidade automatizado mais suave.

2. Preparação de dados

Daqui até o final do post, usamos o public FICS-PCB: Um Conjunto de Dados de Imagem Multimodal para Inspeção Visual de Placa de Circuito Impresso Automatizado conjunto de dados licenciado sob um Licença Creative Commons Atribuição 4.0 Internacional (CC BY 4.0) para ilustrar o pipeline de aumento de imagem e o consequente treinamento e teste do Lookout for Vision. Este conjunto de dados foi projetado para oferecer suporte à avaliação de sistemas automatizados de inspeção visual de PCB. Ele foi coletado no laboratório SeCurity and AssuraNce (SCAN) da Universidade da Flórida. Ele pode ser acessado SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

Começamos com a hipótese de que o cliente fornece apenas uma única imagem normal de uma placa PCB (uma amostra de PCB s10) como conjunto de dados. Ele pode ser visto a seguir:

3. Aumento de imagem para imagens normais

O serviço Lookout for Vision requer pelo menos 20 imagens normais e 20 anomalias por tipo de defeito. Como há apenas uma imagem normal dos dados de amostra, devemos gerar mais imagens normais usando técnicas de aumento de imagem. Do ponto de vista do ML, alimentar várias transformações de imagem usando diferentes técnicas de aumento pode melhorar a precisão e a robustez do modelo.

Vamos usar imagem para aumento de imagem de imagens normais. Imgaug é um pacote python de código aberto que permite aumentar imagens em experimentos de ML.

Primeiro vamos instalar o imagem biblioteca em um Amazon Sage Maker notebook.

pip install imgaug

Em seguida, podemos instalar o pacote python chamado 'IPyPlot'.

pip install ipyplot

Em seguida, realizamos o aumento da imagem original usando transformações, incluindo GammaContrast, SigmoidContrast e LinearContrast, e adicionando ruído gaussiano na imagem.

import imageio
import imgaug as ia
import imgaug.augmenters as iaa
import ipyplot
input_img = imageio.imread('s10.png')
noise=iaa.AdditiveGaussianNoise(10,40)
input_noise=noise.augment_image(input_img)
contrast=iaa.GammaContrast((0.5, 2.0))
contrast_sig = iaa.SigmoidContrast(gain=(5, 10), cutoff=(0.4, 0.6))
contrast_lin = iaa.LinearContrast((0.6, 0.4))
input_contrast = contrast.augment_image(input_img)
sigmoid_contrast = contrast_sig.augment_image(input_img)
linear_contrast = contrast_lin.augment_image(input_img)
images_list=[input_img, input_contrast,sigmoid_contrast,linear_contrast,input_noise]
labels = ['Original', 'Gamma Contrast','SigmoidContrast','LinearContrast','Gaussian Noise Image']
ipyplot.plot_images(images_list,labels=labels,img_width=180)

Como precisamos de pelo menos 20 imagens normais, e quanto mais, melhor, geramos 10 imagens aumentadas para cada uma das 4 transformações mostradas acima como nosso conjunto de dados de imagem normal. No futuro, planejamos também transformar as imagens para serem posicionadas em diferentes locais e diferentes ângulos para que o modelo treinado seja menos sensível ao posicionamento do objeto em relação à câmera fixa.

4. Geração de defeitos sintéticos para aumento de imagens anormais

Nesta seção, apresentamos um pipeline sintético de geração de defeitos para aumentar o número de imagens com anomalias no conjunto de dados. Observe que, ao contrário da seção anterior, onde criamos novas amostras normais a partir de amostras normais existentes, aqui criamos novas imagens de anomalias a partir de amostras normais. Este é um recurso atraente para clientes que não possuem esse tipo de imagem em seus conjuntos de dados, por exemplo, removendo um componente da placa PCB normal. Esse pipeline de geração de defeitos sintéticos tem três etapas: primeiro, geramos máscaras sintéticas a partir de imagens de origem (normais) usando o Amazon SageMaker Ground Truth. Nesta postagem, focamos em um tipo de defeito específico: componente ausente. Essa geração de máscara fornece uma imagem de máscara e um arquivo de manifesto. Em segundo lugar, o arquivo de manifesto deve ser modificado e convertido em um arquivo de entrada para um terminal SageMaker. E, terceiro, o arquivo de entrada é inserido em um endpoint SageMaker de remoção de objeto responsável por remover as partes da imagem normal indicadas pela máscara. Este endpoint fornece a imagem anormal resultante.

4.1 Gerar máscaras de defeitos sintéticos usando o Amazon SageMaker Ground Truth

Amazon Sagemaker Ground Truth para rotulagem de dados

O Amazon SageMaker Ground Truth é um serviço de rotulagem de dados que facilita rotular dados e oferece a opção de usar anotadores humanos por meio de Amazon Mechanical Turk, fornecedores terceirizados ou sua própria força de trabalho privada. você pode seguir Neste tutorial para configurar um trabalho de rotulagem.

Nesta seção, mostraremos como usamos Verdade no solo do Amazon SageMaker para marcar “componentes” específicos em imagens normais a serem removidos na próxima etapa. Observe que uma contribuição importante desta postagem é que não usamos o Amazon SageMaker Ground Truth da maneira tradicional (ou seja, para rotular imagens de treinamento). Aqui, usamos para gerar uma máscara para futura remoção em imagens normais. Essas remoções em imagens normais irão gerar os defeitos sintéticos.

Para o propósito desta postagem, em nosso trabalho de rotulagem, removeremos artificialmente até três componentes da placa PCB: IC, resistor1 e resistor2. Depois de inserir o trabalho de rotulagem como rotulador, você pode selecionar o nome da etiqueta e desenhar uma máscara de qualquer formato ao redor do componente que deseja remover da imagem como um defeito sintético. Observe que você não pode incluir '_' no nome do rótulo para este experimento, pois usamos '_' para separar metadados diferentes no nome do defeito posteriormente no código.

Na figura a seguir, desenhamos uma máscara verde ao redor do CI (Circuito Integrado), uma máscara azul ao redor do resistor 1 e uma máscara laranja ao redor do resistor 2.

Depois de selecionarmos o enviar botão, o Amazon SageMaker Ground Truth gerará uma máscara de saída com fundo branco e um arquivo de manifesto da seguinte forma:

{"source-ref":"s3://pcbtest22/label/s10.png","s10-label-ref":"s3://pcbtest22/label/s10-label/annotations/consolidated-annotation/output/0_2022-09-08T18:01:51.334016.png","s10-label-ref-metadata":{"internal-color-map":{"0":{"class-name":"BACKGROUND","hex-color":"#ffffff","confidence":0},"1":{"class-name":"IC","hex-color":"#2ca02c","confidence":0},"2":{"class-name":"resistor_1","hex-color":"#1f77b4","confidence":0},"3":{"class-name":"resistor_2","hex-color":"#ff7f0e","confidence":0}},"type":"groundtruth/semantic-segmentation","human-annotated":"yes","creation-date":"2022-09-08T18:01:51.498525","job-name":"labeling-job/s10-label"}}

Observe que até agora não geramos nenhuma imagem anormal. Acabamos de marcar os três componentes que serão removidos artificialmente e cuja remoção gerará imagens anormais. Posteriormente, usaremos (1) a imagem de máscara acima e (2) as informações do arquivo de manifesto como entradas para o pipeline de geração de imagem anormal. A próxima seção mostra como preparar a entrada para o terminal SageMaker.

4.2 Preparar a entrada para o endpoint do SageMaker

Transforme o manifesto do Amazon SageMaker Ground Truth em um arquivo de entrada de endpoint do SageMaker

Primeiro, montamos um Serviço de armazenamento simples da Amazon (Amazon S3) bucket para armazenar todas as entradas e saídas do pipeline de aumento de imagem. No post, usamos um bucket S3 chamado qualityinspection. Em seguida, geramos todas as imagens normais aumentadas e as carregamos neste balde S3.

from PIL import Image 
import os 
import shutil 
import boto3

s3=boto3.client('s3')

# make the image directory
dir_im="images"
if not os.path.isdir(dir_im):
    os.makedirs(dir_im)
# create augmented images from original image
input_img = imageio.imread('s10.png')

for i in range(10):
    noise=iaa.AdditiveGaussianNoise(scale=0.2*255)
    contrast=iaa.GammaContrast((0.5,2))
    contrast_sig = iaa.SigmoidContrast(gain=(5,20), cutoff=(0.25, 0.75))
    contrast_lin = iaa.LinearContrast((0.4,1.6))
      
    input_noise=noise.augment_image(input_img)
    input_contrast = contrast.augment_image(input_img)
    sigmoid_contrast = contrast_sig.augment_image(input_img)
    linear_contrast = contrast_lin.augment_image(input_img)
      
    im_noise = Image.fromarray(input_noise)
    im_noise.save(f'{dir_im}/input_noise_{i}.png')

    im_input_contrast = Image.fromarray(input_contrast)
    im_input_contrast.save(f'{dir_im}/contrast_sig_{i}.png')

    im_sigmoid_contrast = Image.fromarray(sigmoid_contrast)
    im_sigmoid_contrast.save(f'{dir_im}/sigmoid_contrast_{i}.png')

    im_linear_contrast = Image.fromarray(linear_contrast)
    im_linear_contrast.save(f'{dir_im}/linear_contrast_{i}.png')
    
# move original image to image augmentation folder
shutil.move('s10.png','images/s10.png')
# list all the images in the image directory
imlist =  [file for file in os.listdir(dir_im) if file.endswith('.png')]

# upload augmented images to an s3 bucket
s3_bucket='qualityinspection'
for i in range(len(imlist)):
    with open('images/'+imlist[i], 'rb') as data:
        s3.upload_fileobj(data, s3_bucket, 'images/'+imlist[i])

# get the image s3 locations
im_s3_list=[]
for i in range(len(imlist)):
    image_s3='s3://qualityinspection/images/'+imlist[i]
    im_s3_list.append(image_s3)

Em seguida, baixamos a máscara do Amazon SageMaker Ground Truth e a carregamos em uma pasta chamada 'mask' nesse bucket do S3.

# download Ground Truth annotation mask image to local from the Ground Truth s3 folder
s3.download_file('pcbtest22', 'label/S10-label3/annotations/consolidated-annotation/output/0_2022-09-09T17:25:31.918770.png', 'mask.png')
# upload mask to mask folder
s3.upload_file('mask.png', 'qualityinspection', 'mask/mask.png')

Depois disso, baixamos o arquivo de manifesto do trabalho de rotulagem do Amazon SageMaker Ground Truth e o lemos como linhas json.

import json
#download output manifest to local
s3.download_file('pcbtest22', 'label/S10-label3/manifests/output/output.manifest', 'output.manifest')
# read the manifest file
with open('output.manifest','rt') as the_new_file:
    lines=the_new_file.readlines()
    for line in lines:
        json_line = json.loads(line)

Por fim, geramos um dicionário de entrada que registra a localização S3 da imagem de entrada, a localização da máscara, as informações da máscara etc., salvamos como arquivo txt e, em seguida, carregamos na pasta 'input' do bucket S3 de destino.

# create input dictionary
input_dat=dict()
input_dat['input-image-location']=im_s3_list
input_dat['mask-location']='s3://qualityinspection/mask/mask.png'
input_dat['mask-info']=json_line['S10-label3-ref-metadata']['internal-color-map']
input_dat['output-bucket']='qualityinspection'
input_dat['output-project']='synthetic_defect'

# Write the input as a txt file and upload it to s3 location
input_name='input.txt'
with open(input_name, 'w') as the_new_file:
    the_new_file.write(json.dumps(input_dat))
s3.upload_file('input.txt', 'qualityinspection', 'input/input.txt')

O seguinte é um arquivo de entrada de amostra:

{"input-image-location": ["s3://qualityinspection/images/s10.png", ... "s3://qualityinspection/images/contrast_sig_1.png"], "mask-location": "s3://qualityinspection/mask/mask.png", "mask-info": {"0": {"class-name": "BACKGROUND", "hex-color": "#ffffff", "confidence": 0}, "1": {"class-name": "IC", "hex-color": "#2ca02c", "confidence": 0}, "2": {"class-name": "resistor1", "hex-color": "#1f77b4", "confidence": 0}, "3": {"class-name": "resistor2", "hex-color": "#ff7f0e", "confidence": 0}}, "output-bucket": "qualityinspection", "output-project": "synthetic_defect"}

4.3 Criar endpoint assíncrono do SageMaker para gerar defeitos sintéticos com componentes ausentes

4.3.1 Modelo LaMa

Para remover componentes da imagem original, estamos usando um modelo PyTorch de código aberto chamado LaMa de LaMa: pintura interna de máscara grande com resolução robusta e convoluções de Fourier. É um modelo de pintura em máscara grande com resolução robusta com convoluções de Fourier desenvolvido pela Samsung AI. As entradas para o modelo são uma imagem e uma máscara em preto e branco e a saída é uma imagem com os objetos dentro da máscara removidos. Usamos o Amazon SageMaker Ground Truth para criar a máscara original e, em seguida, transformá-la em uma máscara em preto e branco, conforme necessário. A aplicação do modelo LaMa é demonstrada da seguinte forma:

4.3.2 Introdução à inferência assíncrona do Amazon SageMaker 

Inferência assíncrona do Amazon SageMaker é uma nova opção de inferência em Amazon Sage Maker que enfileira as solicitações recebidas e as processa de forma assíncrona. A inferência assíncrona permite que os usuários economizem custos dimensionando automaticamente a contagem de instâncias para zero quando não há solicitações para processar. Isso significa que você paga apenas quando seu endpoint está processando solicitações. A nova opção de inferência assíncrona é ideal para cargas de trabalho em que os tamanhos de solicitação são grandes (até 1 GB) e os tempos de processamento de inferência são da ordem de minutos. O código para implantar e invocar o endpoint é SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

4.3.3 Implantação de endpoint

Para implantar o endpoint assíncrono, primeiro devemos obter o Papel do IAM e configurar algumas variáveis ​​de ambiente.

from sagemaker import get_execution_role
from sagemaker.pytorch import PyTorchModel
import boto3

role = get_execution_role()
env = dict()
env['TS_MAX_REQUEST_SIZE'] = '1000000000'
env['TS_MAX_RESPONSE_SIZE'] = '1000000000'
env['TS_DEFAULT_RESPONSE_TIMEOUT'] = '1000000'
env['DEFAULT_WORKERS_PER_MODEL'] = '1'

Como mencionamos antes, estamos usando o modelo PyTorch de código aberto LaMa: pintura interna de máscara grande com resolução robusta e convoluções de Fourier e o modelo pré-treinado foi carregado para s3://qualityinspection/model/big-lama.tar.gz. O image_uri aponta para um contêiner docker com a estrutura necessária e as versões do python.

model = PyTorchModel(
    entry_point="./inference_defect_gen.py",
    role=role,
    source_dir = './',
    model_data='s3://qualityinspection/model/big-lama.tar.gz',
    image_uri = '763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-inference:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker',
    framework_version="1.7.1",
    py_version="py3",
    env = env,
    model_server_workers=1
)

Em seguida, devemos especificar parâmetros de configuração específicos de inferência assíncrona adicionais ao criar a configuração do terminal.

from sagemaker.async_inference.async_inference_config import AsyncInferenceConfig
bucket = 'qualityinspection'
prefix = 'async-endpoint'
async_config = AsyncInferenceConfig(output_path=f"s3://{bucket}/{prefix}/output",max_concurrent_invocations_per_instance=10)

Em seguida, implantamos o endpoint em uma instância ml.g4dn.xlarge executando o seguinte código:

predictor = model.deploy(
    initial_instance_count=1,
    instance_type='ml.g4dn.xlarge',
    model_server_workers=1,
    async_inference_config=async_config
)

Após aproximadamente 6 a 8 minutos, o endpoint é criado com sucesso e aparecerá no console do SageMaker.

4.3.4 Chamar o endpoint

Em seguida, usamos o arquivo txt de entrada que geramos anteriormente como entrada do endpoint e invocamos o endpoint usando o seguinte código:

import boto3
runtime= boto3.client('runtime.sagemaker')
response = runtime.invoke_endpoint_async(EndpointName='pytorch-inference-2022-09-16-02-04-37-888',
                                   InputLocation='s3://qualityinspection/input/input.txt')

O comando acima terminará a execução imediatamente. No entanto, a inferência continuará por vários minutos até concluir todas as tarefas e retornar todas as saídas no bucket do S3.

4.3.5 Verifique o resultado da inferência do endpoint 

Depois de selecionar o endpoint, você verá a sessão Monitor. Selecione 'Exibir logs' para verificar os resultados da inferência no console.

Dois registros de log serão exibidos nos fluxos de log. Aquele chamado data-log mostrará o resultado final da inferência, enquanto o outro registro de log mostrará os detalhes da inferência, que geralmente é usado para fins de depuração.

Se a solicitação de inferência for bem-sucedida, você verá a mensagem: Inference request succeeded.no registro de dados e também obter informações da latência total do modelo, tempo total do processo, etc. na mensagem. Se a inferência falhar, verifique o outro log para depurar. Você também pode verificar o resultado pesquisando o status da solicitação de inferência. Saiba mais sobre a inferência assíncrona do Amazon SageMaker SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

4.3.6 Gerando defeitos sintéticos com componentes ausentes usando o endpoint

Concluiremos quatro tarefas no endpoint:

1. O serviço de localização de anomalias Lookout for Vision requer um defeito por imagem no conjunto de dados de treinamento para otimizar o desempenho do modelo. Portanto, devemos separar as máscaras para diferentes defeitos no endpoint por filtragem de cores.
   
2. Divida o conjunto de dados de treinamento/teste para atender ao seguinte requisito:
   • pelo menos 10 imagens normais e 10 anomalias para conjunto de dados de trem
   • um defeito/imagem no conjunto de dados do trem
   • pelo menos 10 imagens normais e 10 anomalias para conjunto de dados de teste
   • vários defeitos por imagem são permitidos para o conjunto de dados de teste
3. Gere defeitos sintéticos e carregue-os nos locais de destino do S3.

Geramos um defeito por imagem e mais de 20 defeitos por classe para conjunto de dados de trem, bem como 1-3 defeitos por imagem e mais de 20 defeitos por classe para o conjunto de dados de teste.

A seguir está um exemplo da imagem de origem e seus defeitos sintéticos com três componentes: IC, resistor1 e resistor 2 ausentes.

imagem original

40_im_mask_IC_resistor1_resistor2.jpg (o nome do defeito indica os componentes ausentes)

4.  Gere arquivos de manifesto para conjunto de dados de treinamento/teste registrando todas as informações acima.

Por fim, geraremos manifestos de treinamento/teste para registrar informações, como localização do defeito sintético S3, localização da máscara S3, classe do defeito, cor da máscara etc.

A seguir estão exemplos de linhas json para uma anomalia e uma imagem normal no manifesto.

Para anomalia:

{"source-ref": "s3://qualityinspection/synthetic_defect/anomaly/train/6_im_mask_IC.jpg", "auto-label": 11, "auto-label-metadata": {"class-name": "anomaly", "type": "groundtruth/image-classification"}, "anomaly-mask-ref": "s3://qualityinspection/synthetic_defect/mask/MixMask/mask_IC.png", "anomaly-mask-ref-metadata": {"internal-color-map": {"0": {"class-name": "IC", "hex-color": "#2ca02c", "confidence": 0}}, "type": "groundtruth/semantic-segmentation"}}

Para imagem normal:

{"source-ref": "s3://qualityinspection/synthetic_defect/normal/train/25_im.jpg", "auto-label": 12, "auto-label-metadata": {"class-name": "normal", "type": "groundtruth/image-classification"}}

4.3.7 Estrutura de pastas do Amazon S3

A entrada e a saída do endpoint são armazenadas no bucket S3 de destino na seguinte estrutura:

5 Lookout for Vision modelo de treinamento e resultado

5.1 Configure um projeto, carregue o conjunto de dados e inicie o treinamento do modelo. 

1. Primeiro, você pode ir para Lookout for Vision a partir do Console AWS e criar um projeto.
   
2. Em seguida, você pode criar um conjunto de dados de treinamento escolhendo Importar imagens rotuladas pelo SageMaker Ground Truth e forneça a localização do Amazon S3 do manifesto do conjunto de dados train gerado pelo endpoint SageMaker.
   
3. Em seguida, você pode criar um conjunto de dados de teste escolhendo Importar imagens rotuladas pelo SageMaker Ground Truth novamente e forneça a localização do Amazon S3 do manifesto do conjunto de dados de teste gerado pelo endpoint SageMaker.
   
   .......
   ....
4. Depois que os conjuntos de dados de treinamento e teste forem carregados com sucesso, você poderá selecionar o Modelo de trem botão no canto superior direito para acionar o treinamento do modelo de localização de anomalias.
   ......
5. Em nosso experimento, o modelo demorou um pouco mais de uma hora para concluir o treinamento. Quando o status mostra treinamento concluído, você pode selecionar o link do modelo para verificar o resultado.
   ....
   

5.2 Resultado do treinamento do modelo

5.2.1 Métricas de desempenho do modelo 

Depois de selecionar no Modelo 1 como mostrado acima, podemos ver pela pontuação 100% Precision, 100% Recall e 100% F1 que o desempenho do modelo é muito bom. Também podemos verificar o desempenho por rótulo (componente ausente) e ficaremos felizes em descobrir que as pontuações F1 de todos os três rótulos estão acima de 93% e os IoUs médios estão acima de 85%. Este resultado é satisfatório para este pequeno conjunto de dados que demonstramos no post.

5.2.2 Visualização da detecção de defeitos sintéticos no conjunto de dados de teste. 

Como mostra a imagem a seguir, cada imagem será defeituosa como um normal or anomaly rótulo com uma pontuação de confiança. Se for uma anomalia, mostrará uma máscara sobre a área anormal na imagem com uma cor diferente para cada tipo de defeito.

Veja a seguir um exemplo de componentes ausentes combinados (três defeitos neste caso) no conjunto de dados de teste:

Em seguida, você pode compilar e empacotar o modelo como um AWS IoT Greengrass componente seguindo as instruções deste post, Identifique a localização de anomalias usando o Amazon Lookout for Vision na borda sem usar uma GPUe executar inferências no modelo.

6. Teste o modelo Lookout for Vision treinado em dados sintéticos contra defeitos reais

Para testar se o modelo treinado no defeito sintético pode funcionar bem contra defeitos reais, escolhemos um conjunto de dados (aliens-dataset) de SUA PARTICIPAÇÃO FAZ A DIFERENÇA para executar um experimento.

Primeiro, comparamos o defeito sintético gerado e o defeito real. A imagem da esquerda é um defeito real com um cabeçote faltando, e a imagem da direita é um defeito gerado com o cabeçote removido usando um modelo ML.

defeito real

defeito sintético

Em segundo lugar, usamos as detecções de teste no Lookout for Vision para testar o modelo em relação ao defeito real. Você pode salvar as imagens de teste no bucket do S3 e importá-las do Amazon S3 ou fazer upload de imagens do seu computador. Em seguida, selecione Detectar anomalias para executar a detecção.

Finalmente, você pode ver o resultado da previsão do defeito real. O modelo treinado em defeitos sintéticos pode desertar o defeito real com precisão neste experimento.

O modelo treinado em defeitos sintéticos nem sempre funciona bem em defeitos reais, especialmente placas de circuito que são muito mais complicadas do que este conjunto de dados de amostra. Se você deseja treinar novamente o modelo com defeitos reais, pode selecionar o botão laranja rotulado Verifique as previsões da máquina no canto superior direito do resultado da previsão e marque-o como Correto or Incorreto.

Em seguida, você pode adicionar a imagem verificada e o rótulo ao conjunto de dados de treinamento selecionando o botão laranja no canto superior direito para aprimorar o desempenho do modelo.

7. Estimativa de custos 

Esse pipeline de aumento de imagem para o Lookout for Vision é muito econômico. No exemplo mostrado acima, o Amazon SageMaker Ground Truth Labeling, o notebook Amazon SageMaker e a implantação e inferência de endpoint assíncrono do SageMaker custam apenas alguns dólares. Pelo serviço Lookout for Vision, você paga apenas pelo que usar. Existem três componentes que determinam sua fatura: cobranças por treinamento do modelo (horas de treinamento), cobranças por detecção de anomalias na nuvem (horas de inferência na nuvem) e/ou cobranças por detecção de anomalias na borda (unidades de inferência de borda). Em nosso experimento, o modelo Lookout for Vision levou um pouco mais de uma hora para concluir o treinamento e custou US$ 2.00 por hora de treinamento. Além disso, você pode usar o modelo treinado para inferência na nuvem ou na borda com o preço listado SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

8. Limpar

Para evitar cobranças desnecessárias, use o Console para excluir os endpoints e recursos que você criou durante a execução dos exercícios do post.

1. Abra o console do SageMaker e exclua os seguintes recursos:
   • O ponto final. A exclusão do endpoint também exclui a instância de computação de ML ou as instâncias que a suportam.
     1. Debaixo Inferência, escolha Pontos finais.
     2. Escolha o endpoint que você criou no exemplo, escolha Opções, e então escolha Apagar.
   • A configuração do terminal.
     1. Debaixo Inferência, escolha Configurações de endpoint.
     2. Escolha a configuração do endpoint que você criou no exemplo, escolha Opções, e então escolha Apagar.
   • O modelo.
     1. Debaixo Inferência, escolha Modelos.
     2. Escolha o modelo que você criou no exemplo, escolha Opções, e então escolha Apagar.
   • A instância do notebook. Antes de excluir a instância do notebook, interrompa-a.
     1. Debaixo Portátil, escolha Instâncias de notebook.
     2. Escolha a instância de notebook que você criou no exemplo, escolha Opções, e então escolha Dê um basta. A instância do notebook leva vários minutos para parar. Quando o Status muda para Parado, vá para a próxima etapa.
     3. Escolha Opções, e então escolha Apagar.
2. Abra o Console Amazon S3e, em seguida, exclua o depósito que você criou para armazenar artefatos de modelo e o conjunto de dados de treinamento.
3. Abra o Console do Amazon CloudWatche, em seguida, exclua todos os grupos de logs com nomes começando com /aws/sagemaker/.

Você também pode excluir o endpoint do notebook SageMaker executando o seguinte código:

import boto3
sm_boto3 = boto3.client("sagemaker")
sm_boto3.delete_endpoint(EndpointName='endpoint name')

9. Conclusão

Nesta postagem, demonstramos como anotar máscaras de defeitos sintéticos usando o Amazon SageMaker Ground Truth, como usar diferentes técnicas de aumento de imagem para transformar uma imagem normal no número desejado de imagens normais, criar um endpoint assíncrono do SageMaker e preparar o arquivo de entrada para o endpoint, bem como invocar o endpoint. Por fim, demonstramos como usar o manifesto train/test para treinar um modelo de localização de anomalias Lookout for Vision. Esse pipeline proposto pode ser estendido a outros modelos de ML para gerar defeitos sintéticos, e tudo o que você precisa fazer é personalizar o modelo e o código de inferência no endpoint do SageMaker.

Comece explorando o Lookout for Vision para inspeção de qualidade automatizada SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

---

Sobre os autores

Kara Yang é cientista de dados na AWS Professional Services. Ela é apaixonada por ajudar os clientes a atingir suas metas de negócios com os serviços de nuvem da AWS e ajudou as organizações a criar soluções completas de IA/ML em vários setores, como manufatura, automotivo, sustentabilidade ambiental e aeroespacial.

Octavi Obiols-Vendas See More é um cientista computacional especializado em aprendizado profundo (DL) e aprendizado de máquina certificado como arquiteto de soluções associado. Com amplo conhecimento na nuvem e na borda, ele ajuda a acelerar os resultados de negócios por meio da criação de soluções de IA de ponta a ponta. Octavi obteve seu PhD em ciência computacional na Universidade da Califórnia, Irvine, onde impulsionou o estado da arte em algoritmos DL+HPC.

Fabian Benítez-Quiroz é cientista de dados do IoT Edge nos serviços profissionais da AWS. Ele é PhD em Visão Computacional e Reconhecimento de Padrões pela The Ohio State University. Fabian está envolvido em ajudar os clientes a executar seus modelos de Machine Learning com baixa latência em dispositivos IoT e na nuvem.

Manish Talreja é gerente de produto principal para soluções de IoT na AWS. Ele é apaixonado por ajudar os clientes a criar soluções inovadoras usando os serviços AWS IoT e ML na nuvem e na borda.

Yuxin Yang é um arquiteto AI/ML da AWS, certificado na AWS Machine Learning Specialty. Ela permite que os clientes acelerem seus resultados por meio da criação de soluções completas de IA/ML, incluindo manutenção preditiva, visão computacional e aprendizado por reforço. Yuxin obteve seu mestrado na Universidade de Stanford, onde se concentrou em aprendizado profundo e análise de big data.

Yingmao Timothy Li é Cientista de Dados da AWS. Ele ingressou na AWS há 11 meses e trabalha com uma ampla variedade de serviços e tecnologias de aprendizado de máquina para criar soluções para um conjunto diversificado de clientes. Ele possui um Ph.D em Engenharia Elétrica. Em seu tempo livre, ele gosta de jogos ao ar livre, corridas de carros, natação e pilotar um filhote de flautista para cruzar o país e explorar o céu.