人工智能实际应用-更复杂的应用案例-CSDN博客

以下是一个更为复杂的模拟人工智能交通管理的代码示例，考虑了不同类型的车辆、实时交通数据采集以及更复杂的信号灯控制算法。

整体思路

此代码构建了一个包含多个路段和十字路口的交通网络模型。不同类型的车辆（如汽车、公交车、自行车）会以不同的速度和通行优先级在路段上行驶。实时交通数据会不断采集，包括每个路段的车辆数量和等待时间。信号灯控制算法会根据这些实时数据，通过加权计算各方向的交通压力来动态调整信号灯时长。

代码实现

import random
import time

# 定义车辆类型及其属性
VEHICLE_TYPES = {
    "car": {"speed": 3, "priority": 1},
    "bus": {"speed": 2, "priority": 2},
    "bike": {"speed": 1, "priority": 1}
}

# 定义交通灯状态
class TrafficLight:
    def __init__(self, name, initial_state="red", initial_duration=10):
        self.name = name
        self.state = initial_state
        self.duration = initial_duration

    def change_state(self, new_state, new_duration):
        self.state = new_state
        self.duration = new_duration
        print(f"{self.name} 交通灯变为 {self.state}，持续 {self.duration} 个时间单位")

    def decrement_duration(self):
        if self.duration > 0:
            self.duration -= 1
        if self.duration == 0:
            if self.state == "green":
                self.change_state("yellow", 2)
            elif self.state == "yellow":
                self.change_state("red", 0)

# 定义车道和车辆队列
class Lane:
    def __init__(self, name):
        self.name = name
        self.vehicles = []

    def add_vehicle(self):
        vehicle_type = random.choice(list(VEHICLE_TYPES.keys()))
        if random.random() < 0.3:  # 30% 的概率有新车加入
            self.vehicles.append(vehicle_type)
            print(f"{self.name} 车道新增一辆 {vehicle_type}，当前车辆数: {len(self.vehicles)}")

    def remove_vehicle(self):
        if self.vehicles:
            vehicle = self.vehicles.pop(0)
            print(f"{self.name} 车道一辆 {vehicle} 通过，当前车辆数: {len(self.vehicles)}")

# 定义路段
class RoadSegment:
    def __init__(self, name, length):
        self.name = name
        self.length = length
        self.lanes = [Lane(f"{name}_lane_{i}") for i in range(2)]  # 每条路段有两条车道
        self.waiting_time = 0

    def update(self):
        for lane in self.lanes:
            lane.add_vehicle()
        self.waiting_time = sum([len(lane.vehicles) for lane in self.lanes])

# 定义十字路口
class Intersection:
    def __init__(self, name):
        self.name = name
        # 初始化四个方向的交通灯
        self.north_south_light = TrafficLight(f"{name} 南北方向")
        self.east_west_light = TrafficLight(f"{name} 东西方向", initial_state="green")
        # 初始化四个方向的路段
        self.north_road = RoadSegment(f"{name} 北路段", 10)
        self.south_road = RoadSegment(f"{name} 南路段", 10)
        self.east_road = RoadSegment(f"{name} 东路段", 10)
        self.west_road = RoadSegment(f"{name} 西路段", 10)
        self.time_step = 0

    def collect_traffic_data(self):
        self.north_road.update()
        self.south_road.update()
        self.east_road.update()
        self.west_road.update()

    def calculate_traffic_pressure(self, road1, road2):
        total_vehicles = sum([len(lane.vehicles) for lane in road1.lanes + road2.lanes])
        total_waiting_time = road1.waiting_time + road2.waiting_time
        # 考虑不同车辆类型的优先级
        priority_sum = 0
        for road in [road1, road2]:
            for lane in road.lanes:
                for vehicle in lane.vehicles:
                    priority_sum += VEHICLE_TYPES[vehicle]["priority"]
        return total_vehicles + total_waiting_time + priority_sum

    def adjust_traffic_lights(self):
        north_south_pressure = self.calculate_traffic_pressure(self.north_road, self.south_road)
        east_west_pressure = self.calculate_traffic_pressure(self.east_road, self.west_road)

        if self.north_south_light.state == "green":
            if east_west_pressure > north_south_pressure and self.north_south_light.duration > 5:
                self.north_south_light.change_state("yellow", 2)
                self.east_west_light.change_state("green", max(5, int(east_west_pressure / 2)))
        elif self.east_west_light.state == "green":
            if north_south_pressure > east_west_pressure and self.east_west_light.duration > 5:
                self.east_west_light.change_state("yellow", 2)
                self.north_south_light.change_state("green", max(5, int(north_south_pressure / 2)))

    def update_traffic(self):
        self.time_step += 1
        print(f"\n时间步: {self.time_step}")

        # 采集实时交通数据
        self.collect_traffic_data()

        # 根据交通灯状态和车辆数量调整交通灯
        if self.north_south_light.state == "green":
            for lane in self.north_road.lanes + self.south_road.lanes:
                for _ in range(VEHICLE_TYPES["car"]["speed"]):
                    lane.remove_vehicle()
        elif self.east_west_light.state == "green":
            for lane in self.east_road.lanes + self.west_road.lanes:
                for _ in range(VEHICLE_TYPES["car"]["speed"]):
                    lane.remove_vehicle()

        # 调整信号灯
        self.adjust_traffic_lights()

        # 减少交通灯剩余时长
        self.north_south_light.decrement_duration()
        self.east_west_light.decrement_duration()

# 主程序
if __name__ == "__main__":
    intersection = Intersection("主十字路口")
    for _ in range(30):  # 模拟 30 个时间步
        intersection.update_traffic()
        time.sleep(0.5)  # 为了便于观察，每个时间步间隔 0.5 秒

代码解释

车辆类型定义：VEHICLE_TYPES 字典定义了不同类型车辆（汽车、公交车、自行车）的速度和通行优先级。
TrafficLight 类：与之前示例类似，负责管理交通灯的状态和剩余时长。
Lane 类：表示车道，可随机添加不同类型的车辆，并在绿灯时允许车辆通过。
RoadSegment 类：表示路段，包含多条车道，可更新车道上的车辆情况并计算该路段的等待时间。
Intersection 类：
- collect_traffic_data 方法：采集四个方向路段的实时交通数据。
- calculate_traffic_pressure 方法：通过考虑车辆数量、等待时间和车辆优先级，计算某个方向的交通压力。
- adjust_traffic_lights 方法：根据计算得到的交通压力动态调整信号灯时长。
- update_traffic 方法：在每个时间步更新交通情况，包括车辆移动、数据采集和信号灯调整。