Sie haben ein Deep-Learning-/Machine-Learning-Modell, was tun Sie als Nächstes?

Nachdem Sie Ihre Trainings- und Testdaten in mehreren Iterationen trainiert und getestet haben, haben Sie endlich die Feinabstimmung Ihres Modells abgeschlossen und sind bereit, es einzusetzen und zu verwenden und die gewünschte Wirkung zu erzielen, wissen aber nicht, was Sie als Nächstes tun sollen? Keine Sorge, wir führen Sie durch die verschiedenen Möglichkeiten, wie Sie Ihr Modell deployen können.

Bei größeren Projekten müssen Sie normalerweise mehrere Faktoren wie Datenspeicherung/-abruf, Feedback/Iteration und Frameworks usw. berücksichtigen, aber hier werden wir es so einfach wie möglich halten: Das Modell soll so schnell wie möglich in einen einsatzfähigen Zustand gebracht werden.

Hier sind die zwei Methoden/Anwendungsfälle, von denen Sie sich inspirieren lassen können, um Ihr nächstes Modell bereitzustellen:

• Bereitstellen eines Scikit-learn-ML-Modells mit Flask
• Bereitstellen eines Tensorflow-Modells mit Tensorflow-Serving

Inhaltsverzeichnis:

1. Bereitstellen eine Scikit-learn-ML-Modells mit Flask
2. Bereitstellen eine Tensorflow-Modells mit Tensorflow-Serving
3. Zusammenfassung

Bereitstellen eines Scikit-learn-ML-Modells mit Flask

Scikit-learn ist eine Python-basierte ML-Bibliothek, die weit verbreitete Regressions-, Klassifizierungs- und Clustering-Algorithmen bietet. Es bietet auch K-Means, Random Forests, SVM und Gradient Boosting usw. Es ist die Anlaufstelle für neue und fortgeschrittene Data Scientists, da es kostenlos und leicht verfügbar ist und eine Menge Community-Support und Diskussionsforen bietet.

Flask ist eine Webentwicklungsbibliothek, die auch für die Sprache Python frei verfügbar ist. Es bietet eine benutzerfreundliche Funktion zum Bereitstellen Ihrer Anwendung in wenigen einfachen Schritten.

Um ein Scikit-learn-Modell zu implementieren, sind drei Schritte erforderlich:

1. Erstellen Sie das ML-Modell, trainieren Sie es und validieren Sie es anschließend.

Natürlich benötigen wir für die Bereitstellung ein gültiges ML-Modell. Für die Zwecke dieses Lernprogramms entwickeln wir ein einfaches Random-Forest-Klassifikatormodell. Hier ist die einfachste Form des Modells im Code (Bitte beachten Sie, dass das Testen und die Validierung nicht Teil dieses Codes sind):

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split


df = pd.read_csv('possum.csv')
df = df.dropna()

X = df.drop(["case", "site", "Pop", "sex"], axis=1)
y = df["sex"]
       
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=44)
classifier = RandomForestClassifier(n_estimators=50, max_features="auto", random_state=44)
classifier.fit(X_train, y_train)

2. Speichern Sie das Modell

Oft kommt es vor, dass das Modell woanders eingesetzt wird als dort, wo es trainiert wurde. Dies geschieht, weil das Trainieren eines Modells im Vergleich zu den Ressourcen, die zum Bereitstellen des Modells erforderlich sind, eine andere umfangreichere Menge an Ressourcen erfordert. Scikit-learn bietet auch dafür eine Lösung.

import joblib

joblib.dump(classifier, 'classifier.pkl')

3. Richten Sie den Vorhersageserver ein

Jetzt richten wir den Endpunkt ein, den der Endbenutzer verwendet, um die Daten zu senden, um Vorhersagen zu treffen. Bitte beachten Sie, dass der Endpunkt JSON als Teil des Anfragetexts akzeptiert. Sie können „X_test.to_json()“ verwenden, um die JSON-Form der Testdaten zu erhalten. Hier ist der Code, den Sie benötigen, um den Endpunkt zu bedienen

from flask import Flask,request, jsonify

app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
     json_ = request.json
     query_df = pd.DataFrame(json_)
     query = pd.get_dummies(query_df)
    
     classifier = joblib.load('classifier.pkl')
     prediction = classifier.predict(query)
     return jsonify({'prediction': list(prediction)})


