HDF5 für Simulationsdaten: Parallele E/A und Langzeitspeicherung

Reading Time: 10 minutes

HDF5 ist der De-facto-Standard für die Speicherung von wissenschaftlichen Simulationsdaten im großen Maßstab. Seine hierarchische Struktur, die parallelen E/A-Funktionen über MPI und die integrierte Komprimierung machen es ideal für Hochleistungs-Computing-Umgebungen. Eine unsachgemäße Verwendung – insbesondere schlechte Chunking-Optionen und falsche parallele Zugriffsmuster – kann jedoch zu starker Leistungsminderung oder Datenbeschädigung führen. Dieser Leitfaden behandelt die HDF5-Architektur, die parallele I/O-Implementierung in Python, Techniken zur Leistungsoptimierung und Best Practices für die Aufbewahrung für die langfristige Speicherung.

Einleitung: Die Simulationsdaten-Herausforderung

Wissenschaftliche Simulationen generieren routinemäßig Terabyte Daten über Tausende von Zeitschritten und mehrere physikalische Felder. Die Verwaltung dieser Sintflut erfordert mehr als nur ein Dateiformat – es erfordert ein System, das verarbeiten kann:

Scale: Gigabyte bis Petabyte von mehrdimensionalen Arrays
Leistung: Effizientes Lesen/Schreiben auf HPC-Systemen mit parallelen Dateisystemen
Organisation: Selbstbeschreibende Strukturen, die Jahre später verständlich bleiben
Haltbarkeit: Langzeitkonservierung ohne Formatveralterung
Access: Schnelle Untereinstellung ohne vollständige Datensätze zu lesen

HDF5 (Hierarchical Data Format Version 5) behebt diese Herausforderungen durch eine Kombination aus flexibler Datenmodellierung, paralleler E/A-Unterstützung und Metadatenintegration. Von der NASA, der NASA, den DOE-Labors und den Forschungseinrichtungen weit verbreitet, ist HDF5 zum Rückgrat wissenschaftlicher Datenarchive weltweit geworden[^1][^2].

Was ist HDF5? Architektur und Kernkonzepte

HDF5 ist sowohl ein Dateiformat als auch eine Softwarebibliothek, die einen Container für heterogene wissenschaftliche Daten bereitstellt. Seine Architektur basiert auf sechs grundlegenden Einheiten[^3]:

Gruppe: Containerobjekte analog zu Verzeichnissen, hierarchisch organisieren
Dataset: Mehrdimensionale Arrays mit tatsächlichen numerischen oder strukturierten Daten
Dataspace: Beschreibt die Datensatzdimensionen (Form, Rang und Ausmaß)
DataType: Gibt Elementtypen an (Ganzzahl, Floats, Strings, Compounds)
Attribut: Kleine Metadaten an Gruppen oder Datensätze
link: Verbindet Objekte innerhalb der Hierarchie (Hard- und Softlinks)

Die hierarchische Struktur

Eine HDF5-Datei ist ein gerichteter Graph mit einer einzelnen Wurzelgruppe (/). Gruppen können andere Gruppen und Datasets enthalten, die beliebig tiefe Verschachtelung ermöglichen. Diese Struktur spiegelt ein Dateisystem wider, aber mit wesentlichen Unterschieden:

Selbstbeschreibung: Alle Metadaten (Datentypen, Dimensionen) reisen mit den Daten
Portable: Plattformunabhängiges Binärformat
Extensible: Datensätze können in der Größe geändert und Gruppen/Datasets dynamisch hinzugefügt werden
Komprimiert: Chunk-basierte Speicherung ermöglicht Komprimierungsfilter pro Chunk

/simulation
├── metadata
│   ├── title (attribute)
│   ├── creation_date (attribute)
│   └── parameters (group)
│       ├── mesh_size (dataset)
│       └── time_step (dataset)
├── fields
│   ├── temperature (dataset, 3D [x,y,z,time])
│   ├── velocity (dataset, 4D [x,y,z,time,component])
│   └── pressure (dataset, 3D)
└── output
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

Warum HDF5 für wissenschaftliche Simulation?

Im Vergleich zu einfachen Textformaten (CSV, JSON) oder einfacheren Binärformaten bietet HDF5 kritische Vorteile:

