Chengfang.LU/HSAP
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: HSAP platform v2 — modular navigation, quality review, audit log, world model simulation

Browse Source 
Major changes:
- New frontend (platform/web/): Vite + React 18 + TypeScript + Tailwind
- 4-module navigation: 数据送标 / 模型管理 / 车队管理 / 系统管理
- Data catalog with charts (DMS/ADAS/Lane 3-tab view)
- Quality review workflow (标注质检): Good/Fine/Bad scoring with auto-advance
- Audit enhancements: batch operations, rejection categories, Feishu notifications
- Operation audit log (操作日志)
- World model simulation studio (仿真工坊)
- Dataset version management with snapshots and diff
- ADAS 7-class dataset integration (138K images organized + compressed)
- User management with Feishu integration and pagination
- CRUD/search/filter on all pages, card layout redesign
- PIL-optimized image overlay rendering
- Auto-snapshot on build, in_review workflow stage
- Removed embedded algorithm code (now in workspace)
This commit is contained in:
Chengfang Lu
2026-06-03 11:40:21 +08:00
parent 7c43b44c57
commit e72bc061c5
5487 changed files with 979207 additions and 6197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_dla34_culane.py Normal file
View File

@@ -0,0 +1,124 @@
net = dict(type='Detector', )
backbone = dict(
type='DLAWrapper',
dla='dla34',
pretrained=True,
)
num_points = 72
max_lanes = 4
sample_y = range(589, 230, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 2.
xyt_loss_weight = 0.2
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/dla34_culane"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.4, nms_thres=50, nms_topk=max_lanes)
epochs = 15
batch_size = 24
optimizer = dict(type='AdamW', lr=0.6e-3) # 3e-4 for batchsize 8
total_iter = (88880 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 10
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1640
ori_img_h = 590
img_w = 800
img_h = 320
cut_height = 270
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/CULane'
dataset_type = 'CULane'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 500
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

124
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_dla34_llamas.py Normal file
View File

@@ -0,0 +1,124 @@
net = dict(type='Detector', )
backbone = dict(
type='DLAWrapper',
dla='dla34',
pretrained=True,
)
num_points = 72
max_lanes = 4
sample_y = range(717, 300, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 4.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/dla34_llamas"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.45, nms_thres=50, nms_topk=max_lanes)
epochs = 20
batch_size = 24
optimizer = dict(type='AdamW', lr=0.6e-3) # 3e-4 for batchsize 8
total_iter = (58272 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 5
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1276
ori_img_h = 717
img_w = 800
img_h = 320
cut_height = 300
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
# dict(name='MultiplyAndAddToBrightness',
# parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
# p=0.6),
# dict(name='AddToHueAndSaturation',
# parameters=dict(value=(-10, 10)),
# p=0.7),
# dict(name='OneOf',
# transforms=[
# dict(name='MotionBlur', parameters=dict(k=(3, 5))),
# dict(name='MedianBlur', parameters=dict(k=(3, 5)))
# ],
# p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/llamas'
dataset_type = 'LLAMAS'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='val',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 500
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

126
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet101_culane.py Normal file
View File

@@ -0,0 +1,126 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet101',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 4
sample_y = range(589, 230, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 2.
xyt_loss_weight = 0.2
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r101_culane"
neck = dict(type='FPN',
in_channels=[512, 1024, 2048],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.4, nms_thres=50, nms_topk=max_lanes)
epochs = 20
batch_size = 12
optimizer = dict(type='AdamW', lr=0.3e-3) # 3e-4 for batchsize 8
total_iter = (88880 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 10
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1640
ori_img_h = 590
img_w = 800
img_h = 320
cut_height = 270
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/CULane'
dataset_type = 'CULane'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 500
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

127
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet101_tusimple.py Normal file
View File

@@ -0,0 +1,127 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet101',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 5
sample_y = range(710, 150, -10)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 6.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r101_tusimple"
neck = dict(type='FPN',
in_channels=[512, 1024, 2048],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.40, nms_thres=50, nms_topk=max_lanes)
epochs = 70
batch_size = 10
optimizer = dict(type='AdamW', lr=0.3e-3) # 3e-4 for batchsize 8
total_iter = (3616 // batch_size + 1) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 1
save_ep = epochs
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1280
ori_img_h = 720
img_h = 320
img_w = 800
cut_height = 160
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/tusimple'
dataset_type = 'TuSimple'
test_json_file = 'data/tusimple/test_label.json'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='trainval',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 100
# seed = 0
num_classes = 6 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

126
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet18_culane.py Normal file
View File

@@ -0,0 +1,126 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet18',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 4
sample_y = range(589, 230, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 2.
xyt_loss_weight = 0.2
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r18_culane"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.4, nms_thres=50, nms_topk=max_lanes)
epochs = 15
batch_size = 24
optimizer = dict(type='AdamW', lr=0.6e-3) # 3e-4 for batchsize 8
total_iter = (88880 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 1
save_ep = 10
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1640
ori_img_h = 590
img_w = 800
img_h = 320
cut_height = 270
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/CULane'
dataset_type = 'CULane'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 1000
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

126
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet18_llamas.py Normal file
View File

@@ -0,0 +1,126 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet18',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 4
sample_y = range(717, 300, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 8.
cls_loss_weight = 2.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/resnet18_llamas"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.45, nms_thres=60, nms_topk=max_lanes)
epochs = 20
batch_size = 24
optimizer = dict(type='AdamW', lr=0.6e-3) # 3e-4 for batchsize 8
total_iter = (58272 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 5
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1276
ori_img_h = 717
img_w = 800
img_h = 320
cut_height = 300
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/llamas'
dataset_type = 'LLAMAS'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='val',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 100
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

127
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet18_mufld.py Normal file
View File

@@ -0,0 +1,127 @@
# CLRNet on lane0_copy MUFLD packs (1280x720)
# data_root = parent of DATASET / DATASET-AddBy-*
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet18',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 4
sample_y = range(710, 150, -10)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 6.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/mufld_r18"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.40, nms_thres=50, nms_topk=max_lanes)
epochs = 15
batch_size = 16
optimizer = dict(type='AdamW', lr=1.0e-3)
# ~144k / 16 * 15 — adjust after changing train_packs
total_iter = (144117 // batch_size + 1) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 5
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1280
ori_img_h = 720
img_w = 800
img_h = 320
cut_height = 160
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
# --- MUFLD multi-pack (same as UFLD) ---
dataset_path = '/home/chengfanglu/DATA/lane0_copy'
train_packs = ['DATASET']
# train_packs = ['DATASET', 'DATASET-A'] # alias in datasets_registry.json
val_packs = ['DATASET']
pack_list_name = 'list/train_gt.txt'
pack_val_list_name = 'list/val_gt.txt'
merged_list_dir = 'lists_merged'
remerge_lists = False
write_lines_cache = True
lines_cache_dir = 'cache/mufld_lines'
dataset_type = 'MufldLane'
dataset = dict(
train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='val',
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
list_file='DATASET/list/test_gt.txt',
),
)
workers = 8
log_interval = 500
num_classes = max_lanes + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

60
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet18_mufld_smoke.py Normal file
View File

@@ -0,0 +1,60 @@
# Smoke: copy fields from clr_resnet18_mufld.py and override below
# (CLRNet Config does not use _base_ inheritance)
net = dict(type='Detector', )
backbone = dict(type='ResNetWrapper', resnet='resnet18', pretrained=True,
replace_stride_with_dilation=[False, False, False], out_conv=False)
num_points = 72
max_lanes = 4
sample_y = range(710, 150, -10)
heads = dict(type='CLRHead', num_priors=192, refine_layers=3, fc_hidden_dim=64, sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 6.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/mufld_r18_smoke"
neck = dict(type='FPN', in_channels=[128, 256, 512], out_channels=64, num_outs=3, attention=False)
test_parameters = dict(conf_threshold=0.40, nms_thres=50, nms_topk=max_lanes)
epochs = 1
batch_size = 4
optimizer = dict(type='AdamW', lr=1.0e-3)
total_iter = 32
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 1
save_ep = 1
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1280
ori_img_h = 720
img_w = 800
img_h = 320
cut_height = 160
train_process = [
dict(type='GenerateLaneLine',
transforms=[dict(name='Resize', parameters=dict(size=dict(height=img_h, width=img_w)), p=1.0)],
training=True),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[dict(name='Resize', parameters=dict(size=dict(height=img_h, width=img_w)), p=1.0)],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = '/home/chengfanglu/DATA/lane0_copy'
train_list_file = 'DATASET/list/train_gt_smoke.txt'
val_list_file = 'DATASET/list/train_gt_smoke.txt'
write_lines_cache = True
lines_cache_dir = 'cache/mufld_lines'
dataset_type = 'MufldLane'
dataset = dict(
train=dict(type=dataset_type, data_root=dataset_path, split='train'),
val=dict(type=dataset_type, data_root=dataset_path, split='val'),
test=dict(type=dataset_type, data_root=dataset_path, split='test',
list_file='DATASET/list/train_gt_smoke.txt'),
)
workers = 2
log_interval = 8
num_classes = max_lanes + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

127
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet18_tusimple.py Normal file
View File

@@ -0,0 +1,127 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet18',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 5
sample_y = range(710, 150, -10)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 6.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r18_tusimple"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.40, nms_thres=50, nms_topk=max_lanes)
epochs = 70
batch_size = 40
optimizer = dict(type='AdamW', lr=1.0e-3) # 3e-4 for batchsize 8
total_iter = (3616 // batch_size + 1) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = epochs
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1280
ori_img_h = 720
img_h = 320
img_w = 800
cut_height = 160
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/tusimple'
dataset_type = 'TuSimple'
test_json_file = 'data/tusimple/test_label.json'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='trainval',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 100
# seed = 0
num_classes = 6 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

126
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet34_culane.py Normal file
View File

@@ -0,0 +1,126 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet34',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 4
sample_y = range(589, 230, -20)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 2.
xyt_loss_weight = 0.2
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r34_culane"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.4, nms_thres=50, nms_topk=max_lanes)
epochs = 15
batch_size = 24
optimizer = dict(type='AdamW', lr=0.6e-3) # 3e-4 for batchsize 8
total_iter = (88880 // batch_size) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = 10
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1640
ori_img_h = 590
img_w = 800
img_h = 320
cut_height = 270
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/CULane'
dataset_type = 'CULane'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='train',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 500
# seed = 0
num_classes = 4 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False

127
algorithms/lane_ufld/code.embedded.bak/CLRNet-main/configs/clrnet/clr_resnet34_tusimple.py Normal file
View File

@@ -0,0 +1,127 @@
net = dict(type='Detector', )
backbone = dict(
type='ResNetWrapper',
resnet='resnet34',
pretrained=True,
replace_stride_with_dilation=[False, False, False],
out_conv=False,
)
num_points = 72
max_lanes = 5
sample_y = range(710, 150, -10)
heads = dict(type='CLRHead',
num_priors=192,
refine_layers=3,
fc_hidden_dim=64,
sample_points=36)
iou_loss_weight = 2.
cls_loss_weight = 6.
xyt_loss_weight = 0.5
seg_loss_weight = 1.0
work_dirs = "work_dirs/clr/r34_tusimple"
neck = dict(type='FPN',
in_channels=[128, 256, 512],
out_channels=64,
num_outs=3,
attention=False)
test_parameters = dict(conf_threshold=0.40, nms_thres=50, nms_topk=max_lanes)
epochs = 70
batch_size = 32
optimizer = dict(type='AdamW', lr=0.8e-3) # 3e-4 for batchsize 8
total_iter = (3616 // batch_size + 1) * epochs
scheduler = dict(type='CosineAnnealingLR', T_max=total_iter)
eval_ep = 3
save_ep = epochs
img_norm = dict(mean=[103.939, 116.779, 123.68], std=[1., 1., 1.])
ori_img_w = 1280
ori_img_h = 720
img_h = 320
img_w = 800
cut_height = 160
train_process = [
dict(
type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
dict(name='HorizontalFlip', parameters=dict(p=1.0), p=0.5),
dict(name='ChannelShuffle', parameters=dict(p=1.0), p=0.1),
dict(name='MultiplyAndAddToBrightness',
parameters=dict(mul=(0.85, 1.15), add=(-10, 10)),
p=0.6),
dict(name='AddToHueAndSaturation',
parameters=dict(value=(-10, 10)),
p=0.7),
dict(name='OneOf',
transforms=[
dict(name='MotionBlur', parameters=dict(k=(3, 5))),
dict(name='MedianBlur', parameters=dict(k=(3, 5)))
],
p=0.2),
dict(name='Affine',
parameters=dict(translate_percent=dict(x=(-0.1, 0.1),
y=(-0.1, 0.1)),
rotate=(-10, 10),
scale=(0.8, 1.2)),
p=0.7),
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
),
dict(type='ToTensor', keys=['img', 'lane_line', 'seg']),
]
val_process = [
dict(type='GenerateLaneLine',
transforms=[
dict(name='Resize',
parameters=dict(size=dict(height=img_h, width=img_w)),
p=1.0),
],
training=False),
dict(type='ToTensor', keys=['img']),
]
dataset_path = './data/tusimple'
dataset_type = 'TuSimple'
test_json_file = 'data/tusimple/test_label.json'
dataset = dict(train=dict(
type=dataset_type,
data_root=dataset_path,
split='trainval',
processes=train_process,
),
val=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
),
test=dict(
type=dataset_type,
data_root=dataset_path,
split='test',
processes=val_process,
))
workers = 10
log_interval = 100
# seed = 0
num_classes = 6 + 1
ignore_label = 255
bg_weight = 0.4
lr_update_by_epoch = False