Von Jerry Fan

Große JSONL-Dateien verarbeiten (1GB+)

Strategien und bewährte Verfahren, um JSONL-Daten im Gigabyte-Bereich effizient zu verarbeiten

Warum große JSONL-Dateien besondere Sorgfalt erfordern

Das Parsen einer gesamten JSONL-Datei in Python-Dictionaries oder JavaScript-Objekte kann wesentlich mehr Arbeitsspeicher erfordern, als die Datei auf dem Datenträger belegt. Der zusätzliche Bedarf hängt von der Anzahl der Datensätze, den Feldnamen, den Werten und der Laufzeitumgebung ab. Messen Sie ihn mit einer repräsentativen Datei, statt einen festen Speicherfaktor anzunehmen.

Der entscheidende Vorteil von JSONL gegenüber herkömmlichem JSON: Sie können die Daten zeilenweise verarbeiten. Jede Zeile ist ein eigenständiges JSON-Dokument. Sie müssen also nie die gesamte Datei laden. Diese Streaming-Eigenschaft macht JSONL zum bevorzugten Format für große Datenmengen im Machine Learning, bei der Log-Analyse und im Data Engineering.

Große Dateien per Streaming lesen

Das Grundprinzip beim Umgang mit großen JSONL-Dateien ist einfach: Lesen Sie die Datei zeilenweise und verarbeiten Sie jeden Datensatz einzeln. Die folgenden Beispiele zeigen, wie das mit gängigen Programmiersprachen und Tools funktioniert.

Beim Iterieren über eine Datei liest Python jeweils eine Zeile. Der Speicherbedarf hängt von der größten Zeile und den Daten ab, die Ihr Verarbeitungscode im Speicher hält. Auch ein einzelner sehr großer Datensatz kann den Arbeitsspeicher erschöpfen.

Python
import json


def process_large_jsonl(filepath: str) -> int:
    """Process a large JSONL file line by line."""
    count = 0
    errors = 0
    
    with open(filepath, 'r', encoding='utf-8') as f:
        for line_num, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue
            try:
                record = json.loads(line)
                # Process your record here
                count += 1
            except json.JSONDecodeError as e:
                errors += 1
                print(f'Line {line_num}: {e}')
    
    print(f'Processed {count} records, {errors} errors')
    return count

Mit dem readline-Interface von Node.js lassen sich Dateien über Streams effizient Zeile für Zeile verarbeiten. Der Speicherverbrauch bleibt dabei auch bei Dateien mit mehreren Gigabyte gering.

Node.js
import { createReadStream } from 'fs';
import { createInterface } from 'readline';


async function processLargeJsonl(filepath) {
  const rl = createInterface({
    input: createReadStream(filepath, 'utf-8'),
    crlfDelay: Infinity,
  });


  let count = 0;
  for await (const line of rl) {
    const trimmed = line.trim();
    if (!trimmed) continue;
    try {
      const record = JSON.parse(trimmed);
      // Process your record here
      count++;
    } catch (err) {
      console.error(`Parse error: ${err.message}`);
    }
  }
  console.log(`Processed ${count} records`);
}

Mit Unix-Kommandozeilen-Tools können Sie große JSONL-Dateien schnell prüfen und verarbeiten, ohne selbst Code zu schreiben.

Kommandozeilen-Tools
# Count lines in a JSONL file
wc -l data.jsonl


# View first 10 records
head -n 10 data.jsonl


# View last 5 records
tail -n 5 data.jsonl


# Pretty-print first record
head -n 1 data.jsonl | jq .


# Filter records with jq
jq -c 'select(.age > 30)' data.jsonl


# Extract specific fields
jq -c '{name, email}' data.jsonl

Den Speicherverbrauch im Griff behalten

Zusätzlich zum zeilenweisen Lesen helfen Ihnen die folgenden Techniken, große JSONL-Dateien effizienter zu verarbeiten.

Verarbeiten Sie jeweils 1.000–10.000 Datensätze in einem Batch, um ein gutes Verhältnis zwischen Speicherverbrauch und Verarbeitungseffizienz zu erreichen. Das ist besonders bei Datenbankzugriffen und API-Aufrufen hilfreich.

Batch-Verarbeitung
import json
from typing import Iterator


def read_jsonl_batches(
    filepath: str,
    batch_size: int = 5000
) -> Iterator[list]:
    batch = []
    with open(filepath, 'r') as f:
        for line in f:
            record = json.loads(line.strip())
            batch.append(record)
            if len(batch) >= batch_size:
                yield batch
                batch = []
    if batch:
        yield batch


# Usage
for batch in read_jsonl_batches('large.jsonl'):
    # Insert batch into database
    db.insert_many(batch)

Überwachen Sie während der Verarbeitung den Speicherverbrauch. So erkennen Sie Probleme frühzeitig und können die Batch-Größe anpassen.

Speicherverbrauch überwachen
import json
import psutil
import os


def process_with_monitoring(filepath: str):
    process = psutil.Process(os.getpid())
    
    with open(filepath, 'r') as f:
        for i, line in enumerate(f):
            record = json.loads(line)
            # Process record
            
            if i % 100000 == 0:
                mem = process.memory_info().rss / 1024 / 1024
                print(f'Line {i:,}: {mem:.1f} MB')

