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.
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'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.
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.
# 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.jsonlOptimiser 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.
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.
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à.
# 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"
doneCette 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.
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.
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.
Essayez nos outils JSONL gratuits
Consultez, validez et convertissez du JSONL localement dans votre navigateur. Le contenu des fichiers reste sur votre appareil ; la capacité de traitement et sa durée dépendent de votre navigateur et de l'outil choisi.
Divisez les grands fichiers JSONL en morceaux plus petits et gérables par nombre de lignes.
Combinez plusieurs fichiers JSONL en un seul avec dédoublonnage.
Comparez gzip, zstd et Brotli pour compresser vos fichiers JSONL. Retrouvez des benchmarks, des exemples de code en Python et Node.js, des stratégies de stockage cloud et des bonnes pratiques.
Validez vos fichiers JSONL ligne par ligne. Repérez immédiatement les erreurs de syntaxe et les problèmes d’encodage ou de format.
Ouvrez vos fichiers .jsonl et .ndjson dans un tableau fluide avec fonction de recherche, directement dans votre éditeur. L'extension est conçue pour les fichiers trop volumineux pour être parcourus par défilement et les logs en cours d'écriture.