Warst du jemals in einer Scenario 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 -Experience für die Datenvisualisierung. Gradio bietet diese Funktionalität mit minimaler Codierung, wenn sie neben Python verwendet wird. Die Datenvisualisierung ist ein leistungsstarkes Instrument, 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.

Gradio verstehen

Gradio ist eine Open-Supply-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 Internet -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.

Beide Instruments können verwendet werden, um interaktive Dashboards zu erstellen. Die Wahl von einem hängt von den spezifischen Anforderungen des Projekts ab.

Mehr lesen: Gradio gegen stromlit 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 die Python Gradio Dashboard ist eine synthetische CSV -Datei. Es enthält 100.000 Datensätze, die das Engagement der Web site des Web site -Benutzers simulieren. Jeder Datensatz stellt eine Benutzersitzung oder eine signifikante Interaktion dar.

Hier ist ein Beispiel, wie unser CSV aussehen wird:

Sie können den folgenden Python -Code verwenden, um diese Artwork von Daten zu generieren. Hier generieren wir einen zu Demonstrationszwecken. Stellen Sie sicher, dass Sie Numpy und Pandas installiert haben.

import numpy as np

import pandas as pd

from datetime import datetime, timedelta

def generate_website_data(nrows: int, filename: str):

   # Potential values for categorical fields

   pages = ("/residence", "/merchandise", "/companies", "/about", "/contact", "/weblog")

   international locations = ("USA", "Canada", "UK", "Germany", "France", "India", "Australia")

   device_types = ("Desktop", "Cellular", "Pill")

   browsers = ("Chrome", "Firefox", "Safari", "Edge", "Opera")

   # Generate random knowledge

   user_ids = (f"User_{i}" for i in np.random.randint(1000, 2000, dimension=nrows))

   page_visited_data = np.random.selection(pages, dimension=nrows)

   session_durations = np.random.randint(30, 1800, dimension=nrows) # Session length between 30s and 30min

   country_data = np.random.selection(international locations, dimension=nrows)

   device_type_data = np.random.selection(device_types, dimension=nrows)

   browser_data = np.random.selection(browsers, dimension=nrows)

   # Generate random timestamps during the last two years

   end_t = datetime.now()

   start_t = end_t - timedelta(days=730)

   time_range_seconds = int((end_t - start_t).total_seconds())

   timestamps_data = ()

   for _ in vary(nrows):

       random_seconds = np.random.randint(0, time_range_seconds)

       timestamp = start_t + timedelta(seconds=random_seconds)

       timestamps_data.append(timestamp.strftime('%Y-%m-%d %H:%M:%S'))

   # Outline columns for the DataFrame

   columns = {

       "timestamp": timestamps_data,

       "user_id": user_ids,

       "page_visited": page_visited_data,

       "session_duration_seconds": session_durations,

       "nation": country_data,

       "device_type": device_type_data,

       "browser": browser_data,

   }

   # Create Pandas DataFrame

   df = pd.DataFrame(columns)

   # Kind by timestamp

   df('timestamp') = pd.to_datetime(df('timestamp'))

   df = df.sort_values(by="timestamp").reset_index(drop=True)

   # Write to CSV

   df.to_csv(filename, index=False)

   print(f"{nrows} rows of knowledge generated and saved to {filename}")

# Generate 100,000 rows of knowledge

generate_website_data(100_000, "website_engagement_data.csv")

# print("Please uncomment the above line to generate the information.")

Ausgabe:

100000 rows of knowledge generated and saved to 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 Set up von Gradio ist mit PIP sehr unkompliziert. Es wird empfohlen, eine dedizierte Python -Umgebung zu verwenden. Instruments wie Venv und Conda können verwendet werden, um eine isolierte Umgebung zu schaffen. Gradio benötigt Python 3.8 oder eine neuere Model.

python -m venv gradio_env

supply gradio_env/bin/activate  # On Linux/macOS

.gradio_envScriptsactivate  # On Home windows

Set up der erforderlichen Bibliotheken

pip set up 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 as gr

import pandas as pd

import plotly.categorical as px

import plotly.graph_objects as go

from datetime import datetime, date

from cachetools import cached, TTLCache

import warnings

