def create_marker_cluster_map():
   """Create a map with marker clustering for giant datasets"""
   np.random.seed(123)
   n_locations = 5000
  
   lats = np.random.uniform(25, 49, n_locations)
   lons = np.random.uniform(-125, -65, n_locations)
   values = np.random.randint(1, 100, n_locations)
  
   df_markers = pd.DataFrame({
       'lat': lats,
       'lon': lons,
       'worth': values
   })
  
   m = folium.Map(location=(37.8, -96), zoom_start=4)
  
   marker_cluster = MarkerCluster(
       identify="Location Cluster",
       overlay=True,
       management=True
   ).add_to(m)
  
   for idx, row in df_markers.iterrows():
       if row('worth') < 33:
           shade="inexperienced"
       elif row('worth') < 66:
           shade="orange"
       else:
           shade="purple"
      
       folium.Marker(
           location=(row('lat'), row('lon')),
           popup=f"Worth: {row('worth')}",
           tooltip=f"Location {idx}",
           icon=folium.Icon(shade=shade, icon='info-sign')
       ).add_to(marker_cluster)
  
   folium.LayerControl().add_to(m)
  
   title_html=""'
                <div fashion="place: mounted;
                            high: 10px; left: 50px; width: 350px; top: 60px;
                            background-color: white; border:2px stable gray; z-index:9999;
                            font-size:14px; padding: 10px">
                <h4 fashion="margin: 0;">Marker Clustering Demo</h4>
                <p fashion="margin: 5px 0 0 0; font-size: 12px;">5000 markers - zoom to see particular person factors</p>
                </div>
                '''
   m.get_root().html.add_child(folium.Component(title_html))
  
   return m


def create_time_series_map():
   """Create an animated map displaying knowledge adjustments over time"""
   start_date = datetime(2024, 8, 1)
   options = ()
  
   path = (
       (25.0, -70.0), (26.5, -72.0), (28.0, -74.5), (29.5, -76.5),
       (31.0, -78.0), (32.5, -79.5), (34.0, -80.5), (35.5, -81.0)
   )
  
   for i, (lat, lon) in enumerate(path):
       timestamp = start_date + timedelta(hours=i*6)
      
       function = {
           'sort': 'Function',
           'geometry': {
               'sort': 'Level',
               'coordinates': (lon, lat)
           },
           'properties': {
               'time': timestamp.isoformat(),
               'popup': f'Hurricane Place<br>Time: {timestamp.strftime("%Y-%m-%d %H:%M")}<br>Class: {min(5, i//2 + 1)}',
               'icon': 'circle',
               'iconstyle': {
                   'fillColor': ('yellow', 'orange', 'purple', 'darkred', 'purple')(min(4, i//2)),
                   'fillOpacity': 0.8,
                   'stroke': 'true',
                   'radius': 8 + i * 2
               }
           }
       }
       options.append(function)
  
   m = folium.Map(
       location=(30.0, -75.0),
       zoom_start=5,
       tiles="CartoDB Positron"
   )
  
   TimestampedGeoJson(
       {'sort': 'FeatureCollection', 'options': options},
       interval='PT6H',
       add_last_point=True,
       auto_play=True,
       loop=True,
       max_speed=2,
       loop_button=True,
       date_options="YYYY-MM-DD HH:mm",
       time_slider_drag_update=True
   ).add_to(m)
  
   title_html=""'
                <div fashion="place: mounted;
                            high: 10px; left: 50px; width: 300px; top: 80px;
                            background-color: white; border:2px stable gray; z-index:9999;
                            font-size:14px; padding: 10px">
                <h4 fashion="margin: 0;">Hurricane Path Animation</h4>
                <p fashion="margin: 5px 0 0 0; font-size: 12px;">Simulated hurricane monitoring<br>
                Use controls under to play/pause</p>
                </div>
                '''
   m.get_root().html.add_child(folium.Component(title_html))
  
   return m


def create_interactive_plugins_map():
   """Create a map with a number of interactive plugins"""
   m = folium.Map(
       location=(40.7128, -74.0060),
       zoom_start=12,
       tiles="OpenStreetMap"
   )
  
   minimap = MiniMap(toggle_display=True)
   m.add_child(minimap)
  
   draw = Draw(
       export=True,
       filename="drawn_shapes.geojson",
       place='topleft',
       draw_options={
           'polyline': True,
           'polygon': True,
           'circle': True,
           'rectangle': True,
           'marker': True,
           'circlemarker': True
       },
       edit_options={'edit': True}
   )
   m.add_child(draw)
  
   Fullscreen(
       place='topright',
       title="Develop map",
       title_cancel="Exit fullscreen",
       force_separate_button=True
   ).add_to(m)
  
   plugins.MeasureControl(
       place='bottomleft',
       primary_length_unit="kilometers",
       secondary_length_unit="miles",
       primary_area_unit="sqkilometers",
       secondary_area_unit="acres"
   ).add_to(m)
  
   plugins.MousePosition(
       place='bottomright',
       separator=" | ",
       empty_string='NaN',
       lng_first=True,
       num_digits=20,
       prefix='Coordinates:',
   ).add_to(m)
  
   plugins.LocateControl(
       auto_start=False,
       place='topleft'
   ).add_to(m)
  
   folium.Marker(
       (40.7128, -74.0060),
       popup='<b>NYC</b><br>Strive the drawing instruments!',
       icon=folium.Icon(shade="purple", icon='info-sign')
   ).add_to(m)
  
   return m


