Inferência de um modelo de Machine Learning usando Angular e Flask — Implementação de ponta a ponta

Mar 26 2023

Pré-requisitos Desafios na inferência Angular é uma estrutura JavaScript de código aberto escrita em TypeScript. O Google o mantém e seu objetivo principal é desenvolver aplicativos de página única.

Pré-requisitos

Noções básicas de aprendizado de máquina
Noções básicas de Python
Fundamentos do Frasco
Fundamentos do Angular
Salvando e carregando um modelo de aprendizado de máquina — Link

Depois que um modelo é treinado, o modelo treinado deve ser usado passando os respectivos dados de entrada para buscar a saída. A saída pode ser uma classificação, predição, agrupamento, etc. Esse processo de usar o modelo para geração de saída é chamado de inferência .
Essencialmente, nos bastidores, com base nos dados de treinamento, o modelo desenvolveu uma equação matemática. Onde, quando uma entrada é fornecida, esta equação/algoritmo funciona nos dados de entrada com base nos parâmetros aprendidos com os dados de treinamento para produzir uma saída.
Em outras palavras,

Desafios na inferência

Como chamar esse modelo treinado de outro aplicativo? Suponha que tenhamos uma IU (Angular, React, etc.) onde estamos recebendo entradas dos usuários e precisamos passar essas entradas para o modelo treinado. Como podemos conseguir isso?
Como industrializamos ou produzimos um modelo treinado?

Para disponibilizar um modelo para outras aplicações podemos utilizar API's. Em geral, API (Application Programming Interface) é um método pelo qual dois ou mais aplicativos podem se comunicar entre si.

Vários frameworks podem nos ajudar na implementação de API's como Flask, Django, etc. Esses frameworks podem expor API's, onde as API's expostas obtêm a entrada no formato desejado, processam a entrada passando-a para o modelo treinado e retornam uma resposta.

Vamos criar um modelo simples de aprendizado de máquina e consumi-lo desde o front-end. O modelo de aprendizado de máquina será desenvolvido usando python. Para o desenvolvimento da API, usaremos o framework Flask.
A interface do usuário do frontend é desenvolvida usando Angular, onde obteremos as entradas do usuário. As entradas da interface do usuário serão passadas para a estrutura do Flask por meio de APIs.
A estrutura Flask processará os dados de entrada aplicando o modelo treinado e retornando a resposta. A resposta retornada será recebida e exibida ao cliente pelo aplicativo angular.

Neste blog, desenvolveremos um modelo simples de detecção de força de senha que pode detectar a força da senha fornecida.
Embora existam verificações simples que podem ser implementadas para detectar a força da senha, como a presença de caracteres alfanuméricos, especiais, etc. sem o uso de modelos. Desenvolveremos um modelo baseado em NLP que entenderá a combinação de letras, números e caracteres especiais usados na senha.
Isso é obtido treinando um modelo usando um conjunto de dados rotulado que contém senhas diferentes junto com sua força. Durante o treinamento, o modelo aprenderá e entenderá os padrões ou combinações e, com base nisso, o modelo classificará sua força.
O conjunto de dados usado aqui está disponível neste link . O repositório de código completo para este blog pode ser encontrado aqui . Mais detalhes sobre a modelagem podem ser encontrados aqui .

Importe os pacotes necessários. O modelo é implementado usando os métodos TfidfVectorizer e RandomForestClassifier do pacote sklearn. Certifique-se de instalar o pacote sklearn usando o comando pip install sklearn

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import getpass
import pickle

data = pd.read_csv("../assets/train_data/training.csv", error_bad_lines=False)
print(data.head())

data = data.dropna()
data["strength"] = data["strength"].map({0: "Weak", 
                                         1: "Medium",
                                         2: "Strong"})

def word(password):
    character=[]
    for i in password:
        character.append(i)
    return character
  
x = np.array(data["password"])
y = np.array(data["strength"])

tdif = TfidfVectorizer(tokenizer=word)
x = tdif.fit_transform(x)
xtrain, xtest, ytrain, ytest = train_test_split(x, y, 
                                                test_size=0.05, 
                                                random_state=42)

model = RandomForestClassifier()
model.fit(xtrain, ytrain)
print(model.score(xtest, ytest))

pickle.dump(tdif, open("../assets/pickled/vectorizer.pkl", "wb"))
pickle.dump(model, open('../assets/pickled/model.pkl', 'wb'))

A base de código para o servidor flask pode ser encontrada aqui — Link

Instale o Flask usando o comando pip install Flask
Crie um arquivo app.py e o seguinte código

from flask import Flask, render_template, jsonify, request, json
import os

app = Flask(__name__)

@app.route('/pingServer', methods=['GET'])
def pingServer():
    resp = {
        "messId": "S",
        "messText": "Success"
    }
    return jsonify(resp)


if __name__ == "__main__":
    port = int(os.environ.get('PORT', 5011))
    app.run(debug=True, host='0.0.0.0', port=port)

Adicione nosso modelo treinado como uma API, fazendo algumas adições ao código. A primeira etapa é carregar o vetorizador ajustado e o modelo treinado do arquivo pickle.

if __name__ == "__main__":
    # Load Pickled Objects
    pickled_tfidf = pickle.load(open('./assets/pickled/vectorizer.pkl', 'rb'))
    pickled_model = pickle.load(open('./assets/pickled/model.pkl', 'rb'))

    port = int(os.environ.get('PORT', 5011))
    app.run(debug=True, host='0.0.0.0', port=port)

@app.route('/validatePass', methods=['POST'])
@cross_origin()
def validatePass():
    body_inp = json.loads(request.data)
    data = pickled_tfidf.transform([body_inp['password']]).toarray()
    output = pickled_model.predict(data)
    resp = {
        "messId": "S",
        "messText": "Success",
        "strength": output[0]
    }
    return jsonify(resp)


def word(password):
    character = []
    for i in password:
        character.append(i)
    return character

O servidor Flask está sendo executado na porta 5011 com dois endpoints de API. Um endpoint é testar a conexão. Outro endpoint é usado para passar entradas para executar o modelo e retornar uma resposta.

Angular é uma estrutura JavaScript de código aberto escrita em TypeScript. O Google o mantém e seu objetivo principal é desenvolver aplicativos de página única. Como uma estrutura, o Angular tem vantagens claras, ao mesmo tempo em que fornece uma estrutura padrão para os desenvolvedores trabalharem. — Simplilearn