Crie, treine e implante modelos do Amazon Lookout for Equipment usando o Python Toolbox

A manutenção preditiva pode ser uma maneira eficaz de evitar falhas em máquinas industriais e tempos de inatividade dispendiosos, monitorando proativamente a condição do seu equipamento, para que você possa ser alertado sobre quaisquer anomalias antes que ocorram falhas no equipamento. A instalação de sensores e a infraestrutura necessária para conectividade de dados, armazenamento, análise e alertas são os elementos fundamentais para viabilizar soluções de manutenção preditiva. No entanto, mesmo depois de instalar a infraestrutura ad hoc, muitas empresas utilizam análises de dados básicas e abordagens de modelagem simples que muitas vezes são ineficazes na detecção de problemas com antecedência suficiente para evitar tempo de inatividade. Além disso, implementar uma solução de aprendizado de máquina (ML) para seu equipamento pode ser difícil e demorado.

Com o Amazon Lookout para Equipamentos, você pode analisar automaticamente os dados dos sensores do seu equipamento industrial para detectar comportamentos anormais da máquina, sem a necessidade de experiência em ML. Isso significa que você pode detectar anormalidades no equipamento com velocidade e precisão, diagnosticar problemas rapidamente e tomar medidas para reduzir o dispendioso tempo de inatividade.

O Lookout for Equipment analisa os dados de seus sensores e sistemas, como pressão, vazão, RPMs, temperatura e potência, para treinar automaticamente um modelo específico para seu equipamento com base em seus dados. Ele usa seu modelo de ML exclusivo para analisar os dados recebidos do sensor em tempo real e identifica sinais de alerta precoce que podem levar a falhas da máquina. Para cada alerta detectado, o Lookout for Equipment identifica quais sensores específicos estão indicando o problema e a magnitude do impacto no evento detectado.

Com a missão de colocar o ML nas mãos de todos os desenvolvedores, queremos apresentar mais um complemento ao Lookout for Equipment: um caixa de ferramentas Python de código aberto que permite que desenvolvedores e cientistas de dados criem, treinem e implantem modelos Lookout for Equipment de maneira semelhante ao que você está acostumado Amazon Sage Maker. Esta biblioteca é um wrapper na API Lookout for Equipment boto3 python e é fornecida para iniciar sua jornada com este serviço. Se você tiver alguma sugestão de melhoria ou bug para relatar, registre um problema na caixa de ferramentas Repositório GitHub.

Nesta postagem, fornecemos um guia passo a passo para usar a caixa de ferramentas Python de código aberto Lookout for Equipment em um notebook SageMaker.

Configuração do ambiente

Para usar a caixa de ferramentas Lookout for Equipment de código aberto de um notebook SageMaker, precisamos conceder ao notebook SageMaker as permissões necessárias para chamar APIs do Lookout for Equipment. Para esta postagem, presumimos que você já criou uma instância de notebook SageMaker. Para obter instruções, consulte Introdução às instâncias de notebook do Amazon SageMaker. A instância do notebook é automaticamente associada a uma função de execução.

1. Para encontrar a função anexada à instância, selecione a instância no console do SageMaker.
   
2. Na próxima tela, role para baixo para encontrar o Gerenciamento de acesso e identidade da AWS (IAM) anexada à instância no Permissões e criptografia seção.
3. Escolha a função para abrir o console do IAM.
   

A seguir, anexamos uma política inline à nossa função SageMaker IAM.

4. No Permissões guia da função que você abriu, escolha Adicionar política embutida.
   
5. No JSON guia, insira o seguinte código. Usamos uma ação curinga (lookoutequipment:*) para o serviço para fins de demonstração. Para casos de uso reais, forneça apenas as permissões necessárias para executar as chamadas apropriadas da API do SDK.

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lookoutequipment:*" ], "Resource": "*" } ] }

6. Escolha Rever a política.
7. Forneça um nome para a política e crie-a.

Além da política in-line anterior, na mesma função do IAM, precisamos estabelecer uma relação de confiança para permitir que o Lookout for Equipment assuma essa função. A função SageMaker já tem o acesso de dados apropriado para Serviço de armazenamento simples da Amazon (Amazon S3); permitir que o Lookout for Equipment assuma essa função garante que ele tenha o mesmo acesso aos dados que o seu notebook. No seu ambiente, você já pode ter uma função específica garantindo que o Lookout for Equipment tenha acesso aos seus dados; nesse caso, você não precisa ajustar a relação de confiança dessa função comum.

8. Dentro de nossa função SageMaker IAM no Relações de confiança guia, escolha Editar relação de confiança.
9. No documento de política, substitua toda a política pelo seguinte código:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lookoutequipment.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }

10. Escolha Atualizar política de confiança.

Agora estamos prontos para usar a caixa de ferramentas Lookout for Equipment em nosso ambiente de notebook SageMaker. A caixa de ferramentas Lookout for Equipment é um pacote Python de código aberto que permite que cientistas de dados e desenvolvedores de software criem e implantem facilmente modelos de detecção de anomalias de série temporal usando Lookout for Equipment. Vejamos o que você pode conseguir com mais facilidade graças à caixa de ferramentas!

Dependências

No momento em que este artigo foi escrito, a caixa de ferramentas precisava do seguinte instalado:

• Python(> = 3.6)
• boto3 (> = 1.17.48)
• redução
• numpy
• pandas
• Pyarrow
• s3fs

Depois de satisfazer essas dependências, você pode instalar e iniciar a caixa de ferramentas Lookout for Equipment com o seguinte comando em um terminal Jupyter:

pip install lookoutequipment

A caixa de ferramentas agora está pronta para uso. Nesta postagem, demonstramos como usar a caixa de ferramentas treinando e implantando um modelo de detecção de anomalias. Um ciclo de vida de desenvolvimento de ML típico consiste em construir o conjunto de dados para treinamento, treinar o modelo, implantar o modelo e realizar inferência no modelo. A caixa de ferramentas é bastante abrangente em termos de funcionalidades que oferece, mas neste post nos concentramos nos seguintes recursos:

• Preparar o conjunto de dados
• Treine um modelo de detecção de anomalias usando Lookout for Equipment
• Crie visualizações para avaliação do seu modelo
• Configurar e iniciar um agendador de inferência
• Visualize resultados de inferências do agendador

Vamos entender como podemos usar a caixa de ferramentas para cada um desses recursos.

Preparar o conjunto de dados

O Lookout for Equipment requer que um conjunto de dados seja criado e ingerido. Para preparar o conjunto de dados, conclua as seguintes etapas:

1. Antes de criar o conjunto de dados, precisamos carregar um conjunto de dados de amostra e carregá-lo em um Serviço de armazenamento simples da Amazon (Amazon S3) balde. Nesta postagem, usamos o expander conjunto de dados:

   from lookoutequipment import dataset data = dataset.load_dataset(dataset_name='expander', target_dir='expander-data')
   dataset.upload_dataset('expander-data', bucket, prefix)

O devolvido data object representa um dicionário contendo o seguinte:

• • Um DataFrame de dados de treinamento
  • Um rótulo DataFrame
  • As datas de início e término do treinamento
  • As datas de início e término da avaliação
  • Uma descrição de tags DataFrame

Os dados de treinamento e rótulo são carregados do diretório de destino para o Amazon S3 no local do bucket/prefixo.

2. Após fazer upload do conjunto de dados no S3, criamos um objeto de LookoutEquipmentDataset classe que gerencia o conjunto de dados:

   lookout_dataset = dataset.LookoutEquipmentDataset( dataset_name='my_dataset', access_role_arn=role_arn, component_root_dir=f's3://{bucket}/{prefix}training-data'
   ) # creates the dataset
   lookout_dataset.create()

A access_role_arn fornecido deve ter acesso ao bucket S3 onde os dados estão presentes. Você pode recuperar o ARN da função da instância do notebook SageMaker do anterior Configuração do ambiente seção e adicione uma política IAM para conceder acesso ao seu bucket S3. Para mais informações, veja Escrevendo políticas de IAM: como conceder acesso a um intervalo Amazon S3.

A component_root_dir O parâmetro deve indicar o local no Amazon S3 onde os dados de treinamento estão armazenados.

Depois de lançarmos as APIs anteriores, nosso conjunto de dados foi criado.

3. Ingerir os dados no conjunto de dados:

   response = lookout_dataset.ingest_data(bucket, prefix + 'training-data/')

Agora que seus dados estão disponíveis no Amazon S3, criar um conjunto de dados e ingerir os dados nele contidos é apenas uma questão de três linhas de código. Você não precisa criar manualmente um esquema JSON extenso; a caixa de ferramentas detecta sua estrutura de arquivos e a constrói para você. Depois que seus dados forem ingeridos, é hora de passar para o treinamento!

Treine um modelo de detecção de anomalias

Depois que os dados forem ingeridos no conjunto de dados, podemos iniciar o processo de treinamento do modelo. Veja o seguinte código:

from lookoutequipment import model lookout_model = model.LookoutEquipmentModel(model_name='my_model', dataset_name='my_dataset') lookout_model.set_time_periods(data['evaluation_start'],data['evaluation_end'],data['training_start'],data['training_end'])
lookout_model.set_label_data(bucket=bucket,prefix=prefix + 'label-data/',access_role_arn=role_arn)
lookout_model.set_target_sampling_rate(sampling_rate='PT5M') #trigger training job
response = lookout_model.train() #poll every 5 minutes to check the status of the training job
lookout_model.poll_model_training(sleep_time=300)

