从零构建社会力模型：用Python模拟真实人群动态的工程实践

你是否曾站在繁忙的地铁站，观察过人群如何像流体一样涌动、分流、避让？这种看似无序却又遵循着某种内在规律的运动，背后隐藏着深刻的物理与社会学原理。对于算法工程师、游戏开发者或城市规划研究者而言，将这种复杂的人群动态在计算机中复现出来，不仅是一项迷人的技术挑战，更是解决现实问题的关键。社会力模型（Social Force Model, SFM）为我们提供了一套优雅的数学框架，将行人的心理动机转化为可计算的“力”，从而驱动虚拟个体在环境中做出逼真的决策。

本文不是一篇理论综述，而是一份面向实践者的工程指南。我们将彻底抛开繁琐的公式推导，聚焦于如何用Python和NumPy/PyTorch，从零开始搭建一个高效、可扩展的社会力模型仿真引擎。你将获得一套可直接运行、高度模块化的代码，并掌握关键的参数调优技巧，让你能快速地将学术模型转化为解决实际项目（如人群模拟、智能体行为测试、异常检测特征生成）的利器。无论你是想为游戏注入更真实的NPC行为，还是为安防分析构建人群动态基线模型，这里都有你需要的“干货”。

1. 工程化视角下的社会力模型核心

在开始敲代码之前，我们需要将经典的社会力模型“翻译”成工程师更容易理解和操作的语言。模型的核心思想很简单：每个行人的运动状态变化，是由几种虚拟的“力”共同作用的结果。我们的任务就是精确计算并合成这些力。

1.1 力的分解与物理意义

想象你正在走向一个咖啡店（你的目标）。你的内心驱动（期望力）推着你向前；当你靠近另一个行人时，你会不自觉地调整路径，保持一个舒适的社交距离（人与人之间的排斥力）；同时，你也会避开墙壁和障碍物（人与环境的排斥力）。社会力模型正是量化了这些直觉。

在工程实现上，我们主要关注三种核心作用力：

1. 驱动力 (Driving Force)：这是行人内在的动机，使其以期望的速度朝向目标点移动。它本质上是一个指向目标方向的加速度。
2. 人际排斥力 (Interpersonal Repulsive Force)：保证个体之间保持一定的私人空间。当两人距离过近时，此力会迅速增大，迫使彼此远离。
3. 环境排斥力 (Environmental Repulsive Force)：防止行人穿过墙壁、栅栏等静态障碍物。其计算方式与人际排斥力类似，但作用对象是环境边界。

提示：在实际编码中，我们通常将“吸引力”（如朋友间的聚集）视为一种可选的、特殊配置的力，并非基础模型的必需部分。初期实现可专注于上述三种力，以保持系统稳定。

1.2 从公式到代码：关键参数映射

理论论文中的公式往往包含许多希腊字母和抽象符号。为了编程，我们必须将其转化为具体的变量和参数。下表列出了最核心的几个参数及其物理意义和典型取值范围，这是调优的基石：

参数符号	参数名（代码变量）	物理意义	典型值/范围	影响
τ	tau	松弛时间常数	0.5 s	控制个体调整到期望速度的快慢。值越小，反应越敏捷，但也可能更“抖动”。
v_des	desired_speed	期望速度大小	1.0 ~ 1.5 m/s	行人在无干扰情况下希望达到的速度。影响整体人群流动速率。
A	A_inter	人际排斥力强度	2000 N	控制人与人之间排斥力的最大强度。值过大会导致人群过度分散。
B	B_inter	人际排斥力作用范围	0.08 m	定义排斥力开始显著作用的距离。影响私人空间的大小。
A_wall	A_wall	环境排斥力强度	2000 N	控制人与墙壁/障碍物之间排斥力的强度。
B_wall	B_wall	环境排斥力作用范围	0.08 m	定义人与障碍物间的最小容许距离。
body_radius	radius	个体物理半径	0.2 ~ 0.3 m	用于碰撞检测的刚体半径，也影响力的计算位置（从中心算起）。

