


Erstellen einer interaktiven Daten -Dashboard -Erstellung mit Gradio
Jul 07, 2025 am 09:07 AMWarst du jemals in einer Situation festgefahren, in der du einen riesigen Datensatz hast und wolltest Einblicke davon? Klingt be?ngstigend, oder? Nützliche Erkenntnisse zu erhalten, insbesondere aus einem riesigen Datensatz, ist eine gro?e Bestellung. Stellen Sie sich vor, Sie verwandeln Ihren Datensatz in eine interaktive Webanwendung ohne Frontend -Expertise für die Datenvisualisierung. Gradio bietet diese Funktionalit?t mit minimaler Codierung, wenn sie neben Python verwendet wird. Die Datenvisualisierung ist ein leistungsstarkes Tool, um Datenerblicke effektiv zu pr?sentieren. In diesem Leitfaden werden wir untersuchen, wie moderne interaktive Daten -Dashboards erstellt werden, wobei der Schwerpunkt auf der Visualisierung von Gradio -Daten und der Erstellung einer GUI mit Python liegt. Fangen wir an.
Inhaltsverzeichnis
- Gradio verstehen
- Gradio gegen stromlit
- Schritte zum Erstellen eines interaktiven Armaturenbretts
- Daten erhalten
- Installieren von Gradio
- Importieren der erforderlichen Bibliotheken
- Laden der CSV -Daten
- Zwischen- und Versorgungsfunktionen
- Datenfilterung und wichtige Metrikenfunktionen
- Graph -Plotfunktionen
- Tabellenanzeige- und Datenaktualisierungsfunktionen
- Erstellen von Gradio -Schnittstellen
- Hauptausführungsfunktion zum Ausführen des Gradio
- Abschluss
Gradio verstehen
Gradio ist eine Open-Source-Python-Bibliothek zum Erstellen webbasierter Schnittstellen. Es wurde speziell für die Vereinfachung der Entwicklung von Benutzeroberfl?chen für die Bereitstellung maschineller Lernmodelle und Datenanwendungen erstellt. Sie ben?tigen keinen umfangreichen Hintergrund in Web -Technologien wie HTML, JavaScript und CSS. Gradio kümmert sich intern um alle Komplexit?ten und andere Dinge. Auf diese Weise k?nnen Sie sich nur auf den Python -Code konzentrieren.
Gradio gegen stromlit
Streamlit und Gradio erm?glichen beide die Entwicklung von Webanwendungen mit minimalen Codezeilen. Sie unterscheiden sich beide v?llig voneinander. Das Verst?ndnis der Unterschiede kann daher helfen, das richtige Framework für das Erstellen von Webanwendungen auszuw?hlen.
Aspekt | Gradio | Straffung |
Benutzerfreundlichkeit | Gradio ist sehr einfach zu bedienen und wird für seine Einfachheit oft gesch?tzt. Anf?nger finden Gradio leicht zu beginnen. | Streamlit bietet eine gro?e Anzahl von Funktionen und Anpassungen, die m?glicherweise eine steile Lernkurve aufweisen. |
Hauptfokus | Der Hauptaugenmerk von Gradio liegt auf der Erstellung der Schnittstellen für maschinelles Lernen oder künstliche Intelligenzmodelle. | Streamlit ist eher ein allgemeiner Rahmen für breitere Aufgaben. |
Reaktives Modell | Gradio -Komponenten aktualisieren h?ufig eine bestimmte Aktion, z. B. eine Schaltfl?che Klicken, obwohl Live -Updates konfiguriert werden k?nnen. | Streamlit verwendet ein reaktives Modell. Jede Eingabe?nderung wird in der Regel das gesamte Skript umgeben. |
St?rken | Gradio eignet sich hervorragend zum schnellen Pr?sentieren von Modellen oder zum Erstellen einfacherer Gradio -Datenvisualisierungstools. | Streamlit ist stark für datenorientierte Apps und detaillierte interaktive Daten Dashboards. |
Beide Tools k?nnen verwendet werden, um interaktive Dashboards zu erstellen. Die Wahl von einem h?ngt von den spezifischen Anforderungen des Projekts ab.
Lesen Sie mehr: Gradio vs streamlit detaillierter Vergleich
Schritte zum Erstellen eines interaktiven Armaturenbretts
Schauen wir uns die entscheidenden Schritte an, die für den Aufbau dieses interaktiven Armaturenbretts erforderlich sind.
1. Erhalten Sie die Daten
Einer der entscheidenden Schritte vor dem Erstellen des Dashboards besteht darin, die zugrunde liegenden Daten zu haben, die für die Visualisierung verwendet werden. Unsere Daten für das Python Gradio Dashboard sind eine synthetische CSV -Datei. Es enth?lt 100.000 Datens?tze, die das Engagement der Website des Website -Benutzers simulieren. Jeder Datensatz stellt eine Benutzersitzung oder eine signifikante Interaktion dar.
Hier ist ein Beispiel, wie unser CSV aussehen wird:
Zeitstempel | Benutzer-ID | Page_vises | Session_duration_seconds | Land | Device_type | Browser |
2023-01-15 10:30:00 | U1001 | /heim | 120 | USA | Desktop | Chrom |
2023-01-15 10:32:00 | U1002 | /Produkte | 180 | Kanada | Mobile | Safari |
2023-01-15 10:35:00 | U1001 | /Kontakt | 90 | USA | Desktop | Chrom |
… | … | … | … | … | … | … |
Sie k?nnen den folgenden Python -Code verwenden, um diese Art von Daten zu generieren. Hier generieren wir einen zu Demonstrationszwecken. Stellen Sie sicher, dass Sie Numpy und Pandas installiert haben.
Numph als NP importieren Pandas als PD importieren Aus DateTime Import DateTime, Timedelta Def generate_website_data (nrows: int, fileName: str): # M?gliche Werte für kategoriale Felder Seiten = ["/home", "/products", "/dienstleistungen", "über", "/contact", "/blog"] L?nder = ["USA", "Kanada", "Gro?britannien", "Deutschland", "Frankreich", "Indien", "Australien"] Device_types = ["Desktop", "Mobile", "Tablet"] Browser = ["Chrome", "Firefox", "Safari", "Edge", "Opera"] # Zufallsdaten generieren user_ids = [f "user_ {i}" für i in np.random.randint (1000, 2000, size = nrows)] page_viited_data = np.random.choice (Seiten, size = nrows) Session_durations = np.random.randint (30, 1800, size = nrows) # Sitzungsdauer zwischen 30ern und 30 min Country_data = np.random.choice (L?nder, Gr??e = Nrows) Device_type_data = np.random.choice (Device_types, size = nrows) browser_data = np.random.choice (browser, size = nrows) # Generieren Sie in den letzten zwei Jahren zuf?llige Zeitstempel end_t = datetime.now () start_t = end_t - Timedelta (Tage = 730) time_range_seconds = int ((end_t - start_t) .total_seconds ()) TIMESTAMPS_DATA = [] für _ im Bereich (NROWS): random_seconds = np.random.randint (0, time_range_seconds) TIMESTAMP = START_T Timedelta (Sekunden = Random_sekunden) TIMESTAMPS_DATA.Append (Zeitstempel.Strftime ('%y-%M-%d%H:%M:%s')) # Spalten für den DataFrame definieren Spalten = { "Zeitstempel": TIMESTAMPS_DATA, "user_id": user_ids, "page_visesd": page_viited_data, "Session_duration_Seconds": Session_durations, "Land": Country_Data, "Device_type": Device_type_data, "Browser": browser_data, } # Pandas DataFrame erstellen df = pd.dataframe (Spalten) # Sortieren nach dem Zeitstempel df ['timestamp'] = pd.to_datetime (df ['timestamp']) df = df.sort_values ??(by = "timestamp"). reset_index (drop = true) # Schreiben Sie an CSV df.to_csv (Dateiname, index = false) print (f "{nrows} Zeilen von Datenzeilen generiert und in {Dateiname}")) # Generieren Sie 100.000 Datenzeilen generate_website_data (100_000, "Website_Engagement_data.csv")) # Drucken ("Bitte kontrollieren Sie die obige Zeile, um die Daten zu generieren.")
Ausgabe:
100000 Zeilen von Datenzeilen generiert und gespeichert auf Website_Engagement_data.csv
Nachdem Sie diesen Code ausgeführt haben, sehen Sie eine Ausgabe, und eine CSV -Datei, die die Daten enth?lt, wird generiert.
2. Installieren von Gradio
Die Installation von Gradio ist mit PIP sehr unkompliziert. Es wird empfohlen, eine dedizierte Python -Umgebung zu verwenden. Tools wie Venv und Conda k?nnen verwendet werden, um eine isolierte Umgebung zu schaffen. Gradio ben?tigt Python 3.8 oder eine neuere Version.
Python -m Venv Gradio_env Source Gradio_env/bin/aktivieren # unter Linux/macos . \ gradio_env \ scripts \ aktivieren # unter Windows aktivieren
Installation der erforderlichen Bibliotheken
PIP Installieren Sie Gradio Pandas Plotly Cachetools
Jetzt haben wir alle Abh?ngigkeiten installiert. Lassen Sie uns Schritt für Schritt das Dashboard erstellen.
3.. Importieren der notwendigen Bibliotheken
Erstellen Sie zun?chst eine App.py -Datei und importieren Sie die erforderlichen Bibliotheken zum Erstellen des interaktiven Dashboards. Wir werden Plotly für die Gradio -Datenvisualisierung verwenden. Und Cachetools zum Erstellen eines Cache für teure Funktionsaufrufe zur Verbesserung der Leistung.
Import Gradio als Gr Pandas als PD importieren plotly.express als px importieren plotly.graph_objects as Go importieren Ab DateTime Import DateTime, Datum aus Cachetools zwischengespeichert, ttlcache importieren Warnungen importieren Warnungen.FilterWarnings ("Ignore", Kategorie = FutureWarning, Module = "Plotly") Warnungen.FilterWarnings ("Ignore", category = userWarning, module = "plotly")
4. Laden Sie die CSV -Daten
Laden wir die generierte CSV -Datei. Stellen Sie sicher, dass sich die CSV -Datei im selben Verzeichnis wie Ihre App.py befindet.
# --- CSV-Daten laden --- Data_file = "Website_Engagement_Data.csv" # achten Sie sicher raw_data = keine Def load_engagement_data (): Global RAW_DATA versuchen: # Daten generieren, wenn es nicht vorhanden ist (für Erstmals) OS importieren Wenn nicht os.path.exists (data_file): print (f "{data_file} nicht gefunden. Synthetische Daten generieren ...") print (f "Bitte generieren Sie {data_file} 'mit dem bereitgestellten Skript zuerst, wenn es fehlt.") return pd.dataframe () DTYPE_SPEC = { 'user_id': 'String',, 'page_visited': 'Kategorie',, 'Session_duration_seconds': 'int32',, 'Land': 'Kategorie', 'Device_type': 'Kategorie',, 'Browser': 'Kategorie' } raw_data = pd.read_csv ( Data_file, Parse_dates = ["Timestamp"], DTYPE = DTYPE_SPEC, low_memory = false ) # Stellen Sie sicher, dass der Zeitstempel datetime ist raw_data ['timestamp'] = pd.to_datetime (raw_data ['timestamp']) print (f "Daten erfolgreich geladen: {len (raw_data)} Zeilen.") Au?er FilenotFoundError: print (f "Fehler: Die Datei {data_file} wurde nicht gefunden.") raw_data = pd.dataframe () # leerer Datenframe zurückgeben, wenn die Datei nicht gefunden wurde au?er Ausnahme als E: print (f "Ein Fehler beim Laden von Daten: {e}") raw_data = pd.dataframe () RECH RAW_DATA zurück # Daten beim Skriptstart laden load_engagement_data ()
5. Caching- und Versorgungsfunktionen
Diese Funktionen werden verwendet, um einen Cache für das schnelle Laden von Daten zu erstellen, wodurch die Berechnungszeit verkürzt wird.
# Caching- und Dienstprogrammfunktionen --- # Cache für teure Funktionsaufrufe zur Verbesserung der Leistung ttl_cache = ttlcache (maxSize = 100, ttl = 300) # cache bis zu 100 Elemente, nach 5 Minuten verfallen @cached (ttl_cache) Def get_unique_filter_values ??(): Wenn raw_data keine oder raw_data.eMpty ist: zurückkehren [], [], [] Seiten = sortiert (RAW_DATA ['PAGE_VISED']. DROPNA (). Unique (). Tolist ()) devices = sortiert (RAW_DATA ['Device_type']. Dropna (). Unique (). Tolist ()) L?nder = sortiert (raw_data ['Land']. Dropna (). Unique (). Tolist ()) Rückgabeseiten, Ger?te, L?nder Def get_date_range_from_data (): Wenn raw_data keine oder raw_data.eMpty ist: Rückgabedatum.today (), Datum.today () min_dt = raw_data ['timestamp']. min (). Datum () max_dt = raw_data ['timestamp']. max (). date () return min_dt, max_dt
6. Datenfilterung und wichtige Metrikenfunktionen
Die folgende Funktion wird verwendet, um die Daten basierend auf den Eingaben oder Aktionen des Benutzers auf dem Dashboard zu filtern.
# Datenfilterungsfunktion --- Def Filter_Engagement_Data (start_date_dt, end_date_dt, selected_page, selected_device, selected_country): Global RAW_DATA Wenn raw_data keine oder raw_data.eMpty ist: return pd.dataframe () # Stellen Sie sicher Wenn isinstance (start_date_dt, str): start_date_dt = datetime.strptime (start_date_dt, '%y-%M-%d'). Datum ()). Wenn isinstance (end_date_dt, str): end_date_dt = datetime.strptime (end_date_dt, '%y-%M-%d'). Datum ()) # Umwandeln Sie Daten zum Vergleich mit der Zeitstempelspalte in DateTime um start_datetime = datetime.combine (start_date_dt, datetime.min.time ()) end_datetime = datetime.combine (end_date_dt, datetime.max.time ()) filtered_df = raw_data [ (raw_data ['timestamp']> = start_datetime) & (raw_data ['timestamp'] <p> Die n?chste Funktion wird verwendet, um die wichtigsten Kennzahlen wie Gesamtsitzungen, eindeutige Benutzer und Top -Seite nach Anzahl der Besucher zu berechnen.</p><pre class="brush:php;toolbar:false"> #Funktion zur Berechnung der Schlüsselmetriken --- @cached (ttl_cache) Def calculate_key_metrics (start_date_dt, end_date_dt, Seite, Ger?t, Land): df = filter_engagement_data (start_date_dt, end_date_dt, Seite, Ger?t, Land) Wenn df.empty: Rückgabe 0, 0, 0, "n/a" Total_Sessions = df ['user_id']. count () # unter der Annahme, dass jede Zeile eine Sitzung/Interaktion ist Unique_users = df ['user_id']. nunique () avg_session_duration = df ['Session_duration_seconds']. Mean ()) wenn avg_session_duration = 0 # Top -Seite nach Anzahl der Besuche wenn nicht df ['page_vises']. modus (). leer: TOP_PAGE_VEITED = DF ['PAGE_VISED']. modus () [0] anders: TOP_PAGE_VEITED = "N/A" return Total_Sessions, Unique_Users, Round (avg_session_duration, 2), TOP_PAGE_VE.
7. Diagramm -Plotfunktionen
Jetzt werden wir einige Diagramm -Plotfunktionen mithilfe von Plotly erstellen. Dadurch wird unser Dashboard detaillierter und ansprechender aussehen.
# Funktionen für das Planen mit Handlung --- Def create_sessions_over_time_plot (start_date_dt, end_date_dt, Seite, Ger?t, Land): df = filter_engagement_data (start_date_dt, end_date_dt, Seite, Ger?t, Land) Wenn df.empty: Abb. Rückkehr Abb SESSIONS_BY_DATE = DF.GROUPBY (df ['Timestamp']. Dt.date) ['user_id']. count (). reset_index () SESSIONS_BY_DATE.Rename (columns = {'timestamp': 'Date', 'user_id': 'Sessions'}, inplaPl = true) Fig = PX.Line (Sessions_by_date, x = 'Date', y = 'Sessions', title = 'Benutzersitzungen im Laufe der Zeit'). Abb.Update_Layout (margin = dict (l = 20, r = 20, t = 40, b = 20)) Rückkehr Abb Def create_engagement_by_device_plot (start_date_dt, end_date_dt, Seite, Ger?t, Land): df = filter_engagement_data (start_date_dt, end_date_dt, Seite, Ger?t, Land) Wenn df.empty: Abb. Rückkehr Abb Device_Engagement = df.groupby ('Device_type') ['Session_duration_seconds']. sum (). reset_index () Device_Engagement.rename (columns = {'Session_duration_seconds': 'Total_duration'}, inplace = true) Abb. title = 'Gesamtsitzungsdauer nach Ger?tetyp', color = 'Device_type') Abb.Update_Layout (margin = dict (l = 20, r = 20, t = 40, b = 20)) Rückkehr Abb Def create_page_vissits_distribution_plot (start_date_dt, end_date_dt, Seite, Ger?t, Land): df = filter_engagement_data (start_date_dt, end_date_dt, Seite, Ger?t, Land) Wenn df.empty: Abb. Rückkehr Abb page_visitsits = df ['page_vises']. value_counts (). reset_index () page_vissits.columns = ['page_vises', 'Visits'] Fig = px.pie (page_vissits, names = 'page_vises', values ??= 'besucht',, Titel = 'Verteilung der Seitenbesuche', Loch = 0,3) Abb.Update_Layout (margin = dict (l = 20, r = 20, t = 40, b = 20)) Rückkehr Abb
8. Tabellenanzeige- und Datenaktualisierungsfunktionen
Die folgenden Funktionen werden verwendet, um die Daten für die tabellarische Anzeige zu erstellen und die Dashboard -Werte nach Funktionen oder Eingaben des Benutzers zu aktualisieren.
# Funktion zum Erstellen von Daten für die Tabellenanzeige --- Def get_data_for_table_display (start_date_dt, end_date_dt, Seite, Ger?t, Land): df = filter_engagement_data (start_date_dt, end_date_dt, Seite, Ger?t, Land) Wenn df.empty: Return pd.dataframe (columns = ['timestamp', 'user_id', 'page_vided', 'Session_duration_seconds', 'Country', 'Device_Type', 'Browser']) # Spalten für die Anzeige ausw?hlen und bestellen display_columns = ['timestamp', 'user_id', 'page_visesd', 'session_duration_seconds', 'land', 'device_type', 'browser'] df_display = df [display_columns] .copy () df_display ['timestamp'] = df_display ['timestamp']. Return DF_Display.head (100) # Top 100 Zeilen für die Leistung anzeigen #Main-Update-Funktion für das Dashboard --- Def update_full_dashboard (start_date_str, end_date_str, selected_page, selected_device, selected_country): Wenn RAW_DATA keine oder RAW_DATA.EMPTY: # Behandlungsfall, in dem das Laden von Daten fehlgeschlagen ist leere_fig = go.Figure (). update_layout (title_text = "Daten nicht geladen", xaxis_showgrid = false, yaxis_showgrid = false) leere_df = pd.dataframe ()) return lese_fig, leer_fig, leer_fig, leer_df, 0, 0, 0.0, "n/a" # Konvertieren Sie Datumszeichenfolgen von der Gradio -Eingabe in DateTime.Date -Objekte start_date_obj = datetime.strptime (start_date_str, '%y-%M-%d'). Date () if isinstance (start_date_str, str) sonst start_date_str end_date_obj = datetime.strptime (end_date_str, '%y-%M-%d'). Date () if isinstance (end_date_str, str) sonst end_date_str # Get wichtige Metriken Sitzungen, Benutzer, avg_duration, top_page = calculate_key_metrics ( start_date_obj, end_date_obj, selected_page, selected_device, selected_country ) # Diagramme generieren plot_sessions_time = create_Sessions_over_time_plot ( start_date_obj, end_date_obj, selected_page, selected_device, selected_country ) plot_engagement_device = create_engagement_by_device_plot ( start_date_obj, end_date_obj, selected_page, selected_device, selected_country ) plot_page_visits = create_page_visits_distribution_plot ( start_date_obj, end_date_obj, selected_page, selected_device, selected_country ) # Daten für die Tabelle abrufen table_df = get_data_for_table_display ( start_date_obj, end_date_obj, selected_page, selected_device, selected_country ) zurückkehren ( plot_sessions_time, plot_engagement_device, plot_page_vissits, table_df, Sitzungen, Benutzer, avg_duration, top_page )
9. Gradio -Schnittstelle erstellen
Schlie?lich erstellen wir die Gradio -Schnittstelle mit allen oben erstellten Nutzfunktionen.
# Gradio Dashboard-Schnittstelle erstellen --- Def Build_engagement_dashboard (): Unique_pages, Unique_Devices, Unique_countries = get_unique_filter_values ??() min_data_date, max_data_date = get_date_range_from_data () # Setzen Sie die Anfangsdaten als Zeichenfolgen für Gradio -Komponenten initial_start_date_str = min_data_date.strftime ('%y-%M-%d') initial_end_date_str = max_data_date.strftime ('%y-%M-%d') mit gr.blocks (thema = gr.themes.soft (), title = "Website -Engagement -Dashboard") als Dashboard_interface: Gr.Markdown ("# Website -Benutzer -Engagement -Dashboard")) Gr.Markdown ("Benutzeraktivit?tstrends und Engagement -Metriken für Ihre Website erkunden. Diese ** Python Gradio Dashboard ** hilft bei ** Gradio -Datenvisualisierung **.") # --- Filterreihe --- mit gr.row (): start_date_picker = gr.textbox (Label = "Startdatum (yyyy-mm-dd)", value = initial_start_date_str, type = "text")) end_date_picker = gr.textbox (label = "Enddatum (yyyy-mm-dd)", value = initial_end_date_str, type = "text") mit gr.row (): page_dropdown = gr.dropdown (Choices = ["Alle Seiten"] eindeutig_pages, label = "Seite besucht", value = "alle Seiten") Ger?te_Dropdown = gr.dropdown (Choices = ["Alle Ger?te"] Unique_devices, Label = "Ger?tetyp", value = "alle Ger?te") Country_Dropdown = gr.dropdown (Auswahl = ["Alle L?nder"] Unique_countries, Label = "Country", Value = "Alle L?nder") # --- Key Metrics Display --- Gr.markdown ("## Schlüsselmetriken") mit gr.row (): Total_Sessions_num = gr.number (Label = "Gesamtsitzungen", value = 0, Precision = 0) Unique_users_num = gr.number (Label = "Eindeutige Benutzer", value = 0, Precision = 0) avg_duration_num = gr.number (label = "avg. Sitzungsdauer (s)", value = 0, precision = 2) top_page_text = gr.textbox (Label = "Die meisten besuchten Seite", value = "n/a", interActive = false) # --- Visualisierungen Registerkarten --- Gr.markdown ("## Visualisierungen") mit gr.tabs (): mit gr.tabitem ("Sitzungen im Laufe der Zeit"): Sitzungen_Plot_Output = gr.plot ()) Mit Gr.Tabitem ("Engagement by Device"): Ger?t_Plot_Output = gr.plot ()) Mit Gr.Tabitem ("Seitenbesuchsverteilung"): Page_visits_plot_output = gr.plot ()) # --- Rohdatentabelle --- Gr.markdown ("## RAW -Engagement -Daten (Beispiel)")) # Korrigiert: MAX_ROWS entfernt. Die Anzahl der angezeigten Zeilen wird gesteuert # durch den Datenfreame, der von get_data_for_table_display zurückgegeben wurde (was den Kopf (100) zurückgibt). # Gradio wird dies dann paginieren oder scrollen. data_table_output = gr.dataframe ( Label = "Benutzersitzungen Daten", interaktiv = falsch, Headers = ['Timestamp', 'Benutzer -ID', 'Seite besucht', 'Dauer' ',' Land ',' Ger?t ',' Browser '] # Für die Anzeigeh?he k?nnen Sie den Parameter "H?he", z. B. H?he = 400 ) # --- Definieren Sie Eingaben und Ausg?nge für die Aktualisierungsfunktion --- inputs_list = [start_date_picker, end_date_picker, page_dropdown, device_dropdown, country_dropdown] outs_list = [ SESSISS_PLOT_OUTPUT, Ger?t_Plot_Output, page_visits_plot_output, Data_table_output, Total_Sessions_num, Unique_users_num, avg_duration_num, top_page_text ] # --- Ereignisbearbeitung: Aktualisieren Sie das Dashboard, wenn sich Filter ?ndern --- Für filter_component in Inputs_List: Wenn isinstance (filter_component, gr.textbox): filter_component.submit (fn = update_full_dashboard, inputs = inputs_list, outputs = outputs_list) anders: filter_component.change (fn = update_full_dashboard, inputs = inputs_list, outputs = outputs_list) # --- Erste Last des Dashboards --- Dashboard_interface.load ( fn = update_full_dashboard, inputs = inputs_list, Ausg?nge = Ausg?nge_List ) return Dashboard_interface
10. Hauptausführungsfunktion zum Ausführen des Gradio
Hier führen wir die Hauptfunktion, Build_Engagement_Dashboard aus, mit der die Schnittstelle für den Start der Webanwendung vorbereitet wird.
# --- Hauptausführungsblock --- Wenn __name__ == "__main__": Wenn raw_data keine oder raw_data.eMpty ist: Print ("Stalten: Daten konnten nicht geladen werden. Bitte stellen Sie sicher, dass 'Website_Engagement_data.csv' existiert oder generiert werden kann.") anders: print ("Erstellen und Starten des Gradio Dashboard ...") Engagement_dashboard = build_engagement_dashboard () Engagement_dashboard.launch (server_name = "0.0.0.0") # macht es im lokalen Netzwerk zug?nglich Print ("Dashboard wird ausgeführt. ?ffnen Sie Ihren Browser für die bereitgestellte URL.")
Führen Sie nun die Python App.py im Terminal aus, um die Webanwendung auszuführen.
Ausgabe:
Klicken Sie auf den lokalen URL -Link, um die Gradio -Schnittstelle zu starten.
Ausgabe:
Es wurde ein interaktives Dashboard erstellt. Wir k?nnen diese Schnittstelle verwenden, um unseren Datensatz zu analysieren und auf interaktive Weise leicht daraus zu erkennen.
Wir k?nnen die Visualisierungen anhand verschiedener Filter sehen.
Abschluss
Gradio kann effektiv eingesetzt werden, um Einblicke aus einem massiven Datensatz zu erhalten. Durch das Erstellen eines interaktiven Visualisierungs -Dashboards kann der Prozess der Datenanalyse engagiert werden. Wenn Sie diese detaillierte Anleitung abgeschlossen haben, k?nnen Sie mit Gradio ein interaktives Dashboard effizient erstellen. Wir haben die Datenerzeugung, das Laden, das Zwischenspeichern, die Definition der Filterlogik, die Berechnung der Metriken und das Erstellen von Diagrammen mit Plotly behandelt. Um dies aufzubauen, war keine Kenntnis der Front-End-Programmierung und -technologien erforderlich. W?hrend wir CSV in diesem Handbuch verwendet haben, k?nnen Sie bei Bedarf jede andere Datenquelle verwenden. Gradio erwies sich als wertvolles Tool zum Erstellen dynamischer und benutzerfreundlicher Dashboards.
Das obige ist der detaillierte Inhalt vonErstellen einer interaktiven Daten -Dashboard -Erstellung mit Gradio. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Hei?e KI -Werkzeuge