Partial I/O: Nur notwendige Teilmengen lesen, ohne ganze Datensätze zu laden
Kompression: Verlustfreie Komprimierung (gzip, szip, lzf) reduziert die Speicherung um 2–10×
Parallel Access: Mehrere Prozesse können über MPI-IO gleichzeitig lesen/schreiben
Metadatenreichtum: Attribute Dokumenteinheiten, Beschreibungen und Provenienz
Große Dateiunterstützung: Behandelt Dateien mit mehr als 2 GB (im Gegensatz zu älteren HDF4)
Cross-Plattform: Funktioniert unter Linux, macOS, Windows; Unterstützt in Python, C, C++, FORTRAN, MATLAB, R

Bei Simulations-Workflows – bei denen Checkpoint-Dateien, Zeitreihenausgaben und Netzdaten über Jahre bestehen müssen – sind diese Funktionen nicht optional; Sie sind essentiell.

Grundlegendes zur HDF5-Datenorganisation

Gruppen und Datensätze: Die Bausteine

Gruppen bieten Namespaces und logische Organisation. Jede Datei hat eine Root-Gruppe (/) und Sie können verschachtelte Gruppen beliebig erstellen. Gruppen selbst speichern keine Daten; Sie enthalten Links zu Datasets und anderen Gruppen.

Datasets sind dort, wo Ihre Simulationsergebnisse leben. Ein Dataset ist ein mehrdimensionales Array mit festen oder erweiterbaren Dimensionen. Gemeinsame Muster für Simulationsdaten:

3D-Felder: (nx, ny, nz) Arrays für räumliche Variablen
4D-Zeitreihen: (nx, ny, nz, nt) Arrays mit der vierten Dimension
2D-Schnitte: (nx, nt) für Liniensonden oder Sensordaten
Strukturierte Daten: Zusammengesetzte Datentypen für Partikeleigenschaften (Position, Geschwindigkeit, Masse)

Datenbereiche: Gestalten Ihrer Daten

Ein Dataspace definiert das logische Layout eines Datasets. HDF5 unterstützt:

Skalar: Einzelwert (0-D)
Simple: Reguläres N-dimensionales Array mit festen oder unbegrenzten Abmessungen
Komplex: Willkürliche Auswahl mit Hyperslabs

Unbegrenzte Dimensionen (erweiterbare Achsen) sind entscheidend für Simulationsausgaben, bei denen die Anzahl der Zeitschritte vorher unbekannt ist.

Attribute: die selbst beschreibende Kraft

Attribute sind kleine Metadatenobjekte, die an Gruppen oder Datasets angehängt sind. Sie sind der primäre Mechanismus für die Dokumentation Ihrer Daten[^4]. Verwenden Sie Attribute zum Speichern:

Physikalische Einheiten ("m/s", "K", "Pa")
Beschreibung Zeichenfolgen
Zeitstempel
Simulationsparameter
Zitierinformationen
Softwareversion verwendet

# Example: Adding attributes with h5py
import h5py

with h5py.File('simulation.h5', 'w') as f:
    grp = f.create_group('temperature')
    dset = grp.create_dataset('field', data=temperature_array)
    
    dset.attrs['units'] = 'Kelvin'
    dset.attrs['long_name'] = 'Temperature field'
    dset.attrs['simulation_time'] = 1234.56

Parallele E/A mit HDF5

Was ist paralleles HDF5?

Parallel HDF5 (PHDF5) erweitert die Standardbibliothek um MPI-IO-Unterstützung, sodass mehrere Prozesse gleichzeitig auf dieselbe HDF5-Datei zugreifen können. Dies ist für groß angelegte Simulationen auf HPC-Clustern unerlässlich, in denen der Rechenauftrag Hunderte oder Tausende von Kernen umfasst [^5].

Wie es funktioniert

Unter der Haube verwendet PHDF5 MPI-IO (das parallele E / A-Subsystem von MPI), um den Zugriff zu koordinieren. Beim Öffnen einer Datei im Parallelmodus teilen alle Prozesse im MPI Communicator denselben Dateihandle und Koordinatenlesen/Schreiben.

# Parallel HDF5 example (requires h5py built with MPI support)
from mpi4py import MPI
import h5py

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

