Python交通流仿真【含原始碼】

雖然交通并不總是暢通無阻，但汽車無縫穿越交叉路口，在交通信號燈處轉彎和停車看起來相當壯觀，這種沉思讓我思考交通流對人類文明的重要性，

在此之后，內心的書呆子特質讓我忍不住思考一種模擬交通流的方法，我在一個涉及交通流量的本科專案上投入了幾個星期的時間，深入到不同的模擬技術，最終選擇了一個，

在本文中，我將解釋為什么交通流模擬很重要，比較不同的方法來模擬交通流，并呈現仿真結果（以及源代碼），

1、為什么要模擬交通流？

模擬交通流的主要原因是在沒有真實世界的情況下生成資料，你可以使用軟體運行模型來預測交通流，而不需要在現實世界中安裝傳感器來測驗新的管理思路如何影響現實世界，這有助于加速交通流系統的優化和資料收集，仿真是實際測驗更便宜、更快捷的替代方案，

訓練機器學習模型需要巨大的資料集，這些資料集的收集和處理成本可能很高，通過模擬交通流在程式上生成資料可以很容易地適應所需的資料型別，

2、建 模

要分析和優化交通系統，我們首先必須對交通系統進行數學建模，這種模型應根據輸入引數（路網幾何、每分鐘車輛、車速等）真實地表示交通流量，

交通流系統模型通常分為三類，具體取決于它們在哪個級別上運行：

• 微型模型：分別代表每輛車，并嘗試復現駕駛員行為，
• 宏觀模型：從交通密度（每公里車輛）和交通流量（車輛每分鐘）的角度描述車輛的整體移動，它們通常類似于流體的流動，
• 中觀模型：是結合微觀和宏觀模型特點的混合模型，將流量建模為車輛的"包"，
  在本文中，我將使用微觀模型，

3、微觀模型

在微觀模型中使用駕駛員模型描述單個駕駛員/車輛的行為，因此，它必須是一個多代理系統，即每輛車都使用來自其環境的輸入自行運行，

在微觀模型中，每輛車都編號為i，第i輛車跟隨第（i-1）輛車，對于第i輛車，我們將用xi表示其沿路的位置，用vi表示其速度，以及li表示其長度，每輛車都是如此，

我們將用si表示保險杠到保險杠的距離，用Δv? 表示第i輛車和前面的第i-1輛車之間的速度差異，

4、智能駕駛員模型 （IDM）

2000年，Treiber, Hennecke 和 Helbing開發了智能駕駛員模型，它描述第i輛車的加速度是其變數和前面車輛的變數的函式，動態方程的定義為：

在我解釋這個模型背后的直覺之前，我應該先解釋下這些符號代表什么，

我們已經談到了s?, v?, andΔv?，其他引數包括：

• s0i：是第i輛車和第i-1輛車之間的最小期望距離，
• v0i ：是第i輛車的最大期望速度.
• δ：是加速度指數，它控制著加速度的"平滑度"，
• Ti：是第i輛車的駕駛員的反應時間，
• ai ：是第i輛車的最大加速度，
• bi ：是第i輛車的舒適減速度.
• s* ： 是第i輛車和第i-1輛車之間的實際期望距離，

首先，我們將看看s*，這是一個距離，它由三部分組成，

• s0i：如前所言，是所需的最小距離，

• viTi：是反應時間的安全距離，這是車輛在駕駛員反應（剎車）前行駛的距離，由于速度是隨著時間推移而保持的距離，距離是速度乘以時間，
  

• (v? Δv?)/√(2a? b?)：這個有點復雜，這是一個基于速度差的安全距離，它表示車輛在非緊急剎車時（減速度應小于bi），不撞到前面的車輛的前提下所需的距離，

5、智能駕駛員模型的作業原理

車輛假定沿著一條直道行駛，并假定遵守以下方程：

為了更好地了解這個等式，我們可以將其一分為二，我們有一個自由道路加速度和互動加速度，

