chassis-sim 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- chassis_sim/__init__.py +12 -0
- chassis_sim/bridges/__init__.py +34 -0
- chassis_sim/bridges/adapters.py +200 -0
- chassis_sim/bridges/base.py +217 -0
- chassis_sim/bridges/raycast.py +124 -0
- chassis_sim/bridges/simple_bridge.py +1041 -0
- chassis_sim/chassis/__init__.py +20 -0
- chassis_sim/chassis/ackermann.py +131 -0
- chassis_sim/chassis/base.py +153 -0
- chassis_sim/chassis/diff_drive.py +66 -0
- chassis_sim/chassis/mecanum.py +69 -0
- chassis_sim/chassis/registry.py +81 -0
- chassis_sim/config/__init__.py +15 -0
- chassis_sim/config/curriculum.yaml +248 -0
- chassis_sim/config/env.yaml +49 -0
- chassis_sim/config/reward.yaml +274 -0
- chassis_sim/controllers/__init__.py +13 -0
- chassis_sim/controllers/_geometry.py +181 -0
- chassis_sim/controllers/base.py +253 -0
- chassis_sim/controllers/dwa.py +625 -0
- chassis_sim/controllers/pure_pursuit.py +156 -0
- chassis_sim/envs/__init__.py +51 -0
- chassis_sim/envs/chassis_env.py +1993 -0
- chassis_sim/envs/config.py +779 -0
- chassis_sim/envs/dynamics.py +203 -0
- chassis_sim/envs/observation.py +584 -0
- chassis_sim/envs/path_extractor.py +261 -0
- chassis_sim/envs/path_utils.py +160 -0
- chassis_sim/envs/privileged.py +215 -0
- chassis_sim/envs/reward.py +738 -0
- chassis_sim/envs/safety_gate.py +142 -0
- chassis_sim/eval/__init__.py +773 -0
- chassis_sim/gym_registration.py +51 -0
- chassis_sim/obs/__init__.py +40 -0
- chassis_sim/obs/spec.py +385 -0
- chassis_sim/planning/__init__.py +102 -0
- chassis_sim/planning/hybrid_astar.py +855 -0
- chassis_sim/planning/map_generator.py +1788 -0
- chassis_sim/planning/rs_curve.py +715 -0
- chassis_sim/py.typed +0 -0
- chassis_sim/render/__init__.py +66 -0
- chassis_sim/render/animation.py +130 -0
- chassis_sim/render/figure.py +1082 -0
- chassis_sim/render/recorder.py +232 -0
- chassis_sim/render/scene.py +330 -0
- chassis_sim/scenarios/__init__.py +114 -0
- chassis_sim/scenarios/data/circle.yaml +40 -0
- chassis_sim/scenarios/data/corridor.yaml +28 -0
- chassis_sim/scenarios/data/dense_static.yaml +88 -0
- chassis_sim/scenarios/data/dynamic_crossing.yaml +27 -0
- chassis_sim/scenarios/data/foldback_reverse.yaml +18 -0
- chassis_sim/scenarios/data/maze_grid.yaml +22 -0
- chassis_sim/scenarios/data/obstacles_dense.yaml +17 -0
- chassis_sim/scenarios/data/obstacles_dense_reverse.yaml +17 -0
- chassis_sim/scenarios/data/obstacles_medium.yaml +17 -0
- chassis_sim/scenarios/data/obstacles_sparse.yaml +18 -0
- chassis_sim/scenarios/data/straight.yaml +15 -0
- chassis_sim/scenarios/loader.py +585 -0
- chassis_sim/scenarios/reset_options.py +349 -0
- chassis_sim/scenarios/scenario.py +231 -0
- chassis_sim/sensors/__init__.py +26 -0
- chassis_sim/sensors/specs.py +167 -0
- chassis_sim/sensors/suite.py +393 -0
- chassis_sim-0.2.0.dist-info/METADATA +1236 -0
- chassis_sim-0.2.0.dist-info/RECORD +68 -0
- chassis_sim-0.2.0.dist-info/WHEEL +5 -0
- chassis_sim-0.2.0.dist-info/licenses/LICENSE +21 -0
- chassis_sim-0.2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,248 @@
|
|
|
1
|
+
# 课程学习阶段配置 — Hybrid-A* 全局路径生成
|
|
2
|
+
# 使用 active_stage (0-indexed) 切换当前阶段
|
|
3
|
+
# 每个 stage 继承 defaults,只写差异项
|
|
4
|
+
|
|
5
|
+
active_stage: 0
|
|
6
|
+
|
|
7
|
+
defaults:
|
|
8
|
+
hybrid_astar:
|
|
9
|
+
point_spacing: 0.05 # 路径点间距(米),长路径点多、短路径点少
|
|
10
|
+
turning_radius: 0.25
|
|
11
|
+
reverse_cost_multiplier: 1.5
|
|
12
|
+
start_theta_range: [-0.5, 0.5]
|
|
13
|
+
goal_theta_range: [-0.5, 0.5]
|
|
14
|
+
via_points: {enabled: false}
|
|
15
|
+
reverse_probability: 0.0 # 默认不反向起步朝向(stage 4+ 可覆盖)
|
|
16
|
+
path_reverse_probability: 0.0 # 默认不翻转路径(stage 4+ 可覆盖)
|
|
17
|
+
min_start_goal_dist: 3.0 # 起点与终点最小欧几里得距离(米)
|
|
18
|
+
boundary_margin: 1.5 # 起终点距世界边界的最小距离(米),自动 clamp region
|
|
19
|
+
obstacle_spacing: 0.60
|
|
20
|
+
|
|
21
|
+
# ── 参考路径横向抖动(2026-10-23,默认 0.0 = 完全关闭)─────────────────
|
|
22
|
+
# 机制:MapGenerator.generate() 在最终路径确定之后、返回之前,沿每个路径点的
|
|
23
|
+
# 路径法向(相邻点中心差分切线旋转 90 度)叠加 N(0, sigma) 样本。目的是模拟
|
|
24
|
+
# 定位误差 / 地图过期 / 规划精度不足,让参考路径可能贴得比车体还近 —— 制造
|
|
25
|
+
# "盲跟路径会撞、必须主动偏离"的实验条件(判断学习控制何时值得用)。
|
|
26
|
+
# 保持的性质(tests/test_path_perturbation.py 锁住):首末点不动(起终点位姿
|
|
27
|
+
# 与 env 的 reset/goal 判定一致)、theta 列不改(方向语义由 env 独立判定)、
|
|
28
|
+
# 抖动后的点仍在世界边界内、只由 generate(rng) 的 rng 驱动(同 seed 可复现)。
|
|
29
|
+
# 足迹复验 _check_path_footprint 仍然只看规划器输出(抖动在它之后)。
|
|
30
|
+
# 0.0 = 关闭 ⇒ 与加入本键之前逐位相同,且不消耗 rng。
|
|
31
|
+
# 三向一致:本键 / MapGenerator._path_cfg 读取(path_perturb_sigma 属性)/
|
|
32
|
+
# 装配期校验 >= 0(非法值抛 ValueError 而不是静默生成怪路径)。
|
|
33
|
+
path_perturb_sigma: 0.0
|
|
34
|
+
# 抖动方式(2026-10-23 追加,同一机制的两个采样口径):
|
|
35
|
+
# point = 每个路径点独立抽 N(0, sigma)(默认,首版行为)。在 0.05 m 点距上
|
|
36
|
+
# 等价于"每 5 cm 换一次方向":sigma=0.2/0.3 实测平均点距 0.24/0.35 m、
|
|
37
|
+
# 单步最大位移 1.0/1.5 m、每图 6~18 个自交 ⇒ 参考路径变成锯齿折线。
|
|
38
|
+
# control = 每隔 path_perturb_control_spacing 米取一个控制点抽 N(0, sigma),再沿
|
|
39
|
+
# 弧长线性插值到每个点 ⇒ 噪声的空间相关长度被钉成 0.5 m,路径仍是
|
|
40
|
+
# 一条合理曲线,同时贴障程度基本保留。首末控制点强制为 0(首末点不动)。
|
|
41
|
+
# 两种方式都保持同样三条硬约束(首末点不动 / theta 列不改 / 点在世界边界内)
|
|
42
|
+
# 且都只由 generate(rng) 的 rng 驱动;sigma=0 时两种方式都逐位不变且不抽样本。
|
|
43
|
+
path_perturb_mode: "point"
|
|
44
|
+
# control 模式的控制点弧长间距(米),须 > 0。越小越平滑噪声相关长度越短(越像
|
|
45
|
+
# point 模式);路径总长 < 本值时只有两个控制点 ⇒ 插值恒 0 = 根本不抖。
|
|
46
|
+
path_perturb_control_spacing: 0.5
|
|
47
|
+
|
|
48
|
+
# ── 折返(cusp)合法性过滤(2026-10-28,两条判据独立开关,0 = 关闭)──────────
|
|
49
|
+
# 机制:MapGenerator.generate() 在 _check_path_footprint 通过之后、_compute_goal_heading
|
|
50
|
+
# 之前调用 _cusp_violation(path);不合规 ⇒ 丢弃这张图(含障碍)重新采样,与
|
|
51
|
+
# "路径撞墙"同一条重试链(max_generate_retries),用尽则抛 MapGenerationError
|
|
52
|
+
# (env 侧再兜 8 次 MAP_GEN_RETRIES,最后退化成空地直线 + warning)。
|
|
53
|
+
# 为此丢弃的次数由 MapGenerator.cusp_rejections 计数(不逐次 warn:实测拒绝率
|
|
54
|
+
# ~10%,训练时 16 env × 每回合 reset 会把 stderr 刷满)。
|
|
55
|
+
#
|
|
56
|
+
# 「倒车腿」= 连续反向段,判据与运行时 envs/ackermann_env.py 的 segment_is_reverse
|
|
57
|
+
# 同源(段运动方向 vs 该段起点鼻向夹角 > π/2)。倒车段与 cusp 从 stage 0 就有:
|
|
58
|
+
# 每个 stage 的 reverse_primitives 都是 true(整条路径反向翻转只在 stage 4/5 由
|
|
59
|
+
# path_reverse_probability 触发,但 planner 在正向无解时会自己用 backward 原语)。
|
|
60
|
+
#
|
|
61
|
+
# 判据 1 · 短折返:某个极大倒车段的弧长 < min_cusp_fold_arc(米)。
|
|
62
|
+
# 为什么:「倒 0.5 m 再往前开」在参考路径上只占几个点,却让 path_dir /
|
|
63
|
+
# heading_error / 档位闸门在几步内翻两次;车长 0.38 m,这种折返在几何上
|
|
64
|
+
# 没有意义。它与"从哪一点开始算两条腿"无关(纯段分类 + 弧长),最稳健。
|
|
65
|
+
# 判据 2 · 窄发卡:倒车腿与前进腿最近距离 < min_cusp_leg_separation(米)。
|
|
66
|
+
# 为什么:两腿间距接近车身(半宽 0.10 m + planner robot_inflation 0.16 m)时,
|
|
67
|
+
# 车在一条腿上做横向修正就贴到另一条腿的参考线;而 PathExtractor 后的
|
|
68
|
+
# ±25 点(≈±1.25 m)最近点窗口在那一段同时含两条腿。
|
|
69
|
+
# 量法按段中点算,且只比较弧长间隔 >= cusp_min_arc_gap 的段对 —— 折返顶点
|
|
70
|
+
# 附近两腿按构造相交,把那里的 0 距离算进来这个量就失去意义。实测这个量随
|
|
71
|
+
# min_arc_gap 变化很大(stage1 80 图:gap=0.4/0.5/1.0/1.5 m ⇒ median
|
|
72
|
+
# 0.45/0.31/0.64/1.70 m)⇒ 它是"尾部判定",不是难度旋钮,改它之前先重测。
|
|
73
|
+
#
|
|
74
|
+
# 实测(2026-10-28,真 planner,每 stage 60 条候选路径,过滤关闭时统计"开启后
|
|
75
|
+
# 会丢哪些"):含倒车段 55.8%;倒车段弧长 < 0.8 m 的占 33%(分 stage
|
|
76
|
+
# 50/42/44/57/66/74%);两腿间距 < 0.35 m 的占 14%(40/21/10/16/29/26%);
|
|
77
|
+
# 两者任一 41%。开启后产出的路径违规 0/60(判据是硬的),reset 墙钟
|
|
78
|
+
# stage5 p50 480→569 ms、stage4 254→370 ms(+13~46%)。
|
|
79
|
+
# ⚠️ 短折返的来源是规划器原语:_BACKWARD_PRIMITIVES 三条都是 0.5 m 弧长
|
|
80
|
+
# (直 / κ=±4)⇒ 判据 1 实际等价于"这条路径里不许有单原语的 0.5 m 倒车"。
|
|
81
|
+
# 位置分布:最短折返段在中途 67/119、起步 35、末段 17。
|
|
82
|
+
# ⚠️ 代价(2026-10-28 用户裁决 A:接受):stage3-5 的候选图分别被丢 57/66/74%
|
|
83
|
+
# ⇒ 留下的基本是"规划器能纯前进解出来"的地图,实际难度比 stage 名字轻;
|
|
84
|
+
# 10 次内部重试用尽的概率实测 5~10%(stage4/5),由 env 侧的 8 次
|
|
85
|
+
# MAP_GEN_RETRIES 兜住(有效退化概率 ≈0,见 envs/ackermann_env.py 的 reset)。
|
|
86
|
+
# 代码默认 0.0/0.0/1.0(全关 = 与加入本键之前逐位相同),本文件显式开启。
|
|
87
|
+
# 三向一致:本文件 / MapGenerator._path_cfg 读取(同名 property)/
|
|
88
|
+
# 装配期校验 >= 0(非法值抛 ValueError 而不是静默生成怪路径)。
|
|
89
|
+
min_cusp_fold_arc: 0.8
|
|
90
|
+
min_cusp_leg_separation: 0.35
|
|
91
|
+
cusp_min_arc_gap: 1.0
|
|
92
|
+
|
|
93
|
+
stages:
|
|
94
|
+
# ══════════════════════════════════════════════════════════════════════════
|
|
95
|
+
# 2026-10-04 重构:删除空地图阶段(原 stage 0 empty_straight / 1 empty_curved)
|
|
96
|
+
# 理由(run021 实证):
|
|
97
|
+
# 1. 空地图上碰撞分支永远不可达 → critic 学不到碰撞价值,
|
|
98
|
+
# Q 景观奖励"无视 LiDAR、全速直行",正是障碍任务的反面先验;
|
|
99
|
+
# 2. 从空地图切到 count[10,20] 障碍是 0→15 的断崖,不是 ramp,
|
|
100
|
+
# 分布漂移 + primacy bias 导致策略不可恢复地退化;
|
|
101
|
+
# 3. 用户要求:直接从有障碍地图开始训练。
|
|
102
|
+
# 新思路:**从"稀疏障碍"起步,用密度 ramp 替代"有/无障碍 ramp"**。
|
|
103
|
+
# 每个阶段都是障碍地图,只是障碍密度/间距不同;专家在这些地图上
|
|
104
|
+
# 的到达率决定了自举(几何预热 + BC)是否可用。
|
|
105
|
+
# 实测几何专家(PurePursuit)到达率 vs 障碍数(修复路径几何之前):
|
|
106
|
+
# 1-2 个 80% | 2-4 个 62% | 4-6 个 52% | 5-8 个 47% | 10-20 个 22-30%
|
|
107
|
+
# ══════════════════════════════════════════════════════════════════════════
|
|
108
|
+
|
|
109
|
+
# Stage 0: 稀疏障碍 — 从障碍地图起步(无空地图),专家可自举
|
|
110
|
+
- name: "obstacles_sparse"
|
|
111
|
+
obstacles:
|
|
112
|
+
enabled: true
|
|
113
|
+
count: [2, 5]
|
|
114
|
+
shapes: ["circle", "rectangle"]
|
|
115
|
+
circle: { radius: [0.2, 0.5] }
|
|
116
|
+
rectangle: { length: [0.5, 1.5], width: [0.2, 0.6] }
|
|
117
|
+
position_margin: 1.2
|
|
118
|
+
obstacle_spacing: 1.0
|
|
119
|
+
hybrid_astar:
|
|
120
|
+
reverse_primitives: true
|
|
121
|
+
max_iterations: 3000
|
|
122
|
+
start_region: [1, 3, 1, 3]
|
|
123
|
+
goal_region: [7, 9, 7, 9]
|
|
124
|
+
start_theta_range: [-0.5, 0.5]
|
|
125
|
+
goal_theta_range: [-0.5, 0.5]
|
|
126
|
+
start_goal_clearance: 1.0
|
|
127
|
+
via_points: {enabled: false}
|
|
128
|
+
path_perturb_sigma: 0.0
|
|
129
|
+
path_perturb_mode: "point"
|
|
130
|
+
path_perturb_control_spacing: 0.5
|
|
131
|
+
|
|
132
|
+
# Stage 1: 中等障碍 — 密度上升,仍以直行为主
|
|
133
|
+
- name: "obstacles_medium"
|
|
134
|
+
obstacles:
|
|
135
|
+
enabled: true
|
|
136
|
+
count: [5, 9]
|
|
137
|
+
shapes: ["circle", "rectangle"]
|
|
138
|
+
circle: { radius: [0.2, 0.5] }
|
|
139
|
+
rectangle: { length: [0.5, 1.5], width: [0.2, 0.6] }
|
|
140
|
+
position_margin: 1.1
|
|
141
|
+
obstacle_spacing: 0.8
|
|
142
|
+
hybrid_astar:
|
|
143
|
+
reverse_primitives: true
|
|
144
|
+
max_iterations: 3000
|
|
145
|
+
start_region: [1, 3, 1, 3]
|
|
146
|
+
goal_region: [7, 9, 7, 9]
|
|
147
|
+
start_theta_range: [-0.8, 0.8]
|
|
148
|
+
goal_theta_range: [-1.0, 1.0]
|
|
149
|
+
start_goal_clearance: 0.85
|
|
150
|
+
via_points: {enabled: false}
|
|
151
|
+
path_perturb_sigma: 0.0
|
|
152
|
+
path_perturb_mode: "point"
|
|
153
|
+
path_perturb_control_spacing: 0.5
|
|
154
|
+
|
|
155
|
+
# Stage 2: 密集障碍 — 原 stage 2 的密度,作为主要收敛目标
|
|
156
|
+
- name: "obstacles_dense"
|
|
157
|
+
obstacles:
|
|
158
|
+
enabled: true
|
|
159
|
+
count: [9, 15]
|
|
160
|
+
shapes: ["circle", "rectangle"]
|
|
161
|
+
circle: { radius: [0.2, 0.5] }
|
|
162
|
+
rectangle: { length: [0.5, 1.5], width: [0.2, 0.6] }
|
|
163
|
+
position_margin: 1.0
|
|
164
|
+
obstacle_spacing: 0.65
|
|
165
|
+
hybrid_astar:
|
|
166
|
+
reverse_primitives: true
|
|
167
|
+
max_iterations: 4000
|
|
168
|
+
start_region: [1, 3, 1, 3]
|
|
169
|
+
goal_region: [7, 9, 7, 9]
|
|
170
|
+
start_theta_range: [-1.0, 1.0]
|
|
171
|
+
goal_theta_range: [-1.5, 1.5]
|
|
172
|
+
start_goal_clearance: 0.7
|
|
173
|
+
via_points: {enabled: false}
|
|
174
|
+
path_perturb_sigma: 0.0
|
|
175
|
+
path_perturb_mode: "point"
|
|
176
|
+
path_perturb_control_spacing: 0.5
|
|
177
|
+
|
|
178
|
+
# Stage 3: 密集障碍 + 倒车路段(原 stage 3 密度下调后)
|
|
179
|
+
- name: "obstacles_dense_reverse"
|
|
180
|
+
obstacles:
|
|
181
|
+
enabled: true
|
|
182
|
+
count: [8, 14]
|
|
183
|
+
shapes: ["circle", "rectangle"]
|
|
184
|
+
circle: { radius: [0.2, 0.5] }
|
|
185
|
+
rectangle: { length: [0.3, 1.2], width: [0.2, 0.5] }
|
|
186
|
+
position_margin: 1.0
|
|
187
|
+
obstacle_spacing: 0.65
|
|
188
|
+
hybrid_astar:
|
|
189
|
+
reverse_primitives: true
|
|
190
|
+
max_iterations: 4000
|
|
191
|
+
start_region: [0.5, 3, 0.5, 3]
|
|
192
|
+
goal_region: [7, 9.5, 7, 9.5]
|
|
193
|
+
start_theta_range: [-1.0, 1.0]
|
|
194
|
+
goal_theta_range: [-1.0, 1.0]
|
|
195
|
+
start_goal_clearance: 0.7
|
|
196
|
+
reverse_probability: 0.4 # 40% 起步倒车
|
|
197
|
+
path_reverse_probability: 0.2 # 20% 翻转整条路径
|
|
198
|
+
path_perturb_sigma: 0.0
|
|
199
|
+
path_perturb_mode: "point"
|
|
200
|
+
path_perturb_control_spacing: 0.5
|
|
201
|
+
|
|
202
|
+
# Stage 4: 倒车/折返
|
|
203
|
+
# 【2026-10-30 密度 ramp】count 12-20 → 10-16、circle 半径上限 0.6 → 0.5、spacing 0.6 → 0.62。
|
|
204
|
+
# 依据:run113 / run114 两次都在本阶段自锁(foldback eval 均值 0.496 / 0.428;run114 的 31 次
|
|
205
|
+
# eval 里 0 次达到 threshold_advance 0.65、最高 0.575),而 stage3 dense_reverse(count 8-14 +
|
|
206
|
+
# 倒车 0.4/0.2)两次都在 0.61-0.64 ⇒ 断崖来自"数量 +45% + 半径上限 +0.1 + 间距 -0.05"三连跳,
|
|
207
|
+
# 不是倒车本身(倒车概率 0.3/0.3 保持不动,只把密度抬到 stage3 与旧 stage4 之间)。stage5 未动。
|
|
208
|
+
- name: "foldback_reverse"
|
|
209
|
+
obstacles:
|
|
210
|
+
enabled: true
|
|
211
|
+
count: [10, 16]
|
|
212
|
+
shapes: ["circle", "rectangle"]
|
|
213
|
+
circle: { radius: [0.2, 0.5] }
|
|
214
|
+
rectangle: { length: [0.5, 1.5], width: [0.2, 0.5] }
|
|
215
|
+
position_margin: 1.0
|
|
216
|
+
obstacle_spacing: 0.62
|
|
217
|
+
hybrid_astar:
|
|
218
|
+
turning_radius: 0.25
|
|
219
|
+
reverse_primitives: true
|
|
220
|
+
max_iterations: 4000
|
|
221
|
+
start_theta_range: [-1.0, 1.0]
|
|
222
|
+
start_region: [0.5, 2.5, 0.5, 2.5]
|
|
223
|
+
goal_region: [7.5, 9.5, 7.5, 9.5]
|
|
224
|
+
start_goal_clearance: 0.7
|
|
225
|
+
reverse_probability: 0.3
|
|
226
|
+
path_reverse_probability: 0.3
|
|
227
|
+
path_perturb_sigma: 0.0
|
|
228
|
+
path_perturb_mode: "point"
|
|
229
|
+
path_perturb_control_spacing: 0.5
|
|
230
|
+
|
|
231
|
+
# Stage 5: 网格迷宫 — 死胡同倒车
|
|
232
|
+
- name: "maze_grid"
|
|
233
|
+
obstacles:
|
|
234
|
+
enabled: true
|
|
235
|
+
generation: "grid"
|
|
236
|
+
grid_size: 1.0
|
|
237
|
+
fill_ratio: [0.4, 0.7]
|
|
238
|
+
dead_end_ratio: [0.1, 0.3]
|
|
239
|
+
position_margin: 1.0
|
|
240
|
+
hybrid_astar:
|
|
241
|
+
reverse_primitives: true
|
|
242
|
+
max_iterations: 5000
|
|
243
|
+
start_region: [1, 3, 1, 3]
|
|
244
|
+
goal_region: [7, 9, 7, 9]
|
|
245
|
+
start_goal_clearance: 1.0
|
|
246
|
+
path_perturb_sigma: 0.0
|
|
247
|
+
path_perturb_mode: "point"
|
|
248
|
+
path_perturb_control_spacing: 0.5
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
world:
|
|
2
|
+
height: 10
|
|
3
|
+
width: 10
|
|
4
|
+
step_time: 0.1 # 10Hz
|
|
5
|
+
sample_time: 0.1
|
|
6
|
+
offset: [0, 0]
|
|
7
|
+
control_mode: "auto"
|
|
8
|
+
collision_mode: "stop"
|
|
9
|
+
|
|
10
|
+
robot:
|
|
11
|
+
kinematics: {name: 'acker'}
|
|
12
|
+
shape: {name: 'rectangle', length: 0.38, width: 0.2, wheelbase: 0.145}
|
|
13
|
+
state: [1, 1, 0, 0] # Placeholder — overridden by MapGenerator
|
|
14
|
+
goal: [9, 9, 0] # Placeholder — overridden by MapGenerator
|
|
15
|
+
color: 'b'
|
|
16
|
+
vel_dim: 2
|
|
17
|
+
vel_min: [-1, -1] # [v_min, steer_min] — 宽松于 train.yaml v_min=-0.6,防止 ir-sim 裁剪动作映射
|
|
18
|
+
vel_max: [2, 1] # [v_max, steer_max] — 宽松于 train.yaml v_max=1.3,防止 ir-sim 裁剪动作映射
|
|
19
|
+
|
|
20
|
+
# ── 动力学三级开关(2026-11-04;语义与标定依据见 src/chassis_sim/envs/dynamics.py)──
|
|
21
|
+
# 挂在 robot 段下而不是新增顶层键:env.yaml 的顶层键必须保持 {world, robot}(与主仓
|
|
22
|
+
# 一致,见 tests/test_envs_config.py 的 TestPackagedYaml)。
|
|
23
|
+
# level: none 纯运动学(默认)。与加入本开关前逐位相同:dynamics.py 连 import 都不发生
|
|
24
|
+
# limits 加速度/转角速率硬限幅(|Δv| ≤ accel_max·dt,|Δδ| ≤ steer_rate_max·dt)
|
|
25
|
+
# wheel limits + 执行器一阶滞后 + 死区 + 轮滑
|
|
26
|
+
# 构造器 dynamics= 可覆盖本段 level(其余参数仍取本段);显式传 "none" 时本段的
|
|
27
|
+
# accel_max / steer_rate_max 也不再生效(none 档是纯运动学,见 ChassisSimEnv 注释)。
|
|
28
|
+
# 三个默认值(0 = 未显式配置)与 dataclass 默认值逐位相同,否则 load_default_config()
|
|
29
|
+
# 就不再等于 EnvConfig()(tests/test_envs_config.py 的 test_equals_dataclass_defaults)。
|
|
30
|
+
dynamics:
|
|
31
|
+
level: "none"
|
|
32
|
+
accel_max: 0.0 # m/s²;0 ⇒ limits/wheel 档用 1.5(none 档不看它)
|
|
33
|
+
steer_rate_max: 0.0 # rad/s;0 ⇒ limits/wheel 档用 3.0(none 档不看它)
|
|
34
|
+
v_tau: 0.15 # s;速度一阶滞后(仅 wheel 档)
|
|
35
|
+
omega_tau: 0.10 # s;角速度一阶滞后(仅 wheel 档)
|
|
36
|
+
v_deadband: 0.0 # m/s;|v_cmd| 低于此值时输出归零(0 = 关,仅 wheel 档)
|
|
37
|
+
wheel_slip: 0.0 # 轮滑系数 ∈[0,1);地速 = 轮速×(1−slip)(0 = 关,仅 wheel 档)
|
|
38
|
+
|
|
39
|
+
sensors:
|
|
40
|
+
- type: 'lidar2d'
|
|
41
|
+
range_max: 10.0
|
|
42
|
+
angle_range: 3.1415926 # 180 deg in radians
|
|
43
|
+
number: 180
|
|
44
|
+
offset: [0.145, 0, 0] # 安装在车头
|
|
45
|
+
- type: 'lidar2d'
|
|
46
|
+
range_max: 10.0
|
|
47
|
+
angle_range: 3.1415926 # 180 deg in radians
|
|
48
|
+
number: 180
|
|
49
|
+
offset: [-0.155, 0, 3.1415926] # 车尾, theta=π 朝向后方
|
|
@@ -0,0 +1,274 @@
|
|
|
1
|
+
# ============================================================================
|
|
2
|
+
# 奖励函数配置 — 极简模型 (2026-08-16 v5)
|
|
3
|
+
#
|
|
4
|
+
# 核心原则:
|
|
5
|
+
# 1. Reward 定义目标,不教方法 — 删除所有硬编码驾驶规则
|
|
6
|
+
# 2. 7 分量:cte + heading + obstacle + progress + steer + goal_proximity + step(drive 已删)
|
|
7
|
+
# progress 与 goal_proximity 均为势能型(Φ(s')−Φ(s)),保证总量有界、无法通过徘徊刷分
|
|
8
|
+
# 3. 无动态权重、无布尔分支、无不可微点
|
|
9
|
+
#
|
|
10
|
+
# 总奖励 = r_cte + r_heading + r_obstacle + r_progress + r_steer + r_goal_prox + r_step
|
|
11
|
+
# r_goal_prox (2026-08-19 势能化) = w × [1/(d_t+0.5) − 1/(d_{t−1}+0.5)],总量有界、不可刷分
|
|
12
|
+
# ============================================================================
|
|
13
|
+
|
|
14
|
+
# ── 各分量权重 ──────────────────────────────────────────────────────────
|
|
15
|
+
reward_weights:
|
|
16
|
+
drive: 0 # 已删除——与 progress 共线 (v×cosθ≈位移/dt),progress 更鲁棒
|
|
17
|
+
cte_penalty: 6.0 # 二次型 CTE² 惩罚权重——近路径梯度≈0,远路径加速惩罚
|
|
18
|
+
# 2026-10-30 由 3.0 抬到 6.0:实测 |CTE| 中位 0.17 m 处单步罚
|
|
19
|
+
# 只有 −0.07,把横向误差压到专家级(0.012 m)整回合也只多拿
|
|
20
|
+
# +10 raw ≈ 一次成功的 2.6% ⇒ 贴线在奖励里几乎无价
|
|
21
|
+
# (docs/2026-10-29-贴线精度诊断.md §4)。副作用:更保守/更多超时。
|
|
22
|
+
heading_penalty: 0.3 # 偏航惩罚权重(前进段)——防低速平行漂移
|
|
23
|
+
heading_penalty_reverse: 0.5 # 倒车段的偏航惩罚权重 (2026-10-05 新增)。
|
|
24
|
+
# 实测 run025 在倒车段上 82~90% 的步是"掉头正着开"
|
|
25
|
+
# (横向 |CTE| 只有 0.16~0.27m,位置势能完全看不出差别),
|
|
26
|
+
# 说明 0.3 的偏航罚不足以抵消"掉头比倒车好开"的收益。
|
|
27
|
+
# 取值 0.5(**保守值**,2026-10-05 由用户选定):
|
|
28
|
+
# 最大 -1.57/步(前进段仍是 -0.94/步),
|
|
29
|
+
# 与 env 侧"档位闸门"(反向前进不给正向 arc_progress)
|
|
30
|
+
# 叠加后,正确倒车比作弊每步好约 1.87。
|
|
31
|
+
# 我先按 1.0 实现(单步差约 3.4),但 stage4 上非合规步
|
|
32
|
+
# 每步多罚约 2.2、171 步 ≈ -376/回合,力度偏大;
|
|
33
|
+
# 0.5 是留了余量的版本。若倒车段合规率仍上不去,
|
|
34
|
+
# 再调回 1.0(改这一个数即可)。代码默认值仍是 1.0
|
|
35
|
+
# (envs/reward.py:65/203),**以 YAML 为准**。
|
|
36
|
+
obstacle: 1.5 # 指数避障惩罚权重 (d=0→-1.0)
|
|
37
|
+
progress: 4.0 # 路径进度奖励——势能型 arc_progress=Φ(s_{t+1})−Φ(s_t),前进+/后退−/振荡零 (2026-08-16 替代速率型)
|
|
38
|
+
steer_penalty: 0.5 # 转向惩罚——防直线画龙 (abs(prev_delta))
|
|
39
|
+
# 2026-10-30 由 0.1 抬到 0.5:策略把转向学成了满舵 PWM
|
|
40
|
+
# (a0 每约 3 步换号、|a0| 均值 0.79),满舵步罚分
|
|
41
|
+
# −0.043 → −0.215/步,等于给"来回打死方向"直接定价。
|
|
42
|
+
collision: 1.0 # 碰撞终止惩罚权重
|
|
43
|
+
goal: 1.0 # 到达目标终止奖励权重
|
|
44
|
+
goal_heading: 1.0 # 到达目标时朝向对齐奖励权重
|
|
45
|
+
alive: 0.0 # 禁用存活奖励
|
|
46
|
+
stuck: 1.0 # 卡住终止惩罚权重
|
|
47
|
+
timeout: 1.0 # 超时终止惩罚权重
|
|
48
|
+
path_deviation: 1.0 # 路径偏离终止惩罚权重
|
|
49
|
+
goal_proximity: 2.0 # 终点距离势能权重 (2026-08-19 势能化, 修 B7 刷分漏洞):
|
|
50
|
+
# r = w×[Φ(d_t) − Φ(d_{t−1})], Φ(d) = 1/(d+0.5)
|
|
51
|
+
# 旧形式 w/(d+0.5) 为恒定稠密加成 → 1.5m 处悬停 400 步白拿 +400
|
|
52
|
+
# 势能总量有界 = w×[Φ(d_T) − Φ(d_0)] ≤ w×(1/0.5) = 4.0
|
|
53
|
+
# 2m 内势能差上限 = 2.0×(2.0 − 0.4) = 3.2;恒距悬停每步 ≈ 0
|
|
54
|
+
# 逼近为正 / 远离为负 / 徘徊净零;随 d 自然衰减故不再用 near_goal 门控
|
|
55
|
+
|
|
56
|
+
# ── 数值参数 ────────────────────────────────────────────────────────────
|
|
57
|
+
reward_params:
|
|
58
|
+
dense_scale: 1.0 # 稠密奖励不缩放
|
|
59
|
+
|
|
60
|
+
cte_range: 4.0 # CTE 归一化分母 (m) — 保留兼容,代码不再读取
|
|
61
|
+
cte_delta: 0.5 # Huber 转捩点 (m) — 保留兼容,代码不再读取
|
|
62
|
+
failure_dense_cap: 0.12 # 失败回合的稠密累计"每步额度" C = 该值×max_steps
|
|
63
|
+
# 2026-10-23 诊断:0.0 → 0.12(重新开启)。诊断实测 run100(700k)
|
|
64
|
+
# 的 episode 回报:collision 均值 −57.2(37 步)/ timeout 均值
|
|
65
|
+
# −302.1(300 步)⇒ 撞车比超时便宜 5.3 倍,即"早死更便宜"。
|
|
66
|
+
# 本项让失败代价不再随步数线性增长(C = 0.12×500 = 60)。
|
|
67
|
+
# 历史(2026-10-05 为何一度关闭):不设上限时退款在终止步一次
|
|
68
|
+
# 冲 +220~+3562,把"长失败回路的前一步"变成价值最高的状态
|
|
69
|
+
# ⇒ 现在**必须**配 failure_dense_refund_cap(见下)。
|
|
70
|
+
# 0 = 关闭(回退到 2026-10-05~10-23 的行为)。
|
|
71
|
+
failure_dense_refund_cap: 120.0 # 失败补偿的单次退款上限 (2026-10-05 引入, 2026-10-23 设为 120)
|
|
72
|
+
# 不设上限时终止步退款实测达 +3562(= goal_bonus 的 8.9×),
|
|
73
|
+
# 把"长失败回路的前一步"变成 MDP 里价值最高的状态(+534 缩放后),
|
|
74
|
+
# 并让 4.2% 的 target 撞上 +150 上限。
|
|
75
|
+
# 设 120 后终止奖励上界 = −100×stage_scale 基项 + 120×comp_scale,
|
|
76
|
+
# 即 stage≥3 碰撞/超时 ≤ +20(×reward_scale 0.15 后 ≤ +3),
|
|
77
|
+
# 不再有千级尖峰。0 = 不限(回退旧行为,**不要**与 cap>0 同时用)。
|
|
78
|
+
failure_time_compensation: 0.0 # 时间税补回倍率 (2026-10-23 补进 YAML)
|
|
79
|
+
# 该参数 reward.py 一直在读、RewardConfig 也早已白名单,但
|
|
80
|
+
# reward.yaml 里从来没有这个键 ⇒ 两个失败补偿参数只有一半真能
|
|
81
|
+
# 从 YAML 配。0.0 = 关闭(实测方向与目标相反:把"早失败少付的
|
|
82
|
+
# 时间税"又罚一遍,25/120 步失败差反而 7.5 → 9.8)。
|
|
83
|
+
path_d_max: 4.0 # CTE 观测归一化除数 (m),对齐 cte_range
|
|
84
|
+
|
|
85
|
+
# 指数避障范围 (m) — 2026-10-05 标定 1.5 → 0.8(用户拍板方向:「obstacle 的 range
|
|
86
|
+
# 降低一些,碰撞检测不用太严厉,稍微离障碍物近点也可以只要不碰到」)。
|
|
87
|
+
# ⚠ 收窄的只是**软惩罚的作用范围**;物理碰撞判定(_check_collision / SAT 足迹 /
|
|
88
|
+
# collision_penalty)一律未动。权重 obstacle=1.5 也未动 ⇒ d=0 处最大值仍 -1.50。
|
|
89
|
+
# 为什么必须收窄(真 numpy 环境 × 真 stage4/5 地图 × PurePursuit oracle 实测,
|
|
90
|
+
# 每阶段 16 回合、对照两遍轨迹逐位一致;脚本 /tmp/calib_measure.py):
|
|
91
|
+
# · 参考路径**自身**的净空 mu=0.75m / p50=0.71m / min=0.17m,36.6% 的路点 <0.6m
|
|
92
|
+
# ⇒ range=1.5 时"照着参考路径正常行驶"每步就被扣 -0.93/步;
|
|
93
|
+
# · 成功回合的总稠密罚分 -0.75/步里 obstacle 一项就是 -0.75/步(占 94%~100%),
|
|
94
|
+
# 其余 6 项净和 ≈ 0 —— 即"锅几乎全在这一项";
|
|
95
|
+
# · range=0.8 后逐距离:d=1.5m → -0.23、d=1.0m → -0.43、d=0.6m → -0.71、
|
|
96
|
+
# d=0.3m → -1.03、d=0.1m → -1.32、d=0 → -1.50
|
|
97
|
+
# ⇒ 贴路径(≳1.2m)基本无感,真靠近(<0.6m)照样罚得动。
|
|
98
|
+
obstacle_range: 0.8
|
|
99
|
+
|
|
100
|
+
# ── 终点附近(near_goal = 距终点 < 2m)的 obstacle 项门控 (P2-14, 2026-10-23) ──
|
|
101
|
+
# 事实(读码核实 envs/reward.py 的 compute):near_goal 只影响 obstacle 一项,
|
|
102
|
+
# 其它分量照算;两条分支——
|
|
103
|
+
# factor == 0 → **整项清零**(不是"衰减到 0",也不留残值):实测终点前一步
|
|
104
|
+
# obstacle 由 −1.3237 直接变 0.0,即"终点附近撞不撞无所谓";
|
|
105
|
+
# factor > 0 → r_obstacle *= max(factor, goal_dist/obstacle_near_goal_range),
|
|
106
|
+
# 即以 factor 为**下限**的线性衰减(越近折扣越大,但永不归零)。
|
|
107
|
+
# 这两个参数此前只写在 RewardCalculator.__init__ 的 **kwargs 里:RewardConfig
|
|
108
|
+
# 白名单与 reward.yaml 都没有它们 ⇒ 不可配、不可见,行为被硬钉死。
|
|
109
|
+
# **默认 0.0 = 保持当前行为不变**(本轮只做"可见 + 可配",不改标定结论)。
|
|
110
|
+
# 认为"终点附近撞不撞无所谓"是有意设计 → 保持 0.0;
|
|
111
|
+
# 希望终点附近仍保留避障梯度 → 设 0.2~0.5(= 最多打 2~5 折,但不归零)。
|
|
112
|
+
# 注:是否真生效还取决于 env 侧是否把该字段转发给 RewardCalculator
|
|
113
|
+
# (2026-10-23 的 2 行 getattr 转发由 X6 在 envs/ackermann_env.py 落地)。
|
|
114
|
+
# ── 速度感知障碍惩罚 (2026-10-23) ─────────────────────────────────────
|
|
115
|
+
# 旧公式 obstacle = -w_obs × exp(-d/range) **只看距离**:同一个位置上
|
|
116
|
+
# "全速冲过"与"减速蹭过"的即时罚分完全相同 ⇒ critic 的价格信号里没有任何
|
|
117
|
+
# "该减速"的经济理由(Q 校准审计实测:a1 网格上 92.9% 的状态 argmax 落在
|
|
118
|
+
# 边界 +1.0 最大速度,内部点合计 <1%)。
|
|
119
|
+
#
|
|
120
|
+
# 开启后(power > 0):
|
|
121
|
+
# factor = 1 + (|v| / v_max) ** obstacle_speed_power ∈ [1, 2]
|
|
122
|
+
# |v| = 0(静止/极慢) → factor = 1 → 罚分与旧公式**逐位相同**
|
|
123
|
+
# |v| = v_max(满速) → factor = 2 → 罚分翻倍
|
|
124
|
+
# v 取该步**实际执行**的车速(env 侧 raw['odometry'][3],经加速度限幅后),
|
|
125
|
+
# v_max 取 env 配置(train.yaml env.v_max = 1.0)。
|
|
126
|
+
# 用 |v| 而不是 v:**倒车贴近障碍同样该罚**(档位与风险无关)。
|
|
127
|
+
#
|
|
128
|
+
# **0.0 = 关闭 = 默认 = 生产行为逐位不变**(compute() 里整段跳过,不乘 1.0)。
|
|
129
|
+
# 校验:≥ 0,非法值在**配置加载期**被 training/config.py 拒掉。
|
|
130
|
+
#
|
|
131
|
+
# ⚠ 选值前必读(2026-10-23 实测,真 stage1 地图 + 真 RewardCalculator,18 个
|
|
132
|
+
# 成功回合 / 2838 步,脚本 /tmp/measure_speed_power.py):
|
|
133
|
+
# · 逐**步**看(固定步数、只换速度):本项让"减速"的即时罚分变轻
|
|
134
|
+
# (d=0.2m 处 p=1:全速 -2.3364 → 降到 35% 速度 -1.5771,差 +0.7593,
|
|
135
|
+
# ×reward_scale 后 +0.114)。旧公式下这个差**恒为 0**。
|
|
136
|
+
# · 逐**米**看(同样走完这段路,慢就得多走几步):每米成本 ∝ (1+u^p)/u,
|
|
137
|
+
# u=|v|/v_max。p=1 时降到 35% 速度仍比满速贵 1.93×,降到 70% 贵 1.21×
|
|
138
|
+
# ⇒ **p=1 不会让"减速"在经济上划算**,只会加一个逐步的局部梯度。
|
|
139
|
+
# · 想真的让"减速更划算",需要 u^p < 2u−1(只有 u>0.5 才可能):
|
|
140
|
+
# p=3 → 降到 70% 时 0.959(开始划算);p=4 → 0.886。
|
|
141
|
+
# 实测整回合口径:风险区降到 70%,p=3 时 0.99×(打平)、p=4 时 0.97×。
|
|
142
|
+
# · 代价:p 越大,满速端 d(factor)/du = p 越陡 ⇒ Q 在 a1≈+1 附近更陡,
|
|
143
|
+
# 可能把现在的"边界 argmax"换成更硬的 bang-bang。建议先跑 p=3 的 A/B。
|
|
144
|
+
# · 上限:不强制校验,但 >2 就是"过度放大满速端梯度"区间(除非专门做 A/B)。
|
|
145
|
+
# 一句话:p=1 ≈ "把障碍罚分整体放大一倍 + 一点点速度梯度";要改 argmax 用 p≈3。
|
|
146
|
+
# 不改标定:obstacle_range=0.8 / obstacle=1.5 一律未动(本开关只叠一个 ≤2 的因子)。
|
|
147
|
+
# 三向一致:本键 / RewardConfig.obstacle_speed_power /
|
|
148
|
+
# _SRewardParams.obstacle_speed_power / RewardCalculator 签名默认 / env 侧转发
|
|
149
|
+
# (tests/test_obstacle_speed_power.py 锁住)。
|
|
150
|
+
obstacle_speed_power: 0.0
|
|
151
|
+
# ── 前进段倒退的专项定价(2026-10-29)───────────────────────────────
|
|
152
|
+
# r_reverse = -w × min(1, |v|/v_max),**仅当 path_dir>0(路径要求前进)且 v<0**。
|
|
153
|
+
# 为什么需要单独一项(而不是调大 progress 权重):
|
|
154
|
+
# arc_progress 是**路径比例**(每步 0.0018~0.0106),所以 progress 项在倒退时
|
|
155
|
+
# 只有 -0.007~-0.042/步;×3 也才 -0.02~-0.13/步,结构上到不了"倒退有代价"。
|
|
156
|
+
# 实证(run110 最后 20 万步,stage=obstacles_dense,10031 episodes):
|
|
157
|
+
# 撞墙全部 n=825 len46.5 R=-144.3;<30 步撞墙 n=400(48.5%) R=-130.1;
|
|
158
|
+
# 走满 300 步超时 n=117 R=-169.6 ⇒ 早死比熬到超时高 44 分;
|
|
159
|
+
# 起点 27~37% 的确定性动作给出 v<0(预览 step_990080:21 步倒 1.9 m 撞墙)。
|
|
160
|
+
# 取值:v_max=1.0 ⇒ 2.5 表示满速倒退 -2.5/步;那集 21 步约 -47 ⇒
|
|
161
|
+
# 总回报 -144.8→约 -192,从此"倒退撞墙"严格劣于"走满超时"。
|
|
162
|
+
# 0.0 = 关闭(默认 = 逐位不变)。只罚前进段倒退 ⇒ 倒车段正确倒车不受影响;
|
|
163
|
+
# "倒车段掉头正着开"仍由 heading_penalty_reverse 负责。
|
|
164
|
+
# 三向一致:本键 / RewardConfig.reverse_motion_penalty /
|
|
165
|
+
# _SRewardParams.reverse_motion_penalty / RewardCalculator 签名默认 / env 侧转发
|
|
166
|
+
# (tests/test_reverse_motion_penalty.py 锁住)。
|
|
167
|
+
reverse_motion_penalty: 2.5
|
|
168
|
+
|
|
169
|
+
obstacle_near_goal_factor: 0.0
|
|
170
|
+
# 上述线性衰减的分母 (m):仅在 factor > 0 时生效;2.0 与 env 侧 near_goal 判定阈值一致。
|
|
171
|
+
obstacle_near_goal_range: 2.0
|
|
172
|
+
|
|
173
|
+
step_penalty: -0.02 # 微小时间税——抑制原地振荡(2026-07-19 恢复)
|
|
174
|
+
# 到达时间奖金乘数 (2026-10-05: 40.0 → 0.0)
|
|
175
|
+
# 为什么关掉:省 40 步 = 时间奖金 40×(40/500)=+3.2 + 时间税 +0.8 +
|
|
176
|
+
# γ=0.995 把 +238 终点奖励提前到账 ≈ +43 ⇒ 抄近道净赚 ≈ +47/回合;
|
|
177
|
+
# 而离开路径 1m 只罚 -3/步 ⇒ 15 步内抄完就净赚。时间红利是
|
|
178
|
+
# "抄近道"的第二个驱动器(第一个是稠密分按步累计,见 reward.py
|
|
179
|
+
# 的失败时刻补偿)。0.0 = 关闭(不再有"越早到越赚")。
|
|
180
|
+
# 注意:goal_proximity 不是原因,它已势能化(整回合上界 4.0),别再动它。
|
|
181
|
+
goal_time_bonus: 0.0 # 到达时间奖金乘数 (0 = 关闭)
|
|
182
|
+
|
|
183
|
+
# 终止事件 — 失败惩罚统一 × stage_scale + 撞墙附加罚 + 超时下限
|
|
184
|
+
# 【2026-10-23 失败经济学】三条一起才成立:
|
|
185
|
+
# collision_terminal = collision_penalty × stage_scale − collision_surcharge
|
|
186
|
+
# timeout_terminal = min(−timeout_min_penalty,
|
|
187
|
+
# timeout_penalty × stage_scale × (1 − arc_completion))
|
|
188
|
+
# ⇒ margin = timeout − collision
|
|
189
|
+
# = 100·s + surcharge + min(−P, −100·s·(1−ac))
|
|
190
|
+
# ≥ min(S, 100·stage_scale_floor + S − P) = min(60, 20+60−30) = 50
|
|
191
|
+
# 与 stage、与进度**无关**地成立。
|
|
192
|
+
# 旧公式下"撞墙严格更贵"只在 stage_scale > 1−ac 时成立(stage0 要 ac>0.8),
|
|
193
|
+
# 于是策略学会了用撞车结束回合(论文实测:策略 180 集只超时 1 次,
|
|
194
|
+
# DWA/MPC/PP/PP+avoid 超时占 25–60%;实测 stage2 撞车 −106.8(62 步) vs
|
|
195
|
+
# 超时 −131.9(300 步) —— 刹车挽回只比撞上去多 25 分)。
|
|
196
|
+
# 只把 timeout 也乘 stage_scale **还不够**:低阶段基项掉到 −20·(1−ac),叠上
|
|
197
|
+
# failure_dense_refund_cap=120 足以让"悬停到超时"的净回报翻正(实测 +1.7)
|
|
198
|
+
# ⇒ 所以再加 timeout_min_penalty 这道下限(失败回合净回报为正 = 历史上每次都是 bug)。
|
|
199
|
+
# stage_scale = clip(stage/3, stage_scale_floor, 1.0),stage 必须由 make_env(stage_index=...) 注入
|
|
200
|
+
# (2026-08-19 B6 修复:此前恒为 -1 → 恒下限,碰撞只罚 -20)
|
|
201
|
+
# stage 0 → 0.2000 → 碰撞 −80.00 超时 −30.00 (任意 ac)
|
|
202
|
+
# stage 1 → 0.3333 → 碰撞 −93.33 超时 −33.33 (ac=0) → −30.00 (ac≥0.10)
|
|
203
|
+
# stage 2 → 0.6667 → 碰撞 −126.67 超时 −66.67 (ac=0) → −30.00 (ac≥0.55)
|
|
204
|
+
# stage 3/4/5 → 1.0000 → 碰撞 −160.00 超时 −100.00 (ac=0) → −30.00 (ac≥0.70)
|
|
205
|
+
# ⚠ stage≥3 且 ac ≤ 0.7 时 timeout 项与旧实现 −100×(1−ac) **逐位相同**;
|
|
206
|
+
# ac > 0.7 被下限抬到 −30(有意为之:否则"走到 90% 再超时"只罚 −10,
|
|
207
|
+
# 抵不过 +120 的失败退款)。
|
|
208
|
+
|
|
209
|
+
# ── stage_scale 的**下限**(失败惩罚随课程放大的起步值,2026-10-23 可配)──
|
|
210
|
+
# 这个 0.2 原先是 envs/reward.py 里的硬编码字面量 np.clip(..., 0.2, 1.0):
|
|
211
|
+
# 不可配、不可见、无法校验。现提为 reward_params 的键,**默认值不变**
|
|
212
|
+
# ⇒ 生产行为逐位不变(stage0 碰撞仍为 -20.0)。
|
|
213
|
+
# 为什么它值得调("早死更便宜"的算术根源,**2026-10-23 之前的口径**):
|
|
214
|
+
# stage0 碰撞基项 = -100×0.2 = -20,而 timeout 基项 -100×(1-ac) **不乘**
|
|
215
|
+
# stage_scale ⇒ 两者天生差 4.75 倍;再叠加 300 步稠密罚(实测约 -242),
|
|
216
|
+
# 实测 run100:collision 均值 -57.2(37 步)vs timeout -302.1(300 步)= 5.28×。
|
|
217
|
+
# 调大下限 = 只抬高**低阶段**的失败代价,不改任何 per-step 稠密分。
|
|
218
|
+
# ⚠ 2026-10-23 起 timeout **也乘 stage_scale**(见上面的失败经济学段):这个旋钮
|
|
219
|
+
# 现在同时缩放 collision 与 timeout 的基项,**不再**能改变两者的相对便宜程度——
|
|
220
|
+
# 排序由 collision_surcharge + timeout_min_penalty 保证(margin ≥ 50,与 floor 无关);
|
|
221
|
+
# floor 只影响"失败有多贵"的绝对量级。
|
|
222
|
+
# 实测(真 RewardCalculator,collision 的 −100×s 部分、不含附加罚与补偿):
|
|
223
|
+
# floor=0.2(默认)→ stage0 -20.0 / stage1 -33.33 / stage2 -66.67 / stage3+ -100.0
|
|
224
|
+
# floor=0.5 → stage0 -50.0 / stage1 -50.00 / stage2 -66.67 / stage3+ -100.0
|
|
225
|
+
# ⇒ floor ≤ 0.6667 时 stage≥3 **完全不受影响**(clip 上界 1.0 恒定),
|
|
226
|
+
# 即主要收敛阶段的标定不会被这个旋钮动到。
|
|
227
|
+
# 约束:0 < stage_scale_floor ≤ 1,非法值在**配置加载期**被 training/config.py 拒掉
|
|
228
|
+
# (tests/test_stage_scale_floor.py 锁住三方一致 + 校验 + 默认行为不变)。
|
|
229
|
+
stage_scale_floor: 0.2
|
|
230
|
+
|
|
231
|
+
collision_penalty: -100.0 # 碰撞惩罚(终端值还要再减 collision_surcharge)
|
|
232
|
+
# ── 撞墙的附加罚(2026-10-23 失败经济学;**不随 stage_scale 缩放**)────────
|
|
233
|
+
# 为什么要一个"不缩放"的项:collision 与 timeout 都乘 stage_scale 之后,ac=0 时
|
|
234
|
+
# 两者相等(−100s vs −100s)⇒ margin 会退化成 0;多加一项常数罚才有严格不等。
|
|
235
|
+
# collision_terminal = collision_penalty × stage_scale − collision_surcharge
|
|
236
|
+
# timeout_terminal = min(−timeout_min_penalty, timeout_penalty·s·(1 − ac))
|
|
237
|
+
# margin = 100·s + surcharge + min(−P, −100·s·(1−ac))
|
|
238
|
+
# ≥ min(S, 100·floor + S − P) = min(60, 50) = 50
|
|
239
|
+
# 实测(真 RewardCalculator 的 done 分支,stage 0–5 × ac 0…1 全扫):
|
|
240
|
+
# surcharge=60 + timeout_min_penalty=30 ⇒ margin ∈ [50.0, 130.0](最小 stage0/ac=0,
|
|
241
|
+
# 最大 stage≥3/ac≥0.9),全表 collision 严格更贵;
|
|
242
|
+
# surcharge=0(只留 timeout 下限)⇒ **stage0 的 margin 变 −10**(撞墙又比超时便宜:
|
|
243
|
+
# −20 vs −30),这就是这个常数罚不能省掉的证据。
|
|
244
|
+
# 60 这个量级的理由:reward_scale=0.15 后 ≈ 9 分的确定性差,远大于 1 步稠密噪声
|
|
245
|
+
# (单步 −0.8 量级);同时"悬停到超时"的最坏净回报 = −30 − C(=60) = −90 < 0。
|
|
246
|
+
# 而不大到压过 goal_bonus(400) 的"做完 vs 撞墙"主导项(−160 vs +400)。
|
|
247
|
+
# 0 = 关掉附加罚(A/B 回滚);< 0 在配置加载期与 RewardCalculator 构造期都被拒。
|
|
248
|
+
# 三向一致:本键 / RewardConfig.collision_surcharge / RewardCalculator 签名默认。
|
|
249
|
+
collision_surcharge: 60.0 # 撞墙附加罚 (2026-10-23 新增,默认 60.0)
|
|
250
|
+
# 到达目标奖励 — 2026-10-05 标定 200 → 400。
|
|
251
|
+
# 实测(同一批真 stage4/5 地图 + oracle、轨迹逐位一致的对照):
|
|
252
|
+
# 改前 goal=200:成功回合均值 +79.2(stage4) / +111.6(stage5)
|
|
253
|
+
# 改后 goal=400:成功回合均值 +311.4 / +343.4
|
|
254
|
+
# 失败回合(含 failure_dense_cap 补偿)两侧都钉在 ≈ -152 / -155
|
|
255
|
+
# ⚠ 2026-10-23 起 failure_dense_refund_cap=120,超过 C+120 的**长**失败不再
|
|
256
|
+
# 钉在 −152/−155(退款被截断,长度依赖部分回归);短失败仍适用。
|
|
257
|
+
# ⇒ "做完 − 撞墙" 的差从 +231/+267 抬到 +463/+498。
|
|
258
|
+
# 400 的量级论证:它必须大于"一次成功回合的全部稠密罚分"(250 步 × ~-0.75/步
|
|
259
|
+
# ≈ -190)加上失败侧上限(-160)才有明显净优势。reward_scale=0.15 后
|
|
260
|
+
# 终点项 = 400×0.15 = 60(target_q 上限 150 仍有 2.4× 余量,见 policy/networks.py)。
|
|
261
|
+
goal_bonus: 400.0 # 到达目标奖励 (2026-10-05: 200 → 400)
|
|
262
|
+
goal_heading_scale: 10.0 # 到达目标时朝向奖励倍数
|
|
263
|
+
stuck_penalty: 0 # 卡住惩罚 (0=禁用 stuck 检测)
|
|
264
|
+
timeout_penalty: -100.0 # 超时惩罚(终端值 = min(−timeout_min_penalty, 本值×s×(1−ac)))
|
|
265
|
+
# ── 超时基项的**下限**(2026-10-23 失败经济学第二轮;必须 > 0)────────────
|
|
266
|
+
# 只把 timeout 也乘 stage_scale 时,低阶段基项会掉到 −20·(1−ac):
|
|
267
|
+
# stage0 悬停 500 步超时 → 基项 ≈ −20,叠上 failure_dense_refund_cap=120 的退款,
|
|
268
|
+
# 实测净回报 **+1.7**(失败回合为正 = 本项目历史上每次都是 bug)。
|
|
269
|
+
# 下限把基项钉在 ≤ −P(默认 −30)⇒ 悬停到超时最坏 −30 − C(60) = −90。
|
|
270
|
+
# 与 collision_surcharge 的分工:S 保证**排序**(撞墙更贵),P 保证**绝对值为负**。
|
|
271
|
+
# 0 或负值在配置加载期与 RewardCalculator 构造期都被拒(0 = 关掉下限)。
|
|
272
|
+
# 三向一致:本键 / RewardConfig.timeout_min_penalty / RewardCalculator 签名默认。
|
|
273
|
+
timeout_min_penalty: 30.0 # 超时基项下限 (2026-10-23 新增,默认 30.0)
|
|
274
|
+
path_deviation_penalty: -100.0 # 路径偏离截断惩罚
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
"""控制器层:`Controller` 协议 + 两个参考控制器(纯追踪 / DWA)。
|
|
2
|
+
|
|
3
|
+
三者共用同一份车型逆映射 `Controller.to_chassis_action`:
|
|
4
|
+
控制器内部按物理 (v, ω) 规划,出口转成该车型的归一化 action。
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
from .base import Controller
|
|
10
|
+
from .dwa import DwaController
|
|
11
|
+
from .pure_pursuit import PurePursuitController
|
|
12
|
+
|
|
13
|
+
__all__ = ["Controller", "DwaController", "PurePursuitController"]
|