def create_earthquake_map():
   """Create complete earthquake visualization utilizing actual USGS knowledge"""
   url="https://earthquake.usgs.gov/earthquakes/feed/v1.0/abstract/2.5_month.geojson"
  
   strive:
       response = requests.get(url)
       earthquake_data = response.json()
       print(f"Efficiently loaded {len(earthquake_data('options'))} earthquakes")
   besides Exception as e:
       print(f"Error fetching knowledge: {e}")
       earthquake_data = {
           'options': (
               {
                   'properties': {'magazine': 5.2, 'place': 'Pattern Location 1', 'time': 1640000000000},
                   'geometry': {'coordinates': (-122.0, 37.0, 10)}
               },
               {
                   'properties': {'magazine': 6.1, 'place': 'Pattern Location 2', 'time': 1640100000000},
                   'geometry': {'coordinates': (140.0, 35.0, 20)}
               }
           )
       }
  
   earthquakes = ()
   for function in earthquake_data('options'):
       props = function('properties')
       coords = function('geometry')('coordinates')
      
       earthquakes.append({
           'lat': coords(1),
           'lon': coords(0),
           'depth': coords(2),
           'magnitude': props.get('magazine', 0),
           'place': props.get('place', 'Unknown'),
           'time': datetime.fromtimestamp(props.get('time', 0) / 1000)
       })
  
   df_eq = pd.DataFrame(earthquakes)
  
   print(f"nEarthquake Statistics:")
   print(f"Whole earthquakes: {len(df_eq)}")
   print(f"Magnitude vary: {df_eq('magnitude').min():.1f} - {df_eq('magnitude').max():.1f}")
   print(f"Depth vary: {df_eq('depth').min():.1f} - {df_eq('depth').max():.1f} km")
  
   m = folium.Map(
       location=(20, 0),
       zoom_start=2,
       tiles="CartoDB dark_matter"
   )
  
   minor = folium.FeatureGroup(identify="Minor (< 4.0)")
   average = folium.FeatureGroup(identify="Reasonable (4.0-5.0)")
   robust = folium.FeatureGroup(identify="Sturdy (5.0-6.0)")
   main = folium.FeatureGroup(identify="Main (≥ 6.0)")
  
   for idx, eq in df_eq.iterrows():
       magazine = eq('magnitude')
      
       if magazine < 4.0:
           shade="inexperienced"
           radius = 3
           group = minor
       elif magazine < 5.0:
           shade="yellow"
           radius = 6
           group = average
       elif magazine < 6.0:
           shade="orange"
           radius = 9
           group = robust
       else:
           shade="purple"
           radius = 12
           group = main
      
       popup_html = f"""
       <div fashion="font-family: Arial; width: 250px;">
           <h4 fashion="margin: 0; shade: {shade};">Magnitude {magazine:.1f}</h4>
           <hr fashion="margin: 5px 0;">
           <p><b>Location:</b> {eq('place')}</p>
           <p><b>Depth:</b> {eq('depth'):.1f} km</p>
           <p><b>Time:</b> {eq('time').strftime('%Y-%m-%d %H:%M:%S')}</p>
           <p><b>Coordinates:</b> {eq('lat'):.4f}, {eq('lon'):.4f}</p>
       </div>
       """
      
       folium.CircleMarker(
           location=(eq('lat'), eq('lon')),
           radius=radius,
           popup=folium.Popup(popup_html, max_width=270),
           tooltip=f"M{magazine:.1f} - {eq('place')}",
           shade=shade,
           fill=True,
           fillColor=shade,
           fillOpacity=0.7,
           weight=2
       ).add_to(group)
  
   minor.add_to(m)
   average.add_to(m)
   robust.add_to(m)
   main.add_to(m)
  
   heat_data = ((row('lat'), row('lon'), row('magnitude')) for idx, row in df_eq.iterrows())
   heatmap = folium.FeatureGroup(identify="Density Heatmap", present=False)
   HeatMap(
       heat_data,
       min_opacity=0.3,
       radius=15,
       blur=20,
       gradient={0.4: 'blue', 0.6: 'cyan', 0.7: 'lime', 0.8: 'yellow', 1: 'purple'}
   ).add_to(heatmap)
   heatmap.add_to(m)
  
   folium.LayerControl(place='topright', collapsed=False).add_to(m)
  
   legend_html=""'
   <div fashion="place: mounted;
               backside: 50px; proper: 50px; width: 200px; top: 180px;
               background-color: white; border:2px stable gray; z-index:9999;
               font-size:14px; padding: 10px; border-radius: 5px;">
       <h4 fashion="margin: 0 0 10px 0;">Earthquake Magnitude</h4>
       <p fashion="margin: 5px 0;"><span fashion="shade: inexperienced;">●</span> Minor (< 4.0)</p>
       <p fashion="margin: 5px 0;"><span fashion="shade: yellow;">●</span> Reasonable (4.0-5.0)</p>
       <p fashion="margin: 5px 0;"><span fashion="shade: orange;">●</span> Sturdy (5.0-6.0)</p>
       <p fashion="margin: 5px 0;"><span fashion="shade: purple;">●</span> Main (≥ 6.0)</p>
       <hr fashion="margin: 10px 0;">
       <p fashion="margin: 5px 0; font-size: 11px;">Information: USGS (Previous 30 days)</p>
   </div>
   '''
   m.get_root().html.add_child(folium.Component(legend_html))
  
   title_html=""'
   <div fashion="place: mounted;
               high: 10px; left: 50px; width: 400px; top: 80px;
               background-color: rgba(255, 255, 255, 0.95); border:2px stable gray; z-index:9999;
               font-size:14px; padding: 10px; border-radius: 5px;">
       <h3 fashion="margin: 0;"> World Earthquake Monitor</h3>
       <p fashion="margin: 5px 0 0 0; font-size: 12px;">
           Actual-time earthquake knowledge (M ≥ 2.5)<br>
           Click on markers for particulars | Toggle layers to discover
       </p>
   </div>
   '''
   m.get_root().html.add_child(folium.Component(title_html))
  
   Fullscreen(place='topright').add_to(m)
  
   return m


