Autor: Jerry Fan

Jak pracować z dużymi plikami JSONL (1GB+)

Metody i dobre praktyki wydajnego przetwarzania gigabajtowych zbiorów danych JSONL

Dlaczego duże pliki JSONL wymagają innego podejścia

Parsowanie całego pliku JSONL do słowników w Pythonie lub obiektów w JavaScripcie może wymagać znacznie więcej pamięci niż rozmiar pliku na dysku. Dodatkowe zużycie zależy od liczby rekordów, nazw pól, wartości i środowiska wykonawczego. Zmierz je na reprezentatywnym pliku zamiast zakładać stały mnożnik zużycia pamięci.

Główna przewaga JSONL nad zwykłym JSON polega na możliwości przetwarzania danych wiersz po wierszu. Każdy wiersz to osobny dokument JSON, więc nie musisz wczytywać całego pliku. Dzięki przetwarzaniu strumieniowemu JSONL jest chętnie wybieranym formatem dużych zbiorów danych w uczeniu maszynowym, analizie logów i inżynierii danych.

Metody odczytu strumieniowego

Podstawą pracy z dużymi plikami JSONL jest odczytywanie ich wiersz po wierszu i przetwarzanie każdego rekordu osobno. Poniżej znajdziesz przykłady w popularnych językach i narzędziach.

Iterowanie po pliku w Pythonie odczytuje po jednym wierszu. Zużycie pamięci zależy od największego wiersza i danych zachowywanych przez kod przetwarzający; nawet jeden bardzo duży rekord może wyczerpać pamięć.

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

Interfejs readline w Node.js pozwala wydajnie przetwarzać pliki wiersz po wierszu z użyciem strumieni. Zużycie pamięci pozostaje minimalne nawet przy plikach o rozmiarze wielu gigabajtów.

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

Uniksowe narzędzia wiersza poleceń świetnie nadają się do szybkiego sprawdzania zawartości i przetwarzania dużych plików JSONL bez pisania kodu.

Narzędzia wiersza poleceń
# 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

Techniki zarządzania pamięcią

Oprócz odczytu wiersz po wierszu możesz zastosować poniższe techniki, aby wydajniej przetwarzać duże pliki JSONL.

Przetwarzaj rekordy w partiach po 1000-10 000, aby uzyskać kompromis między zużyciem pamięci a wydajnością. To szczególnie przydatne przy zapisywaniu danych do baz lub wywoływaniu API.

Przetwarzanie wsadowe
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)

Monitoruj zużycie pamięci podczas przetwarzania, aby szybko wykrywać problemy i odpowiednio dobierać wielkość partii.

Monitorowanie zużycia pamięci
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')

Dzielenie dużych plików JSONL

Czasem trzeba podzielić duży plik JSONL na mniejsze części, aby przetwarzać je równolegle, przesłać do usług z limitem rozmiaru pliku lub rozdzielić pracę między kilka maszyn.

Użyj split -l, aby zachować całe wiersze. Nie używaj split -b do tworzenia samodzielnych części JSONL: granica wyznaczona według liczby bajtów może wypaść w środku rekordu JSON lub znaku UTF-8. Poniższe polecenia tworzą nowy katalog i przerywają działanie, jeśli już istnieje.

Dzielenie za pomocą polecenia 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

Ten wariant w Pythonie dzieli plik według liczby wierszy i zachowuje bajty wejściowe, w tym znaki UTF-8 i zakończenia wierszy. Tworzy nowy katalog wyjściowy i odmawia nadpisania istniejącego. Najpierw zwaliduj dane wejściowe: dzielenie nie naprawia nieprawidłowych rekordów.

Skrypt w Pythonie
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 kompresji

JSONL często dobrze się kompresuje, gdy w rekordach powtarzają się nazwy pól i wartości. Oszczędność zależy od zbioru danych, poziomu kompresji i kodeka; zmierz rozmiar po kompresji oraz czas przetwarzania na reprezentatywnej próbce.

Moduł gzip w Pythonie pozwala pracować ze skompresowanymi plikami JSONL bez osobnego etapu kompresji lub dekompresji. Rozszerzenie .gz jest przyjętą konwencją, którą narzędzia rozpoznają automatycznie.

Odczyt i zapis plików JSONL skompresowanych za pomocą 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')

Porównanie kompresji

Wybierz kodek na podstawie kompatybilności i wydajności zmierzonej na własnych danych. Poniższe punkty opisują kompromisy, a nie wyniki testów wydajności:

gzip: szeroko obsługiwany; praktyczny wybór do wymiany skompresowanych plików JSONL.

zstd: oferuje regulowane poziomy kompresji; porównaj rozmiar i przepustowość z gzip dla swojego obciążenia.

lz4: zaprojektowany z myślą o szybkiej kompresji i dekompresji; zmierz na własnych danych, jak ten wybór wpływa na rozmiar.

Bez kompresji: eliminuje pracę związaną z dekompresją, ale wymaga więcej miejsca; przydatne, gdy potrzebujesz bezpośredniego dostępu do bajtów.

Przetwarzanie dużych plików w przeglądarce

jsonl.co odczytuje pliki JSONL lokalnie w przeglądarce. Przeglądarka JSONL skanuje pliki blokami i korzysta z wirtualnego przewijania, więc nie renderuje wszystkich rekordów naraz. Zawartość Twoich plików nie jest wysyłana na serwer.

Rozmiar pliku, który można przetworzyć, zależy od pamięci przeglądarki, zasobów urządzenia, rozmiaru rekordów i wykonywanej operacji. Strumieniowy odczyt danych wejściowych nie gwarantuje ograniczonego zużycia pamięci dla danych wyjściowych: na przykład konwersja do Excela gromadzi wiersze i buduje skoroszyt w pamięci. Najpierw wypróbuj mniejszą próbkę i w razie potrzeby podziel pliki.

Pracuj z dużymi plikami JSONL online

Sprawdzaj JSONL lokalnie za pomocą narzędzia do podglądu w przeglądarce. Przy większych ilościach danych podziel plik lub użyj powyższych skryptów przetwarzających wiersz po wierszu.

Najczęściej zadawane pytania

Źródła