Eine Schritt-für-Schritt-Anleitung zum Bereitstellen von ML-Modellen mit Streamlit

Einführung

Die meisten Enthusiasten des maschinellen Lernens schreiben sich für einige Kurse und Lehrpläne ein, um mit KI und ML zu beginnen. Diese Kurse decken viele grundlegende Dinge ab und leiten die Lernenden sauber an, um die hochmodernen ML-Modelle zu erstellen und zu trainieren.

Aber eine Sache, mit der die meisten Anfänger zu kämpfen haben, ist der Bereitstellungsteil. Ein maschinelles Lernprojekt kann nicht ohne eine interaktive App um es herum belassen werden. Damit Benutzer einfach mit dem Modell interagieren oder sogar unsere Projekte präsentieren können, müssen wir sie mithilfe von Cloud-Diensten in Web-Apps, Android-Apps oder eine Art API-Struktur einbetten.

Es gibt verschiedene Möglichkeiten, diese Wrapper für unsere Modelle zu erstellen, aber in diesem Artikel werde ich mich darauf konzentrieren, wie Sie Streamlit als Lösung für dieses Problem verwenden können und warum ich es für ein so leistungsstarkes Tool halte.

Dieser Artikel enthält eine Schritt-für-Schritt-Anleitung zum Erstellen eines ML-Projekts und zum Erstellen einer Web-App-Plattform dafür mit Streamlit. Das Projekt, das wir bauen werden, ist ein kalifornisches Hauspreisvorhersagemodell. Die Website wird dynamisch sein und Hyperparameter wie die Lernrate, die Anzahl der Neuronen usw. können direkt über die Web-App geändert und damit experimentiert werden.

Wenn Sie mit dem Erstellen einer solchen Webanwendung mit einigen Frameworks wie Flask oder Django fortfahren, bin ich mir fast sicher, dass es viel Zeit in Anspruch nehmen wird, diese Benutzeroberfläche zuerst zu erstellen, und dann gibt es ein weiteres Problem, sie auf einem Server zu hosten es kann für jeden zugänglich sein.

Und hier stellt sich die Hauptfrage: „Warum sollten Enthusiasten des maschinellen Lernens ihre Zeit mit dem Erlernen einiger UI-Frameworks verschwenden, wenn sie stattdessen diese wertvolle Zeit zum Lernen verwenden können, um bessere Modelle zu erstellen?“

Hier werden viele Themen behandelt, wie Sie Streamlit für Ihre Projekte verwenden können. Fühlen Sie sich frei, zu den Teilen zu springen, über die Sie mehr erfahren möchten.

• Warum Streamlit?
• Erstellen eines grundlegenden ML-Modells
• Hinzufügen der Magie mit Streamlit
• Bereitstellen der Streamlit-Web-App
• Fazit

Warum Streamlit?

Streamlit macht es uns sehr einfach und schnell, eine Web-App für maschinelles Lernen zu erstellen. Andere Möglichkeiten, die zum Entwickeln solcher Wrapper für ML-Modelle verfügbar sind, sind nicht sehr komfortabel.

Flask ist ein Python-Framework, mit dem Benutzer Web-Apps entwickeln und mithilfe der Python-Sprache bereitstellen können. Es erfordert gute Python-Kenntnisse und wir müssen auch Zeit investieren, um es zu lernen. Auch danach ist es im Vergleich zu Streamlit nicht ganz einfach, eine Web-App zu entwickeln.

Django ist ein weiteres Python-basiertes Framework für die Webentwicklung. Man kann sagen, dass es eine bessere und komplexere Version von Flask ist. Es erfordert viel Zeit, dieses Framework zu erlernen, und schließlich ist das Erstellen einer Web-App, die es verwendet, nicht so schnell, wie wir es uns wünschen würden.

Tensorflow.js ist eine sehr gute Möglichkeit, Modelle zu speichern, die mit Webplattformen kompatibel sind, und diese Modelle können dann zum Erstellen von Web-Apps verwendet werden. Viele der komplexen Implementierungen von ML-Modellen und High-Level-Architekturen werden noch nicht von Tensorflow.js unterstützt. Es gibt viele Modelle, die in Python funktionieren und möglicherweise nicht in Javascript in der Tensorflow.js-Bibliothek.

