Teilen Sie:
IOS-Entwickler, der sich für Data Science und maschinelles Lernen begeistert. Ich möchte, dass die Menschen verstehen, was maschinelles Lernen ist und wie wir es in unseren Applications nutzen können.
Erstellung eines Modells zur Vorhersage der Nutzerabwanderung mit Scikit-Learn und Vonage
Lesedauer: 13 Minuten
Mit der Conversation API von Vonage können Entwickler ihre eigene Contact Center-Lösung aufbauen. Mit Voice, Text und Integrationen zu anderen Lösungen können Sie mit Vonage eine komplexe Lösung aufbauen, ohne dass die Entwicklung komplex ist.
Wenn Sie Ihre Contact Center-Lösung aufbauen, muss sie intelligent sein. Die leistungsfähigsten Lösungen nutzen KI, um Anrufe weiterzuleiten, Texte zu übersetzen, Produkte zu empfehlen und so weiter. Das Tolle daran ist, dass Sie kein KI-Forscher mit Doktortitel sein müssen, um KI in Ihre Anwendung zu integrieren. Sie müssen sich auch nicht auf ein System eines Drittanbieters verlassen. Das scheint auf den ersten Blick unmöglich zu sein, aber es gibt viele Fortschritte bei den Bibliotheken für maschinelles Lernen, so dass Sie als Entwickler ein maschinelles Lernsystem in Ihre Lösung einbauen können. In diesem Beitrag werden wir uns mit der Möglichkeit befassen, die Wahrscheinlichkeit der Abwanderung eines Kunden vorherzusagen.
Die Abwanderung ist definitionsgemäß die Anzahl der Kunden, die Ihr Produkt nicht mehr nutzen, geteilt durch die Anzahl der Gesamtkunden. Ein Unternehmen mit einer Abwanderungsrate von 1 % pro Monat und 1000 Kunden bedeutet beispielsweise, dass 10 von 1000 Kunden den Dienst des Unternehmens jeden Monat nicht mehr in Anspruch nehmen. Sie wird als Indikator für die Leistung des Unternehmens verwendet. Ein Unternehmen mit geringer Kundenabwanderung bedeutet in der Regel, dass die Kunden dem Unternehmen treu bleiben. Eine höhere Abwanderungsrate bedeutet, dass die Kunden das Produkt oder die Dienstleistung zwar nutzen, dann aber abwandern.
Ein Kontaktzentrum ist ein Ort, an dem Kunden direkt mit dem Unternehmen interagieren, insbesondere mit dem Kundendienst. Und wenn Sie einen Kunden mit schlechtem Support verlieren, kann sich das auf die Kundenabwanderung und damit auf Ihr Unternehmen auswirken.
In diesem Beitrag erfahren Sie, wie Sie mit Hilfe der Vonage Conversation API eine Anwendung erstellen, die ein Gespräch zwischen einem Kunden und einem Agenten simuliert und die Wahrscheinlichkeit einer Abwanderung vorhersagen kann.
In unserer Demo haben wir zwei User Personas: einen Kunden und einen Agenten. In diesem Beispiel gehen wir davon aus, dass das Unternehmen ein Fernsehdienstleister ist und der Kunde eine Frage zu seinem Dienst hat. Wir gehen auch davon aus, dass dieser Kunde schon eine Weile bei dem Unternehmen ist, und wir haben Daten, die dies belegen.
In unserem Beispiel haben wir einige Informationen über den Benutzer. Dies könnte sein:
Wie lange (in Monaten) hat der Kunde den Dienst genutzt?
Ihre derzeitige Zahlungsmethode. (Scheck, Kreditkarte...)
Die von ihnen genutzten Dienste. (Live-TV, Set-Top-Box, Streaming-Dienste...)
Und viele mehr.
In unserer Demo zeigen wir dem Agenten bei der Interaktion mit dem Kunden die Abwanderungswahrscheinlichkeit auf dem Bildschirm des Agenten an, sobald dieser interagiert. Dies könnte für den Agenten hilfreich sein, bevor er das Gespräch beginnt, damit er dem Kunden je nach Abwanderungswahrscheinlichkeit mehr Aufmerksamkeit schenken kann.
Zugang zu Google Colab
Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.
Wir verwenden Hui Jing Chenden ausgezeichneten Blogbeitrag als Starthilfe. Wir werden diese Anwendung um unsere Funktion zur Vorhersage von Abwanderung erweitern.
Um unsere Anwendung lokal auszuführen, klonen wir das Projektarchivklonen, und wir müssen ngrok. Wenn Sie mit Ngrok nicht vertraut sind, lesen Sie bitte unser Ngrok-Anleitung bevor Sie fortfahren.
Bevor wir uns mit der Anwendung befassen, müssen wir zunächst unser Modell erstellen. Und um es zu erstellen, werden wir Jupyter-Notebooks die auf Google Colab laufen. Ein Jupyter-Notebook ist eine interaktive Methode zur Ausführung von Code und wird häufig in den Bereichen Data Science und maschinelles Lernen verwendet. Google Colab ist ein kostenloser Dienst, mit dem Sie diese Notebooks in der Cloud ausführen können. Den Code zum Erstellen des Notizbuchs finden Sie hierUm dieses Notizbuch auszuführen, laden Sie es zu Google Colab hoch.
In diesem Lernprogramm gehen wir davon aus, dass Sie ein grundlegendes Verständnis von maschinellem Lernen haben, aber Sie müssen nicht alles verstehen, um mitzukommen.
Um ein Modell zu erstellen, benötigen wir zunächst Daten. Und für dieses Beispiel verwenden wir Telecom Churn Dataset von IBM. Dieser Datensatz enthält 7043 Zeilen mit anonymisierten Nutzerdaten eines Telekommunikationsunternehmens. Um ein Verständnis für den Datensatz zu bekommen, schauen wir uns die ersten 10 Zeilen der Daten mit Pandas an. Pandas ist eine Python-Bibliothek zum Verarbeiten und Verstehen von Daten. Für jeden Benutzer gibt es 23 Spalten, die auch als Merkmale bezeichnet werden. Dazu gehören das Geschlecht des Kunden (männlich, weiblich), die Vertragsdauer (wie lange er schon Kunde ist) und ob er verschiedene Dienste nutzt, darunter Telefon, Internet und Fernsehen.
Um unser Modell zu erstellen, müssen wir zunächst sicherstellen, dass keine leeren Werte im Datensatz vorhanden sind. Wenn wir dies nicht überprüfen und versuchen, unser Modell zu erstellen, werden wir Fehler erhalten.
Lesen wir unseren Datensatz ein und entfernen wir alle leeren Werte.
df = pd.read_csv("/content/WA_Fn-UseC_-Telco-Customer-Churn.csv")
df = df.dropna(axis='columns', inplace=True)Als nächstes verwenden Sie df.head() um die ersten 10 Zeilen der Daten anzuzeigen. Wenn wir uns diese Daten ansehen, sehen wir, dass viele der Zeilen Zeichenketten enthalten. (YES, NO). Nun müssen wir diese Strings in Numbers umwandeln, denn Modelle für maschinelles Lernen können nur mit Zahlen umgehen.
Für jede Zeile, die eine Zeichenkette enthält, müssen wir prüfen, ob die Zeichenketten eindeutig sind. Um alle möglichen Werte in dieser Spalte zu sehen, hat Pandas eine Funktion, die unique() um dies für uns zu tun.
df.Partner.unique()zurück: array(['Yes', 'No'], dtype=object)
Dies bedeutet, dass die Zeile nur die Werte YES und NO. Für diese Spalte können wir diese Zeichenfolgen in Boolesche Werte (1,0) umwandeln. Wenn wir uns jedoch die anderen Zeilen ansehen, z. B. PaymentMethodsehen, gibt es mehr Werte als YES oder NO.
df.PaymentMethod.unique()gibt zurück. array(['Electronic check', 'Mailed check', 'Bank transfer (automatic)', 'Credit card (automatic)'], dtype=object)
Für diese Spalte müssen wir also ein wenig mehr Arbeit leisten. Wann immer ein Wert YES oder NOist, können wir ihn umwandeln in 1 oder 0umwandeln. Wenn es sich um eine beliebige andere Zeichenkette handelt, setzen wir sie in -1. Auch hier gilt, dass das maschinelle Lernmodell nur Numbers verwenden kann, deshalb setzen wir es auf -1.
Betrachten wir die anderen Spalten, PhoneService, MultipleLines, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, und StreamingMoviesscheinen sie ähnlich zu sein. Schreiben wir also eine Funktion, die jede Spalte durchläuft und unsere Zeichenketten in Ints umwandelt.
numeric_features = ['Partner', 'Dependents', 'PhoneService', 'MultipleLines','OnlineSecurity', 'OnlineBackup','DeviceProtection', 'TechSupport','StreamingTV', 'StreamingMovies', 'PaperlessBilling', 'Churn']
def to_numeric(s):
if s == "Yes":
return 1
elif s == "No":
return 0
else: return -1
for feature in numeric_features:
df[feature] = df[feature].apply(to_numeric)Numeric_features ist eine Liste aller Spalten, die wir aktualisieren müssen. to_numeric ist eine Funktion, die den Wert aus jeder Zeile aufnimmt und die Zeichenkette in eine Zahl umwandelt. Schließlich durchlaufen wir eine Schleife durch alle Elemente in to_numeric und rufen die Pandas-Funktion apply um unsere Funktion aufzurufen. Schauen wir uns die ersten 10 Zeilen an, um sie zu verifizieren.
Es sieht so aus, als ob diese Zeilen jetzt gültig sind, aber wir müssen uns mit den anderen Spalten befassen. Prüfen wir zunächst Contact und sehen uns die angezeigten Werte an.
df.Contract.unique()die zurückkommt: array(['Month-to-month', 'One year', 'Two year'], dtype=object)
Diese Werte sind immer noch Zeichenketten, aber es ist nicht so einfach wie die Konvertierung in 1's und 0's. Es gibt weitere Spalten in diesem Datensatz, die ähnlich sind, darunter PhoneService, MultipleLines, InternetService, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, StreamingMovies, Contract, PaperlessBilling. und PaymentMethod.
Glücklicherweise können wir in Pandas diese Werte konvertieren, indem wir get_dummies(). Diese Funktion erzeugt, wenn sie auf eine Spalte angewendet wird, eine neue Spalte für jeden möglichen Wert. Und jeder Wert in jeder dieser neuen Spalten wird zu 1 oder 0. Dies ist auch bekannt als one-hot-encoding.
Nehmen wir also zum Beispiel die Contract Spalte, die die Werte von Month-to-month, One year, und Two year. Mit get_dummies()werden wir 3 neue Spalten mit den Namen Contract_Month-to-month, Contract_One year und Contract_Two year. Und jeder Wert in diesen Spalten ist entweder 1 oder 0.
categorical_features = [
'PhoneService',
'MultipleLines',
'InternetService',
'OnlineSecurity',
'OnlineBackup',
'DeviceProtection',
'TechSupport',
'StreamingTV',
'StreamingMovies',
'Contract',
'PaperlessBilling',
'PaymentMethod']
df = pd.get_dummies(df, columns=categorical_features)Hier erstellen wir eine Liste dieser Merkmale, die wir in kategorische Merkmale umwandeln wollen, und rufen die Funktion get_dummies Funktion mit dem DataFrame(df) und der Liste der Spalten(categorical_features). Sehen wir uns noch einmal die ersten 10 Zeilen an, um unsere Arbeit zu überprüfen. Da der DataFrame jetzt 41 Merkmale enthält, verlinken wir auf die Zelle hier anstatt ein Bildschirmfoto des DataFrame zu zeigen
Es sieht so aus, als ob alle Spalten numerisch sind. Lassen Sie uns unser Modell erstellen. Um unser Modell zu erstellen, verwenden wir ein anderes Paket namens scikit-learn. Scikit-Learn hat viele eingebaute Funktionen zur Verarbeitung und zum Trainieren eines Modells mit unseren Daten.
Zunächst benötigen wir 2 Matrizen, X und y. X ist eine Matrix, die alle unsere Merkmale enthält, mit Ausnahme des Merkmals, das wir für die Vorhersage verwenden (Churn). Y ist einfach der Wert von Churn, der ein 1 oder 0.
X = df.drop(labels='Churn',axis=1)
Y = df.Churn
print(X.shape, Y.shape)Dies ergibt: ((7043, 40), (7043,)) Das bedeutet, dass es in X 7043 Zeilen und 40 Spalten gibt. Yhaben wir 7043 Zeilen.
Als nächstes müssen wir unsere Daten in einen Trainings- und einen Testsatz aufteilen. Beim Trainieren unseres Modells verwenden wir nur einen Teil des Datensatzes. Der Rest der Daten wird zum Testen verwendet. So können wir sehen, wie gut unser Modell die Daten gelernt hat. Mit Scikit-Learn teilen wir unseren Datensatz mit der Funktion train-test-split() Funktion.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,Y,test_size=0.3, random_state=42)Schließlich können wir ein Modell erstellen.
Für dieses Beispiel werden wir ein einfaches Modell verwenden. Aber in der realen Welt müssen wir verschiedene Modelle mit unserem Datensatz testen, um zu sehen, welches am besten ist. Darin liegt ein großer Teil der Arbeit beim maschinellen Lernen. Es gibt keine festen oder schnellen Regeln für die Auswahl eines Modells für Ihre Daten. Es kommt immer auf den Datensatz an.
Für dieses Beispiel werden wir Folgendes verwenden LogisticRegression um unser Modell zu trainieren. Es ist ein gutes Modell, um damit zu beginnen, da es im Allgemeinen gut mit Vorhersagen für boolesche Werte funktioniert. Scikit-learn macht es sehr einfach, dieses Modell zu implementieren.
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
model = LogisticRegression()
model.fit(X_train, y_train)Nachdem das Modell auf der Trainingsmenge trainiert wurde, können wir es nun auf der Testmenge verwenden, indem wir die Funktion predict Funktion aufrufen und unseren Testsatz (X_test).
model.predict(X_test)
# Print the prediction accuracy
print (metrics.accuracy_score(y_test, prediction_test))Mit metrics.accuracy_score können wir unsere Genauigkeit ausdrucken, 0.8135352579271179, was ~89% entspricht. Das bedeutet, dass unser Modell, wenn es Daten aus dem Testsatz erhält, um eine Vorhersage zu treffen, in etwa 89 % der Fälle richtig liegt. Beachten Sie, dass diese Genauigkeit nur eine von vielen Messgrößen ist, wenn Evaluierung eines Modells.
Sobald wir unser Modell haben, müssen wir es speichern, damit wir es in unserer Contact Center-App verwenden können. Um das Modell zu speichern, verwenden wir die joblib-Funktion dump.
Wir müssen auch die Namen der Spalten speichern, die wir für das Training verwendet haben, da wir sie verwenden werden, wenn wir unseren Server für die Vorhersagen erstellen.
model_columns = list(df.columns)
model_columns.remove('Churn')
joblib.dump(model_columns, 'model_columns.pkl')Als Nächstes bauen wir einen einfachen Python-Server, der dieses Modell bedient.
Als nächstes werden wir einen Flask Anwendung, um eine grundlegende Serveranwendung für unser Modell zu erstellen. Wir brauchen eine Möglichkeit, das Modell zu hosten und Vorhersagen zu treffen. Wäre dies eine Produktionsanwendung, müssten wir die Informationen des Nutzers speichern, die dieselben Informationen enthalten, die wir für das Training in unserem Datensatz verwendet haben. Dazu gehören die Dauer der Betriebszugehörigkeit des Benutzers, ob er InternetService, PhoneService, OnlineBackupusw... Auf diese Weise würden wir, wenn wir unsere Vorhersage machen, eine Abfrage an unsere Datenbank stellen, um die Benutzerinformationen zurückzugeben, eine Vorhersage anhand unseres Modells machen und die Wahrscheinlichkeit der Abwanderung zurückgeben. In diesem Beispiel werden wir jedoch die Informationen für einen Benutzer generieren und diese Vorhersage an die Anwendung zurücksenden.
Unter server.pywerden wir eine einfache Flask-Anwendung erstellen, die nur einen Endpunkt namens /predict. Dieser Endpunkt generiert die Daten des Benutzers, ruft unser Modell auf und gibt die Vorhersage als JSON-Antwort zurück.
Bevor wir die Vorhersage machen, müssen wir zunächst das gespeicherte Modell beim Start des Servers laden.
app = Flask(__name__)
@app.route('/predict', methods=['GET'])
@cross_origin()
def predict():
#will return prediction
return
if __name__ == '__main__':
model = joblib.load('model/model.pkl')
model_columns = joblib.load('model/model_columns.pkl')
app.run()Hier verwenden wir joblib um unser Modell und die Spalten zu laden, die wir für das Training verwendet haben. Wir müssen sicherstellen, dass wir die Spalten model.pkl und model_columns.pkl in unsere Serveranwendung kopieren. In der predict() Funktion werden wir die Daten eines zufälligen Benutzers generieren und einen neuen DataFrame aus den Daten unter Verwendung der gespeicherten Spaltennamen erstellen.
def predict():
random_user_data = generate_data()
#https://towardsdatascience.com/a-flask-api-for-serving-scikit-learn-models-c8bcdaa41daa
query = pd.get_dummies(pd.DataFrame(random_user_data, index=[0]))
query = query.reindex(columns=model_columns, fill_value=0)
#return prediction as probability in percent
prediction = round(model.predict_proba(query)[:,1][0], 2)* 100
return jsonify({'churn': prediction})Die Funktion generate_data() Funktion erstellt ein neues Wörterbuch, das die gleichen Spalten wie unser Trainingsdatensatz enthält und weist jeder Spalte einen Zufallswert zu.
def random_bool():
return random_number()
def random_number(low=0, high=1):
return random.randint(low,high)
def generate_data():
internetServices = ['DSL', 'Fiber optic', 'No']
contracts = ['Month-to-month', 'One year', 'Two year']
paymentMethods = ['Electronic check', 'Mailed check', 'Bank transfer (automatic)','Credit card (automatic)']
random_data = {
'name':'customer',
'Partner': random_bool(),
'Dependents': random_bool(),
'tenure': random_number(0,50),
'PhoneService': random_bool(),
'MultipleLines': random_number(-1),
'InternetService': random.choice(internetServices),
'OnlineSecurity': random_number(-1),
'OnlineBackup': random_number(-1),
'DeviceProtection': random_number(-1),
'TechSupport': random_number(-1),
'StreamingTV': random_number(-1),
'StreamingMovies': random_number(-1),
'Contract': random.choice(contracts),
'PaperlessBilling': random_bool(),
'PaymentMethod': random.choice(paymentMethods)
}
return random_dataFür InternetService, Contract und PaymentMethodwerden die möglichen Werte, die für jedes Merkmal verwendet werden können, hart kodiert, und es wird ein Zufallswert gewählt. Für die anderen Merkmale, wenn sie nur einen Yes oder No Wert in der Trainingsmenge enthält, weisen wir 1 oder 0Für die Merkmale, die den Wert Yes, No und eine andere Zeichenkette verwenden, werden wir 1, 0 und -1, beziehungsweise.
Als Nächstes gehen wir unsere Predict-Funktion durch, die aufgerufen wird, wenn eine Anfrage an den/predict Endpunkt.
@app.route('/predict', methods=['GET'])
@cross_origin()
def predict():
random_user_data = generate_data()
query = pd.get_dummies(pd.DataFrame(random_user_data, index=[0]))
query = query.reindex(columns=model_columns, fill_value=0)
#return prediction as probability in percent
prediction = round(model.predict_proba(query)[:,1][0], 2)* 100
return jsonify({'churn': prediction})Hier erzeugen wir Daten für einen zufälligen Benutzer und erstellen dann einen DataFrame, der genauso aussieht wie der DataFrame, den wir für das Training unseres Modells verwendet haben. Dieser hat die gleichen Spalten, aber nur eine Zeile des Datensatzes.
Schließlich rufen wir predict_proba auf, um einen Vektor für die Wahrscheinlichkeit der Abwanderung des Nutzers zurückzugeben. [[0.79329917 0.20670083]] Diese Matrix enthält die Wahrscheinlichkeit, dass der Nutzer abwandert (0,79329917) und dass er nicht abwandert (0,20670083). Wir nehmen das letzte Element des Vektors, runden auf 2 Dezimalstellen und wandeln es in einen Prozentsatz um.
prediction = round(model.predict_proba(query)[:,1][0], 2)* 100 Dies ergibt 21.0zurück, der den Prozentsatz der abwandernden Nutzer angibt.
Schließlich geben wir diesen Wert als JSON in einem churn Objekt zurück.
Als Nächstes werden wir unser Modell lokal ausführen und bereitstellen.
Navigieren Sie in Ihrem Terminal zum model_server Ordner und führen Sie ihn aus:
Jetzt läuft unser Modellserver, und wir können ihn testen, indem wir eine GET-Anfrage an den /predict Endpunkt.
Der Server gibt eine JSON-Antwort zurück, die den Prozentsatz der Wahrscheinlichkeit angibt, dass ein zufälliger Benutzer abwandert.
Nachdem wir unser maschinelles Lernmodell erstellt und ein Backend für unsere Vorhersagen entwickelt haben, werden wir es nun in eine Web-App integrieren, um einem Kundendienstmitarbeiter Abwanderungsvorhersagen anzuzeigen.
Um unsere Abwanderungsprognose zu zeigen, werden wir ein benutzerdefiniertes Konversationsereignis namens churn-prediction das aufgerufen wird, wenn der Modellserver seine Abwanderungsprognose für einen bestimmten Benutzer zurückgibt.
Im Ordner ui_app Ordner, navigieren Sie zur common.js Datei, innerhalb des Ordners public und fügen Sie Folgendes hinzu:
function getChurnForUser(conversation) {
//Send custom event to agent
if (window.location.pathname == "/") {
fetch("http://127.0.0.1:3001/predict",{
mode: 'cors',
headers: {
'Access-Control-Allow-Origin':'*'
}
})
.then(response => {return response.json()})
.then(json => {
conversation.sendCustomEvent({ type: 'churn-prediction', body: json}).then(() => {
console.log('custom event was sent');
}).catch((error)=>{
console.log('error sending the custom event', error);
});
})
.catch(error => console.log('error', error));
}
}
Diese Funktion akzeptiert die activate-Konversation und ruft den Modellserver auf, den wir zuvor erstellt haben. Der Einfachheit halber haben wir die URL und den Port fest codiert.
In einer Produktionsumgebung würden wir die user-id eingeben, um eine Vorhersage für diesen Benutzer zu erstellen. In diesem Beispiel werden jedoch, wie zuvor gezeigt, zufällige Benutzerdaten für das Modell zur Vorhersage der Abwanderung generiert.
Als nächstes fügen wir ein h2 Tag auf dem Bildschirm des Agenten, um die Abwanderungsvorhersage anzuzeigen. Dann fügen wir einen Listener zu churn-prediction Ereignis hinzu, das den Text innerhalb des h2 Tag aktualisiert. Innerhalb von setupListeners Funktion fügen wir dies hinzu:
activeConversation.on('churn-prediction', (sender, message) => {
if (window.location.pathname == "/agent") {
document.getElementById("churn_text").innerHTML = "Likelihood of customer churn: " + message["body"]["churn"] + "%"
console.log(sender, message);
}
});
Wenn das churn-prediction Ereignis ausgelöst wird, senden wir die Abwanderungsvorhersage in der message Eigenschaft und aktualisieren den innerHTML Text mit der Abwanderung.
Jetzt können wir jedes Mal, wenn ein neuer Benutzer mit unserem Agenten spricht, die Abwanderungswahrscheinlichkeit dieses Benutzers sehen. Wenn die Abwanderungswahrscheinlichkeit hoch ist, sollten wir vielleicht ein bisschen netter zu ihnen sein :)
Insgesamt haben wir gezeigt, dass die Erstellung eines Modells für maschinelles Lernen keine Zauberei ist und dass jeder etwas erstellen kann, das nützlich ist und in einer Produktionsumgebung verwendet werden kann. Wir haben gezeigt, dass unser Modell in der Lage ist, die Abwanderungswahrscheinlichkeit mit 89 % Genauigkeit vorherzusagen. Das ist großartig für unser erstes Modell. Aber es gibt noch viel mehr, was wir tun können, um ein noch besseres Modell zu entwickeln. Eine der besten Methoden, um zu lernen, ist, es selbst zu tun. Also lassen Sie uns sehen, ob Sie ein Modell erstellen können, das dieses Modell übertrifft!
Sie können das mitgelieferte Google Colab Notizbuch als Einstiegsprojekt verwenden. Wie immer helfen wir gerne bei Fragen in unserem Community-Slack.