Di Jerry Fan

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.

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

L’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.

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

Gli strumenti da riga di comando Unix sono ideali per esaminare ed elaborare rapidamente file JSONL di grandi dimensioni senza scrivere codice.

Strumenti da riga di comando
# 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

Tecniche 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.

Elaborazione in batch
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.

Monitoraggio della memoria
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à.

Usare il comando split
# 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

Questa 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.

Script Python
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.

Leggere e scrivere file JSONL compressi con gzip
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.

Gestisci online file JSONL di grandi dimensioni

Esamina JSONL in locale con il visualizzatore nel browser. Per carichi di lavoro maggiori, suddividi il file o usa gli script qui sopra che elaborano una riga alla volta.

Domande frequenti

Riferimenti