Große JSONL-Dateien aufteilen

Manchmal ist es nötig, eine große JSONL-Datei in kleinere Dateien aufzuteilen: etwa für die parallele Verarbeitung, für Uploads zu Diensten mit Größenlimits oder um die Verarbeitung auf mehrere Rechner zu verteilen.

Verwenden Sie split -l, damit Zeilen vollständig erhalten bleiben. Verwenden Sie split -b nicht für eigenständig nutzbare JSONL-Teildateien: Eine Bytegrenze kann mitten in einem JSON-Datensatz oder einem UTF-8-Zeichen liegen. Die folgenden Befehle erstellen ein neues Verzeichnis und brechen ab, falls es bereits existiert.

Mit dem split-Befehl
# Split into parts of 100,000 complete lines in a NEW directory
mkdir jsonl-parts &&
split -l 100000 data.jsonl jsonl-parts/chunk_ &&
for f in jsonl-parts/chunk_*; do
    [ -f "$f" ] || continue
    mv "$f" "$f.jsonl"
done

Diese Python-Alternative teilt die Datei nach Zeilenanzahl auf und erhält die Eingabebytes unverändert, einschließlich UTF-8-Zeichen und Zeilenenden. Sie erstellt ein neues Ausgabeverzeichnis und überschreibt kein vorhandenes. Validieren Sie zuerst die Eingabe: Das Aufteilen repariert keine ungültigen Datensätze.

Python-Skript
from pathlib import Path


def split_jsonl(input_path, output_dir="jsonl-parts", lines_per_file=100000):
    if lines_per_file < 1:
        raise ValueError("lines_per_file must be positive")
    directory = Path(output_dir)
    file_num = 0
    output = None
    with open(input_path, "rb") as source:
        directory.mkdir()  # Refuse to overwrite an existing directory
        try:
            for line_number, line in enumerate(source):
                if line_number % lines_per_file == 0:
                    if output is not None:
                        output.close()
                    file_num += 1
                    output = (directory / f"part_{file_num:04d}.jsonl").open("xb")
                output.write(line)
        finally:
            if output is not None:
                output.close()
    print(f"Split into {file_num} files")


split_jsonl("data.jsonl")

Dateien komprimieren

JSONL lässt sich häufig gut komprimieren, wenn sich Feldnamen und Werte in den Datensätzen wiederholen. Die Einsparung hängt vom Datensatz, der Komprimierungsstufe und dem Codec ab. Messen Sie die komprimierte Größe und die Verarbeitungszeit anhand einer repräsentativen Stichprobe.

Mit dem gzip-Modul von Python können Sie direkt mit komprimierten JSONL-Dateien arbeiten. Die Dateiendung .gz ist eine gängige Konvention, die Tools automatisch erkennen.

Gzip-komprimierte JSONL-Dateien lesen und schreiben
import gzip
import json


# Reading gzipped JSONL
with gzip.open('data.jsonl.gz', 'rt', encoding='utf-8') as f:
    for line in f:
        record = json.loads(line)
        # Process record


# Writing gzipped JSONL
with gzip.open('output.jsonl.gz', 'wt', encoding='utf-8') as f:
    for record in records:
        f.write(json.dumps(record) + '\n')

Komprimierungsverfahren im Vergleich

Wählen Sie einen Codec nach Kompatibilität und gemessener Leistung mit Ihren eigenen Daten. Die folgenden Punkte beschreiben Abwägungen, keine Benchmark-Ergebnisse:

gzip: wird breit unterstützt und ist eine praktische Wahl für den Austausch komprimierter JSONL-Dateien.

zstd: bietet einstellbare Komprimierungsstufen. Vergleichen Sie Größe und Durchsatz bei Ihrer Arbeitslast mit gzip.

lz4: ist auf schnelles Komprimieren und Dekomprimieren ausgelegt. Messen Sie mit Ihren Daten, welche Dateigröße sich dabei ergibt.

Ohne Komprimierung: erspart die Dekomprimierung, benötigt aber mehr Speicherplatz. Sinnvoll, wenn Sie direkten Zugriff auf einzelne Bytes benötigen.

Große Dateien im Browser verarbeiten

jsonl.co liest JSONL-Dateien lokal in Ihrem Browser. Der Viewer durchsucht Dateien blockweise und nutzt virtuelles Scrollen, sodass er nicht alle Datensätze gleichzeitig darstellt. Ihre Dateiinhalte werden nicht hochgeladen.

Welche Dateigröße sich verarbeiten lässt, hängt vom Browserspeicher, den Ressourcen des Geräts, der Datensatzgröße und der jeweiligen Operation ab. Das Einlesen als Stream garantiert keinen begrenzten Speicherbedarf für die Ausgabe: Die Excel-Konvertierung sammelt beispielsweise Zeilen und erstellt die Arbeitsmappe im Arbeitsspeicher. Probieren Sie zunächst eine kleinere Stichprobe aus und teilen Sie Dateien bei Bedarf auf.

Große JSONL-Dateien online verarbeiten

Prüfen Sie JSONL lokal mit dem Browser-Viewer. Teilen Sie die Datei bei größeren Datenmengen auf oder verwenden Sie die obigen Skripte zur zeilenweisen Verarbeitung.

Häufig gestellte Fragen

Quellen