理解这些参数是调优的第一步。例如，在模拟恐慌场景时，你可能会显著提高 desired_speed，同时适当降低 tau，以模拟急促、反应过度的行为。

2. 搭建高效的社会力模型计算引擎

理论清晰后，我们进入实战环节。我们将采用面向对象的设计，构建一个高度模块化的仿真系统。这里选择 NumPy 作为核心计算库，因为它能提供高效的向量化运算，非常适合处理成百上千个行人的状态更新。

2.1 定义行人个体类

首先，我们定义每个行人的基本属性和状态。这个类将存储其位置、速度、目标点以及个人参数。

import numpy as np

class Pedestrian:
    def __init__(self, pid, position, desired_speed=1.34, tau=0.5, radius=0.25):
        """
        初始化一个行人个体。
        
        参数:
            pid: 个体唯一ID
            position: 初始位置，形如 [x, y] 的numpy数组
            desired_speed: 期望速度大小 (m/s)
            tau: 松弛时间常数 (s)
            radius: 个体半径 (m)，用于碰撞和力计算
        """
        self.id = pid
        self.position = np.array(position, dtype=np.float64)
        self.velocity = np.zeros(2, dtype=np.float64)  # 当前速度 [vx, vy]
        self.desired_speed = desired_speed
        self.tau = tau
        self.radius = radius
        
        # 目标相关
        self.target = None  # 当前目标点 [x, y]
        self.waypoints = [] # 路径点列表
        self.current_waypoint_idx = 0
        
    def set_target(self, target_position):
        """设置当前目标点。"""
        self.target = np.array(target_position, dtype=np.float64)
    
    def set_waypoints(self, points):
        """设置一系列路径点，行人将依次前往。"""
        self.waypoints = [np.array(p, dtype=np.float64) for p in points]
        self.current_waypoint_idx = 0
        if self.waypoints:
            self.target = self.waypoints[0]
    
    def update_target_from_waypoints(self):
        """如果到达当前路径点，则切换到下一个。"""
        if self.target is not None and self.waypoints:
            dist_to_target = np.linalg.norm(self.position - self.target)
            if dist_to_target < 0.5:  # 到达阈值，可调整
                self.current_waypoint_idx += 1
                if self.current_waypoint_idx < len(self.waypoints):
                    self.target = self.waypoints[self.current_waypoint_idx]
                else:
                    self.target = None  # 到达终点

2.2 实现核心作用力计算

力的计算是整个模型的心脏。我们将每种力实现为独立的函数或类方法，确保代码清晰且易于调试。

驱动力计算：这是最直接的一个力，方向指向目标，大小与当前速度和期望速度的差值成正比。

def compute_driving_force(ped, dt):
    """
    计算行人的驱动力。
    
    参数:
        ped: Pedestrian 对象
        dt: 仿真时间步长 (s)，用于平滑方向更新（可选）
    
    返回:
        force: 驱动力向量 [fx, fy]
    """
    if ped.target is None:
        return np.zeros(2)
    
    # 计算指向目标的方向向量
    direction_to_target = ped.target - ped.position
    distance = np.linalg.norm(direction_to_target)
    
    # 防止除零，并归一化方向
    if distance < 1e-5:
        desired_direction = np.zeros(2)
    else:
        desired_direction = direction_to_target / distance
    
    # 计算期望速度向量
    desired_velocity = ped.desired_speed * desired_direction
    
    # 驱动力公式: (期望速度 - 当前速度) / tau
    force = (desired_velocity - ped.velocity) / ped.tau
    
    return force

人际与环境排斥力计算：这两种力在数学形式上类似，通常采用指数衰减模型，模拟一种“软”排斥，即越近斥力越大。

