A dinâmica de pressionamento de tecla usada nos modelos de aprendizado de máquina deste artigo para reconhecimento do usuário é a biometria comportamental. A dinâmica de pressionamento de tecla usa a forma distinta que cada pessoa digita para confirmar sua identidade. Isso é feito analisando os 2 eventos de pressionamento de tecla e liberação de tecla - que constituem um pressionamento de tecla em teclados de computador para extrair padrões de digitação. O artigo examinará como esses modelos de ML podem ser usados em situações da vida real para prever um usuário.

O artigo anterior descreveu como podemos treinar 3 modelos de ML, em um conjunto de +880 entradas de teclado de 100 usuários que foram solicitados a escrever o mesmo texto 12 vezes.

Os aplicativos que usaremos para simular uma situação da vida real.

A arquitetura

Sandbox : Para testar cenários da vida real, usaremos Carteiro + Frasco .

Produção : Quando quisermos mover este aplicativo para produção, podemos simplesmente substituir os bits do código Flask pelo código de um AWS Lambda .

Flask é uma estrutura web que podemos usar para replicar o Lambda + API Gateway.

O Lambda é um serviço web sem servidor hospedado na AWS, que pode executar código orientado a eventos escrito em várias linguagens, porém para este aplicativo usaremos python.

O fluxo de dados é:

1. Carregamos o cabeçalho com os dados de identificação e o modelo que queremos usar, esse é basicamente o nosso payload json. No cabeçalho também adicionaremos a chave de autorização (somente Prod)
2. Fazemos solicitação do método HTTP POST para Flask App/API Gateway
3. O API Gateway verifica a chave de autorização (chave API) e se aceitar a solicitação, envia o payload ao Lambda para processamento
4. O FlaskApp/Lambda executa o código subjacente
5. O que obtemos no corpo de retorno é o ID do usuário previsto se o evento for bem-sucedido, caso contrário, receberemos uma mensagem de erro

Conforme mencionado anteriormente, todo o código você pode encontrar na página do projeto no Github:

https://github.com/BogdanAlinTudorache/KeystrokeDynamics

O pedido do carteiro

Cru

 { "info": { "_postman_id": "c62ddbda-e487-432f-998a-4dfc9313f0fa", "name": "BogdanTudorache", "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json" }, "item": [ { "name": "predict_user", "request": { "method": "POST", "header": [], "body": { "mode": "raw", "raw": "{\n \"Model\": \"RF\",\n \"HT\": {\n \"Mean\": 48.43,\n \"STD\": 23.34\n },\n \"PPT\": {\n \"Mean\": 120.43,\n \"STD\": 37.41\n },\n \"RRT\": {\n \"Mean\": 124.43,\n \"STD\": 45.34\n },\n \"RPT\": {\n \"Mean\": 132.56,\n \"STD\": 47.12\n }\n}", "options": { "raw": { "language": "json" } } }, "url": { "raw": "http://127.0.0.1:5000", "protocol": "http", "host": [ "127", "0", "0", "1" ], "port": "5000" } }, "response": [] } ] }

Você pode baixar o arquivo do GitHub.

Corpo

 { "Model": "RF", "HT": { "Mean": 48.43, "STD": 23.34 }, "PPT": { "Mean": 120.43, "STD": 37.41 }, "RRT": { "Mean": 124.43, "STD": 45.34 }, "RPT": { "Mean": 132.56, "STD": 47.12 } }

O aplicativo Flask / aplicativo Lambda

Se quisermos testar o processo em sandbox antes de mover tudo para AWS, devemos replicar uma chamada ponta a ponta usando Flask.

Como iniciar o aplicativo Flask?

No GitHub, você encontrará a versão completa do flask_lambda_function.py e em qualquer IDE você só precisa executar o script, pois ele iniciará automaticamente o aplicativo flask.

No meu caso, estou usando o IntelliJ Idea, então simplesmente executo o script (clique com o botão direito → executar):

Testando um cenário da vida real

Assim que o script for iniciado na parte inferior do IDE você verá o console python informando que o webservice foi iniciado no localhost e na porta 5000 (acho que isso é o padrão, mas também pode ser configurado).

Agora toda vez que fizermos uma solicitação HTTP POST , teremos acionado o aplicativo flask, simulando um cenário da vida real.

Solicitação POST:

Resposta do console Python:

Resposta do carteiro:

Código DeepDive

 @app.route('/', methods=['GET', 'POST']) def index(): # Bellow code should be uncommented when running in AWS:Lambda # above should be commented as well as flask import + app definition # def lambda_handler(event, context): """ Lambda handler: When a request hits the API gateway linked to this lambda_function this is the function that gets called. The request data is passed as the event variable which is a dictionary object, in this case it the json of the POST request from which we extract the body details """ # Parses the details from the POST request: extracts model and input data # Based on model it imports the trained model from local # Outputs the predicted user based on input data try: prediction = functions.predict_user(request.get_json()) # Below code should be uncommented when running from AWS, above should be commented. # prediction = functions.predict_user(event) return jsonify({'statuscode': 200, 'status': 'success', 'predicted user': str(prediction) }) except Exception as e: return jsonify({'statuscode': 400, 'status': 'error', 'message': str(e)})

O código acima está definido como flask-app, no entanto, comentando e descomentando certas linhas, você pode facilmente mudar para Lambda.

A estrutura é muito simples, estamos simplesmente chamando outra função, que é predizer_user() e fornecendo como entrada o corpo json da solicitação POST.

prever_usuário()

 def predict_user(event): """ Gets the input details from the body of the POST request and returns the predicted user """ # Print the event for debugging purposes print(event) # Check if the message has the correct body structure if ['Model', 'HT', 'PPT', 'RRT', 'RPT'] == list(event.keys()): print(f"Model is:", event['Model']) if event["Model"] == "SVM": # Load the trained SVM model from the joblib file model_path = os.path.join(basedir, 'models', 'svm_model.joblib') model = joblib.load(model_path) elif event["Model"] == "RF": # Load the trained Random Forest model from the joblib file model_path = os.path.join(basedir, 'models', 'rf_model.joblib') model = joblib.load(model_path) elif event["Model"] == "XGBoost": # Load the trained XGBoost model from the joblib file model_path = os.path.join(basedir, 'models', 'xgb_model.joblib') model = joblib.load('model_path') # Extract the features from the event dictionary features = [ event['HT']['Mean'], event['HT']['STD'], event['PPT']['Mean'], event['PPT']['STD'], event['RRT']['Mean'], event['RRT']['STD'], event['RPT']['Mean'], event['RPT']['STD'] ] # Make a prediction using the loaded model and the extracted features prediction = model.predict([features]) # Return the predicted user return prediction[0]

Esta função é escrita de forma simplista, dependendo do parâmetro do modelo, decidimos carregar o modelo de ML pré-treinado específico.

Com o modelo pré-treinado fazemos a previsão do usuário e devolvemos ao solicitante. ( veja a última foto da resposta do Postman )

O treinamento dos modelos foi feito na parte I deste artigo, veja link acima .

Se você gostou do artigo e gostaria de me apoiar, certifique-se de:

🔔 Siga-me Bogdan Tudorache

🔔 Conecte-se comigo: LinkedIn | Reddit