Anyverse合成数据:DMS/OMS/CPD训练数据生成全流程

Anyverse合成数据:DMS/OMS/CPD训练数据生成全流程

背景:为什么需要合成数据

真实数据的挑战

挑战 问题描述 影响
数据稀缺 边缘场景难以采集 模型泛化差
标注成本 人工标注耗时费力 开发周期长
隐私问题 人脸数据隐私敏感 合规风险
覆盖不足 多样性有限 偏见风险

合成数据优势

  1. 无限生成:覆盖所有边缘场景
  2. 精确标注:自动生成ground truth
  3. 隐私安全:无真实人脸数据
  4. 可控多样:精确控制变量

Anyverse平台介绍

Anyverse是专业的车内监控合成数据平台,支持:

  • DMS:驾驶员状态监控
  • OMS:乘员监控系统
  • CPD:儿童存在检测

核心能力

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
class AnyverseDataGenerator:
"""
Anyverse合成数据生成器

支持:
- 参数化场景
- 生物力学人体模型
- 物理传感器仿真(RGB/IR/雷达)
"""

def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.anyverse.ai/v1"

def generate_dms_dataset(
self,
num_samples: int,
scenarios: list,
sensor_config: dict
) -> dict:
"""
生成DMS数据集

Args:
num_samples: 样本数量
scenarios: 场景列表 [{type, parameters}, ...]
sensor_config: 传感器配置

Returns:
{dataset_id, download_url, statistics}
"""
import requests

payload = {
"num_samples": num_samples,
"scenarios": scenarios,
"sensor_config": sensor_config,
"output_format": "coco"
}

response = requests.post(
f"{self.base_url}/generate",
headers={"Authorization": f"Bearer {self.api_key}"},
json=payload
)

return response.json()


# DMS场景配置示例
DMS_SCENARIOS = [
{
"type": "distraction_phone",
"parameters": {
"phone_position": ["left_ear", "right_ear", "lap"],
"duration_sec": [5, 10, 15],
"head_pose": ["normal", "tilted"],
"lighting": ["day", "night", "tunnel"]
}
},
{
"type": "fatigue",
"parameters": {
"fatigue_level": ["mild", "moderate", "severe"],
"eye_closure_pattern": ["gradual", "sudden"],
"yawning": [True, False]
}
},
{
"type": "distraction_reaching",
"parameters": {
"target_location": ["rear_seat", "glove_box", "floor"],
"hand": ["left", "right", "both"]
}
}
]


# 传感器配置示例
SENSOR_CONFIG = {
"rgb_camera": {
"resolution": [1920, 1080],
"fov_degrees": 60,
"position": ["dashboard", "steering_column"]
},
"ir_camera": {
"resolution": [1280, 720],
"wavelength_nm": [850, 940],
"active_illumination": True
},
"radar": {
"frequency_ghz": 60,
"antenna_config": "4tx4rx"
}
}

Euro NCAP对齐场景

分心检测场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class EuroNCAPDistractionScenarios:
"""
Euro NCAP 2026分心检测场景

来源:Safe Driving Protocol v1.1
"""

# Euro NCAP定义的分心场景
DISTRACTION_SCENARIOS = {
'D-01': {
'name': '手机使用(打电话)',
'duration_sec': [5, 10, 15],
'phone_hand': ['left', 'right'],
'phone_position': ['ear'],
'detection_requirement': '≤3秒检测,一级警告'
},
'D-02': {
'name': '手机使用(发短信)',
'duration_sec': [5, 10],
'phone_hand': ['left', 'right'],
'phone_position': ['lap', 'steering_wheel'],
'detection_requirement': '≤3秒检测,一级警告'
},
'D-03': {
'name': '手机使用(手持)',
'duration_sec': [5, 10, 15],
'phone_hand': ['left', 'right'],
'phone_position': ['in_front'],
'detection_requirement': '≤3秒检测,二级警告'
},
'D-04': {
'name': '操作中控',
'duration_sec': [5, 10],
'target': ['radio', 'navigation', 'climate'],
'detection_requirement': '≤3秒检测'
},
'D-05': {
'name': '视线偏离道路',
'duration_sec': [3, 5],
'gaze_direction': ['passenger', 'rear', 'window'],
'detection_requirement': '≤3秒检测'
}
}

