第六十七篇：AI模型的“饭碗”：训练数据格式转换与高效存储 - 指南

AI数据转换

• 前言：从“食材”到“饭碗”——数据如何被高效“投喂”？
• 第一章：训练数据格式：为什么“存得好”和“用得快”同样重要？
• • 1.1 核心挑战：大规模数据加载的I/O瓶颈
  • 1.2 理想的数据格式：高效、灵活、可扩展
• 第二章：JSONL：简洁通用，人类友好的“行式记录”
• • 2.1 核心思想：每行一个JSON对象
  • 2.2 优劣势：易读易写，但效率不高
  • 2.3 Python生成与解析JSONL文件
• 第三章：WebDataset：流式高效，分布式训练的“新宠”
• • 3.1 核心思想：打包为“tar文件”，实现流式加载
  • 3.2 优劣势：I/O高效，分布式友好，但管理复杂
  • 3.3 将图像数据集转换为WebDataset格式
• 第四章：TFRecord：TensorFlow生态的“原生容器”
• • 4.1 核心思想：Google生态的序列化数据格式
  • 4.2 优劣势：TF生态兼容，但通用性差
  • 4.3 Python生成与解析TFRecord文件
• 第五章：数据格式选择：为你的AI模型“挑选饭碗”
• • 5.1 特性对比：JSONL vs WebDataset vs TFRecord
  • 5.2 实际场景：如何根据需求进行选择？
• 常见训练数据格式的特点与适用场景
• “零拷贝”数据加载：性能优化的极致
• 总结与展望：你已掌握AI模型“高效投喂”的艺术

前言：从“食材”到“饭碗”——数据如何被高效“投喂”？

在前面的章节中，我们已经学会了如何采集原始数据，并将其精加工成AI模型可消化的“食材”（如标注图像、抽帧视频、提取字幕）。我们甚至学会了构造Prompt来作为AI的“语言教材”。
现在，这些准备好的数据（例如Prompt-Response对、图像-标签对），应该以什么格式存储，才能被PyTorch、TensorFlow等深度学习框架高效地读取和训练？

不同的数据格式，对训练效率、数据加载速度、甚至分布式训练都有着巨大影响。选择一个适合的“饭碗”，是高效训练AI的关键。

今天，我们将聚焦于训练数据格式转换。我们将深入探讨JSONL、WebDataset和TFRecord这三种最常见的、用于大规模深度学习训练的数据格式，理解它们的设计哲学、优劣势、适用场景，并亲手编写Python代码，实现它们之间的转换。

第一章：训练数据格式：为什么“存得好”和“用得快”同样重要？

强调训练数据格式在大规模深度学习中的重要性，特别是I/O性能瓶颈。

1.1 核心挑战：大规模数据加载的I/O瓶颈

数据量巨大：现代AI模型训练需要TB甚至PB级别的数据。

高速读取：GPU训练速度极快，CPU数据加载速度必须跟上，否则GPU会处于“饥饿”状态，效率低下。

I/O瓶颈：硬盘读取速度、文件系统性能、网络传输速度，都可能成为数据加载的瓶颈。
理想的训练数据格式，应该能够最小化这些I/O开销，确保数据能够源源不断地、高效地“投喂”给模型。

1.2 理想的数据格式：高效、灵活、可扩展

一个好的训练数据格式应具备以下特性：

高效读取：最小化磁盘寻道时间，最大化吞吐量。

便于管理：易于存储、查找、版本控制。

灵活多变：支持不同类型的数据（图像、文本、音频）和复杂的结构。

分布式友好：便于在多机多卡训练时进行数据分发。

可扩展：能够应对未来更大的数据集和更复杂的数据类型。

第二章：JSONL：简洁通用，人类友好的“行式记录”

JSONL格式的特点、优劣势，并提供Python生成与解析的代码实战。

2.1 核心思想：每行一个JSON对象

JSONL (JSON Lines)：也叫JSON per line或line-delimited JSON。它是一种简单的文本文件格式，文件中每一行都是一个独立的、完整的JSON对象。