if __name__ == "__main__":
   print("=" * 80)
   print("ADVANCED FOLIUM TUTORIAL - ALL EXAMPLES")
   print("=" * 80)
   print("nGenerating all maps...n")
  
   maps = {
       'multi_tile_map': create_multi_tile_map(),
       'advanced_markers_map': create_advanced_markers_map(),
       'heatmap': create_heatmap(),
       'choropleth_map': create_choropleth_map(),
       'marker_cluster_map': create_marker_cluster_map(),
       'time_series_map': create_time_series_map(),
       'interactive_plugins_map': create_interactive_plugins_map(),
       'earthquake_map': create_earthquake_map()
   }
  
   print("n" + "=" * 80)
   print("SAVING MAPS TO HTML FILES")
   print("=" * 80)
  
   for identify, map_obj in maps.objects():
       if map_obj just isn't None:
           filename = f"{identify}.html"
           map_obj.save(filename)
           print(f"✓ Saved: {filename}")
       else:
           print(f"✗ Skipped: {identify} (map technology failed)")
  
   print("n" + "=" * 80)
   print("ALL MAPS GENERATED SUCCESSFULLY!")
   print("=" * 80)
   print("nYou can now:")
   print("1. Open any HTML file in your browser to view the interactive map")
   print("2. Entry the map objects in code utilizing the 'maps' dictionary")
   print("3. Show maps in Jupyter/Colab by returning the map object")
   print("nExample: To show the earthquake map in a pocket book, simply run:")
   print("  maps('earthquake_map')")
   print("n" + "=" * 80)

In diesem Tutorial zeigen wir, wie man über statische, codelastige Diagramme hinausgeht und direkt mit ihnen einen wirklich interaktiven Workflow für die explorative Datenanalyse erstellt PyGWalker. Wir beginnen mit der Vorbereitung des Titanic-Datensatzes für umfangreiche interaktive Abfragen. Diese analysebereiten technischen Funktionen offenbaren die zugrunde liegende Struktur der Daten und ermöglichen gleichzeitig sowohl eine detaillierte Untersuchung auf Zeilenebene als auch aggregierte Ansichten auf hoher Ebene für tiefere Einblicke. Die Einbettung einer Drag-and-Drop-Schnittstelle im Tableau-Stil direkt in das Pocket book ermöglicht schnelle Hypothesentests, intuitive Kohortenvergleiche und eine effiziente Datenqualitätsprüfung, und das alles ohne die Reibung, die durch den Wechsel zwischen Code- und Visualisierungstools entsteht.

import sys, subprocess, json, math, os
from pathlib import Path


def pip_install(pkgs):
   subprocess.check_call((sys.executable, "-m", "pip", "set up", "-q") + pkgs)


pip_install((
   "pygwalker>=0.4.9",
   "duckdb>=0.10.0",
   "pandas>=2.0.0",
   "numpy>=1.24.0",
   "seaborn>=0.13.0"
))


import numpy as np
import pandas as pd
import seaborn as sns


df_raw = sns.load_dataset("titanic").copy()
print("Uncooked form:", df_raw.form)
show(df_raw.head(3))

Wir richten eine saubere und reproduzierbare Colab-Umgebung ein, indem wir alle erforderlichen Abhängigkeiten für interaktives EDA installieren. Wir laden den Titanic-Datensatz und führen eine erste Plausibilitätsprüfung durch, um seine Rohstruktur und seinen Umfang zu verstehen. Es schafft eine stabile Grundlage, bevor eine Transformation oder Visualisierung beginnt.

def make_safe_bucket(collection, bins=None, labels=None, q=None, prefix="bucket"):
   s = pd.to_numeric(collection, errors="coerce")
   if q will not be None:
       attempt:
           cuts = pd.qcut(s, q=q, duplicates="drop")
           return cuts.astype("string").fillna("Unknown")
       besides Exception:
           cross
   if bins will not be None:
       cuts = pd.reduce(s, bins=bins, labels=labels, include_lowest=True)
       return cuts.astype("string").fillna("Unknown")
   return s.astype("float64")


def preprocess_titanic_advanced(df):
   out = df.copy()
   out.columns = (c.strip().decrease().change(" ", "_") for c in out.columns)


   for c in ("survived", "pclass", "sibsp", "parch"):
       if c in out.columns:
           out(c) = pd.to_numeric(out(c), errors="coerce").fillna(-1).astype("int64")


   if "age" in out.columns:
       out("age") = pd.to_numeric(out("age"), errors="coerce").astype("float64")
       out("age_is_missing") = out("age").isna()
       out("age_bucket") = make_safe_bucket(
           out("age"),
           bins=(0, 12, 18, 30, 45, 60, 120),
           labels=("little one", "teen", "young_adult", "grownup", "mid_age", "senior"),
       )


   if "fare" in out.columns:
       out("fare") = pd.to_numeric(out("fare"), errors="coerce").astype("float64")
       out("fare_is_missing") = out("fare").isna()
       out("log_fare") = np.log1p(out("fare").fillna(0))
       out("fare_bucket") = make_safe_bucket(out("fare"), q=8)


   for c in ("intercourse", "class", "who", "embarked", "alone", "adult_male"):
       if c in out.columns:
           out(c) = out(c).astype("string").fillna("Unknown")


   if "cabin" in out.columns:
       out("deck") = out("cabin").astype("string").str.strip().str(0).fillna("Unknown")
       out("deck_is_missing") = out("cabin").isna()
   else:
       out("deck") = "Unknown"
       out("deck_is_missing") = True


   if "ticket" in out.columns:
       t = out("ticket").astype("string")
       out("ticket_len") = t.str.len().fillna(0).astype("int64")
       out("ticket_has_alpha") = t.str.accommodates(r"(A-Za-z)", regex=True, na=False)
       out("ticket_prefix") = t.str.extract(r"^((A-Za-z./s)+)", broaden=False).fillna("None").str.strip()
       out("ticket_prefix") = out("ticket_prefix").change("", "None").astype("string")


   if "sibsp" in out.columns and "parch" in out.columns:
       out("family_size") = (out("sibsp") + out("parch") + 1).astype("int64")
       out("is_alone") = (out("family_size") == 1)


   if "title" in out.columns:
       title = out("title").astype("string").str.extract(r",s*((^.)+).", broaden=False).fillna("Unknown").str.strip()
       vc = title.value_counts(dropna=False)
       preserve = set(vc(vc >= 15).index.tolist())
       out("title") = title.the place(title.isin(preserve), different="Uncommon").astype("string")
   else:
       out("title") = "Unknown"


   out("phase") = (
       out("intercourse").fillna("Unknown").astype("string")
       + " | "
       + out("class").fillna("Unknown").astype("string")
       + " | "
       + out("age_bucket").fillna("Unknown").astype("string")
   )


   for c in out.columns:
       if out(c).dtype == bool:
           out(c) = out(c).astype("int64")
       if out(c).dtype == "object":
           out(c) = out(c).astype("string")


   return out