def generate_dataset(self, scenario_id: str, num_samples: int) -> list:
"""
生成指定场景的数据集

返回格式:COCO格式标注
"""
scenario = self.DISTRACTION_SCENARIOS.get(scenario_id)
if not scenario:
return []

samples = []
for i in range(num_samples):
# 参数化采样
duration = np.random.choice(scenario['duration_sec'])

sample = {
'image_path': f"{scenario_id}_{i:05d}.png",
'annotations': {
'scenario_id': scenario_id,
'duration_sec': duration,
'keypoints': self._generate_keypoints(scenario),
'bbox': self._generate_bbox(scenario),
'attributes': self._sample_attributes(scenario)
}
}
samples.append(sample)

return samples

def _generate_keypoints(self, scenario: dict) -> list:
"""生成人体关键点"""
# 简化:返回标准17点关键点
return [
{'name': 'nose', 'x': 0.5, 'y': 0.3},
{'name': 'left_eye', 'x': 0.48, 'y': 0.28},
{'name': 'right_eye', 'x': 0.52, 'y': 0.28},
# ... 更多关键点
]

def _generate_bbox(self, scenario: dict) -> dict:
"""生成边界框"""
return {
'person': {'x': 0.3, 'y': 0.1, 'w': 0.4, 'h': 0.8},
'phone': {'x': 0.45, 'y': 0.5, 'w': 0.1, 'h': 0.15}
}

def _sample_attributes(self, scenario: dict) -> dict:
"""采样属性"""
attrs = {}
for key, values in scenario.items():
if isinstance(values, list):
attrs[key] = np.random.choice(values)
return attrs

疲劳检测场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
class EuroNCAPFatigueScenarios:
"""
Euro NCAP 2026疲劳检测场景
"""

FATIGUE_SCENARIOS = {
'F-01': {
'name': 'PERCLOS超标',
'perclos_threshold': [30, 40, 50], # %
'window_sec': 60,
'eye_closure_duration': [0.5, 1.0, 1.5] # 秒
},
'F-02': {
'name': '频繁眨眼',
'blink_rate': [20, 25, 30], # 次/分钟
'duration_sec': 60
},
'F-03': {
'name': '微睡眠',
'eye_closure_sec': [1.5, 2.0, 3.0],
'frequency_per_minute': [1, 2, 3]
},
'F-04': {
'name': '打哈欠',
'mouth_open_ratio': [0.7, 0.8, 0.9],
'duration_sec': [2, 3, 4]
},
'F-05': {
'name': '头部下垂',
'head_pitch_angle': [15, 20, 30], # 度
'duration_sec': [3, 5, 10]
}
}

def generate_fatigue_sequence(
self,
scenario_id: str,
num_frames: int,
fps: int = 30
) -> list:
"""
生成疲劳时序序列

返回:逐帧标注数据
"""
scenario = self.FATIGUE_SCENARIOS[scenario_id]
frames = []

for frame_idx in range(num_frames):
timestamp = frame_idx / fps

frame = {
'frame_idx': frame_idx,
'timestamp_sec': timestamp,
'eye_state': self._simulate_eye_state(scenario, timestamp),
'head_pose': self._simulate_head_pose(scenario, timestamp),
'mouth_state': self._simulate_mouth_state(scenario, timestamp),
'fatigue_indicators': self._compute_indicators(scenario, timestamp)
}
frames.append(frame)

return frames

def _simulate_eye_state(self, scenario: dict, t: float) -> dict:
"""模拟眼部状态"""
# PERCLOS场景:周期性闭眼
if 'perclos_threshold' in scenario:
threshold = np.random.choice(scenario['perclos_threshold'])
# 模拟PERCLOS模式
closed_probability = threshold / 100.0
is_closed = np.random.random() < closed_probability

return {
'is_closed': is_closed,
'closure_duration': 0.5 if is_closed else 0,
'openness': 0.0 if is_closed else np.random.uniform(0.7, 1.0)
}

# 微睡眠场景
if 'eye_closure_sec' in scenario:
closure_duration = np.random.choice(scenario['eye_closure_sec'])
# 周期性微睡眠
cycle = 30 # 秒
phase = (t % cycle) / cycle

is_closed = phase < (closure_duration / cycle)

return {
'is_closed': is_closed,
'closure_duration': closure_duration if is_closed else 0,
'openness': 0.0 if is_closed else 0.8
}