# Each process opens the file collectively
with h5py.File('parallel_output.h5', 'w', driver='mpio', comm=comm) as f:
    # Create a dataset distributed across all processes
    # Each process writes its chunk of the global array
    local_data = compute_local_chunk(rank, size)
    dset = f.create_dataset('field', (global_nx, global_ny), dtype='f8')
    # Write using hyperslabs
    dset[local_slice] = local_data

Kollektive vs. unabhängige E/A

Eine kritische Leistungsunterscheidung in paralleler HDF5:

Collective I/O: Alle Prozesse nehmen an derselben E/A-Operation teil. Die MPI-Bibliothek kann Datenbewegung, Aggregation und Striping optimieren. Verwenden Sie dies wann immer möglich.
Independent I/O: Jeder Prozess öffnet, liest und schreibt unabhängig. Dies führt zu einer schlechten Leistung aufgrund von Dateisystemkonflikten und verpassten Optimierungsmöglichkeiten[^6].

Best Practice: Strukturieren Sie Ihren Code so, dass alle Prozesse gleichzeitig read() oder write() mit kompatiblen HyperSlab-Auswahlen aufrufen. Vermeiden Sie bedingte E / A, die nur einige Prozesse ausführen.

Parallele HDF5-Leistungstipps

Aggregate Writes: Schreiben Sie in großen zusammenhängenden Stücken, nicht in vielen kleinen Stücken
Gesamtpufferung verwenden: Lassen Sie den MPI-Bibliotheks-Cache und Coalesce schreiben
Stücke mit Prozesszerlegung ausrichten: Ordnen Sie den Datensatz-Chunking Ihrer Domain-Zerlegung zu
Vermeiden Sie Dateisystem-Thrashing: Verwenden Sie eine Datei pro Ausgabeschritt, nicht eine Datei pro Prozess
Geeignete Chunk-Cache-Größe festlegen: Erhöhen Sie den Cache für häufig abgerufene Datasets

HDF5 mit Python: Die H5Py-Bibliothek

Das h5py-Paket bietet die pythonischste Schnittstelle zu HDF5[^7].

Grundlegende Operationen

import h5py
import numpy as np

# Writing data
with h5py.File('output.h5', 'w') as f:
    # Create a dataset
    data = np.random.randn(1000, 1000)
    dset = f.create_dataset('temperature', data=data, compression='gzip')
    
    # Add attributes
    dset.attrs['units'] = 'K'
    dset.attrs['description'] = 'Temperature at final time step'
    
    # Create groups for organization
    grp = f.create_group('initial_conditions')
    grp.create_dataset('velocity', data=velocity_field)

# Reading data
with h5py.File('output.h5', 'r') as f:
    temp = f['temperature'][:]  # Load entire dataset
    # Or read a slice
    slice_ = f['temperature'][100:200, 300:400]
    
    # Access attributes
    units = f['temperature'].attrs['units']

Simulationsausgabe effizient schreiben

Verwenden Sie für zeitabhängige Simulationen Erweiterbare Datasets mit einer unbegrenzten Zeitdimension:

with h5py.File('time_series.h5', 'w') as f:
    # Create dataset with unlimited maxshape
    dset = f.create_dataset(
        'temperature', 
        shape=(0, nx, ny), 
        maxshape=(None, nx, ny),  # Unlimited time dimension
        dtype='f8',
        chunks=(1, nx, ny)  # Chunk along time axis
    )
    
    # Append each time step
    for t in range(num_steps):
        current_temp = simulate_step(t)
        dset.resize((t+1, nx, ny))  # Extend dataset
        dset[t, :, :] = current_temp

Anhängen-Modus für Prüfpunkte

Verwenden Sie den Append-Modus ('a'), um vorhandenen Dateien neue Ausgaben hinzuzufügen, ohne zu überschreiben:

with h5py.File('run_001.h5', 'a') as f:
    if 'checkpoint_002' not in f:
        f.create_dataset('checkpoint_002', data=new_data)

Leistungsoptimierung: Chunking und Komprimierung

Chunking: Der Schlüssel zur Leistung

HDF5 speichert Datensätze in Chunks – Hyper-Rechtecke mit fester Größe, die die Einheit von E/A und Komprimierung sind[^8]. Chunking ist Erforderlich für:

Datensatzkomprimierung
Erweiterbare Datensätze
Effiziente partielle Lese- / Schreibvorgänge
Parallele E / A

Chunk-Größe wirkt sich dramatisch auf die Leistung aus:

Zu klein: Übermäßiger Metadaten-Overhead, schlechte Kompressionsverhältnisse, hoher Systemaufruf-Overhead
Zu groß: Das Lesen einer kleinen Teilmenge lädt den gesamten Block in den Speicher und verschwendet die E/A-Bandbreite

Faustregel: Wählen Sie Blöcke, die Ihrem typischen Zugriffsmuster entsprechen. Für 3D-Zeitreihen, die plan-by-plane aufrufen, chunk als (1, nx, ny) oder (nt, nx, 1), je nachdem, welche Dimension am schnellsten variiert.

# Optimal chunking for 3D time-series where we read full XY planes
dset = f.create_dataset(
    'field',
    shape=(nt, nx, ny),
    chunks=(1, nx, ny),  # Each time step is one chunk
    compression='gzip'
)

# Reading one time step only decompresses one chunk
time_step_50 = dset[50, :, :]

Komprimierung: Trade Storage für CPU

HDF5 unterstützt mehrere verlustfreie Komprimierungsfilter:

Gzip: universell, gute Komprimierung (2–5 ×), CPU-intensiv
szip: Schnell, hardwarebeschleunigt auf einigen Systemen, weniger portabel
LZF: Sehr schnelle, mäßige Kompression (2×)
Blosc: Hochleistungs-Multi-Thread (über externe Bibliothek)

Wann komprimieren:

Archivspeicher, bei dem die Größe wichtiger ist als die Schreibgeschwindigkeit
I/O-gebundene Workloads, bei denen der Dekompressionsaufwand geringer ist als die Lesezeit der Festplatte
Wenn Daten Redundanz aufweisen (glatte Felder, wiederholte Werte)

Wann Komprimierung vermeiden:

Ultra-Hochleistungsschreibpfade (Checkpoint-Intervalle < 1 Sekunde)
Bereits komprimierte Daten (Bilder, Videos)
Bei paralleler E/A mit nicht übereinstimmenden Chunk-Größen

# Compression examples
dset = f.create_dataset('data', data=data, compression='gzip', compression_opts=4)  # gzip level 4
dset = f.create_dataset('data', data=data, compression='lzf')  # Fast LZF

Cache-Konfiguration

Die HDF5-Bibliothek verwaltet zwei Caches:

Metadaten-Cache: Speichert Informationen zu Gruppen, Datasets, Attributen
Chunk-Cache: Hält kürzlich aufgerufene Datenblöcke

Für leistungskritische Workloads stimmen Sie diese Caches über h5py ab:

with h5py.File('file.h5', 'w', libver='latest') as f:
    f.swmr_mode = True  # Enable Single-Writer-Multiple-Reader for concurrent access
    
# Configure chunk cache when opening
with h5py.File('file.h5', 'r', rdcc_nbytes=1024**3, rdcc_w0=0.75) as f:
    # 1 GB chunk cache, 75% preemption policy
    pass

Best Practices für Datenorganisation

Dateistrukturmuster

single-file-per-run: Speichern Sie alle Ausgaben einer Simulation in einer einzigen HDF5-Datei mit einer klaren Gruppenhierarchie. Vorteile:

Einzeltransfer- / Archiveinheit
Atomische Updates (entweder alle Daten sind geschrieben oder keine)
Einfachere Integrität zu validieren

Prüfpunkte für mehrere Dateien: Separate Checkpoint-Dateien von der endgültigen Ausgabe. Verwenden Sie Softlinks, um sie zu verbinden:

run_001.h5
├── /initial (link to checkpoint_000.h5:/data)
├── /final
│   └── field (dataset)
└── /checkpoints (group)
    ├── checkpoint_000.h5 (external link)
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

Dokumentieren Sie alles mit Attributen

HDF5-Dateien können ohne gründliche Dokumentation undurchdringlich werden. Jeder Datensatz und jede Gruppe sollten beschreibende Attribute haben[^9]:

dset.attrs['units'] = 'm/s'
dset.attrs['long_name'] = 'Fluid velocity vector'
dset.attrs['standard_name'] = 'velocity'
dset.attrs['positive'] = 'up'  # For vertical components
dset.attrs['grid_mapping'] = '/mesh/x_grid'  # Link to coordinate variables
dset.attrs['comment'] = 'Computed using second-order upwind scheme'
dset.attrs['software'] = 'FiPy 3.4'
dset.attrs['git_commit'] = 'abc123def'