def compute_repulsive_force(ped, other_pos, A, B, is_wall=False):
    """
    计算从一个源点（另一个行人或墙壁）作用在行人ped上的排斥力。
    采用经典的Helbing排斥力模型。
    
    参数:
        ped: 受力的行人对象
        other_pos: 排斥源的位置（行人中心点或墙壁上的最近点）
        A: 力强度常数
        B: 力作用范围常数
        is_wall: 是否为墙壁力，墙壁力计算时方向略有不同
    
    返回:
        force: 排斥力向量 [fx, fy]
    """
    # 计算从源指向行人的向量
    if is_wall:
        # 对于墙壁，other_pos是行人在墙壁上的投影点
        direction = ped.position - other_pos
    else:
        # 对于其他行人，方向是从对方指向自己
        direction = ped.position - other_pos
    
    distance = np.linalg.norm(direction)
    if distance < 1e-5:
        return np.zeros(2)
    
    # 有效距离：减去两个个体的半径（如果是人人交互）
    effective_distance = distance
    if not is_wall:
        # 假设另一个个体也有半径，这里简化处理，使用ped.radius作为参考
        effective_distance = distance - 2 * ped.radius
        if effective_distance <= 0:
            effective_distance = 0.01  # 避免除零，赋予一个极小值表示碰撞
    
    # 归一化方向
    norm_direction = direction / distance
    
    # 核心排斥力公式: A * exp((radius - distance) / B) * norm_direction
    # 注意：原公式中是指数衰减，这里做了变形以符合常见实现
    force_magnitude = A * np.exp((ped.radius - effective_distance) / B)
    force = force_magnitude * norm_direction
    
    return force

2.3 集成与状态更新：构建仿真主循环

有了力的计算单元，我们需要一个仿真管理器来协调所有行人，在每个时间步长内计算合力并更新状态。

class SocialForceSimulator:
    def __init__(self, width=20.0, height=20.0):
        self.width = width
        self.height = height
        self.pedestrians = []
        self.walls = []  # 墙壁表示为线段列表 [(x1,y1,x2,y2), ...]
        self.time = 0.0
        self.dt = 0.05  # 仿真时间步长，推荐0.01-0.05秒
        
        # 模型参数（可全局设置，也可个体单独设置）
        self.A_inter = 2000.0  # 人际排斥强度
        self.B_inter = 0.08    # 人际排斥范围
        self.A_wall = 2000.0   # 墙壁排斥强度
        self.B_wall = 0.08     # 墙壁排斥范围
        
    def add_pedestrian(self, ped):
        self.pedestrians.append(ped)
    
    def add_wall(self, start, end):
        self.walls.append((start, end))
    
    def compute_total_force(self, ped):
        """计算作用在单个行人上的合力。"""
        total_force = np.zeros(2)
        
        # 1. 驱动力
        total_force += compute_driving_force(ped, self.dt)
        
        # 2. 来自其他行人的人际排斥力
        for other in self.pedestrians:
            if other.id == ped.id:
                continue
            rep_force = compute_repulsive_force(
                ped, other.position, self.A_inter, self.B_inter, is_wall=False
            )
            total_force += rep_force
        
        # 3. 来自墙壁的环境排斥力
        for wall_start, wall_end in self.walls:
            # 计算行人在墙壁线段上的最近点（投影点）
            closest_point = self._closest_point_on_segment(
                ped.position, wall_start, wall_end
            )
            wall_force = compute_repulsive_force(
                ped, closest_point, self.A_wall, self.B_wall, is_wall=True
            )
            total_force += wall_force
        
        # （可选）4. 可在此处添加随机扰动力，模拟决策噪声
        # random_force = np.random.normal(0, 0.1, size=2)
        # total_force += random_force
        
        return total_force
    
    def _closest_point_on_segment(self, point, seg_start, seg_end):
        """计算点到线段的最短距离点（投影点）。"""
        # 向量AP和AB
        ap = point - seg_start
        ab = seg_end - seg_start
        
        # 计算投影长度比例
        ab_squared = np.dot(ab, ab)
        if ab_squared == 0:
            return seg_start  # 线段退化为点
        
        t = np.dot(ap, ab) / ab_squared
        t = np.clip(t, 0.0, 1.0)  # 将投影点限制在线段上
        
        # 返回线段上的最近点
        closest = seg_start + t * ab
        return closest
    
    def step(self):
        """执行一个仿真时间步长。"""
        new_positions = []
        new_velocities = []
        
        for ped in self.pedestrians:
            # 计算合力
            total_force = self.compute_total_force(ped)
            
            # 根据牛顿第二定律更新速度 (假设质量m=1)
            acceleration = total_force  # F = m*a, m=1
            new_velocity = ped.velocity + acceleration * self.dt
            
            # 简单速度限制，防止数值不稳定
            speed = np.linalg.norm(new_velocity)
            if speed > ped.desired_speed * 2.0:  # 最大速度限制
                new_velocity = new_velocity / speed * (ped.desired_speed * 2.0)
            
            # 更新位置
            new_position = ped.position + new_velocity * self.dt
            
            # 检查边界（可选，可改为边界排斥力）
            new_position[0] = np.clip(new_position[0], 0.0, self.width)
            new_position[1] = np.clip(new_position[1], 0.0, self.height)
            
            new_positions.append(new_position)
            new_velocities.append(new_velocity)
        
        # 批量更新状态
        for ped, new_pos, new_vel in zip(self.pedestrians, new_positions, new_velocities):
            ped.position = new_pos
            ped.velocity = new_vel
            # 更新路径点目标
            ped.update_target_from_waypoints()
        
        self.time += self.dt

