Come gestire file JSONL di grandi dimensioni (1GB+)
Strategie e best practice per elaborare in modo efficiente dati JSONL nell’ordine dei gigabyte
Perché i file JSONL di grandi dimensioni richiedono accorgimenti specifici
Il parsing di un intero file JSONL in dizionari Python o oggetti JavaScript può richiedere molta più memoria rispetto alle dimensioni del file su disco. Il consumo aggiuntivo dipende dal numero di record, dai nomi dei campi, dai valori e dall’ambiente di esecuzione. Misuralo con un file rappresentativo invece di presumere un moltiplicatore fisso della memoria.
Il vantaggio principale di JSONL rispetto al normale JSON è la possibilità di elaborarlo riga per riga. Ogni riga è un documento JSON indipendente, quindi non serve mai caricare l’intero file. È proprio questa possibilità di elaborazione in streaming a rendere JSONL il formato preferito per dataset di grandi dimensioni nel machine learning, nell’analisi dei log e nella data engineering.
Strategie di lettura in streaming
Per gestire file JSONL di grandi dimensioni, l’approccio di base è leggerli riga per riga ed elaborare ogni record in modo indipendente. Ecco come farlo con alcuni dei linguaggi e degli strumenti più diffusi.
L’iterazione su un file in Python legge una riga alla volta. Il consumo di memoria dipende dalla riga più grande e dai dati conservati dal codice di elaborazione; anche un solo record molto grande può esaurire la memoria.
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 countL’interfaccia readline di Node.js permette di elaborare i file riga per riga in modo efficiente tramite gli stream, mantenendo minimo il consumo di memoria anche con file da più gigabyte.
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`);
}Gli strumenti da riga di comando Unix sono ideali per esaminare ed elaborare rapidamente file JSONL di grandi dimensioni senza scrivere codice.
# 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.jsonlTecniche di gestione della memoria
Oltre alla semplice lettura riga per riga, queste tecniche ti aiutano a elaborare i file JSONL di grandi dimensioni in modo più efficiente.
Elabora i record in batch da 1.000 a 10.000 per trovare un equilibrio tra consumo di memoria ed efficienza di elaborazione. È particolarmente utile quando scrivi su un database o effettui chiamate API.
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)Tieni sotto controllo il consumo di memoria durante l’elaborazione per individuare subito eventuali problemi e regolare la dimensione dei batch.
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')Suddividere file JSONL di grandi dimensioni
A volte serve suddividere un file JSONL di grandi dimensioni in file più piccoli per elaborarli in parallelo, caricarli su servizi che impongono limiti di dimensione o distribuire il lavoro su più macchine.
Usa split -l per mantenere le righe intere. Non usare split -b per creare parti JSONL utilizzabili in modo autonomo: un taglio basato sui byte può spezzare un record JSON o un carattere UTF-8. I comandi seguenti creano una nuova directory e si interrompono se esiste già.
# 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"
doneQuesta alternativa Python suddivide il file in base al numero di righe e preserva i byte di input, inclusi i caratteri UTF-8 e i terminatori di riga. Crea una nuova directory di output e si rifiuta di sovrascriverne una esistente. Valida prima l’input: la suddivisione non corregge i record non validi.
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")Strategie di compressione
JSONL si comprime spesso bene quando i record ripetono nomi di campi e valori. Il risparmio dipende dal dataset, dal livello di compressione e dal codec; misura le dimensioni compresse e il tempo di elaborazione su un campione rappresentativo.
Il modulo gzip di Python gestisce i file JSONL compressi in modo trasparente. L’estensione .gz è una convenzione riconosciuta automaticamente dagli strumenti.
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')Confronto tra le opzioni di compressione
Scegli un codec in base alla compatibilità e alle prestazioni misurate sui tuoi dati. I punti seguenti descrivono compromessi da valutare, non risultati di benchmark:
gzip: ampiamente supportato; una scelta pratica per scambiare file JSONL compressi.
zstd: offre livelli di compressione regolabili; confronta dimensioni e throughput con gzip sul tuo carico di lavoro.
lz4: progettato per comprimere e decomprimere rapidamente; misura sui tuoi dati il compromesso in termini di dimensioni.
Senza compressione: evita il lavoro di decompressione, ma occupa più spazio di archiviazione; utile quando serve accedere direttamente ai byte.
Elaborare file di grandi dimensioni nel browser
jsonl.co legge i file JSONL in locale nel browser. Il visualizzatore scorre i file a blocchi e usa lo scorrimento virtuale per non renderizzare tutti i record contemporaneamente. Il contenuto dei tuoi file non viene caricato su un server.
Le dimensioni dei file che puoi elaborare dipendono dalla memoria del browser, dalle risorse del dispositivo, dalle dimensioni dei record e dall’operazione. Leggere l’input in streaming non garantisce un consumo di memoria limitato per l’output: la conversione in Excel, ad esempio, accumula righe e crea la cartella di lavoro in memoria. Prova prima con un campione più piccolo e suddividi i file quando necessario.
Prova i nostri strumenti JSONL gratuiti
Visualizza, valida e converti JSONL in locale nel browser. Il contenuto dei file resta sul tuo dispositivo; la capacità e i tempi di elaborazione dipendono dal browser e dallo strumento scelto.
Dividi file JSONL grandi in parti più piccole e gestibili per numero di righe.
Combina più file JSONL in un unico file con deduplicazione.
Comprimi file JSONL con gzip, zstd, lz4 e snappy. Scopri i rapporti di compressione, lo streaming di dati compressi e l'ottimizzazione di JSONL per archiviazione e trasferimento.
Valida i file JSONL riga per riga. Individua subito errori di sintassi e problemi di codifica o di formato.
Apri i file .jsonl e .ndjson direttamente nel tuo editor, in una tabella veloce da consultare e in cui puoi effettuare ricerche. Pensata per file troppo grandi da scorrere e per log ancora in fase di scrittura.