- Strona główna
- Przewodnik
- Jak pracować z dużymi plikami JSONL (1GB+)
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ęć.
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 countInterfejs 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.
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.
# 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.jsonlTechniki 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.
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.
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.
# 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"
doneTen 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.
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.
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.
Wypróbuj nasze bezpłatne narzędzia do JSONL
Przeglądaj, waliduj i konwertuj JSONL lokalnie w przeglądarce. Zawartość plików pozostaje na Twoim urządzeniu; ilość danych możliwych do przetworzenia i czas przetwarzania zależą od przeglądarki oraz wybranego narzędzia.
Podziel duze pliki JSONL na mniejsze, latwiejsze do zarzadzania czesci wedlug liczby wierszy.
Polacz wiele plikow JSONL w jeden plik z deduplikacja.
Kompresuj pliki JSONL za pomocą gzip, zstd, lz4 i snappy. Poznaj współczynniki kompresji, strumieniowanie skompresowanych danych i optymalizację JSONL do przechowywania i transferu.
Waliduj pliki JSONL linia po linii. Od razu wykrywaj błędy składni, problemy z kodowaniem i niezgodności z formatem.
Otwieraj pliki .jsonl i .ndjson w postaci tabeli, którą można szybko przeglądać i przeszukiwać — bezpośrednio w edytorze. Rozszerzenie powstało z myślą o plikach zbyt dużych do zwykłego przewijania oraz logach, do których wciąż dopisywane są nowe wpisy.