3. 可视化与调试：让仿真结果“动”起来

仿真的结果必须直观可见。我们将使用 Matplotlib 的动画功能，实时观察人群的动态。可视化不仅是展示成果，更是调试模型参数不可或缺的工具。

3.1 创建实时动画

下面的代码创建了一个简单的动画窗口，展示行人在有障碍环境中的运动。

import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib.patches import Circle, Rectangle

def run_simulation_visualization(simulator, total_time=30.0):
    """
    运行仿真并生成实时动画。
    
    参数:
        simulator: SocialForceSimulator 实例
        total_time: 总仿真时间 (秒)
    """
    fig, ax = plt.subplots(figsize=(10, 10))
    ax.set_xlim(0, simulator.width)
    ax.set_ylim(0, simulator.height)
    ax.set_aspect('equal')
    ax.set_title("Social Force Model Simulation")
    ax.set_xlabel("X (m)")
    ax.set_ylabel("Y (m)")
    
    # 绘制墙壁
    for wall_start, wall_end in simulator.walls:
        ax.plot([wall_start[0], wall_end[0]], 
                [wall_start[1], wall_end[1]], 
                'k-', linewidth=3)
    
    # 初始化行人绘图对象（圆点）
    pedestrians_artists = []
    for ped in simulator.pedestrians:
        circle = Circle((ped.position[0], ped.position[1]), 
                        ped.radius, 
                        fc='blue', 
                        alpha=0.7, 
                        ec='black')
        ax.add_patch(circle)
        # 添加一个箭头表示速度方向
        arrow = ax.arrow(ped.position[0], ped.position[1], 
                         ped.velocity[0]*0.5, ped.velocity[1]*0.5, 
                         head_width=0.1, head_length=0.2, 
                         fc='red', ec='red', alpha=0.5)
        pedestrians_artists.append((circle, arrow))
    
    # 目标点标记（如果有）
    target_scatter = None
    targets = [p.target for p in simulator.pedestrians if p.target is not None]
    if targets:
        target_x = [t[0] for t in targets]
        target_y = [t[1] for t in targets]
        target_scatter = ax.scatter(target_x, target_y, c='green', marker='*', s=100, zorder=5)
    
    def update(frame):
        """动画的每一帧更新函数。"""
        nonlocal target_scatter
        
        # 执行10个仿真步长再更新一帧，提高动画流畅度
        for _ in range(10):
            simulator.step()
        
        # 更新行人位置和箭头
        for (circle, arrow), ped in zip(pedestrians_artists, simulator.pedestrians):
            circle.center = (ped.position[0], ped.position[1])
            # 移除旧箭头，创建新箭头
            arrow.remove()
            new_arrow = ax.arrow(ped.position[0], ped.position[1],
                                 ped.velocity[0]*0.5, ped.velocity[1]*0.5,
                                 head_width=0.1, head_length=0.2,
                                 fc='red', ec='red', alpha=0.5)
            pedestrians_artists[pedestrians_artists.index((circle, arrow))] = (circle, new_arrow)
        
        # 更新目标点显示
        if target_scatter:
            target_scatter.remove()
        targets = [p.target for p in simulator.pedestrians if p.target is not None]
        if targets:
            target_x = [t[0] for t in targets]
            target_y = [t[1] for t in targets]
            target_scatter = ax.scatter(target_x, target_y, c='green', marker='*', s=100, zorder=5)
        
        ax.set_title(f"Social Force Model Simulation - Time: {simulator.time:.2f}s")
        return [circle for circle, _ in pedestrians_artists] + [arrow for _, arrow in pedestrians_artists] + ([target_scatter] if target_scatter else [])
    
    # 计算总帧数
    total_frames = int(total_time / (simulator.dt * 10))
    ani = animation.FuncAnimation(fig, update, frames=total_frames, 
                                  interval=50, blit=False, repeat=False)
    plt.show()
    
    return ani

