import random
from collections import Counter, defaultdict
from datetime import date, timedelta
from prefab_ui.actions import AppendState, OpenLink, PopState, SetState, ShowToast, ToggleState
from prefab_ui.app import PrefabApp
from prefab_ui.parts import (
   Alert, AlertDescription, AlertTitle, Badge, Button, Card, CardContent,
   CardDescription, CardFooter, CardHeader, CardTitle, Code, Column,
   DataTable, DataTableColumn, Kind, Grid, H2, Enter, Markdown, Mermaid,
   Metric, Muted, Progress, Ring, Row, Slider, Small, Swap, Tab, Tabs,
   Textual content
)
from prefab_ui.parts.charts import (
   BarChart, ChartSeries, LineChart, PieChart, RadarChart, ScatterChart,
   Sparkline
)
from prefab_ui.parts.control_flow import Else, ForEach, If
from prefab_ui.rx import EVENT, STATE
random.seed(42)
TODAY = date.as we speak()
DATES = (TODAY - timedelta(days=29 - i) for i in vary(30))
REGIONS = ("All", "APAC", "EMEA", "NA", "LATAM")
PIPELINES = (
   "Buyer 360 ETL",
   "Bill OCR",
   "LLM Triage",
   "Danger Scoring",
   "Forecast Sync",
   "Warehouse Load",
)
OWNERS = ("Knowledge Platform", "AI Apps", "Income Ops", "Danger Engineering")
STATES = ("Accomplished", "Accomplished", "Accomplished", "Accomplished", "Late", "Failed")
PRIORITIES = ("P0", "P1", "P2", "P3")
runs = ()
daily_region_rows = ()
for d in DATES:
   for area in REGIONS(1:):
       region_bias = {
           "APAC": 0.96,
           "EMEA": 0.94,
           "NA": 0.97,
           "LATAM": 0.91,
       }(area)
       quantity = random.randint(32, 78)
       failures = 0
       late = 0
       total_cost = 0.0
       total_latency = 0.0
       total_revenue = 0.0
       for i in vary(quantity):
           pipeline = random.selection(PIPELINES)
           proprietor = random.selection(OWNERS)
           state = random.selections(
               STATES,
               weights=(
                   region_bias * 10,
                   6,
                   4,
                   3,
                   1.2,
                   max(0.2, (1 - region_bias) * 16),
               ),
               ok=1,
           )(0)
           period = max(
               12,
               int(
                   random.gauss(95, 35)
                   + (20 if state == "Late" else 0)
                   + (45 if state == "Failed" else 0)
               ),
           )
           price = spherical(max(0.09, random.lognormvariate(-1.15, 0.55) + period / 1800), 2)
           income = spherical(random.uniform(1.2, 8.5) * (1.3 if state == "Accomplished" else 0.6), 2)
           precedence = random.selections(PRIORITIES, weights=(1, 3, 7, 10), ok=1)(0)
           if state == "Failed":
               failures += 1
           if state == "Late":
               late += 1
           total_cost += price
           total_latency += period
           total_revenue += income
           if d >= TODAY - timedelta(days=10) and (state in {"Failed", "Late"} or random.random() < 0.05):
               runs.append({
                   "run_id": f"{d.strftime('%mpercentd')}-{area(:2)}-{len(runs)+1:04d}",
                   "date": d.strftime("%Y-%m-%d"),
                   "pipeline": pipeline,
                   "proprietor": proprietor,
                   "area": area,
                   "state": state,
                   "precedence": precedence,
                   "duration_s": period,
                   "cost_usd": price,
                   "revenue_k": income,
                   "sla_gap": spherical(max(0, period - 120) / 60, 1),
               })
       daily_region_rows.append({
           "date": d.strftime("%b %d"),
           "area": area,
           "runs": quantity,
           "failures": failures,
           "late": late,
           "success_rate": spherical(100 * (quantity - failures - late * 0.35) / quantity, 1),
           "avg_latency": spherical(total_latency / quantity, 1),
           "cost_usd": spherical(total_cost, 2),
           "revenue_k": spherical(total_revenue, 1),
       })
runs = sorted(
   runs,
   key=lambda r: (r("precedence"), r("state") != "Failed", -r("duration_s"))
)(:80)
def aggregate_daily(rows):
   by_date = defaultdict(lambda: {
       "date": "",
       "runs": 0,
       "failures": 0,
       "late": 0,
       "cost_usd": 0.0,
       "revenue_k": 0.0,
       "latency_weighted": 0.0,
   })
   for r in rows:
       bucket = by_date(r("date"))
       bucket("date") = r("date")
       bucket("runs") += r("runs")
       bucket("failures") += r("failures")
       bucket("late") += r("late")
       bucket("cost_usd") += r("cost_usd")
       bucket("revenue_k") += r("revenue_k")
       bucket("latency_weighted") += r("avg_latency") * r("runs")
   out = ()
   for d in (x.strftime("%b %d") for x in DATES):
       b = by_date(d)
       if b("runs"):
           b("success_rate") = spherical(100 * (b("runs") - b("failures") - b("late") * 0.35) / b("runs"), 1)
           b("avg_latency") = spherical(b("latency_weighted") / b("runs"), 1)
           b("cost_usd") = spherical(b("cost_usd"), 2)
           b("revenue_k") = spherical(b("revenue_k"), 1)
           del b("latency_weighted")
           out.append(dict(b))
   return out
def aggregate_regions(rows):
   by_region = defaultdict(lambda: {
       "area": "",
       "runs": 0,
       "failures": 0,
       "late": 0,
       "cost_usd": 0.0,
       "revenue_k": 0.0,
       "latency_weighted": 0.0,
   })
   for r in rows:
       b = by_region(r("area"))
       b("area") = r("area")
       b("runs") += r("runs")
       b("failures") += r("failures")
       b("late") += r("late")
       b("cost_usd") += r("cost_usd")
       b("revenue_k") += r("revenue_k")
       b("latency_weighted") += r("avg_latency") * r("runs")
   out = ()
   for area in REGIONS(1:):
       b = by_region(area)
       b("success_rate") = spherical(100 * (b("runs") - b("failures") - b("late") * 0.35) / b("runs"), 1)
       b("avg_latency") = spherical(b("latency_weighted") / b("runs"), 1)
       b("cost_usd") = spherical(b("cost_usd"), 2)
       b("revenue_k") = spherical(b("revenue_k"), 1)
       b("roi") = spherical(b("revenue_k") / max(1, b("cost_usd")), 1)
       del b("latency_weighted")
       out.append(dict(b))
   return out
def make_status_rows(table_rows):
   counts = Counter(r("state") for r in table_rows)
   return ({"state": ok, "rely": v} for ok, v in counts.gadgets())
def make_pipeline_rows(table_rows):
   counts = Counter(r("pipeline") for r in table_rows)
   return ({"pipeline": ok, "rely": v} for ok, v in counts.most_common())