Undress AI Tool
Ausziehbilder kostenlos

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem v?llig kostenlosen KI-Gesichtstausch-Tool aus!

Hei?er Artikel

Hei?e Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Erinnern Sie sich an die Flut chinesischer Open-Source-Modelle, die die Genai-Industrie Anfang dieses Jahres gest?rt haben? W?hrend Deepseek die meisten Schlagzeilen machte, war Kimi K1.5 einer der herausragenden Namen in der Liste. Und das Modell war ziemlich cool.

Bis Mitte 2025 heizt sich das KI ?Wettret“ auf, und Xai und Anthropic haben beide ihre Flaggschiff-Modelle GROK 4 und Claude 4 ver?ffentlicht. Diese beiden Modelle befinden

Aber wir müssen wahrscheinlich nicht einmal 10 Jahre warten, um einen zu sehen. Was als erste Welle wirklich nützlicher, menschlicher Maschinen angesehen werden k?nnte, ist bereits da. In den letzten Jahren wurden eine Reihe von Prototypen und Produktionsmodellen aus t herausgezogen

Bis zum Vorjahr wurde eine schnelle Engineering als entscheidende F?higkeit zur Interaktion mit gro?artigen Modellen (LLMs) angesehen. In jüngster Zeit sind LLM jedoch in ihren Argumentations- und Verst?ndnisf?higkeiten erheblich fortgeschritten. Natürlich unsere Erwartung