3.2 构建一个完整的测试场景

现在，让我们将所有代码组合起来，创建一个经典的“十字路口”或“门口瓶颈”场景进行测试。

# 主程序：创建场景并运行仿真
if __name__ == "__main__":
    # 1. 初始化仿真器
    sim = SocialForceSimulator(width=30.0, height=20.0)
    
    # 2. 添加墙壁，构造一个带有狭窄通道的环境
    # 左房间
    sim.add_wall((0, 0), (10, 0))
    sim.add_wall((0, 0), (0, 20))
    sim.add_wall((0, 20), (10, 20))
    # 右房间
    sim.add_wall((20, 0), (30, 0))
    sim.add_wall((30, 0), (30, 20))
    sim.add_wall((20, 20), (30, 20))
    # 中间的通道（门）
    sim.add_wall((10, 0), (10, 8))   # 左墙下半部分
    sim.add_wall((10, 12), (10, 20)) # 左墙上半部分
    sim.add_wall((20, 0), (20, 8))   # 右墙下半部分
    sim.add_wall((20, 12), (20, 20)) # 右墙上半部分
    # 通道中间可放置一个障碍物
    # sim.add_wall((14, 9), (16, 11))
    
    # 3. 添加行人，一部分在左边，目标在右边
    np.random.seed(42)  # 固定随机种子，便于复现
    for i in range(15):
        # 左房间的行人
        start_x = np.random.uniform(1, 9)
        start_y = np.random.uniform(1, 19)
        ped = Pedestrian(pid=i, 
                         position=[start_x, start_y],
                         desired_speed=np.random.uniform(1.1, 1.6),
                         tau=0.5,
                         radius=0.2 + np.random.rand()*0.1)  # 随机半径增加真实性
        # 设置目标点为右房间的某个随机位置
        target_x = np.random.uniform(21, 29)
        target_y = np.random.uniform(1, 19)
        ped.set_target([target_x, target_y])
        sim.add_pedestrian(ped)
    
    # 4. （可选）添加一些从右向左的行人，制造双向流
    for i in range(15, 25):
        start_x = np.random.uniform(21, 29)
        start_y = np.random.uniform(1, 19)
        ped = Pedestrian(pid=i,
                         position=[start_x, start_y],
                         desired_speed=np.random.uniform(1.1, 1.6),
                         tau=0.5,
                         radius=0.2 + np.random.rand()*0.1)
        target_x = np.random.uniform(1, 9)
        target_y = np.random.uniform(1, 19)
        ped.set_target([target_x, target_y])
        sim.add_pedestrian(ped)
    
    # 5. 运行可视化仿真
    print("开始社会力模型仿真...")
    ani = run_simulation_visualization(sim, total_time=60.0)
    # 如需保存动画为GIF或视频，可取消下面一行的注释
    # ani.save('sfm_simulation.mp4', writer='ffmpeg', fps=20)