Wie ich bereits sagte, sollten wir unsere Zeit nicht damit verschwenden, diese Frameworks zu lernen, und stattdessen lernen, wie man gute ML-Modelle erstellt. Und hier kommt Streamlit ins Spiel. Es ist der einfachste und schnellste Weg, Webanwendungen zu entwickeln. Die mit Streamlit erstellten Web-Apps haben großartige UI-Elemente und sind sehr einfach zu bedienen.

Um meine Behauptung zu untermauern, dass Streamlit der einfachste und schnellste Weg zum Erstellen von ML-Webanwendungen ist, möchte ich Ihnen mitteilen, wie ich auf dieses Framework gestoßen bin. Ich habe gelernt, wie man GANs baut und damit künstliche Gesichter generiert, Schwarz-Weiß-Skizzen in bunte umwandelt und solche Implementierungen.

Die Modelle funktionierten gut im Jupyter-Notebook, aber ich wollte es mit anderen teilen. Ich begann, nach Frameworks zu suchen, um eine App zu erstellen und das Modell zu hosten, aber ich wollte meine Zeit nicht damit verschwenden, ein weiteres Framework zu lernen, da ich andere GAN-Implementierungen erkunden wollte.

Ich habe mir alle alternativen Ressourcen angesehen, über die ich zuvor in diesem Artikel gesprochen habe. Das im Sketch-To-Color-Generierungsprojekt verwendete Generatormodell ist etwas komplex. Es ist ein U-Net-Architekturmodell und erfordert, dass Sie Verbindungen überspringen.

Aufgrund seiner hohen Komplexität war es mir nicht möglich, das endgültige Modell mit Tensorflow.js für Javascript zu konvertieren. Flask oder Django von Grund auf neu zu lernen, war für mich keine Option, also begann ich, nach anderen Frameworks oder Bibliotheken zu suchen.

Dabei bin ich auf Streamlit gestoßen. In einem Artikel von Adrien Treuille zeigt er, wie er in weniger als 13 Codezeilen eine erstaunliche Web-App für ein TL-GAN erstellt hat. Das alles war nur dank Streamlit möglich.

Die Dokumentation auf ihrer offiziellen Website ist ebenfalls sehr präzise und hilfreich. Ich habe versucht, eine Streamlit-Web-App für mein Sketch-to-Color-GANs-Modell zu erstellen, und es war erstaunlich. Ich musste nur 12 Codezeilen zu meinem vorhandenen Python-Code hinzufügen. Aus diesem Grund habe ich mich endlich daran gemacht, Streamlit zu erkunden und andere Projekte damit zu erstellen.

Erstellen eines grundlegenden ML-Modells

Wie bereits erwähnt, werden wir uns für dieses Beispiel das Problem der kalifornischen Hauspreisvorhersage ansehen. Lassen Sie uns zunächst sehen, wie wir normalerweise ein Modell dafür erstellen. Es ist ein Regressionsproblem.

Zunächst importieren wir die erforderlichen Bibliotheken für unser einfaches ML-Modell. Hier verwenden wir TensorFlow, Pandas und NumPy.

Tensorflow als tf importieren

importiere numpy als np

pandas als pd importieren

Jetzt werden wir die Datensätze von Scikit-Learn verwenden, um den kalifornischen Wohnungsdatensatz herunterzuladen.

aus sklearn.datasets importieren Sie fetch_california_housing

Gehäuse = fetch_california_housing()

Als nächstes müssen wir die geladenen Daten in Trainings-, Validierungs- und Testsätze aufteilen. Dazu stehen viele Methoden zur Verfügung. Wir werden die Funktion train_test_split verwenden, die in der Scikit-Learn-Bibliothek verfügbar ist. Wenn Sie es zweimal verwenden, wird der Datensatz in 3 Sätze trainieren, validieren und testen unterteilt.

