Add 321 text-to-video energy reports from Video Killed the Energy Budget

data/video_killed_the_energy_budget/conversion/exp_all_wan/converter.py

@@ -0,0 +1,226 @@
+"""Convert exp_wan_all.csv into BoAmps energy reports.
+
+One report is produced per row (see exp_all_wan/mapping_info.csv and
+exp_all_wan/mapping_extra_info.md for the row-to-report cardinality and
+per-field mapping rationale).
+"""
+
+import argparse
+import json
+import re
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+import polars as pl
+
+PAPER_TITLE = (
+    "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes "
+    "of Open Text-to-Video Models"
+)
+PUBLISHER_NAME = "Julien Delavande, Regis Pierrard, Sasha Luccioni"
+FOUNDATION_MODEL_URI = "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers"
+PROMPT_CHAR_COUNT = 213
+
+
+def load_sources(files: list[str]) -> pl.DataFrame:
+    return pl.concat([pl.read_csv(f, infer_schema_length=None) for f in files])
+
+
+def fmt_num(value):
+    if value is None:
+        return None
+    if isinstance(value, float):
+        if value != value:  # NaN
+            return None
+        if value == int(value):
+            return int(value)
+    return value
+
+
+def extract_timestamp(name_csv: str) -> str:
+    match = re.search(r"(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.csv$", name_csv)
+    dt = datetime.strptime(match.group(1), "%Y-%m-%d_%H-%M-%S")
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def parse_parameters_number(model_name: str):
+    match = re.search(r"(\d+\.?\d*)[bB]$", model_name)
+    if match:
+        return fmt_num(float(match.group(1)))
+    return None
+
+
+def build_header(row: dict) -> dict:
+    return {
+        "licensing": "Creative Commons 4.0",
+        "formatVersion": "0.1",
+        "reportId": str(uuid.uuid4()),
+        "reportDatetime": extract_timestamp(row["name_csv"]),
+        "reportStatus": "final",
+        "publisher": {
+            "name": PUBLISHER_NAME,
+            "projectName": PAPER_TITLE,
+            "confidentialityLevel": "public",
+        },
+    }
+
+
+def build_task(row: dict) -> dict:
+    return {
+        "taskStage": "inference",
+        "taskFamily": "text to video generation",
+        "nbRequest": 1,
+        "taskDescription": (
+            f"Text-to-video generation with {row['model_name']}. "
+            f"Output: {row['width']}x{row['height']}, {row['num_frames']} frames @ "
+            f"{row['fps']} fps, {row['steps']} diffusion steps, "
+            f"guidance_scale={row['guidance_scale']}. Part of a scaling-law parameter "
+            f"sweep varying '{row['parameter']}' (run: {row['name_csv']})."
+        ),
+    }
+
+
+def build_algorithms(row: dict) -> list[dict]:
+    algorithm = {
+        "algorithmType": "diffusion model",
+        "foundationModelName": row["model_name"],
+        "foundationModelUri": FOUNDATION_MODEL_URI,
+        "framework": "diffusers",
+    }
+    parameters_number = parse_parameters_number(row["model_name"])
+    if parameters_number is not None:
+        algorithm["parametersNumber"] = parameters_number
+    return [algorithm]
+
+
+def build_dataset(row: dict) -> list[dict]:
+    return [
+        {
+            "dataUsage": "input",
+            "dataType": "text",
+            "dataFormat": "text",
+            "dataQuantity": PROMPT_CHAR_COUNT,
+        },
+        {
+            "dataUsage": "output",
+            "dataType": "video",
+            "dataQuantity": 1,
+        },
+    ]
+
+
+def build_measures(row: dict) -> list[dict]:
+    timestamp = extract_timestamp(row["name_csv"])
+    duration = fmt_num(row["duration_generate"])
+    common = {
+        "measurementMethod": "codecarbon",
+        "measurementDuration": duration,
+        "measurementDateTime": timestamp,
+    }
+    return [
+        {
+            **common,
+            "gpuTrackingMode": "nvml",
+            "powerConsumption": fmt_num(row["energy_generate_gpu"]),
+        },
+        {
+            **common,
+            "cpuTrackingMode": "rapl",
+            "powerConsumption": fmt_num(row["energy_generate_cpu"]),
+        },
+        {
+            **common,
+            "powerConsumption": fmt_num(row["energy_generate_ram"]),
+        },
+    ]
+
+
+def build_system(row: dict) -> dict:
+    return {"os": "linux"}
+
+
+def build_software(row: dict) -> dict:
+    return {"language": "python"}
+
+
+def build_infrastructure(row: dict) -> dict:
+    return {"infraType": "onPremise"}
+
+
+def build_components(row: dict) -> list[dict]:
+    return [
+        {
+            "componentName": row["cpu_model"],
+            "componentType": "cpu",
+            "nbComponent": int(row["cpu_count"]),
+            "manufacturer": "amd",
+            "family": "epyc",
+            "series": "7r13",
+        },
+        {
+            "componentName": row["gpu_model"],
+            "componentType": "gpu",
+            "nbComponent": int(row["gpu_count"]),
+            "memorySize": 80,
+            "manufacturer": "nvidia",
+            "family": "h100",
+            "series": "sxm",
+        },
+        {
+            "componentType": "ram",
+            "nbComponent": 1,
+        },
+    ]
+
+
+def build_report(row: dict) -> dict:
+    return {
+        "header": build_header(row),
+        "task": {
+            **build_task(row),
+            "algorithms": build_algorithms(row),
+            "dataset": build_dataset(row),
+        },
+        "measures": build_measures(row),
+        "system": build_system(row),
+        "software": build_software(row),
+        "infrastructure": {
+            **build_infrastructure(row),
+            "components": build_components(row),
+        },
+        "quality": "high",
+    }
+
+
+def output_filename(row: dict) -> str:
+    stem = row["name_csv"]
+    if stem.endswith(".csv"):
+        stem = stem[: -len(".csv")]
+    return f"{stem}.json"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("sources", nargs="+")
+    parser.add_argument("--output", default="public_data_conversion/output")
+    args = parser.parse_args()
+
+    df = load_sources(args.sources)
+    out_dir = Path(args.output)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    rows = df.to_dicts()
+
+    filenames = [output_filename(row) for row in rows]
+    assert len(set(filenames)) == len(rows), "filename collisions detected"
+
+    for row, filename in zip(rows, filenames):
+        report = build_report(row)
+        (out_dir / filename).write_text(json.dumps(report, indent=2))
+
+    print(f"Wrote {len(rows)} reports to {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

data/video_killed_the_energy_budget/conversion/exp_all_wan/mapping_extra_info.md

@@ -0,0 +1,248 @@
+# Mapping Extra Info — exp_wan_all.csv → BoAmps
+
+This mapping is a variant of the sibling mapping in `public_data_conversion/mapping_info.csv` /
+`mapping_extra_info.md` (for `text2video_energy_benchmark.csv`), adapted for a structurally
+different source file from the **same paper**. See the "Differences from the sibling mapping"
+section below for a quick diff.
+
+## Source Data
+
+- File: `public_data_conversion/exp_wan_all.csv`
+- Format: CSV, comma-delimited, UTF-8, single file, header row.
+- 314 rows, 19 columns, **no null values anywhere**.
+- Source paper: *"Video Killed the Energy Budget: Characterizing the Latency and Power Regimes
+  of Open Text-to-Video Models"* by Julien Delavande, Regis Pierrard, Sasha Luccioni
+  (verified via `2509.19222v1.pdf` in this directory — same paper as the sibling mapping).
+- This file covers the paper's **fine-grained scaling-law validation experiments on
+  WAN2.1-T2V-1.3B** ("we validate these predictions through fine-grained experiments on
+  WAN2.1-T2V, showing quadratic growth with spatial and temporal dimensions, and linear scaling
+  with the number of denoising steps"), *not* the 6/7-model cross-comparison benchmark that the
+  sibling mapping covers.
+
+## Row-to-Report Cardinality
+
+**One BoAmps report per row.** 314 reports total.
+
+Each row is a genuinely distinct experiment configuration — a single point in a systematic
+parameter sweep — not a repeated measurement of the same task. The `parameter` column names
+which single dimension was varied for that row, holding the other two fixed at their default:
+
+| `parameter` value | rows | varies | held constant |
+|---|---|---|---|
+| `frames` | 100 | `num_frames` (1–100) | `steps=50`, `height=720`, `width=1280` |
+| `res` | 14 | `height`/`width` (14 resolution pairs, 240×256 up to 1008×1792) | `num_frames=81`, `steps=50` |
+| `steps` | 200 | `steps` (1–200) | `num_frames=50`, `height=720`, `width=1280` |
+
+`model_name` (`WAN2.1-T2V-1.3B`), `guidance_scale` (5.0), `fps` (15), `runs` (5), `warmup` (1),
+`cpu_count`/`cpu_model`/`gpu_count`/`gpu_model` are constant across **all** 314 rows — confirmed
+via full-file unique-value scan. This means, unlike the sibling mapping, **no CONDITIONAL /
+platform-discriminator logic is needed anywhere** in this mapping: there is only one model and
+one hardware configuration in the whole file.
+
+Each row's `duration_generate` / `energy_generate_*` values are already aggregated over the row's
+5 measured runs (`runs=5`, `warmup=1`, excluded) — same assumption as the sibling mapping, carried
+over unverified (the source doesn't state sum vs. mean, but since every row is used as a single
+value it doesn't matter for the mapping — no per-row summation across rows is needed here since
+cardinality is 1:1).
+
+## Key Column Semantics
+
+| Column | Unit | Description |
+|---|---|---|
+| `parameter` | — | Which dimension this row's sweep varies: `frames`, `res`, or `steps` |
+| `name_csv` | — | Original per-run result filename, e.g. `exp7_frames_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_frames78_2025-08-05_20-51-54.csv`. Unique per row (314/314). Encodes the experiment id (`exp7`/`exp8`/`exp10`), swept parameter, model, prompt id (always `prompt1`), the swept value, and a `YYYY-MM-DD_HH-MM-SS` timestamp of when that run completed |
+| `duration_generate` | seconds | Wall-clock time for the generation phase of this run |
+| `energy_generate_gpu/cpu/ram` | kWh | Energy consumed by GPU/CPU/RAM during the generation phase of this run |
+| `runs` / `warmup` | count | 5 measured runs / 1 warmup iteration for this row — constant across all rows; already baked into the reported duration/energy values |
+| `height`, `width`, `num_frames`, `steps`, `fps`, `guidance_scale` | — | Generation parameters for this specific run |
+
+Columns present in the sibling CSV but **absent here**: `prompt`, `negative_prompt`,
+`model_hf_page`, `energy_upsample_*`/`energy_denoise_*`, `duration_upsample`/`duration_denoise`,
+`adapter_repo`/`adapter_ckpt`/`base_model`, `upsample_model_name`, `downscaled_width/height`,
+`generate_steps`, `denoise_steps`, `denoise_strength`, `decode_timestep`,
+`image_cond_noise_scale`. None of these are needed here since this file has only one model
+(WAN2.1-T2V-1.3B, which uses none of the LTX-Video/AnimateDiff-specific extra phases or adapters).
+
+## Energy & Duration Conversions
+
+**No unit conversion needed** — same conclusion as the sibling mapping, re-verified on this file:
+for a `res`-sweep row at the largest resolution (1008×1792, `duration_generate` = 1336.69 s,
+`energy_generate_gpu` = 0.257332), implied average GPU power =
+`0.257332 kWh × 3,600,000 / 1336.69 s ≈ 693 W`, consistent with an H100's ~700 W TDP. This confirms:
+
+- `energy_generate_gpu/cpu/ram` → already in **kWh**, direct copy.
+- `duration_generate` → already in **seconds**, direct copy.
+
+Per-row formulas for `measures[N].powerConsumption` (kWh) and `measures[N].measurementDuration` (s):
+
+```
+powerConsumption (gpu measure) = energy_generate_gpu
+powerConsumption (cpu measure) = energy_generate_cpu
+powerConsumption (ram measure) = energy_generate_ram
+measurementDuration (all 3 measures) = duration_generate
+```
+
+No summing across rows or extra phase columns is needed (unlike the sibling mapping's LTX-Video
+upsample/denoise handling) — this file has no such columns and cardinality is 1:1.
+
+## header.reportDatetime / measures[*].measurementDateTime — Timestamp Extraction
+
+Unlike the sibling mapping (which had no experiment timestamp and used conversion time as a
+placeholder), **this file lets us recover the real per-run timestamp** from `name_csv`. Every
+value ends in a `_YYYY-MM-DD_HH-MM-SS.csv` suffix — verified against all 314 rows (0 non-matches).
+Timestamps span `2025-08-05 10:52:36` to `2025-08-19 20:11:30`.
+
+```python
+import re
+from datetime import datetime
+
+m = re.search(r"(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.csv$", name_csv)
+dt = datetime.strptime(m.group(1), "%Y-%m-%d_%H-%M-%S")
+formatted = dt.strftime("%Y-%m-%d %H:%M:%S")  # BoAmps string format
+```
+
+Use `formatted` for both `header.reportDatetime` and all three `measures[N].measurementDateTime`
+(same run, same timestamp).
+
+## task.algorithms[0].parametersNumber
+
+Same regex rule as the sibling mapping: `(\d+\.?\d*)[bB]$` applied to `model_name`. Since
+`model_name` is always `"WAN2.1-T2V-1.3B"` in this file, this always resolves to `1.3`. No lookup
+table needed (unlike the sibling mapping, which needed one for models without a size suffix).
+
+## task.dataset[0] — Input (no prompt text in source)
+
+This file has **no `prompt` column**. `name_csv` shows every row used the same fixed prompt id
+(`prompt1`), confirming a single constant prompt was used throughout the whole sweep — consistent
+with the paper's controlled-scaling-law methodology (only the swept parameter should vary between
+runs). The user confirmed the prompt text itself is constant across all runs and is 213 characters
+long. Since the text isn't in the source, `dataQuantity` is hardcoded to `213` (static value) per
+user instruction — not derived from any column.
+
+## task.taskDescription — Format
+
+Free-text field built per row from its generation parameters plus which parameter was swept:
+
+```
+"Text-to-video generation with {model_name}. Output: {width}x{height}, {num_frames} frames @ {fps} fps, {steps} diffusion steps, guidance_scale={guidance_scale}. Part of a scaling-law parameter sweep varying '{parameter}' (run: {name_csv})."
+```
+
+`guidance_scale` is never null in this file (constant 5.0 across all 314 rows) — unlike the
+sibling mapping, no conditional omission clause is needed here.
+
+## Infrastructure Components
+
+Constant across the entire file (single benchmark machine — `cpu_count`, `cpu_model`,
+`gpu_count`, `gpu_model` each have exactly one unique value across all 314 rows), identical
+hardware to the sibling mapping:
+
+```json
+[
+  {
+    "componentName": "AMD EPYC 7R13 Processor",
+    "componentType": "cpu",
+    "nbComponent": 8,
+    "manufacturer": "amd",
+    "family": "epyc",
+    "series": "7r13"
+  },
+  {
+    "componentName": "NVIDIA H100 80GB HBM3",
+    "componentType": "gpu",
+    "nbComponent": 1,
+    "memorySize": 80,
+    "manufacturer": "nvidia",
+    "family": "h100",
+    "series": "sxm"
+  },
+  {
+    "componentType": "ram",
+    "nbComponent": 1
+  }
+]
+```
+
+No CONDITIONAL logic needed — same hardware for every row.
+
+## Output
+
+- Output directory: `public_data_conversion/output/` (one JSON file per report).
+- **File naming convention: strip the `.csv` extension from `name_csv`** and use the result as
+  the filename, e.g. `exp7_frames_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_frames78_2025-08-05_20-51-54.json`.
+  Unlike the sibling mapping (`{model_name}.json`), `model_name` alone would collide across all
+  314 reports here since it's constant; `name_csv` is verified unique (314/314) and keeps
+  traceability back to the original per-run source file.
+
+## Null Handling
+
+**None needed.** Every column in this file is fully populated (0 nulls across all 314 rows × 19
+columns, confirmed via full-file scan) — no fallback logic required anywhere in this mapping.
+
+## environment object — OMIT
+
+Same as the sibling mapping: no country/location data available. `environment.country` is
+**required** whenever the `environment` object is present, and `environment` itself is optional
+at the top level, so **the converter should omit the entire `environment` object** rather than
+emit a report with a missing required sub-field.
+
+## Differences from the sibling mapping (`../mapping_info.csv`)
+
+1. **Cardinality**: 1 row = 1 report here (314 reports), vs. 1 model-group = 1 report there
+   (7 reports). This file has one model with 314 distinct configs; the sibling has 7 models with
+   ~49 prompts aggregated per model.
+2. **No CONDITIONAL fields anywhere** — this file has a single constant model and hardware
+   config; the sibling needed lookup tables for `parametersNumber` and per-model
+   `taskDescription` clauses (adapter/upsample/negative_prompt).
+3. **Real timestamps recovered** from `name_csv` for `header.reportDatetime` and
+   `measures[*].measurementDateTime`, replacing the sibling mapping's conversion-time placeholder.
+4. **`task.dataset[0].dataQuantity`** is a hardcoded static value (213, prompt char count
+   confirmed by user) instead of a computed `sum(len(prompt))`, since this file has no `prompt`
+   column at all.
+5. **`task.algorithms[0].foundationModelUri`** is a hardcoded static value (reused from the
+   sibling mapping's WAN2.1-T2V-1.3B row) instead of a per-row `model_hf_page` column lookup,
+   since this file has no `model_hf_page` column.
+6. **Output file naming** uses the `name_csv` stem instead of `{model_name}.json`, since
+   `model_name` is constant here and would collide.
+7. **`quality`** note updated: 5 runs + **1** warmup iteration (vs. the sibling's 5 runs + 2
+   warmup iterations) — still rated `high`.
+8. **`task.nbRequest`** is a static `1` (one generation per report) instead of a per-model
+   row count.
+9. **`task.taskDescription`** adds the swept-`parameter` name and `name_csv` for traceability,
+   which the sibling mapping's version doesn't need (it instead lists LTX-Video/AnimateDiff
+   extra-phase params, not applicable here).
+
+## Assumptions to Confirm
+
+1. **Units** — `energy_generate_gpu/cpu/ram` assumed to be kWh already (re-confirmed via power
+   sanity-check against H100 TDP on this file's data); `duration_generate` assumed to be seconds
+   already. Same assumption as the sibling mapping.
+2. **Hardware specs** — identical to the sibling mapping: GPU memory (80 GB) parsed from
+   `gpu_model` string; GPU `series` set to `"sxm"` from the paper's prose, not from the CSV
+   itself. RAM `memorySize` left blank — no RAM capacity given in source.
+3. **Timestamps** — unlike the sibling mapping, real per-run timestamps ARE available here
+   (extracted from `name_csv`) and are used for `header.reportDatetime` and
+   `measures[*].measurementDateTime`. No placeholder needed for this file.
+4. **Licensing** — `header.licensing` set to `"Creative Commons 4.0"`, carried over from the
+   sibling mapping's unconfirmed guess; please verify or correct.
+5. **Software / framework versions** — `task.algorithms[0].frameworkVersion` (diffusers version)
+   and `software.version` (Python version) left blank; not present in source.
+6. **Measurement tool** — same as sibling mapping: `measurementMethod="codecarbon"` for all
+   three measures, `cpuTrackingMode="rapl"`, `gpuTrackingMode="nvml"`, per the paper's stated
+   methodology. RAM energy is a heuristic estimate, not a direct measurement.
+7. **`infrastructure.infraType`** — set to `"onPremise"`, same unconfirmed assumption as the
+   sibling mapping (paper describes a "dedicated" GPU but doesn't state cloud vs. on-prem).
+8. **`task.dataset[0].dataQuantity` = 213** — the prompt text itself is not present anywhere in
+   this source file; this character count was provided directly by the user rather than derived
+   from data. If it later turns out to vary or was mis-stated, this needs correcting.
+9. **`task.algorithms[0].foundationModelUri`** — reused from the sibling mapping's value for
+   WAN2.1-T2V-1.3B (`https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers`); confirm this is
+   still the correct model page.
+10. **`environment` object omitted entirely** — no country/location data available; same as the
+    sibling mapping.
+11. **`quality`** set to `"high"` — controlled scaling-law sweep, 5 measured runs + 1 warmup
+    iteration per row, dedicated hardware.
+12. **Aggregation-within-row assumption carried over unverified** — whether each row's
+    `duration_generate`/`energy_generate_*` represents a sum or a mean across its 5 measured runs
+    is not stated in the source (same gap as the sibling mapping); doesn't affect this mapping's
+    correctness since no cross-row arithmetic is performed, but would matter if these values were
+    ever compared against a total energy budget for the whole sweep.

data/video_killed_the_energy_budget/conversion/exp_all_wan/mapping_info.csv

@@ -0,0 +1,127 @@
+boamps_field,boamps_type,required,source_field,source_type,transformation,static_value,note
+header.licensing,string,False,,,,Creative Commons 4.0,ASSUMPTION - not specified by user; carried over from prior mapping; confirm before running converter
+header.formatVersion,string,False,,,,0.1,
+header.formatVersionSpecificationUri,string,False,,,,,
+header.reportId,string,False,,,uuid4(),,Generated fresh per report at conversion time
+header.reportDatetime,string,True,name_csv,string,"regex extract trailing timestamp `_YYYY-MM-DD_HH-MM-SS.csv` from name_csv, strptime(""%Y-%m-%d_%H-%M-%S""), reformat to ""%Y-%m-%d %H:%M:%S""",,"IMPROVEMENT over prior mapping - real per-run experiment timestamp recovered from the filename embedded in name_csv, instead of using conversion time as a placeholder"
+header.reportStatus,string (enum),False,,,,final,"Allowed values: draft, final, corrective, other"
+header.publisher.name,string,False,,,,"Julien Delavande, Regis Pierrard, Sasha Luccioni",Paper authors - same paper as prior mapping (verified via 2509.19222v1.pdf)
+header.publisher.division,string,False,,,,,
+header.publisher.projectName,string,False,,,,Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models,"Same paper as prior mapping; this file covers the WAN2.1-T2V-1.3B scaling-law sweep experiments (Section on fine-grained experiments validating quadratic/linear scaling laws), not the 6/7-model benchmark comparison"
+header.publisher.confidentialityLevel,string (enum),True,,,,public,"Allowed values: public, internal, confidential, secret"
+header.publisher.publicKey,string,False,,,,,
+task.taskStage,string,True,,,,inference,
+task.taskFamily,string,True,,,,text to video generation,
+task.nbRequest,number,False,,,,1,"One row = one report = one single generation run (fixed prompt, one config)"
+task.algorithms[0].trainingType,string,False,,,,,Pretrained/foundation model used as-is at inference; not applicable
+task.algorithms[0].algorithmType,string,False,,,,diffusion model,
+task.algorithms[0].algorithmName,string,False,,,,,Left empty; using foundationModelName instead
+task.algorithms[0].algorithmUri,string,False,,,,,
+task.algorithms[0].foundationModelName,string,False,model_name,string,,,Constant "WAN2.1-T2V-1.3B" across the whole file
+task.algorithms[0].foundationModelUri,string,False,,,,https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers,"No model_hf_page column in this file (unlike prior CSV); hardcoded as static since model_name is constant across the whole file. Value reused from prior mapping's WAN2.1-T2V-1.3B row - confirm still correct"
+task.algorithms[0].parametersNumber,number,False,model_name,string,"regex `(\d+\.?\d*)[bB]\$` on model_name -> 1.3",,"Same parsing rule as prior mapping; trivial here since model_name is always ""WAN2.1-T2V-1.3B"""
+task.algorithms[0].framework,string,False,,,,diffusers,HuggingFace Diffusers library per paper
+task.algorithms[0].frameworkVersion,string,False,,,,,ASSUMPTION GAP - not specified by user; version unknown
+task.algorithms[0].classPath,string,False,,,,,
+task.algorithms[0].layersNumber,number,False,,,,,
+task.algorithms[0].epochsNumber,number,False,,,,,"Inference only, not applicable"
+task.algorithms[0].optimizer,string,False,,,,,
+task.algorithms[0].quantization,string,False,,,,,Not specified in source
+task.dataset[0].dataUsage,string (enum),True,,,,input,"Allowed values: input, output"
+task.dataset[0].dataType,string (enum),True,,,,text,"Allowed values: tabular, audio, boolean, image, video, object, text, token, word, other"
+task.dataset[0].dataFormat,string (enum),False,,,,text,
+task.dataset[0].dataSize,number,False,,,,,
+task.dataset[0].dataQuantity,number,False,,,,213,"No `prompt` column in this file (unlike prior CSV). name_csv shows the same fixed prompt (""prompt1"") was used for every row across the whole sweep. User confirmed the prompt text is constant and measures 213 characters - hardcoded per user instruction"
+task.dataset[0].shape,string,False,,,,,
+task.dataset[0].source,string (enum),False,,,,,"Allowed values: public, private, other"
+task.dataset[0].sourceUri,string,False,,,,,
+task.dataset[0].owner,string,False,,,,,
+task.dataset[1].dataUsage,string (enum),True,,,,output,"Allowed values: input, output"
+task.dataset[1].dataType,string (enum),True,,,,video,"Allowed values: tabular, audio, boolean, image, video, object, text, token, word, other"
+task.dataset[1].dataFormat,string (enum),False,,,,,Not confirmed in source (no output file format column in this CSV)
+task.dataset[1].dataSize,number,False,,,,,
+task.dataset[1].dataQuantity,number,False,,,,1,One video generated per row/report
+task.dataset[1].shape,string,False,,,,,"Generation params (resolution/frames/fps) placed in taskDescription instead, per user request (consistent with prior mapping)"
+task.dataset[1].source,string (enum),False,,,,,
+task.dataset[1].sourceUri,string,False,,,,,
+task.dataset[1].owner,string,False,,,,,
+task.measuredAccuracy,number,False,,,,,
+task.estimatedAccuracy,string (enum),False,,,,,
+task.taskDescription,string,False,,,"DERIVED - see mapping_extra_info.md",,"Formatted string with width/height/num_frames/fps/steps/guidance_scale plus which parameter (`parameter` column: frames/res/steps) was swept for this run, and the source name_csv for traceability"
+measures[0].measurementMethod,string,True,,,,codecarbon,GPU measure
+measures[0].manufacturer,string,False,,,,,
+measures[0].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[0].cpuTrackingMode,string,False,,,,,Not applicable to GPU measure
+measures[0].gpuTrackingMode,string,False,,,,nvml,CodeCarbon interfaces with NVML per paper
+measures[0].averageUtilizationCpu,number,False,,,,,
+measures[0].averageUtilizationGpu,number,False,,,,,Not present in source
+measures[0].powerCalibrationMeasurement,number,False,,,,,
+measures[0].durationCalibrationMeasurement,number,False,,,,,
+measures[0].powerConsumption,number,True,energy_generate_gpu,Float64,,,"Already in kWh; direct copy (no summing needed - one row is one report, and this file has no upsample/denoise phase columns)"
+measures[0].measurementDuration,number,False,duration_generate,Float64,,,Already in seconds; direct copy
+measures[0].measurementDateTime,string,False,name_csv,string,"same timestamp extraction as header.reportDatetime",,IMPROVEMENT over prior mapping - real per-run timestamp now available from name_csv
+measures[1].measurementMethod,string,True,,,,codecarbon,CPU measure
+measures[1].manufacturer,string,False,,,,,
+measures[1].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[1].cpuTrackingMode,string,False,,,,rapl,CodeCarbon interfaces with pyRAPL per paper
+measures[1].gpuTrackingMode,string,False,,,,,Not applicable to CPU measure
+measures[1].averageUtilizationCpu,number,False,,,,,Not present in source
+measures[1].averageUtilizationGpu,number,False,,,,,
+measures[1].powerCalibrationMeasurement,number,False,,,,,
+measures[1].durationCalibrationMeasurement,number,False,,,,,
+measures[1].powerConsumption,number,True,energy_generate_cpu,Float64,,,Already in kWh; direct copy
+measures[1].measurementDuration,number,False,duration_generate,Float64,,,Same wall-clock duration as GPU measure
+measures[1].measurementDateTime,string,False,name_csv,string,"same timestamp extraction as header.reportDatetime",,IMPROVEMENT over prior mapping
+measures[2].measurementMethod,string,True,,,,codecarbon,"RAM measure - estimated via CodeCarbon's default heuristic, not directly measured"
+measures[2].manufacturer,string,False,,,,,
+measures[2].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[2].cpuTrackingMode,string,False,,,,,Not applicable to RAM measure
+measures[2].gpuTrackingMode,string,False,,,,,Not applicable to RAM measure
+measures[2].averageUtilizationCpu,number,False,,,,,
+measures[2].averageUtilizationGpu,number,False,,,,,
+measures[2].powerCalibrationMeasurement,number,False,,,,,
+measures[2].durationCalibrationMeasurement,number,False,,,,,
+measures[2].powerConsumption,number,True,energy_generate_ram,Float64,,,Already in kWh; heuristic estimate not direct measurement; direct copy
+measures[2].measurementDuration,number,False,duration_generate,Float64,,,Same wall-clock duration as GPU/CPU measures
+measures[2].measurementDateTime,string,False,name_csv,string,"same timestamp extraction as header.reportDatetime",,IMPROVEMENT over prior mapping
+system.os,string,True,,,,linux,ASSUMPTION - not stated by user; ML GPU benchmark environment typically Linux
+system.distribution,string,False,,,,,
+system.distributionVersion,string,False,,,,,
+software.language,string,True,,,,python,
+software.version,string,False,,,,,ASSUMPTION GAP - Python version not specified
+infrastructure.infraType,string (enum),True,,,,onPremise,"ASSUMPTION - paper says 'dedicated' GPU with no co-scheduled jobs; cloud vs on-premise not confirmed. Allowed values: publicCloud, privateCloud, onPremise, other"
+infrastructure.cloudProvider,string,False,,,,,
+infrastructure.cloudInstance,string,False,,,,,
+infrastructure.cloudService,string,False,,,,,
+infrastructure.components[0].componentName,string,False,cpu_model,string,,,CPU component
+infrastructure.components[0].componentType,string,True,,,,cpu,
+infrastructure.components[0].nbComponent,integer,True,cpu_count,Int64,,,
+infrastructure.components[0].memorySize,number,False,,,,,Not applicable for CPU component
+infrastructure.components[0].manufacturer,string,False,,,,amd,Parsed from cpu_model "AMD EPYC 7R13 Processor"
+infrastructure.components[0].family,string,False,,,,epyc,
+infrastructure.components[0].series,string,False,,,,7r13,
+infrastructure.components[0].share,number,False,,,,,"Default 1 (dedicated machine, no co-scheduled jobs per paper)"
+infrastructure.components[1].componentName,string,False,gpu_model,string,,,GPU component
+infrastructure.components[1].componentType,string,True,,,,gpu,
+infrastructure.components[1].nbComponent,integer,True,gpu_count,Int64,,,
+infrastructure.components[1].memorySize,number,False,,,,80,"Parsed from gpu_model ""NVIDIA H100 80GB HBM3"" (GB per unit)"
+infrastructure.components[1].manufacturer,string,False,,,,nvidia,
+infrastructure.components[1].family,string,False,,,,h100,
+infrastructure.components[1].series,string,False,,,,sxm,"ASSUMPTION - paper text says 'H100 SXM'; CSV gpu_model text does not distinguish SXM/PCIe"
+infrastructure.components[1].share,number,False,,,,,Default 1
+infrastructure.components[2].componentName,string,False,,,,,RAM component
+infrastructure.components[2].componentType,string,True,,,,ram,
+infrastructure.components[2].nbComponent,integer,True,,,,1,Single RAM pool assumed
+infrastructure.components[2].memorySize,number,False,,,,,"Left blank per prior mapping instruction - RAM size not in source data"
+infrastructure.components[2].manufacturer,string,False,,,,,
+infrastructure.components[2].family,string,False,,,,,
+infrastructure.components[2].series,string,False,,,,,
+infrastructure.components[2].share,number,False,,,,,
+environment.country,string,True,,,,,"OMIT ENTIRE environment OBJECT - no country data available (same as prior mapping); see mapping_extra_info.md"
+environment.latitude,number,False,,,,,Omit with environment object
+environment.longitude,number,False,,,,,Omit with environment object
+environment.location,string,False,,,,,Omit with environment object
+environment.powerSupplierType,string (enum),False,,,,,Omit with environment object
+environment.powerSource,string (enum),False,,,,,Omit with environment object
+environment.powerSourceCarbonIntensity,number,False,,,,,Omit with environment object
+quality,string (enum),False,,,,high,"Controlled scaling-law sweep: 5 measured runs + 1 warmup iteration per row (runs=5, warmup=1 constant); differs from prior mapping's 2-warmup benchmark"

data/video_killed_the_energy_budget/conversion/text2video/converter.py

@@ -0,0 +1,293 @@
+"""Convert text2video_energy_benchmark.csv into BoAmps energy reports.
+
+One report is produced per `model_name` group (see mapping_extra_info.md for the
+row-to-report cardinality and per-field mapping rationale).
+"""
+
+import argparse
+import json
+import re
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+import polars as pl
+
+PAPER_TITLE = (
+    "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes "
+    "of Open Text-to-Video Models"
+)
+PUBLISHER_NAME = "Julien Delavande, Regis Pierrard, Sasha Luccioni"
+
+PARAMETERS_NUMBER_LOOKUP = {
+    "LTX-Video-0.9.7-dev": 13,
+    "Mochi-1-preview": 10,
+    "AnimateDiff": 1.277,
+}
+
+
+def load_sources(files: list[str]) -> pl.DataFrame:
+    return pl.concat([pl.read_csv(f, infer_schema_length=None) for f in files])
+
+
+def fmt_num(value):
+    if value is None:
+        return None
+    if isinstance(value, float):
+        if value != value:  # NaN
+            return None
+        if value == int(value):
+            return int(value)
+    return value
+
+
+def sum_cols(df: pl.DataFrame, cols: list[str]) -> float:
+    total = 0.0
+    for col in cols:
+        total += df[col].fill_null(0).sum()
+    return total
+
+
+def parse_parameters_number(model_name: str):
+    if model_name in PARAMETERS_NUMBER_LOOKUP:
+        return PARAMETERS_NUMBER_LOOKUP[model_name]
+    match = re.search(r"(\d+\.?\d*)[bB]$", model_name)
+    if match:
+        return fmt_num(float(match.group(1)))
+    return None
+
+
+def build_group_context(model_name: str, group_df: pl.DataFrame) -> dict:
+    ctx = dict(group_df.row(0, named=True))
+    ctx["model_name"] = model_name
+    ctx["nb_rows"] = group_df.height
+    ctx["prompt_char_sum"] = group_df.select(pl.col("prompt").str.len_chars().sum()).item()
+    ctx["energy_gpu_sum"] = sum_cols(
+        group_df, ["energy_generate_gpu", "energy_upsample_gpu", "energy_denoise_gpu"]
+    )
+    ctx["energy_cpu_sum"] = sum_cols(
+        group_df, ["energy_generate_cpu", "energy_upsample_cpu", "energy_denoise_cpu"]
+    )
+    ctx["energy_ram_sum"] = sum_cols(
+        group_df, ["energy_generate_ram", "energy_upsample_ram", "energy_denoise_ram"]
+    )
+    ctx["duration_sum"] = sum_cols(
+        group_df, ["duration_generate", "duration_upsample", "duration_denoise"]
+    )
+    return ctx
+
+
+def build_header(row: dict) -> dict:
+    return {
+        "licensing": "CC BY 4.0",
+        "formatVersion": "0.1",
+        "reportId": str(uuid.uuid4()),
+        "reportDatetime": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "reportStatus": "final",
+        "publisher": {
+            "name": PUBLISHER_NAME,
+            "projectName": PAPER_TITLE,
+            "confidentialityLevel": "public",
+        },
+    }
+
+
+def build_task(row: dict) -> dict:
+    return {
+        "taskStage": "inference",
+        "taskFamily": "text to video generation",
+        "nbRequest": row["nb_rows"],
+        "taskDescription": build_task_description(row),
+    }
+
+
+def build_task_description(row: dict) -> str:
+    model_name = row["model_name"]
+    width = fmt_num(row.get("width"))
+    height = fmt_num(row.get("height"))
+    num_frames = fmt_num(row.get("num_frames"))
+    fps = fmt_num(row.get("fps"))
+    steps = fmt_num(row.get("steps"))
+    guidance_scale = row.get("guidance_scale")
+
+    desc = (
+        f"Text-to-video generation with {model_name}. Output: {width}x{height}, "
+        f"{num_frames} frames @ {fps} fps, {steps} diffusion steps"
+    )
+    if guidance_scale is not None:
+        desc += f", guidance_scale={fmt_num(guidance_scale)}."
+    else:
+        desc += "."
+
+    if model_name == "LTX-Video-0.9.7-dev":
+        desc += (
+            f" Additional upsample+denoise phase: downscaled "
+            f"{fmt_num(row.get('downscaled_width'))}x{fmt_num(row.get('downscaled_height'))}, "
+            f"generate_steps={fmt_num(row.get('generate_steps'))}, "
+            f"denoise_steps={fmt_num(row.get('denoise_steps'))}, "
+            f"denoise_strength={row.get('denoise_strength')}, "
+            f"decode_timestep={row.get('decode_timestep')}, "
+            f"image_cond_noise_scale={row.get('image_cond_noise_scale')}, "
+            f"upsample_model={row.get('upsample_model_name')}."
+        )
+
+    if model_name == "AnimateDiff":
+        desc += (
+            f" Uses adapter {row.get('adapter_repo')} "
+            f"(checkpoint {row.get('adapter_ckpt')}) on base model {row.get('base_model')}."
+        )
+
+    negative_prompt = row.get("negative_prompt")
+    if negative_prompt:
+        desc += f' Negative prompt used: "{negative_prompt}".'
+
+    return desc
+
+
+def build_algorithms(row: dict) -> list[dict]:
+    return [
+        {
+            "algorithmType": "diffusion model",
+            "foundationModelName": row["model_name"],
+            "foundationModelUri": row.get("model_hf_page"),
+            "parametersNumber": parse_parameters_number(row["model_name"]),
+            "framework": "diffusers",
+        }
+    ]
+
+
+def build_dataset(row: dict) -> list[dict]:
+    return [
+        {
+            "dataUsage": "input",
+            "dataType": "text",
+            "dataFormat": "text",
+            "dataQuantity": row["prompt_char_sum"],
+        },
+        {
+            "dataUsage": "output",
+            "dataType": "video",
+            "dataQuantity": row["nb_rows"],
+        },
+    ]
+
+
+def build_measures(row: dict) -> list[dict]:
+    duration = row["duration_sum"]
+    return [
+        {
+            "measurementMethod": "codecarbon",
+            "gpuTrackingMode": "nvml",
+            "powerConsumption": row["energy_gpu_sum"],
+            "measurementDuration": duration,
+        },
+        {
+            "measurementMethod": "codecarbon",
+            "cpuTrackingMode": "rapl",
+            "powerConsumption": row["energy_cpu_sum"],
+            "measurementDuration": duration,
+        },
+        {
+            "measurementMethod": "codecarbon",
+            "powerConsumption": row["energy_ram_sum"],
+            "measurementDuration": duration,
+        },
+    ]
+
+
+def build_system(row: dict) -> dict:
+    return {"os": "linux"}
+
+
+def build_software(row: dict) -> dict:
+    return {"language": "python"}
+
+
+def build_infrastructure(row: dict) -> dict:
+    return {"infraType": "onPremise"}
+
+
+def build_components(row: dict) -> list[dict]:
+    return [
+        {
+            "componentName": row.get("cpu_model"),
+            "componentType": "cpu",
+            "nbComponent": int(row["cpu_count"]),
+            "manufacturer": "amd",
+            "family": "epyc",
+            "series": "7r13",
+        },
+        {
+            "componentName": row.get("gpu_model"),
+            "componentType": "gpu",
+            "nbComponent": int(row["gpu_count"]),
+            "memorySize": 80,
+            "manufacturer": "nvidia",
+            "family": "h100",
+            "series": "sxm",
+        },
+        {
+            "componentType": "ram",
+            "nbComponent": 1,
+        },
+    ]
+
+
+def clean(obj):
+    if isinstance(obj, dict):
+        return {k: clean(v) for k, v in obj.items() if v is not None and v != ""}
+    if isinstance(obj, list):
+        return [clean(v) for v in obj]
+    return obj
+
+
+def build_report(row: dict) -> dict:
+    report = {
+        "header": build_header(row),
+        "task": {
+            **build_task(row),
+            "algorithms": build_algorithms(row),
+            "dataset": build_dataset(row),
+        },
+        "measures": build_measures(row),
+        "system": build_system(row),
+        "software": build_software(row),
+        "infrastructure": {
+            **build_infrastructure(row),
+            "components": build_components(row),
+        },
+        "quality": "high",
+    }
+    return clean(report)
+
+
+def save_report(report: dict, model_name: str, output_dir: Path) -> Path:
+    path = output_dir / f"{model_name}.json"
+    path.write_text(json.dumps(report, indent=2))
+    return path
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("files", nargs="+")
+    parser.add_argument("--output", default="public_data_conversion/output/")
+    args = parser.parse_args()
+
+    df = load_sources(args.files)
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    model_names = sorted(df["model_name"].unique().to_list())
+    written = []
+    for model_name in model_names:
+        group_df = df.filter(pl.col("model_name") == model_name)
+        ctx = build_group_context(model_name, group_df)
+        report = build_report(ctx)
+        written.append(save_report(report, model_name, output_dir))
+
+    assert len(written) == len(model_names), "Filename collision detected"
+    print(f"Wrote {len(written)} reports to {output_dir}")
+
+
+if __name__ == "__main__":
+    main()

data/video_killed_the_energy_budget/conversion/text2video/mapping_extra_info.md

@@ -0,0 +1,192 @@
+# Mapping Extra Info — text2video_energy_benchmark.csv → BoAmps
+
+## Source Data
+
+- File: `public_data_conversion/text2video_energy_benchmark.csv`
+- Format: CSV, comma-delimited, UTF-8, single file, header row.
+- 335 rows total, 39 columns.
+- One row = one (model, prompt) inference run, already averaged/aggregated over 5 measured
+  runs with 2 warmup iterations excluded (`runs=5`, `warmup=2` constant on every row).
+- Source paper: *"Video Killed the Energy Budget: Characterizing the Latency and Power Regimes
+  of Open Text-to-Video Models"* by Julien Delavande, Regis Pierrard, Sasha Luccioni.
+
+## Row-to-Report Cardinality
+
+**Aggregation: one BoAmps report per `model_name`.** 7 reports total.
+
+| model_name | rows (prompts benchmarked) |
+|---|---|
+| AnimateDiff | 49 |
+| CogVideoX-2b | 49 |
+| CogVideoX-5b | 49 |
+| LTX-Video-0.9.7-dev | 49 |
+| Mochi-1-preview | 49 |
+| WAN2.1-T2V-1.3B | 49 |
+| WAN2.1-T2V-14B | 41 (8 prompts missing/failed for this model) |
+
+For each model group:
+- `task.nbRequest` = number of rows in the group.
+- `measures[*].powerConsumption` and `measures[*].measurementDuration` = **sum** across all rows
+  in the group (total energy/time spent benchmarking that model), not the mean per generation.
+- Generation parameters (`height`, `width`, `num_frames`, `fps`, `steps`, `guidance_scale`) are
+  constant within each model group — verified during mapping design — so any row's value can be
+  used for `taskDescription`.
+
+## Key Column Semantics
+
+| Column | Unit | Description |
+|---|---|---|
+| `duration_generate` | seconds | Wall-clock time for the main generation phase of one prompt run |
+| `energy_generate_gpu/cpu/ram` | kWh | Energy consumed by GPU/CPU/RAM during the generation phase, per prompt run |
+| `duration_upsample`, `duration_denoise` | seconds | LTX-Video-only extra pipeline phases (spatial upscaling + denoising pass) |
+| `energy_upsample_*`, `energy_denoise_*` | kWh | Energy for the LTX-Video extra phases (gpu/cpu/ram) |
+| `runs` / `warmup` | count | 5 measured runs / 2 warmup iterations per prompt — constant across all rows; already baked into the reported duration/energy values |
+| `adapter_repo`, `adapter_ckpt`, `base_model` | — | AnimateDiff-only: LoRA/motion-module adapter repo + checkpoint + base diffusion model it's attached to |
+| `upsample_model_name` | — | LTX-Video-only: name of the spatial upscaler model used in the extra phase |
+| `prompt` / `negative_prompt` | text | Text prompt fed to the model; negative_prompt only used by some models |
+
+## Energy & Duration Conversions
+
+**No unit conversion needed.** Confirmed by sanity check: for the longest run
+(WAN2.1-T2V-14B, `duration_generate` = 1879.58 s, `energy_generate_gpu` = 0.360737),
+implied average GPU power = `0.360737 kWh × 3,600,000 / 1879.58 s ≈ 691 W`, consistent with an
+H100's ~700 W TDP if the value were already kWh. This confirms:
+
+- `energy_generate_*` / `energy_upsample_*` / `energy_denoise_*` → already in **kWh**, direct copy (sum).
+- `duration_generate` / `duration_upsample` / `duration_denoise` → already in **seconds**, direct copy (sum).
+
+Per-model formulas used for `measures[N].powerConsumption` (kWh) and `measures[N].measurementDuration` (s),
+grouped by `model_name`:
+
+```
+powerConsumption (gpu measure) = sum(energy_generate_gpu) + sum(energy_upsample_gpu, if present) + sum(energy_denoise_gpu, if present)
+powerConsumption (cpu measure) = sum(energy_generate_cpu) + sum(energy_upsample_cpu, if present) + sum(energy_denoise_cpu, if present)
+powerConsumption (ram measure) = sum(energy_generate_ram) + sum(energy_upsample_ram, if present) + sum(energy_denoise_ram, if present)
+measurementDuration (all 3 measures) = sum(duration_generate) + sum(duration_upsample, if present) + sum(duration_denoise, if present)
+```
+
+Only LTX-Video-0.9.7-dev has non-null `*_upsample_*` / `*_denoise_*` columns; for all other models
+these terms are simply 0/absent.
+
+## task.algorithms[0].parametersNumber — Lookup Table
+
+| model_name | parametersNumber (B) | Source |
+|---|---|---|
+| WAN2.1-T2V-1.3B | 1.3 | Parsed from model name |
+| WAN2.1-T2V-14B | 14 | Parsed from model name |
+| CogVideoX-2b | 2 | Parsed from model name |
+| CogVideoX-5b | 5 | Parsed from model name |
+| LTX-Video-0.9.7-dev | 13 | User-provided (transformer/DiT component, ~26.1 GB safetensors) |
+| Mochi-1-preview | 10 | User-provided (Asymmetric Diffusion Transformer, AsymmDiT) |
+| AnimateDiff | 1.277 | User-provided: motion module (~0.417B) is a plug-in adapter attached to a base SD1.5 U-Net (~0.86B); total = 0.417 + 0.86. **Flagged as an assumption to confirm** — the two components could instead be reported separately or only the motion module counted. |
+
+Parsing rule for the 4 models with a size suffix in `model_name`: regex `(\d+\.?\d*)[bB]` at the
+end of the name (e.g. `WAN2.1-T2V-1.3B` → `1.3`, `CogVideoX-2b` → `2`).
+
+## task.taskDescription — Format
+
+Free-text field built from each model group's (constant) generation parameters:
+
+```
+"Text-to-video generation with {model_name}. Output: {width}x{height}, {num_frames} frames @ {fps} fps, {steps} diffusion steps, guidance_scale={guidance_scale}."
+```
+
+Append when applicable:
+
+- **LTX-Video-0.9.7-dev** (has upsample/denoise phase): append
+  `" Additional upsample+denoise phase: downscaled {downscaled_width}x{downscaled_height}, generate_steps={generate_steps}, denoise_steps={denoise_steps}, denoise_strength={denoise_strength}, decode_timestep={decode_timestep}, image_cond_noise_scale={image_cond_noise_scale}, upsample_model={upsample_model_name}."`
+- **AnimateDiff** (uses adapter): append
+  `" Uses adapter {adapter_repo} (checkpoint {adapter_ckpt}) on base model {base_model}."`
+- **WAN2.1-T2V-1.3B / WAN2.1-T2V-14B / LTX-Video-0.9.7-dev** (have `negative_prompt`): append
+  `" Negative prompt used: \"{negative_prompt}\"."` — omit for models where `negative_prompt` is null
+  (Mochi-1-preview, AnimateDiff, CogVideoX-2b, CogVideoX-5b).
+- `guidance_scale` is null for Mochi-1-preview and LTX-Video-0.9.7-dev — omit that clause for
+  those two models instead of printing `guidance_scale=None`.
+
+## Infrastructure Components
+
+Constant across the entire dataset (single benchmark machine, verified — `cpu_count`, `cpu_model`,
+`gpu_count`, `gpu_model` each have exactly one unique value across all 335 rows):
+
+```json
+[
+  {
+    "componentName": "AMD EPYC 7R13 Processor",
+    "componentType": "cpu",
+    "nbComponent": 8,
+    "manufacturer": "amd",
+    "family": "epyc",
+    "series": "7r13"
+  },
+  {
+    "componentName": "NVIDIA H100 80GB HBM3",
+    "componentType": "gpu",
+    "nbComponent": 1,
+    "memorySize": 80,
+    "manufacturer": "nvidia",
+    "family": "h100",
+    "series": "sxm"
+  },
+  {
+    "componentType": "ram",
+    "nbComponent": 1
+  }
+]
+```
+
+No CONDITIONAL logic needed here since hardware is identical for every model/report.
+
+## Output
+
+- Output directory: `public_data_conversion/output/` (one JSON file per report).
+- File naming convention: `{model_name}.json` (e.g. `WAN2.1-T2V-14B.json`), lowercased and with
+  any characters unsafe for filenames (`.`, spaces) left as-is since model names here are already
+  filename-safe.
+
+## Null Handling
+
+| Column(s) | Null for | Fallback |
+|---|---|---|
+| `guidance_scale` | Mochi-1-preview, LTX-Video-0.9.7-dev (98 rows) | Omit from `taskDescription`, no BoAmps field maps directly to it |
+| `negative_prompt` | AnimateDiff, CogVideoX-2b, CogVideoX-5b, Mochi-1-preview (196 rows) | Omit clause from `taskDescription` |
+| `adapter_repo`, `adapter_ckpt`, `base_model` | All except AnimateDiff (286 rows) | Only append adapter clause to `taskDescription` when `model_name == "AnimateDiff"` |
+| `duration_upsample`, `duration_denoise`, `energy_upsample_*`, `energy_denoise_*`, `upsample_model_name`, `downscaled_height`, `downscaled_width`, `generate_steps`, `denoise_steps`, `denoise_strength`, `decode_timestep`, `image_cond_noise_scale` | All except LTX-Video-0.9.7-dev (286 rows) | Treat as 0/absent when summing energy & duration for other models; only append upsample/denoise clause to `taskDescription` when `model_name == "LTX-Video-0.9.7-dev"` |
+
+## environment object — OMIT
+
+No country was provided by the user for this benchmark. Since `environment.country` is **required**
+whenever the `environment` object is present, and `environment` itself is optional at the top level,
+**the converter should omit the entire `environment` object from the output JSON** rather than emit
+a report with a missing required sub-field. If the user later confirms a country/location, revisit
+this and populate `environment.country` (+ optionally `powerSupplierType`, `powerSource`).
+
+## Assumptions to Confirm
+
+1. **Units** — `energy_generate_*`/`energy_upsample_*`/`energy_denoise_*` assumed to be kWh already
+   (confirmed via power sanity-check against H100 TDP); `duration_*` assumed to be seconds already.
+2. **Hardware specs** — GPU memory (80 GB) parsed from the `gpu_model` string
+   `"NVIDIA H100 80GB HBM3"`; GPU `series` set to `"sxm"` based on the paper's prose ("dedicated
+   NVIDIA H100 SXM GPU"), even though the CSV's `gpu_model` column itself doesn't state SXM vs PCIe
+   — confirm this is correct. RAM `memorySize` left blank entirely — no RAM capacity given in either
+   source or paper excerpt.
+3. **Timestamps** — No experiment timestamp in source; `header.reportDatetime` uses the conversion
+   run time as a placeholder for all 7 reports.
+4. **Licensing** — `header.licensing` set to `"Creative Commons 4.0"` as a guess (public benchmark
+   data); not explicitly confirmed by the user — please verify or correct.
+5. **Software / framework versions** — `task.algorithms[0].frameworkVersion` (diffusers version) and
+   `software.version` (Python version) left blank; not present in source or provided by the user.
+6. **Measurement tool** — `measurementMethod` set to `"codecarbon"` for all three measures (gpu/cpu/ram),
+   `cpuTrackingMode="rapl"` (pyRAPL) and `gpuTrackingMode="nvml"`, per the paper excerpt: *"We measured
+   GPU and CPU energy using CodeCarbon, which interfaces with NVML and pyRAPL, and estimated RAM
+   energy using CodeCarbon's default heuristic."* RAM energy is a **heuristic estimate**, not a direct
+   measurement — flagged on `measures[2]`.
+7. **`infrastructure.infraType`** — set to `"onPremise"` based on the paper's description of a
+   "dedicated" GPU with "no co-scheduled jobs," but this could equally be a dedicated cloud instance
+   (e.g. Lambda Labs, CoreWeave). Not explicitly confirmed — please verify.
+8. **`task.algorithms[0].parametersNumber` for AnimateDiff** — set to 1.277B (0.417B motion module +
+   0.86B base SD1.5), a combined total rather than either component alone. Confirm this is the
+   intended interpretation, or specify a different value (e.g. motion module only: 0.417B).
+9. **`environment` object omitted entirely** — no country/location data available; see above. If a
+   location becomes known, this section needs to be added back into the converter output.
+10. **`quality`** set to `"high"` per user confirmation (controlled benchmark: 5 runs + 2 warmup
+    iterations per prompt, dedicated hardware, no co-scheduled jobs).

data/video_killed_the_energy_budget/conversion/text2video/mapping_info.csv

@@ -0,0 +1,127 @@
+boamps_field,boamps_type,required,source_field,source_type,transformation,static_value,note
+header.licensing,string,False,,,,Creative Commons 4.0,ASSUMPTION - not specified by user; confirm before running converter
+header.formatVersion,string,False,,,,0.1,
+header.formatVersionSpecificationUri,string,False,,,,,
+header.reportId,string,False,,,uuid4(),,Generated fresh per report at conversion time
+header.reportDatetime,string,True,,,datetime.now().strftime("%Y-%m-%d %H:%M:%S"),,PLACEHOLDER - no experiment timestamp in source data; using conversion time
+header.reportStatus,string (enum),False,,,,final,"Allowed values: draft, final, corrective, other"
+header.publisher.name,string,False,,,,"Julien Delavande, Regis Pierrard, Sasha Luccioni",Paper authors
+header.publisher.division,string,False,,,,,
+header.publisher.projectName,string,False,,,,Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models,Paper title
+header.publisher.confidentialityLevel,string (enum),True,,,,public,"Allowed values: public, internal, confidential, secret"
+header.publisher.publicKey,string,False,,,,,
+task.taskStage,string,True,,,,inference,
+task.taskFamily,string,True,,,,text to video generation,
+task.nbRequest,number,False,model_name,string,"count(rows) grouped by model_name (49 for all models except WAN2.1-T2V-14B which is 41)",,Number of prompts actually benchmarked for that model
+task.algorithms[0].trainingType,string,False,,,,,Pretrained/foundation models used as-is at inference; not applicable
+task.algorithms[0].algorithmType,string,False,,,,diffusion model,
+task.algorithms[0].algorithmName,string,False,,,,,Left empty; using foundationModelName instead
+task.algorithms[0].algorithmUri,string,False,,,,,
+task.algorithms[0].foundationModelName,string,False,model_name,string,,,
+task.algorithms[0].foundationModelUri,string,False,model_hf_page,string,,,
+task.algorithms[0].parametersNumber,number,False,model_name,string,"CONDITIONAL - see mapping_extra_info.md",,"Parsed from name where possible (WAN2.1-T2V-1.3B/14B, CogVideoX-2b/5b); hardcoded lookup for AnimateDiff/LTX-Video-0.9.7-dev/Mochi-1-preview (not in name)"
+task.algorithms[0].framework,string,False,,,,diffusers,HuggingFace Diffusers library per paper
+task.algorithms[0].frameworkVersion,string,False,,,,,ASSUMPTION GAP - not specified by user; version unknown
+task.algorithms[0].classPath,string,False,,,,,
+task.algorithms[0].layersNumber,number,False,,,,,
+task.algorithms[0].epochsNumber,number,False,,,,,"Inference only, not applicable"
+task.algorithms[0].optimizer,string,False,,,,,
+task.algorithms[0].quantization,string,False,,,,,Not specified in source
+task.dataset[0].dataUsage,string (enum),True,,,,input,"Allowed values: input, output"
+task.dataset[0].dataType,string (enum),True,,,,text,"Allowed values: tabular, audio, boolean, image, video, object, text, token, word, other"
+task.dataset[0].dataFormat,string (enum),False,,,,text,
+task.dataset[0].dataSize,number,False,,,,,
+task.dataset[0].dataQuantity,number,False,prompt,string,"sum(len(prompt)) grouped by model_name",,Total characters across all prompts used for that model (per user request)
+task.dataset[0].shape,string,False,,,,,
+task.dataset[0].source,string (enum),False,,,,,"Allowed values: public, private, other"
+task.dataset[0].sourceUri,string,False,,,,,
+task.dataset[0].owner,string,False,,,,,
+task.dataset[1].dataUsage,string (enum),True,,,,output,"Allowed values: input, output"
+task.dataset[1].dataType,string (enum),True,,,,video,"Allowed values: tabular, audio, boolean, image, video, object, text, token, word, other"
+task.dataset[1].dataFormat,string (enum),False,,,,,Not confirmed in source (no output file format column in this CSV)
+task.dataset[1].dataSize,number,False,,,,,
+task.dataset[1].dataQuantity,number,False,model_name,string,"count(rows) grouped by model_name",,Total videos generated for that model (1 video per prompt row)
+task.dataset[1].shape,string,False,,,,,"Generation params (resolution/frames/fps) placed in taskDescription instead, per user request"
+task.dataset[1].source,string (enum),False,,,,,
+task.dataset[1].sourceUri,string,False,,,,,
+task.dataset[1].owner,string,False,,,,,
+task.measuredAccuracy,number,False,,,,,
+task.estimatedAccuracy,string (enum),False,,,,,
+task.taskDescription,string,False,,,"CONDITIONAL - see mapping_extra_info.md",,Formatted string with width/height/num_frames/fps/steps/guidance_scale (all models) plus LTX-Video upsample/denoise params or AnimateDiff adapter params where applicable
+measures[0].measurementMethod,string,True,,,,codecarbon,GPU measure
+measures[0].manufacturer,string,False,,,,,
+measures[0].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[0].cpuTrackingMode,string,False,,,,,Not applicable to GPU measure
+measures[0].gpuTrackingMode,string,False,,,,nvml,CodeCarbon interfaces with NVML per paper
+measures[0].averageUtilizationCpu,number,False,,,,,
+measures[0].averageUtilizationGpu,number,False,,,,,Not present in source
+measures[0].powerCalibrationMeasurement,number,False,,,,,
+measures[0].durationCalibrationMeasurement,number,False,,,,,
+measures[0].powerConsumption,number,True,energy_generate_gpu,Float64,"sum(energy_generate_gpu [+ energy_upsample_gpu + energy_denoise_gpu if not null]) grouped by model_name",,Already in kWh; sum across all prompts for that model
+measures[0].measurementDuration,number,False,duration_generate,Float64,"sum(duration_generate [+ duration_upsample + duration_denoise if not null]) grouped by model_name",,Already in seconds
+measures[0].measurementDateTime,string,False,,,,,
+measures[1].measurementMethod,string,True,,,,codecarbon,CPU measure
+measures[1].manufacturer,string,False,,,,,
+measures[1].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[1].cpuTrackingMode,string,False,,,,rapl,CodeCarbon interfaces with pyRAPL per paper
+measures[1].gpuTrackingMode,string,False,,,,,Not applicable to CPU measure
+measures[1].averageUtilizationCpu,number,False,,,,,Not present in source
+measures[1].averageUtilizationGpu,number,False,,,,,
+measures[1].powerCalibrationMeasurement,number,False,,,,,
+measures[1].durationCalibrationMeasurement,number,False,,,,,
+measures[1].powerConsumption,number,True,energy_generate_cpu,Float64,"sum(energy_generate_cpu [+ energy_upsample_cpu + energy_denoise_cpu if not null]) grouped by model_name",,Already in kWh
+measures[1].measurementDuration,number,False,duration_generate,Float64,"sum(duration_generate [+ duration_upsample + duration_denoise if not null]) grouped by model_name",,Same wall-clock duration as GPU measure
+measures[1].measurementDateTime,string,False,,,,,
+measures[2].measurementMethod,string,True,,,,codecarbon,"RAM measure - estimated via CodeCarbon's default heuristic, not directly measured"
+measures[2].manufacturer,string,False,,,,,
+measures[2].version,string,False,,,,,ASSUMPTION GAP - CodeCarbon version not specified
+measures[2].cpuTrackingMode,string,False,,,,,Not applicable to RAM measure
+measures[2].gpuTrackingMode,string,False,,,,,Not applicable to RAM measure
+measures[2].averageUtilizationCpu,number,False,,,,,
+measures[2].averageUtilizationGpu,number,False,,,,,
+measures[2].powerCalibrationMeasurement,number,False,,,,,
+measures[2].durationCalibrationMeasurement,number,False,,,,,
+measures[2].powerConsumption,number,True,energy_generate_ram,Float64,"sum(energy_generate_ram [+ energy_upsample_ram + energy_denoise_ram if not null]) grouped by model_name",,Already in kWh; heuristic estimate not direct measurement
+measures[2].measurementDuration,number,False,duration_generate,Float64,"sum(duration_generate [+ duration_upsample + duration_denoise if not null]) grouped by model_name",,Same wall-clock duration as GPU/CPU measures
+measures[2].measurementDateTime,string,False,,,,,
+system.os,string,True,,,,linux,ASSUMPTION - not stated by user; ML GPU benchmark environment typically Linux
+system.distribution,string,False,,,,,
+system.distributionVersion,string,False,,,,,
+software.language,string,True,,,,python,
+software.version,string,False,,,,,ASSUMPTION GAP - Python version not specified
+infrastructure.infraType,string (enum),True,,,,onPremise,"ASSUMPTION - paper says 'dedicated' GPU with no co-scheduled jobs; cloud vs on-premise not confirmed. Allowed values: publicCloud, privateCloud, onPremise, other"
+infrastructure.cloudProvider,string,False,,,,,
+infrastructure.cloudInstance,string,False,,,,,
+infrastructure.cloudService,string,False,,,,,
+infrastructure.components[0].componentName,string,False,cpu_model,string,,,CPU component
+infrastructure.components[0].componentType,string,True,,,,cpu,
+infrastructure.components[0].nbComponent,integer,True,cpu_count,Int64,,,
+infrastructure.components[0].memorySize,number,False,,,,,Not applicable for CPU component
+infrastructure.components[0].manufacturer,string,False,,,,amd,Parsed from cpu_model "AMD EPYC 7R13 Processor"
+infrastructure.components[0].family,string,False,,,,epyc,
+infrastructure.components[0].series,string,False,,,,7r13,
+infrastructure.components[0].share,number,False,,,,,"Default 1 (dedicated machine, no co-scheduled jobs per paper)"
+infrastructure.components[1].componentName,string,False,gpu_model,string,,,GPU component
+infrastructure.components[1].componentType,string,True,,,,gpu,
+infrastructure.components[1].nbComponent,integer,True,gpu_count,Int64,,,
+infrastructure.components[1].memorySize,number,False,,,,80,"Parsed from gpu_model ""NVIDIA H100 80GB HBM3"" (GB per unit)"
+infrastructure.components[1].manufacturer,string,False,,,,nvidia,
+infrastructure.components[1].family,string,False,,,,h100,
+infrastructure.components[1].series,string,False,,,,sxm,"ASSUMPTION - paper text says 'H100 SXM'; CSV gpu_model text does not distinguish SXM/PCIe"
+infrastructure.components[1].share,number,False,,,,,Default 1
+infrastructure.components[2].componentName,string,False,,,,,RAM component
+infrastructure.components[2].componentType,string,True,,,,ram,
+infrastructure.components[2].nbComponent,integer,True,,,,1,Single RAM pool assumed
+infrastructure.components[2].memorySize,number,False,,,,,"Left blank per user instruction - RAM size not in source data"
+infrastructure.components[2].manufacturer,string,False,,,,,
+infrastructure.components[2].family,string,False,,,,,
+infrastructure.components[2].series,string,False,,,,,
+infrastructure.components[2].share,number,False,,,,,
+environment.country,string,True,,,,,"OMIT ENTIRE environment OBJECT - no country data available (user confirmed 'no country specified'); see mapping_extra_info.md"
+environment.latitude,number,False,,,,,Omit with environment object
+environment.longitude,number,False,,,,,Omit with environment object
+environment.location,string,False,,,,,Omit with environment object
+environment.powerSupplierType,string (enum),False,,,,,Omit with environment object
+environment.powerSource,string (enum),False,,,,,Omit with environment object
+environment.powerSourceCarbonIntensity,number,False,,,,,Omit with environment object
+quality,string (enum),False,,,,high,"Controlled benchmark: 5 measured runs + 2 warmup iterations per prompt"

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_AnimateDiff.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "5fa7123d-70a1-4d46-8382-7a2bfcc9b212",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with AnimateDiff. Output: 512x512, 16 frames @ 10 fps, 4 diffusion steps, guidance_scale=1. Uses adapter ByteDance/AnimateDiff-Lightning (checkpoint animatediff_lightning_4step_diffusers.safetensors) on base model emilianJR/epiCRealism.",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "AnimateDiff",
+        "foundationModelUri": "https://huggingface.co/ByteDance/AnimateDiff-Lightning",
+        "parametersNumber": 1.277,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0056196387179431005,
+      "measurementDuration": 33.3376886844635
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0007615448747093165,
+      "measurementDuration": 33.3376886844635
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.0004044982301864721,
+      "measurementDuration": 33.3376886844635
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_CogVideoX-2b.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "fcbb1cda-8daf-4566-91b8-a1cea69f5c25",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with CogVideoX-2b. Output: 720x480, 49 frames @ 8 fps, 50 diffusion steps, guidance_scale=6.",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "CogVideoX-2b",
+        "foundationModelUri": "https://huggingface.co/THUDM/CogVideoX-2b",
+        "parametersNumber": 2,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.4065223190509389,
+      "measurementDuration": 2477.872232913971
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0413074445974709,
+      "measurementDuration": 2477.872232913971
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.026207985085668902,
+      "measurementDuration": 2477.872232913971
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_CogVideoX-5b.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "109004fc-42e0-4e3a-aae2-518f4f2b368a",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with CogVideoX-5b. Output: 720x480, 49 frames @ 8 fps, 50 diffusion steps, guidance_scale=6.",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "CogVideoX-5b",
+        "foundationModelUri": "https://huggingface.co/THUDM/CogVideoX-5b",
+        "parametersNumber": 5,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 1.059459606178118,
+      "measurementDuration": 6090.837685108185
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.11537630870552909,
+      "measurementDuration": 6090.837685108185
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.0643448302173363,
+      "measurementDuration": 6090.837685108185
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_LTX-Video-0.9.7-dev.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "507f623b-9b55-4b98-8d68-99c224ed554d",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with LTX-Video-0.9.7-dev. Output: 704x512, 121 frames @ 24 fps, 30 diffusion steps. Additional upsample+denoise phase: downscaled 448x320, generate_steps=30, denoise_steps=10, denoise_strength=0.4, decode_timestep=0.05, image_cond_noise_scale=0.025, upsample_model=Lightricks/ltxv-spatial-upscaler-0.9.7. Negative prompt used: \"worst quality, inconsistent motion, blurry, jittery, distorted\".",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "LTX-Video-0.9.7-dev",
+        "foundationModelUri": "https://huggingface.co/Lightricks/LTX-Video-0.9.7-dev",
+        "parametersNumber": 13,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.15497440336834617,
+      "measurementDuration": 872.8568269252777
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.01551406800405404,
+      "measurementDuration": 872.8568269252777
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.009371530087664618,
+      "measurementDuration": 872.8568269252777
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_Mochi-1-preview.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "176f1b4d-77c0-4f15-8e8f-cee9c8746e29",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with Mochi-1-preview. Output: 848x480, 84 frames @ 30 fps, 64 diffusion steps.",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "Mochi-1-preview",
+        "foundationModelUri": "https://huggingface.co/genmo/mochi-1-preview",
+        "parametersNumber": 10,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 2.19133387795458,
+      "measurementDuration": 12898.644016838074
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.22454845362416562,
+      "measurementDuration": 12898.644016838074
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.1362051481645743,
+      "measurementDuration": 12898.644016838074
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_WAN2.1-T2V-1.3B.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "8ed70636-316a-4bff-9cf5-43d146d5b336",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 49,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 832x480, 81 frames @ 15 fps, 60 diffusion steps, guidance_scale=5. Negative prompt used: \"Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards\".",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "parametersNumber": 1.3,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2909
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 49
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 3.861731952827526,
+      "measurementDuration": 20091.968884801867
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.3613186175236096,
+      "measurementDuration": 20091.968884801867
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.2121346123380258,
+      "measurementDuration": 20091.968884801867
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_WAN2.1-T2V-14B.json

@@ -0,0 +1,94 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "4e45a76c-ecbc-4839-92cd-dfa8553f086c",
+    "reportDatetime": "2026-07-23 10:15:50",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 41,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-14B. Output: 832x480, 81 frames @ 15 fps, 60 diffusion steps, guidance_scale=5. Negative prompt used: \"Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards\".",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-14B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-14B-Diffusers",
+        "parametersNumber": 14,
+        "framework": "diffusers"
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 2502
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 41
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 14.747198899083086,
+      "measurementDuration": 76865.76736812593
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 1.4656004357475192,
+      "measurementDuration": 76865.76736812593
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "powerConsumption": 0.8114054799409882,
+      "measurementDuration": 76865.76736812593
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps100_2025-08-17_08-01-58.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "85a978dc-3db2-44e5-92e0-cbdf7c00d3f0",
+    "reportDatetime": "2025-08-17 08:01:58",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 100 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps100_2025-08-17_08-01-58.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 360.5433068275452,
+      "measurementDateTime": "2025-08-17 08:01:58",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0690663369196921
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 360.5433068275452,
+      "measurementDateTime": "2025-08-17 08:01:58",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0063097120441052
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 360.5433068275452,
+      "measurementDateTime": "2025-08-17 08:01:58",
+      "powerConsumption": 0.0038075165951685
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps101_2025-08-17_08-26-20.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "2e9e2c71-5892-406d-9de7-c10535baf255",
+    "reportDatetime": "2025-08-17 08:26:20",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 101 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps101_2025-08-17_08-26-20.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 364.0549844900767,
+      "measurementDateTime": "2025-08-17 08:26:20",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0697356533810686
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 364.0549844900767,
+      "measurementDateTime": "2025-08-17 08:26:20",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0063778451176474
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 364.0549844900767,
+      "measurementDateTime": "2025-08-17 08:26:20",
+      "powerConsumption": 0.0038446422473349
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps102_2025-08-17_08-50-54.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "1c9b89b6-3421-4c28-911b-7f53d11e425e",
+    "reportDatetime": "2025-08-17 08:50:54",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 102 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps102_2025-08-17_08-50-54.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 367.2132449944814,
+      "measurementDateTime": "2025-08-17 08:50:54",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0703798020445371
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 367.2132449944814,
+      "measurementDateTime": "2025-08-17 08:50:54",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0064270899506644
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 367.2132449944814,
+      "measurementDateTime": "2025-08-17 08:50:54",
+      "powerConsumption": 0.0038779640985724
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps103_2025-08-17_09-15-42.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "68ef4833-d434-416d-ac52-9e87f83c061f",
+    "reportDatetime": "2025-08-17 09:15:42",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 103 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps103_2025-08-17_09-15-42.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 371.0958520571391,
+      "measurementDateTime": "2025-08-17 09:15:42",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0710937734490476
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 371.0958520571391,
+      "measurementDateTime": "2025-08-17 09:15:42",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0064956466067859
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 371.0958520571391,
+      "measurementDateTime": "2025-08-17 09:15:42",
+      "powerConsumption": 0.0039189132579925
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps104_2025-08-17_09-40-45.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "b5f277ac-0004-4357-b033-8aaa5dd04245",
+    "reportDatetime": "2025-08-17 09:40:45",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 104 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps104_2025-08-17_09-40-45.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 374.584925254186,
+      "measurementDateTime": "2025-08-17 09:40:45",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0717654529678739
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 374.584925254186,
+      "measurementDateTime": "2025-08-17 09:40:45",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0065506517280331
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 374.584925254186,
+      "measurementDateTime": "2025-08-17 09:40:45",
+      "powerConsumption": 0.003955732330149
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps105_2025-08-17_10-06-02.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "fed5dfce-8e7f-44ef-ac2a-317c4e57ed20",
+    "reportDatetime": "2025-08-17 10:06:02",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 105 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps105_2025-08-17_10-06-02.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 378.3819662729899,
+      "measurementDateTime": "2025-08-17 10:06:02",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0724746914056334
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 378.3819662729899,
+      "measurementDateTime": "2025-08-17 10:06:02",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0066203615814145
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 378.3819662729899,
+      "measurementDateTime": "2025-08-17 10:06:02",
+      "powerConsumption": 0.0039958214572326
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps106_2025-08-17_10-31-34.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "065255ef-520c-4224-9eae-7591db8a2d49",
+    "reportDatetime": "2025-08-17 10:31:34",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 106 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps106_2025-08-17_10-31-34.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 381.5249512990316,
+      "measurementDateTime": "2025-08-17 10:31:34",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0731090949687095
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 381.5249512990316,
+      "measurementDateTime": "2025-08-17 10:31:34",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0066708275755673
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 381.5249512990316,
+      "measurementDateTime": "2025-08-17 10:31:34",
+      "powerConsumption": 0.0040290017874521
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps107_2025-08-17_10-57-19.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "28cb612c-7398-4076-a82d-3a0fcbb01043",
+    "reportDatetime": "2025-08-17 10:57:19",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 107 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps107_2025-08-17_10-57-19.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 385.43336550394696,
+      "measurementDateTime": "2025-08-17 10:57:19",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.073827678136169
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 385.43336550394696,
+      "measurementDateTime": "2025-08-17 10:57:19",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.006735103226474
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 385.43336550394696,
+      "measurementDateTime": "2025-08-17 10:57:19",
+      "powerConsumption": 0.0040702576855146
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps108_2025-08-17_11-23-20.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "35e36342-638a-4468-9a7e-af700f8cacee",
+    "reportDatetime": "2025-08-17 11:23:20",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 108 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps108_2025-08-17_11-23-20.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 388.5975617567698,
+      "measurementDateTime": "2025-08-17 11:23:20",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0744576667883076
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 388.5975617567698,
+      "measurementDateTime": "2025-08-17 11:23:20",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0068063310494727
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 388.5975617567698,
+      "measurementDateTime": "2025-08-17 11:23:20",
+      "powerConsumption": 0.0041036976473245
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps109_2025-08-17_11-49-35.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "a11c1a8e-e954-4c99-8b4b-256866ff57e6",
+    "reportDatetime": "2025-08-17 11:49:35",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 109 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps109_2025-08-17_11-49-35.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 392.3612826665242,
+      "measurementDateTime": "2025-08-17 11:49:35",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0751739016205543
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 392.3612826665242,
+      "measurementDateTime": "2025-08-17 11:49:35",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.006864708505556
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 392.3612826665242,
+      "measurementDateTime": "2025-08-17 11:49:35",
+      "powerConsumption": 0.0041433810488198
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps10_2025-08-16_11-40-12.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "3f042a96-b2d9-471c-b461-8ea98c828b71",
+    "reportDatetime": "2025-08-16 11:40:12",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 10 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps10_2025-08-16_11-40-12.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 40.4174591700236,
+      "measurementDateTime": "2025-08-16 11:40:12",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0077130076518822
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 40.4174591700236,
+      "measurementDateTime": "2025-08-16 11:40:12",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0007145885278082
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 40.4174591700236,
+      "measurementDateTime": "2025-08-16 11:40:12",
+      "powerConsumption": 0.0004284127299624
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps110_2025-08-17_12-16-04.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "4e21ca4f-0438-4acb-97f4-75bbf0617e1b",
+    "reportDatetime": "2025-08-17 12:16:04",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 110 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps110_2025-08-17_12-16-04.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 396.0121046702067,
+      "measurementDateTime": "2025-08-17 12:16:04",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0758653379144433
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 396.0121046702067,
+      "measurementDateTime": "2025-08-17 12:16:04",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0069386774162158
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 396.0121046702067,
+      "measurementDateTime": "2025-08-17 12:16:04",
+      "powerConsumption": 0.0041819174320391
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps111_2025-08-17_12-42-47.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "682127a3-508c-40ae-8eb0-2dc7363ec658",
+    "reportDatetime": "2025-08-17 12:42:47",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 111 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps111_2025-08-17_12-42-47.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 399.88246329625446,
+      "measurementDateTime": "2025-08-17 12:42:47",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0766004459099392
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 399.88246329625446,
+      "measurementDateTime": "2025-08-17 12:42:47",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0070252832009656
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 399.88246329625446,
+      "measurementDateTime": "2025-08-17 12:42:47",
+      "powerConsumption": 0.004222767762829
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps112_2025-08-17_13-09-42.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "4fc1d998-89f7-4206-936c-2484dc118fe9",
+    "reportDatetime": "2025-08-17 13:09:42",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 112 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps112_2025-08-17_13-09-42.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 403.5731239318848,
+      "measurementDateTime": "2025-08-17 13:09:42",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0773136660175524
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 403.5731239318848,
+      "measurementDateTime": "2025-08-17 13:09:42",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0071344370331964
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 403.5731239318848,
+      "measurementDateTime": "2025-08-17 13:09:42",
+      "powerConsumption": 0.0042617183962292
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps113_2025-08-17_13-36-51.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "3e7d984b-76af-44d4-bf51-a8ee527674ed",
+    "reportDatetime": "2025-08-17 13:36:51",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 113 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps113_2025-08-17_13-36-51.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 407.60093998909,
+      "measurementDateTime": "2025-08-17 13:36:51",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0780721057909706
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 407.60093998909,
+      "measurementDateTime": "2025-08-17 13:36:51",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0071915608759918
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 407.60093998909,
+      "measurementDateTime": "2025-08-17 13:36:51",
+      "powerConsumption": 0.0043042338625901
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps114_2025-08-17_14-04-15.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "34b32c90-3b7b-4c25-ac4c-30b494ff12d8",
+    "reportDatetime": "2025-08-17 14:04:15",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 114 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps114_2025-08-17_14-04-15.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 411.260049422582,
+      "measurementDateTime": "2025-08-17 14:04:15",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0787737307041188
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 411.260049422582,
+      "measurementDateTime": "2025-08-17 14:04:15",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0072734738834696
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 411.260049422582,
+      "measurementDateTime": "2025-08-17 14:04:15",
+      "powerConsumption": 0.0043428665408
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps115_2025-08-17_14-31-54.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "b29348b0-51af-41ed-9d1f-b8efcd6fa860",
+    "reportDatetime": "2025-08-17 14:31:54",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 115 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps115_2025-08-17_14-31-54.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 415.108807404836,
+      "measurementDateTime": "2025-08-17 14:31:54",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0795033699915327
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 415.108807404836,
+      "measurementDateTime": "2025-08-17 14:31:54",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.007350351985073
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 415.108807404836,
+      "measurementDateTime": "2025-08-17 14:31:54",
+      "powerConsumption": 0.0043834884727026
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps116_2025-08-17_14-59-49.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "2e6346ac-1e8c-466f-826e-6fbebcbf206d",
+    "reportDatetime": "2025-08-17 14:59:49",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 116 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps116_2025-08-17_14-59-49.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 418.7338016827901,
+      "measurementDateTime": "2025-08-17 14:59:49",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0802015210130164
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 418.7338016827901,
+      "measurementDateTime": "2025-08-17 14:59:49",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0074013226340768
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 418.7338016827901,
+      "measurementDateTime": "2025-08-17 14:59:49",
+      "powerConsumption": 0.0044217503808661
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps117_2025-08-17_15-27-58.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "2cafb50a-4c09-4716-ab51-34aec583005c",
+    "reportDatetime": "2025-08-17 15:27:58",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 117 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps117_2025-08-17_15-27-58.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 423.15050053596497,
+      "measurementDateTime": "2025-08-17 15:27:58",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0809917082192418
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 423.15050053596497,
+      "measurementDateTime": "2025-08-17 15:27:58",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0074950527907652
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 423.15050053596497,
+      "measurementDateTime": "2025-08-17 15:27:58",
+      "powerConsumption": 0.0044683756978231
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps118_2025-08-17_15-56-25.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "672e992a-9046-4a2c-948f-40cd69da6816",
+    "reportDatetime": "2025-08-17 15:56:25",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 118 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps118_2025-08-17_15-56-25.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 426.6690895557404,
+      "measurementDateTime": "2025-08-17 15:56:25",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0816738299686411
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 426.6690895557404,
+      "measurementDateTime": "2025-08-17 15:56:25",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0075387809387103
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 426.6690895557404,
+      "measurementDateTime": "2025-08-17 15:56:25",
+      "powerConsumption": 0.0045055186589401
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps119_2025-08-17_16-25-05.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "60933138-4d10-42a0-9713-36dd388ca869",
+    "reportDatetime": "2025-08-17 16:25:05",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 119 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps119_2025-08-17_16-25-05.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 430.0063713391622,
+      "measurementDateTime": "2025-08-17 16:25:05",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0823296772525784
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 430.0063713391622,
+      "measurementDateTime": "2025-08-17 16:25:05",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0076135486979635
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 430.0063713391622,
+      "measurementDateTime": "2025-08-17 16:25:05",
+      "powerConsumption": 0.0045407449980303
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps11_2025-08-16_11-43-11.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "8f7d70fb-a05b-40e6-907a-9136e886cd91",
+    "reportDatetime": "2025-08-16 11:43:11",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 11 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps11_2025-08-16_11-43-11.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 43.976036071777344,
+      "measurementDateTime": "2025-08-16 11:43:11",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0083971664399484
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 43.976036071777344,
+      "measurementDateTime": "2025-08-16 11:43:11",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0007811208752783
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 43.976036071777344,
+      "measurementDateTime": "2025-08-16 11:43:11",
+      "powerConsumption": 0.0004659717075322
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps120_2025-08-17_16-54-00.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "f6394208-0c70-4669-9978-2c8c6ce0f32b",
+    "reportDatetime": "2025-08-17 16:54:00",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 120 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps120_2025-08-17_16-54-00.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 433.4761091073354,
+      "measurementDateTime": "2025-08-17 16:54:00",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.083009865111542
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 433.4761091073354,
+      "measurementDateTime": "2025-08-17 16:54:00",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0076830285729207
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 433.4761091073354,
+      "measurementDateTime": "2025-08-17 16:54:00",
+      "powerConsumption": 0.0045773610287485
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps121_2025-08-17_17-23-08.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "ca48777a-db76-42a4-b0a5-431c9ace1d41",
+    "reportDatetime": "2025-08-17 17:23:08",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 121 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps121_2025-08-17_17-23-08.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 437.19378701845807,
+      "measurementDateTime": "2025-08-17 17:23:08",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.08369546454891
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 437.19378701845807,
+      "measurementDateTime": "2025-08-17 17:23:08",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0077661125347062
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 437.19378701845807,
+      "measurementDateTime": "2025-08-17 17:23:08",
+      "powerConsumption": 0.0046166093072925
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps122_2025-08-17_17-52-31.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "4fdd6ef4-61f6-4920-bb7d-818b15384877",
+    "reportDatetime": "2025-08-17 17:52:31",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 122 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps122_2025-08-17_17-52-31.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 440.9567515055339,
+      "measurementDateTime": "2025-08-17 17:52:31",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0843973361289253
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 440.9567515055339,
+      "measurementDateTime": "2025-08-17 17:52:31",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0078171232018194
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 440.9567515055339,
+      "measurementDateTime": "2025-08-17 17:52:31",
+      "powerConsumption": 0.0046563329743655
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps123_2025-08-17_18-22-10.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "ac0c8bf5-351e-44fe-821f-b5ef4fbbb570",
+    "reportDatetime": "2025-08-17 18:22:10",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 123 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps123_2025-08-17_18-22-10.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 445.065528233846,
+      "measurementDateTime": "2025-08-17 18:22:10",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0851369457020941
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 445.065528233846,
+      "measurementDateTime": "2025-08-17 18:22:10",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0078863543892552
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 445.065528233846,
+      "measurementDateTime": "2025-08-17 18:22:10",
+      "powerConsumption": 0.0046997100189346
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps124_2025-08-17_18-52-04.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "e2eeec49-fd39-487d-800b-af52bf21e472",
+    "reportDatetime": "2025-08-17 18:52:04",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 124 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps124_2025-08-17_18-52-04.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 448.0918924013774,
+      "measurementDateTime": "2025-08-17 18:52:04",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0857743496379418
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 448.0918924013774,
+      "measurementDateTime": "2025-08-17 18:52:04",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0079191406168587
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 448.0918924013774,
+      "measurementDateTime": "2025-08-17 18:52:04",
+      "powerConsumption": 0.0047316445802918
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps125_2025-08-17_19-22-12.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "10530b6d-6fba-4017-8a45-561b3808eddb",
+    "reportDatetime": "2025-08-17 19:22:12",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 125 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps125_2025-08-17_19-22-12.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 450.82958738009137,
+      "measurementDateTime": "2025-08-17 19:22:12",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0863362163837327
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 450.82958738009137,
+      "measurementDateTime": "2025-08-17 19:22:12",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0079938138243857
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 450.82958738009137,
+      "measurementDateTime": "2025-08-17 19:22:12",
+      "powerConsumption": 0.0047605435586775
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps126_2025-08-17_19-52-31.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "19be7f57-a842-45b8-9897-8aa7ab3f2729",
+    "reportDatetime": "2025-08-17 19:52:31",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 126 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps126_2025-08-17_19-52-31.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 455.10740900039673,
+      "measurementDateTime": "2025-08-17 19:52:31",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0871404826752926
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 455.10740900039673,
+      "measurementDateTime": "2025-08-17 19:52:31",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.008036495889976
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 455.10740900039673,
+      "measurementDateTime": "2025-08-17 19:52:31",
+      "powerConsumption": 0.0048056954597219
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps127_2025-08-17_20-23-06.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "f70468f4-cb0c-4175-938f-18eff1d3fe8d",
+    "reportDatetime": "2025-08-17 20:23:06",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 127 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps127_2025-08-17_20-23-06.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 458.446489016215,
+      "measurementDateTime": "2025-08-17 20:23:06",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0877883281935728
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 458.446489016215,
+      "measurementDateTime": "2025-08-17 20:23:06",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0081350013474576
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 458.446489016215,
+      "measurementDateTime": "2025-08-17 20:23:06",
+      "powerConsumption": 0.0048409605658844
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps128_2025-08-17_20-53-54.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "0b6490f3-950b-46f0-ba50-ffeb8df3592b",
+    "reportDatetime": "2025-08-17 20:53:54",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 128 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps128_2025-08-17_20-53-54.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 462.6596740881602,
+      "measurementDateTime": "2025-08-17 20:53:54",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0885436130570553
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 462.6596740881602,
+      "measurementDateTime": "2025-08-17 20:53:54",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0093805602844804
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 462.6596740881602,
+      "measurementDateTime": "2025-08-17 20:53:54",
+      "powerConsumption": 0.0048854087237157
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps129_2025-08-17_21-24-59.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "00ffd58a-131e-4f68-8753-de77448ece39",
+    "reportDatetime": "2025-08-17 21:24:59",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 129 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps129_2025-08-17_21-24-59.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 465.6753062407176,
+      "measurementDateTime": "2025-08-17 21:24:59",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0891629166080534
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 465.6753062407176,
+      "measurementDateTime": "2025-08-17 21:24:59",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0095206293220796
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 465.6753062407176,
+      "measurementDateTime": "2025-08-17 21:24:59",
+      "powerConsumption": 0.0049172767074053
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps12_2025-08-16_11-46-23.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "398f05a7-b899-4747-8c4e-79a11f430396",
+    "reportDatetime": "2025-08-16 11:46:23",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 12 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps12_2025-08-16_11-46-23.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 47.62348612149557,
+      "measurementDateTime": "2025-08-16 11:46:23",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0090849580087019
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 47.62348612149557,
+      "measurementDateTime": "2025-08-16 11:46:23",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0008475591207283
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 47.62348612149557,
+      "measurementDateTime": "2025-08-16 11:46:23",
+      "powerConsumption": 0.0005044694358847
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps130_2025-08-17_21-56-16.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "670c10a2-0815-4105-b56f-61b8dcb2f5fd",
+    "reportDatetime": "2025-08-17 21:56:16",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 130 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps130_2025-08-17_21-56-16.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 469.0192046960195,
+      "measurementDateTime": "2025-08-17 21:56:16",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0898261046386063
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 469.0192046960195,
+      "measurementDateTime": "2025-08-17 21:56:16",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0095765040621699
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 469.0192046960195,
+      "measurementDateTime": "2025-08-17 21:56:16",
+      "powerConsumption": 0.0049525458516622
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps131_2025-08-17_22-27-49.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "c66b921b-27a8-4762-8e12-4cfd4303ff65",
+    "reportDatetime": "2025-08-17 22:27:49",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 131 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps131_2025-08-17_22-27-49.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 471.0062781969706,
+      "measurementDateTime": "2025-08-17 22:27:49",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0902461005301565
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 471.0062781969706,
+      "measurementDateTime": "2025-08-17 22:27:49",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0096487728898006
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 471.0062781969706,
+      "measurementDateTime": "2025-08-17 22:27:49",
+      "powerConsumption": 0.004973518181369
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps132_2025-08-17_22-59-27.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "e6942750-3339-4e91-9740-a3e4201e4519",
+    "reportDatetime": "2025-08-17 22:59:27",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 132 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps132_2025-08-17_22-59-27.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 475.79337135950726,
+      "measurementDateTime": "2025-08-17 22:59:27",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0911237598433937
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 475.79337135950726,
+      "measurementDateTime": "2025-08-17 22:59:27",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.009613761016704
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 475.79337135950726,
+      "measurementDateTime": "2025-08-17 22:59:27",
+      "powerConsumption": 0.0050240566753585
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}

data/video_killed_the_energy_budget/reports/report_video-killed-energy_inference_text-to-video-generation_onPremise_exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps133_2025-08-17_23-31-25.json

@@ -0,0 +1,97 @@
+{
+  "header": {
+    "licensing": "Creative Commons 4.0",
+    "formatVersion": "0.1",
+    "reportId": "5ce056fc-9ec4-4ca0-97bd-3cc6031bf56c",
+    "reportDatetime": "2025-08-17 23:31:25",
+    "reportStatus": "final",
+    "publisher": {
+      "name": "Julien Delavande, Regis Pierrard, Sasha Luccioni",
+      "projectName": "Video Killed the Energy Budget: Characterizing the Latency and Power Regimes of Open Text-to-Video Models",
+      "confidentialityLevel": "public"
+    }
+  },
+  "task": {
+    "taskStage": "inference",
+    "taskFamily": "text to video generation",
+    "nbRequest": 1,
+    "taskDescription": "Text-to-video generation with WAN2.1-T2V-1.3B. Output: 1280x720, 50 frames @ 15 fps, 133 diffusion steps, guidance_scale=5.0. Part of a scaling-law parameter sweep varying 'steps' (run: exp10_steps_Wan2.1-T2V-1.3B-Diffusers_results_prompt1_steps133_2025-08-17_23-31-25.csv).",
+    "algorithms": [
+      {
+        "algorithmType": "diffusion model",
+        "foundationModelName": "WAN2.1-T2V-1.3B",
+        "foundationModelUri": "https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        "framework": "diffusers",
+        "parametersNumber": 1.3
+      }
+    ],
+    "dataset": [
+      {
+        "dataUsage": "input",
+        "dataType": "text",
+        "dataFormat": "text",
+        "dataQuantity": 213
+      },
+      {
+        "dataUsage": "output",
+        "dataType": "video",
+        "dataQuantity": 1
+      }
+    ]
+  },
+  "measures": [
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 479.13936257362366,
+      "measurementDateTime": "2025-08-17 23:31:25",
+      "gpuTrackingMode": "nvml",
+      "powerConsumption": 0.0916854220519833
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 479.13936257362366,
+      "measurementDateTime": "2025-08-17 23:31:25",
+      "cpuTrackingMode": "rapl",
+      "powerConsumption": 0.0098873992864835
+    },
+    {
+      "measurementMethod": "codecarbon",
+      "measurementDuration": 479.13936257362366,
+      "measurementDateTime": "2025-08-17 23:31:25",
+      "powerConsumption": 0.0050593639182818
+    }
+  ],
+  "system": {
+    "os": "linux"
+  },
+  "software": {
+    "language": "python"
+  },
+  "infrastructure": {
+    "infraType": "onPremise",
+    "components": [
+      {
+        "componentName": "AMD EPYC 7R13 Processor",
+        "componentType": "cpu",
+        "nbComponent": 8,
+        "manufacturer": "amd",
+        "family": "epyc",
+        "series": "7r13"
+      },
+      {
+        "componentName": "NVIDIA H100 80GB HBM3",
+        "componentType": "gpu",
+        "nbComponent": 1,
+        "memorySize": 80,
+        "manufacturer": "nvidia",
+        "family": "h100",
+        "series": "sxm"
+      },
+      {
+        "componentType": "ram",
+        "nbComponent": 1
+      }
+    ]
+  },
+  "quality": "high"
+}