df = preprocess_titanic_advanced(df_raw)
print("Prepped form:", df.form)
show(df.head(3))

Wir konzentrieren uns auf fortschrittliche Vorverarbeitung und Characteristic-Engineering, um die Rohdaten in eine analysebereite Kind umzuwandeln. Wir erstellen robuste, DuckDB-sichere Funktionen wie Buckets, Segmente und konstruierte kategoriale Signale, die die nachgelagerte Exploration verbessern. Wir stellen sicher, dass der Datensatz stabil, ausdrucksstark und für interaktive Abfragen geeignet ist.

def data_quality_report(df):
   rows = ()
   n = len(df)
   for c in df.columns:
       s = df(c)
       miss = int(s.isna().sum())
       miss_pct = (miss / n * 100.0) if n else 0.0
       nunique = int(s.nunique(dropna=True))
       dtype = str(s.dtype)
       pattern = s.dropna().head(3).tolist()
       rows.append({
           "col": c,
           "dtype": dtype,
           "lacking": miss,
           "missing_%": spherical(miss_pct, 2),
           "nunique": nunique,
           "sample_values": pattern
       })
   return pd.DataFrame(rows).sort_values(("lacking", "nunique"), ascending=(False, False))


dq = data_quality_report(df)
show(dq.head(20))


RANDOM_SEED = 42
MAX_ROWS_FOR_UI = 200_000


df_for_ui = df
if len(df_for_ui) > MAX_ROWS_FOR_UI:
   df_for_ui = df_for_ui.pattern(MAX_ROWS_FOR_UI, random_state=RANDOM_SEED).reset_index(drop=True)


agg = (
   df.groupby(("phase", "deck", "embarked"), dropna=False)
     .agg(
         n=("survived", "measurement"),
         survival_rate=("survived", "imply"),
         avg_fare=("fare", "imply"),
         avg_age=("age", "imply"),
     )
     .reset_index()
)


for c in ("survival_rate", "avg_fare", "avg_age"):
   agg(c) = agg(c).astype("float64")


Path("/content material").mkdir(mother and father=True, exist_ok=True)
df_for_ui.to_csv("/content material/titanic_prepped_for_ui.csv", index=False)
agg.to_csv("/content material/titanic_agg_segment_deck_embarked.csv", index=False)

Wir bewerten die Datenqualität und erstellen einen strukturierten Überblick über Fehlen, Kardinalität und Datentypen. Wir bereiten sowohl einen Datensatz auf Zeilenebene als auch eine aggregierte Tabelle auf Kohortenebene vor, um eine schnelle Vergleichsanalyse zu unterstützen. Die duale Darstellung ermöglicht es uns, gleichzeitig detaillierte Muster und übergeordnete Traits zu untersuchen.

import pygwalker as pyg


SPEC_PATH = Path("/content material/pygwalker_spec_titanic.json")


def load_spec(path):
   if path.exists():
       attempt:
           return json.hundreds(path.read_text())
       besides Exception:
           return None
   return None


def save_spec(path, spec_obj):
   attempt:
       if isinstance(spec_obj, str):
           spec_obj = json.hundreds(spec_obj)
       path.write_text(json.dumps(spec_obj, indent=2))
       return True
   besides Exception:
       return False


def launch_pygwalker(df, spec_path):
   spec = load_spec(spec_path)
   kwargs = {}
   if spec will not be None:
       kwargs("spec") = spec


   attempt:
       walker = pyg.stroll(df, use_kernel_calc=True, **kwargs)
   besides TypeError:
       walker = pyg.stroll(df, **kwargs) if spec will not be None else pyg.stroll(df)


   captured = None
   for attr in ("spec", "_spec"):
       if hasattr(walker, attr):
           attempt:
               captured = getattr(walker, attr)
               break
           besides Exception:
               cross
   for meth in ("to_spec", "export_spec", "get_spec"):
       if captured is None and hasattr(walker, meth):
           attempt:
               captured = getattr(walker, meth)()
               break
           besides Exception:
               cross


   if captured will not be None:
       save_spec(spec_path, captured)


   return walker


walker_rows = launch_pygwalker(df_for_ui, SPEC_PATH)
walker_agg = pyg.stroll(agg)

Wir integrieren PyGWalker, um unsere vorbereiteten Tabellen in eine vollständig interaktive Drag-and-Drop-Analyseschnittstelle umzuwandeln. Wir behalten die Visualisierungsspezifikation bei, sodass Dashboard-Layouts und Codierungen auch Pocket book-Wiederholungen überdauern. Es verwandelt das Pocket book in eine wiederverwendbare Erkundungsumgebung im BI-Stil.

HTML_PATH = Path("/content material/pygwalker_titanic_dashboard.html")


def export_html_best_effort(df, spec_path, out_path):
   spec = load_spec(spec_path)
   html = None


   attempt:
       html = pyg.stroll(df, spec=spec, return_html=True) if spec will not be None else pyg.stroll(df, return_html=True)
   besides Exception:
       html = None


   if html is None:
       for fn in ("to_html", "export_html"):
           if hasattr(pyg, fn):
               attempt:
                   f = getattr(pyg, fn)
                   html = f(df, spec=spec) if spec will not be None else f(df)
                   break
               besides Exception:
                   proceed


   if html is None:
       return None


   if not isinstance(html, str):
       html = str(html)


   out_path.write_text(html, encoding="utf-8")
   return out_path


export_html_best_effort(df_for_ui, SPEC_PATH, HTML_PATH)

Wir erweitern den Workflow, indem wir das interaktive Dashboard als eigenständiges HTML-Artefakt exportieren. Wir stellen sicher, dass die Analyse geteilt oder überprüft werden kann, ohne dass eine Python-Umgebung oder eine Colab-Sitzung erforderlich ist. Es vervollständigt die Pipeline von Rohdaten bis hin zu verteilbaren, interaktiven Erkenntnissen.