Erwägen Sie die Übernahme der Klima- und Prognosekonventionen für geophysikalische Simulationen oder domänenspezifische Metadatenstandards, sofern verfügbar.

Vermeiden Sie die Proliferation des Datensatzes

Während HDF5 Millionen von Datensätzen zulässt, verschlechtert sich die Leistung mit übermäßigen Zahlen[^10]. Bevorzugen:

weniger große Datensätze über viele kleine
Zusammengesetzte Datentypen für verwandte Skalarfelder (z. B. Partikelposition + Geschwindigkeit + Masse)
Gruppieren von ähnlichen kleinen Arrays in einem einzigen strukturierten Datensatz

Defragmentieren Sie große Dateien

Mit der Zeit können HDF5-Dateien fragmentiert werden, wenn Datensätze erstellt und gelöscht werden. Verwenden Sie h5repack, um Dateien optimal umzuschreiben:

h5repack -f GZIP=4 input.h5 output_compressed.h5
h5repack -l CHUNK=100x100x100 input.h5 rechunked.h5

HDF5 vs. Alternativen: NetCDF4, ZARR, CSV

Vergleichszusammenfassung

Funktion	HDF5	netcdf-4	ZARR	CSV / JSON
Parallel I / O	✅ MPI-IO	✅ MPI-IO	✅ (Cloud-optimiert)	❌
Kompression	Mehrere Filter	gzip / szip	Mehrere (BLOCK, GZIP)	❌
Einzeldatei	✅	✅	❌ (Verzeichnis)	✅
Cloud-Native	⚠️ (mit HSDs)	⚠️	✅	✅
Python-First	⚠️ (h5py)	✅ (netcdf4)	✅	✅
Metadaten	Reiche Attribute	CF-Konventionen	Reiche Attribute	Beschränkt
Lernkurve	Steil	Mäßig	Leicht	Trivial
Erhaltung	✅ Ausgezeichnet	✅ Ausgezeichnet	⚠️ Entwickeln	✅ menschlich lesbar

Wann wählen Sie HDF5

HPC-Umgebungen: MPI-basierte Parallelsimulationen
Langzeitarchive: Bewährtes Format mit über 20 Jahren Track Record[^1]
Komplexe Hierarchien: tiefe Gruppenstrukturen, gemischte Datentypen
Große Binärdaten: Bilder, 3D-Felder, Matrizen
Cross-Sprach: Benötigen Sie C/Fortran/MatLab-Kompatibilität

Wenn NetCDF-4 oder ZARR besser sein können

Klima/Atmosphärenwissenschaft: NetCDF-4 mit CF-Konventionen ist der Gemeinschaftsstandard
Cloud Storage: Das Verzeichnis-Layout von Zarr funktioniert besser mit Objektspeichern (S3, GCS)
Einfache Zeitreihe: ZARR oder NetCDF4 bieten einfachere APIs
Rapid-Prototyping: Die reine Python-Implementierung von ZARR hat keine Abhängigkeiten der Kompilierungszeit

Für die meisten wissenschaftlichen Simulationsprojekte – insbesondere solche mit PDE-Solvern wie FIPY – bleibt HDF5 die fähigste und am weitesten verbreitete Option [^11].

Langzeitlagerung und -konservierung

Warum HDF5 ARCHIVAL-QUALITÄT ist

Die Library of Congress und National Archives erkennen HDF5 als geeignetes Format für die langfristige Erhaltung[^1] an. Schlüsselfaktoren:

Open Standard: Nicht proprietär, gepflegt von der HDF-Gruppe (Non-Profit)
Selbstbeschreibend: Keine externen Schemadateien erforderlich, um Daten zu interpretieren
Plattformunabhängig: Binärformat funktioniert auf jeder Architektur
Wide Adoption: Wird von der NASA, NOAA, DOE, ESA verwendet; Tausende von Werkzeugen existieren
Stabile Spezifikation: HDF5 1.10+ ist abwärtskompatibel; Formatänderungen sind selten

Best Practices für die Erhaltung

