Door Jerry Fan

Grote JSONL-bestanden verwerken (1GB+)

Strategieën en best practices om JSONL-data op gigabyteschaal efficiënt te verwerken

Waarom grote JSONL-bestanden een andere aanpak vragen

Een heel JSONL-bestand parsen naar Python-dictionaries of JavaScript-objecten kan aanzienlijk meer geheugen kosten dan de bestandsgrootte op schijf. De extra belasting hangt af van het aantal records, de veldnamen, de waarden en de runtime. Meet dit met een representatief bestand in plaats van uit te gaan van een vaste vermenigvuldigingsfactor voor het geheugengebruik.

Het grote voordeel van JSONL ten opzichte van gewone JSON is dat je het regel voor regel kunt verwerken. Elke regel is een zelfstandig JSON-document, dus je hoeft nooit het hele bestand te laden. Dankzij die mogelijkheid om data te streamen is JSONL het voorkeursformaat voor grote datasets in machine learning, loganalyse en data engineering.

Bestanden streamend lezen

De basis voor het verwerken van grote JSONL-bestanden is eenvoudig: lees ze regel voor regel en verwerk elk record afzonderlijk. Hieronder zie je hoe dat werkt met veelgebruikte talen en tools.

Bij het doorlopen van een bestand leest Python één regel tegelijk. Het geheugengebruik hangt af van de grootste regel en de data die je verwerkingscode bewaart; één heel groot record kan het geheugen nog steeds uitputten.

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

Met de readline-interface van Node.js kun je bestanden efficiënt regel voor regel verwerken via streams. Zo blijft het geheugengebruik minimaal, ook bij bestanden van meerdere gigabytes.

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`);
}

Met Unix-commandlinetools kun je grote JSONL-bestanden snel bekijken en verwerken zonder code te schrijven.

Commandlinetools
# 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

Efficiënt omgaan met geheugen

Naast regel voor regel lezen kun je de volgende technieken gebruiken om grote JSONL-bestanden efficiënter te verwerken.

Verwerk records in batches van 1.000-10.000 voor een goede balans tussen geheugengebruik en verwerkingssnelheid. Dat is vooral handig als je naar databases schrijft of API-aanroepen doet.

Batchverwerking
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)

Houd tijdens de verwerking het geheugengebruik in de gaten om problemen vroeg op te merken en je batchgrootte daarop af te stemmen.

Geheugengebruik monitoren
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')

Grote JSONL-bestanden splitsen

Soms moet je een groot JSONL-bestand in kleinere delen splitsen om het parallel te verwerken, te uploaden naar diensten met een maximale bestandsgrootte of het werk over meerdere machines te verdelen.

Gebruik split -l om regels heel te houden. Gebruik split -b niet voor zelfstandig bruikbare JSONL-delen: een grens op basis van bytes kan midden in een JSON-record of UTF-8-teken vallen. De onderstaande commando’s maken een nieuwe map en stoppen als die al bestaat.

Het split-commando gebruiken
# 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

Dit Python-alternatief splitst op regelaantal en behoudt de invoerbytes, inclusief UTF-8-tekens en regeleinden. Het maakt een nieuwe uitvoermap en weigert een bestaande map te overschrijven. Valideer eerst de invoer: splitsen herstelt geen ongeldige records.

Python-script
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")

Compressiestrategieën

JSONL laat zich vaak goed comprimeren als records veldnamen en waarden herhalen. De besparing hangt af van de dataset, het compressieniveau en de codec. Meet de gecomprimeerde grootte en de verwerkingstijd met een representatieve steekproef.

Met de gzip-module van Python kun je gecomprimeerde JSONL-bestanden net zo lezen en schrijven als gewone bestanden. De extensie .gz is een conventie die tools automatisch herkennen.

Met gzip gecomprimeerde JSONL lezen en schrijven
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')

Compressiemethoden vergeleken

Kies een codec op basis van compatibiliteit en gemeten prestaties met je eigen data. Dit zijn afwegingen, geen benchmarkresultaten:

gzip: breed ondersteund; een praktische keuze voor het uitwisselen van gecomprimeerde JSONL.

zstd: biedt instelbare compressieniveaus; vergelijk de grootte en doorvoersnelheid met gzip voor jouw werklast.

lz4: ontworpen voor snelle compressie en decompressie; meet met je eigen data welke bestandsgrootte daartegenover staat.

Geen compressie: bespaart decompressiewerk, maar gebruikt meer opslagruimte; handig als je directe toegang tot bytes nodig hebt.

Grote bestanden verwerken in de browser

jsonl.co leest JSONL-bestanden lokaal in je browser. De viewer scant bestanden in blokken en gebruikt virtueel scrollen, zodat niet alle records tegelijk worden gerenderd. De inhoud van je bestanden wordt niet geüpload.

De verwerkbare bestandsgrootte hangt af van het browsergeheugen, de beschikbare systeembronnen op je apparaat, de recordgrootte en de bewerking. Invoer als stream lezen garandeert geen begrensd geheugengebruik voor de uitvoer: bij Excel-conversie worden bijvoorbeeld rijen verzameld en wordt de werkmap in het geheugen opgebouwd. Probeer eerst een kleinere steekproef en splits bestanden waar nodig.

Verwerk grote JSONL-bestanden online

Inspecteer JSONL lokaal met de browserviewer. Splits het bestand bij grotere werklasten of gebruik de bovenstaande scripts die regel voor regel verwerken.

Veelgestelde vragen

Bronnen