Spaces:
Sleeping
Sleeping
Download benchmark/runner.py from Ducdata1808/AGV_simulator: direct link, hf CLI and curl.
- Browser
- Download file 13.9 kB
-
https://huggingface.co/spaces/Ducdata1808/AGV_simulator/resolve/main/benchmark/runner.py
- Command line
-
hf download hf://spaces/Ducdata1808/AGV_simulator/benchmark/runner.py
-
curl -L -o runner.py https://huggingface.co/spaces/Ducdata1808/AGV_simulator/resolve/main/benchmark/runner.py
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) | |