aus sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

Gehäuse.Daten, Gehäuse.Ziel

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_Zug_voll, y_Zug_voll

)

Die uns zur Verfügung stehenden Daten enthalten Längen- und Breitengrade für jeden Eintrag. Um dies besser zu visualisieren, können wir ein Streudiagramm auf einer Karte erstellen. Um die Karten zu verwenden, werden wir die Altair- Bibliothek importieren.

Altair als Alt importieren

map_data = pd.DataFrame(

X_Zug,

Spalten=[

'MedInc',

'Hausalter',

'AveRooms',

'AveBedrms',

'Bevölkerung',

'AveOccup',

'Breite',

'Längengrad'

])

Mittelpunkt = (np.average(map_data[„Breitengrad“]), np.average(map_data[„Längengrad“]))

st.write(pdk.Deck(

map_style=”mapbox://styles/mapbox/light-v9″,

initial_view_state={

„Breitengrad“: Mittelpunkt[0],

„Längengrad“: Mittelpunkt[1],

„zoomen“: 6,

„Tonhöhe“: 75,

},

Schichten=[

pdk.Layer(

„HexagonSchicht“,

data=map_data,

get_position=["Längengrad", "Breitengrad"],

Radius=1000,

Elevation_scale=4,

Höhenbereich=[0, 10000],

pickable=True,

extrudiert = wahr,

),

],

))

Die Daten, die wir jetzt bei uns haben, werden für das Modell nicht gut verarbeitet. Wir müssen die Vorverarbeitung durchführen, um bessere Ergebnisse zu erzielen. Zunächst müssen wir die Werte normalisieren, da die meisten Machine-Learning-Modelle am besten funktionieren, wenn die Daten in einem kleinen Wertebereich liegen. Dazu verwenden wir die StandardScaler-Klasse aus der sklearn-Bibliothek.

aus sklearn.preprocessing importieren Sie StandardScaler

Scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

Nach der Aufbereitung der Daten erstellen wir nun ein Modell. Dieses Modell ist ein neuronales Netzwerk mit einer bestimmten Anzahl von Neuronen in der ersten Eingabeschicht und einem einzelnen Neuron in der letzten Schicht, da es sich um ein Regressionsproblem handelt. Dies kann durch die Verwendung der TensorFlow-Bibliothek erreicht werden.

Tensorflow als tf importieren

model = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

In TensorFlow müssen wir das Modell nach dem Erstellen kompilieren. Hier müssen wir die Verlustfunktion erwähnen, die wir verwenden werden, und auch den Optimierer, den wir wollen. Wir werden die mittlere quadratische Fehlerverlustfunktion und den SGD-Optimierer mit einer bestimmten Lernrate verwenden.

modell.compile(

loss='mean_squared_error',

optimizer=tf.keras.optimizers.SGD(l_rate)

)

Alles ist jetzt an Ort und Stelle. Alles, was wir tun müssen, ist das Modell zu trainieren. In TensorFlow kann dies durch einen einfachen Aufruf der Methode fit() erfolgen. Wir können alle Protokolle in einer Variablen, history , speichern .

Geschichte = model.fit (

X_Zug,

y_zug,

Epochen=n_Epochen,

validation_data=(X_gültig, y_gültig)

)

Nach dem Training können wir auch die Genauigkeit und den Verlust unseres Modells mit der Methode „evaluate()“ bewerten.

Evaluation = model.evaluate(X_test, y_test)

Wenn wir nun mithilfe dieses Modells Hauspreise vorhersagen möchten, können wir dies einfach tun, indem wir die Methode " predict() " aufrufen .

X_neu = X_test[:3]

Vorhersagen = model.predict(X_new)

So können Sie mit TensorFlow, scikit-learn und Pandas ein einfaches Hauspreisvorhersagemodell erstellen. Aber das Problem, wie Sie sehen können, ist, dass es keine Möglichkeit gibt, dieses Modell anderen Benutzern zu zeigen, wo sie damit interagieren können, und dies ist nur ein Modell in einem Jupyter Notebook. Lassen Sie uns jetzt etwas Magie mit Streamlit hinzufügen!

