Speichern eines vollständigen TensorFlow-Modells (Architektur + Parameter) in einer PostgreSQL-Datenbank | von Leonardo Godói | Juni 2023

0
25


Einrichten der PostgreSQL-Datenbank

Da wir PostgreSQL in seiner einfachsten Kind verwenden werden, empfehle ich die Ausführung eines PostgreSQL-Containers mit Docker anstatt PostgreSQL tatsächlich auf Ihrem Host zu installieren. Falls Sie Docker immer noch nicht auf Ihrem Pc installiert haben, können Sie den Hyperlink unten überprüfen, um es zu installieren.

https://docs.docker.com/get-docker/

Wenn Docker ordnungsgemäß installiert ist, können wir einfach mit dem folgenden Befehl einen PostgreSQL-Container ausführen.

docker run --name db-container -e POSTGRES_USERNAME=postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=db -p 5432:5432 -d postgres

Greifen wir auf unseren PostgreSQL-Container zu und navigieren wir zu der Datenbank, die wir im vorherigen Befehl angegeben haben.

docker exec -it db-container /bin/bash

psql -U postgres

c db;

Wir führen nun den folgenden Befehl aus, um eine Tabelle zum Speichern unseres Modells zu erstellen. Der Spaltentyp zum Speichern unseres Modells muss sein Byteadas die Speicherung von Binärzeichenfolgen unterstützt.

CREATE TABLE fashions (
id SERIAL PRIMARY KEY,
information BYTEA
);

Erstellen und Trainieren des neuronalen Netzwerks

Beginnen wir mit dem Importieren aller Pakete, die wir in diesem Tutorial benötigen.

import tensorflow as tf
import numpy as np
import pickle
import psycopg2

Jetzt können wir einige Zufallsdaten generieren, um unser Modell zu trainieren und auszuwerten. Dabei gehen wir von 1000 Stichproben mit 9 Merkmalen für das X-Array und 70 % Nullen (Klasse 0) und 30 % Einsen (Klasse 1) für das Y-Array aus. Sie können diese Parameter nach Belieben ändern.

n_samples = 1000
n_features = 9
X = np.random.random((n_samples, n_features))
y = np.random.alternative([0, 1], measurement=n_samples, p=[.7, .3])

In unserem Beispiel wird ein einfaches neuronales Netzwerk mit zwei dichten Schichten erstellt, einer Dropout-Schicht und einer Ausgabeschicht mit Sigmoidfunktion, geeignet für die binäre Klassifizierung. Da die Leistung des neuronalen Netzwerks für den Zweck dieses Tutorials nicht related ist, können Sie gerne Änderungen vornehmen.

original_model = tf.keras.fashions.Sequential([
tf.keras.layers.Flatten(input_shape=(n_features,)),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(16, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])

Wir kompilieren unser Modell mit dem Adam-Optimierer, legen Binary Cross Entropy als Verlustfunktion fest und überwachen die Genauigkeit des Modells.

original_model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])

Trainieren wir das Modell anhand der generierten Daten für 10 Epochen.

original_model.match(X, y, epochs=10)

Und bewerten Sie es, um seinen Verlust und seine Genauigkeit zu ermitteln.

original_loss, original_accuracy = original_model.consider(X, y)

Speichern des Modells in der Datenbank

Wir beginnen nun den Hauptteil dieses Tutorials mit der Serialisierung unseres Modells mithilfe von Essiggurke Modul.

pickled_original_model = pickle.dumps(original_model)

Daher stellen wir eine Verbindung zu der Datenbank her, die wir zuvor in diesem Tutorial erstellt haben.

conn = psycopg2.join(
host="localhost",
database="db",
port=5432,
consumer="postgres",
password="postgres")

Abschließend speichern wir das serialisierte Modell in der Bytea-Spalte der von uns erstellten Tabelle.

cursor = conn.cursor()
cursor.execute("INSERT INTO fashions (information) VALUES (%s) RETURNING id",
(pickled_original_model,))
conn.commit()

Es ist praktisch, die von PostgreSQL automatisch generierte ID für das gespeicherte Modell abzurufen.

model_id = cursor.fetchone()[0]

Abrufen des gespeicherten Modells

Jetzt verwenden wir die ID, um das Modell aus der Datenbank zurückzurufen.

pickled_retrieved_model = cursor.fetchone()[0]

Wir müssen das abgerufene Modell sofort deserialisieren, damit wir damit Vorhersagen treffen können.

retrieved_model = pickle.masses(pickled_retrieved_model)

Ähnlich wie beim Originalmodell werten wir das abgerufene Modellobjekt aus, um dessen Verlust und Genauigkeit für dieselben Daten zu ermitteln.

retrieved_loss, retrieved_accuracy = original_model.consider(X, y)

Vergleich des Originals und des wiederhergestellten Modells

Wenn wir den Verlust und die Genauigkeit beider Modelle ausdrucken, können wir überprüfen, ob das abgerufene Modell dem Authentic entspricht.

print(f"Authentic loss: {original_loss}")
print(f"Retrieved loss: {retrieved_loss}")
print(f"Authentic accuracy: {original_accuracy}")
print(f"Retrieved accuracy: {retrieved_accuracy}")
Authentic loss: 0.6023926734924316
Retrieved loss: 0.6023926734924316
Authentic accuracy: 0.7070000171661377
Retrieved accuracy: 0.7070000171661377

Durch den Vergleich der Metriken können wir den Schluss ziehen, dass das Modell erfolgreich gespeichert und abgerufen wurde, ohne dass seine Qualität beeinträchtigt wurde. Falls Sie jedoch noch einen genaueren Beweis dafür benötigen, dass die Modelle gleichwertig sind, können Sie einige aus dem Coaching resultierende Gewichte ausdrucken und vergleichen.

print(f"Some weights of authentic mannequin: {original_model.weights[0][0]}n")
print(f"Some weights of retrieved mannequin: {retrieved_model.weights[0][0]}")
Some weights of authentic mannequin: [-0.37762427 -0.31172457  0.16281793  0.20875677 -0.03447147 -0.01916301
0.0424621 0.26985747 -0.3445434 0.05018247 0.23163241 -0.37049234
-0.30362964 0.06312352 0.0663638 -0.26932436 0.02068468 -0.05438694
0.25234967 -0.34015387 0.20112173 -0.01952727 -0.08877492 0.3514789
0.19104229 -0.34066972 -0.29300463 0.09896617 -0.00937416 0.2626564
-0.28591692 -0.24513282]

Some weights of retrieved mannequin: [-0.37762427 -0.31172457 0.16281793 0.20875677 -0.03447147 -0.01916301
0.0424621 0.26985747 -0.3445434 0.05018247 0.23163241 -0.37049234
-0.30362964 0.06312352 0.0663638 -0.26932436 0.02068468 -0.05438694
0.25234967 -0.34015387 0.20112173 -0.01952727 -0.08877492 0.3514789
0.19104229 -0.34066972 -0.29300463 0.09896617 -0.00937416 0.2626564
-0.28591692 -0.24513282]

Das komplette Projekt

Das vollständige Projekt, das sich aus diesem Tutorial ergibt, ist im folgenden Repository verfügbar.

https://github.com/lfgodoi/tutorials



Source link

HINTERLASSEN SIE EINE ANTWORT

Please enter your comment!
Please enter your name here