示例：
jsonl {
"id": "001", "text": "猫咪很可爱。", "label": "正面"
} {
"id": "002", "text": "今天天气真好。", "label": "中性"
} {
"id": "003", "text": "我讨厌下雨。", "label": "负面"
}

2.2 优劣势：易读易写，但效率不高

特性 优势 劣势

人类可读性 高，直接用文本编辑器即可查看和编辑

易于解析 简单，每行独立解析，无需一次性加载整个文件

灵活性 高，每个JSON对象可有不同键值对，支持复杂结构

I/O效率 低，作为文本文件，解析开销大，不适合二进制数据

存储效率 相对较低，JSON字符串比二进制数据冗余

适用场景 小型数据集、配置文件、日志记录、中间格式 大规模图像/视频数据集的直接存储，训练时的高效读取不适合

2.3 Python生成与解析JSONL文件

目标：使用Python标准库json，生成和读取一个JSONL文件，展示其简洁性。
前置：Python基础。

# data_format_jsonl_demo.py
import json
import os
def create_jsonl_file(output_path, data_list):
"""
创建JSONL文件。
output_path: 输出文件路径。
data_list: 包含要写入JSONL的字典列表。
"""
print(f"--- 案例#001：Python生成与解析JSONL文件 ---")
print(f"正在创建JSONL文件: {output_path
}...")
with open(output_path, 'w', encoding='utf-8') as f:
for i, data_item in enumerate(data_list):
json_line = json.dumps(data_item, ensure_ascii=False) # 将字典转换为JSON字符串
f.write(json_line + '\n') # 写入一行，并加上换行符
print(f" 写入行 {i+1
}: {json_line[:50]
}...")
print(f"✅ JSONL文件 '{output_path
}' 创建成功！")
def read_jsonl_file(input_path):
"""
解析JSONL文件。
input_path: 输入文件路径。
"""
print(f"\n正在解析JSONL文件: {input_path
}...")
parsed_data = []
if not os.path.exists(input_path):
print(f"❌ 错误：未找到JSONL文件 '{input_path
}'。")
return None
with open(input_path, 'r', encoding='utf-8') as f:
for i, line in enumerate(f):
try:
data_item = json.loads(line.strip()) # 解析每一行的JSON字符串
parsed_data.append(data_item)
print(f" 解析行 {i+1
}: {data_item
}")
except json.JSONDecodeError as e:
print(f"❌ 警告：行 {i+1
} 解析失败: {e
}。跳过此行。")
continue
print(f"✅ JSONL文件 '{input_path
}' 解析完成！解析到 {
len(parsed_data)
} 条记录。")
return parsed_data
# --- 运行演示 ---
if __name__ == '__main__':
sample_data = [
{
"id": "text_001", "text": "人工智能正在改变我们的世界。", "label": "科技"
},
{
"id": "text_002", "text": "小猫咪在阳光下睡午觉，很可爱。", "label": "生活"
},
{
"id": "text_003", "text": "这是一个测试数据，包含特殊字符：✨", "label": "测试"
}
]
jsonl_filename = "sample_data.jsonl"
create_jsonl_file(jsonl_filename, sample_data)
read_jsonl_file(jsonl_filename)
print("-" * 50)

【代码解读】

这个案例展示了JSONL文件的生成和解析。

json.dumps(data_item, ensure_ascii=False)：将Python字典转换为JSON字符串。
ensure_ascii=False确保中文字符不被转义。

f.write(json_line + ‘\n’)：关键！每写入一个JSON对象后，必须加上换行符，形成JSONL格式。

json.loads(line.strip())：读取时，line.strip()去除每行末尾的换行符，然后json.loads()解析JSON字符串为Python字典。

第三章：WebDataset：流式高效，分布式训练的“新宠”

深入WebDataset的设计哲学，理解其如何通过“打包为tar文件”实现高效流式加载，并提供代码实战。

3.1 核心思想：打包为“tar文件”，实现流式加载

背景：传统数据集（如ImageNet）通常是大量小文件（几十万张图片），加载时会产生巨大的磁盘寻道开销。

WebDataset：由Google等机构提出，核心思想是将大量数据打包成一个或几个大的.tar文件（或其他归档格式，如.zip）。