运行这段代码，你将看到一个弹窗，展示行人在狭窄通道处自然形成队列、避让、甚至出现短暂“堵塞”的生动场景。通过观察，你可以直观地判断参数设置是否合理。

4. 高级调优与性能优化技巧

一个能跑的模型只是开始，一个高效、稳定、逼真的模型才是目标。以下是几个关键的调优和优化方向。

4.1 参数调优：让行为更逼真

模型的行为对参数极其敏感。盲目调整往往事倍功半。下面是一个系统性的调优清单，建议你按照顺序进行：

• 第一步：校准基础运动。关闭所有排斥力，只保留驱动力。调整 tau 和 desired_speed，确保单个行人能平滑、准确地沿直线移动到目标点，且速度曲线自然（加速-匀速-减速）。
• 第二步：引入墙壁排斥。添加一面墙，测试行人是否能以合理的距离绕过或沿墙行走。主要调整 A_wall 和 B_wall。B_wall 决定了行人与墙壁的“舒适距离”，通常略大于个体半径。
• 第三步：测试人际交互。放置两个相向而行的行人。观察他们是否会自然错身而过。此时需要精细调整 A_inter 和 B_inter。一个常见的“坑”是排斥力太强，导致两人在很远距离就突然转向，显得不自然；或者太弱，导致两人几乎相撞。
• 第四步：观察群体现象。在瓶颈场景中，调整参数以观察是否会出现自组织现象，如自动形成行进队列（lane formation）、在门口处的振荡（clogging）以及“快即是慢”效应（faster-is-slower effect，即个别行人过于急躁反而降低整体通行效率）。这些现象的出现是模型逼真度的重要标志。

注意：参数没有绝对的最优值。它们与你的仿真尺度（1像素代表多少米？）、时间步长 dt 紧密相关。建议将参数与真实物理量（米、秒、牛顿）对应起来思考，并基于特定场景进行校准。

4.2 性能优化：从百人到万人模拟

当行人数量增加到数百甚至上千时，上述的O(N²)复杂度（每个人需要计算与其他所有人的力）将成为瓶颈。以下是一些实用的优化策略：

1. 空间分割（Space Partitioning） 这是最有效的优化。我们只计算与邻近行人的作用力。可以使用网格法（Grid）或四叉树（Quadtree）。

import numpy as np
from collections import defaultdict

class SpatialGrid:
    def __init__(self, width, height, cell_size):
        self.cell_size = cell_size
        self.nx = int(np.ceil(width / cell_size))
        self.ny = int(np.ceil(height / cell_size))
        self.grid = defaultdict(list)  # 键为网格坐标 (i, j)，值为行人ID列表
    
    def clear(self):
        self.grid.clear()
    
    def add_pedestrian(self, ped_id, position):
        """将行人添加到对应的网格单元格中。"""
        i = int(position[0] / self.cell_size)
        j = int(position[1] / self.cell_size)
        i = np.clip(i, 0, self.nx-1)
        j = np.clip(j, 0, self.ny-1)
        self.grid[(i, j)].append(ped_id)
    
    def get_neighbor_ids(self, ped_id, position, search_radius):
        """获取给定位置周围指定半径内的所有行人ID。"""
        center_i = int(position[0] / self.cell_size)
        center_j = int(position[1] / self.cell_size)
        
        neighbor_ids = []
        # 搜索周围3x3的网格（根据search_radius调整）
        search_range = int(np.ceil(search_radius / self.cell_size))
        for di in range(-search_range, search_range+1):
            for dj in range(-search_range, search_range+1):
                cell_key = (center_i + di, center_j + dj)
                if cell_key in self.grid:
                    neighbor_ids.extend(self.grid[cell_key])
        
        # 移除自己
        if ped_id in neighbor_ids:
            neighbor_ids.remove(ped_id)
        return neighbor_ids