Lesen Sie auch: Projektideen für maschinelles Lernen

Hinzufügen der Magie mit Streamlit

Um eine Web-App für maschinelles Lernen zu erstellen, müssen Sie nur ein paar Codezeilen für Streamlit-Funktionsaufrufe hinzufügen, und das war's. Sie benötigen kein HTML, CSS oder Javascript. Nur reine Python!

Ja, Sie haben richtig gelesen. Sie brauchen sich um nichts weiter zu kümmern. Installieren Sie einfach Streamlit auf Ihrem System und Sie können loslegen. Verwenden Sie den folgenden Befehl in Ihren Terminals:

pip installieren streamlit

Sie können den folgenden Befehl verwenden, um sich in ihrer Hallo-Welt-App umzusehen. Es ist ein gutes Beispiel dafür, wie die Web-Apps mit Streamlit aussehen.:

strombeleuchtetes hallo

Nachdem Sie Streamlit lokal installiert und die magische Zeile zum Code hinzugefügt haben, müssen Sie nur den folgenden Befehl ausführen, um die App lokal auszuführen:

streamlit run file_name.py

Die Frage lautet nun also: „Was sind diese magischen Codezeilen?“ Sie sind ganz einfach. Ich erkläre zuerst die grundlegenden Funktionen, die in Streamlit verwendet werden, und zeige dann den Code, damit Sie ihn direkt mit dem Beispiel in Verbindung bringen können.

Vor allem importieren wir die Streamlit-Bibliothek mit der folgenden Codezeile:

streamlit als st importieren

Die erste wichtige Funktion ist, dass Sie einfach alles in die 3 doppelten Anführungszeichen eingeben können, es zeigt einfach den Text so an, wie er in der Web-App ist. Es unterstützt die Syntax der Markdown-Sprache. Sie können also viele Dinge tun, z. B. Überschriften, Aufzählungszeichen, Tabellen und vieles mehr. Anstelle dieser Notation können Sie auch die Funktion st.write() verwenden. Es hat die gleiche Funktionalität.

Als nächstes kommt die Funktion with st.echo():. Dies führt im Grunde den darin geschriebenen Python-Code aus und zeigt ihn dann auch in der Web-App. Auf diese Weise können wir eine Web-App erstellen, die zeigt, wie sie erstellt wurde.

st.empty() ist ein Bereich, der später für einige dynamische Inhalte reserviert ist.

st.spinner() zeigt ein Ladeelement, wenn es bei der Ausführung eines Codeabschnitts zu Verzögerungen kommt.

st.success() zeigt eine Nachricht in grüner Farbe. Dies hat einen großartigen Designaspekt für erfolgreiche Dialoge.

st.sidebar() zeigt den Inhalt standardmäßig in einer Seitenleiste links an.

st.sidebar.slider() bietet einen Schieberegler in der Seitenleiste, um Werte aus einem Bereich vorgegebener Zahlen auszuwählen. st.sidebar.selectbox() ermöglicht es Ihnen, einen Wert aus der gegebenen Liste auszuwählen und Streamlit hat noch viele weitere wunderbare Funktionen und Features. Einige der Funktionen sind wie folgt:

• Live ändert sich, wenn Sie die Datei speichern
• Führen Sie die App erneut aus, indem Sie einfach R auf der Tastatur drücken
• Löschen Sie den Cache, indem Sie einfach C auf der Tastatur drücken
• Nehmen Sie die Web-App auf und speichern Sie eine Videodatei lokal, um sie mit allen zu teilen

…Und vieles mehr

Muss gelesen werden: Karriere im maschinellen Lernen

Der Code

streamlit als st importieren

altair als alt importieren

pydeck als pdk importieren

train_area = st.leer()

"""

# Immobilienpreise in Kalifornien

Dies ist der Datensatz der kalifornischen Wohnungspreise, der Daten aus der US-Volkszählung von 1990 enthält. Die folgende Tabelle enthält Beschreibungen, Datenbereiche und Datentypen für jedes Feature im Datensatz.

## Werfen wir zunächst einen Blick auf Importe

"""

