Aprendizado de máquina no PLCnext

Até agora, todo mundo já ouviu falar sobre Machine Learning e como isso mudará tudo. Mas muito poucos têm uma ideia de como começar a mudar tudo. Espero que quando você tentar os passos neste blog, ou mesmo ler sobre isso, ajude você a entender como começar a mudar as coisas com seu PLCnext Controller. Neste blog vou treinar seu primeiro modelo de ML, convertendo-o para o padrão ONNX e inferindo o modelo em um controlador PLCnext. Para não sobrecarregar as coisas, estarei usando o famoso conjunto de dados Iris para construir nosso modelo.

Antes de começarmos, deve ficar muito claro o que vamos tentar alcançar. Por isso vou dar uma pequena explicação sobre os temas tratados neste blog. Minhas referências podem ser encontradas no final deste blog.

Introdução ao aprendizado de máquina

O que é aprendizado de máquina

Então, acho que devemos começar explicando o que é aprendizado de máquina. A essência do aprendizado de máquina é que tentaremos encontrar padrões em conjuntos de dados com o uso de estatísticas e algoritmos. Diferenciamos três tipos principais de aprendizado de máquina:aprendizado de máquina supervisionado, aprendizado de máquina não supervisionado e aprendizado por reforço. O aprendizado supervisionado é o “sabor” mais usado hoje e usaremos o aprendizado supervisionado neste blog. No aprendizado supervisionado, rotulamos os dados e informamos à máquina exatamente quais padrões estamos procurando.

No aprendizado não supervisionado, não rotulamos nossos dados e deixamos a máquina encontrar seus próprios padrões, pois essa técnica tem aplicações menos óbvias, o aprendizado não supervisionado é menos popular.

Por fim, no aprendizado por reforço, um algoritmo aprende por tentativa e erro para atingir um objetivo declarado. Ele apenas tenta muitas coisas e recebe uma recompensa ou penalizado dependendo se foi uma ação boa ou ruim. O AlphaGo do Google é um exemplo famoso de aprendizado por reforço.

O conjunto de dados da flor Iris

De acordo com a Wikipedia, o conjunto de dados da flor Iris é:

Ok, tudo bem, mas como ele se parece?

No conjunto de dados Iris existem 5 campos:comprimento da sépala, largura da sépala, comprimento da pétala, largura da pétala e a variedade da flor da íris. Nosso objetivo hoje é encontrar o tipo de flor de íris quando sabemos o comprimento da sépala, largura da sépala, comprimento da pétala e largura da pétala. Então vamos treinar o modelo para classificar o tipo de flor. Como você poderia ter adivinhado, esse tipo de aprendizado de máquina é a classificação.

O aprendizado de máquina também pode ser usado para prever um valor no conjunto de dados. Este procedimento chama-se regressão e utiliza algoritmos diferentes da classificação.

O Algoritmo

Hoje usaremos o “Classificador de Árvore de Decisão” não porque seja perfeito para a tarefa, mas é muito intuitivo e pode ser facilmente entendido sem matemática sofisticada. Aqui você pode encontrar um exemplo de uma árvore de decisão para nosso conjunto de dados de flores Iris.

ONNX

Como você pode imaginar, os modelos de Machine Learning podem vir em uma ampla variedade de formatos e precisam ser executados em muitos hardwares diferentes com diferentes métodos de aceleração. O Open Neural Network Exchange tenta mitigar esse problema. Ele é usado em open office, azure e inúmeras outras aplicações ao redor do mundo. Ele é quase certamente usado no dispositivo que você está lendo este blog.


Para executar modelos onnx, precisamos do tempo de execução onnx, isso vem com seus desafios. Especialmente em processadores de braço, mas com as imagens do docker fornecidas, você deve ficar bem!

Passeio técnico

Pré-requisitos