Aufgebaut auf Leia's propriet?rer neuronaler Tiefenmotor verarbeitet die App still Bilder und fügt die natürliche Tiefe zusammen mit simulierten Bewegungen hinzu - wie Pfannen, Zoome und Parallaxeffekte -, um kurze Video -Rollen zu erstellen, die den Eindruck erwecken, in die SCE einzusteigen

Stellen Sie sich vor, dass etwas Geformtes, wie ein KI -Motor, der bereit ist, ein detailliertes Feedback zu einer neuen Kleidungssammlung von Mailand oder automatische Marktanalyse für ein weltweit betriebenes Unternehmen zu geben, oder intelligentes Systeme, das eine gro?e Fahrzeugflotte verwaltet.

Eine neue Studie von Forschern am King's College London und der University of Oxford teilt die Ergebnisse dessen, was passiert ist, als OpenAI, Google und Anthropic in einem Cutthroat -Wettbewerb zusammengeworfen wurden, der auf dem iterierten Dilemma des Gefangenen basiert. Das war nein

Wissenschaftler haben eine clevere, aber alarmierende Methode aufgedeckt, um das System zu umgehen. Juli 2025 markierte die Entdeckung einer aufw?ndigen Strategie, bei der Forscher unsichtbare Anweisungen in ihre akademischen Einreichungen eingefügt haben - diese verdeckten Richtlinien waren Schwanz