mit st.echo():

Tensorflow als tf importieren

importiere numpy als np

pandas als pd importieren

"""

## Laden des Datensatzes

Wir werden das Datensatzmodul von scikit-learn verwenden, um Daten zu führen, die bereits für uns bereinigt sind und nur die numerischen Merkmale aufweisen.

"""

mit st.echo():

aus sklearn.datasets importieren Sie fetch_california_housing

Gehäuse = fetch_california_housing()

"""

Dadurch werden die gesamten Daten in die Variable „housing“ geladen, wie Sie unten sehen können

"""

st.subheader('Eingabefunktionen')

Gehäuse.Daten

st.subheader('Ausgabeetiketten')

Gehäuse.Ziel

"""

## Aufteilen der Daten in Train-, Test- und Dev-Sets

Dies ist eines der wichtigsten Dinge am Anfang jeder Lösung für maschinelles Lernen, da das Ergebnis eines Modells stark davon abhängen kann, wie gut Sie die Daten auf diese Sätze verteilt haben.

Zum Glück für uns haben wir scikit-learn zur Rettung, wo es so einfach wie 2 Codezeilen geworden ist.

"""

mit st.echo():

aus sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

Gehäuse.Daten, Gehäuse.Ziel

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_Zug_voll, y_Zug_voll

)

"""

Die Funktion „train_test_split()“ teilt die Daten in 2 Sätze auf, wobei der Testsatz 25 % des gesamten Datensatzes ausmacht. Wir haben dieselbe Funktion erneut auf train_full verwendet, um sie in Zug- und Validierungssätze aufzuteilen. 25 % ist ein Standardparameter und Sie können ihn nach Ihren Bedürfnissen anpassen. Sehen Sie es sich in der [Dokumentation von Scikit-Learn] (https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) an.

## Ein Blick auf die Zugdaten

Die Spalten stellen die folgenden Daten dar:

"""

st.write(housing.feature_names)

"""

Sehen wir uns nun die Lage der Häuser an, indem wir sie mit Breiten- und Längengradwerten auf der Karte einzeichnen:

"""

mit st.echo():

map_data = pd.DataFrame(

X_Zug,

Spalten=[

'MedInc',

'Hausalter',

'AveRooms',

'AveBedrms',

'Bevölkerung',

'AveOccup',

'Breite',

'Längengrad'

])

Mittelpunkt = (np.average(map_data[„Breitengrad“]), np.average(map_data[„Längengrad“]))

st.write(pdk.Deck(

map_style=”mapbox://styles/mapbox/light-v9″,

initial_view_state={

„Breitengrad“: Mittelpunkt[0],

„Längengrad“: Mittelpunkt[1],

„zoomen“: 6,

„Tonhöhe“: 75,

},

Schichten=[

pdk.Layer(

„HexagonSchicht“,

data=map_data,

get_position=["Längengrad", "Breitengrad"],

Radius=1000,

Elevation_scale=4,

Höhenbereich=[0, 10000],

pickable=True,

extrudiert = wahr,

),

],

))

"""

**Sie können gerne hineinzoomen oder ziehen, während Sie die ALT-Taste gedrückt halten, um den 3D-Ansichtswinkel der Karte nach Bedarf zu ändern.**

## Vorverarbeitung

Wie bereits erwähnt, ist dieser Datensatz von scikit-learn bereits gut vorverarbeitet, damit wir ihn direkt verwenden können, ohne uns Gedanken über NaN-Werte und andere Dinge machen zu müssen.

Wir werden die Werte jedoch in bestimmten Bereichen skalieren, indem wir "StandardScaler" verwenden, damit unser Modell effizient arbeitet.

"""

mit st.echo():

aus sklearn.preprocessing importieren Sie StandardScaler

Scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