“流式加载”：训练时，DataLoader直接从这些大的.tar文件中流式读取数据，无需解压整个文件到硬盘，也无需随机寻道，而是顺序读取。

优点：

1. I/O效率极高：减少了磁盘寻道，实现了接近硬盘带宽的读取速度。

2. 分布式友好：每个worker可以直接从不同的.tar文件或.tar文件的不同部分进行读取，避免竞争。

3. URL访问：可以直接从HTTP服务器加载.tar文件，无需先下载到本地。

4. 兼容性好：支持多种数据类型，且与PyTorch的DataLoader无缝集成。

3.2 优劣势：I/O高效，分布式友好，但管理复杂

特性 优势 劣势

I/O效率 极高，最小化寻道，最大化吞吐量 管理复杂，需要打包工具

分布式训练 极佳，天然支持多worker并行读取

灵活性 支持任意键值对、多种媒体类型 数据不再是独立文件，调试和查看不便

存储效率 较高，无文件系统元数据开销

适用场景 大规模图像/视频/多模态数据集训练 小数据集或需要频繁修改的场景不适用

3.3 将图像数据集转换为WebDataset格式

目标：将一个包含多张图像的文件夹，转换为WebDataset .tar格式，并演示如何从.tar文件中读取数据。

前置：pip install webdataset torchvision。需要一个本地图像文件夹。