def make_kpis(area, daily_rows, table_rows):
   runs_count = sum(r("runs") for r in daily_rows)
   failures = sum(r("failures") for r in daily_rows)
   late = sum(r("late") for r in daily_rows)
   price = sum(r("cost_usd") for r in daily_rows)
   income = sum(r("revenue_k") for r in daily_rows)
   return {
       "area": area,
       "runs": runs_count,
       "success_rate": spherical(100 * (runs_count - failures - late * 0.35) / max(1, runs_count), 1),
       "avg_latency": spherical(sum(r("avg_latency") * r("runs") for r in daily_rows) / max(1, runs_count), 1),
       "cost_usd": spherical(price, 2),
       "revenue_k": spherical(income, 1),
       "roi": spherical(income / max(1, price), 1),
       "open_issues": len(table_rows),
       "p0p1": sum(1 for r in table_rows if r("precedence") in {"P0", "P1"}),
       "failure_rate": spherical(100 * failures / max(1, runs_count), 2),
       "spark": (r("success_rate") for r in daily_rows(-14:)),
   }
DAILY_BY_REGION = {"All": aggregate_daily(daily_region_rows)}
REGION_ROWS = aggregate_regions(daily_region_rows)
for area in REGIONS(1:):
   DAILY_BY_REGION(area) = (r for r in daily_region_rows if r("area") == area)
