Spaces:
Sleeping
Sleeping
File size: 13,864 Bytes
e039c53 53b11d4 e039c53 | 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 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 | import os
import json
import time
from datetime import datetime
from typing import Dict, List, Any, Optional
import config
from main import VehicleSimulator
from protocol.vda_2_0_0.vda5050_2_0_0_order import Order
from protocol.vda_2_0_0.vda5050_2_0_0_state import ActionStatus
from models.base_adapter import BaseModelAdapter
from benchmark.metrics import ScenarioMetrics
from benchmark.evaluator import ScenarioEvaluator
from benchmark.packet_logger import PacketLogger
class BenchmarkRunner:
"""Điều phối và chạy thử nghiệm Benchmark cho 1 Scenario"""
def __init__(self, model_adapter: BaseModelAdapter, output_base_dir: str = "results"):
self.model_adapter = model_adapter
self.output_base_dir = output_base_dir
def run_scenario(self, scenario_path: str) -> ScenarioMetrics:
# 1. Load kịch bản và sơ đồ nhà máy
with open(scenario_path, "r", encoding="utf-8") as f:
scenario = json.load(f)
layout_name = scenario.get("factory_layout")
layout_path = f"factory_layouts/{layout_name}.json"
with open(layout_path, "r", encoding="utf-8") as f:
layout = json.load(f)
scenario_id = scenario["scenario_id"]
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
model_name = getattr(self.model_adapter, "model_name", "unknown_model")
# Thay thế ký tự đặc biệt (/, :) để hợp lệ trên hệ thống tập tin Windows
safe_model_name = model_name.replace("/", "_").replace(":", "_")
# Thư mục lưu kết quả của lần test này
run_dir = os.path.join(self.output_base_dir, f"{safe_model_name}_{timestamp}_{scenario_id}")
logger = PacketLogger(run_dir)
logger.log_event("scenario_loaded", "INPUT", scenario)
logger.log_event("layout_loaded", "INPUT", layout)
# 2. Xây dựng thông tin đầu vào gửi cho AI Model
agv_states = []
for agv_info in scenario.get("agvs", []):
agv_states.append({
"serial_number": agv_info["serial_number"],
"position": agv_info["initial_position"],
"battery_charge": agv_info["battery_charge"],
"speed": agv_info["speed"],
"capabilities": agv_info.get("capabilities", [])
})
logger.log_event("model_request_sent", "INPUT", {
"agv_states": agv_states,
"transport_requests": scenario["transport_requests"]
})
# 3. Gọi model để sinh chỉ thị di chuyển (VDA5050 Orders)
print(f"Calling model '{model_name}' for scenario '{scenario_id}'...")
response = self.model_adapter.generate_orders(
factory_layout=layout,
agv_states=agv_states,
transport_requests=scenario["transport_requests"],
constraints=scenario.get("constraints", {})
)
logger.log_event("model_response_received", "OUTPUT", {
"status": response.status,
"latency_ms": response.latency_ms,
"orders": response.orders,
"error_message": response.error_message
})
# Khởi tạo metrics
metrics = ScenarioMetrics(
scenario_id=scenario_id,
model_latency_ms=response.latency_ms,
total_requests=len(scenario["transport_requests"]),
raw_response=response.raw_response
)
if response.status != "SUCCESS":
metrics.success = False
metrics.failure_reason = "invalid_json" if "JSON" in str(response.error_message) else "api_error"
self._save_summary(run_dir, metrics)
logger.close()
return metrics
# 4. Khởi tạo Simulator cho từng AGV
simulators: Dict[str, VehicleSimulator] = {}
base_config = config.get_config()
for agv_info in scenario.get("agvs", []):
serial = agv_info["serial_number"]
# Tạo config riêng cho từng AGV
agv_cfg = config.Config(
mqtt_broker=base_config.mqtt_broker,
vehicle=config.VehicleConfig(
manufacturer=base_config.vehicle.manufacturer,
serial_number=serial,
vda_version=base_config.vehicle.vda_version,
vda_full_version=base_config.vehicle.vda_full_version
),
settings=config.Settings(
action_time=scenario.get("constraints", {}).get("action_time", 2.0),
speed=agv_info["speed"],
robot_count=1,
state_frequency=1,
visualization_frequency=1,
map_id=layout["map_id"]
)
)
sim = VehicleSimulator(agv_cfg)
# Thiết lập vị trí và pin ban đầu theo kịch bản
sim.state.agv_position.x = agv_info["initial_position"]["x"]
sim.state.agv_position.y = agv_info["initial_position"]["y"]
sim.state.battery_state.battery_charge = agv_info["battery_charge"]
simulators[serial] = sim
metrics.initial_battery[serial] = agv_info["battery_charge"]
# 5. Bơm Orders nhận được từ model vào simulator
orders_received = response.orders
for serial, order_data in orders_received.items():
if serial in simulators:
try:
# Điền thông tin header/metadata còn thiếu vào order_data trước khi parse
sim = simulators[serial]
order_data["headerId"] = order_data.get("headerId", 0)
order_data["timestamp"] = order_data.get("timestamp", sim.state.timestamp)
order_data["version"] = order_data.get("version", sim.config.vehicle.vda_full_version)
order_data["manufacturer"] = order_data.get("manufacturer", sim.config.vehicle.manufacturer)
order_data["serialNumber"] = order_data.get("serialNumber", serial)
# Chuyển đổi dữ liệu JSON thành object VDA5050 Order
parsed_order = Order.from_dict(order_data)
simulators[serial].order_accept_procedure(parsed_order)
logger.log_event("order_injected", "INTERNAL", {"agv": serial, "order_id": parsed_order.order_id})
except Exception as e:
print(f"Error parsing order for {serial}: {e}")
metrics.success = False
metrics.failure_reason = "invalid_order"
self._save_summary(run_dir, metrics)
logger.close()
return metrics
# Trạng thái theo dõi sự kiện cho trực quan hóa
last_nodes = {serial: sim.state.last_node_sequence_id for serial, sim in simulators.items()}
action_statuses = {
serial: {a.action_id: a.action_status for a in sim.state.action_states}
for serial, sim in simulators.items()
}
# 6. Vòng lặp giả lập (Simulation Tick Loop)
# Mỗi tick đại diện cho 50ms (0.05 giây)
tick_time = 0.05
max_time = scenario.get("constraints", {}).get("max_time_seconds", 120)
max_ticks = int(max_time / tick_time)
sim_success = False
failure_reason = None
print("Starting in-memory simulation run...")
for tick in range(1, max_ticks + 1):
elapsed_time = tick * tick_time
metrics.simulation_time_seconds = elapsed_time
# Chạy iterate cho từng AGV
for serial, sim in simulators.items():
sim.state_iterate()
# Kiểm tra xem xe có đến trạm mới không
if sim.state.last_node_sequence_id != last_nodes[serial]:
last_nodes[serial] = sim.state.last_node_sequence_id
logger.log_event("agv_arrived_node", "EVENT", {
"agv": serial,
"node_id": sim.state.last_node_id,
"sequence_id": sim.state.last_node_sequence_id
}, elapsed_time=elapsed_time)
# Kiểm tra trạng thái Action thay đổi
for a in sim.state.action_states:
old_status = action_statuses[serial].get(a.action_id, ActionStatus.WAITING)
if a.action_status != old_status:
action_statuses[serial][a.action_id] = a.action_status
logger.log_event("agv_action_update", "EVENT", {
"agv": serial,
"action_id": a.action_id,
"action_type": a.action_type,
"status": a.action_status.value
}, elapsed_time=elapsed_time)
# Thu thập vị trí để kiểm tra va chạm
agv_positions = {s: (sim.state.agv_position.x, sim.state.agv_position.y) for s, sim in simulators.items()}
# Ghi log trạng thái mỗi tick giả lập để vẽ hình mượt mà
states_log = {s: sim.state.to_dict() for s, sim in simulators.items()}
logger.log_event("sim_tick_state", "INTERNAL", states_log, elapsed_time=elapsed_time)
# A. Kiểm tra hết pin
battery_dead = False
for serial, sim in simulators.items():
if sim.state.battery_state.battery_charge <= 0:
battery_dead = True
failure_reason = "battery_dead"
break
if battery_dead:
break
# B. Kiểm tra va chạm giữa các xe
agv_collisions = ScenarioEvaluator.check_collision_agv_vs_agv(agv_positions)
if agv_collisions:
metrics.collision_count += len(agv_collisions)
failure_reason = "collision"
logger.log_event("collision_detected", "EVENT", {"collisions": agv_collisions}, elapsed_time=elapsed_time)
break
# C. Kiểm tra va chạm vật cản
obstacle_collisions = ScenarioEvaluator.check_collision_with_obstacles(agv_positions, layout.get("obstacles", []))
if obstacle_collisions:
metrics.collision_count += len(obstacle_collisions)
failure_reason = "collision"
logger.log_event("collision_with_obstacle_detected", "EVENT", {"collisions": obstacle_collisions}, elapsed_time=elapsed_time)
break
# E. Kiểm tra xâm nhập vùng hạn chế di chuyển (Restricted Zone)
no_restricted = scenario.get("success_criteria", {}).get("no_restricted_zone_violation", False)
if no_restricted:
restricted_violations = ScenarioEvaluator.check_restricted_zone_violation(agv_positions, layout.get("zones", []))
if restricted_violations:
failure_reason = "restricted_zone_violation"
logger.log_event("restricted_zone_violation_detected", "EVENT", {"violations": restricted_violations}, elapsed_time=elapsed_time)
break
# D. Kiểm tra hoàn thành tất cả nhiệm vụ
# Một kịch bản coi như hoàn thành khi tất cả các simulator hoàn thành đơn hàng
# (không còn node_states hoặc chỉ còn node cuối cùng và không có action nào chưa hoàn thành)
all_done = True
for serial, sim in simulators.items():
if sim.state.node_states:
last_node_seq = max(node.sequence_id for node in sim.state.node_states)
reached_last_node = sim.state.last_node_sequence_id >= last_node_seq
else:
reached_last_node = True
has_pending_actions = any(a.action_status != ActionStatus.FINISHED for a in sim.state.action_states)
if not reached_last_node or has_pending_actions:
all_done = False
break
if all_done:
sim_success = True
break
# Sleep to let real-world time progress for action timers
time.sleep(tick_time)
# Xác định kết quả cuối cùng
for serial, sim in simulators.items():
metrics.final_battery[serial] = sim.state.battery_state.battery_charge
if sim_success:
metrics.success = True
metrics.completed_requests = metrics.total_requests
print(f"Scenario completed successfully in {metrics.simulation_time_seconds:.2f} seconds!")
else:
metrics.success = False
metrics.failure_reason = failure_reason if failure_reason else "timeout"
print(f"Scenario failed! Reason: {metrics.failure_reason}")
# Ghi nhận log cuối cùng
logger.log_event("simulation_finished", "OUTPUT", metrics.to_dict(), elapsed_time=metrics.simulation_time_seconds)
self._save_summary(run_dir, metrics)
logger.close()
return metrics
def _save_summary(self, run_dir: str, metrics: ScenarioMetrics):
"""Lưu file tóm tắt kết quả kiểm tra"""
os.makedirs(run_dir, exist_ok=True)
summary_path = os.path.join(run_dir, "benchmark_report.json")
with open(summary_path, "w", encoding="utf-8") as f:
json.dump(metrics.to_dict(), f, indent=4, ensure_ascii=False)
|