Antes de lançarmos o treinamento, precisamos especificar os períodos de treinamento e avaliação no conjunto de dados. Também definimos o local no Amazon S3 onde os dados rotulados são armazenados e definimos a taxa de amostragem para 5 minutos. Depois de lançarmos o treinamento, o poll_model_training pesquisa o status do trabalho de treinamento a cada 5 minutos até que o treinamento seja bem-sucedido.

O módulo de treinamento da caixa de ferramentas Lookout for Equipment permite treinar um modelo com menos de 10 linhas de código. Ele cria todas as strings de solicitação de criação de comprimento necessárias para a API de baixo nível em seu nome, eliminando a necessidade de criar documentos JSON longos e propensos a erros.

Depois que o modelo for treinado, podemos verificar os resultados durante o período de avaliação ou configurar um agendador de inferência usando a caixa de ferramentas.

Avalie um modelo treinado

Depois que um modelo é treinado, o DescreverModelo A API do Lookout for Equipment registra as métricas associadas ao treinamento. Esta API retorna um documento JSON com dois campos de interesse para plotar os resultados da avaliação: labeled_ranges e predicted_ranges, que contêm as anomalias conhecidas e previstas na faixa de avaliação, respectivamente. A caixa de ferramentas fornece utilitários para carregá-los em um DataFrame do Pandas:

from lookoutequipment import evaluation LookoutDiagnostics = evaluation.LookoutEquipmentAnalysis(model_name='my_model', tags_df=data['data']) predicted_ranges = LookoutDiagnostics.get_predictions()
labels_fname = os.path.join('expander-data', 'labels.csv')
labeled_range = LookoutDiagnostics.get_labels(labels_fname)

A vantagem de carregar os intervalos em um DataFrame é que podemos criar boas visualizações traçando um dos sinais da série temporal original e adicionar uma sobreposição dos eventos anômalos rotulados e previstos usando o TimeSeriesVisualization classe da caixa de ferramentas:

from lookoutequipment import plot TSViz = plot.TimeSeriesVisualization(timeseries_df=data['data'], data_format='tabular')
TSViz.add_signal(['signal-001'])
TSViz.add_labels(labeled_range)
TSViz.add_predictions([predicted_ranges])
TSViz.add_train_test_split(data['evaluation_start'])
TSViz.add_rolling_average(60*24)
TSViz.legend_format = {'loc': 'upper left', 'framealpha': 0.4, 'ncol': 3}
fig, axis = TSViz.plot()

Essas poucas linhas de código geram um gráfico com os seguintes recursos:

• Um gráfico de linhas para o sinal selecionado; a parte utilizada para treinamento o modelo aparece em azul enquanto a parte de avaliação fica em cinza
• A média móvel aparece como uma linha vermelha fina sobreposta ao longo da série temporal
• Os rótulos são mostrados em uma faixa verde chamada “Anomalias conhecidas” (por padrão)
• Os eventos previstos são mostrados em uma fita vermelha chamada “Eventos detectados”

A caixa de ferramentas realiza todo o trabalho pesado de localização, carregamento e análise dos arquivos JSON, ao mesmo tempo que fornece visualizações prontas para uso que reduzem ainda mais o tempo para obter insights de seus modelos de detecção de anomalias. Nesse estágio, a caixa de ferramentas permite que você se concentre na interpretação dos resultados e na tomada de ações para agregar valor comercial direto aos usuários finais. Além dessas visualizações de série temporal, o SDK fornece outros gráficos, como uma comparação de histograma dos valores de seus sinais entre tempos normais e anormais. Para saber mais sobre os outros recursos de visualização que você pode usar imediatamente, consulte o Procure a documentação da caixa de ferramentas do equipamento.

Programar inferência

Vamos ver como podemos agendar inferências usando a caixa de ferramentas:

from lookout import scheduler #prepare dummy inference data
dataset.prepare_inference_data( root_dir='expander-data', sample_data_dict=data, bucket=bucket, prefix=prefix
) #setup the scheduler
lookout_scheduler = scheduler.LookoutEquipmentScheduler(scheduler_name='my_scheduler',model_name='my_model')
scheduler_params = { 'input_bucket': bucket, 'input_prefix': prefix + 'inference-data/input/', 'output_bucket': bucket, 'output_prefix': prefix + 'inference-data/output/', 'role_arn': role_arn, 'upload_frequency': 'PT5M', 'delay_offset': None, 'timezone_offset': '+00:00', 'component_delimiter': '_', 'timestamp_format': 'yyyyMMddHHmmss' } lookout_scheduler.set_parameters(**scheduler_params)
response = lookout_scheduler.create()