Estou usando um controlador AXC F 2152 com firmware 2021.0 LTS instalado e uma VM Ubuntu 20.04 para treinar o modelo. Os scripts para treinamento e inferência do modelo são fornecidos, mas a configuração da VM do Ubuntu está fora do escopo do blog. Você pode encontrar boas explicações sobre como instalar os pacotes Python necessários e todos os pacotes usados ​​devem ser instalados corretamente com pip3.

No controlador PLCnext, precisaremos de um mecanismo de contêiner instalado. Você pode encontrar uma boa explicação do procedimento aqui.

Um procedimento semelhante com o AXC F 3152 também é possível.

Você precisará de pelo menos uma experiência mínima com Python e contêineres para este blog.

Treinando o modelo

Baixe o conteúdo deste repositório GitHub e certifique-se de que todos os pacotes necessários estejam instalados.

O primeiro script que vamos executar é o script de trem onde vamos ajustar nosso modelo ao conjunto de dados da íris.
Abaixo, você pode encontrar um código extraído deste script de treinamento. Este script irá criar um arquivo “.onnx” que contém um modelo treinado.

# Slit the dataset in a training and testing dataset
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, Y_test = train_test_split(X, y)

# Define the model and fit the model with training data and print information about the model
clr = DecisionTreeClassifier()
clr.fit(X_train, y_train)
print(clr)

#Convert the model from sklearn format to ONNX (Open Neural Network Exchange)
initial_type = [('float_input', FloatTensorType([None, 4]))]
onx = convert_sklearn(clr, initial_types=initial_type)
with open("decision_tree_iris.onnx", "wb") as f:
 f.write(onx.SerializeToString())

Inferência no Ubuntu

Verifique seu modelo executando-o em sua máquina de desenvolvimento. Ao executar o script de inferência, você deve obter 2 inteiros correspondentes a um tipo de flor Iris.

import numpy as np
import onnxruntime as rt

X_test = np.array([[5.8,4.0,1.2,0.2],[7.7,3.8,6.7,2.2,]])

sess = rt.InferenceSession("decision_tree_iris.onnx")
input_name = sess.get_inputs()[0].name
label_name = sess.get_outputs()[0].name
pred_onx = sess.run(
 [label_name], {input_name: X_test.astype(np.float32)})[0]
print(pred_onx)

output : [0 2]

Inferência no PLCnext

Abra seu cliente sFTP favorito e solte os repositórios “.onnx” e “inference.py” em /opt/plcnext/onnx em seu controlador PLCnext. Prossiga com a execução do próximo comando como root:

balena-engine run -it --name onnx -v /opt/plcnext/onnx/:/app pxcbe/onnx-runtime-arm32v7

execute o script de inferência python com

cd /app
python3 /app/inference.py

Se tudo correu bem, você obtém a mesma saída da inferência na sua VM do Ubuntu! Parabéns, você chegou até o final. Agora vá mudar as coisas!

Como implementar em um aplicativo?

Na verdade, ainda não terminamos. Quer dizer, classificar flores de íris é divertido, mas não consigo imaginar vários aplicativos para isso em um controlador lógico. Você precisará criar seu próprio modelo e criar uma API para esse modelo para poder inferir com ele. Você pode optar por entregar dados ao modelo com OPC UA ou criar um endpoint REST personalizado para ele. De qualquer forma, você precisará escrever um pouco mais de código do que o fornecido por mim.

Levando em consideração que construir as imagens literalmente me levou dias e uma noite sem dormir, sugiro que você construa sua imagem em cima da imagem fornecida. Na referência, você pode encontrar um bom recurso para criar um aplicativo de contêiner Python.

Referências:

https://www.technologyreview.com/2018/11/17/103781/what-is-machine-learning-we-drew-you-another-flowchart/https://en.wikipedia.org/wiki/Iris_flower_data_set
Por favor, aceite cookies de marketing para assistir a este vídeo.
https://www.researchgate.net/figure/Decision-tree-for-Iris-dataset_fig1_293194222https://onnx.ai/
https://github.com/PLCnext/Docker_GettingStarted

https://www.wintellect.com/containerize-python-app-5-minutes/
https://github.com/onnx/models