# data_format_webdataset_demo.py
import webdataset as wds # 导入WebDataset库
import torch
from torchvision import datasets, transforms
from PIL import Image
import os
import random
import io # 用于内存中的二进制流操作
def create_dummy_image_folder(num_images=10, output_dir="dummy_images"):
"""创建一个包含假图片的文件夹用于测试。"""
os.makedirs(output_dir, exist_ok=True)
print(f"--- 准备 {num_images
} 张假图片用于WebDataset ---")
for i in range(num_images):
img = Image.new('RGB', (64, 64), color=(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
img.save(os.path.join(output_dir, f'image_{i:03d
}.jpg'))
print("假图片创建完成！")
return output_dir
def convert_folder_to_webdataset(input_folder, output_tar_path):
"""
将图像文件夹转换为WebDataset格式的.tar文件。
input_folder: 包含图像的输入文件夹路径。
output_tar_path: 输出的.tar文件路径。
"""
print(f"\n--- 案例#002：将图像数据集转换为WebDataset格式 ---")
print(f"正在将 '{input_folder
}' 转换为 '{output_tar_path
}'...")
# 定义要写入WebDataset的数据流
# 每一项是一个字典，key是文件名（不含后缀），value是对应的数据
# 例如：{'__key__': 'image_001', 'jpg': b'...', 'txt': 'label_for_image_001'}
def data_iterator():
for i, filename in enumerate(os.listdir(input_folder)):
if filename.endswith(('.jpg', '.png', '.jpeg')):
filepath = os.path.join(input_folder, filename)
with open(filepath, 'rb') as img_file:
image_bytes = img_file.read()
base_name, _ = os.path.splitext(filename)
# 假设每张图片有一个简单的文本标签
label_text = f"label for {base_name
}"
# WebDataset的每一条记录是一个字典
# '__key__': 唯一标识符
# 'jpg': 图像的二进制数据 (可以根据文件类型是 'png', 'jpeg' 等)
# 'txt': 相关的文本信息
yield {
"__key__": base_name,
"jpg": image_bytes,
"txt": label_text,
}
if i % 2 == 0:
print(f" 已处理 {i+1
} 个文件...")
# 使用wds.ShardWriter写入WebDataset
# maxcount: 每个分片（shard）包含的最大记录数
# maxsize: 每个分片的最大文件大小（字节）
with wds.ShardWriter(output_tar_path, maxcount=1000, maxsize=1e9) as sink:
for sample in data_iterator():
sink.write(sample)
print(f"✅ WebDataset文件 '{output_tar_path
}' 创建成功！")
def read_webdataset_file(input_tar_path):
"""
从WebDataset格式的.tar文件中读取数据。
input_tar_path: 输入的.tar文件路径。
"""
print(f"\n正在从WebDataset文件: {input_tar_path
} 读取数据...")
if not os.path.exists(input_tar_path):
print(f"❌ 错误：未找到WebDataset文件 '{input_tar_path
}'。")
return None
# 定义数据读取和解码流程
# wds.WebDataset() 创建WebDataset实例
# .decode() 自动解码常见的图片/文本格式
# .to_tuple() 将字典形式的样本转换为元组
dataset = wds.WebDataset(input_tar_path).decode("pil").to_tuple("jpg", "txt")
# 使用PyTorch DataLoader读取数据
loader = torch.utils.data.DataLoader(dataset, batch_size=2) # 演示批量读取
parsed_samples = []
for i, (image, text) in enumerate(loader):
print(f" 读取Batch {i+1
}:")
print(f" 图像形状: {image.shape
} (PIL Image已转为Tensor)")
print(f" 文本标签: {text
}")
parsed_samples.append({
"image": image[0], "text": text[0]
}) # 取Batch中的第一个样本
if i >= 1: break # 只读取2个Batch进行演示
print(f"✅ WebDataset文件 '{input_tar_path
}' 读取成功！读取到 {
len(parsed_samples)
} 个样本。")
return parsed_samples
# --- 运行演示 ---
if __name__ == '__main__':
dummy_img_folder = create_dummy_image_folder(num_images=5)
webdataset_filename = "dummy_images.tar"
convert_folder_to_webdataset(dummy_img_folder, webdataset_filename)
read_webdataset_file(webdataset_filename)
# 清理假图片和tar文件
import shutil
shutil.rmtree(dummy_img_folder)
os.remove(webdataset_filename)
print("\n清理完成。")
print("-" * 50)

【代码解读】

这个案例演示了WebDataset的创建和读取。

wds.ShardWriter(output_tar_path)：用于将数据写入.tar文件。maxcount和maxsize控制分片大小。
yield {“key”: base_name, “jpg”: image_bytes, “txt”: label_text}：data_iterator函数通过yield生成
字典形式的样本，WebDataset会将其打包。

wds.WebDataset(input_tar_path).decode(“pil”).to_tuple(“jpg”, “txt”)：读取WebDataset的关键。.decode(“pil”)会自动解码图片，.to_tuple(“jpg”, “txt”)则将样本字典转换为元组，方便DataLoader。

运行这段代码，它会创建一些假图片，将它们打包成.tar文件，然后再读取出来。

第四章：TFRecord：TensorFlow生态的“原生容器”

介绍TFRecord这种TensorFlow原生的高效数据格式，并提供其生成与解析的代码骨架。

4.1 核心思想：Google生态的序列化数据格式

TFRecord：TensorFlow原生的、用于存储序列化数据的二进制文件格式。每个TFRecord文件都包含一个或多个tf.train.Example协议缓冲区（Protocol Buffer）消息。

tf.train.Example：一种灵活的、可扩展的数据结构，用于存储键值对。键是特征名称，值是实际数据（可以是单一值或列表）。

优势：

1. I/O性能高：二进制格式，读取效率高，适合大规模数据。
2. TF生态兼容：与TensorFlow的tf.data API完美集成，提供高效的数据管道。
3. 支持稀疏数据：能够高效存储稀疏特征。

4.2 优劣势：TF生态兼容，但通用性差

特性	优势	劣势
I/O效率	极高，二进制格式，数据流式读取
TF兼容性	极佳，原生支持，与tf.data API无缝集成	通用性差，PyTorch/JAX等框架需额外库支持
灵活性	tf.train.Example支持多种数据类型和结构
存储效率	较高
适用场景	大规模TensorFlow模型训练，尤其是Google云平台	PyTorch用户通常倾向于WebDataset或HDF5等

4.3 Python生成与解析TFRecord文件

目标：使用TensorFlow API，生成TFRecord文件，并演示如何从TFRecord文件中读取数据。
前置：pip install tensorflow。

# data_format_tfrecord_demo.py
import tensorflow as tf # 导入TensorFlow库
import os
def _bytes_feature(value):
"""返回一个 bytes_list 从一个 string/bytes."""
if isinstance(value, type(tf.constant(0))): # instance of tf.RaggedTensor or tf.Tensor
value = value.numpy() # ensure_ascii=False 
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
def _float_feature(value):
"""返回一个 float_list 从一个 float/double."""
return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))
def _int64_feature(value):
"""返回一个 int64_list 从一个 bool / enum / int / uint."""
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
def create_tfrecord_file(output_path, data_list):
"""
创建TFRecord文件。
output_path: 输出文件路径。
data_list: 包含要写入TFRecord的字典列表，每个字典代表一个样本。
例如：{"image_bytes": b'...', "label": 1}
"""
print(f"--- 案例#003：Python生成与解析TFRecord文件 ---")
print(f"正在创建TFRecord文件: {output_path
}...")
with tf.io.TFRecordWriter(output_path) as writer:
for i, data_item in enumerate(data_list):
# 将每个样本转换为tf.train.Example协议缓冲区
feature = {
'image_bytes': _bytes_feature(data_item['image_bytes']),
'label': _int64_feature(data_item['label'])
}
# 创建一个Example消息
example = tf.train.Example(features=tf.train.Features(feature=feature))
writer.write(example.SerializeToString()) # 将Example序列化并写入文件
print(f" 写入样本 {i+1
}...")
print(f"✅ TFRecord文件 '{output_path
}' 创建成功！")
def parse_tfrecord_example(example_proto):
"""解析TFRecord中的tf.train.Example消息。"""
feature_description = {
'image_bytes': tf.io.FixedLenFeature([], tf.string),
'label': tf.io.FixedLenFeature([], tf.int64),
}
return tf.io.parse_single_example(example_proto, feature_description)
def read_tfrecord_file(input_path):
"""
从TFRecord文件中读取数据。
input_path: 输入文件路径。
"""
print(f"\n正在从TFRecord文件: {input_path
} 读取数据...")
if not os.path.exists(input_path):
print(f"❌ 错误：未找到TFRecord文件 '{input_path
}'。")
return None
raw_dataset = tf.data.TFRecordDataset(input_path) # 创建TFRecord数据集
parsed_dataset = raw_dataset.map(parse_tfrecord_example) # 解析每个Example
parsed_samples = []
print("\n--- 读取到的样本 (部分) ---")
for i, parsed_record in enumerate(parsed_dataset.take(3)): # 只读取前3个进行演示
image_bytes_val = parsed_record['image_bytes'].numpy()
label_val = parsed_record['label'].numpy()
# 将图像字节转换回PIL Image (可选，为了可视化)
# image = Image.open(io.BytesIO(image_bytes_val))
print(f" 样本 {i+1
}: 标签={label_val
}, 图像字节长度={
len(image_bytes_val)
}")
parsed_samples.append({
"image_bytes": image_bytes_val, "label": label_val
})
print(f"✅ TFRecord文件 '{input_path
}' 读取完成！读取到 {
len(parsed_samples)
} 个样本。")
return parsed_samples
# --- 运行演示 ---
if __name__ == '__main__':
# 准备模拟数据 (包含图像字节和标签)
dummy_image_data = []
for i in range(5): # 模拟5张图片
img = Image.new('RGB', (32, 32), color=(i*50, i*30, i*10))
# 将PIL Image转换为字节 (模拟图像数据)
img_byte_arr = io.BytesIO()
img.save(img_byte_arr, format='JPEG')
dummy_image_data.append({
"image_bytes": img_byte_arr.getvalue(),
"label": i % 2 # 模拟二分类标签
})
tfrecord_filename = "sample_data.tfrecord"
create_tfrecord_file(tfrecord_filename, dummy_image_data)
read_tfrecord_file(tfrecord_filename)
# 清理文件
os.remove(tfrecord_filename)
print("\n清理完成。")
print("-" * 50)