"""

## Erstellen eines Modells

Wir werden ein einfaches sequentielles Modell erstellen, dessen erste Schicht 30 Neuronen und die Aktivierungsfunktion von RELU enthält.

Die nächste Schicht wird eine einzelne Neuronenschicht ohne Aktivierungsfunktion sein, da das Modell eine Reihe von Werten vorhersagen soll und nicht nur binäre oder mehrklassige Ergebnisse wie Klassifizierungsprobleme.

"""

st.sidebar.title('Hyperparameter')

n_neurons = st.sidebar.slider('Neuronen', 1, 128, 30)

l_rate = st.sidebar.selectbox('Lernrate', (0.0001, 0.001, 0.01), 1)

n_epochs = st.sidebar.number_input('Anzahl der Epochen', 1, 50, 20)

#Die n_neurons, l_rate und _nepochs sind die Eingaben, die vom Benutzer zum Trainieren des Modells genommen werden. Die Standardwerte für sie sind ebenfalls festgelegt. Der Standardwert für n_neurons ist 30, der Standardwert für l_rate ist 0,01 und der Standardwert für n_epochs ist 20. Zu Beginn hat das Modell also 30 Neuronen in der ersten Schicht, die Lernrate ist 0,01 und die Anzahl der Epochen für wofür das Modell trainieren wird, ist 20.

mit st.echo():

Tensorflow als tf importieren

model = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

"""

## Kompilieren des Modells

Die Tensorflow-Keras-API stellt uns die Funktion „model.compile()“ zur Verfügung, um die Optimierer, die Verlustfunktion und einige andere Details für das Modell zuzuweisen.

"""

mit st.echo():

modell.compile(

loss='mean_squared_error',

optimizer=tf.keras.optimizers.SGD(l_rate)

)

"""

## Training des Modells

Um das Modell zu trainieren, müssen Sie einfach die Funktion „fit()“ für das Modell mit Trainings- und Validierungssatz und einer Anzahl von Epochen aufrufen, für die das Modell trainieren soll.

**Versuchen Sie, mit den Hyperparametern aus der Seitenleiste auf der linken Seite zu spielen, und klicken Sie auf die Schaltfläche "Modell trainieren", die unten angegeben ist, um das Training zu starten.**

"""

train = st.button('Modell trainieren')

wenn Zug:

mit st.spinner('Trainingsmodell…'):

mit st.echo():

model.summary(print_fn=lambda x: st.write(“{}”.format(x)))

Geschichte = model.fit (

X_Zug,

y_zug,

Epochen=n_Epochen,

validation_data=(X_gültig, y_gültig)

)

st.success('Modelltraining abgeschlossen!')

"""

## Modellleistung

"""

mit st.echo():

st.line_chart(pd.DataFrame(history.history))

"""

## Bewertung des Modells auf dem Testset

Wiederum ist ein weiterer wichtiger, aber einfacher Schritt, Ihr Modell anhand der Testdaten zu bewerten, die es noch nie zuvor gesehen hat. Denken Sie daran, dass Sie dies nur tun sollten, nachdem Sie sich über das von Ihnen erstellte Modell sicher genug sind, und Sie sollten sich einer Hyperparameter-Abstimmung widersetzen, nachdem Sie das Modell auf dem Testset bewertet haben, da dies es nur für das Testset verbessern würde und es wird es wieder tun ein Generalisierungsproblem sein, wenn das Modell in der Produktionsphase neue Daten sieht.

"""

mit st.echo():

Evaluation = model.evaluate(X_test, y_test)

Auswertung

"""

> Dieser Verlust auf dem Test-Set ist etwas schlimmer als der auf dem Validierungs-Set, was wie erwartet ist, da das Modell die Bilder des Test-Sets noch nie gesehen hat.

"""

"""

## Vorhersagen mit dem Modell

"""

mit st.echo():

X_neu = X_test[:3]

Vorhersagen = model.predict(X_new)

"""

### Vorhersagen

"""

Vorhersagen

"""

### Grundwahrheit

"""

y_test[:3]