Zusammenfassend haben wir ein robustes Muster für fortgeschrittene EDA erstellt, das weit über den Titanic-Datensatz hinaus skaliert und gleichzeitig vollständig Pocket book-nativ bleibt. Wir haben gezeigt, wie sorgfältige Vorverarbeitung, Typsicherheit und Characteristic-Design es PyGWalker ermöglichen, zuverlässig mit komplexen Daten zu arbeiten, und wie die Kombination detaillierter Datensätze mit aggregierten Zusammenfassungen leistungsstarke analytische Arbeitsabläufe ermöglicht. Anstatt die Visualisierung als nachträglichen Gedanken zu behandeln, nutzten wir sie als erstklassige interaktive Ebene, die es uns ermöglichte, Annahmen zu iterieren, zu validieren und Erkenntnisse in Echtzeit zu gewinnen.

Schauen Sie sich das an Vollständige Codes hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

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.

Harsh Mishra ist ein KI/ML -Ingenieur, der mehr Zeit damit verbringt, mit großen Sprachmodellen zu sprechen als mit tatsächlichen Menschen. Leidenschaft über Genai, NLP und Maschinen schlauer (damit sie ihn noch nicht ersetzen). Wenn er Fashions nicht optimiert, optimiert er wahrscheinlich seine Kaffeeaufnahme.

Wenn Sie den Workflow vom Terminal aus starten, können Sie problemlos erkennen, welcher Schritt ausgeführt wird und welche Protokollierung wir in diese Schritte eingefügt haben.

Wir können die Human-in-the-Loop-Interaktion auch ermöglichen, indem wir einfach user_feedback = enter()im Workflow. Dadurch wird der Workflow angehalten und auf die Benutzereingabe gewartet (siehe das Human-in-the-Loop-Beispiel in diesem offiziellen Llamaindex Notizbuch). Um jedoch die gleiche Funktionalität in einer benutzerfreundlichen Oberfläche erreichen zu können, sind zusätzliche Änderungen am ursprünglichen Workflow erforderlich.

Die Ausführung eines Workflows kann lange dauern. Um die Benutzerfreundlichkeit zu verbessern, hat Llamaindex eine Möglichkeit bereitgestellt, Streaming-Ereignisse zu senden, um den Fortschritt des Workflows anzuzeigen, wie im Pocket book angezeigt. HierIn meinem Workflow definiere ich einen WorkflowStreamingEvent Klasse, um nützliche Informationen zur Ereignisnachricht einzuschließen, z. B. den Typ des Ereignisses und von welchem ​​Schritt es gesendet wird:

class WorkflowStreamingEvent(BaseModel):
event_type: Literal("server_message", "request_user_input") = Discipline(
..., description="Kind of the occasion"
)
event_sender: str = Discipline(
..., description="Sender (workflow step identify) of the occasion"
)
event_content: Dict(str, Any) = Discipline(..., description="Content material of the occasion")

Um das Senden von Streaming-Ereignissen zu ermöglichen, muss der Workflow-Schritt Zugriff auf den freigegebenen Kontext haben. Dies geschieht durch Hinzufügen @step(pass_context=True) Dekorator zur Schrittdefinition. Dann können wir in der Schrittdefinition Ereignismeldungen über den Fortschritt durch den Kontext senden. Zum Beispiel in der tavily_query() Schritt:

@step(pass_context=True)
async def tavily_query(self, ctx: Context, ev: StartEvent) -> TavilyResultsEvent:
ctx.information("research_topic") = ev.user_query
question = f"arxiv papers in regards to the state-of-the-art of {ev.user_query}"
ctx.write_event_to_stream(
Occasion(
msg=WorkflowStreamingEvent(
event_type="server_message",
event_sender=examine.currentframe().f_code.co_name,
event_content={"message": f"Querying Tavily with: '{question}'"},
).model_dump()
)
)

In diesem Beispiel setzen wir die event_type zu sein “server_message” . Das bedeutet, dass es sich um eine Replace-Nachricht handelt und keine Benutzeraktion erforderlich ist. Wir haben einen anderen Ereignistyp "request_user_input" das darauf hinweist, dass eine Benutzereingabe erforderlich ist. Beispielsweise in der gather_feedback_outline() Schritt im Workflow: Nach dem Generieren der Folientextgliederung aus der ursprünglichen Papierzusammenfassung wird eine Nachricht gesendet, in der der Benutzer aufgefordert wird, dem Gliederungstext seine Zustimmung zu erteilen und Suggestions dazu abzugeben:

@step(pass_context=True)
async def gather_feedback_outline(
self, ctx: Context, ev: OutlineEvent
) -> OutlineFeedbackEvent | OutlineOkEvent:
"""Current person the unique paper abstract and the outlines generated, collect suggestions from person"""
...
# Ship a particular occasion indicating that person enter is required
ctx.write_event_to_stream(
Occasion(
msg=json.dumps(
{
"event_type": "request_user_input",
"event_sender": examine.currentframe().f_code.co_name,
"event_content": {
"abstract": ev.abstract,
"define": ev.define.dict(),
"message": "Do you approve this define? If not, please present suggestions.",
},
}
)
)
)
...

Diese Ereignisse werden in der Backend-API und der Frontend-Logik unterschiedlich behandelt, was ich in den späteren Abschnitten dieses Artikels ausführlich beschreiben werde.

Beim Senden einer "request_user_input" Ereignis an den Benutzer, wir wollen nur mit dem nächsten Schritt fortfahren nach wir haben die Benutzereingabe erhalten. Wie im Workflow-Diagramm oben gezeigt, geht es entweder zum outlines_with_layout()Schritt, wenn der Benutzer die Gliederung genehmigt, oder an den summary2outline() wiederholen Sie den Schritt, wenn der Benutzer nicht zustimmt.

Dies wird erreicht durch die Future() Objekt aus Pythons asyncio Bibliothek. In der SlideGenerationWorkflow Klasse setzen wir ein Attribut self.user_input_future = asyncio.Future() das kann man erwarten in der gather_feedback_outline() Schritt. Die anschließende Ausführung des Workflows hängt vom Inhalt des Benutzerfeedbacks ab:

@step(pass_context=True)
async def gather_feedback_outline(
self, ctx: Context, ev: OutlineEvent
) -> OutlineFeedbackEvent | OutlineOkEvent:
...
# Anticipate person enter
if not self.user_input_future.accomplished():
user_response = await self.user_input_future
logger.information(f"gather_feedback_outline: Acquired person response: {user_response}")
# Course of user_response, which must be a JSON string
attempt:
response_data = json.masses(user_response)
approval = response_data.get("approval", "").decrease().strip()
suggestions = response_data.get("suggestions", "").strip()
besides json.JSONDecodeError:
# Deal with invalid JSON
logger.error("Invalid person response format")
increase Exception("Invalid person response format")
if approval == ":materials/thumb_up:":
return OutlineOkEvent(abstract=ev.abstract, define=ev.define)
else:
return OutlineFeedbackEvent(
abstract=ev.abstract, define=ev.define, suggestions=suggestions
)

Wir richten das Backend mit fastAPI ein, stellen einen POST-Endpunkt zur Bearbeitung von Anfragen bereit und initiieren den Workflow-Lauf. Die asynchrone Funktion run_workflow_endpoint() dauert ResearchTopic als Eingabe. In der Funktion wird ein asynchroner Generator event_generator() definiert, wodurch eine Aufgabe zum Ausführen des Workflows erstellt wird und die Ereignisse im Verlauf des Workflows an den Consumer gestreamt werden. Wenn der Workflow abgeschlossen ist, werden auch die endgültigen Dateiergebnisse an den Consumer gestreamt.

class ResearchTopic(BaseModel):
question: str = Discipline(..., instance="instance question")
@app.submit("/run-slide-gen")
async def run_workflow_endpoint(matter: ResearchTopic):
workflow_id = str(uuid.uuid4())
wf = SummaryAndSlideGenerationWorkflow(wid=workflow_id, timeout=2000, verbose=True)
wf.add_workflows(
summary_gen_wf=SummaryGenerationWorkflow(
wid=workflow_id, timeout=800, verbose=True
)
)
wf.add_workflows(
slide_gen_wf=SlideGenerationWorkflow(
wid=workflow_id, timeout=1200, verbose=True
)
)
async def event_generator():
loop = asyncio.get_running_loop()
logger.debug(f"event_generator: loop id {id(loop)}")
yield f"{json.dumps({'workflow_id': workflow_id})}nn"
job = asyncio.create_task(wf.run(user_query=matter.question))
logger.debug(f"event_generator: Created job {job}")
attempt:
async for ev in wf.stream_events():
logger.information(f"Sending message to frontend: {ev.msg}")
yield f"{ev.msg}nn"
await asyncio.sleep(0.1)  # Small sleep to make sure correct chunking
final_result = await job
# Assemble the obtain URL
download_pptx_url = f"http://backend:80/download_pptx/{workflow_id}"
download_pdf_url = f"http://backend:80/download_pdf/{workflow_id}"
final_result_with_url = {
"consequence": final_result,
"download_pptx_url": download_pptx_url,
"download_pdf_url": download_pdf_url,
}
yield f"{json.dumps({'final_result': final_result_with_url})}nn"
besides Exception as e:
error_message = f"Error in workflow: {str(e)}"
logger.error(error_message)
yield f"{json.dumps({'occasion': 'error', 'message': error_message})}nn"
lastly:
# Clear up
workflows.pop(workflow_id, None)
return StreamingResponse(event_generator(), media_type="textual content/event-stream")

Zusätzlich zu diesem Endpunkt gibt es Endpunkte zum Empfangen von Benutzereingaben vom Consumer und zum Verarbeiten von Dateidownloadanforderungen. Da jedem Workflow eine eindeutige Workflow-ID zugewiesen ist, können wir die vom Consumer empfangenen Benutzereingaben dem richtigen Workflow zuordnen. Durch Aufrufen des set_result() auf die wartenden Futurekann die Ausführung des ausstehenden Workflows fortgesetzt werden.

@app.submit("/submit_user_input")
async def submit_user_input(information: dict = Physique(...)):
workflow_id = information.get("workflow_id")
user_input = information.get("user_input")
wf = workflows.get(workflow_id)
if wf and wf.user_input_future:
loop = wf.user_input_future.get_loop()  # Get the loop from the long run
logger.information(f"submit_user_input: wf.user_input_future loop id {id(loop)}")
if not wf.user_input_future.accomplished():
loop.call_soon_threadsafe(wf.user_input_future.set_result, user_input)
logger.information("submit_user_input: set_result referred to as")
else:
logger.information("submit_user_input: future already accomplished")
return {"standing": "enter acquired"}
else:
increase HTTPException(
status_code=404, element="Workflow not discovered or future not initialized"
)

Der Obtain-Endpunkt identifiziert anhand der Workflow-ID auch, wo sich die endgültige Datei befindet.

@app.get("/download_pptx/{workflow_id}")
async def download_pptx(workflow_id: str):
file_path = (
Path(settings.WORKFLOW_ARTIFACTS_PATH)
/ "SlideGenerationWorkflow"
/ workflow_id
/ "remaining.pptx"
)
if file_path.exists():
return FileResponse(
path=file_path,
media_type="software/vnd.openxmlformats-officedocument.presentationml.presentation",
filename=f"remaining.pptx",
)
else:
increase HTTPException(status_code=404, element="File not discovered")

Auf der Frontend-Seite, nachdem der Benutzer das Forschungsthema über st.text_input()wird in einem Hintergrund-Thread in einer neuen Ereignisschleife ein lang laufender Prozess gestartet, um die gestreamten Ereignisse vom Backend zu empfangen, ohne den Relaxation der Seite zu beeinträchtigen:

def start_long_running_task(url, payload, message_queue, user_input_event):
attempt:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(
get_stream_data(url, payload, message_queue, user_input_event)
)
loop.shut()
besides Exception as e:
message_queue.put(("error", f"Exception in background thread: {str(e)}"))
...
def principal():
...
with st.sidebar:
with st.kind(key="slide_gen_form"):
question = st.text_input(
"Enter the subject of your analysis:",
)
submit_button = st.form_submit_button(label="Submit")
if submit_button:
# Reset the workflow_complete flag for a brand new workflow
st.session_state.workflow_complete = False
# Begin the long-running job in a separate thread
if (
st.session_state.workflow_thread is None
or not st.session_state.workflow_thread.is_alive()
):
st.write("Beginning the background thread...")
st.session_state.workflow_thread = threading.Thread(
goal=start_long_running_task,
args=(
"http://backend:80/run-slide-gen",
{"question": question},
st.session_state.message_queue,
st.session_state.user_input_event,
),
)
st.session_state.workflow_thread.begin()
st.session_state.received_lines = ()
else:
st.write("Background thread is already working.")

