AGV_simulator / benchmark /runner.py
Ducdata1808's picture
feat: enforce no_restricted_zone_violation check in backend and update scenario_013 metrics
53b11d4
Raw History Blame Contribute Delete
13.9 kB
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)