Das war's! Nur ein paar Zeilen zusätzlichen Codes und Sie haben bereits eine großartige Web-App erstellt, die schön aussieht und auch dynamische Inhalte hat. Es war nicht so schwierig, oder? Versuchen Sie, verschiedene Projekte zu erstellen und andere Funktionen von Streamlit aus ihrer Dokumentation zu verwenden. Es ist ganz einfach und intuitiv.

Lesen Sie: Maschinelles Lernen mit Python

Bereitstellen der Streamlit-Web-App

Streamlit-Web-Apps können über verschiedene im Internet verfügbare Optionen zur direkten Verwendung bereitgestellt werden. Wir können sie kurz durchgehen und sehen, wie es gemacht werden kann.

Bevor wir zu anderen Plattformen gehen, die uns bei der Bereitstellung unserer Web-Apps helfen können, wollen wir uns ansehen, was Streamlit uns zu bieten hat. Eine sehr aktuelle Feature-Release, die sie gemacht haben, ist Streamlit Sharing. Auf diese Weise können die Benutzer ihre Streamlit-Web-Apps mit einem einzigen Klick bereitstellen.

Wenn Sie Ihren Code in Ihre GitHub-Repositories hochgeladen haben, können Sie das Repository einfach aus dem Dashboard von Streamlit auswählen und es wird es automatisch für Sie hosten. Es ist sehr erstaunlich und ab sofort völlig kostenlos. Es gab bisher keinen einfacheren Weg, Web-Apps für maschinelles Lernen bereitzustellen.

Heroku ist eine weitere gute Methode zum Bereitstellen der Streamlit-Web-App. Auf diese Weise müssen Sie keine Cloud-Server auswählen und dann virtuelle Instanzen darin einrichten. Heroku kümmert sich um alles.

Es gibt einen einfachen Nachteil in Heroku, dass die kostenlose Version es Ihnen nicht erlaubt, alle Pakete mit einer Größe von mehr als 512 MB in einer kostenlosen Version zu haben. TensorFlow 2.2.0, das ich für das Projekt verwendet habe, ist etwas größer als der angegebene Speicherplatz, sodass ich andere Dienste verwenden musste.

AWS (Amazon Web Services) ist auch eine gute Möglichkeit, Ihre Streamlit-Apps bereitzustellen. Es ist ein wenig komplex für einen Anfänger, aber wenn Sie es verwenden, wird es einfacher einzurichten. Sie bieten kostenlose EC2-Instanzen für neue Benutzer. Sie können eine mit Ubuntu 18.04 oder höher starten und alle Abhängigkeiten installieren, die für die App erforderlich sind.

Nachdem alles eingerichtet ist, können Sie die App mit dem Befehl ausführen – streamlit run filename.py. Hier erhalten Sie eine öffentliche URL, die mit allen geteilt werden kann. Ein großer Nachteil hierbei ist, dass die App nicht online verfügbar ist, wenn Sie die Instanz herunterfahren. Eine kostenlose Instanz wird also einige Einschränkungen haben.

Wenn Sie den Code im GitHub-Repository haben, gibt es eine weitere coole Möglichkeit, Ihre App zu hosten. Es ist nicht sehr professionell und legitim, da der Benutzer Streamlit auch auf seinen Systemen installiert haben muss.

Wenn Streamlit auf dem System verfügbar ist und Sie den Link für die Python-Datei der Streamlit-App haben, können Sie die Web-App ausführen, indem Sie einfach den folgenden Befehl ausführen: streamlit run url . Sie können meine App lokal ausprobieren, wenn Sie Streamlit installiert haben. Verwenden Sie den folgenden Befehl in Ihren Terminals:

Streamlit-Lauf https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py

Fazit

Sie haben gesehen, wie einfach und doch leistungsstark Streamlit ist. Ich habe noch nie zuvor ein solches Tool kennengelernt, das mir in diesem Maße geholfen und mein Entwicklungsleben erleichtert hat. Aus diesem Grund denke ich, dass Streamlit ein beeindruckendes Framework ist, das jedem helfen kann, sich auf die wichtigen Teile der Entwicklung des maschinellen Lernens zu konzentrieren, und uns helfen kann, uns mehr auf die wichtigsten Erkenntnisse aus KI und ML zu konzentrieren. Dies erleichtert die Lernkurve erheblich und ermöglicht es uns, Hobbyprojekte einfach zu erstellen und bereitzustellen.

