dantinox.visualization

The visualization module uses a class-level registry. Charts are registered with @Visualizer.register and auto-discovered at import time. No configuration required to use built-in charts.

---

Visualizer

class dantinox.visualization.visualizer.Visualizer(config: RenderConfig | None = None)

Bases: object

Central chart registry and rendering orchestrator.

The Visualizer maintains a class-level registry of Chart subclasses. Built-in charts are registered automatically on import. User charts are registered with the register() decorator.

Quick-start:

from dantinox.visualization import Visualizer

viz = Visualizer()
viz.render(report, out_dir="plots")           # all charts
viz.render(report, charts=["pareto", "radar"])# specific charts

Adding a custom chart:

from dantinox.visualization import Visualizer
from dantinox.visualization.base import Chart

@Visualizer.register
class MyChart(Chart):
    name    = "my_chart"
    accepts = object

    def _render_mpl(self, data, config, fig, ax):
        ax.bar([1, 2], [3, 4])

viz = Visualizer()
viz.render(data, charts=["my_chart"])

classmethod register(chart_cls: type[Chart]) → type[Chart]

Register a Chart subclass. Can be used as a decorator.

classmethod available_charts() → list[str]

Return the names of all registered charts.

render(data: Any, *, charts: list[str] | None = None, out_dir: str = 'plots', config: RenderConfig | None = None) → dict[str, Path]

Render one or more charts and write them to out_dir.

Parameters:

• data – Any data understood by the registered charts (e.g. SuiteReport, pandas.DataFrame, or a CSV path).

• charts – Names of charts to render. Renders all registered charts when omitted.

• out_dir – Directory for output files (created if absent).

• config – Override the instance-level RenderConfig.

Returns:

{chart_name: output_path} for every chart that succeeded.

---

Base types

class dantinox.visualization.base.RenderConfig(backend: str = 'matplotlib', fmt: str = 'png', dpi: int = 150, width: float = 10.0, height: float = 6.0, style: str = 'publication')

Bases: object

Controls how a Chart renders and saves its output.

Attributes

backend : Plotting engine — "matplotlib" (default) or "plotly". fmt : Output file format — "png" | "pdf" | "svg". dpi : Raster resolution (ignored for vector formats). width : Figure width in inches. height : Figure height in inches. style : Named style preset — "publication" | "dark" | "minimal".

backend: str = 'matplotlib'

fmt: str = 'png'

dpi: int = 150

width: float = 10.0

height: float = 6.0

style: str = 'publication'

class dantinox.visualization.base.Chart

Bases: ABC

Abstract base for all DantinoX visualization charts.

Implementing a new chart requires only two overrides:

class AccuracyChart(Chart):
    name     = "accuracy"
    accepts  = SuiteReport          # or pd.DataFrame, list[dict], …

    def _render_mpl(self, data, config, fig, ax):
        ax.plot(data.epochs, data.accuracy)
        ax.set_title("Accuracy over epochs")

The chart is then automatically available through the Visualizer registry once imported:

from dantinox.visualization import Visualizer
Visualizer.register(AccuracyChart)

name: ClassVar[str]

accepts: ClassVar[type]

render(data: Any, config: RenderConfig, out_path: Path) → Path

Render the chart and write it to out_path.

Dispatches to the appropriate backend method based on config.backend. Returns the resolved output path.

---

Built-in charts

class dantinox.visualization.charts.training.TrainingCurveChart

Bases: Chart

Plot training (and optional validation) loss over epochs or steps.

Accepts

pandas.DataFrame

Must contain a numeric loss column. Optional val_loss and epoch / step columns are used automatically when present.

str

Path to a CSV with the same schema.

Example:

from dantinox.visualization import Visualizer
Visualizer().render(report, charts=["training_curve"], out_dir="plots")

name: ClassVar[str] = 'training_curve'

accepts

alias of object

render(data: Any, config: RenderConfig, out_path: Any) → Any

Render the chart and write it to out_path.

Dispatches to the appropriate backend method based on config.backend. Returns the resolved output path.

class dantinox.visualization.charts.throughput.ThroughputChart

