dataeval-plots 0.0.9__tar.gz → 0.0.11__tar.gz

{dataeval_plots-0.0.9 → dataeval_plots-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dataeval-plots
-Version: 0.0.9
+Version: 0.0.11
 Summary: DataEval companion package for plotting utilities
 Project-URL: Homepage, https://dataeval.ai/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/
@@ -175,9 +175,94 @@ This enables:
 | `SufficiencyOutput` | "sufficiency" | Learning curves with extrapolation | [dataeval/_workflows.py](../dataeval/src/dataeval/outputs/_workflows.py) |
 | `BaseStatsOutput` | "stats" | Statistical histograms and distributions | [dataeval/_stats.py](../dataeval/src/dataeval/outputs/_stats.py) |
 | `DriftMVDCOutput` | "drift_mvdc" | Drift detection plots (MVDC analysis) | [dataeval/_drift.py](../dataeval/src/dataeval/outputs/_drift.py) |
+| `FeasibilityOutput` | "feasibility" | Which accuracy requirements the evidence demonstrates or rules out | [dataeval/_feasibility.py](../dataeval/src/dataeval/performance/_feasibility.py) |
 
 Each output type implements the `Plottable` protocol and can be plotted using any registered backend.
 
+## Reading the Feasibility Plot
+
+`plot()` draws the result of DataEval's experimental `Feasibility().evaluate(...)`. It answers one question per
+quantity you asked about: for each accuracy or AP requirement, does the evidence demonstrate it, rule it out, or leave
+it unknown?
+
+```python
+from dataeval.performance import Feasibility
+from dataeval_plots import plot
+
+result = Feasibility().evaluate(dataset, target={"accuracy": 0.95}, embeddings=embeddings)
+
+fig = plot(result)  # one band per quantity
+fig = plot(result, plot_evidence=True)  # one row per evidence source, in place of the bands
+```
+
+### What the plot shows
+
+Each quantity gets its own band, with a "Required ..." axis (for example "Required accuracy" or "Required AP") and a
+subtitle that says which models the band judges:
+
+| Subtitle | Judged models |
+|----------|---------------|
+| Models may use the whole image | Models that may use the whole input |
+| Models may use only the embeddings | Models restricted to the embeddings |
+| Models give one answer per group | Models that give one answer per group |
+
+The axis is split into three zones. Each zone classifies the requirements that fall inside it:
+
+- **Demonstrated** runs from the axis minimum up to the lower confidence bound of the best tested model. The band
+  reads "Requirements through *x*% are demonstrated".
+- **Unknown** lies between the other two zones. The evidence neither demonstrates nor rules out these requirements.
+- **Ruled out** runs from the upper confidence bound of the lowest applicable ceiling to the top of the axis. It holds
+  only under the recorded assumptions, and the zone reads "ruled out under the recorded assumptions" wherever the
+  label fits.
+
+Each of your requirements is marked on the axis, and the marker states the determination in words:
+
+| Marker | Meaning |
+|--------|---------|
+| "95% requirement: demonstrated ✓" | The requirement is at or below the lower confidence bound |
+| "not enough evidence ?" | The requirement falls in the unknown zone, and the evidence cannot decide it |
+| "ruled out under the recorded assumptions ✗" | The requirement is above the upper confidence bound of a ceiling |
+| "not ruled out ?" | The requirement also falls in the unknown zone: it is not above any ceiling's upper confidence bound, and no tested model reaches it |
+
+The caption under the band reports the observed score next to the lower confidence bound it supports, for example
+"Your model scored 91.0% on the 2,000 evaluation images. Allowing for sampling uncertainty gives a lower
+confidence bound of 88.5%." The sentence about the observed score appears only when an observed score exists. The
+caption then states that the bounds concern new images drawn from the same population, and that confidence holds
+jointly across the whole evaluation (for example "Confidence is 95% jointly across this evaluation").
+
+Numbers read as DataEval prints them. Bounds are given to 0.1%, a lower bound rounded down and an upper bound rounded
+up, so rounding never overstates what the evidence shows. Requirements and confidence keep their own decimals, such as
+"95.5% requirement" or "Confidence is 97.5%".
+
+When a ceiling bounds the band, the caption adds "Under the recorded assumptions, requirements above *x*% are ruled out
+at the stated confidence." A group-based ceiling carries the extra note that its validity argument awaits lead-scientist
+sign-off.
+
+A ceiling that applies only to narrower models than the band judges never draws a zone. It appears as a note instead,
+for example that the group-based ceiling does not limit models that distinguish individual images.
+
+### Other outcomes
+
+- **Ruled out.** A requirement above the lowest applicable ceiling's upper confidence bound is marked "ruled out
+  under the recorded assumptions ✗". The ruled-out zone covers everything above that bound, and the caption reads
+  "Under the recorded assumptions, requirements above *x*% are ruled out at the stated confidence."
+- **Evidence conflict.** When bounds from different sources contradict each other, the band draws no zones. A dashed
+  warning outline reads "Evidence conflicts: check assumptions", both clashing bounds are marked, and the caption
+  says that the bounds disagree and to check the assumptions, including whether evaluation images entered training.
+  Even when the assumptions hold, the probability that any bound fails is at most the stated alpha (for example 5% at
+  95% confidence).
+- **Bounds at 0% or 100%.** A lower confidence bound of 0% demonstrates nothing and an upper confidence bound of 100%
+  rules nothing out, so neither draws a zone.
+
+### Showing the evidence
+
+`plot_evidence=True` replaces each band with one row per evidence source. Each row shows the observed score as a dot
+and the confidence bound as a tick, with a legend line explaining both: the dot is the score observed on the
+evaluation images, and the tick is the lower (or upper) confidence bound for new images from the same population.
+Evidence that does not apply to the judged models is drawn faint and labeled with the models it applies to. A source
+that produced no bound for the quantity is listed faint as "no bound available", and when no source has a bound the
+view says "No bound is available yet." instead of showing empty axes.
+
 ## Extending the Package
 
 ### Creating Custom Outputs

{dataeval_plots-0.0.9 → dataeval_plots-0.0.11}/README.md

@@ -129,9 +129,94 @@ This enables:
 | `SufficiencyOutput` | "sufficiency" | Learning curves with extrapolation | [dataeval/_workflows.py](../dataeval/src/dataeval/outputs/_workflows.py) |
 | `BaseStatsOutput` | "stats" | Statistical histograms and distributions | [dataeval/_stats.py](../dataeval/src/dataeval/outputs/_stats.py) |
 | `DriftMVDCOutput` | "drift_mvdc" | Drift detection plots (MVDC analysis) | [dataeval/_drift.py](../dataeval/src/dataeval/outputs/_drift.py) |
+| `FeasibilityOutput` | "feasibility" | Which accuracy requirements the evidence demonstrates or rules out | [dataeval/_feasibility.py](../dataeval/src/dataeval/performance/_feasibility.py) |
 
 Each output type implements the `Plottable` protocol and can be plotted using any registered backend.
 
+## Reading the Feasibility Plot
+
+`plot()` draws the result of DataEval's experimental `Feasibility().evaluate(...)`. It answers one question per
+quantity you asked about: for each accuracy or AP requirement, does the evidence demonstrate it, rule it out, or leave
+it unknown?
+
+```python
+from dataeval.performance import Feasibility
+from dataeval_plots import plot
+
+result = Feasibility().evaluate(dataset, target={"accuracy": 0.95}, embeddings=embeddings)
+
+fig = plot(result)  # one band per quantity
+fig = plot(result, plot_evidence=True)  # one row per evidence source, in place of the bands
+```
+
+### What the plot shows
+
+Each quantity gets its own band, with a "Required ..." axis (for example "Required accuracy" or "Required AP") and a
+subtitle that says which models the band judges:
+
+| Subtitle | Judged models |
+|----------|---------------|
+| Models may use the whole image | Models that may use the whole input |
+| Models may use only the embeddings | Models restricted to the embeddings |
+| Models give one answer per group | Models that give one answer per group |
+
+The axis is split into three zones. Each zone classifies the requirements that fall inside it:
+
+- **Demonstrated** runs from the axis minimum up to the lower confidence bound of the best tested model. The band
+  reads "Requirements through *x*% are demonstrated".
+- **Unknown** lies between the other two zones. The evidence neither demonstrates nor rules out these requirements.
+- **Ruled out** runs from the upper confidence bound of the lowest applicable ceiling to the top of the axis. It holds
+  only under the recorded assumptions, and the zone reads "ruled out under the recorded assumptions" wherever the
+  label fits.
+
+Each of your requirements is marked on the axis, and the marker states the determination in words:
+
+| Marker | Meaning |
+|--------|---------|
+| "95% requirement: demonstrated ✓" | The requirement is at or below the lower confidence bound |
+| "not enough evidence ?" | The requirement falls in the unknown zone, and the evidence cannot decide it |
+| "ruled out under the recorded assumptions ✗" | The requirement is above the upper confidence bound of a ceiling |
+| "not ruled out ?" | The requirement also falls in the unknown zone: it is not above any ceiling's upper confidence bound, and no tested model reaches it |
+
+The caption under the band reports the observed score next to the lower confidence bound it supports, for example
+"Your model scored 91.0% on the 2,000 evaluation images. Allowing for sampling uncertainty gives a lower
+confidence bound of 88.5%." The sentence about the observed score appears only when an observed score exists. The
+caption then states that the bounds concern new images drawn from the same population, and that confidence holds
+jointly across the whole evaluation (for example "Confidence is 95% jointly across this evaluation").
+
+Numbers read as DataEval prints them. Bounds are given to 0.1%, a lower bound rounded down and an upper bound rounded
+up, so rounding never overstates what the evidence shows. Requirements and confidence keep their own decimals, such as
+"95.5% requirement" or "Confidence is 97.5%".
+
+When a ceiling bounds the band, the caption adds "Under the recorded assumptions, requirements above *x*% are ruled out
+at the stated confidence." A group-based ceiling carries the extra note that its validity argument awaits lead-scientist
+sign-off.
+
+A ceiling that applies only to narrower models than the band judges never draws a zone. It appears as a note instead,
+for example that the group-based ceiling does not limit models that distinguish individual images.
+
+### Other outcomes
+
+- **Ruled out.** A requirement above the lowest applicable ceiling's upper confidence bound is marked "ruled out
+  under the recorded assumptions ✗". The ruled-out zone covers everything above that bound, and the caption reads
+  "Under the recorded assumptions, requirements above *x*% are ruled out at the stated confidence."
+- **Evidence conflict.** When bounds from different sources contradict each other, the band draws no zones. A dashed
+  warning outline reads "Evidence conflicts: check assumptions", both clashing bounds are marked, and the caption
+  says that the bounds disagree and to check the assumptions, including whether evaluation images entered training.
+  Even when the assumptions hold, the probability that any bound fails is at most the stated alpha (for example 5% at
+  95% confidence).
+- **Bounds at 0% or 100%.** A lower confidence bound of 0% demonstrates nothing and an upper confidence bound of 100%
+  rules nothing out, so neither draws a zone.
+
+### Showing the evidence
+
+`plot_evidence=True` replaces each band with one row per evidence source. Each row shows the observed score as a dot
+and the confidence bound as a tick, with a legend line explaining both: the dot is the score observed on the
+evaluation images, and the tick is the lower (or upper) confidence bound for new images from the same population.
+Evidence that does not apply to the judged models is drawn faint and labeled with the models it applies to. A source
+that produced no bound for the quantity is listed faint as "no bound available", and when no source has a bound the
+view says "No bound is available yet." instead of showing empty axes.
+
 ## Extending the Package
 
 ### Creating Custom Outputs

{dataeval_plots-0.0.9 → dataeval_plots-0.0.11}/src/dataeval_plots/__init__.py

@@ -20,6 +20,7 @@ from dataeval_plots.protocols import (
     PlottableBalance,
     PlottableDiversity,
     PlottableDriftMVDC,
+    PlottableFeasibility,
     PlottableStats,
     PlottableSufficiency,
     PlottableType,
@@ -97,6 +98,31 @@ def plot(
 ) -> Any: ...
 
 
+@overload
+def plot(
+    output: PlottableFeasibility,
+    /,
+    figsize: tuple[float, float] | None = None,
+    backend: str | None = None,
+    *,
+    plot_evidence: bool = False,
+) -> Any:
+    """
+    Plot a feasibility result as one band per quantity.
+
+    Each band classifies accuracy requirements as demonstrated (up to the best tested model's lower confidence
+    bound), unknown, or ruled out (above the lowest applicable ceiling's upper confidence bound, under the recorded
+    assumptions). Confidence holds jointly across the whole evaluation.
+
+    Parameters
+    ----------
+    plot_evidence : bool, default False
+        Replace each band with one row per evidence source, showing the observed score as a dot and the confidence
+        bound as a tick.
+    """
+    ...
+
+
 @overload
 def plot(
     output: Dataset,
@@ -104,10 +130,10 @@ def plot(
     figsize: tuple[float, float] | None = None,
     backend: str | None = None,
     *,
-    indices: Sequence[int],
+    indices: Sequence[int] | None = None,
     images_per_row: int = 3,
     show_labels: bool = False,
-    show_metadata: bool = False,
+    show_metadata: bool | Sequence[str] = False,
     additional_metadata: Sequence[dict[str, Any]] | None = None,
 ) -> Any: ...
 
@@ -138,7 +164,7 @@ def plot(
         Plotting backend ('matplotlib', 'seaborn', 'plotly', 'altair').
         If None, uses default backend.
     **kwargs
-        Backend-specific plotting parameters
+        Backend-specific plotting parameters, such as ``plot_evidence`` for feasibility outputs
 
     Returns
     -------

{dataeval_plots-0.0.9 → dataeval_plots-0.0.11}/src/dataeval_plots/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.9'
-__version_tuple__ = version_tuple = (0, 0, 9)
+__version__ = version = '0.0.11'
+__version_tuple__ = version_tuple = (0, 0, 11)
 
 __commit_id__ = commit_id = None

{dataeval_plots-0.0.9 → dataeval_plots-0.0.11}/src/dataeval_plots/backends/_altair.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import textwrap
 from collections.abc import Iterable, Mapping, Sequence
 from typing import Any, Literal
 
@@ -9,12 +10,17 @@ import numpy as np
 import polars as pl
 from numpy.typing import NDArray
 
+from dataeval_plots.backends import _feasibility_layout as layout
 from dataeval_plots.backends._base import BasePlottingBackend
 from dataeval_plots.backends._shared import (
     CHANNELWISE_METRICS,
+    FEASIBILITY_COLORS,
+    FEASIBILITY_CONFLICT_TEXT,
+    FeasibilityBand,
     calculate_projection,
     draw_bounding_boxes,
     extract_boxes_and_labels,
+    feasibility_zones,
     format_label_from_target,
     image_to_base64_png,
     image_to_hwc,
@@ -25,6 +31,7 @@ from dataeval_plots.backends._shared import (
     prepare_balance_data,
     prepare_diversity_data,
     prepare_drift_data,
+    prepare_feasibility_data,
     project_steps,
     validate_class_names,
 )
@@ -33,10 +40,149 @@ from dataeval_plots.protocols import (
     PlottableBalance,
     PlottableDiversity,
     PlottableDriftMVDC,
+    PlottableFeasibility,
     PlottableStats,
     PlottableSufficiency,
 )
 
+# Feasibility: one layer per mark, positioned in the band's data units (y in inches) like the matplotlib backend.
+# DejaVu Sans, as matplotlib, where installed: the layout is measured in it and it has every glyph used.
+_FONT = "DejaVu Sans, sans-serif"
+
+
+def _mark(layers: list[Any], axes: tuple[Any, Any], mark: str, row: dict[str, Any], **props: Any) -> None:
+    """Draw ``mark`` once at ``row``'s x and y on the band's ``axes``, with its x2, y2 and text if given."""
+    import altair as alt
+
+    x, y = axes
+    channels = {k: "text:N" if k == "text" else k for k in ("x2", "y2", "text") if k in row}
+    layers.append(getattr(alt.Chart(alt.Data(values=[row])), f"mark_{mark}")(**props).encode(x=x, y=y, **channels))
+
+
+def _text(
+    layers: list[Any],
+    axes: tuple[Any, Any],
+    x: float,
+    y: float,
+    text: str,
+    size: float = layout.LABEL_PT,
+    backing: float | None = None,
+    **props: Any,
+) -> None:
+    """Text on the band's axes, centered unless ``align`` or ``baseline`` say otherwise; given the x units per inch
+    as ``backing``, a white box behind it keeps it legible over lines."""
+    lines, line_h = text.count("\n") + 1, layout.px(size) * 1.25
+    align, baseline = props.setdefault("align", "center"), props.setdefault("baseline", "middle")
+    if backing is not None:
+        bold = 1.1 if props.get("fontWeight") == "bold" else 1.0  # measured at regular weight
+        w, h = layout.text_width(text, size) * bold + 0.04, lines * line_h / layout.PX
+        x0 = x - {"left": 0.02, "center": w / 2, "right": w - 0.02}[align] * backing
+        y0 = y - {"top": h, "middle": h / 2, "bottom": 0}[baseline]
+        _mark(layers, axes, "rect", {"x": x0, "x2": x0 + w * backing, "y": y0, "y2": y0 + h}, color="white")
+    # Vega puts the first line, not the block, at a middle baseline
+    dy = -(lines - 1) * line_h / 2 if baseline == "middle" else 0
+    props = {"color": FEASIBILITY_COLORS["ink"], "fontSize": layout.px(size), "lineHeight": line_h, "dy": dy, **props}
+    _mark(layers, axes, "text", {"x": x, "y": y, "text": text}, lineBreak="\n", font=_FONT, **props)
+
+
+def _side(x: float, text: str, prefer_left: bool, x_range: tuple[float, float], ax_w: float) -> tuple[float, str]:
+    """Where a label beside its mark starts and how it aligns: the preferred side, unless that leaves the axes."""
+    pad = layout.PAD * (x_range[1] - x_range[0]) / ax_w
+    return (x - pad, "right") if layout.goes_left(x, text, prefer_left, x_range, ax_w) else (x + pad, "left")
+
+
+def _altair_requirements(
+    layers: list[Any],
+    axes: tuple[Any, Any],
+    placed: list[layout.Placed],
+    per_in: float,
+    y0: float,
+    y_label: float,
+) -> None:
+    """Dashed requirement lines from ``y0`` up to their labels' level, labels on top."""
+    ink = FEASIBILITY_COLORS["ink"]
+    for x, text, ha, level in placed:
+        y = y_label + level * layout.LEVEL
+        _mark(
+            layers, axes, "rule", {"x": x, "y": y0, "y2": y}, color=ink, strokeWidth=layout.px(1.2), strokeDash=[4, 3]
+        )
+        _mark(
+            layers, axes, "point", {"x": x, "y": y}, shape="triangle-down", filled=True, size=60, color=ink, opacity=1
+        )
+        dx = layout.PAD * per_in if ha == "right" else -layout.PAD * per_in
+        _text(layers, axes, x + dx, y + 0.06, text, align=ha, baseline="bottom")
+
+
+def _altair_band(
+    layers: list[Any],
+    axes: tuple[Any, Any],
+    band: FeasibilityBand,
+    ax_w: float,
+    placed: list[layout.Placed],
+) -> None:
+    """Zones, boundaries and requirement markers of one band."""
+    colors = FEASIBILITY_COLORS
+    lo, hi = band.x_range
+    per_in = (hi - lo) / ax_w
+    y0, y1 = layout.BOUNDARY, layout.BOUNDARY + layout.BAR
+    for kind, start, end, label in feasibility_zones(band):
+        zone = {"x": start, "x2": end, "y": y0, "y2": y1}
+        _mark(layers, axes, "rect", zone, color=colors[f"{kind}_fill"], stroke="white", strokeWidth=layout.px(1.5))
+        fit = layout.zone_label(band, start, end, label, per_in)
+        if fit:
+            _text(layers, axes, fit[0], y0 + layout.BAR / 2, fit[1])
+    if band.conflict:
+        dashed = {"stroke": colors["warning"], "strokeWidth": layout.px(2), "strokeDash": [6, 4]}
+        _mark(layers, axes, "rect", {"x": lo, "x2": hi, "y": y0, "y2": y1}, fillOpacity=0, **dashed)
+    for x, text, kind, left in band.boundary_labels:
+        color = colors["demonstrated" if kind == "lower" else "ruled_out"]
+        _mark(layers, axes, "rule", {"x": x, "y": y0 - 0.06, "y2": y1 + 0.06}, color=color, strokeWidth=layout.px(2.5))
+        at, align = _side(x, text, left, band.x_range, ax_w)
+        _text(layers, axes, at, y0 - 0.1, text, align=align, baseline="top")
+    _altair_requirements(layers, axes, placed, per_in, y0, y1 + 0.2)
+    if band.conflict:  # over the requirement and boundary lines
+        center = ((lo + hi) / 2, y0 + layout.BAR / 2)
+        _text(layers, axes, *center, FEASIBILITY_CONFLICT_TEXT, 11, per_in, fontWeight="bold")
+
+
+def _altair_evidence(
+    layers: list[Any],
+    axes: tuple[Any, Any],
+    band: FeasibilityBand,
+    x_range: tuple[float, float],
+    ax_w: float,
+    placed: list[layout.Placed],
+) -> None:
+    """One row per source: a tick at its bound, a dot at its observed score, both labeled."""
+    colors, muted = FEASIBILITY_COLORS, FEASIBILITY_COLORS["ink_muted"]
+    per_in = (x_range[1] - x_range[0]) / ax_w
+    rows_top, ys = layout.evidence_rows(band)
+    _altair_requirements(layers, axes, placed, per_in, 0, rows_top + 0.12)
+    at = x_range[0] + layout.PAD * per_in  # text in place of marks
+    if band.evidence_note:
+        _text(
+            layers, axes, at, rows_top - layout.ROW / 2, band.evidence_note, backing=per_in, align="left", color=muted
+        )
+    for y, row in zip(ys, band.evidence):
+        # Bound labeled below, observed above, so the two never collide; a white backing keeps them legible over
+        # the requirement lines
+        ink = {"color": muted if row.faint else colors["ink"], "backing": per_in}
+        source = textwrap.fill(row.label, layout.SOURCE_WRAP)
+        _text(layers, axes, x_range[0] - 0.1 * per_in, y, source, align="right", color=ink["color"])
+        if row.bound is None:
+            _text(layers, axes, at, y, row.bound_label, backing=per_in, align="left", color=muted)
+            continue
+        color = colors["demonstrated" if row.bound_type == "lower" else "ruled_out"]
+        mark = {"color": color, "opacity": 0.35 if row.faint else 1.0}
+        _mark(layers, axes, "rule", {"x": row.bound, "y": y - 0.12, "y2": y + 0.12}, strokeWidth=layout.px(2.5), **mark)
+        side, align = _side(row.bound, row.bound_label, row.bound_left, x_range, ax_w)
+        _text(layers, axes, side, y - 0.14, row.bound_label, align=align, baseline="top", **ink)
+        if row.observed is not None and row.observed_label is not None:
+            _mark(layers, axes, "rule", {"x": row.bound, "x2": row.observed, "y": y}, strokeWidth=layout.px(3), **mark)
+            _mark(layers, axes, "circle", {"x": row.observed, "y": y}, size=100, **mark)
+            side, align = _side(row.observed, row.observed_label, not row.bound_left, x_range, ax_w)
+            _text(layers, axes, side, y + 0.29, row.observed_label, align=align, baseline="top", **ink)
+
 
 class AltairBackend(BasePlottingBackend):
     """Altair implementation of plotting backend."""
@@ -676,11 +822,11 @@ class AltairBackend(BasePlottingBackend):
     def _plot_image_grid(
         self,
         dataset: Dataset,
-        indices: Sequence[int],
+        indices: Sequence[int] | None = None,
         images_per_row: int = 3,
         figsize: tuple[float, float] | None = None,
         show_labels: bool = False,
-        show_metadata: bool = False,
+        show_metadata: bool | Sequence[str] = False,
         additional_metadata: Sequence[dict[str, Any]] | None = None,
     ) -> Any:
         """
@@ -690,16 +836,17 @@ class AltairBackend(BasePlottingBackend):
         ----------
         dataset : Dataset
             MAITE-compatible dataset containing images
-        indices : Sequence[int]
-            Indices of images to plot from the dataset
+        indices : Sequence[int] or None, default None
+            Indices of images to plot from the dataset. None plots every item.
         images_per_row : int, default 3
             Number of images to display per row
         figsize : tuple[float, float] or None, default None
             Figure size in inches (width, height)
         show_labels : bool, default False
             Whether to display labels extracted from targets
-        show_metadata : bool, default False
-            Whether to display metadata from the dataset items
+        show_metadata : bool or Sequence[str], default False
+            Whether to display metadata from the dataset items. A sequence of keys
+            displays only those, in the order given.
         additional_metadata : Sequence[dict[str, Any]] or None, default None
             Additional metadata to display for each image (must match length of indices)
 
@@ -716,6 +863,8 @@ class AltairBackend(BasePlottingBackend):
         import altair as alt
         import pandas as pd
 
+        indices = range(len(dataset)) if indices is None else indices
+
         # Validate additional_metadata length
         if additional_metadata is not None and len(additional_metadata) != len(indices):
             raise ValueError(
@@ -790,9 +939,9 @@ class AltairBackend(BasePlottingBackend):
                     title_parts.append(label_str)
 
             if show_metadata and metadata:
-                # Format metadata as key: value pairs
-                metadata_strs = [f"{k}: {v}" for k, v in metadata.items()]
-                title_parts.extend(metadata_strs)
+                # Every key, or just the named ones, as key: value pairs
+                keys = metadata if isinstance(show_metadata, bool) else [k for k in show_metadata if k in metadata]
+                title_parts.extend(f"{k}: {metadata[k]}" for k in keys)
 
             # Create title or use empty string
             title = " | ".join(title_parts) if title_parts else ""
@@ -1014,3 +1163,98 @@ class AltairBackend(BasePlottingBackend):
             grid = grid.properties(title=title)
 
         return grid
+
+    def _plot_feasibility(
+        self,
+        output: PlottableFeasibility,
+        figsize: tuple[float, float] | None = None,
+        plot_evidence: bool = False,
+    ) -> Any:  # alt.VConcatChart
+        """
+        Plot each quantity's requirements as a band of demonstrated, unknown and ruled-out zones.
+
+        Parameters
+        ----------
+        output : PlottableFeasibility
+            The feasibility output object to plot
+        figsize : tuple[float, float] or None, default None
+            Figure size in inches (width, height), drawn at 100 pixels per inch. If None, 9 inches wide and as tall
+            as the bands need. An explicit height stretches or squeezes the band views to meet it; captions keep
+            their height.
+        plot_evidence : bool, default False
+            Whether to plot each source's observed score and confidence bound instead of the bands
+
+        Returns
+        -------
+        alt.VConcatChart
+            One band chart and its caption per quantity, stacked
+        """
+        import altair as alt
+
+        ink, muted = FEASIBILITY_COLORS["ink"], FEASIBILITY_COLORS["ink_muted"]
+        width = figsize[0] if figsize else 9.0
+        gutter, ax_w, height, blocks = layout.blocks(prepare_feasibility_data(output), plot_evidence, width)
+        # Only the band views stretch, so the rest keeps its height and the total meets the requested one
+        views = sum(block[3] for block in blocks)
+        stretch = max(figsize[1] - (height - views), 0.1) / views if figsize else 1.0
+        view = alt.ViewBackground(stroke=None)  # per chart, so the result stays composable
+
+        charts = []
+        for band, x_range, xlabel, ax_h, placed, texts in blocks:
+            axis = alt.Axis(
+                format=".0%",
+                tickCount=max(2, round(ax_w / 1.3)),  # about matplotlib's tick density
+                tickMinStep=0.01,
+                title=xlabel,
+                titleFont=_FONT,
+                titleFontSize=layout.px(11),
+                titleFontWeight="bold",
+                titleColor=ink,
+                labelFont=_FONT,
+                labelFontSize=layout.px(layout.LABEL_PT),
+                labelColor=muted,
+                tickColor=muted,
+                domainColor=muted,
+                grid=plot_evidence,
+                gridColor="#e4e3df",
+            )
+            axes = (
+                alt.X("x:Q", scale=alt.Scale(domain=list(x_range), nice=False, zero=False), axis=axis),
+                alt.Y("y:Q", scale=alt.Scale(domain=[0, ax_h], nice=False, zero=False), axis=None),
+            )
+            layers: list[Any] = []
+            if plot_evidence:
+                _altair_evidence(layers, axes, band, x_range, ax_w, placed)
+            else:
+                _altair_band(layers, axes, band, ax_w, placed)
+            title = alt.TitleParams(
+                band.subtitle,
+                anchor="start",
+                frame="group",
+                font=_FONT,
+                fontSize=layout.px(10),
+                fontWeight="normal",
+                color=muted,
+            )
+            size = {"width": ax_w * layout.PX, "height": ax_h * layout.PX * stretch}
+            charts.append(alt.layer(*layers).properties(title=title, view=view, **size))
+
+            # Below the axes, from the figure margin: the evidence legend, the caption paragraph, then the notes
+            lines, top = [], 0.0
+            for text, points, color in texts:
+                style = {
+                    "font": _FONT,
+                    "fontSize": layout.px(points),
+                    "color": color,
+                    "lineHeight": layout.LINE * layout.PX,
+                }
+                x, y = alt.value(-(gutter - layout.MARGIN) * layout.PX), alt.value(top * layout.PX)
+                lines.append(
+                    alt.Chart(alt.Data(values=[{"text": text}]))
+                    .mark_text(align="left", baseline="top", lineBreak="\n", **style)
+                    .encode(x=x, y=y, text="text:N")
+                )
+                top += layout.text_height(text)
+            charts.append(alt.layer(*lines).properties(width=ax_w * layout.PX, height=top * layout.PX, view=view))
+
+        return alt.vconcat(*charts, spacing=10)