Eine Sache, die dieses Framework so einfach zu implementieren macht, ist die offizielle Dokumentation. Alles, was in den Dokumenten steht, ist präzise und einfach. Ich schlage vor, dass Sie die Dokumentation einmal durchgehen und versuchen, ein neues Projekt zu implementieren. Es ist der beste Weg, um mit neuen Frameworks zu beginnen. Die offizielle Streamlit-Dokumentation finden Sie unter folgendem Link: https://docs.streamlit.io/en/stable/ target=“_blank“ rel=“nofollow“ .

Die Community ist immer die beste Ressource, um Dinge zu lernen und ein Problem mit unseren Lösungen zu finden. Streamlit hat ein wunderbares Diskussionsforum, in dem Sie Fragen zum Entwicklungsprozess einer Streamlit-App, Zweifel bezüglich der Bereitstellung, Funktionsanfragen, Fehlerberichte und alles andere stellen können, was Ihnen beim erfolgreichen Erstellen Ihrer App helfen könnte. Treten Sie dem Diskussionsforum unter folgendem Link bei — https://discuss.streamlit.io/

Wenn Sie mehr über maschinelles Lernen erfahren möchten, sehen Sie sich das PG-Diplom in maschinellem Lernen und KI von IIIT-B & upGrad an, das für Berufstätige konzipiert ist und mehr als 450 Stunden strenge Schulungen, mehr als 30 Fallstudien und Aufgaben bietet, IIIT- B-Alumni-Status, mehr als 5 praktische, praktische Abschlussprojekte und Jobunterstützung bei Top-Unternehmen.

Was ist die größte Schwierigkeit bei der Bereitstellung eines maschinellen Lernprojekts?

Die größte Schwierigkeit bei der Bereitstellung eines Machine-Learning-Projekts ist die Unvollständigkeit der Datenerfassung. Meistens reichen die Zeit und das Geld nicht aus, um alle Daten zu sammeln, die für eine genaue Analyse erforderlich sind. Daher müssen die gesammelten Daten zuverlässig und von guter Qualität sein. Außerdem müssen die richtigen Daten ausgewählt werden. Die Auswahl der Daten ist der Schlüssel zum Einsatz eines Projekts.

Was ist Streamlit beim maschinellen Lernen?

Streamlit ist ein inkrementeller Algorithmus für maschinelles Lernen. Es nutzt die Tatsache aus, dass der Suchraum von neuronalen Netzen sehr groß ist und dass das Training schnell ist und es somit nicht den gesamten Raum durchsuchen muss, sondern ein neuronales Netz lokal aufbauen kann. StreamLit ist eine Form von langem Kurzzeitgedächtnis, das zur Verarbeitung sequentieller Daten verwendet wird. Es ist ein Deep-Learning-Algorithmus, der RNNs verwendet, um Daten in Zahlenvektoren zu codieren. Diese Vektoren können verwendet werden, um Daten in Grafiken oder Text darzustellen. Es kann auch verwendet werden, um Text in natürlicher Sprache zu generieren.

Wie stelle ich mit Streamlit bereit?

Die Bereitstellung mit Streamlit ist einfach. Zunächst müssen Sie ein Streamlit-Konto haben. Zweitens benötigen Sie Software, die bereitgestellt werden kann. Zum Beispiel Beanstalk, S3 oder rsync. Drittens müssen Sie Ihre Software für die Bereitstellung vorbereiten. Kopieren Sie Ihre App mit rsync auf Ihren Webserver. Wenn Sie eine neue Website bereitstellen, ist die Website das Verzeichnis, das Sie kopiert haben. Wenn Sie eine vorhandene Website bereitstellen, ist die hochgeladene Website das Verzeichnis, das Sie kopiert haben. Auf der linken Seite des Bildschirms unter dem