Die vom Backend gestreamten Ereignisdaten werden abgerufen von httpx.AsyncClient und zur weiteren Verarbeitung in eine Nachrichtenwarteschlange gestellt. Abhängig vom Ereignistyp werden unterschiedliche Informationen extrahiert. Für den Ereignistyp “request_user_input”wird der Thread ebenfalls angehalten, bis die Benutzereingabe erfolgt.

async def fetch_streaming_data(url: str, payload: dict = None):
async with httpx.AsyncClient(timeout=1200.0) as shopper:
async with shopper.stream("POST", url=url, json=payload) as response:
async for line in response.aiter_lines():
if line:
yield line
async def get_stream_data(url, payload, message_queue, user_input_event):
# message_queue.put(("message", "Beginning to fetch streaming information..."))
data_json = None
async for information in fetch_streaming_data(url, payload):
if information:
attempt:
data_json = json.masses(information)
if "workflow_id" in data_json:
# Ship workflow_id to principal thread
message_queue.put(("workflow_id", data_json("workflow_id")))
proceed
elif "final_result" in data_json:
# Ship final_result to principal thread
message_queue.put(("final_result", data_json("final_result")))
proceed
event_type = data_json.get("event_type")
event_sender = data_json.get("event_sender")
event_content = data_json.get("event_content")
if event_type in ("request_user_input"):
# Ship the message to the primary thread
message_queue.put(("user_input_required", data_json))
# Wait till person enter is offered
user_input_event.wait()
user_input_event.clear()
proceed
else:
# Ship the road to the primary thread
message_queue.put(("message", format_workflow_info(data_json)))
besides json.JSONDecodeError:  # todo: is that this essential?
message_queue.put(("message", information))
if data_json and "final_result" in data_json or "final_result" in str(information):
break  # Cease processing after receiving the ultimate consequence

Wir speichern die Nachrichten im st.session_state und verwenden Sie eine st.expander() um diese gestreamten Daten anzuzeigen und zu aktualisieren.

if st.session_state.received_lines:
with expander_placeholder.container():
# Create or replace the expander with the most recent truncated line
expander = st.expander(st.session_state.expander_label)
for line in st.session_state.received_lines:
expander.write(line)
expander.divider()

Um sicherzustellen, dass die Benutzeroberfläche reaktionsfähig bleibt und die Ereignismeldungen anzeigt, wenn sie in einem Hintergrundthread verarbeitet werden, verwenden wir eine benutzerdefinierte automatische Aktualisierung Komponente zum Aktualisieren der Seite in festgelegten Intervallen:

if not st.session_state.workflow_complete:
st_autorefresh(interval=2000, restrict=None, key="data_refresh")

Wenn das gestreamte Ereignis vom Typ ist “request_user_input”zeigen wir die zugehörigen Informationen in einem separaten Container an und sammeln Benutzerfeedback. Da es bei einem Workflow-Lauf mehrere Ereignisse geben kann, die Benutzereingaben erfordern, platzieren wir sie in einer Nachrichtenwarteschlange und stellen sicher, dass dem st.suggestions(), st.text_area() Und st.button() die mit jedem Ereignis verknüpft sind, um sicherzustellen, dass die Widgets sich nicht gegenseitig stören:

def gather_outline_feedback(placeholder):
container = placeholder.container()
with container:
if st.session_state.user_input_required:
information = st.session_state.user_input_prompt
event_type = information.get("event_type")
if event_type == "request_user_input":
abstract = information.get("event_content").get("abstract")
define = information.get("event_content").get("define")
prompt_message = information.get("event_content").get(
"message", "Please overview the define."
)
# show the content material for person enter
st.markdown("## Unique Abstract:")
st.text_area("Abstract", abstract, disabled=True, peak=400)
st.divider()
st.markdown("## Generated Slide Define:")
st.json(define)
st.write(prompt_message)
# Outline distinctive keys for widgets
current_prompt = st.session_state.prompt_counter
approval_key = f"approval_state_{current_prompt}"
feedback_key = f"user_feedback_{current_prompt}"
# Show the approval suggestions widget
approval = st.suggestions("thumbs", key=approval_key)
st.write(f"Present Approval state is: {approval}")
logging.information(f"Present Approval state is: {approval}")
# Show the suggestions textual content space
suggestions = st.text_area(
"Please present suggestions you probably have any:", key=feedback_key
)
# Deal with the submission of person response
if st.button(
"Submit Suggestions", key=f"submit_response_{current_prompt}"
):
if not st.session_state.user_response_submitted:
# Retrieve approval and suggestions utilizing distinctive keys
approval_state = st.session_state.get(approval_key)
user_feedback = st.session_state.get(feedback_key, "")
# Guarantee approval_state is legitimate
if approval_state not in (0, 1):
st.error("Please choose an approval possibility.")
return
user_response = {
"approval": (
":materials/thumb_down:"
if approval_state == 0
else ":materials/thumb_up:"
),
"suggestions": user_feedback,
}
# Ship the person's response to the backend
attempt:
response = requests.submit(
"http://backend:80/submit_user_input",
json={
"workflow_id": st.session_state.workflow_id,
"user_input": json.dumps(user_response),
},
)
response.raise_for_status()
logging.information(
f"Backend response for submitting approval: {response.status_code}"
)
besides requests.RequestException as e:
st.error(f"Didn't submit person enter: {str(e)}")
return
...

Am Ende, wenn der Workflow-Lauf abgeschlossen ist, erhält der Frontend-Consumer eine Antwort, die den Pfad zu den endgültig generierten Dateien enthält (dasselbe Foliendeck im PDF-Format zum Rendern in der Benutzeroberfläche und im PPTX-Format zum Herunterladen wie das Endergebnis). Wir zeigen die PDF-Datei an und erstellen eine Schaltfläche zum Herunterladen der PPTX-Datei:

  if "download_url_pdf" in st.session_state and st.session_state.download_url_pdf:
download_url_pdf = st.session_state.download_url_pdf
attempt:
# Fetch the PDF content material
pdf_response = requests.get(download_url_pdf)
pdf_response.raise_for_status()
st.session_state.pdf_data = pdf_response.content material
st.markdown("### Generated Slide Deck:")
# Show the PDF utilizing an iframe
st.markdown(
f'<iframe src="information:software/pdf;base64,{base64.b64encode(st.session_state.pdf_data).decode()}" width="100%" peak="600px" kind="software/pdf"></iframe>',
unsafe_allow_html=True,
)
besides Exception as e:
st.error(f"Didn't load the PDF file: {str(e)}")
# Present the obtain button for PPTX if obtainable
if (
"download_url_pptx" in st.session_state
and st.session_state.download_url_pptx
):
download_url_pptx = st.session_state.download_url_pptx
attempt:
# Fetch the PPTX content material
pptx_response = requests.get(download_url_pptx)
pptx_response.raise_for_status()
pptx_data = pptx_response.content material
st.download_button(
label="Obtain Generated PPTX",
information=pptx_data,
file_name="generated_slides.pptx",
mime="software/vnd.openxmlformats-officedocument.presentationml.presentation",
)
besides Exception as e:
st.error(f"Didn't load the PPTX file: {str(e)}")

Wir erstellen eine Multi-Service-Docker-Anwendung mit docker-compose um die Frontend- und Backend-Apps auszuführen.

model: '3.8'
providers:
backend:
construct:
context: ./backend
args:
- --no-cache
ports:
- "8000:80"
networks:
- app-network
volumes:
- .env:/app/.env
- ./information:/app/information
- ./workflow_artifacts:/app/workflow_artifacts
- ~/.azure:/root/.azure
frontend:
construct:
context: ./frontend
args:
- --no-cache
ports:
- "8501:8501"
networks:
- app-network
networks:
app-network:

Das ist es! Lauf einfach docker-compose upund wir verfügen jetzt über eine App, die einen Forschungsworkflow basierend auf der Eingabeabfrage des Benutzers ausführen, den Benutzer während der Ausführung um Suggestions bitten und dem Benutzer das Endergebnis anzeigen kann.

Synthese har nyligen lanserat en betydande Aktualisierung Dank seiner KI-basierten Videoplattform wird ein großer Schritt in Richtung der Entwicklung KI-generierter Movies gemacht. Denn diese Aktualisierung führt zu vielen neuen Funktionen, die die Teamarbeit erleichtern und die Teilnahme an interaktiven und anregenden Movies erleichtern.

Interaktive KI-Movies und Helkropsavatare

Einer der am häufigsten gestellten Fragen zur Einführung ist, dass Sie mithilfe von Synthesias neuem Video-Spiel interaktive Movies ansehen können. Mithilfe der App können Sie jetzt anklickbare Hotspots in einige Movies integrieren. Sie können diese dann direkt aufrufen, indem Sie auf jedes Ingredient klicken. Dies kann beispielsweise dazu verwendet werden, ein Formular auszufüllen, einen Kalender oder ein Quiz auszufüllen oder durch den Browser zu navigieren, um die genaue Videogröße zu ermitteln. Denn diese Funktion ist nun in vollem Gange und lässt sich innerhalb weniger Tage problemlos bedienen.

Mithilfe interaktiver Movies können Sie Synthesia zu einem interaktiven Avatar machen, der Ihre Hände frei hat und dazu bereit ist, eine Gemeinschaft auf einer interaktiven Plattform zu gründen. Dies ist der Zweck der Kommunikation mit einem neuen Stage, bei dem eine kurze Rede gehalten wird, wodurch es realistischer und effektiver wird und die Zusammenarbeit gefördert wird.

Skapa-Personliga-KI-Avatar

Mit den neuen Updates ist es möglich, auf zwei Arten persönliche KI-Avatare zu erstellen: Sie können zunächst in einem Studio mit einer professionellen Kamera einen Avatar für ein professionelles Variety spielen oder dann Ihre Webcam oder Ihr Telefon verwenden, um einen freigegebenen Avatar zu erstellen. auf einem natürlichen Hintergrund. Auf diese Weise können Sie die Netzwerksynchronisierung und einen natürlicheren Modus aktivieren und Ihre Einstellungen über 30 Sekunden wiederholen.

AI-Skärminspelare und Bulk-Video-Skapande

Synthesia stellt sogar einen KI-Simulator vor, der es ermöglicht, ohne Skepsis zu spielen und anschließend mithilfe der zugrunde liegenden Modelle eine professionelle KI-Videowiedergabe zu ermöglichen. Dies beinhaltet das Zeichnen von Bildern und die Transkription von Bildern, Sie können es auch mit anderen Anwendungen bearbeiten, indem Sie es in Ihren Avatar einfügen und einen automatischen Zoom-Effekt für die konkrete Bearbeitung aktivieren.

Zunächst einmal verfügt es über eine große Textdatenbank mit hilfreichen Informationen, mit denen Sie Synthesia in wenigen Minuten zu einer Video-Großaufnahme mit ihrem AI Video Assistant einführen können. Dies macht es möglich, innerhalb kurzer Zeit hunderte von Artikeln mit hochqualitativen Movies zu füllen, die dem Kunden zugänglich gemacht werden und Ressourcen für das Kundendienstteam des Verfassers sparen.

Synthesias neue Plattform-Help-Marker haben einen wichtigen Rahmen für KI-generierte Movies geschaffen, um interaktive Movies, Hilfsavatare und neue Funktionen für die Erstellung persönlicher Avatare und Massenvideos einzuführen. Diese Funktionen ermöglichen es uns, unsere Zielgruppe zu erreichen und ansprechende und effektive Movies ohne traditionelle Produktionsmethoden zu teilen.

Mehr zu Synthesia

Synthese 2.0

Hilfe zum Einstieg bei Synthesia