warnings.filterwarnings("ignore", class=FutureWarning, module="plotly")

warnings.filterwarnings("ignore", class=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.

# --- Load CSV knowledge ---

DATA_FILE = "website_engagement_data.csv" # Ensure that this file is generated and in the identical listing or present full path

raw_data = None

def load_engagement_data():

   international raw_data

   attempt:

       # Generate knowledge if it does not exist (for first-time run)

       import os

       if not os.path.exists(DATA_FILE):

           print(f"{DATA_FILE} not discovered. Producing artificial knowledge...")

           print(f"Please generate '{DATA_FILE}' utilizing the offered script first if it is lacking.")

           return pd.DataFrame()

       dtype_spec = {

           'user_id': 'string',

           'page_visited': 'class',

           'session_duration_seconds': 'int32',

           'nation': 'class',

           'device_type': 'class',

           'browser': 'class'

       }

       raw_data = pd.read_csv(

           DATA_FILE,

           parse_dates=("timestamp"),

           dtype=dtype_spec,

           low_memory=False

       )

       # Guarantee timestamp is datetime

       raw_data('timestamp') = pd.to_datetime(raw_data('timestamp'))

       print(f"Information loaded efficiently: {len(raw_data)} rows.")

   besides FileNotFoundError:

       print(f"Error: The file {DATA_FILE} was not discovered.")

       raw_data = pd.DataFrame() # Return empty dataframe if file not discovered

   besides Exception as e:

       print(f"An error occurred whereas loading knowledge: {e}")

       raw_data = pd.DataFrame()

   return raw_data

# Load knowledge at script startup

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 and Utility Capabilities ---

# Cache for costly perform calls to enhance efficiency

ttl_cache = TTLCache(maxsize=100, ttl=300) # Cache as much as 100 gadgets, expire after 5 minutes

@cached(ttl_cache)

def get_unique_filter_values():

   if raw_data is None or raw_data.empty:

       return (), (), ()

   pages = sorted(raw_data('page_visited').dropna().distinctive().tolist())

   units = sorted(raw_data('device_type').dropna().distinctive().tolist())

   international locations = sorted(raw_data('nation').dropna().distinctive().tolist())

   return pages, units, international locations

def get_date_range_from_data():

   if raw_data is None or raw_data.empty:

       return date.at this time(), date.at this time()

   min_dt = raw_data('timestamp').min().date()

   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.

# Information Filtering Operate ---

def filter_engagement_data(start_date_dt, end_date_dt, selected_page, selected_device, selected_country):

   international raw_data

   if raw_data is None or raw_data.empty:

       return pd.DataFrame()

   # Guarantee dates are datetime.date objects if they're strings

   if isinstance(start_date_dt, str):

       start_date_dt = datetime.strptime(start_date_dt, '%Y-%m-%d').date()

   if isinstance(end_date_dt, str):

       end_date_dt = datetime.strptime(end_date_dt, '%Y-%m-%d').date()

   # Convert dates to datetime for comparability with timestamp column

   start_datetime = datetime.mix(start_date_dt, datetime.min.time())

   end_datetime = datetime.mix(end_date_dt, datetime.max.time())

   filtered_df = raw_data(

       (raw_data('timestamp') >= start_datetime) &

       (raw_data('timestamp') <= end_datetime)

   ).copy()

   if selected_page != "All Pages" and selected_page just isn't None:

       filtered_df = filtered_df(filtered_df('page_visited') == selected_page)

   if selected_device != "All Gadgets" and selected_device just isn't None:

       filtered_df = filtered_df(filtered_df('device_type') == selected_device)

   if selected_country != "All Nations" and selected_country just isn't None:

       filtered_df = filtered_df(filtered_df('nation') == selected_country)

   return filtered_df

Die nächste Funktion wird verwendet, um die wichtigsten Kennzahlen wie Gesamtsitzungen, eindeutige Benutzer und Prime -Seite nach Anzahl der Besucher zu berechnen.

#Operate to Calculate Key Metrics ---

@cached(ttl_cache)

def calculate_key_metrics(start_date_dt, end_date_dt, web page, machine, nation):

   df = filter_engagement_data(start_date_dt, end_date_dt, web page, machine, nation)

   if df.empty:

       return 0, 0, 0, "N/A"

   total_sessions = df('user_id').depend() # Assuming every row is a session/interplay

   unique_users = df('user_id').nunique()

   avg_session_duration = df('session_duration_seconds').imply()

   if pd.isna(avg_session_duration): # Deal with case the place imply is NaN (e.g., no periods)

       avg_session_duration = 0

   # Prime web page by variety of visits

   if not df('page_visited').mode().empty:

       top_page_visited = df('page_visited').mode()(0)

   else:

       top_page_visited = "N/A"

   return total_sessions, unique_users, spherical(avg_session_duration, 2), top_page_visited

7. Diagramm -Plotfunktionen

Jetzt werden wir einige Diagramm -Plotfunktionen mithilfe von Plotly erstellen. Dadurch wird unser Dashboard detaillierter und ansprechender aussehen.

# Capabilities for Plotting with Plotly ---

def create_sessions_over_time_plot(start_date_dt, end_date_dt, web page, machine, nation):

   df = filter_engagement_data(start_date_dt, end_date_dt, web page, machine, nation)

   if df.empty:

       fig = go.Determine().update_layout(title_text="No knowledge for chosen filters", xaxis_showgrid=False, yaxis_showgrid=False)

       return fig

   sessions_by_date = df.groupby(df('timestamp').dt.date)('user_id').depend().reset_index()

   sessions_by_date.rename(columns={'timestamp': 'date', 'user_id': 'periods'}, inplace=True)

   fig = px.line(sessions_by_date, x='date', y='periods', title="Person Classes Over Time")

   fig.update_layout(margin=dict(l=20, r=20, t=40, b=20))

   return fig

def create_engagement_by_device_plot(start_date_dt, end_date_dt, web page, machine, nation):

   df = filter_engagement_data(start_date_dt, end_date_dt, web page, machine, nation)

   if df.empty:

       fig = go.Determine().update_layout(title_text="No knowledge for chosen filters", xaxis_showgrid=False, yaxis_showgrid=False)

       return fig

   device_engagement = df.groupby('device_type')('session_duration_seconds').sum().reset_index()

   device_engagement.rename(columns={'session_duration_seconds': 'total_duration'}, inplace=True)

   fig = px.bar(device_engagement, x='device_type', y='total_duration',

                title="Complete Session Period by Gadget Sort", shade="device_type")

   fig.update_layout(margin=dict(l=20, r=20, t=40, b=20))

   return fig

def create_page_visits_distribution_plot(start_date_dt, end_date_dt, web page, machine, nation):

   df = filter_engagement_data(start_date_dt, end_date_dt, web page, machine, nation)

   if df.empty:

       fig = go.Determine().update_layout(title_text="No knowledge for chosen filters", xaxis_showgrid=False, yaxis_showgrid=False)

       return fig

   page_visits = df('page_visited').value_counts().reset_index()

   page_visits.columns = ('page_visited', 'visits')

   fig = px.pie(page_visits, names="page_visited", values="visits",

                title="Distribution of Web page Visits", gap=0.3)

   fig.update_layout(margin=dict(l=20, r=20, t=40, b=20))

   return fig

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.

# Operate to Put together Information for Desk Show ---

def get_data_for_table_display(start_date_dt, end_date_dt, web page, machine, nation):

   df = filter_engagement_data(start_date_dt, end_date_dt, web page, machine, nation)

   if df.empty:

       return pd.DataFrame(columns=('timestamp', 'user_id', 'page_visited', 'session_duration_seconds', 'nation', 'device_type', 'browser'))

   # Choose and order columns for show

   display_columns = ('timestamp', 'user_id', 'page_visited', 'session_duration_seconds', 'nation', 'device_type', 'browser')

   df_display = df(display_columns).copy()

   df_display('timestamp') = df_display('timestamp').dt.strftime('%Y-%m-%d %H:%M:%S') # Format date for show

   return df_display.head(100) # Show prime 100 rows for efficiency

#Essential Replace Operate for the Dashboard ---

def update_full_dashboard(start_date_str, end_date_str, selected_page, selected_device, selected_country):

   if raw_data is None or raw_data.empty: # Deal with case the place knowledge loading failed

       empty_fig = go.Determine().update_layout(title_text="Information not loaded", xaxis_showgrid=False, yaxis_showgrid=False)

       empty_df = pd.DataFrame()

       return empty_fig, empty_fig, empty_fig, empty_df, 0, 0, 0.0, "N/A"

   # Convert date strings from Gradio enter to datetime.date objects

   start_date_obj = datetime.strptime(start_date_str, '%Y-%m-%d').date() if isinstance(start_date_str, str) else start_date_str

   end_date_obj = datetime.strptime(end_date_str, '%Y-%m-%d').date() if isinstance(end_date_str, str) else end_date_str

   # Get key metrics

   periods, customers, avg_duration, top_page = calculate_key_metrics(

       start_date_obj, end_date_obj, selected_page, selected_device, selected_country

   )

   # Generate plots

   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

   )

   # Get knowledge for desk

   table_df = get_data_for_table_display(

       start_date_obj, end_date_obj, selected_page, selected_device, selected_country

   )

   return (

       plot_sessions_time,

       plot_engagement_device,

       plot_page_visits,

       table_df,

       periods,

       customers,

       avg_duration,

       top_page

   )

