Por Jerry Fan

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.

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

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

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

Las herramientas de línea de comandos de Unix son ideales para inspeccionar y procesar rápidamente archivos JSONL grandes sin escribir código.

Herramientas de línea de comandos
# 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

Té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.

Procesamiento por lotes
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.

Supervisión del consumo de 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')

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.

Con el 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

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

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

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.

Lectura y escritura de JSONL comprimido 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')

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.

Trabaja con archivos JSONL grandes online

Inspecciona JSONL localmente con el visor del navegador. Para cargas de trabajo mayores, divide el archivo o usa los scripts anteriores que procesan línea por línea.

Preguntas frecuentes

Referencias