return {'is_closed': False, 'openness': 0.8}

def _simulate_head_pose(self, scenario: dict, t: float) -> dict:
"""模拟头部姿态"""
if 'head_pitch_angle' in scenario:
angle = np.random.choice(scenario['head_pitch_angle'])
# 渐进式下垂
phase = min(t / 60, 1.0) # 60秒内渐进
return {
'pitch': angle * phase,
'yaw': np.random.uniform(-5, 5),
'roll': np.random.uniform(-3, 3)
}

return {'pitch': 0, 'yaw': 0, 'roll': 0}

def _simulate_mouth_state(self, scenario: dict, t: float) -> dict:
"""模拟嘴部状态"""
if 'mouth_open_ratio' in scenario:
ratio = np.random.choice(scenario['mouth_open_ratio'])
# 周期性打哈欠
cycle = 45 # 秒
phase = (t % cycle) / cycle

if phase < 0.2: # 打哈欠阶段
return {
'is_yawning': True,
'open_ratio': ratio * (phase / 0.2)
}

return {'is_yawning': False, 'open_ratio': 0.1}

def _compute_indicators(self, scenario: dict, t: float) -> dict:
"""计算疲劳指标"""
# 简化计算
return {
'perclos': np.random.uniform(20, 50),
'blink_rate': np.random.uniform(15, 30),
'yawn_count': int(t / 45) if 'mouth_open_ratio' in scenario else 0
}

CPD儿童存在检测场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
class CPDScenarioGenerator:
"""
CPD儿童存在检测场景生成器

Euro NCAP 2026要求
"""

CPD_SCENARIOS = {
'CPD-01': {
'name': '婴儿后向座椅',
'occupant_type': 'infant',
'seat_type': 'rear_facing_car_seat',
'age_months': [0, 6, 12],
'locations': ['rear_left', 'rear_right', 'front_passenger']
},
'CPD-02': {
'name': '幼儿前向座椅',
'occupant_type': 'toddler',
'seat_type': 'forward_facing_car_seat',
'age_months': [12, 24, 36],
'locations': ['rear_left', 'rear_right']
},
'CPD-03': {
'name': '儿童增高座椅',
'occupant_type': 'child',
'seat_type': 'booster_seat',
'age_years': [4, 6, 8],
'locations': ['rear_left', 'rear_right']
},
'CPD-04': {
'name': '儿童单独后排',
'occupant_type': 'child',
'seat_type': 'none',
'age_years': [6, 8, 10],
'locations': ['rear_left', 'rear_right', 'rear_center']
},
'CPD-05': {
'name': '宠物检测',
'occupant_type': 'pet',
'pet_type': ['dog_small', 'dog_large', 'cat'],
'locations': ['rear_seat', 'front_passenger']
},
'CPD-06': {
'name': '空座',
'occupant_type': 'none',
'locations': ['all_seats']
}
}

def generate_cpd_multimodal(
self,
scenario_id: str,
num_samples: int
) -> dict:
"""
生成CPD多模态数据集

包含:RGB + IR + Radar
"""
scenario = self.CPD_SCENARIOS[scenario_id]

dataset = {
'scenario_id': scenario_id,
'samples': [],
'modalities': ['rgb', 'ir', 'radar']
}

for i in range(num_samples):
sample = {
'sample_id': f"{scenario_id}_{i:05d}",
'rgb': {
'image_path': f"rgb/{scenario_id}_{i:05d}.png",
'resolution': [1920, 1080]
},
'ir': {
'image_path': f"ir/{scenario_id}_{i:05d}.png",
'wavelength_nm': 940,
'resolution': [640, 480]
},
'radar': {
'data_path': f"radar/{scenario_id}_{i:05d}.npy",
'type': 'range_doppler',
'config': {
'frequency_ghz': 60,
'num_chirps': 128,
'num_samples': 256
}
},
'annotations': {
'occupant_type': scenario['occupant_type'],
'location': np.random.choice(scenario.get('locations', ['rear_seat'])),
'vital_signs': self._simulate_vital_signs(scenario),
'bounding_box_3d': self._generate_3d_bbox(scenario)
}
}
dataset['samples'].append(sample)

return dataset

def _simulate_vital_signs(self, scenario: dict) -> dict:
"""模拟生命体征"""
if scenario['occupant_type'] == 'none':
return {'heart_rate': 0, 'breathing_rate': 0}

