streamlit ist ein kraftvolles Open-Source-Framework, mit dem Sie Webanwendungen für Data Science und maschinelles Lernen erstellen können, mit nur wenigen Zeilen von Python-Code.

Es ist einfach, intuitiv und erfordert keine Frontend -Erfahrung , was es sowohl für Anfänger als auch für erfahrene Entwickler zu einem großartigen Werkzeug macht, die schnell maschinelles Lernen einsetzen möchten.

In diesem Blog werde ich Sie durch einen Schritt-für-Schritt-Prozess führen, um eine grundlegende streamlit-App und ein maschinelles Lernprojekt mithilfe des iris dataset mit einem randomanforestclassifier.

zu erstellen.

. Erste Streamlit

Bevor wir in das Projekt springen, gehen wir durch eine grundlegende Stromlit -Funktionalität, um sich mit dem Framework vertraut zu machen. Sie können Streamlit mit dem folgenden Befehl installieren:

pip install streamlit

PIP Installieren Sie stromlit

Sobald Sie installiert sind, können Sie Ihre erste streamlit

App starten, indem Sie eine Python -Datei erstellen, sagen Sie App.py und ausgeführt mit:

pip install streamlit

streamlit run app.py

Jetzt untersuchen wir die Kernfunktionen von Streamlit:

1. Titel schreiben und Text anstellen

pip install streamlit

importieren stromlit als st # Einen Titel schreiben St.Title ("Hallo Welt") # Einfacher Text anzeigen St.Write ("Einfacher Text anzeigen")

2. Anzeigen von DataFrames

pip install streamlit

Pandas als PD importieren # Erstellen eines Datenrahmens df = pd.dataframe ({{ "Erste Spalte": [1, 2, 3, 4], "zweite Spalte": [5, 6, 7, 8] }) # Zeigen Sie den Datenrahmen an St.Write ("Anmelden eines Datenrahmens") St.Write (DF)

3. Visualisieren von Daten mit Diagrammen

pip install streamlit

Numph als NP importieren # Zufallsdaten generieren chart_data = pd.dataframe ( np.random.randn (20, 4), Spalten = ['A', 'B', 'C', 'D'] ) # Zeigen Sie das Zeilendiagramm an St.Line_Chart (Diagramm_Data)

4. Benutzerinteraktion: Texteingabe, Schieberegler und wählen Sie Felder
streamlit

aktiviert interaktive Widgets wie Texteingaben, Schieberegler und wählen Sie Kästchen, die basierend auf Benutzereingaben dynamisch aktualisieren.

pip install streamlit

# Texteingabe Name = St.Text_input ("Ihr Name ist:") Wenn Name: St.Write (f'hello, {Name} ') # Slider Alter = St.Slider ("Wählen Sie Ihr Alter aus:", 0, 100, 25) Wenn Alter: St.Write (f'your Age ist: {Alter} ') # Box auswählen Auswahl = ["Python", "Java", "JavaScript"] Lang = St.Selectbox ('Lieblingsprogrammiersprache', Auswahl) Wenn Lang: St.Write (F'favorite -Programmiersprache ist {Lang} ')

5. Datei Upload
Sie können Benutzern erlauben, Dateien hochzuladen und ihre Inhalte dynamisch in Ihrer streamlit

App:

pip install streamlit

# Datei -Uploader für CSV -Dateien Datei = St.File_Uploader ('Wählen Sie eine CSV -Datei,' CSV '). Wenn Datei: Data = pd.read_csv (Datei) St.Write (Daten)

Erstellen eines maschinellen Lernprojekts mit streamlit

Jetzt, da Sie mit den Grundlagen vertraut sind, lassen Sie uns ein maschinelles Lernprojekt erstellen. Wir werden den berühmten IRIS-Datensatz verwenden und eine einfache Klassifizierung model verwenden, indem Sie RandomforestClassifier von sciKit-Learn

.

verwenden.

Projektstruktur:

• Laden Sie den Datensatz.
• trainieren Sie einen zufälligen ForestClassifier.
• erlauben Benutzern die Eingabe von Funktionen mit Sliders.
.

die Spezies basierend auf den Eingabefunktionen vorhersagen.

1. Installieren Sie die notwendigen Abhängigkeiten

pip install streamlit scikit-learn numpy pandas

PIP installieren Stromlit Scikit-Learn Numpy Pandas
2. Bibliotheken importieren und Daten laden

import streamlit as st
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

# Cache data for efficient loading
@st.cache_data
def load_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df["species"] = iris.target
    return df, iris.target_names

df, target_name = load_data()

importieren stromlit als st Pandas als PD importieren von sklearn.datasets import load_iris aus sklearn.ensemble import randomforestclassifierer # Cache -Daten zum effizienten Laden @St.Cache_Data Def load_data (): iris = load_iris () df = pd.dataframe (iris.data, columns = iris.feature_names) df ["spezies"] = iris.target return df, iris.target_names df, target_name = load_data ()
3. Trainieren Sie das maschinelle Lernmodell

# Train RandomForestClassifier
model = RandomForestClassifier()
model.fit(df.iloc[:, :-1], df["species"])

# Train RandomforestClassifier Modell = RandomforestClassifier () model.fit (df.iloc [:,: -1], df ["spezies"])
4. Erstellen der Eingabebereiche

# Sidebar for user input
st.sidebar.title("Input Features")
sepal_length = st.sidebar.slider("Sepal length", float(df['sepal length (cm)'].min()), float(df['sepal length (cm)'].max()))
sepal_width = st.sidebar.slider("Sepal width", float(df['sepal width (cm)'].min()), float(df['sepal width (cm)'].max()))
petal_length = st.sidebar.slider("Petal length", float(df['petal length (cm)'].min()), float(df['petal length (cm)'].max()))
petal_width = st.sidebar.slider("Petal width", float(df['petal width (cm)'].min()), float(df['petal width (cm)'].max()))

# Seitenleiste für Benutzereingaben St.SideBar.Title ("Eingangsfunktionen") sepal_length = St.SideBar.slider ("Sepal Länge", float (df ['Sepal Länge (cm)']. min ()), float (df ['Sepal Länge (cm)']. max ()))) sepal_width = St.SideBar.slider ("Sepal Width", Float (df ['Sepal Breite (cm)']. min ()), float (df ['Sepal Width (cm)']. max ())) petal_length = st.ssideBar.slider ("Blütenblattlänge", float (df ['Blütenblattlänge (cm)']. min ()), float (df ['Blütenblattlänge (cm)']. max ()))) PETAL_WIDTH = SSIDEBAR.SLIDER ("Blütenbreite", float (df ['Blütenbreite (cm)']. min ()), float (df ['Blütenbreite (cm)']. max ())))
5. Vorhersage der Spezies

# Prepare the input data
input_data = [[sepal_length, sepal_width, petal_length, petal_width]]

# Prediction
prediction = model.predict(input_data)
prediction_species = target_name[prediction[0]]

# Display the prediction
st.write("Prediction:")
st.write(f'Predicted species is {prediction_species}')

# Bereiten Sie die Eingabedaten vor input_data = [[sepal_length, sepal_width, petal_length, petal_width]] # Vorhersage Vorhersage = Modell.PREDICT (input_data) Prediction_species = target_name [Vorhersage [0]] # Zeigen Sie die Vorhersage an St.Write ("Vorhersage:") St.Write (famitierte Spezies ist {Prediction_species} ')

Das wird aussehen wie:

schließlich

streamlit

macht es unglaublich einfach, maschinelles Lernen mit minimaler Anstrengung zu erstellen und bereitzustellen. ? In nur wenigen Codezeilen haben wir eine interaktive App erstellt? Dadurch können Benutzer Merkmale eingeben und die Arten einer Blume vorhersagen? Verwenden eines maschinellen Lernmodells. ??

Happy Coding! ?