if __name__ == '__main__':
     app.run(port=8082)

Sie können jetzt zusammen mit dem JSON-Body eine POST-Anforderung an  http://127.0.0.1:8082/predict senden, um die Vorhersagen für die angegebenen Testdaten zu erhalten.

Bereitstellen eines Tensorflow-Modells mit Tensorflow-Serving

Tensorflow ist ein von Google entwickeltes und gepflegtes Framework, das umfangreiche Funktionen in Bezug auf Maschinelles Lernen bietet und sich mehr auf Deep Learning konzentriert. Tensorflow ist auch mein bevorzugtes Framework für die Arbeit mit Deep-Learning-Modellen. Tensorflow wird mit einem Modul namens Tensorflow Serving geliefert, das den Prozess vom Modell bis zur Bereitstellung vereinfacht. Es bietet REST out of the box und bietet für die Skalierung auch die Integration mit Docker und Kubernetes. Es unterstützt außerdem das Bereitstellen von Nicht-Tensorflow-Modellen, aber das ist nicht Teil dieses Tutorials. Die Bereitstellung eines Modells mit Tensorflow besteht aus 3 Schritten, die den im vorherigen Abschnitt beschriebenen ähneln.

1. Tensorflow-Modell erstellen

import tensorflow as tf
from tensorflow import keras

(x_train, y_train), (x_val, y_val) = keras.datasets.fashion_mnist.load_data()

def preprocess(x, y):
  x = tf.cast(x, tf.float32) / 255.0
  y = tf.cast(y, tf.int64)

  return x, y

def create_dataset(xs, ys, n_classes=10):
  ys = tf.one_hot(ys, depth=n_classes)
  return tf.data.Dataset.from_tensor_slices((xs, ys)) \
    .map(preprocess) \
    .shuffle(len(ys)) \
    .batch(128)

train_dataset = create_dataset(x_train, y_train)
val_dataset = create_dataset(x_val, y_val)

2. Modell trainieren

Nachdem die Datensätze erstellt wurden, können wir nun das neuronale Netz erstellen und trainieren.

Wir speichern dann auch das Modell, das dann auf dem Webserver bereitgestellt werden kann.

model = keras.Sequential([
    keras.layers.Reshape(target_shape=(28 * 28,), input_shape=(28, 28)),
    keras.layers.Dense(units=256, activation='relu'),
    keras.layers.Dense(units=192, activation='relu'),
    keras.layers.Dense(units=128, activation='relu'),
    keras.layers.Dense(units=10, activation='softmax')
])

model.compile(optimizer='adam', 
              loss=tf.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

history = model.fit(
    train_dataset.repeat(), 
    epochs=10, 
    steps_per_epoch=500,
    validation_data=val_dataset.repeat(), 
    validation_steps=2
)

model.save('mnist')

3. Vorhersageserver einrichten

Führen Sie den folgenden Befehl aus, um den Endpunkt einzurichten:

docker run -t --rm  -p 8503:8502 -v
"/Users/arsaljalib/jupyternotebooks/mnist:/models/mnist" -e
MODEL_NAME=mnist tensorflow/serving &

Der Endpunkt wäre jetzt erreichbar unter

http://localhost:8501/v1/models/mnist:predict

Sie können die Post-Anforderung jetzt zusammen mit dem JSON an diesen Endpunkt senden. Sie können den JSON für dieses Beispiel abrufen, indem Sie die folgenden Befehle in Python verwenden:

test_request = test_data.reshape(test_data.shape[0], 28, 28, 1)
data = json.dumps({"instances": test_ request [0:1].tolist()})

Zusammenfassung

Die Bereitstellung eines ML-Modells kann so einfach in drei bis vier Schritten erfolgen und ist nicht so kompliziert, wie es scheinen mag. Natürlich sind die hier bereitgestellten Beispiele sehr einfach, aber dies sollte Ihnen eine gute Vorstellung davon geben, wie Sie Deep Learning- und ML-Modelle in Betrieb nehmen und sie auf einem Endpunkt bereitstellen, wo der Endkunde sie verwenden kann, um Entscheidungen/Vorhersagen zu treffen.

Produktionsumgebungen können je nach Anforderung komplexer sein, aber diese Beispiele sollten Ihnen helfen, sich im Deployment wohl zu fühlen, und Ihnen einen Ausgangspunkt bieten.