Die Tastendynamik, die in den maschinellen Lernmodellen dieses Artikels zur Benutzererkennung verwendet wird, ist Verhaltensbiometrie. Die Tastaturdynamik nutzt die unterschiedliche Art und Weise, wie jede Person tippt, um ihre Identität zu bestätigen. Dies wird durch die Analyse der beiden Tastenanschlagereignisse „Tastendruck“ und „Tastenfreigabe“ erreicht, die auf Computertastaturen einen Tastenanschlag ausmachen, um Tippmuster zu extrahieren. In dem Artikel wird untersucht, wie diese ML-Modelle in realen Situationen verwendet werden können, um einen Benutzer vorherzusagen.

Im vorherigen Artikel wurde beschrieben, wie wir 3 ML-Modelle anhand einer Reihe von +880 Tastatureingaben von 100 Benutzern trainieren können, die aufgefordert wurden, 12 Mal denselben Text zu schreiben.

Die Apps, mit denen wir eine reale Situation simulieren werden.

Die Architektur

Sandbox : Um reale Szenarien zu testen, werden wir sie verwenden Briefträger + Flasche .

Produktion : Wenn wir diese Anwendung in die Produktion überführen möchten, können wir einfach die Bits des Flask-Codes durch Code für eine ersetzen AWS Lambda .

Flask ist ein Web-Framework, mit dem wir das Lambda + API Gateway replizieren können.

Lambda ist ein serverloser Webdienst, der in AWS gehostet wird und ereignisgesteuerten Code in verschiedenen Sprachen ausführen kann. Für diese App verwenden wir jedoch Python.

Der Datenfluss ist:

1. Wir laden den Header mit Identifikationsdaten und dem Modell, das wir verwenden möchten. Dies ist im Grunde unsere JSON-Nutzlast. In der Kopfzeile fügen wir auch den Autorisierungsschlüssel hinzu (nur Prod).
2. Wir führen eine HTTP-POST-Methodenanfrage an Flask App/API Gateway durch
3. API Gateway prüft den Autorisierungsschlüssel (API-Schlüssel) und sendet die Nutzdaten zur Verarbeitung an Lambda, wenn es die Anfrage akzeptiert
4. Die FlaskApp/Lambda führt den zugrunde liegenden Code aus
5. Was wir im Rückgabetext erhalten, ist die ID des vorhergesagten Benutzers, wenn das Ereignis erfolgreich ist. Andernfalls erhalten wir eine Fehlermeldung

Wie bereits erwähnt, finden Sie den gesamten Code auf der Github-Projektseite:

https://github.com/BogdanAlinTudorache/KeystrokeDynamics

Die Anfrage des Postboten

Roh

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

Sie können die Datei von GitHub herunterladen.

Körper

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

Die Flask-App / Lambda-App

Wenn wir den Prozess in einer Sandbox testen möchten, bevor wir alles zu AWS verschieben, müssen wir einen End-to-End-Aufruf mit Flask replizieren.

Wie starte ich die Flask-App?

Im GitHub finden Sie die Vollversion von flask_lambda_function.py und in jeder IDE müssen Sie nur das Skript ausführen, da es automatisch die Flask-App startet.

In meinem Fall verwende ich IntelliJ Idea, also führe ich einfach das Skript aus (klicken Sie mit der rechten Maustaste → Ausführen):

Testen eines realen Szenarios

Sobald das Skript im unteren Teil der IDE gestartet wird, sehen Sie die Python-Konsole, die Sie darüber informiert, dass der Webservice auf Localhost und Port 5000 gestartet wurde (ich denke, das ist die Standardeinstellung, kann aber auch konfiguriert werden).

Jedes Mal, wenn wir nun eine HTTP-Anfrage POST stellen, lösen wir die Flask-App aus und simulieren so ein reales Szenario.

POST-Anfrage:

Antwort der Python-Konsole:

Antwort des Postboten:

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

Der obige Code ist auf „flask-app“ eingestellt. Durch Kommentieren und Entfernen von Kommentaren in bestimmten Zeilen können Sie jedoch problemlos zu Lambda wechseln.

Die Struktur ist sehr einfach. Wir rufen einfach eine andere Funktion auf, nämlich Predict_user(), und stellen als Eingabe den JSON-Body aus der POST-Anfrage bereit.

predict_user()

 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]

Diese Funktion ist vereinfacht geschrieben, abhängig vom Modellparameter, den wir zum Laden des spezifischen vorab trainierten ML-Modells beschließen.

Mit dem vorab trainierten Modell führen wir die Benutzervorhersage durch und geben sie an den Anforderer zurück. ( siehe letztes Antwortfoto des Postboten )

Das Training der Modelle wurde in Teil I dieses Artikels durchgeführt, siehe Link oben .

Wenn Ihnen der Artikel gefällt und Sie mich unterstützen möchten, achten Sie darauf:

🔔 Folge mir Bogdan Tudorache

🔔 Verbinden Sie sich mit mir: LinkedIn | Reddit