# 在仿真器的step函数中应用
def step_optimized(self):
    # 每步开始前，重建空间网格
    self.spatial_grid.clear()
    for ped in self.pedestrians:
        self.spatial_grid.add_pedestrian(ped.id, ped.position)
    
    for ped in self.pedestrians:
        # 只查询附近的行人，而非全部
        neighbor_ids = self.spatial_grid.get_neighbor_ids(ped.id, ped.position, search_radius=5.0)
        neighbor_peds = [self.pedestrians[pid] for pid in neighbor_ids]  # 假设id即索引
        
        # 在compute_total_force中，只遍历neighbor_peds而非self.pedestrians
        # ... 后续计算逻辑相同 ...

2. 数值稳定性处理 社会力模型中的指数函数在距离很近时会产生极大的力，导致数值爆炸。必须进行截断或软化处理。

def compute_repulsive_force_safe(ped, other_pos, A, B, is_wall=False):
    """增加了安全处理的排斥力计算。"""
    # ... 前面的向量和距离计算相同 ...
    
    # 在计算力大小前，对过小的距离进行限制
    if effective_distance < 0.01:
        effective_distance = 0.01
    
    force_magnitude = A * np.exp((ped.radius - effective_distance) / B)
    
    # 可选：对力的大小设置上限，防止极端值
    max_force = 1e4
    if force_magnitude > max_force:
        force_magnitude = max_force
    
    force = force_magnitude * norm_direction
    return force

3. 使用PyTorch进行GPU加速 如果你的模拟规模极大（>5000人），并且需要进行大量重复实验（如参数搜索），将计算迁移到GPU是终极方案。PyTorch的自动微分和并行计算能力非常适合此任务。

核心思路是将所有行人的位置、速度、目标等状态存储为PyTorch张量（Tensor），并将所有力计算改写为基于张量的向量化操作。这样，整个仿真循环可以在GPU上并行执行，速度提升可达数十至数百倍。由于篇幅限制，这里不展开具体代码，但其架构与NumPy版本类似，只是将 np.array 替换为 torch.tensor，并确保所有运算支持GPU。

4.3 扩展模型：引入更多社会因素

基础社会力模型是一个强大的起点，但真实世界更复杂。你可以根据应用需求轻松扩展：

• 群体吸引力：在 compute_total_force 中添加一个吸引力项，让属于同一群体（如朋友、家庭）的个体倾向于彼此靠近。这可以通过一个与距离成反比的力来实现，并设置一个作用上限。
• 视觉场（Field of View）：行人通常只对前方的刺激做出反应。可以引入一个视角参数，只计算位于行人前方一定角度（如180度）内的其他个体或障碍物产生的力。这能模拟“背后有人叫你没反应”的现象。
• 文化/情境参数：不同文化背景下的个人空间大小不同。你可以为每个行人设置个性化的 A_inter, B_inter 参数，或在恐慌、拥挤等不同情境下动态调整这些参数，以模拟从“悠闲逛街”到“紧急疏散”的行为谱。

调试一个复杂的人群仿真，最头疼的往往是某个参数设置不当导致整个系统“爆炸”（行人飞出去）或“冻结”（所有人卡住不动）。我的经验是，务必开启实时可视化，并准备一个“紧急停止和检查”的按钮。在每次参数大调整后，先用小规模场景（如2-4人）测试，观察基本交互是否合理，再逐步增加人数。记录下每次调整的参数和产生的现象，你会逐渐积累对模型“手感”的直觉。最终，当你看到虚拟人群在通道口自发形成有序的交替通行队列时，那种感觉就像在调教一个复杂的生命系统，所有的努力都是值得的。