La dynamique de frappe utilisée dans les modèles d'apprentissage automatique de cet article pour la reconnaissance des utilisateurs est la biométrie comportementale. La dynamique de frappe utilise la manière distinctive dont chaque personne tape pour confirmer son identité. Ceci est accompli en analysant les 2 événements de frappe sur Key-Press et Key-Release - qui constituent une frappe sur les claviers d'ordinateur pour extraire les modèles de frappe. L'article examinera comment ces modèles ML peuvent être utilisés dans des situations réelles pour prédire un utilisateur.

L'article précédent décrivait comment former 3 modèles ML, sur un ensemble de +880 saisies clavier provenant de 100 utilisateurs à qui il a été demandé d'écrire le même texte 12 fois.

Les applications que nous utiliserons pour simuler une situation réelle.

L'architecture

Sandbox : Afin de tester des scénarios réels, nous utiliserons Facteur + Ballon .

Production : Lorsque nous souhaitons mettre cette application en production, nous pouvons simplement remplacer les bits du code Flask par du code pour un AWS Lambda .

Flask est un framework Web que nous pouvons utiliser pour répliquer la passerelle Lambda + API.

Lambda est un service Web sans serveur hébergé sur AWS, qui peut exécuter du code piloté par des événements écrit dans différents langages. Cependant, pour cette application, nous utiliserons Python.

Le flux de données est :

1. Nous chargeons l'en-tête avec les données d'identification et le modèle que nous voulons utiliser, il s'agit essentiellement de notre charge utile json. Dans l' en-tête nous ajouterons également la clé d'autorisation (Prod uniquement)
2. Nous effectuons une requête de méthode HTTP POST à Flask App/API Gateway
3. API Gateway vérifie la clé d'autorisation (clé API) et si elle accepte la demande, envoie la charge utile à Lambda pour traitement
4. FlaskApp/Lambda exécute le code sous-jacent
5. Ce que nous obtenons dans le corps de retour est l'ID de l'utilisateur prédit si l'événement réussit, sinon nous obtenons un message d'erreur.

Comme mentionné précédemment, tout le code que vous pouvez trouver sur la page du projet Github :

https://github.com/BogdanAlinTudorache/KeystrokeDynamics

La demande du facteur

Brut

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

Vous pouvez télécharger le fichier depuis GitHub.

Corps

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

L'application Flask / l'application Lambda

Si nous voulons tester le processus en sandbox avant de tout déplacer vers AWS, nous devons répliquer un appel de bout en bout à l'aide de Flask.

Comment démarrer l'application Flask ?

Dans le GitHub, vous trouverez la version complète de flask_lambda_function.py et dans n'importe quel IDE, il vous suffit d'exécuter le script car il démarrera automatiquement l'application flask.

Dans mon cas, j'utilise IntelliJ Idea donc j'exécute simplement le script (clic droit → exécuter) :

Tester un scénario réel

Une fois le script démarré dans la partie inférieure de l'IDE, vous verrez la console Python vous informant que le service Web a démarré sur localhost et le port 5000 (je pense que c'est la valeur par défaut mais cela peut également être configuré).

Désormais, chaque fois que nous effectuons une requête HTTP POST, nous devrons déclencher l'application flask, simulant un scénario réel.

Requête POST :

Réponse de la console Python :

Réponse du facteur :

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

Le code ci-dessus est défini sur flask-app, mais en commentant et en décommentant certaines lignes, vous pouvez facilement passer à Lambda.

La structure est très simple, nous appelons simplement une autre fonction, qui est Predict_user() et fournissons en entrée le corps json de la requête POST.

prédire_utilisateur()

 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]

Cette fonction est écrite de manière simpliste, en fonction du paramètre de modèle que nous décidons de charger le modèle ML pré-entraîné spécifique.

Avec le modèle pré-entraîné, nous effectuons la prédiction de l'utilisateur et la renvoyons au demandeur. ( voir dernière photo de réponse du facteur )

La formation des modèles a été réalisée dans la partie I de cet article, voir lien ci-dessus .

Si vous aimez l’article et souhaitez me soutenir, assurez-vous de :

🔔 Suivez-moi Bogdan Tudorache See More

🔔 Connectez-vous avec moi : LinkedIn | Reddit