Bases: Chart

Tokens/s vs sequence length — one line per attention type or model.

Accepts

SuiteReport or pandas.DataFrame

A DataFrame must contain columns tps_seq{L} for each sequence length and optionally a type column for colour-coding.

name: ClassVar[str] = 'throughput'

accepts

alias of object

class dantinox.visualization.charts.throughput.ThroughputBatchChart

Bases: Chart

Tokens/s vs batch size — shows how well the model scales with parallelism.

Accepts

SuiteReport or pandas.DataFrame

Must contain columns tps_bs{B} for each batch size.

name: ClassVar[str] = 'throughput_batch'

accepts

alias of object

class dantinox.visualization.charts.latency.LatencyChart

Bases: Chart

Throughput (tok/s) vs latency (ms) scatter — the efficiency frontier.

Points above and to the left are Pareto-dominant. A dashed frontier curve is drawn automatically.

Accepts

SuiteReport or pandas.DataFrame

Must contain latency_mean_ms and throughput_tps columns. Optional type column used for colour-coding.

name: ClassVar[str] = 'latency'

accepts

alias of object

class dantinox.visualization.charts.pareto.ParetoChart(x_col: str = 'throughput_tps', y_col: str = 'perplexity', label_col: str = 'run', size_col: str | None = None)

Bases: Chart

Quality vs efficiency Pareto chart.

Plots perplexity (y-axis, lower is better) against throughput or a model-size metric (x-axis, higher is better), revealing the Pareto frontier of quality-vs-efficiency trade-offs.

Parameters:

• x_col – Column name for the efficiency axis (default: "throughput_tps").

• y_col – Column name for the quality axis (default: "perplexity").

• label_col – Column used to annotate each point (default: "run").

• size_col – Column used to size markers (e.g. "n_params"). Optional.

Example:

ParetoChart(x_col="throughput_tps", y_col="perplexity")

name: ClassVar[str] = 'pareto'

accepts

alias of object

class dantinox.visualization.charts.radar.RadarChart(metrics: list[str] | None = None, model_col: str = 'run')

Bases: Chart

Spider / radar chart for multi-task benchmark comparison.

Each spoke represents one benchmark metric; each series represents one model or configuration. Values are automatically normalised to [0, 1].

Accepts

SuiteReport or pandas.DataFrame

DataFrame where each row is a model and each column is a metric. Specify which columns to show via metrics constructor argument.

param metrics:

Column names to include as spokes. Defaults to all numeric columns.

param model_col:

Column used to label series (default: "run").

Example:

RadarChart(metrics=["perplexity", "throughput_tps", "prefill_mean_ms"])

name: ClassVar[str] = 'radar'

accepts

alias of object

render(data: Any, config: RenderConfig, out_path: Any) → Any

Render the chart and write it to out_path.

Dispatches to the appropriate backend method based on config.backend. Returns the resolved output path.

---

Quick reference

import pandas as pd
from dantinox.visualization import Visualizer, RenderConfig

df = pd.read_csv("benchmark_results.csv")

# Render all registered default-constructible charts
Visualizer().render(df, out_dir="plots/")

# Specific charts with custom config
cfg = RenderConfig(backend="matplotlib", fmt="pdf", style="publication", dpi=300)
Visualizer().render(df, charts=["throughput", "pareto"], out_dir="paper_plots/", config=cfg)

# Radar chart (requires explicit instantiation — not auto-rendered)
from dantinox.visualization import RadarChart, Visualizer
radar = RadarChart(metrics=["peak_tps", "perplexity", "prefill_mean_ms"])
Visualizer(extra_charts=[radar]).render(df, charts=["radar"], out_dir="plots/")

Style presets

style	Use case
"publication"	LaTeX-compatible, high-DPI, serif fonts
"dark"	Presentations, dark-mode slides
"minimal"	Lightweight, no gridlines

Chart registry

from dantinox.visualization import Visualizer

# List all registered chart names
print(list(Visualizer._registry.keys()))
# ['training_curve', 'throughput', 'throughput_batch', 'latency', 'pareto', 'radar']