RUNS_BY_REGION = {
   area: (r for r in runs if area == "All" or r("area") == area)
   for area in REGIONS
}
STATUS_BY_REGION = {
   area: make_status_rows(RUNS_BY_REGION(area))
   for area in REGIONS
}
PIPELINE_BY_REGION = {
   area: make_pipeline_rows(RUNS_BY_REGION(area))
   for area in REGIONS
}
KPI_BY_REGION = {
   area: make_kpis(area, DAILY_BY_REGION(area), RUNS_BY_REGION(area))
   for area in REGIONS
}
WATCHLIST = sorted(
   runs,
   key=lambda r: (r("precedence"), r("state") != "Failed", -r("sla_gap"))
)(:8)
SCATTER_ROWS = (
   {
       "area": r("area"),
       "success_rate": r("success_rate"),
       "cost_usd": r("cost_usd"),
       "avg_latency": r("avg_latency"),
   }
   for r in REGION_ROWS
)
RADAR_ROWS = (
   {"metric": "Success", **{r("area"): r("success_rate") for r in REGION_ROWS}},
   {"metric": "ROI", **{r("area"): min(100, r("roi") * 8) for r in REGION_ROWS}},
   {"metric": "Latency", **{r("area"): max(0, 100 - r("avg_latency") / 2) for r in REGION_ROWS}},
   {"metric": "Value", **{r("area"): max(0, 100 - r("cost_usd") / 20) for r in REGION_ROWS}},
)
REGION_ACTIONS = {
   area: (
       SetState("selected_region", area),
       SetState("line_rows", DAILY_BY_REGION(area)),
       SetState("table_rows", RUNS_BY_REGION(area)),
       SetState("status_rows", STATUS_BY_REGION(area)),
       SetState("pipeline_rows", PIPELINE_BY_REGION(area)),
       SetState("region_kpis", KPI_BY_REGION(area)),
       SetState("selected_run", None),
       ShowToast(f"Area set to {area}", variant="data", period=1800),
   )
   for area in REGIONS
}
'''

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)

Robbyant, die verkörperte KI-Einheit innerhalb der Ant Group, verfügt über LingBot-World als Open-Supply-Lösung, ein groß angelegtes Weltmodell, das die Videogenerierung in einen interaktiven Simulator für verkörperte Agenten, autonomes Fahren und Spiele verwandelt. Das System ist darauf ausgelegt, kontrollierbare Umgebungen mit hoher visueller Wiedergabetreue, starker Dynamik und langen Zeithorizonten darzustellen und gleichzeitig reaktionsfähig genug für eine Echtzeitsteuerung zu bleiben.

Vom Textual content zum Video zum Textual content zur Welt

Die meisten Textual content-zu-Video-Modelle erzeugen kurze Clips, die realistisch aussehen, sich aber wie passive Filme verhalten. Sie modellieren nicht, wie Handlungen die Umgebung im Laufe der Zeit verändern. LingBot-World ist stattdessen als aktionsbedingtes Weltmodell aufgebaut. Es lernt die Übergangsdynamik einer virtuellen Welt, sodass Tastatur- und Mauseingaben zusammen mit Kamerabewegungen die Entwicklung zukünftiger Frames vorantreiben.

Formal lernt das Modell die bedingte Verteilung zukünftiger Video-Tokens anhand vergangener Frames, Sprachaufforderungen und diskreter Aktionen. Zur Trainingszeit werden Sequenzen mit einer Länge von bis zu etwa 60 Sekunden vorhergesagt. Zur Inferenzzeit kann es autoregressiv kohärente Videostreams mit einer Länge von etwa 10 Minuten bereitstellen und dabei die Szenenstruktur stabil halten.

Daten-Engine, vom Webvideo bis hin zu interaktiven Flugbahnen

Ein Kerndesign in LingBot-World ist eine einheitliche Daten-Engine. Es bietet umfassende, aufeinander abgestimmte Einblicke in die Artwork und Weise, wie Handlungen die Welt verändern, und deckt gleichzeitig verschiedene reale Szenen ab.

Die Datenerfassungspipeline kombiniert drei Quellen:

1. Großformatige Webvideos von Menschen, Tieren und Fahrzeugen, sowohl aus der Ego- als auch aus der Third-Individual-Perspektive
2. Spieldaten, bei denen RGB-Frames strikt mit Benutzersteuerungen wie W, A, S, D und Kameraparametern gekoppelt sind
3. In der Unreal Engine gerenderte synthetische Flugbahnen, bei denen saubere Frames, Kamera-Intrinsics und -Extrinsics sowie Objektlayouts bekannt sind

Nach der Sammlung wird dieser heterogene Korpus in einer Profilierungsphase standardisiert. Es filtert nach Auflösung und Dauer, segmentiert Movies in Clips und schätzt fehlende Kameraparameter anhand von Geometrie- und Posenmodellen. Ein Imaginative and prescient-Language-Modell bewertet Clips nach Qualität, Bewegungsstärke und Ansichtstyp und wählt dann eine kuratierte Teilmenge aus.

Darüber hinaus baut ein hierarchisches Untertitelmodul drei Ebenen der Textüberwachung auf:

• Erzählerische Bildunterschriften für ganze Flugbahnen, einschließlich Kamerabewegungen
• Statische Szenenuntertitel, die das Umgebungslayout ohne Bewegung beschreiben
• Dichte zeitliche Untertitel für kurze Zeitfenster, die sich auf lokale Dynamiken konzentrieren

Durch diese Trennung kann das Modell die statische Struktur von Bewegungsmustern trennen, was für die Konsistenz über lange Horizonte wichtig ist.

Architektur, MoE-Video-Spine und Aktionskonditionierung

LingBot-World beginnt mit Wan2.2, einem 14B-Parameter-Bild-zu-Video-Diffusionstransformator. Dieses Spine erfasst bereits starke Open-Area-Video-Prioritäten. Das Robbyant-Workforce erweitert es zu einem DiT-Expertenmix mit 2 Experten. Jeder Experte verfügt über etwa 14B Parameter, sodass die Gesamtparameteranzahl 28B beträgt, aber bei jedem Entrauschungsschritt ist nur 1 Experte aktiv. Dadurch bleiben die Inferenzkosten ähnlich wie bei einem dichten 14B-Modell und erhöhen gleichzeitig die Kapazität.

Ein Lehrplan verlängert Trainingssequenzen von 5 Sekunden auf 60 Sekunden. Der Zeitplan erhöht den Anteil von Zeitschritten mit hohem Rauschen, was globale Layouts über lange Kontexte hinweg stabilisiert und den Moduskollaps bei langen Rollouts reduziert.

Um das Modell interaktiv zu machen, werden Aktionen direkt in die Transformatorblöcke eingefügt. Kameradrehungen werden mit Plücker-Einbettungen codiert. Tastaturaktionen werden als Multi-Sizzling-Vektoren über Tasten wie W, A, S, D dargestellt. Diese Codierungen werden zusammengeführt und durch adaptive Layer-Normalisierungsmodule geleitet, die verborgene Zustände im DiT modulieren. Nur die Aktionsadapterebenen werden fein abgestimmt, das Hauptvideo-Spine bleibt eingefroren, sodass das Modell die visuelle Qualität aus dem Vortraining beibehält und gleichzeitig die Aktionsreaktionsfähigkeit aus einem kleineren interaktiven Datensatz lernt.

Bei der Schulung werden sowohl Bild-zu-Video- als auch Video-zu-Video-Fortsetzungsaufgaben verwendet. Anhand eines einzelnen Bildes kann das Modell zukünftige Frames synthetisieren. Bei einem unvollständigen Clip kann die Sequenz verlängert werden. Dadurch entsteht eine interne Übergangsfunktion, die zu beliebigen Zeitpunkten starten kann.

LingBot World Quick, Destillation für den Echtzeiteinsatz

Das mitteltrainierte Modell, LingBot-World Base, basiert immer noch auf mehrstufiger Diffusion und vollständiger zeitlicher Aufmerksamkeit, was für Echtzeitinteraktion kostspielig ist. Das Robbyant-Workforce führt LingBot-World-Quick als beschleunigte Variante ein.

Das schnelle Modell wird vom Experten für hohes Rauschen initialisiert und ersetzt die volle zeitliche Aufmerksamkeit durch blockkausale Aufmerksamkeit. Innerhalb jedes Zeitblocks ist die Aufmerksamkeit bidirektional. Blockübergreifend ist es kausal. Dieses Design unterstützt das Caching von Schlüsselwerten, sodass das Modell Frames autoregressiv und kostengünstiger streamen kann.

Bei der Destillation kommt eine Diffusionsstrategie zum Einsatz. Der Schüler wird mit einem kleinen Satz von Zielzeitschritten, einschließlich Zeitschritt 0, trainiert, sodass er sowohl verrauschte als auch saubere latente Signale erkennt. Die Verteilungsanpassungsdestillation wird mit einem kontradiktorischen Diskriminatorkopf kombiniert. Der gegnerische Verlust aktualisiert nur den Diskriminator. Das Studentennetzwerk wird mit dem Destillationsverlust aktualisiert, was die Ausbildung stabilisiert und gleichzeitig die Handlungsfolge und die zeitliche Kohärenz bewahrt.

In Experimenten erreicht LingBot World Quick 16 Bilder professional Sekunde bei der Verarbeitung von 480p-Movies auf einem System mit 1 GPU-Knoten und hält die Finish-to-Finish-Interaktionslatenz zur Echtzeitkontrolle unter 1 Sekunde.

Emergentes Gedächtnis und Langzeitverhalten

Eine der interessantesten Eigenschaften von LingBot-World ist das entstehende Gedächtnis. Das Modell behält die globale Konsistenz ohne explizite 3D-Darstellungen wie Gaußsches Splatting bei. Wenn sich die Kamera von einem Wahrzeichen wie Stonehenge entfernt und nach etwa 60 Sekunden zurückkehrt, erscheint die Struktur wieder mit konsistenter Geometrie. Wenn ein Auto den Rahmen verlässt und später wieder betritt, erscheint es an einer physikalisch plausiblen Stelle, nicht eingefroren oder zurückgesetzt.

Das Modell kann auch extrem lange Sequenzen durchhalten. Das Forschungsteam zeigt eine kohärente Videogenerierung, die bis zu 10 Minuten dauert, mit stabilem Structure und Erzählstruktur.)

VBench-Ergebnisse und Vergleich mit anderen Weltmodellen

Zur quantitativen Auswertung verwendete das Forschungsteam VBench für einen kuratierten Satz von 100 generierten Movies, die jeweils länger als 30 Sekunden waren. LingBot-World wird mit zwei aktuellen Weltmodellen verglichen, Yume-1.5 und HY-World-1.5.

Auf VBench berichtet LingBot World:

Diese Werte sind höher als beide Basiswerte für Bildqualität, ästhetische Qualität und Dynamikgrad. Der dynamische Gradspielraum ist groß, 0,8857 im Vergleich zu 0,7612 und 0,7217, was auf reichhaltigere Szenenübergänge und komplexere Bewegungen hinweist, die auf Benutzereingaben reagieren. Bewegungsglätte und zeitliches Flimmern sind mit der besten Basislinie vergleichbar und die Methode erreicht die beste Gesamtkonsistenzmetrik unter den drei Modellen.

Ein separater Vergleich mit anderen interaktiven Systemen wie Matrix-Recreation-2.0, Mirage-2 und Genie-3 zeigt, dass LingBot-World eines der wenigen vollständig Open-Supply-Weltmodelle ist, das allgemeine Domänenabdeckung, langen Generationshorizont, hohen Dynamikgrad, 720p-Auflösung und Echtzeitfähigkeiten kombiniert.

Anwendungen, aufforderungsfähige Welten, Agenten und 3D-Rekonstruktion

Über die Videosynthese hinaus ist LingBot-World als Testumgebung für verkörperte KI positioniert. Das Modell unterstützt aufrufbare Weltereignisse, bei denen Textanweisungen im Laufe der Zeit das Wetter, die Beleuchtung oder den Stil ändern oder lokale Ereignisse wie Feuerwerk oder sich bewegende Tiere einspeisen und gleichzeitig die räumliche Struktur bewahren.

Es kann auch nachgelagerte Aktionsagenten trainieren, beispielsweise mit einem kleinen Imaginative and prescient-Language-Aktionsmodell wie Qwen3-VL-2B, das Kontrollrichtlinien anhand von Bildern vorhersagt. Da die generierten Videostreams geometrisch konsistent sind, können sie als Eingabe für 3D-Rekonstruktionspipelines verwendet werden, die stabile Punktwolken für Innen-, Außen- und synthetische Szenen erzeugen.

Wichtige Erkenntnisse

• LingBot-World ist ein aktionsbedingtes Weltmodell, das Textual content-zu-Video in eine Textual content-zu-Welt-Simulation erweitert, wobei Tastaturaktionen und Kamerabewegungen Video-Rollouts über einen langen Horizont von bis zu etwa 10 Minuten direkt steuern.
• Das System basiert auf einer einheitlichen Daten-Engine, die Webvideos, Spielprotokolle mit Aktionsbezeichnungen und Unreal Engine-Trajektorien sowie hierarchische Erzählungen, statische Szenen und dichte zeitliche Untertitel kombiniert, um Structure und Bewegung zu trennen.
• Das Kernrückgrat ist eine 28B-Parametermischung aus Experten-Diffusionstransformator, aufgebaut aus Wan2.2, mit 2 Experten von jeweils 14B und Aktionsadaptern, die fein abgestimmt sind, während das visuelle Rückgrat eingefroren bleibt.
• LingBot-World-Quick ist eine destillierte Variante, die blockkausale Aufmerksamkeit, Diffusionserzwingung und Verteilungsanpassungsdestillation nutzt, um etwa 16 Bilder professional Sekunde bei 480p auf einem GPU-Knoten zu erreichen, mit einer gemeldeten Finish-to-Finish-Latenz von weniger als 1 Sekunde für die interaktive Nutzung.
• Auf VBench mit 100 generierten Movies, die länger als 30 Sekunden sind, meldet LingBot-World die höchste Bildqualität, ästhetische Qualität und den höchsten Dynamikgrad unter Yume-1.5 und HY-World-1.5, und das Modell zeigt ein Emergenzgedächtnis und eine stabile Fernstruktur, die für verkörperte Agenten und 3D-Rekonstruktion geeignet ist.

Schauen Sie sich das an Papier, Repo, Projektseite Und Modellgewichte. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Instruments für die Datenvisualisierung und Erkundung haben es mir ermöglicht, meine Pc Imaginative and prescient -Projekte schneller zu iterieren, insbesondere wenn die Probleme, mit denen ich konfrontiert bin Treffen Sie Algorithmus oder Entwurfsentscheidungen, die auf dynamischen zeitvariablen Signalen basieren. Diese Signale können häufig eine analysierende Analyse sein, indem Sie sich nur schnell ändernde Zahlen, die auf dem Bildschirm aufgezeichnet wurden, oder in einer Tabelle gespeichert werden.

Während ich an einigen dieser Probleme arbeitete, untersuchte ich die eingebauten interaktiven Elemente von OpenCVAber abgesehen von einigen Schiebereglern sind die Optionen dort sehr begrenzt, insbesondere wenn man versucht, einige animierte Handlungen zu integrieren. Es gibt einige hacky Möglichkeiten, dynamische Diagramme aus zu erhalten matplotlib hinein OpenCVwas ich darin erforscht habe Publish.

Ich habe auch verschiedene UI -Frameworks erforscht wie tkinterwas ich in meinem verwendet habe Letztes Projekt Für eine Visualisierung der Stimmungsanalyse. Ich habe eine benutzerdefinierte Komponente erstellt, mit der ich dynamische Rahmen anzeigen konnte. Es fühlte sich jedoch immer noch nicht wirklich wie das richtige Werkzeug für die Aufgabe an, insbesondere wenn es versucht, mit interaktiven Handlungen zu arbeiten.

Und dann stolperte ich über Wiederholung. Hin und wieder entdecke ich ein Werkzeug oder ein Rahmen, das mich wirklich erregt, und dies struggle genau eine dieser Zeiten. RERUN ist ein Open-Supply-Device zur Visualisierung von Daten, die typischerweise in der Robotik-Domäne enthalten sind, die von einfachen Zeitreihendaten und statischen Bildern bis hin zu komplexen 3D-Punktwolken, Videoströmen oder anderen Arten von Multimodaldaten reichen. Die Demos sehen sehr beeindruckend aus und die Setup- und Code -Samples sind so einfach, dass ich sofort begeistert struggle.

Deshalb habe ich mich entschlossen, meine Ball -Monitoring -Demo aus einem früheren Projekt zu überarbeiten und die Daten mit Rerun zu zeichnen. Lassen Sie mich Ihnen zeigen, wie einfach es ist, interaktive Anwendungen zu verwenden und zu erstellen!

QuickStart

Sie können Rerun in einem Ihrer Python -Projekte mit PIP oder UV installieren:

pip set up rerun-sdk
uv add rerun-sdk

Sie können den Betrachter nach der Set up des SDK starten, indem Sie ihn einfach aus der Befehlszeile ausführen:

rerun

Der Betrachter ist Ihr Hauptfenster, in dem Ihre Experimente angezeigt werden. Sie können es offen lassen oder zwischen Ihren Experimenten schließen.

Um einen Wiederholungsbetrieb aus einem Python -Skript zu instanziieren, müssen Sie eine Instanz mit einem Experimentnamen hervorbringen:

import rerun as rr

rr.init("ball_tracking", spawn=True)

Ballverfolgungsdemo

Experimentierungen erneut ausführen können auf und geladen werden .rrd Aufzeichnungsdateien. Sie können die Aufzeichnungsdatei für die Ball -Monitoring -Demo herunterladen Hier. Drücken Ctrl + O oder auswählen Open... Im Menü oben hyperlinks vom Wiederholungsbetrieb und laden Sie die heruntergeladene Aufzeichnungsdatei.

Sie werden die Ball -Monitoring -Demo -Wiedergabe einmal sehen und dann stoppt das Video. Am Ende des Betrachters haben Sie die Zeitleiste. Sie können durch die Zeitleiste schrubben, indem Sie auf den Griff klicken und ziehen.

Diese Aufzeichnungsdateien enthalten nur die Daten des Experiments, einschließlich des Movies, der Anmerkungen und der Zeitreihen der Monitoring. Das Structure des Betrachters wird separat in a gespeichert .rbl Blaupausedatei. Laden Sie die Blueprint -Datei für die Demo herunter Hier und öffnen Sie es oben in der vorhandenen Datendatei.

Jetzt haben wir einen etwas besseren Überblick über die Place der Place, die Geschwindigkeit und die Beschleunigung, die sich getrennt haben und das Video distinguished zentriert.

Im Videoband können Sie auf die Anmerkungen und hyperlinks klicken Blueprint Panel Sie können sie einzeln verbergen oder anzeigen.

Zeitreihendiagramme

Um ein bestimmtes Diagramm zu analysieren, können Sie oben rechts in jedem Fenster auf die Schaltfläche Ansicht erweitern, z. B. das Positionsdiagramm.

Dies ist a TimeSeriesView. Diese Ansicht kann verwendet werden, um Daten in einem 2D-Diagramm mit der x-Achse zu zeichnen, die die Zeitdomäne darstellt, in unserem Fall den diskreten Body-Index des Movies. In dieser Ball -Monitoring -Demo iterieren wir über die Videorahmen in einer Schleife, in der wir den Body -Index unserer Zeitleiste explizit festlegen können.

frame_index = 0

whereas True:
    ret, body = cap.learn()
    if not ret:
        break

    frame_index += 1
    if frame_index >= num_frames:
        break

    rr.set_time("frame_idx", sequence=frame_index)

Um das Diagramm für die Place zu erstellen, müssen Sie einen skalaren Wert für die Place des verfolgten Balls bei jedem Body -Index protokollieren. In diesem Fall, nachdem wir die Place berechnet haben, können wir sie einfach als Wiederholung protokollieren:

rr.log("ball/position_y", rr.Scalars(pos))

Um den Stil dieses Handels zu konfigurieren, müssen wir auch etwas auf demselben Entitätspfad protokollieren (ball/position_y), aber da sich der Stil nicht ändert, können wir ihn einmal vor der Schleife protokollieren und ein statisches Argument liefern.

rr.log(
    "ball/position_y",
    rr.SeriesLines(colours=(0, 128, 255), names="pos y"),
    static=True,
)

Um den Achsenbereich zu definieren, der professional Commonplace sichtbar ist, müssen wir eine Layoutkomponente angeben.

view_pos = rrb.TimeSeriesView(
    origin="ball/position_y",
    axis_y=rrb.ScalarAxis(vary=(0, 700)),
)
format = rrb.Blueprint(view_pos)
rr.send_blueprint(format)

Video Stream

In ähnlicher Weise können wir eine Ansicht für die Videorahmen erstellen, indem wir das Bild für die Wiederholung protokollieren. Da RERUN ein RGB -Bilder erwartet, aber opencv ues BGR für seine Farbkanal -Bestellung, müssen wir die Frames von BGR in RGB konvertieren, bevor wir sie zum Wiederaufbau angeben.

frame_rgb: np.ndarray = cv2.cvtColor(body, cv2.COLOR_BGR2RGB)
rr.log("body", rr.Picture(frame_rgb))

Um der Bildansicht Anmerkungen hinzuzufügen, müssen wir räumliche Elemente auf einem Subpfad des angegebenen Entitätspfads protokollieren. Zum Beispiel können wir die Mitte des verfolgten Balls zeichnen:

rr.log(
    "body/factors",
    rr.Points2D(
        positions=(heart),
        colours=(0, 0, 255),
        radii=4.0,
    ),
)

Um die Video -Body -Ansicht in das Structure aufzunehmen, können wir a verwenden Spatial2DView Knoten:

view_frame = rrb.Spatial2DView(origin="body")

Dann können wir die Handlung vor vertikal mit der Rahmenansicht mit a stapeln Vertical Layoutkomponente:

format = rrb.Blueprint(
    rrb.Vertical(
        view_pos,
        view_frame,
        row_shares=(0.33),
    ),
)
rr.send_blueprint(format)

Die Zeilenaktien geben an, wie stark jede der Zeilen in Prozent einnimmt. Wir können die zweite Zeile -Aktieneintrag für die Body -Ansicht weglassen, da die Aktien bis zu 1 hinzufügen müssen.

Einschränkungen

Während der Arbeit an diesem Projekt struggle ich auf einige Einschränkungen des Wiederholungsunternehmens teilgenommen. Im ursprünglichen Projekt habe ich eine Vorhersage der Flugbahn zu jedem Zeitschritt vorgestellt, dies ist jedoch in einer Zeitreihenansicht derzeit nicht möglich. Auch die Layouts und die Konfiguration der auf den Aufzeichnungsdaten begrenzten Daten sind begrenzt, beispielsweise gibt es keinen integrierten Weg, um einen Kreis ohne Füllung zu zeichnen. Da das Projekt jedoch sehr aktiv entwickelt wird, besteht eine gute Probability, dass einige davon in Zukunft möglich sind.

Abschluss

Die Entwicklererfahrung mit diesem Device als Pc Imaginative and prescient Engineer ist extrem nett, die Benutzeroberfläche lädt quick sofort und das Timeline -Scrubbing kann unglaublich hilfreich sein, um Signale in Zeitreihenplots oder in Movies zu verstehen oder zu debuggen. Ich werde dieses Projekt auf jeden Fall weiter verwenden und erkunden und Sie nur empfehlen, es selbst auszuprobieren!

Weitere Informationen und die vollständige Implementierung finden Sie im Quellcode dieses Projekts unter src/ball_tracking/trajectory_rerun.py.

https://github.com/trflorian/ball-tracking-live-plot

Alle Visualisierungen in diesem Beitrag wurden vom Autor erstellt.

Bild von Autor | Chatgpt

Einführung

Das Erstellen interaktiver webbasierter Daten-Dashboards in Python ist einfacher als je zuvor, wenn Sie die Stärken von kombinieren StraffungAnwesend PandasUnd Handlung. Diese drei Bibliotheken arbeiten nahtlos zusammen, um statische Datensätze in reaktionsschnelle, visuell ansprechende Anwendungen umzuwandeln – alle, ohne einen Hintergrund in der Webentwicklung zu benötigen.

Es gibt jedoch einen wichtigen architektonischen Unterschied zu verstehen, bevor wir beginnen. Im Gegensatz zu Bibliotheken wie Matplotlib oder Seeborn, die direkt in Jupyter -Notebooks arbeiten, erstellt Streamlit eigenständige Webanwendungen, die aus der Befehlszeile ausgeführt werden müssen. Sie schreiben Ihren Code in eine textbasierte IDE wie VS-Code, speichern Sie ihn als a .Py -Dateiund führen Sie es mit streamlit run Filename.py. Diese Verschiebung von der Pocket book-Umgebung zur skriptbasierten Entwicklung eröffnet neue Möglichkeiten zum Teilen und Bereitstellen Ihrer Datenanwendungen.

In diesem praktischen Tutorial lernen Sie, wie Sie ein komplettes Verkaufs-Dashboard aufbauen können zwei klare Schritte. Wir beginnen mit der Kernfunktionalität mit nur Streamlit und Pandas und verbessern dann das Dashboard mit interaktiven Visualisierungen mithilfe von Plotly.

Aufstellen

Installieren Sie die erforderlichen Pakete:

pip set up streamlit pandas plotly

Erstellen Sie einen neuen Ordner für Ihr Projekt und öffnen Sie ihn in VS -Code (oder Ihrem bevorzugten Texteditor).

Schritt 1: Stromverschluss + Pandas Dashboard

Beginnen wir damit, ein funktionales Dashboard mit nur Stromversorgung und Pandas zu erstellen. Dies zeigt, wie streamlit interaktive Internet -Schnittstellen erstellt und wie Pandas die Datenfilterung umgeht.

Erstellen Sie eine Datei aufgerufen STEP1_Dashboard_Basic.py:

import streamlit as st
import pandas as pd
import numpy as np

# Web page config
st.set_page_config(page_title="Primary Gross sales Dashboard", structure="broad")

# Generate pattern information
np.random.seed(42)
df = pd.DataFrame({
    'Date': pd.date_range('2024-01-01', intervals=100),
    'Gross sales': np.random.randint(500, 2000, dimension=100),
    'Area': np.random.alternative(('North', 'South', 'East', 'West'), dimension=100),
    'Product': np.random.alternative(('Product A', 'Product B', 'Product C'), dimension=100)
})

# Sidebar filters
st.sidebar.title('Filters')
areas = st.sidebar.multiselect('Choose Area', df('Area').distinctive(), default=df('Area').distinctive())
merchandise = st.sidebar.multiselect('Choose Product', df('Product').distinctive(), default=df('Product').distinctive())

# Filter information
filtered_df = df((df('Area').isin(areas)) & (df('Product').isin(merchandise)))

# Show metrics
col1, col2, col3 = st.columns(3)
col1.metric("Whole Gross sales", f"${filtered_df('Gross sales').sum():,}")
col2.metric("Common Gross sales", f"${filtered_df('Gross sales').imply():.0f}")
col3.metric("Information", len(filtered_df))

# Show filtered information
st.subheader("Filtered Information")
st.dataframe(filtered_df)

Lassen Sie uns die hier verwendeten wichtigen Stromversorgungsmethoden aufschlüsseln:

• St.Set_Page_Config () Konfiguriert den Registerkarte und Format des Browsers
• St.SideBar Erstellt das linke Navigationspanel für Filter
• St. Multiselect () Generiert Dropdown -Menüs für Benutzerauswahl
• St.Columns () Erstellt nebeneinander Layoutabschnitte
• St.Metric () Zeigt große Zahlen mit Etiketten an
• St.Dataframe () Rendert interaktive Datentabellen

Diese Methoden verarbeiten automatisch Benutzerinteraktionen und lösen App -Updates, wenn sich die Auswahl ändert.

Führen Sie dies von Ihrem Terminal aus (oder integriertes Terminal des VS -Codes) aus:

streamlit run step1_dashboard_basic.py

Ihr Browser wird sich öffnen http: // localhost: 8501 Zeigen Sie ein interaktives Dashboard.

Versuchen Sie, die Filter in der Seitenleiste zu ändern – beobachten Sie, wie die Metriken und die Datentabelle automatisch aktualisieren! Dies zeigt die reaktive Natur von stromloses Kombination mit den Datenmanipulationsfunktionen von Pandas.

Schritt 2: Fügen Sie Plotly für interaktive Visualisierungen hinzu

Lassen Sie uns nun unser Dashboard verbessern, indem wir die interaktiven Diagramme von Plotly hinzufügen. Dies zeigt, wie alle drei Bibliotheken nahtlos zusammenarbeiten. Erstellen wir eine neue Datei und rufen Sie sie an STEP2_Dashboard_Plotly.py:

import streamlit as st
import pandas as pd
import plotly.categorical as px
import numpy as np

# Web page config
st.set_page_config(page_title="Gross sales Dashboard with Plotly", structure="broad")

# Generate information
np.random.seed(42)
df = pd.DataFrame({
    'Date': pd.date_range('2024-01-01', intervals=100),
    'Gross sales': np.random.randint(500, 2000, dimension=100),
    'Area': np.random.alternative(('North', 'South', 'East', 'West'), dimension=100),
    'Product': np.random.alternative(('Product A', 'Product B', 'Product C'), dimension=100)
})

# Sidebar filters
st.sidebar.title('Filters')
areas = st.sidebar.multiselect('Choose Area', df('Area').distinctive(), default=df('Area').distinctive())
merchandise = st.sidebar.multiselect('Choose Product', df('Product').distinctive(), default=df('Product').distinctive())

# Filter information
filtered_df = df((df('Area').isin(areas)) & (df('Product').isin(merchandise)))

# Metrics
col1, col2, col3 = st.columns(3)
col1.metric("Whole Gross sales", f"${filtered_df('Gross sales').sum():,}")
col2.metric("Common Gross sales", f"${filtered_df('Gross sales').imply():.0f}")
col3.metric("Information", len(filtered_df))

# Charts
col1, col2 = st.columns(2)

with col1:
    fig_line = px.line(filtered_df, x='Date', y='Gross sales', shade="Area", title="Gross sales Over Time")
    st.plotly_chart(fig_line, use_container_width=True)

with col2:
    region_sales = filtered_df.groupby('Area')('Gross sales').sum().reset_index()
    fig_bar = px.bar(region_sales, x='Area', y='Gross sales', title="Whole Gross sales by Area")
    st.plotly_chart(fig_bar, use_container_width=True)

# Information desk
st.subheader("Filtered Information")
st.dataframe(filtered_df)

Führen Sie dies von Ihrem Terminal aus (oder integriertes Terminal des VS -Codes) aus:

streamlit run step2_dashboard_plotly.py

Jetzt haben Sie ein komplettes interaktives Dashboard!

Die Diagramme für Handlung sind vollständig interaktiv – Sie können über Datenpunkte schweben, bestimmte Zeiträume vergrößern und sogar auf Legendelemente klicken, um Datenreihen anzuzeigen/auszublenden.

Wie die drei Bibliotheken zusammenarbeiten

Diese Kombination ist leistungsstark, weil jede Bibliothek das umgeht, was sie am besten kann:

Pandas verwaltet alle Datenvorgänge:

• Erstellen und Laden von Datensätzen
• Filterungsdaten basierend auf Benutzerauswahlen
• Daten für Visualisierungen aggregieren
• Umgang mit Datenumwandlungen

Straffung Bietet die Webschnittstelle:

• Erstellt interaktive Widgets (Multiselect, Sliders usw.)
• Weitere die gesamte App erneut, wenn Benutzer mit Widgets interagieren
• Behandelt das reaktive Programmiermodell
• Verwaltet das Format mit Spalten und Containern

Handlung erstellt reichhaltige, interaktive Visualisierungen:

• Diagramme, die Benutzer schweben, zoomen und erkunden können
• Professionelle Diagramme mit minimalem Code
• Automatische Integration in die Reaktivität von Streamlit

Schlüsselentwicklungsworkflow

Der Entwicklungsprozess folgt einem einfachen Muster. Schreiben Sie zunächst Ihren Code in VS -Code oder einem Texteditor und speichern Sie ihn als .Py -Datei. Führen Sie als nächstes die Anwendung von Ihrem Terminal aus streamlit run Filename.pywas Ihr Dashboard in einem Browser öffnet http: // localhost: 8501. Während Sie Ihren Code bearbeiten und speichern, erkennt Streamlit automatisch Änderungen und bietet die Anwendung an. Sobald Sie mit Ihrem Dashboard zufrieden sind, können Sie es über die streamlit Group Cloud bereitstellen, um sie mit anderen zu teilen.

Nächste Schritte

Probieren Sie diese Verbesserungen aus:

Fügen Sie echte Daten hinzu:

# Substitute pattern information with CSV add
uploaded_file = st.sidebar.file_uploader("Add CSV", kind="csv")
if uploaded_file:
    df = pd.read_csv(uploaded_file)

Beachten Sie, dass echte Datensätze die für Ihre Datenstruktur spezifischen Vorverarbeitungsschritte erfordern. Sie müssen Spaltennamen anpassen, fehlende Werte verarbeiten und die Filteroptionen so ändern, dass sie Ihren tatsächlichen Datenfeldern entsprechen. Der Beispielcode enthält eine Vorlage, aber jeder Datensatz hat einzigartige Anforderungen für die Reinigung und Vorbereitung.

Weitere Diagrammtypen:

# Pie chart for product distribution
fig_pie = px.pie(filtered_df, values="Gross sales", names="Product", title="Gross sales by Product")
st.plotly_chart(fig_pie)

Sie können eine Ganze nutzen Galerie von Plotlys Grafikfunktionen.

Bereitstellen Ihres Dashboards

Sobald Ihr Dashboard lokal funktioniert, ist es unkompliziert, es mit anderen durch die streamlite Group -Cloud zu teilen. Drücken Sie zunächst Ihren Code in ein öffentliches Github -Repository und stellen Sie sicher, dass a einbezogen werden Anforderungen.txt Dateiauflistung Ihrer Abhängigkeiten (streamlit, pandas, plotly). Dann besuchen Sie https://streamlit.io/cloudMelden Sie sich mit Ihrem Github -Konto an und wählen Sie Ihr Repository aus. Streamlit erstellt und bereitstellt Ihre App automatisch und bereitet eine öffentliche URL bereit, auf die jeder zugreifen kann. Die kostenlose Stufe unterstützt mehrere Apps und behandelt angemessene Verkehrsladungen, wodurch es perfekt ist, um Dashboards mit Kollegen zu teilen oder Ihre Arbeit in einem Portfolio zu präsentieren.

Abschluss

Die Kombination von Stromlit, Pandas und Plotly verwandelt die Datenanalyse aus statischen Berichten in interaktive Webanwendungen. Mit nur zwei Python -Dateien und einer Handvoll Methoden haben Sie ein komplettes Dashboard erstellt, das teure Enterprise Intelligence -Instruments enthält.

Dieses Tutorial zeigt eine signifikante Verschiebung, wie Datenwissenschaftler ihre Arbeit teilen können. Anstatt statische Diagramme zu senden oder Kollegen zu verpflichten, Jupyter -Notizbücher auszuführen, können Sie jetzt Webanwendungen erstellen, die jeder über einen Browser verwenden kann. Der Übergang von der Pocket book-basierten Analyse zu skriptbasierten Anwendungen eröffnet Datenfachleuten neue Möglichkeiten, ihre Erkenntnisse zugänglicher und wirkungsvoller zu gestalten.

Überlegen Sie, wie interaktive Dashboards mit diesen Instruments mit diesen Instruments fortgesetzt werden können. Die gleichen Prinzipien, die Sie hier gelernt haben, skalieren Sie, um echte Datensätze, komplexe Berechnungen und ausgefeilte Visualisierungen zu verarbeiten. Unabhängig davon, ob Sie Government Dashboards, explorative Datenwerkzeuge oder Kundenanwendungen erstellen, bietet diese Drei-Bibliothek-Kombination eine solide Grundlage für professionelle Datenanwendungen.

Vinod wurde in Indien geboren und ist in Japan aufgewachsen. Er bringt eine globale Perspektive in die Bildung von Datenwissenschaft und maschinellem Lernen. Er überbrückt die Lücke zwischen aufstrebenden KI -Technologien und der praktischen Umsetzung für Berufstätige. Vinod konzentriert sich darauf, zugängliche Lernwege für komplexe Themen wie Agenten -KI, Leistungsoptimierung und KI -Engineering zu erstellen. Er konzentriert sich auf praktische Implementierungen für maschinelles Lernen und Mentoring der nächsten Era von Datenfachleuten durch Reside -Sitzungen und personalisierte Anleitung.

Arbeiten in DatenwissenschaftEs kann schwierig sein, Erkenntnisse aus komplexen Datensätzen mit nur statischen Zahlen zu teilen. Alle Facetten, die die Kind und Bedeutung interessanter Daten beschreiben, werden nicht immer in einer Handvoll vorgenerierter Figuren erfasst. Während wir leistungsstarke Technologien zur Präsentation interaktiver Zahlen zur Verfügung haben – bei denen ein Betrachter komplexe Daten drehen, filtern, zoomen und im Allgemeinen untersuchen kann – haben sie immer Kompromisse.

Hier präsentiere ich meine Erfahrung mit einer kürzlich veröffentlichten Python -Bibliothek –Marimo– Dies eröffnet aufregende neue Möglichkeiten, um interaktive Visualisierungen im gesamten Bereich der Datenwissenschaft zu veröffentlichen.

Interaktive Datenvisualisierung

Die Kompromisse bei der Auswahl eines Ansatzes zur Präsentation von Datenvisualisierungen können in drei Kategorien unterteilt werden:

• Fähigkeiten – Welche Visualisierungen und Interaktivität kann ich dem Benutzer präsentieren?
• Veröffentlichungskosten – Welche Ressourcen benötigen für die Anzeige dieser Visualisierung für Benutzer (z. B. Server ausführend, Internet hosting -Web sites)?
• Benutzerfreundlichkeit– Wie viel von einer neuen Fähigkeiten / Codebasis muss ich im Voraus lernen?

JavaScriptist die Grundlage für tragbare Interaktivität. Jeder Benutzer hat einen Webbrowser auf seinem Laptop installiert, und es stehen viele verschiedene Frameworks zur Verfügung, um ein gewisses Maß an Interaktivität oder Visualisierung anzuzeigen, die Sie sich vorstellen können (z. B. diese Galerie der erstaunlichen Dinge, die Menschen mit drei.Js gemacht haben). Da die Anwendung auf dem Laptop des Benutzers ausgeführt wird, sind keine teuren Server erforderlich. Ein wesentlicher Nachteil für die Datenwissenschaftsgemeinschaft ist jedoch eine einfache Gebrauchsnutzung, da JS nicht viele der hochrangigen (dh benutzerfreundlichen) Bibliotheken hat, die Datenwissenschaftler für Datenmanipulationen, -diagramm und Interaktivität verwenden.

Python Bietet einen nützlichen Vergleichspunkt. Wegen seiner ständig wachsende Popularitäteinige haben das das genannt „Ära von Python“. Insbesondere für Datenwissenschaftler steht Python neben R als eine der grundlegenden Sprachen für schnell und effektiv komplexe Daten. Während Python möglicherweise einfacher zu verwenden ist als JavaScript, gibt es weniger Optionen für die Präsentation interaktiver Visualisierungen. Einige beliebte Projekte, die Interaktivität und Visualisierung liefern, waren FlascheAnwesend Bindestrich Und Straffung(auch erwähnenswert –BokehAnwesend HoloviewsAnwesend AltairUnd Handlung ). Der größte Kompromiss für die Verwendung von Python waren die Kosten für die Veröffentlichung – die Bereitstellung des Instruments an Benutzer. Genauso wie das Shinyapps Erfordern Sie einen laufenden Laptop, um die Visualisierung zu erstellen, und diese pythonbasierten Frameworks wurden ausschließlich serverbasiert. Dies ist keineswegs unerschwinglich für Autoren mit einem Price range, das jedoch die Anzahl der Benutzer einschränkt, die ein bestimmtes Projekt nutzen können.

Pyodid ist ein faszinierender Mittelweg – Python -Code, der direkt im Webbrowser ausgeführt wird WebAssembly (WASM). Es gibt Ressourcenbeschränkungen (nur 1 Thread und 2 GB Speicher), die dies für die starke Aufhebung der Datenwissenschaft unpraktisch machen. JedochDies kann mehr als ausreichend für den Aufbau von Visualisierungen und Aktualisierungen auf der Grundlage der Benutzereingaben sein. Da es im Browser ausgeführt wird, sind für das Internet hosting keine Server erforderlich. Instruments, die Pyodid als Stiftung verwenden, sind interessant zu erforschen, da sie Datenwissenschaftlern die Möglichkeit geben, Python -Code zu schreiben, der direkt auf den Computern der Benutzer ausführt, ohne dass sie außerhalb des Webbrowsers installieren oder ausgeführt werden müssen.

Beiseite, Ich habe mich bisher interessiert an interessiertEin Projekt, das diesen Ansatz ausprobiert hat: stlite Anwesend eine Implementierung von Stromflächen in Browser Auf diese Weise können Sie diese flexiblen und leistungsstarken Apps für eine breite Palette von Benutzern bereitstellen. Eine Kernbegrenzung besteht jedoch darin, dass sich die Stromverstärkung von Stlite (der Port des Stroms nach WASM) unterscheidet, was bedeutet, dass nicht alle Merkmale unterstützt werden und dass die Weiterentwicklung des Projekts von zwei separaten Gruppen abhängt, die entlang kompatibler Linien arbeiten.

Einführung: Marimo

Dies bringt uns zu uns Marimo.

Der Erste Öffentlichkeit Ankündigungen von Marimo waren im Januar 2024, so dass das Projekt sehr neu ist und eine einzigartige Kombination von Funktionen hat:

• Die Schnittstelle ähnelt einer Jupyter Notizbuch was den Benutzern bekannt sein wird.
• Ausführung von Zellen ist reaktivso dass die Aktualisierung einer Zelle alle Zellen erneut umgeben wird, die von ihrer Ausgabe abhängen.
• Benutzereingabe Kann mit einem flexiblen Satz UI -Komponenten erfasst werden.
• Notizbücher können schnell konvertiert werden in Appsden Code verstecken und nur die Eingangs-/Ausgabelemente anzeigen.
• Apps können lokal ausgeführt oder in umgewandelt werden in Statische Webseitenmit WASM/Pyodid.

Marimo gleicht die Kompromisse der Technologie auf eine Weise aus, die intestine für die Fähigkeiten der typischen Datenwissenschaftler geeignet ist:

• Fähigkeiten– Funktionen für Benutzereingaben und visuelle Anzeige sind ziemlich umfangreich. Unterstützung der Benutzereingabeüber Altair- und Handlungsdiagramme.
• Veröffentlichungskosten– Die Bereitstellung als statische Webseiten ist im Grunde kostenlos – keine Server erforderlich
• Benutzerfreundlichkeit– Für Benutzer, die mit Python -Notizbüchern vertraut sind, wird sich Marimo sehr vertraut fühlen und leicht abzuholen.

Veröffentlichung von Marimo -Apps im Internet

Der beste Ort, um mit Marimo zu beginnen, ist das Lesen ihre umfangreiche Dokumentation.

Als einfaches Beispiel für die Artwork der Anzeige, die in der Information Science nützlich sein kann, die aus erklärenden Textual content besteht, die mit interaktiven Shows durchsetzt sind, habe ich ein Barebones erstellt Github -Repository. Probieren Sie es selbst aus Hier .

Benutzer können nur ein bisschen Code verwenden, sondern können:

• Quelldatensätze anhängen
• Generieren Sie Visualisierungen mit flexibler Interaktivität
• Schreiben Sie narrativen Textual content, der ihre Ergebnisse beschreibt
• KOSTENLOS im Internet veröffentlichen (dh mit Github -Seiten)

Weitere Informationen finden Sie in ihrer Dokumentation zum Internet PublishingUnd Template -Repository für die Bereitstellung auf GitHub -Seiten.

Öffentliche App / personal Daten

Diese neue Technologie bietet eine aufregende neue Probability für die Zusammenarbeit – veröffentlichen Sie die App öffentlich für die Welt, aber Benutzer können nur bestimmte Datensätze sehen, auf die sie zugreifen können.

Anstatt für jede App ein dediziertes Daten -Backend zu erstellen, können Benutzerdaten in einem generischen Backend gespeichert werden, auf das sicher authentifiziert und mit einer Python -Consumer -Bibliothek zugegriffen werden kann – alle im Webbrowser des Benutzers enthalten. Beispielsweise erhält der Benutzer einen OAuth -Anmeldeleg, der ihn mit dem Backend authentifiziert und der App ermöglicht, vorübergehend Eingabedaten zuzugreifen.

Als Proof of Idea habe ich eine einfache Visualisierungs -App erstellt, die eine Verbindung zu einer Verbindung herstellt die Cirro -Datenplattformdie an meiner Establishment verwendet wird, um wissenschaftliche Daten zu verwalten. Vollständige Offenlegung: Ich conflict Teil des Groups, das diese Plattform aufgebaut hat, bevor sie als unabhängiges Unternehmen ausging. Auf diese Weise können Benutzer:

• Laden Sie die öffentliche Visualisierungs -App – gehostet auf GitHub -Seiten
• Schließen Sie sich sicher mit ihrem privaten Datenspeicher an
• Laden Sie den entsprechenden Datensatz für die Anzeige
• Teilen Sie einen Hyperlink, der autorisierte Mitarbeiter auf die gleichen Daten leitet

Probieren Sie es selbst aus Hier.

Als Datenwissenschaftler ist dieser Ansatz zur Veröffentlichung kostenloser und Open-Supply-Visualisierungs-Apps, die zur Interaktion mit privaten Datensätzen verwendet werden können. Der Aufbau und Veröffentlichen einer neuen App kann Stunden und Tage statt Wochen und Jahre dauern. Die Forscher können ihre Erkenntnisse schnell mit Mitarbeitern teilen und sie dann in der weiteren Welt veröffentlichen.