Zweitens in einer kurzen Serie zur Entwicklung von Daten Dashboards mithilfe der neuesten Python-basierten GUI-Entwicklungstools, Streamlit, Gradiound Taipy.
Der Quelldatensatz für jedes Dashboard ist gleich, wird jedoch in verschiedenen Formaten gespeichert. So viel wie möglich werde ich auch versuchen, die tatsächlichen Dashboard -Layouts für jedes Werkzeug zu erstellen, und es ähneln die gleiche Funktionalität.
Im ersten Teil dieser Serie habe ich eine streamlit -Model des Dashboards erstellt, in der seine Daten aus einer lokalen PostgreSQL -Datenbank abgerufen werden. Sie können diesen Artikel anzeigen Hier.
Diesmal untersuchen wir die Verwendung der Gradio -Bibliothek.
Die Daten für dieses Dashboard befinden sich in einer lokalen CSV -Datei, und Pandas ist unsere primäre Datenverarbeitungsmaschine.
Wenn Sie eine kurze Demo der App sehen möchten, habe ich sie für umarme Gesichtsräume bereitgestellt. Sie können es mit dem folgenden Hyperlink ausführen. Beachten Sie jedoch, dass die beiden Pop-ups für Eingabedatum-Picker aufgrund eines bekannten Fehlers in der Umgebungs-Gesichtsumgebung nicht funktionieren. Dies ist nur bei bereitgestellten Apps auf HF der Fall. Sie können die Daten immer noch manuell ändern. Das Ausführen der App lokal funktioniert einwandfrei und hat dieses Drawback nicht.
Was ist Gradio?
Gradio ist ein Open-Supply-Python-Paket, das den Prozess des Erstellens von Demos oder Webanwendungen für maschinelle Lernmodelle, APIs oder einer Python-Funktion vereinfacht. Damit können Sie Demos oder Webanwendungen erstellen, ohne JavaScript, CSS oder Webhosting -Erfahrung zu benötigen. Wenn Sie nur ein paar Zeilen Python-Code schreiben, können Sie die Leistung von Gradio freischalten und Ihre maschinellen Lernmodelle einem breiteren Publikum nahtlos präsentieren.
Gradio vereinfacht den Entwicklungsprozess, indem ein intuitives Framework bereitgestellt wird, das die Komplexität, die mit dem Aufbau von Benutzeroberflächen von Grund auf verbunden ist, beseitigt. Unabhängig davon, ob Sie ein Entwickler, Forscher oder Fanatic für maschinelles Lernen sind, können Sie mit Gradio schöne und interaktive Demos erstellen, die das Verständnis und die Zugänglichkeit Ihrer Modelle für maschinelles Lernen verbessern.
Dieses Open-Supply-Python-Paket hilft Ihnen dabei, die Lücke zwischen Ihrem maschinellen Lernen und einem breiteren Publikum zu schließen und Ihre Modelle zugänglich und umsetzbar zu machen.
Was wir entwickeln werden
Wir entwickeln ein Daten Dashboard. Unsere Quelldaten werden eine einzige CSV -Datei sein, die 100.000 synthetische Verkaufsunterlagen enthält.
Die tatsächliche Quelle der Daten ist nicht Das wichtig. Es kann genauso einfach eine Textdatei, eine Excel -Datei, SQLite oder eine beliebige Datenbank sein, mit der Sie eine Verbindung herstellen können.
So wird unser letztes Dashboard aussehen.
Es gibt vier Hauptabschnitte.
- Mit der oberen Zeile kann der Benutzer mithilfe von Datumspickern und einer Dropdown-Liste bestimmte Begin- und Enddaten und/oder Produktkategorien auswählen.
- Die zweite Reihe-Schlüsselmetriken-zeigt eine Zusammenfassung der ausgewählten Daten auf der obersten Ebene.
- Mit dem Abschnitt zur Visualisierung kann der Benutzer eines von drei Diagrammen auswählen, um den Eingabedatensatz anzuzeigen.
- Der Abschnitt mit Rohdaten ist genau das, was er behauptet. Diese tabellarische Darstellung der ausgewählten Daten zeigt effektiv einen Schnappschuss der zugrunde liegenden CSV -Datendatei.
Das Dashboard ist einfach. Zunächst werden Statistiken für den gesamten Datensatz angezeigt. Der Benutzer kann dann den Datenfokus mit den drei Filterfeldern oben in der Anzeige einschränken. Die Grafiken, Schlüsselmetriken und Rohdatenabschnitte aktualisieren dynamisch, um die Auswahl des Benutzers in den Filterfeldern widerzuspiegeln.
Die zugrunde liegenden Daten
Wie bereits erwähnt, sind die Quelldaten des Dashboards in einer einzelnen Comma-getrennten Werte (CSV) enthalten. Die Daten bestehen aus 100.000 synthetischen Verkaufsaufzeichnungen. Hier sind die ersten zehn Aufzeichnungen der Datei, die Ihnen eine Vorstellung davon geben, wie es aussieht.
+----------+------------+------------+----------------+------------+---------------+------------+----------+-------+--------------------+
| order_id | order_date | customer_id| customer_name | product_id | product_names | classes | amount | worth | whole |
+----------+------------+------------+----------------+------------+---------------+------------+----------+-------+--------------------+
| 0 | 01/08/2022 | 245 | Customer_884 | 201 | Smartphone | Electronics| 3 | 90.02 | 270.06 |
| 1 | 19/02/2022 | 701 | Customer_1672 | 205 | Printer | Electronics| 6 | 12.74 | 76.44 |
| 2 | 01/01/2017 | 184 | Customer_21720 | 208 | Pocket book | Stationery | 8 | 48.35 | 386.8 |
| 3 | 09/03/2013 | 275 | Customer_23770 | 200 | Laptop computer | Electronics| 3 | 74.85 | 224.55 |
| 4 | 23/04/2022 | 960 | Customer_23790 | 210 | Cupboard | Workplace | 6 | 53.77 | 322.62 |
| 5 | 10/07/2019 | 197 | Customer_25587 | 202 | Desk | Workplace | 3 | 47.17 | 141.51 |
| 6 | 12/11/2014 | 510 | Customer_6912 | 204 | Monitor | Electronics| 5 | 22.5 | 112.5 |
| 7 | 12/07/2016 | 150 | Customer_17761 | 200 | Laptop computer | Electronics| 9 | 49.33 | 443.97 |
| 8 | 12/11/2016 | 997 | Customer_23801 | 209 | Espresso Maker | Electronics| 7 | 47.22 | 330.54 |
| 9 | 23/01/2017 | 151 | Customer_30325 | 207 | Pen | Stationery | 6 | 3.5 | 21 |
+----------+------------+------------+----------------+------------+---------------+------------+----------+-------+--------------------+Und hier ist ein Python -Code, mit dem Sie einen ähnlichen Datensatz generieren können. Stellen Sie sicher, dass sowohl die Numpy- als auch die Pandas -Bibliotheken zuerst installiert sind.
# generate the 100K document CSV file
#
import polars as pl
import numpy as np
from datetime import datetime, timedelta
def generate(nrows: int, filename: str):
names = np.asarray(
(
"Laptop computer",
"Smartphone",
"Desk",
"Chair",
"Monitor",
"Printer",
"Paper",
"Pen",
"Pocket book",
"Espresso Maker",
"Cupboard",
"Plastic Cups",
)
)
classes = np.asarray(
(
"Electronics",
"Electronics",
"Workplace",
"Workplace",
"Electronics",
"Electronics",
"Stationery",
"Stationery",
"Stationery",
"Electronics",
"Workplace",
"Sundry",
)
)
product_id = np.random.randint(len(names), measurement=nrows)
amount = np.random.randint(1, 11, measurement=nrows)
worth = np.random.randint(199, 10000, measurement=nrows) / 100
# Generate random dates between 2010-01-01 and 2023-12-31
start_date = datetime(2010, 1, 1)
end_date = datetime(2023, 12, 31)
date_range = (end_date - start_date).days
# Create random dates as np.array and convert to string format
order_dates = np.array(((start_date + timedelta(days=np.random.randint(0, date_range))).strftime('%Y-%m-%d') for _ in vary(nrows)))
# Outline columns
columns = {
"order_id": np.arange(nrows),
"order_date": order_dates,
"customer_id": np.random.randint(100, 1000, measurement=nrows),
"customer_name": (f"Customer_{i}" for i in np.random.randint(2**15, measurement=nrows)),
"product_id": product_id + 200,
"product_names": names(product_id),
"classes": classes(product_id),
"amount": amount,
"worth": worth,
"whole": worth * amount,
}
# Create Polars DataFrame and write to CSV with express delimiter
df = pl.DataFrame(columns)
df.write_csv(filename, separator=',',include_header=True) # Guarantee comma is used because the delimiter
# Generate 100,000 rows of information with random order_date and save to CSV
generate(100_000, "/mnt/d/sales_data/sales_data.csv")Installieren und Verwenden von Gradio
Die Set up von Gradio ist einfach mit der Verwendung PipAber für die Codierung besteht die beste Praxis darin, eine separate Python -Umgebung für all Ihre Arbeiten einzurichten. Ich benutze Miniconda für diesen Zweck, kann aber gerne jede Methode zu Ihrer Arbeitspraxis verwenden.
Wenn Sie die Conda -Route hinuntergehen möchten und sie noch nicht haben, müssen Sie zuerst Miniconda (empfohlen) oder Anaconda installieren.
Bitte beachten Sie, dass zum Zeitpunkt des Schreibens, Gradio benötigt mindestens Python 3.8, um korrekt zu arbeiten.
Sobald die Umgebung erstellt wurde, wechseln Sie mit der ‚aktivieren‘ Befehl und dann ausführen „PIP Set up“ Zu Installieren Sie unsere erforderlichen Python -Bibliotheken.
#create our take a look at setting
(base) C:Usersthoma>conda create -n gradio_dashboard python=3.12 -y
# Now activate it
(base) C:Usersthoma>conda activate gradio_dashboard
# Set up python libraries, and so forth ...
(gradio_dashboard) C:Usersthoma>pip set up gradio pandas matplotlib cachetoolsSchlüsselunterschiede zwischen Stromlit und Gradio
Wie ich in diesem Artikel demonstrieren werde, ist es möglich, sehr ähnliche Daten Dashboards mit Streamlit und Gradio zu erstellen. Ihr Ethos unterscheidet sich jedoch in mehrfacher Hinsicht.
Fokus
- Gradio spezialisiert sich auf die Erstellung von Schnittstellen für maschinelles Lernmodelle, während Streamlit mehr für allgemeine Datenanwendungen und Visualisierungen entwickelt wurde.
Benutzerfreundlichkeit
- Gradio ist bekannt für seine Einfachheit und schnellen Prototyping -Funktionen, was es den Anfängern erleichtert. Streamlit bietet erweiterte Funktionen und Anpassungsoptionen, die möglicherweise eine steilere Lernkurve erfordern.
Interaktivität
- Stromlit verwendet einen Reaktiv Programmierung Modell, bei dem jede Eingabeänderung eine vollständige Skript -Wiederholung auslöst und alle Komponenten sofort aktualisiert. Gradio aktualisiert standardmäßig nur dann, wenn ein Benutzer auf eine Senden -Schaltfläche klickt. Sie können jedoch für Dwell -Updates konfiguriert werden.
Anpassung
- Gradio konzentriert sich auf vorgefertigte Komponenten, um schnell KI-Modelle zu demonstrieren. Streamlit bietet umfangreichere Anpassungsoptionen und Flexibilität für komplexe Projekte.
Einsatz
- Nachdem ich sowohl eine Streamlit- als auch eine Gradio -App bereitgestellt habe, würde ich sagen, dass es einfacher ist, eine Streamlit -App bereitzustellen als eine Gradio -App. In der Streamlit kann die Bereitstellung mit einem einzelnen Klick über die Streamlit Group Cloud erfolgen. Diese Funktionalität ist in jede von Ihnen erstellte Streamlit -App integriert. Gradio bietet Bereitstellung mit umarmenden Gesichtsräumen, aber es beinhaltet mehr Arbeit. Keine der beiden Methoden ist jedoch besonders komplex.
Anwendungsfälle
Stromlit zeichnet sich durch das Erstellen datenorientierter Anwendungen und interaktiver Dashboards für komplexe Projekte aus. Gradio ist superb, um schnell maschinelles Lernen Modelle zu präsentieren und einfachere Anwendungen zu erstellen.
Der Gradio Dashboard -Code
Ich werde den Code in Abschnitte zerlegen und jeden im Laufe der fortgeschrittenen Erläuterung erläutern.
Wir beginnen mit dem Importieren der erforderlichen externen Bibliotheken und dem Laden des vollständigen Datensatzes aus der CSV -Datei in einen PANDAS -Datenframe.
import gradio as gr
import pandas as pd
import matplotlib.pyplot as plt
import datetime
import warnings
import os
import tempfile
from cachetools import cached, TTLCache
warnings.filterwarnings("ignore", class=FutureWarning, module="seaborn")
# ------------------------------------------------------------------
# 1) Load CSV information as soon as
# ------------------------------------------------------------------
csv_data = None
def load_csv_data():
world csv_data
# Optionally available: specify column dtypes if recognized; regulate as obligatory
dtype_dict = {
"order_id": "Int64",
"customer_id": "Int64",
"product_id": "Int64",
"amount": "Int64",
"worth": "float",
"whole": "float",
"customer_name": "string",
"product_names": "string",
"classes": "string"
}
csv_data = pd.read_csv(
"d:/sales_data/sales_data.csv",
parse_dates=("order_date"),
dayfirst=True, # in case your dates are DD/MM/YYYY format
low_memory=False,
dtype=dtype_dict
)
load_csv_data()Als nächstes konfigurieren wir einen Cache für den Lebend, der maximal 128 Elemente und einen Ablauf von 300 Sekunden verfälscht. Dies wird verwendet, um die Ergebnisse teurer Funktionsaufrufe zu speichern und wiederholte Lookups zu beschleunigen
Der get_unique_categories Die Funktion gibt eine Liste der eindeutigen, gereinigten (kapitalisierten) Kategorien aus dem DataFrame `csv_data` zurück, wodurch das Ergebnis für einen schnelleren Zugriff zwischengespeichert wird.
Der get_date_range Die Funktion gibt die minimalen und maximalen Bestelldaten aus dem Datensatz zurück oder keine, wenn die Daten nicht verfügbar sind.
Der filter_data Funktion filtert den DataFrame CSV_DATA basierend auf einem bestimmten Datumsbereich und einer optionalen Kategorie, wobei der gefilterte Datenrahmen zurückgegeben wird.
Der get_dashboard_stats Funktion ruft zusammenfassende Metriken – Gesamtumsatz, Gesamtbestellungen, durchschnittliche Bestellwert und obere Kategorie – für die angegebenen Filter ab. Intern wird es verwendet filter_data() Um den Datensatz zu umgehen und dann diese Schlüsselstatistiken zu berechnen.
Der get_data_for_table fDie Union gibt einen detaillierten Datenrahmen für gefilterte Verkaufsdaten zurück, sortiert nach order_id Und order_dateeinschließlich zusätzlicher Einnahmen für jeden Verkauf.
Der get_plot_data Funktionsformate Daten zum Generieren eines Diagramms durch Summieren von Einnahmen im Laufe der Zeit, die nach Datum gruppiert sind.
Der get_revenue_by_category Funktionsaggregate und Rückgaben nach Kategorien, sortiert nach Einnahmen, innerhalb des angegebenen Datumsbereichs und der Kategorie.
Der get_top_products Funktion gibt die High 10 Produkte nach Einnahmen zurück, die nach Datumsbereich und Kategorie gefiltert werden.
Basierend auf dem Orientierungsargument die create_matplotlib_figure Die Funktion generiert ein Balkendiagramm aus den Daten und speichert es als Bilddatei, entweder vertikal oder horizontal.
cache = TTLCache(maxsize=128, ttl=300)
@cached(cache)
def get_unique_categories():
world csv_data
if csv_data is None:
return ()
cats = sorted(csv_data('classes').dropna().distinctive().tolist())
cats = (cat.capitalize() for cat in cats)
return cats
def get_date_range():
world csv_data
if csv_data is None or csv_data.empty:
return None, None
return csv_data('order_date').min(), csv_data('order_date').max()
def filter_data(start_date, end_date, class):
world csv_data
if isinstance(start_date, str):
start_date = datetime.datetime.strptime(start_date, '%Y-%m-%d').date()
if isinstance(end_date, str):
end_date = datetime.datetime.strptime(end_date, '%Y-%m-%d').date()
df = csv_data.loc(
(csv_data('order_date') >= pd.to_datetime(start_date)) &
(csv_data('order_date') <= pd.to_datetime(end_date))
).copy()
if class != "All Classes":
df = df.loc(df('classes').str.capitalize() == class).copy()
return df
def get_dashboard_stats(start_date, end_date, class):
df = filter_data(start_date, end_date, class)
if df.empty:
return (0, 0, 0, "N/A")
df('income') = df('worth') * df('amount')
total_revenue = df('income').sum()
total_orders = df('order_id').nunique()
avg_order_value = total_revenue / total_orders if total_orders else 0
cat_revenues = df.groupby('classes')('income').sum().sort_values(ascending=False)
top_category = cat_revenues.index(0) if not cat_revenues.empty else "N/A"
return (total_revenue, total_orders, avg_order_value, top_category.capitalize())
def get_data_for_table(start_date, end_date, class):
df = filter_data(start_date, end_date, class)
if df.empty:
return pd.DataFrame()
df = df.sort_values(by=("order_id", "order_date"), ascending=(True, False)).copy()
columns_order = (
"order_id", "order_date", "customer_id", "customer_name",
"product_id", "product_names", "classes", "amount",
"worth", "whole"
)
columns_order = (col for col in columns_order if col in df.columns)
df = df(columns_order).copy()
df('income') = df('worth') * df('amount')
return df
def get_plot_data(start_date, end_date, class):
df = filter_data(start_date, end_date, class)
if df.empty:
return pd.DataFrame()
df('income') = df('worth') * df('amount')
plot_data = df.groupby(df('order_date').dt.date)('income').sum().reset_index()
plot_data.rename(columns={'order_date': 'date'}, inplace=True)
return plot_data
def get_revenue_by_category(start_date, end_date, class):
df = filter_data(start_date, end_date, class)
if df.empty:
return pd.DataFrame()
df('income') = df('worth') * df('amount')
cat_data = df.groupby('classes')('income').sum().reset_index()
cat_data = cat_data.sort_values(by='income', ascending=False)
return cat_data
def get_top_products(start_date, end_date, class):
df = filter_data(start_date, end_date, class)
if df.empty:
return pd.DataFrame()
df('income') = df('worth') * df('amount')
prod_data = df.groupby('product_names')('income').sum().reset_index()
prod_data = prod_data.sort_values(by='income', ascending=False).head(10)
return prod_data
def create_matplotlib_figure(information, x_col, y_col, title, xlabel, ylabel, orientation='v'):
plt.determine(figsize=(10, 6))
if information.empty:
plt.textual content(0.5, 0.5, 'No information obtainable', ha='heart', va='heart')
else:
if orientation == 'v':
plt.bar(information(x_col), information(y_col))
plt.xticks(rotation=45, ha='proper')
else:
plt.barh(information(x_col), information(y_col))
plt.gca().invert_yaxis()
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.tight_layout()
with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
plt.savefig(tmpfile.title)
plt.shut()
return tmpfile.titleDer update_dashboard Funktion ruft die wichtigsten Umsatzstatistiken (Gesamtumsatz, Gesamtbestellungen, durchschnittliche Bestellwert und obere Kategorie) ab, indem sie das aufrufenget_dashboard_stats Funktion. Es sammelt Daten für drei unterschiedliche Visualisierungen (Einnahmen im Laufe der Zeit, Umsatz nach Kategorie und High -Produkte) und verwendet dann create_matplotlib_figure Diagramme erzeugen. Es bereitet eine Datentabelle vor und gibt über die zurück get_data_for_table() Funktion) zusammen mit allen erzeugten Diagrammen und Statistiken, damit sie im Dashboard angezeigt werden können.
Der create_dashboard Die Funktion legt die Datumsgrenzen (minimale und maximale Daten) fest und legt die anfänglichen Standardfilterwerte fest. Es wird Gradio verwendet, um eine Benutzeroberfläche (UI) mit Datumspickern, Dropdowns der Kategorie, wichtigen metrischen Anzeigen, Registerkarten für Handlungen und einer Datentabelle zu erstellen. Es wird dann die Filter hochgezogen, so dass das Ändern eines von ihnen einen Anruf an die auslöst update_dashboard Funktion, um sicherzustellen, dass das Dashboard -Visuals und -Metriken immer mit den ausgewählten Filtern synchronisiert sind. Schließlich gibt es die zusammengesetzte Gradio -Schnittstelle zurück, die als Webanwendung gestartet wurde.
def update_dashboard(start_date, end_date, class):
total_revenue, total_orders, avg_order_value, top_category = get_dashboard_stats(start_date, end_date, class)
# Generate plots
revenue_data = get_plot_data(start_date, end_date, class)
category_data = get_revenue_by_category(start_date, end_date, class)
top_products_data = get_top_products(start_date, end_date, class)
revenue_over_time_path = create_matplotlib_figure(
revenue_data, 'date', 'income',
"Income Over Time", "Date", "Income"
)
revenue_by_category_path = create_matplotlib_figure(
category_data, 'classes', 'income',
"Income by Class", "Class", "Income"
)
top_products_path = create_matplotlib_figure(
top_products_data, 'product_names', 'income',
"High Merchandise", "Income", "Product Title", orientation='h'
)
# Information desk
table_data = get_data_for_table(start_date, end_date, class)
return (
revenue_over_time_path,
revenue_by_category_path,
top_products_path,
table_data,
total_revenue,
total_orders,
avg_order_value,
top_category
)
def create_dashboard():
min_date, max_date = get_date_range()
if min_date is None or max_date is None:
min_date = datetime.datetime.now()
max_date = datetime.datetime.now()
default_start_date = min_date
default_end_date = max_date
with gr.Blocks(css="""
footer {show: none !necessary;}
.tabs {border: none !necessary;}
.gr-plot {border: none !necessary; box-shadow: none !necessary;}
""") as dashboard:
gr.Markdown("# Gross sales Efficiency Dashboard")
# Filters row
with gr.Row():
start_date = gr.DateTime(
label="Begin Date",
worth=default_start_date.strftime('%Y-%m-%d'),
include_time=False,
sort="datetime"
)
end_date = gr.DateTime(
label="Finish Date",
worth=default_end_date.strftime('%Y-%m-%d'),
include_time=False,
sort="datetime"
)
category_filter = gr.Dropdown(
selections=("All Classes") + get_unique_categories(),
label="Class",
worth="All Classes"
)
gr.Markdown("# Key Metrics")
# Stats row
with gr.Row():
total_revenue = gr.Quantity(label="Complete Income", worth=0)
total_orders = gr.Quantity(label="Complete Orders", worth=0)
avg_order_value = gr.Quantity(label="Common Order Worth", worth=0)
top_category = gr.Textbox(label="High Class", worth="N/A")
gr.Markdown("# Visualisations")
# Tabs for Plots
with gr.Tabs():
with gr.Tab("Income Over Time"):
revenue_over_time_image = gr.Picture(label="Income Over Time", container=False)
with gr.Tab("Income by Class"):
revenue_by_category_image = gr.Picture(label="Income by Class", container=False)
with gr.Tab("High Merchandise"):
top_products_image = gr.Picture(label="High Merchandise", container=False)
gr.Markdown("# Uncooked Information")
# Information Desk (under the plots)
data_table = gr.DataFrame(
label="Gross sales Information",
sort="pandas",
interactive=False
)
# When filters change, replace the whole lot
for f in (start_date, end_date, category_filter):
f.change(
fn=lambda s, e, c: update_dashboard(s, e, c),
inputs=(start_date, end_date, category_filter),
outputs=(
revenue_over_time_image,
revenue_by_category_image,
top_products_image,
data_table,
total_revenue,
total_orders,
avg_order_value,
top_category
)
)
# Preliminary load
dashboard.load(
fn=lambda: update_dashboard(default_start_date, default_end_date, "All Classes"),
outputs=(
revenue_over_time_image,
revenue_by_category_image,
top_products_image,
data_table,
total_revenue,
total_orders,
avg_order_value,
top_category
)
)
return dashboard
if __name__ == "__main__":
dashboard = create_dashboard()
dashboard.launch(share=False)Ausführen des Programms
Erstellen a Python Datei, z. B. Gradio_test.py und fügen Sie alle oben genannten Code -Snippets ein. Speichern Sie es und führen Sie es so aus,
(gradio_dashboard) $ python gradio_test.py
* Working on native URL: http://127.0.0.1:7860
To create a public hyperlink, set `share=True` in `launch()`.Klicken Sie auf die gezeigte lokale URL und das Dashboard öffnet den Vollbild in Ihrem Browser.
Zusammenfassung
Dieser Artikel enthält einen umfassenden Leitfaden zum Erstellen eines interaktiven Verkaufs -Dashboards mit Gradio und einer CSV -Datei als Quelldaten.
Gradio ist ein modernes, pythonbasiertes Open-Supply-Framework, das die Erstellung von datengesteuerten Dashboards und GUI-Anwendungen vereinfacht. Mit dem von mir entwickelten Dashboard können Benutzer Daten nach Datumsbereichen und Produktkategorien filtern, wichtige Kennzahlen wie Gesamteinnahmen und High-Performing-Kategorien anzeigen, Visualisierungen wie Umsatztrends und High-Produkte untersuchen und mit Pagination durch Rohdaten navigieren.
Ich habe auch einige wichtige Unterschiede zwischen der Entwicklung von Visualisierungstools mit Gradio und Streamlit, einer weiteren beliebten Entrance-Finish-Python-Bibliothek, erwähnt.
Dieser Leitfaden bietet eine umfassende Implementierung eines Gradio -Daten -Dashboards, das den gesamten Prozess abdeckt, vom Erstellen von Beispieldaten zum Entwickeln von Python -Funktionen zum Abfragen von Daten, zum Generieren von Diagrammen und zur Bearbeitung von Benutzereingaben. Dieser Schritt-für-Schritt-Ansatz zeigt, wie die Funktionen von Gradio benutzerfreundliche und dynamische Dashboards erstellt werden können, was es superb für Dateningenieure und Wissenschaftler macht, die interaktive Datenanwendungen erstellen möchten.
Obwohl ich eine CSV -Datei für meine Daten verwendet habe, sollte der Code so geändert werden, dass eine andere Datenquelle verwendet wird, z. B. ein relationales Datenbankverwaltungssystem (RDBMS) wie SQLITE, einfach. In meinem anderen Artikel in dieser Serie zum Erstellen eines ähnlichen Dashboards mit StreamLit ist die Datenquelle beispielsweise eine PostgreSQL -Datenbank.