La dinámica de pulsaciones de teclas que se utiliza en los modelos de aprendizaje automático de este artículo para el reconocimiento de usuarios es biométrica del comportamiento. La dinámica de pulsaciones de teclas utiliza la forma distintiva en que cada persona escribe para confirmar su identidad. Esto se logra analizando los dos eventos de pulsación de tecla al presionar y soltar la tecla, que componen una pulsación de tecla en los teclados de computadora para extraer patrones de escritura. El artículo examinará cómo se pueden utilizar estos modelos de aprendizaje automático en situaciones de la vida real para predecir un usuario.

El artículo anterior describió cómo podemos entrenar 3 modelos de ML, en un conjunto de +880 entradas de teclado de 100 usuarios a los que se les pidió que escribieran el mismo texto 12 veces.

Las aplicaciones que usaremos para simular una situación de la vida real.

La arquitectura

Sandbox : Para probar escenarios de la vida real usaremos Cartero + Matraz .

Producción : cuando queramos mover esta aplicación a producción, simplemente podemos reemplazar los bits del código de Flask con código para un AWS Lambda .

Flask es un marco web que podemos usar para replicar Lambda + API Gateway.

Lambda es un servicio web sin servidor alojado en AWS, que puede ejecutar código basado en eventos escrito en varios idiomas; sin embargo, para esta aplicación usaremos Python.

El flujo de datos es:

1. Cargamos el encabezado con los datos de identificación y el modelo que queremos usar, este es básicamente nuestro payload json. En el encabezado también agregaremos la clave de autorización (solo Prod)
2. Realizamos una solicitud del método HTTP POST a Flask App/API Gateway
3. API Gateway verifica la clave de autorización (clave de API) y, si acepta la solicitud, envía la carga útil a Lambda para su procesamiento.
4. FlaskApp/Lambda ejecuta el código subyacente
5. Lo que obtenemos en el cuerpo de la devolución es el ID del usuario previsto si el evento tiene éxito; de lo contrario, obtenemos un mensaje de error.

Como se mencionó anteriormente, todo el código se puede encontrar en la página del proyecto Github:

https://github.com/BogdanAlinTudorache/KeystrokeDynamics

La petición del cartero

Crudo

 { "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": [] } ] }

Puede descargar el archivo desde GitHub.

Cuerpo

 { "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 } }

La aplicación Flask/la aplicación Lambda

Si queremos probar el proceso en un entorno de pruebas antes de mover todo a AWS, debemos replicar una llamada de un extremo a otro usando Flask.

¿Cómo iniciar la aplicación Flask?

En GitHub, encontrará la versión completa de flask_lambda_function.py y en cualquier IDE solo necesita ejecutar el script, ya que iniciará automáticamente la aplicación flask.

En mi caso, estoy usando IntelliJ Idea, así que simplemente ejecuto el script (haga clic derecho → ejecutar):

Probando un escenario de la vida real

Una vez que se inicia el script en la parte inferior del IDE, verá la consola de Python informando que el servicio web se inició en el host local y el puerto 5000 (creo que esto es el valor predeterminado, sin embargo, también se puede configurar).

Ahora, cada vez que hagamos una solicitud HTTP POST, activaremos la aplicación flask, simulando un escenario de la vida real.

Solicitud de publicación:

Respuesta de la consola Python:

Respuesta del cartero:

Código profundo

 @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)})

El código anterior está configurado en flask-app; sin embargo, al comentar y descomentar ciertas líneas, puede cambiar fácilmente a Lambda.

La estructura es muy simple, simplemente llamamos a otra función, que es predict_user() y proporcionamos como entrada el cuerpo json de la solicitud POST.

predecir_usuario()

 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 función está escrita de manera simplista; según el parámetro del modelo, decidimos cargar el modelo de ML previamente entrenado específico.

Con el modelo previamente entrenado hacemos la predicción del usuario y se la devolvemos al solicitante. ( ver la última foto de respuesta del cartero )

El entrenamiento de los modelos se realizó en la parte I de este artículo, consulte el enlace anterior .

Si te gusta el artículo y quieres apoyarme, asegúrate de:

🔔 Sígueme Bogdan Tudorache

🔔 Conéctate conmigo: LinkedIn | Reddit