Numerische IEEE-Formate verwenden: Vermeiden Sie „native“ Formate, die Daten an bestimmte Hardware-Endianness binden[^1]
Dokumente gründlich: Schließen Sie Einheiten, Beschreibungen, Softwareversionen und Zitate als Attribute ein
Eine Readme-Datei einbeziehen: Speichern Sie menschenlesbare Dokumentationen entweder als Attribut oder als Begleitdatei
Dateien validieren: Verwenden Sie h5dump oder h5py, um die Integrität vor der Archivierung zu überprüfen
Software beibehalten: Archivieren Sie die genaue HDF5-Bibliotheksversion (oder einen Docker-Container), die zum Erstellen der Datei verwendet wird
Vermeiden Sie exotische Kompression: Standard-Gzip ist am sichersten; Benutzerdefinierte Filter werden in 20 Jahren möglicherweise nicht unterstützt

Häufige Fallstricke, die Risikodaten

Kein Journaling : HDF5 fehlen Transaktionsprotokolle. Wenn ein Prozess während des Schreibens abstürzt, kann die Datei korrupt und nicht wiederherstellbar[^12] werden. Schreiben Sie immer in eine temporäre Datei und benennen Sie sie nach Abschluss um.
Parallel-Write-Rennen: Mehrere Autoren ohne ordnungsgemäße Synchronisierung verursachen Korruption. Verwenden Sie den SWMR-Modus oder die kollektive E / A.
Nicht übereinstimmende Datentypen : Das Lesen eines Datensatzes mit dem falschen DType verzerrt die Daten. Überprüfen Sie immer dtype Übereinstimmungen zwischen Schreiber und Leser.
Datasets löscht keine Dateien: HDF5 markiert den Speicherplatz intern als frei, reduziert jedoch nicht die Dateigröße. Verwenden Sie h5repack, um Speicherplatz zurückzugewinnen.

Praktische Checkliste: HDF5 für Simulationsprojekte

Bevor Sie HDF5 in Ihrem Simulationsworkflow verwenden:

Wählen Sie Chunk-Größen basierend auf typischen Zugriffsmustern (nicht beliebig)
Komprimierung aktivieren für Archivausgänge, für Hot-Checkpoint-Daten deaktivieren
Dokument jedes Datensatzes mit Einheiten, Beschreibungen und Erstellungssoftware
Erweiterbare Datasets für Zeitreihen verwenden, um eine Vorzuweisung zu vermeiden
Parallelschreiben validieren mit kollektiven Operationen, nicht unabhängiger E/A
Alle Dateihandles schließen (Kontextmanager verwenden: with h5py.File(...))
Backup-kritische Sicherungsläufe Vor der Nachbearbeitung wird der Speicher getrennt
Testwiederherstellung: Simulieren Sie Abstürze, um sicherzustellen, dass Teildateien erkannt werden
Berücksichtigen Sie netcdf-4 Wenn Ihre Community bereits CF-Konventionen verwendet
Für Cloud-Speicher, bewerten Sie ZARR als alternatives Format

Interne Verlinkung und verwandte Anleitungen

Das Verständnis von HDF5 ist entscheidend für die Verwaltung von Simulationsausgaben in verschiedenen MatForge-Anleitungen:

Verwalten von PDE-Problemen in großen Maßstäben behandelt HPC-Strategien, bei denen HDF5-Parallel-E/A-Auszeichnungen hervorstechen.
Verwenden von FIPY für die Phasenfeldmodellierung Zeigt das Speichern der Simulationsergebnisse in HDF5 für eine spätere Analyse.
Simulationsergebnisse effektiv visualisieren zeigt, wie man HDF5-Ausgänge für die Nachbearbeitung mit ParaView oder MatplotLib liest.
Reproduzierbarkeit und ihre Rolle beim Debuggen Erklärt, wie die selbstbeschreibende Natur von HDF5 die reproduzierbare Forschung unterstützt.

Empfehlungen und wann Sie wählen, was

Für die meisten PDE-basierten Simulationen (einschließlich FIPY-Benutzer):

Start mit HDF5 + H5Py wegen seiner Reife und MPI-Unterstützung
Verwenden Sie GZIP-Komprimierung auf Stufe 4–6 für Archivierungsausgaben (gute Balance zwischen Geschwindigkeit/Größe)
Chunk Along Time Dimension als (1, nx, ny) für 3D-Zeitreihen
Koordinatenarrays speichern (x, y, z) als separate Datensätze mit Unit-Attributen
Fügen Sie eine /metadata-Gruppe mit Simulationsparametern, Softwareversionen und Git-Hashes hinzu