自由道路加速度是自由道路上的加速，即沒有車輛的空路，如果我們繪制加速度作為速度vi的函式，可以得到：

我們注意到，當車輛靜止（vi=0）時，加速是最大的，當車速接近最高速度時，加速變為 0，這表明，自由道路加速度將加速車輛到最高速度，

如果我們繪制不同值的δ的 v-a 圖，我們會注意到它控制駕駛員在接近最大速度時減速的速度，這反過來又控制了加速度/減速度的平滑度，

互動加速度與與前方車輛的互動有關，為了更好地了解它是如何作業的，讓我們考慮以下情況：

• 在自由路上（si >>s*）：
  當前面的車輛很遠時，即si遠遠大于車輛之間所需的安全距離s*，互動加速度幾乎為0，這意味著車輛將受到自由道路加速的制約，
  

• 在高接近速率（(Δv?）：
  當速度差很大時，互動加速度試圖通過分子中的(v?Δv?)2項進行制動補償，但過于困難，這是通過分母中4b?s?2實作的（老實說，我不知道它如何精確限制減速到b?），
  

• 在小距離差（si <<1和Δv?≈0）：
  加速度成為一個簡單的排斥力，
  

6、交通道路網路模型

我們需要模擬道路網路，為此，我們將使用有向圖 G =（V、E），其中：

• V是一組頂點（或節點），
• E是代表道路的邊的幾何，

每輛車將沿著一條由多個路段（邊）組成的路徑形式，我們將在同一路段（邊）上的車輛應用智能駕駛員模型，當車輛到達路的盡頭時，我們會將其從該路段移開并附加到下一路段上，

在仿真中，我們不會保留一組節點（陣列），相反，每條道路都將由其開始和結束節點的值明確定義，

7、隨機車輛發生器

為了將車輛添加到我們的模擬中，我們有兩個選項：

• 通過創建新的Vehicle類實體并將其添加到車輛串列中，手動將每輛車添加到模擬中，
• 根據預先定義的概率，隨機添加車輛，

對于第二個選項，我們必須定義一個隨機車輛發生器，

隨機車輛發生器由兩個約束定義：

• 車輛生成速率（τ）： 平均每分鐘應添加到仿真中的車輛數，
• 車輛配置串列 （L）：車輛配置和生成概率的元組串列，

L = [（p1，V1），（p2，V2），（p3，V3]），…
隨機車輛發生器以概率pi生成車輛Vi，

8、交通信號燈

紅綠燈位于路段端點上，其特點是包含以下兩個區域：

• 減速區：以減速距離和減速系數為特征，是車輛使用減速系數減速的區域，
  

• 停車區：以停車距離為特征，是車輛停車的區域，這是通過此動態方程使用阻尼力實作的：
  

9、仿真

我們將采用面向物件的方法，每輛車和道路將被定義為一個類，

我們將反復使用以下的__init__函式，它通過一個函式set_default_config設定當前類的默認配置，并將一個字典中的屬性設定為當前類實體的屬性，這樣，我們不必擔心更新不同類別的__init__函式或將來的變化，

def __init__(self, config={}):
  # Set default configuration
  self.set_default_config()

  # Update configuration
  for attr, val in config.items():
      setattr(self, attr, val)

我們將為路段創建一個Road類：

from scipy.spatial import distance

class Road:
    def __init__(self, start, end):
        self.start = start
        self.end = end

        self.init_porperties()

    def init_properties(self):
        self.length = distance.euclidean(self.start, self.end)
        self.angle_sin = (self.end[1]-self.start[1]) / self.length
        self.angle_cos = (self.end[0]-self.start[0]) / self.length

當在螢屏上繪制道路及其角度的正弦和余弦時，我們需要道路的長度length，

還有一個Simulation類，讓我們添加了一些方法來將道路添加到仿真里，

from .road import Road

class Simulation:
    def __init__(self, config={}):
        # Set default configuration
        self.set_default_config()

        # Update configuration
        for attr, val in config.items():
            setattr(self, attr, val)

    def set_default_config(self):
        self.t = 0.0            # Time keeping
        self.frame_count = 0    # Frame count keeping
        self.dt = 1/60          # Simulation time step
        self.roads = []         # Array to store roads

    def create_road(self, start, end):
        road = Road(start, end)
        self.roads.append(road)
        return road

    def create_roads(self, road_list):
        for road in road_list:
            self.create_road(*road)

我們必須在螢屏上實時顯示我們的仿真，為此，我們將使用pygame，我將創建一個Window類，以類Simulation作為引數，

我定義了多個繪圖函式，有助于繪制基本形狀，

該loop方法創建一個pygame視窗，并在每一幀呼叫draw方法和loop引數，當我們的仿真需要逐幀更新時，這將變得有用，

import pygame
from pygame import gfxdraw
import numpy as np

class Window:
    def __init__(self, sim, config={}):
        # Simulation to draw
        self.sim = sim

        # Set default configurations
        self.set_default_config()

        # Update configurations
        for attr, val in config.items():
            setattr(self, attr, val)
        
    def set_default_config(self):
        """Set default configuration"""
        self.width = 1400
        self.height = 1000
        self.bg_color = (250, 250, 250)

        self.fps = 60
        self.zoom = 5
        self.offset = (0, 0)

        self.mouse_last = (0, 0)
        self.mouse_down = False


    def loop(self, loop=None):
        """Shows a window visualizing the simulation and runs the loop function."""
        # Create a pygame window
        self.screen = pygame.display.set_mode((self.width, self.height))
        pygame.display.flip()

        # Fixed fps
        clock = pygame.time.Clock()

        # To draw text
        pygame.font.init()
        self.text_font = pygame.font.SysFont('Lucida Console', 16)

        # Draw loop
        running = True
        while not self.sim.stop_condition(self.sim) and running:
            # Update simulation
            if loop: loop(self.sim)

            # Draw simulation
            self.draw()

            # Update window
            pygame.display.update()
            clock.tick(self.fps)

            # Handle all events
            for event in pygame.event.get():
                # Handle mouse drag and wheel events
                ...


    def convert(self, x, y=None):
        """Converts simulation coordinates to screen coordinates"""
        ...

    def inverse_convert(self, x, y=None):
        """Converts screen coordinates to simulation coordinates"""
        ...


    def background(self, r, g, b):
        """Fills screen with one color."""
        ...
        
    def line(self, start_pos, end_pos, color):
        """Draws a line."""
        ...

    def rect(self, pos, size, color):
        """Draws a rectangle."""
        ...

    def box(self, pos, size, color):
        """Draws a rectangle."""
        ...

    def circle(self, pos, radius, color, filled=True):
        """Draws a circle"""
        ...

    def polygon(self, vertices, color, filled=True):
        """Draws a polygon"""

    def rotated_box(self, pos, size, angle=None, cos=None, sin=None, centered=True, color=(0, 0, 255), filled=True):
        """Draws a filled rectangle centered at *pos* with size *size* rotated anti-clockwise by *angle*."""

    def rotated_rect(self, pos, size, angle=None, cos=None, sin=None, centered=True, color=(0, 0, 255)):
        """Draws a rectangle centered at *pos* with size *size* rotated anti-clockwise by *angle*."""


    def draw_axes(self, color=(100, 100, 100)):
        """Draw x and y axis"""

    def draw_grid(self, unit=50, color=(150,150,150)):
        """Draws a grid"""

    def draw_roads(self):
        """Draws every road"""

    def draw_status(self):
        """Draws status text"""


    def draw(self):
        # Fill background
        self.background(*self.bg_color)

        # Major and minor grid and axes
        self.draw_grid(10, (220,220,220))
        self.draw_grid(100, (200,200,200))
        self.draw_axes()

        # Draw roads
        self.draw_roads()

        # Draw status info
        self.draw_status()

我將trafficSimulator檔案夾中的每一個檔案使用__init__.py組合在一起，

from .road import *
from .simulation import *
from .window import *

每當定義新類時，應在此檔案中匯入該類，

將trafficSimulator檔案夾放置在我們的專案檔案夾中將以便使用仿真模塊，

from trafficSimulator import *

# Create simulation
sim = Simulation()

# Add one road
sim.create_road((300, 98), (0, 98))

# Add multiple roads
sim.create_roads([
    ((300, 98), (0, 98)),
    ((0, 102), (300, 102)),
    ((180, 60), (0, 60)),
    ((220, 55), (180, 60)),
    ((300, 30), (220, 55)),
    ((180, 60), (160, 98)),
    ((158, 130), (300, 130)),
    ((0, 178), (300, 178)),
    ((300, 182), (0, 182)),
    ((160, 102), (155, 180))
    
])

# Start simulation
win = Window(sim)
win.loop()

10、車輛

現在，我們必須增加車輛，

我們將使用Taylor級數來近似求解本文建模部分所討論的動態方程，

一個微分方程f的泰勒級數展開是：

使用▲x替換a，使用x+▲x替換x， 我們得到：

使用位置x替換f：

作為一個近似，對位置我們將在2階截止，因為加速度是最高階導數，我們得到方程（2）：

對于速度，我們將用v代替x：

我們將在1階 停止，因為速度是1階導數，方程（2）：

在每個迭代（或幀）中，使用 IDM 公式計算加速度后，我們將使用以下兩個方程更新位置和速度：

在代碼中看起來像這樣：

self.a = ...      # IDM formula 
self.v += self.a*dt
self.x += self.v*dt + self.a*dt*dt/2

由于這只是一個近似值，速度有時可能會變為負值（但模型不允許這樣），當速度為負時，會產生不穩定性，位置和速度會分化為負無窮大，

為了克服這個問題，每當我們預測負速度時，我們就會將其設定為零，并從那里找出方法：

在代碼中，此實作如下：

if self.v + self.a*dt < 0:
  self.x -= 1/2*self.v*self.v/self.a
  self.v = 0
else:
  self.v += self.a*dt
  self.x += self.v*dt + self.a*dt*dt/2

要計算 IDM 加速度，我們將引導車輛表示為lead，并當lead不是None時，計算一個互動項（用alpha表示），

alpha = 0
if lead:
  delta_x = lead.x - self.x - lead.l
  delta_v = self.v - lead.v
  alpha = (self.s0 + max(0, self.T*self.v + delta_v*self.v/self.sqrt_ab)) / delta_x
self.a = self.a_max * (1-(self.v/self.v_max)**4 - alpha**2)

如果車輛停止（例如在紅綠燈處），我們將使用阻尼方程：

if self.stopped: 
  self.a = -self.b_max*self.v/self.v_max

然后，我們將所有內容整合在Vehicle類的update方法中：

import numpy as np

class Vehicle:
    def __init__(self, config={}):
        # Set default configuration
        self.set_default_config()

        # Update configuration
        for attr, val in config.items():
            setattr(self, attr, val)

        # Calculate properties
        self.init_properties()

    def set_default_config(self):    
        self.l = 4
        self.s0 = 4
        self.T = 1
        self.v_max = 16.6
        self.a_max = 1.44
        self.b_max = 4.61

        self.path = []
        self.current_road_index = 0

        self.x = 0
        self.v = self.v_max
        self.a = 0
        self.stopped = False

    def init_properties(self):
        self.sqrt_ab = 2*np.sqrt(self.a_max*self.b_max)
        self._v_max = self.v_max

    def update(self, lead, dt):
        # Update position and velocity
        if self.v + self.a*dt < 0:
            self.x -= 1/2*self.v*self.v/self.a
            self.v = 0
        else:
            self.v += self.a*dt
            self.x += self.v*dt + self.a*dt*dt/2
        
        # Update acceleration
        alpha = 0
        if lead:
            delta_x = lead.x - self.x - lead.l
            delta_v = self.v - lead.v

            alpha = (self.s0 + max(0, self.T*self.v + delta_v*self.v/self.sqrt_ab)) / delta_x

        self.a = self.a_max * (1-(self.v/self.v_max)**4 - alpha**2)

        if self.stopped: 
            self.a = -self.b_max*self.v/self.v_max
        
    def stop(self):
        self.stopped = True

    def unstop(self):
        self.stopped = False

    def slow(self, v):
        self.v_max = v

    def unslow(self):
        self.v_max = self._v_max

在Road類中，我們將添加一個deque（雙端佇列）來跟蹤車輛，佇列是存盤車輛的較好的資料結構，因為佇列中的第一輛車是路上最遠的車輛，它是第一個可以從佇列中洗掉的車輛，要從deque 中洗掉第一個車輛，我們可以使用self.vehicles.popleft() ，

我們將在Road類中添加一個update方法：

def update(self, dt):
  n = len(self.vehicles)

  if n > 0:
    # Update first vehicle
    self.vehicles[0].update(None, dt)
    # Update other vehicles
    for i in range(1, n):
      lead = self.vehicles[i-1]
      self.vehicles[i].update(lead, dt
在Simulation類中添加一個update方法：

def update(self):
        # Update every road
        for road in self.roads:
            road.update(self.dt)

        # Check roads for out of bounds vehicle
        for road in self.roads:
            # If road has no vehicles, continue
            if len(road.vehicles) == 0: continue
            # If not
            vehicle = road.vehicles[0]
            # If first vehicle is out of road bounds
            if vehicle.x >= road.length:
                # If vehicle has a next road
                if vehicle.current_road_index + 1 < len(vehicle.path):
                    # Update current road to next road
                    vehicle.current_road_index += 1
                    # Create a copy and reset some vehicle properties
                    new_vehicle = deepcopy(vehicle)
                    new_vehicle.x = 0
                    # Add it to the next road
                    next_road_index = vehicle.path[vehicle.current_road_index]
                    self.roads[next_road_index].vehicles.append(new_vehicle)
                # In all cases, remove it from its road
                road.vehicles.popleft() 

回到Window類，添加了一個run方法來實時更新仿真：

def run(self, steps_per_update=1):
  """Runs the simulation by updating in every loop."""
  def loop(sim):
    sim.run(steps_per_update)
  self.loop(loop)

現在我們將手動添加車輛：

sim.roads[4].vehicles.append(
  Vehicle({
    "path": [4, 3, 2]
  })
)

sim.roads[0].vehicles.append(Vehicle())
sim.roads[1].vehicles.append(Vehicle())
sim.roads[6].vehicles.append(Vehicle())
sim.roads[7].vehicles.append(Vehicle())

車輛生成器代碼如下：

from .vehicle import Vehicle
from numpy.random import randint

class VehicleGenerator:
    def __init__(self, sim, config={}):
        ...

    def set_default_config(self):
        self.vehicle_rate = 20
        self.vehicles = [
            (1, {})
        ]

    def init_properties(self):
        self.upcoming_vehicle = self.generate_vehicle()

    def generate_vehicle(self):
        """Returns a random vehicle from self.vehicles with random proportions"""
        ...

    def update(self):
        """Add vehicles"""
        ...

VehicleGenerator包含(odds, vehicle) 元組的串列，

元組第一個元素是在同一元組中生成車輛的權重（不是概率），我使用權重， 因為它們更容易作業， 因為我們可以只使用整數，

例如，如果我們有3輛車權重分別為132，這相當于生成概率分別為1/6 ， 3/6 ，2/66 ，

為了實作這一點，我們使用以下演算法

• 生成1到權重和之間的數字r，
• 當r是非負數：回圈所有可能的車輛，并在每次迭代時減去其權重，
• 回傳最后使用的車輛，

如果我們有權重：W1，W2，W3， 此演算法將在1和W 3之間的數字分配到第一輛車，將W? 到 W?+W? 之間的數字分配給第二輛車，將W?+W?+W?到結束的數字分配給第三輛車，

def generate_vehicle(self):
  """Returns a random vehicle from self.vehicles with random proportions"""
  total = sum(pair[0] for pair in self.vehicles)
  r = randint(1, total+1)
  for (weight, config) in self.vehicles:
    r -= weight
    if r <= 0:
      return Vehicle(config)

每次生成器添加車輛時，last_added_time屬性都會更新到當前時間，當當前時間和last_added_time之差值大于車輛生成周期時，添加車輛，

添加車輛的周期是60/vehicle_rate，因為vehicle_rate 的單位是車輛/每分鐘，60表示1分鐘或60秒，

我們還必須檢查道路是否還有空間來添加即將行駛的車輛，我們通過檢查道路上最后一輛車之間的距離和即將行駛的車輛的長度和安全距離的總和來做到這一點，

def update(self):
    """Add vehicles"""
    if self.sim.t - self.last_added_time >= 60 / self.vehicle_rate:
        # If time elasped after last added vehicle is
        # greater than vehicle_period; generate a vehicle
        road = self.sim.roads[self.upcoming_vehicle.path[0]]      
        if len(road.vehicles) == 0\
           or road.vehicles[-1].x > self.upcoming_vehicle.s0 + self.upcoming_vehicle.l:
            # If there is space for the generated vehicle; add it
            self.upcoming_vehicle.time_added = self.sim.t
            road.vehicles.append(self.upcoming_vehicle)
            # Reset last_added_time and upcoming_vehicle
            self.last_added_time = self.sim.t
        self.upcoming_vehicle = self.generate_vehicle()

最后，我們應該通過呼叫Simulation 的update方法來更新車輛生成，

sim.create_gen({
    'vehicle_rate': 60,
    'vehicles': [
        [1, {"path": [4, 3, 2]}],
        [1, {"path": [0]}],
        [1, {"path": [1]}],
        [1, {"path": [6]}],
        [1, {"path": [7]}]
    ]
})

11、紅綠燈

交通信號燈的默認屬性是：

class TrafficSignal:
    def __init__(self, roads, config={}):
        # Initialize roads
        self.roads = roads
        # Set default configuration
        self.set_default_config()
        # Update configuration
        for attr, val in config.items():
            setattr(self, attr, val)
        # Calculate properties
        self.init_properties()

    def set_default_config(self):
        self.cycle = [(False, True), (True, False)]
        self.slow_distance = 40
        self.slow_factor = 10
        self.stop_distance = 15

        self.current_cycle_index = 0
        self.last_t = 0

self.cycle是self.roads 的一個陣列，每個元組包含道路的狀態（True綠色，False紅色），

在默認配置中，(False, True)表示第一組道路為紅色，第二組道路為綠色， (True, False) 則恰恰相反，

所以使用此方法之，是因為它易于擴展，我們創建紅綠燈，包括超過 2 條道路、帶有左右轉彎單獨信號的紅綠燈，甚至用于多個交叉路口的同步交通信號燈，

交通信號燈的update函式應該是可定制的，其默認行為是對稱的固定時間回圈，

def init_properties(self):
    for i in range(len(self.roads)):
        for road in self.roads[i]:
            road.set_traffic_signal(self, i)

@property
def current_cycle(self):
    return self.cycle[self.current_cycle_index]

def update(self, sim):
    # Goes through all cycles every cycle_length and repeats
    cycle_length = 30
	k = (sim.t // cycle_length) % 2
	self.current_cycle_index = int(k)

我們需要在Road類添加以下方法：

def set_traffic_signal(self, signal, group):
    self.traffic_signal = signal
    self.traffic_signal_group = group
    self.has_traffic_signal = True

@property
def traffic_signal_state(self):
    if self.has_traffic_signal:
        i = self.traffic_signal_group
        return self.traffic_signal.current_cycle[i]
    return True

而這個，在Road的update方法，

# Check for traffic signal
if self.traffic_signal_state:
    # If traffic signal is green or doesn't exist
    # Then let vehicles pass
    self.vehicles[0].unstop()
    for vehicle in self.vehicles:
        vehicle.unslow()
else:
    # If traffic signal is red
    if self.vehicles[0].x >= self.length - self.traffic_signal.slow_distance:
        # Slow vehicles in slowing zone
        self.vehicles[0].slow(self.traffic_signal.slow_speed)
    if self.vehicles[0].x >= self.length - self.traffic_signal.stop_distance and\
       self.vehicles[0].x <= self.length - self.traffic_signal.stop_distance / 2:
        # Stop vehicles in the stop zone
        self.vehicles[0].stop()

在Simulation 的update 方法中檢查交通燈狀態：

for signal in self.traffic_signals:
  signal.update(self)

12、曲線

在現實世界中，道路有曲線，雖然從技術上講，我們可以通過手寫很多道路的坐標來接近曲線來創建此模擬中的曲線，但我們可以在程式上實作同樣的事情，

我們將使用貝賽爾曲線來達到這個效果，

我創建了一個curve.py檔案，其中包含有助于創建曲線并按其道路序號參考曲線的功能，

def curve_points(start, end, control, resolution=5):
	# If curve is a straight line
	if (start[0] - end[0])*(start[1] - end[1]) == 0:
		return [start, end]

	# If not return a curve
	path = []

	for i in range(resolution+1):
		t = i/resolution
		x = (1-t)**2 * start[0] + 2*(1-t)*t * control[0] + t**2 *end[0]
		y = (1-t)**2 * start[1] + 2*(1-t)*t * control[1] + t**2 *end[1]
		path.append((x, y))

	return path

def curve_road(start, end, turn_direction, resolution=15):
	points = curve_points(start, end, turn_direction, resolution)
	return [(points[i-1], points[i]) for i in range(1, len(points))]

測驗：

from trafficSimulator import *

# Create simulation
sim = Simulation()

# Add multiple roads
sim.create_roads([
    ((0, 100), (140, 100)),
    ((150, 110), (150, 200)),

    *curve_road((140, 100), (150, 110), (150, 100))
])

sim.create_gen({
    'vehicle_rate': 20,
    'vehicles': [
        [1, {"path": [0, *range(2, 17), 1]}]
    ]
})

# Start simulation
win = Window(sim)
win.run(steps_per_update=5)

13、示例

這些示例的代碼可在 Github 中找到，

公路匝道入口

雙向交叉路口

環形交叉路口

鉆石型分流交叉路口

14、局限性

雖然我們可以修改Simulation類來存盤有關我們以后可以使用的模擬資料，但如果資料收集程序更加簡化，則更好，

這種模擬仍然缺乏很多，曲線的實作是糟糕和低效的，并導致車輛和交通信號之間的相互作用的問題，

雖然有些人可能認為智能驅動模型有點過頭了，但重要的是要有一個模型，可以復制現實世界的現象，如交通波（又名幽靈交通蛇）和司機的反應時間的影響，因此，我選擇使用智能驅動模型，但對于精度和極端現實主義不重要的仿真，就像在視頻游戲中一樣，IDM可以被一個更簡單的基于邏輯的模型所取代，

完全依賴基于仿真的資料會增加過度擬合的風險，你的 ML 模型可以優化用于僅存在于仿真中的處理，并且在現實世界中不存在，

15、結論

仿真是資料科學和機器學習的重要組成部分，有時，從現實世界中收集資料是不可能的，或者成本很高，生成資料有助于以更好的價格構建巨大的資料集，仿真還有助于填補真實資料中的空白，在某些情況下，現實世界資料集缺少對開發模型至關重要的邊緣案例，

這個仿真是我參與的本科學校專案的一部分，目的是優化城市交叉路口的交通信號，我制作了此仿真來測驗和驗證我的優化方法，

我從來沒有想過發表這篇文章，直到我看到特斯拉的AI展示日，其中他們談到他們如何使用仿真來生成資料的邊緣樣本，

原文鏈接：Python交通流仿真 - BimAnt