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.
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 countMet 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.
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.
# 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.jsonlEfficië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.
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.
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.
# 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"
doneDit 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.
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.
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.
Probeer onze gratis JSONL-tools
Bekijk, valideer en converteer JSONL lokaal in je browser. De bestandsinhoud blijft op je apparaat; de verwerkingscapaciteit en verwerkingstijd hangen af van je browser en de gekozen tool.
Splits grote JSONL-bestanden op regelnummer in kleinere, beheersbare delen.
Combineer meerdere JSONL-bestanden tot één bestand met deduplicatie.
Comprimeer JSONL-bestanden met gzip, zstd, lz4 en snappy. Leer compressieverhoudingen, streaming van gecomprimeerde data en optimalisatie van JSONL voor opslag en overdracht.
Valideer JSONL-bestanden regel voor regel. Spoor syntaxfouten, tekencoderingsproblemen en fouten in het formaat direct op.
Open .jsonl- en .ndjson-bestanden als een snelle, doorzoekbare tabel, direct in je editor. Gemaakt voor bestanden die te groot zijn om doorheen te scrollen en voor logs die nog worden weggeschreven.