Alternativen berücksichtigen, wann:

Ausschließlich in Python arbeiten und Cloud-native Speicherung benötigen → ZARR
Klima-/Atmosphärenmodelle mit Standardkonventionen → netcdf-4
Benötigen Sie lesbare einfache Ausgaben → csv/json (erwarten Sie jedoch große Dateigrößen und langsame E / A)

Schlussfolgerung

HDF5 bildet die Grundlage für ein robustes wissenschaftliches Datenmanagement. Die Kombination aus hierarchischer Organisation, paralleler E / A-, Komprimierung und Rich-Metadaten macht es einzigartig für Simulationsausgaben geeignet, die über Jahre bestehen bleiben müssen und gleichzeitig über Plattformen und Programmiersprachen zugänglich bleiben.

Die Macht des Formats geht jedoch mit der Verantwortung einher. Schlechte Auswahlmöglichkeiten, das Ignorieren kollektiver E / A-Muster und unzureichende Metadaten können die Leistung und die langfristige Benutzerfreundlichkeit untergraben. Befolgen Sie die hier beschriebenen Best Practices – insbesondere in Bezug auf Chunking-Strategie, Attributdokumentation und parallele Zugriffsmuster -, um sicherzustellen, dass Ihre Simulationsdaten sowohl performant als auch konservierbar bleiben.

HDF5 ist nicht das neueste Format, aber seine mehr als 20-jährige Erfolgsbilanz in Bezug auf Stabilität und weit verbreitete Akzeptanz in großen Forschungseinrichtungen macht es zur sichersten Wette für Projekte, bei denen Daten Langlebigkeit wichtig sind [^1] [^2].

weiterlesen

HDF5-Benutzerhandbuch (offizielle Dokumentation)
H5PY-Dokumentation
Parallele E/A mit HDF5 (der HDF-Gruppenblog)
Best Practices der NASA HDF5 (NASA EarthData)

[^1]: Kongressbibliothek. „HDF5, hierarchisches Datenformat, Version 5.“ Format Beschreibung Dokument. Erhältlich über Clarin: https://standards.clarin.eu/sis/views/view-format.xq?id=fhdf5
[^2]: Die HDF-Gruppe. „HDF5: Eine neue Generation von HDF.“ https://www.hdfgroup.org/solutions/hdf5/
[^3]: HDF-Gruppe. „HDF5-Datenmodell und Dateistruktur.“ https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d_m__u_g.html
[^4]: HDF-Gruppe. „HDF5-Attribute.“ https://support.hdfgroup.org/documentation/hdf5/latest/_h5_a__u_g.html
[^5]: NERSC. „Einführung in die wissenschaftliche E / A.“ https://support.hdfgroup.org/documentation/hdf5-docs/hdf5. _topics/2016_nersc_introduction_to_scientific_io.pdf
[^6]: LRZ. „Best-Practice-Leitfaden – Parallele E / A.“ https://doku.lrz.de/files/10746566/10746567/11/175. 5197969103/Best-Practice-Guide-Parallel-IO.pdf
[^7]: H5PY-Projekt. „H5PY-Dokumentation.“ https://docs.h5py.org/en/latest/
[^8]: HDF-Gruppe. „Chunking in HDF5.“ https://support.hdfgroup.org/documentation/hdf5-docs/advanced_topics/chunking_in_hdf5.html
[^9]: HDF-Gruppe. „Hochleistungs-E / A mit HDF5 erreichen.“ https://support.hdfgroup.org/documentation/hdf5-docs/hdf5_topics/20200206_eccptutorial-final.pdf
[^10]: HDF-Forum. „HDF5-Datensatz-Größe und -Nummer-Fragen.“ https://forum.hdfgroup.org/t/hdf5-dataset-size-and-number-questions/12215

[^11]: Ambatipudi et al. „Ein Vergleich von HDF5, ZARR und NetCDF4 bei der Durchführung gängiger E / A-Operationen.“ arXiv:2207.09503, 2022.
[^12]: HDF-Forum. „HDF5 Mögliche Datenbeschädigung oder Verlust?“ https://stackoverflow.com/questions/35837243/hdf5-possible-data-corruption-or-loss