【代码解读】

这个案例演示了TFRecord的创建和读取。

_bytes_feature, _float_feature, _int64_feature：辅助函数，用于将Python数据类型封装为TFRecord的特征类型。

tf.io.TFRecordWriter(output_path)：用于写入TFRecord文件。

tf.train.Example(features=tf.train.Features(feature=feature))：核心！每个样本都被封装为一个

Example协议缓冲区消息，其中包含了所有特征。

writer.write(example.SerializeToString())：将Example消息序列化为二进制字符串并写入文件。

tf.data.TFRecordDataset(input_path)：用于读取TFRecord文件。

raw_dataset.map(parse_tfrecord_example)：通过map函数将原始的序列化消息解析为可用的特征字典。
运行这段代码，它会创建TFRecord文件，写入模拟图像数据和标签，然后再读取出来。

第五章：数据格式选择：为你的AI模型“挑选饭碗”

系统对比JSONL、WebDataset和TFRecord的特性，并提供根据实际需求进行选择的建议。

5.1 特性对比：JSONL vs WebDataset vs TFRecord

特性	JSONL	WebDataset	TFRecord
文件类型	文本文件	tar归档文件	二进制文件
可读性	高 (人类可读)	较低 (需工具解压)	低 (二进制不可读)
数据组织	每行独立JSON	样本打包进.tar文件	序列化Example消息
I/O性能	低	极高 (流式顺序读)	极高 (二进制流式读)
分布式训练	较弱 (需额外协调)	极佳 (天然支持)	较佳 (tf.data支持)
生态兼容性	强 (通用JSON)	PyTorch友好 (WDS库)	TensorFlow原生
灵活性	高 (每行可变结构)	高 (支持多种扩展名)	高 (tf.train.Example灵活)
管理复杂度	低	中高 (需打包/分片)	中高 (需Proto定义)
适用场景	小规模文本数据、日志、调试	大规模多模态数据集, PyTorch训练	大规模TensorFlow训练