Este código cria um agendador que processa um arquivo a cada 5 minutos (correspondendo à frequência de upload definida ao configurar o agendador). Após cerca de 15 minutos, devemos ter alguns resultados disponíveis. Para obter esses resultados do agendador em um DataFrame Pandas, basta executar o seguinte comando:

results_df = lookout_scheduler.get_predictions()

A partir daqui, também podemos traçar a importância do recurso para uma previsão usando as APIs de visualização da caixa de ferramentas:

event_details = pd.DataFrame(results_df.iloc[0, 1:]).reset_index()
fig, ax = plot.plot_event_barh(event_details)

Ele produz a seguinte visualização da importância do recurso nos dados de amostra.

A caixa de ferramentas também fornece uma API para interromper o agendador. Veja o seguinte trecho de código:

scheduler.stop()

limpar

Para deletar todos os artefatos criados anteriormente, podemos chamar o método delete_dataset API com o nome do nosso conjunto de dados:

dataset.delete_dataset(dataset_name='my_dataset', delete_children=True, verbose=True)

Conclusão

Ao falar com clientes industriais e de manufatura, um desafio comum que ouvimos em relação ao aproveitamento da IA ​​e do ML é a grande quantidade de personalização e trabalho específico de desenvolvimento e ciência de dados necessários para obter resultados confiáveis ​​e acionáveis. Treinar modelos de detecção de anomalias e obter avisos acionáveis ​​para muitas máquinas industriais diferentes é um pré-requisito para reduzir o esforço de manutenção, reduzir o retrabalho ou desperdício, aumentar a qualidade do produto e melhorar a eficiência geral do equipamento (OEE) ou linhas de produtos. Até agora, isto exigia uma enorme quantidade de trabalho de desenvolvimento específico, que é difícil de dimensionar e manter ao longo do tempo.

Os serviços de IA aplicada da Amazon, como o Lookout for Equipment, permitem que os fabricantes criem modelos de IA sem ter acesso a uma equipe versátil de cientistas de dados, engenheiros de dados e engenheiros de processo. Agora, com a caixa de ferramentas Lookout for Equipment, seus desenvolvedores podem reduzir ainda mais o tempo necessário para explorar insights em seus dados de série temporal e tomar medidas. Esta caixa de ferramentas fornece uma interface fácil de usar e amigável ao desenvolvedor para criar rapidamente modelos de detecção de anomalias usando o Lookout for Equipment. A caixa de ferramentas é de código aberto e todo o código SDK pode ser encontrado no amazon-lookout-for-equipment-python-sdk Repositório GitHub. Também está disponível como um Pacote PyPi.

Esta postagem cobre apenas algumas das APIs mais importantes. Os leitores interessados ​​podem conferir o documentação da caixa de ferramentas para examinar os recursos mais avançados da caixa de ferramentas. Experimente e deixe-nos saber o que você pensa nos comentários!

Sobre os autores

Pandey Vikesh é arquiteto de soluções especialista em aprendizado de máquina na AWS, ajudando clientes no Reino Unido e na região EMEA mais ampla a projetar e construir soluções de ML. Fora do trabalho, Vikesh gosta de experimentar diferentes culinárias e praticar esportes ao ar livre.

Ioan Catana é arquiteto de soluções especialista em inteligência artificial e aprendizado de máquina na AWS. Ele ajuda os clientes a desenvolver e dimensionar suas soluções de ML na Nuvem AWS. Ioan tem mais de 20 anos de experiência, principalmente em design de arquitetura de software e engenharia de nuvem.

Michael Hoarau é um arquiteto de soluções especialista em IA/ML na AWS que alterna entre cientista de dados e arquiteto de aprendizado de máquina, dependendo do momento. Ele é apaixonado por levar o poder da IA/ML às fábricas de seus clientes industriais e trabalhou em uma ampla variedade de casos de uso de ML, desde detecção de anomalias até qualidade preditiva de produtos ou otimização de fabricação. Quando não está ajudando os clientes a desenvolver as próximas melhores experiências de aprendizado de máquina, ele gosta de observar as estrelas, viajar ou tocar piano.

• Coinsmart. A melhor troca de Bitcoin e criptografia da Europa.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. ACESSO LIVRE.
• CryptoHawk. Radar Altcoin. Teste grátis.
• Fonte: https://aws.amazon.com/blogs/machine-learning/build-train-and-deploy-amazon-lookout-for-equipment-models-using-the-python-toolbox/