9. Gradio -Schnittstelle erstellen

Schließlich erstellen wir die Gradio -Schnittstelle mit allen oben erstellten Nutzfunktionen.

# Create Gradio Dashboard Interface ---

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()

   # Set preliminary dates as strings for Gradio parts

   initial_start_date_str = min_data_date.strftime('%Y-%m-%d')

   initial_end_date_str = max_data_date.strftime('%Y-%m-%d')

   with gr.Blocks(theme=gr.themes.Mushy(), title="Web site Engagement Dashboard") as dashboard_interface:

       gr.Markdown("# Web site Person Engagement Dashboard")

       gr.Markdown("Discover person exercise traits and engagement metrics to your web site. This **Python Gradio dashboard** helps with **Gradio knowledge visualization**.")

       # --- Filters Row ---

       with gr.Row():

           start_date_picker = gr.Textbox(label="Begin Date (YYYY-MM-DD)", worth=initial_start_date_str, kind="textual content")

           end_date_picker = gr.Textbox(label="Finish Date (YYYY-MM-DD)", worth=initial_end_date_str, kind="textual content")

       with gr.Row():

           page_dropdown = gr.Dropdown(decisions=("All Pages") + unique_pages, label="Web page Visited", worth="All Pages")

           device_dropdown = gr.Dropdown(decisions=("All Gadgets") + unique_devices, label="Gadget Sort", worth="All Gadgets")

           country_dropdown = gr.Dropdown(decisions=("All Nations") + unique_countries, label="Nation", worth="All Nations")

       # --- Key Metrics Show ---

       gr.Markdown("## Key Metrics")

       with gr.Row():

           total_sessions_num = gr.Quantity(label="Complete Classes", worth=0, precision=0)

           unique_users_num = gr.Quantity(label="Distinctive Customers", worth=0, precision=0)

           avg_duration_num = gr.Quantity(label="Avg. Session Period (s)", worth=0, precision=2)

           top_page_text = gr.Textbox(label="Most Visited Web page", worth="N/A", interactive=False)

       # --- Visualizations Tabs ---

       gr.Markdown("## Visualizations")

       with gr.Tabs():

           with gr.TabItem("Classes Over Time"):

               sessions_plot_output = gr.Plot()

           with gr.TabItem("Engagement by Gadget"):

               device_plot_output = gr.Plot()

           with gr.TabItem("Web page Go to Distribution"):

               page_visits_plot_output = gr.Plot()

       # --- Uncooked Information Desk ---

       gr.Markdown("## Uncooked Engagement Information (Pattern)")

       # Corrected: Eliminated max_rows. The variety of rows displayed might be managed

       # by the DataFrame returned by get_data_for_table_display (which returns head(100)).

       # Gradio will then paginate or scroll this.

       data_table_output = gr.DataFrame(

           label="Person Classes Information",

           interactive=False,

           headers=('Timestamp', 'Person ID', 'Web page Visited', 'Period (s)', 'Nation', 'Gadget', 'Browser')

           # For show peak, you should use the `peak` parameter, e.g., peak=400

       )

       # --- Outline Inputs & Outputs for Replace Operate ---

       inputs_list = (start_date_picker, end_date_picker, page_dropdown, device_dropdown, country_dropdown)

       outputs_list = (

           sessions_plot_output, device_plot_output, page_visits_plot_output,

           data_table_output,

           total_sessions_num, unique_users_num, avg_duration_num, top_page_text

       )

       # --- Occasion Dealing with: Replace dashboard when filters change ---

       for filter_component in inputs_list:

           if isinstance(filter_component, gr.Textbox):

                filter_component.submit(fn=update_full_dashboard, inputs=inputs_list, outputs=outputs_list)

           else:

                filter_component.change(fn=update_full_dashboard, inputs=inputs_list, outputs=outputs_list)

       # --- Preliminary load of the dashboard ---

       dashboard_interface.load(

           fn=update_full_dashboard,

           inputs=inputs_list,

           outputs=outputs_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 Begin der Webanwendung vorbereitet wird.

# --- Essential execution block ---

if __name__ == "__main__":

   if raw_data is None or raw_data.empty:

       print("Halting: Information couldn't be loaded. Please guarantee 'website_engagement_data.csv' exists or might be generated.")

   else:

       print("Constructing and launching the Gradio dashboard...")

       engagement_dashboard = build_engagement_dashboard()

       engagement_dashboard.launch(server_name="0.0.0.0") # Makes it accessible on native community

       print("Dashboard is operating. Open your browser to the offered URL.")

Führen Sie jetzt die Python app.py im Terminal zur Ausführung der Webanwendung.

Ausgabe:

Klicken Sie auf den lokalen URL -Hyperlink, 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, conflict keine Kenntnis der Entrance-Finish-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 Instrument zum Erstellen dynamischer und benutzerfreundlicher Dashboards.

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.

Dashboard -Demo auf Umarmung

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 cachetools

Schlü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.title

Der 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.

Verarbeitung natürlicher Sprache ist in den letzten Jahren schnell gewachsen. Während personal Modelle die Führung haben, haben Open-Supply-Modelle aufgenommen. Olmo 2 ist ein großer Schritt nach vorne in der Open-Supply-Welt und bietet Macht und Zugänglichkeit ähnlich wie personal Modelle. Dieser Artikel enthält eine detaillierte Diskussion von OLMO 2, die seine Ausbildung, Leistung und die Verwendung vor Ort behandelt.

Lernziele

• Verstehen Sie die Bedeutung von Open-Supply Llms und die Rolle von Olmo 2 in der KI -Forschung.
• Erkunden Sie die Architektur, Trainingsmethodik und Leistungsbenchmarks von Olmo 2.
• Unterscheiden Sie zwischen offenen, teilweise offenen und vollständig geöffneten Modellen.
• Erfahren Sie, wie Sie OLMO 2 lokal mit Gradio und ausführen Langchain.
• Implementieren Sie OLMO 2 in einer Chatbot -Anwendung mit Python Codebeispiele.

Dieser Artikel wurde als Teil der veröffentlicht Knowledge Science Blogathon.

Verständnis der Notwendigkeit von Open-Supply-LLMs

Die anfängliche Dominanz von proprietären LLMs führte zu Bedenken hinsichtlich Zugänglichkeit, Transparenz und Kontrolle. Forscher und Entwickler waren begrenzt in ihrer Fähigkeit, die inneren Funktionsweise dieser Modelle zu verstehen, wodurch weitere Innovationen behindert und möglicherweise Vorurteile aufrechterhalten werden. Open-Supply LLMs haben diese Bedenken berücksichtigt, indem sie ein kollaboratives Umfeld bereitstellen, in dem Forscher vorhandene Modelle prüfen, modifizieren und verbessern können. Ein offener Ansatz ist entscheidend, um das Feld voranzutreiben und sicherzustellen, dass die Vorteile von LLMs weit verbreitet sind.

Olmoinitiiert vom Allen Institute for AI (AI2), warfare an der Spitze dieser Bewegung. Mit der Veröffentlichung von OLMO 2 haben sie ihr Engagement für die Öffnung der Wissenschaft festgenommen, indem sie nicht nur die Modellgewichte, sondern auch die Schulungsdaten, Code, Rezepte, Zwischenkontrollpunkte und Anweisungsmodelle bereitstellen. Diese umfassende Veröffentlichung ermöglicht es Forschern und Entwicklern, den Entwicklungsprozess des Modells vollständig zu verstehen und zu reproduzieren und den Weg für weitere Innovationen zu ebnen. Laufen Olmo 2 vor Ort mit Gradio und Langchain

Was ist Olmo 2?

Olmo 2 markiert ein erhebliches Improve des Vorsterbens, dem Olmo-0424. Die neuartige Familie der Parametermodelle 7B und 13B zeigt vergleichbare Leistung oder manchmal besser als ähnlich offene Modelle, während sie mit einer Open-Gewicht-Model wie Lama 3.1 über englische akademische Benchmarks konkurrieren. Dies macht die Leistung angesichts einer verringerten Gesamtmenge an Trainingsflops in Bezug auf einige ähnliche Modelle sehr bemerkenswert.

• OLMO-2 zeigt eine signifikante Verbesserung: Die Olmo-2-Modelle (sowohl 7B- als auch 13B-Parameterversionen) zeigen einen klaren Leistungssprung im Vergleich zu den früheren Olmo-Modellen (OLMO-7B, OLMO-7B-0424, OLMOE-1B-7B-0924). Dies deutet auf erhebliche Fortschritte in der Architektur, Schulungsdaten oder Schulungsmethoden des Modells hin.
• Wettbewerbsfähig mit Map-Neo-7b: Die Olmo-2-Modelle, insbesondere die 13B-Model, erzielen mit MAP-Neo-7B vergleichbar, was wahrscheinlich eine stärkere Grundlinie unter den aufgeführten vollständig geöffneten Modellen warfare.

Brechen Sie den Trainingsprozess von Olmo 2 ab

Die Architektur von Olmo 2 baut auf der Grundlage des ursprünglichen Olmo auf und enthält mehrere wichtige Änderungen, um die Trainingsstabilität und -leistung zu verbessern.

Der Vorbereitungsverfahren für OLMO 2 ist in zwei Stufen unterteilt:

• Stufe 1: Basis-Coaching: In dieser Part wird der Dataset Olmo-Combine-1124 verwendet, eine huge Sammlung von ungefähr 3,9 Billionen Tokens aus verschiedenen offenen Datensätzen. Diese Part konzentriert sich auf den Aufbau einer starken Grundlage für die Funktionen des Sprachverständnisses des Modells.
• Stufe 2: Verfeinerung und Spezialisierung: In dieser Part wird der Datensatz von Dolmino-Combine-1124 verwendet, eine kuratierte Mischung aus hochwertigen Webdaten und domänenspezifischen Daten, einschließlich akademischer Inhalte, Q & A-Foren, Anweisungsdaten und Mathematik-Arbeitsmappen. Diese Part verfeinert das Wissen und die Fähigkeiten des Modells in bestimmten Bereichen. Die Verwendung von „Modellsuppen“ zum Kombinieren mehrerer geschulter Modelle verbessert den endgültigen Kontrollpunkt weiter.

Da OLMO-2 ein vollständig geöffnetes Modell ist, sehen wir uns an, was der Unterschied zwischen offenen Gewichtsmodellen, teilweise offenen Modellen und vollständig geöffneten Modellen ist:

Modelle mit offenem Gewicht

LLAMA-2-13B, MISTRAL-7B-V0.3, LAMA-3.1-8B, MISTRAL-TRAL-NEMO-12B, QWEN-2.5-7B, GEMMA-2-9B, QWEN-2.5-14B: Diese Modelle haben ein Schlüsselmerkmal: Ihre Gewichte sind öffentlich verfügbar. Auf diese Weise können Entwickler sie für verschiedene NLP -Aufgaben verwenden. Kritische Particulars zu ihrem Schulungsprozess, wie der genauen Datensatzzusammensetzung, dem Trainingscode und den Hyperparametern, werden jedoch nicht vollständig offengelegt. Dies macht sie zu „offenem Gewicht“, aber nicht vollständig clear.

Teilweise offene Modelle

Stablelm-2-128, Zamba-2-7b: Diese Modelle fallen in eine Grauzone. Sie bieten einige zusätzliche Informationen, die über die Gewichte hinausgehen, aber nicht das vollständige Bild. Stablelm-2-128 listet beispielsweise Trainingsflops auf, was auf mehr Transparenz als rein offene Modelle hinweist. Das Fehlen vollständiger Trainingsdaten und Code stellt sie jedoch in die Kategorie „teilweise offen“ ein.

Voll offene Modelle

Amber-7b, Olmo-7b, Map-Neo-7b, Olmo-0424-7b, DCLM-7b, Olmo-2-1124-7b, Olmo-2-1124-13b: Diese Modelle sind aufgrund ihrer umfassenden Offenheit hervorgehoben. AI2 (Allen Institute for AI), die Organisation hinter der Olmo -Serie, hat alles veröffentlicht, was für die vollständige Transparenz und Reproduzierbarkeit erforderlich ist: Gewichte, Trainingsdaten (oder detaillierte Beschreibungen davon), Trainingscode, das vollständige Coaching „Rezept“ (einschließlich Hyperparameter) , Intermediate Checkpoints und Anleitungsversionen. Dies ermöglicht es Forschern, diese Modelle tief zu analysieren, ihre Stärken und Schwächen zu verstehen und auf ihnen aufzubauen.

Schlüsselunterschiede

Erforschen Sie Olmo 2

OLMO 2 ist ein fortschrittliches Open-Supply-Sprachmodell für effiziente und leistungsstarke KI-gesteuerte Gespräche. Es integriert sich nahtlos in Frameworks wie Langchain, sodass Entwickler intelligente Chatbots und AI -Anwendungen erstellen können. Erforschen Sie seine Fähigkeiten, Architektur und die Verständnis der natürlichen Sprache in verschiedenen Anwendungsfällen.

• Holen Sie sich das Modell und die Daten: Herunterladen Hier
• Trainingscode: Sicht
• Auswertung: Sicht

Lassen Sie es uns lokal laufen lassen

Obtain Ollama Hier.

So herunterladen OLMO-2 Open CMD und Typ

ollama run olmo2:7b

Dadurch wird OLMO2 in Ihr System heruntergeladen

Bibliotheken installieren

pip set up langchain-ollama
pip set up gradio

Erstellen eines Chatbots mit Olmo 2

Nutzen Sie die Leistung von OLMO 2, um einen intelligenten Chatbot mit Open-Gewicht-LLM-Funktionen aufzubauen. Erfahren Sie, wie Sie es in Python, Gradio und Langchain integrieren können, um nahtlose Interaktionen zu erhalten.

Schritt 1: Importieren der erforderlichen Bibliotheken

Laden Sie essentielle Bibliotheken, einschließlich Gradio für UI, Langchain für die schnelle Handhabung und Ollamallm zur Nutzung des Olmo 2 -Modells in Chatbot -Antworten.

import gradio as gr
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama.llms import OllamaLLM

Schritt 2: Definieren der Reaktionsgenerierungsfunktion

Erstellen Sie eine Funktion, die den Chat-Verlauf und die Benutzereingabe nimmt, die Eingabeaufforderung format, das OLMO 2-Modell aufruft und den Gesprächsverlauf mit AI-generierten Antworten aktualisiert.

def generate_response(historical past, query):
    template = """Query: {query}

    Reply: Let's suppose step-by-step."""
    immediate = ChatPromptTemplate.from_template(template)
    mannequin = OllamaLLM(mannequin="olmo2")
    chain = immediate | mannequin
    reply = chain.invoke({"query": query})
    historical past.append({"function": "consumer", "content material": query})
    historical past.append({"function": "assistant", "content material": reply})
    return historical past

Die Funktion generate_response nimmt einen Chat -Verlauf und eine Benutzerfrage als Eingabe an. Es definiert eine schnelle Vorlage, bei der die Frage dynamisch eingefügt wird, wobei die KI schrittweise nachdenkt. Die Funktion erstellt dann eine ChatpromptTemplate und initialisiert das Ollamallm -Modell (OLMO2). Mit Langchains Pipeline (Eingabeaufforderung | Modell) generiert es eine Antwort, indem das Modell mit der angegebenen Frage aufgerufen wird. Der Gesprächsverlauf wird aktualisiert und erhält die Frage des Benutzers und die Antwort der KI. Es gibt die aktualisierte Geschichte für weitere Interaktionen zurück.

Schritt 3: Erstellen der Gradio -Schnittstelle

Verwenden Sie Gradio BlocksAnwesend ChatbotUnd Textbox Komponenten zum Entwerfen einer interaktiven Chat -Oberfläche, mit der Benutzer Fragen eingeben und Antworten dynamisch empfangen können.

with gr.Blocks() as iface:
    chatbot = gr.Chatbot(sort="messages")
    with gr.Row():
        with gr.Column():
            txt = gr.Textbox(show_label=False, placeholder="Kind your query right here...")
    txt.submit(generate_response, (chatbot, txt), chatbot)

• Verwendet gr.chatbot () zum Anzeigen von Gesprächen.
• Verwendet Gr.TextBox () für die Benutzereingabe.

Schritt 4: Starten der Anwendung

Führen Sie die Gradio -App mit iface.launch()Bereitstellung des Chatbot als webbasierte Schnittstelle für Echtzeit-Interaktionen.

iface.launch()

Dadurch startet die Gradio -Schnittstelle und führt den Chatbot als Internet -App aus.

Holen Sie sich Code von GitHub Hier.

Ausgabe

Immediate

Schreiben Sie eine Python -Funktion, die true zurückgibt, wenn eine bestimmte Zahl eine Leistung von 2 ist, ohne Schleifen oder Rekursion zu verwenden.

Antwort

Abschluss

Daher ist OLMO-2 als einer der größten Beiträge zum Open-Supply LLM-Ökosystem heraus. Es ist einer der mächtigsten Performer in der Enviornment der vollständigen Transparenz mit Schwerpunkt auf Trainingseffizienz. Es spiegelt die wachsende Bedeutung einer offenen Zusammenarbeit in der Welt der KI wider und wird den Weg für zukünftige Fortschritte in zugänglichen und transparenten Sprachmodellen ebnen.

Während Olmo-2-138 ein sehr starkes Modell ist, dominiert es bei allen Aufgaben nicht deutlich. Einige teilweise geöffnete Modelle und QWEN-2.5-14B erhalten beispielsweise höhere Ergebnisse für einige Benchmarks (z. B. QWEN-2.5-14B übertrifft signifikant bei Arc/C und WinOG). Außerdem bleibt OLMO-2 bei bestimmten herausfordernden Aufgaben wie GSM8K (Mathematik der Grundschule) und wahrscheinlich agieval ein deutlich hinter den besten Modellen hinter den besten Modellen.

Im Gegensatz zu vielen anderen LLMs ist OLMO-2 vollständig geöffnet und bietet nicht nur die Modellgewichte, sondern auch die Trainingsdaten, Code, Rezepte und Zwischenkontrollpunkte. Dieses Transparenzniveau ist entscheidend für die Forschung, Reproduzierbarkeit und gemeindenahe Entwicklung. Es ermöglicht den Forschern, die Stärken, Schwächen und möglichen Verzerrungen des Modells gründlich zu verstehen.

Schlüssel zum Mitnehmen

• Die OLMO-2-Modelle, insbesondere die 13B-Parameterversion, zeigen großartige Leistungsergebnisse bei einer Vielzahl von Benchmarks und schlagen andere offene und sogar teilweise offene Architekturen. Es scheint, dass die volle Offenheit in der Tat eine der Möglichkeiten ist, leistungsfähige LLMs zu machen.
• Die vollständig offenen Modelle (insbesondere OLMO) leisten in der Regel intestine. Dies unterstützt das Argument, dass der Zugriff auf den vollständigen Trainingsprozess (Daten, Code usw.) die Entwicklung effektiverer Modelle erleichtert.
• Der Chatbot behält den Gesprächsgeschichte bei und stellt sicher, dass Antworten frühere Interaktionen berücksichtigen.
• Die ereignisbasierte UI (TXT.Submit) von Gradio in Echtzeit aktualisiert die Chatbot reaktionsschnell und benutzerfreundlich.
• Ollamallm integriert KI-Modelle in die Pipeline und ermöglicht eine nahtlose Frage-Beantwortungsfunktionalität.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.