5.2 实际场景：如何根据需求进行选择？

如果你是PyTorch用户，且数据规模巨大（尤其是图像、视频、多模态）：WebDataset是你的首选。它能解决I/O瓶颈，并完美支持分布式训练。

如果你是TensorFlow用户，且数据规模巨大：TFRecord是你的不二选择，它能充分利用tf.data的强大数据管道。

如果你的数据量较小，以文本为主，或者需要频繁手动查看/修改：JSONL是一个简单方便的选择。它也常作为中间格式，在转换为WebDataset或TFRecord之前使用

常见训练数据格式的特点与适用场景

“零拷贝”数据加载：性能优化的极致

展望比现有数据格式更高效的未来，涉及操作系统级别的优化。

无论是WebDataset还是TFRecord，它们都在I/O层面进行了大量优化。但极致的性能优化，是追求**“零拷贝”（Zero-Copy）数据加载**。

概念：数据从硬盘到GPU显存，不经过CPU内存的多次拷贝，而是直接在硬件层面进行数据传输。

实现：这通常需要操作系统支持内存映射（mmap），以及底层驱动和硬件的支持。

优势：进一步减少CPU开销和内存带宽的占用，实现接近物理极限的数据加载速度。

LLaMA.cpp的GGUF格式（第33章）通过mmap实现内存映射加载，就部分体现了“零拷贝”的思想，这正是其高效性的原因之一。

总结与展望：你已掌握AI模型“高效投喂”的艺术

恭喜你！今天你已经深度解密了大规模深度学习训练中训练数据格式转换的核心技巧。
✨ 本章惊喜概括 ✨

你掌握了什么？	对应的核心概念/技术
数据格式的重要性	✅ 解决大规模I/O瓶颈，提升训练效率
JSONL格式	✅ 简洁通用，生成与解析代码实战
WebDataset	✅ 流式高效，分布式友好，打包与读取代码实战
TFRecord	✅ TF原生容器，生成与解析代码骨架
格式选择策略	✅ 根据数据规模、框架生态、可读性等进行权衡
“零拷贝”	✅ 极致性能优化的未来方向

你现在对AI模型的“食粮”有了更深刻的理解，并能亲手操作，为你的AI模型“挑选最合适的饭碗”，从而构建高性能的AI训练链路。你手中掌握的，是AI模型“高效投喂”的**“数据管家”秘籍**！

敬请期待！ 在下一章中，我们将继续深入**《训练链路与采集系统》，探索多模态数据训练中更复杂的挑战——《多模态数据对齐（frame-token同步）》**，为你揭示AI模型如何理解不同感官信息之间的“天衣无缝”！