# 根据年龄调整
if 'age_months' in scenario:
age_months = np.random.choice(scenario['age_months'])
# 婴幼儿心率更高
heart_rate = np.random.uniform(100, 160) if age_months < 12 else np.random.uniform(80, 120)
breathing_rate = np.random.uniform(25, 40) if age_months < 12 else np.random.uniform(18, 30)
elif 'age_years' in scenario:
heart_rate = np.random.uniform(70, 100)
breathing_rate = np.random.uniform(16, 25)
else:
heart_rate = np.random.uniform(60, 100)
breathing_rate = np.random.uniform(12, 20)

return {
'heart_rate': heart_rate,
'breathing_rate': breathing_rate,
'confidence': np.random.uniform(0.8, 1.0)
}

def _generate_3d_bbox(self, scenario: dict) -> dict:
"""生成3D边界框"""
# 座椅坐标系
return {
'center': {'x': 0.5, 'y': 1.0, 'z': 0.4},
'size': {'x': 0.3, 'y': 0.5, 'z': 0.6},
'rotation': {'yaw': 0, 'pitch': 0, 'roll': 0}
}

数据生成流水线

完整流水线实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class DMSDataPipeline:
"""
DMS合成数据生成流水线

流程:
1. 场景定义
2. 参数采样
3. 场景渲染
4. 标注生成
5. 数据增强
6. 格式转换
"""

def __init__(self, output_dir: str):
self.output_dir = output_dir
self.distraction_gen = EuroNCAPDistractionScenarios()
self.fatigue_gen = EuroNCAPFatigueScenarios()
self.cpd_gen = CPDScenarioGenerator()

def run_full_pipeline(
self,
distraction_samples: int = 10000,
fatigue_samples: int = 5000,
cpd_samples: int = 5000
) -> dict:
"""
运行完整流水线
"""
import os
os.makedirs(self.output_dir, exist_ok=True)

results = {
'distraction': self._generate_distraction(distraction_samples),
'fatigue': self._generate_fatigue(fatigue_samples),
'cpd': self._generate_cpd(cpd_samples)
}

# 生成统计报告
self._generate_report(results)

return results

def _generate_distraction(self, total_samples: int) -> dict:
"""生成分心数据"""
scenario_ids = list(self.distraction_gen.DISTRACTION_SCENARIOS.keys())
samples_per_scenario = total_samples // len(scenario_ids)

all_samples = []
for scenario_id in scenario_ids:
samples = self.distraction_gen.generate_dataset(
scenario_id, samples_per_scenario
)
all_samples.extend(samples)

# 数据增强
augmented = self._augment_samples(all_samples)

return {
'total_samples': len(augmented),
'scenarios': scenario_ids,
'samples': augmented[:100] # 返回部分样本用于预览
}

def _generate_fatigue(self, total_samples: int) -> dict:
"""生成疲劳数据"""
scenario_ids = list(self.fatigue_gen.FATIGUE_SCENARIOS.keys())

all_sequences = []
for scenario_id in scenario_ids:
# 生成60秒序列(1800帧@30fps)
sequence = self.fatigue_gen.generate_fatigue_sequence(
scenario_id, num_frames=1800
)
all_sequences.append({
'scenario_id': scenario_id,
'sequence': sequence
})

return {
'total_sequences': len(all_sequences),
'scenarios': scenario_ids
}

def _generate_cpd(self, total_samples: int) -> dict:
"""生成CPD数据"""
scenario_ids = list(self.cpd_gen.CPD_SCENARIOS.keys())
samples_per_scenario = total_samples // len(scenario_ids)

all_datasets = []
for scenario_id in scenario_ids:
dataset = self.cpd_gen.generate_cpd_multimodal(
scenario_id, samples_per_scenario
)
all_datasets.append(dataset)

return {
'total_samples': sum(d['samples'].__len__() for d in all_datasets),
'scenarios': scenario_ids
}

def _augment_samples(self, samples: list) -> list:
"""数据增强"""
augmented = []

for sample in samples:
# 原始样本
augmented.append(sample)

# 增强1:光照变化
aug1 = sample.copy()
aug1['annotations']['attributes']['lighting'] = 'low_light'
augmented.append(aug1)

# 增强2:佩戴物
aug2 = sample.copy()
aug2['annotations']['attributes']['wearables'] = ['sunglasses']
augmented.append(aug2)

