Cómo trabajar con archivos JSONL grandes (1GB+)
Estrategias y buenas prácticas para procesar con eficiencia datos JSONL de varios gigabytes
Por qué los archivos JSONL grandes requieren un tratamiento especial
Analizar un archivo JSONL completo y convertirlo en diccionarios de Python u objetos de JavaScript puede requerir mucha más memoria que su tamaño en disco. La sobrecarga depende del número de registros, los nombres de los campos, los valores y el entorno de ejecución. Mídela con un archivo representativo en lugar de suponer un multiplicador de memoria fijo.
La principal ventaja de JSONL frente al JSON convencional es que permite procesar los datos línea por línea. Cada línea es un documento JSON independiente, así que no necesitas cargar el archivo completo en ningún momento. Esta capacidad de procesamiento en streaming convierte a JSONL en el formato preferido para grandes conjuntos de datos en aprendizaje automático, análisis de logs e ingeniería de datos.
Estrategias de lectura en streaming
La base para trabajar con archivos JSONL grandes es leerlos línea por línea y procesar cada registro de forma independiente. Estos ejemplos muestran cómo hacerlo con lenguajes y herramientas de uso habitual.
Al iterar sobre un archivo, Python lee una línea cada vez. El uso de memoria depende de la línea más grande y de los datos que conserve tu código de procesamiento; un solo registro muy grande puede agotar 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 countLa interfaz readline de Node.js permite procesar archivos línea por línea mediante streams y mantener al mínimo el consumo de memoria, incluso con archivos de varios 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`);
}Las herramientas de línea de comandos de Unix son ideales para inspeccionar y procesar rápidamente archivos JSONL grandes sin escribir código.
# 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.jsonlTécnicas de gestión de memoria
Además de leer línea por línea, puedes aplicar estas técnicas para procesar archivos JSONL grandes con mayor eficiencia.
Procesa los registros en lotes de 1.000 a 10.000 para equilibrar el consumo de memoria y la eficiencia del procesamiento. Esto resulta especialmente útil al escribir en bases de datos o realizar llamadas a una 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)Supervisa el consumo de memoria durante el procesamiento para detectar problemas a tiempo y ajustar el tamaño de los lotes.
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')Cómo dividir archivos JSONL grandes
A veces necesitas dividir un archivo JSONL grande en partes más pequeñas para procesarlas en paralelo, subirlas a servicios con límites de tamaño o repartir el trabajo entre varias máquinas.
Usa split -l para mantener las líneas completas. No uses split -b para crear partes JSONL que puedan usarse de forma independiente: un corte por bytes puede partir un registro JSON o un carácter UTF-8. Los comandos siguientes crean un directorio nuevo y se detienen si ya existe.
# 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"
doneEsta alternativa en Python divide por número de líneas y conserva los bytes de entrada, incluidos los caracteres UTF-8 y los finales de línea. Crea un directorio de salida nuevo y se niega a sobrescribir uno existente. Valida primero la entrada: dividir el archivo no repara los registros no válidos.
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")Estrategias de compresión
JSONL suele comprimirse bien cuando los registros repiten nombres de campos y valores. El ahorro depende del conjunto de datos, el nivel de compresión y el códec; mide el tamaño comprimido y el tiempo de procesamiento con una muestra representativa.
El módulo gzip de Python permite trabajar con archivos JSONL comprimidos de forma transparente. La extensión .gz es una convención que las herramientas reconocen automáticamente.
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')Comparativa de compresión
Elige un códec según la compatibilidad y el rendimiento medido con tus propios datos. Estos son aspectos que debes sopesar, no resultados de pruebas de rendimiento:
gzip: ampliamente compatible; una opción práctica para intercambiar JSONL comprimido.
zstd: ofrece niveles de compresión ajustables; compara el tamaño y la tasa de procesamiento con gzip usando tu carga de trabajo.
lz4: diseñado para comprimir y descomprimir con rapidez; mide cómo afecta al tamaño con tus datos.
Sin compresión: evita el trabajo de descompresión, pero usa más almacenamiento; resulta útil si necesitas acceso directo a los bytes.
Cómo procesar archivos grandes en el navegador
jsonl.co lee los archivos JSONL localmente en tu navegador. El visor recorre los archivos por bloques y usa desplazamiento virtual para no renderizar todos los registros a la vez. El contenido de tus archivos no se sube a ningún servidor.
El tamaño de archivo que puedes procesar depende de la memoria del navegador, los recursos del dispositivo, el tamaño de los registros y la operación. Leer la entrada en streaming no garantiza un uso de memoria acotado para la salida: la conversión a Excel, por ejemplo, acumula filas y crea el libro en memoria. Prueba primero con una muestra más pequeña y divide los archivos cuando sea necesario.
Prueba nuestras herramientas gratuitas para JSONL
Visualiza, valida y convierte JSONL localmente en tu navegador. El contenido de los archivos permanece en tu dispositivo; la capacidad y el tiempo de procesamiento dependen de tu navegador y de la herramienta seleccionada.
Divide archivos JSONL grandes en fragmentos más pequeños y manejables por número de líneas.
Combina múltiples archivos JSONL en uno solo con deduplicación.
Compara gzip, zstd y Brotli para comprimir archivos JSONL. Incluye pruebas de rendimiento, ejemplos de código en Python y Node.js, estrategias de almacenamiento en la nube y buenas prácticas.
Valida archivos JSONL línea por línea. Detecta al instante errores de sintaxis, problemas de codificación y fallos de formato.
Abre archivos .jsonl y .ndjson en una tabla ágil y con búsqueda, directamente en tu editor. Diseñada para archivos demasiado grandes para recorrerlos a mano y para logs que aún se están escribiendo.