Par Jerry Fan

Comment gérer les fichiers JSONL volumineux (1 Go+)

Stratégies et bonnes pratiques pour traiter efficacement plusieurs gigaoctets de données JSONL

Pourquoi les fichiers JSONL volumineux demandent une approche adaptée

Parser un fichier JSONL entier en dictionnaires Python ou en objets JavaScript peut demander bien plus de mémoire que sa taille sur disque. Le surcoût dépend du nombre d'enregistrements, des noms de champs, des valeurs et de l'environnement d'exécution. Mesurez-le avec un fichier représentatif plutôt que de supposer un multiplicateur mémoire fixe.

Le principal avantage du JSONL par rapport au JSON classique est de pouvoir se traiter ligne par ligne. Chaque ligne constitue un document JSON indépendant : vous n'avez donc jamais besoin de charger le fichier entier. Cette possibilité de traitement en streaming fait du JSONL un format de choix pour les jeux de données volumineux en machine learning, en analyse de logs et en ingénierie des données.

Lire les fichiers en streaming

Pour traiter un fichier JSONL volumineux, le principe est de le lire ligne par ligne et de traiter chaque enregistrement séparément. Voici comment procéder avec des langages et des outils courants.

L'itération sur un fichier en Python lit une ligne à la fois. La consommation de mémoire dépend de la ligne la plus volumineuse et des données conservées par votre code de traitement. Un seul enregistrement très volumineux peut donc épuiser la mémoire.

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'interface readline de Node.js permet de traiter efficacement les fichiers ligne par ligne à l'aide de streams. La consommation mémoire reste ainsi minimale, même pour des fichiers de plusieurs gigaoctets.

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

Les outils Unix en ligne de commande sont idéaux pour examiner et traiter rapidement des fichiers JSONL volumineux sans écrire de code.

Outils en ligne de commande
# 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

Optimiser la gestion de la mémoire

En complément de la lecture ligne par ligne, ces techniques permettent de traiter plus efficacement les fichiers JSONL volumineux.

Traitez les enregistrements par lots de 1 000 à 10 000 pour trouver un bon compromis entre consommation mémoire et efficacité du traitement. Cette approche est particulièrement utile pour les écritures en base de données ou les appels API.

Traitement par lots
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)

Surveillez la consommation mémoire pendant le traitement pour repérer rapidement les problèmes et ajuster la taille des lots.

Suivre la consommation mémoire
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')

Découper les fichiers JSONL volumineux

Il est parfois nécessaire de découper un fichier JSONL volumineux en fichiers plus petits pour le traiter en parallèle, l'envoyer à des services qui imposent une limite de taille ou répartir le travail entre plusieurs machines.

Utilisez split -l pour conserver les lignes entières. N'utilisez pas split -b pour créer des fragments JSONL autonomes : une coupure à une limite d'octets peut scinder un enregistrement JSON ou un caractère UTF-8. Les commandes ci-dessous créent un nouveau répertoire et s'arrêtent s'il existe déjà.

Utiliser la commande 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

Cette solution Python découpe le fichier selon le nombre de lignes et préserve les octets d'entrée, y compris les caractères UTF-8 et les fins de ligne. Elle crée un nouveau répertoire de sortie et refuse d'écraser un répertoire existant. Validez d'abord l'entrée : le découpage ne répare pas les enregistrements invalides.

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

Stratégies de compression

Le JSONL se compresse souvent bien lorsque les enregistrements répètent les mêmes noms de champs et valeurs. Le gain dépend du jeu de données, du niveau de compression et du codec. Mesurez la taille compressée et le temps de traitement sur un échantillon représentatif.

Le module gzip de Python gère les fichiers JSONL compressés de manière transparente. L'extension .gz est une convention reconnue automatiquement par les outils.

Lire et écrire des fichiers JSONL compressés avec 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')

Comparer les options de compression

Choisissez un codec selon sa compatibilité et ses performances mesurées sur vos propres données. Les points suivants présentent des compromis, pas des résultats de benchmark :

gzip : largement pris en charge ; un choix pratique pour échanger des fichiers JSONL compressés.

zstd : propose des niveaux de compression réglables ; comparez la taille et le débit avec gzip sur votre charge de travail.

lz4 : conçu pour une compression et une décompression rapides ; mesurez le compromis sur la taille avec vos données.

Sans compression : évite le travail de décompression, mais utilise plus d'espace de stockage ; utile si vous avez besoin d'un accès direct aux octets.

Traiter les fichiers volumineux dans le navigateur

jsonl.co lit les fichiers JSONL localement dans votre navigateur. Le visualiseur parcourt les fichiers par blocs et utilise le défilement virtuel pour ne pas afficher tous les enregistrements à la fois. Le contenu de vos fichiers n'est pas envoyé sur un serveur.

La taille des fichiers que vous pouvez traiter dépend de la mémoire du navigateur, des ressources de l'appareil, de la taille des enregistrements et de l'opération. Lire l'entrée en streaming ne garantit pas une consommation de mémoire bornée pour la sortie : la conversion Excel, par exemple, accumule les lignes et construit le classeur en mémoire. Essayez d'abord un petit échantillon et découpez les fichiers si nécessaire.

Gérez vos fichiers JSONL volumineux en ligne

Examinez du JSONL localement avec le visualiseur du navigateur. Pour des volumes plus importants, découpez le fichier ou utilisez les scripts de traitement ligne par ligne ci-dessus.

Questions fréquentes

Références