# 增强3:遮挡
aug3 = sample.copy()
aug3['annotations']['attributes']['occlusion'] = 0.3
augmented.append(aug3)

return augmented

def _generate_report(self, results: dict):
"""生成报告"""
report = f"""
# DMS合成数据生成报告

## 数据统计

### 分心检测
- 总样本数:{results['distraction']['total_samples']}
- 场景数:{len(results['distraction']['scenarios'])}
- 场景列表:{', '.join(results['distraction']['scenarios'])}

### 疲劳检测
- 总序列数:{results['fatigue']['total_sequences']}
- 场景数:{len(results['fatigue']['scenarios'])}

### CPD检测
- 总样本数:{results['cpd']['total_samples']}
- 场景数:{len(results['cpd']['scenarios'])}

## 数据格式
- 图像:PNG (1920x1080)
- 标注:COCO格式
- 多模态:RGB + IR + Radar

## Euro NCAP对齐
- ✅ 分心场景 D-01 ~ D-05
- ✅ 疲劳场景 F-01 ~ F-05
- ✅ CPD场景 CPD-01 ~ CPD-06
"""

with open(f"{self.output_dir}/report.md", 'w') as f:
f.write(report)


# 使用示例
if __name__ == "__main__":
pipeline = DMSDataPipeline("output/synthetic_data")
results = pipeline.run_full_pipeline(
distraction_samples=10000,
fatigue_samples=5000,
cpd_samples=5000
)

print(f"生成完成!")
print(f"- 分心样本:{results['distraction']['total_samples']}")
print(f"- 疲劳序列:{results['fatigue']['total_sequences']}")
print(f"- CPD样本:{results['cpd']['total_samples']}")

模型训练与验证

使用合成数据训练

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import torch
from torch.utils.data import Dataset, DataLoader

class SyntheticDMSDataset(Dataset):
"""
合成DMS数据集
"""

def __init__(self, data_dir: str, transform=None):
self.data_dir = data_dir
self.transform = transform
self.samples = self._load_annotations()

def _load_annotations(self) -> list:
"""加载标注"""
import json
with open(f"{self.data_dir}/annotations.json", 'r') as f:
return json.load(f)

def __len__(self) -> int:
return len(self.samples)

def __getitem__(self, idx: int) -> tuple:
import cv2

sample = self.samples[idx]

# 加载图像
image = cv2.imread(f"{self.data_dir}/{sample['image_path']}")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

if self.transform:
image = self.transform(image)

# 获取标签
label = sample['annotations']['scenario_id']

return image, label


def train_with_synthetic_data():
"""
使用合成数据训练DMS模型
"""
import torchvision.transforms as transforms

# 数据增强
train_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2, contrast=0.2),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])

# 加载数据
train_dataset = SyntheticDMSDataset(
"output/synthetic_data/distraction",
transform=train_transform
)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 模型
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
model.fc = torch.nn.Linear(512, 10) # 10类分心行为

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

# 训练
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
criterion = torch.nn.CrossEntropyLoss()

for epoch in range(10):
model.train()
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)

optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()

print(f"Epoch {epoch+1} completed")

# 保存模型
torch.save(model.state_dict(), "dms_synthetic_trained.pth")

return model

开发启示

1. 数据策略

阶段 真实数据 合成数据 比例
预训练 20% 80% 1:4
微调 80% 20% 4:1
边缘场景 10% 90% 1:9

2. 关键优势

  1. 边缘场景覆盖:难以采集的场景
  2. 标注质量:100%准确
  3. 迭代速度:快速验证算法
  4. 隐私合规:无真实人脸

3. 注意事项

  • 合成数据需Domain Adaptation
  • 真实数据验证必不可少
  • 持续更新场景库

参考资料:

  1. Anyverse: High-Fidelity Synthetic Data for In-Cabin Monitoring
  2. Euro NCAP Safe Driving Occupant Monitoring Protocol v1.1
  3. CVPR 2026 Workshop: Synthetic Data for Computer Vision

Anyverse合成数据:DMS/OMS/CPD训练数据生成全流程
https://dapalm.com/2026/06/16/2026-06-16-Synthetic-Data-DMS-OMS-CPD-Generation-Pipeline/
作者
Mars
发布于
2026年6月16日
许可协议