Tony Wang's blogs

2026-06-10T16:18:37.542Z

基础

这段代码，可以看到一个倒立摆在胡乱操作

import gym

env_name = "CartPole-v0"
env = gym.make(env_name)          # 导入环境

episodes = 10
for episode in range(1, episodes + 1):
    state = env.reset()           
    done = False
    score = 0

    while not done:
        env.render()                           # 渲染环境
        action = env.action_space.sample()     # 随机采样动作
        n_state, reward, done, info = env.step(action)    # 和环境交互，得到下一个状态，奖励等信息
        score += reward                        # 计算分数
    print("Episode : {}, Score : {}".format(episode, score))

env.close()     # 关闭窗口

用Stable_baseline3来训练的强化学习模型,可以很好地控制这个环境:

from stable_baselines3 import DQN
from stable_baselines3.common.vec_env.dummy_vec_env import DummyVecEnv
from stable_baselines3.common.evaluation import evaluate_policy
import gym

env_name = "CartPole-v0"
env = gym.make(env_name)
# 把环境向量化，如果有多个环境写成列表传入DummyVecEnv中，可以用一个线程来执行多个环境，提高训练效率
env = DummyVecEnv([lambda : env])
# 定义一个DQN模型，设置其中的各个参数
model = DQN(
    "MlpPolicy",                                # MlpPolicy定义策略网络为MLP网络
    env=env, 
    learning_rate=5e-4,
    batch_size=128,
    buffer_size=50000,
    learning_starts=0,
    target_update_interval=250,
    policy_kwargs={"net_arch" : [256, 256]},     # 这里代表隐藏层为2层256个节点数的网络
    verbose=1,                                   # verbose=1代表打印训练信息，如果是0为不打印，2为打印调试信息
    tensorboard_log="./tensorboard/CartPole-v0/"  # 训练数据保存目录，可以用tensorboard查看
)
# 开始训练
model.learn(total_timesteps=1e5)
# 策略评估，可以看到倒立摆在平稳运行了
mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10, render=true)
#env.close()
print("mean_reward:",mean_reward,"std_reward:",std_reward)
# 保存模型到相应的目录
model.save("./model/CartPole.pkl")

自定义环境

需要继承gym.Env类，然后重新其中的方法，配置一定的参数即可，格式如下：

import gym
from gym import spaces

class CustomEnv(gym.Env):
    """Custom Environment that follows gym interface"""
    metadata = {'render.modes': ['human']}

    def __init__(self, arg1, arg2, ...):
        super(CustomEnv, self).__init__()
        # Define action and observation space
        # They must be gym.spaces objects
        # Example when using discrete actions:
        self.action_space = spaces.Discrete(N_DISCRETE_ACTIONS)
        # Example for using image as input (channel-first; channel-last also works):
        self.observation_space = spaces.Box(low=0, high=255,
                                            shape=(N_CHANNELS, HEIGHT, WIDTH), dtype=np.uint8)

    def step(self, action):
        ...
        return observation, reward, done, info
    def reset(self):
        ...
        return observation  # reward, done, info can't be included
    def render(self, mode='human'):
        ...
    def close (self):
        pass

主要三个函数需要实现：

reset() 在每个回合最开始时执行，返回当前的观测（observation）
step(action) 输入 action，智能体执行 action 与环境交互，返回获得的（新的观测、奖励、是否结束、其他）
可选render(method=’human’)` 渲染环境

gym.spaces.Box 任意 shape 的连续空间
spaces.Discrete 维度为 1，且有 n 个枚举值的空间

检查环境是否符合gym接口：

from stable_baselines3.common.env_checker import check_env

env = CustomEnv(arg1, ...)
# It will check your custom environment and output additional warnings if needed
check_env(env)

创建一个让智能体学习如何一直向左边走的1D环境，观测是智能体的当前位置，智能体有两种行为，向左和向右，分别用0和1代表。


import numpy as np
import gym
from gym import spaces


class GoLeftEnv(gym.Env):
  """
  这是一个让智能体学习一直向左走的 1D grid 环境 
  """
  metadata = {'render.modes': ['console']}
  LEFT = 0
  RIGHT = 1

  def __init__(self, grid_size=10):
    super(GoLeftEnv, self).__init__()

    # 1D-grid 的大小
    self.grid_size = grid_size
    # agent 初始化在 grid 的最右边
    self.agent_pos = grid_size - 1

    # 定义 action  observation 
    # 离散行为空间: left、 right
    n_actions = 2
    self.action_space = spaces.Discrete(n_actions)
    # 观测是智能体现在的位置
    self.observation_space = spaces.Box(low=0, high=self.grid_size,
                                        shape=(1,), dtype=np.float32)

  def reset(self):
    """
    Important: 观测必须是一个 np.array
    :return: (np.array) 
    """
    # Initialize the agent at the right of the grid
    self.agent_pos = self.grid_size - 1
    # here we convert to float32 to make it more general (in case we want to use continuous actions)
    return np.array([self.agent_pos]).astype(np.float32)

  def step(self, action):
    if action == self.LEFT:
      self.agent_pos -= 1
    elif action == self.RIGHT:
      self.agent_pos += 1
    else:
      raise ValueError("Received invalid action={} which is not part of the action space".format(action))
    # 如果走到边缘就不能继续走了
    self.agent_pos = np.clip(self.agent_pos, 0, self.grid_size)
    # 如果走到最左边代表结束了
    done = bool(self.agent_pos == 0)
    # 走到最左边就给一个正的 reward
    reward = 1 if self.agent_pos == 0 else 0
    # 目前没有需要额外输出的信息
    info = {}
    return np.array([self.agent_pos]).astype(np.float32), reward, done, info

  def render(self, mode='console'):
    # 在命令行中渲染
    if mode != 'console':
      raise NotImplementedError()
    # agent is represented as a cross, rest as a dot
    print("." * self.agent_pos, end="")
    print("x", end="")
    print("." * (self.grid_size - self.agent_pos))

  def close(self):
    pass

构建环境和智能体

from stable_baselines3 import PPO, A2C # DQN coming soon
from stable_baselines3.common.env_util import make_vec_env

# 构建环境
env = GoLeftEnv(grid_size=10)
env = make_vec_env(lambda: env, n_envs=1)

# 训练智能体
model = A2C('MlpPolicy', env, verbose=1).learn(5000)

# 测试智能体：
# Test the trained agent
obs = env.reset()
n_steps = 20
for step in range(n_steps):
  action, _ = model.predict(obs, deterministic=True)
  print("Step {}".format(step + 1))
  print("Action: ", action)
  obs, reward, done, info = env.step(action)
  print('obs=', obs, 'reward=', reward, 'done=', done)
  env.render(mode='console')
  if done:
    # Note that the VecEnv resets automatically
    # when a done signal is encountered
    print("Goal reached!", "reward=", reward)
    break

也可以是连续动作空间

# _*_coding:utf-8-*-
import sys
import gym
from sympy import *
import math
import numpy as np
gym.logger.set_level(40)
# sys.path.append('这里写其上层文件见的绝对路径，如'~/autodl-nas/robot/'')
# import Params
class RobotEnv(gym.Env):
    # 初始化参数
    def __init__(self):
        # 状态空间为18（关节角度）+18（关节角速度）+2（控制方向）+1（控制速度）=39
        self.observation_space = gym.spaces.Box(low=-1, high=1, shape=(39,))
        # 动作空间为18（关节角度）
        self.action_space = gym.spaces.Box(low=-1, high=1, shape=(18,))
        # 附加功能，可选,对应第35行
        # self.reward_fun = Params.PARAMS_ENV['reward_fun']

    # 获取原始数据，并生成状态，同时更新done
    def get_state(self):
        origin_data = [这里写获取数据的函数]
        tmp_data = [将原始数据按照要求组成状态，注意角度\角速度\方向和速度归一化到[-1,-1],速度可以除以系数归一化到0-1]]
        state = np.array(tmp_data).reshape(1,39)
        self.done = True if[写判断终止条件]else False
        return state

    # 根据强化学习输出，发送控制指令，控制机器人运动
    def move(self, action):
        [这里将动作对应的控制指令发送给仿真环境中的机器人]
        pass

    # 奖励函数
    def get_reward(self):
        reward = [根据任务需求定义奖励函数,建议三个方面：1、存活时间长短（即能否满足站立并运动的要求）2、方向是否为给定方向3、速度是否为给定速度]
        # reward = self.reward_fun#如果使用这个，就不需要上面个这句，上面这句就可以放到参数文件中进行定义
        return reward

    # 主程序
    def step(self, action):
        # 执行动作
        self.move(action)
        # 获取动作对应奖励
        reward = self.get_reward()
        # 获取下一状态
        state = self.get_state()
        # 返回
        return state, reward, self.done, {}

    # 重置环境
    def reset(self):
        [初始化机器人]
        # 获得对应状态
        state = self.get_state()
        return state

    # 关闭机器人
    def close(self):
        [关闭机器人]

2026-06-10T16:18:37.527Z

1 2	https://github.com/eleurent/highway-env https://github.com/MCZhi/Driving-IRL-NGSIM/blob/main/NGSIM_env/envs/ngsim_env.py

1301,3725,511,1118847351400,20.428,717.996,6451628.438,1872868.223,11,4.5,2,31.39,-10.61,2,NA,NA,NA,NA,NA,NA,1289,1304,51.13,1.63,us-101

NGSIM数据集包含四个不同的场景：US-101、I-80、Lankershim与Peachtree。US-101与I-80记录了车辆在高速公路上的行驶轨迹，Lankershim与Peachtree记录了车辆在城市道路上的行驶轨迹

字段名	描述
Vehicle_Id	车辆识别号（根据进入该区域的时间升序），可重复利用。
Frame_Id	该条数据在某一时刻的帧（按开始时间升序），同一Vehicle_ID的帧号不会重复。
Total_Frame	该车出现在此数据集的总帧数。
Global_Time	时间戳（ms）。
Local_X	车辆前部中心的横向（X）坐标，以英尺为单位，相对于截面在行驶方向上的最左侧边缘。
Local_Y	车辆前部中心的纵向（Y）坐标，以英尺为单位，相对于截面在行驶方向上的相对于路段入口的纵向边缘。
Local_X，Local_Y	采集区域内的坐标，采集区域不同，坐标系不同，会有不同的零点。
Global_X, Global_Y	全局坐标，只有一个零点，可用作数据筛选（以英尺为单位）。
v_length	车辆长度（以英尺为单位）。
v_Width	车辆宽度（以英尺为单位）。
v_Class	车辆类型：1-摩托车，2-汽车，3-卡车。
v_Vel	车辆瞬时速度，以英尺/秒为单位。
v_Acc	车辆的瞬时加速度，以英尺/秒平方为单位。
Lane_ID	车辆的当前车道位置。第1车道是最左边的车道，第5车道是最右边的车道。
O_Zone	车辆的起点区域，即车辆进入跟踪系统的位置。研究区域有11个起源，编号从101到111。有关更多详细信息，请参阅数据分析报告。
D_Zone	车辆的目的地区域，即车辆离开跟踪系统的地方。研究区域中有10个目的地，从201到211编号。起点102是单向出口，因此，没有关联的目标号码202。请参阅数据分析报告以获取更多详细信息。
Int_ID	车辆行驶的路口。交叉点的编号为1到4，交叉点1位于最南端，交叉点4位于研究区域的最北端。值为“ 0”表示该车辆不在交叉路口的附近，而是该车辆标识为Lankershim Boulevard的一段（下面的Section_ID）。请参阅数据分析报告以获取更多详细信息。
Section_ID	车辆行驶的路段。 Lankershim Blvd分为五个部分（路口1的南部；路口1和2、2和3、3和4之间；路口4的北部）。值为0表示该车辆未识别出Lankershim Boulevard的一段，并且该车辆紧邻交叉路口（上述Int_ID）。请参阅数据分析报告以获取更多详细信息。
Direction	车辆的行驶方向。 1-东行（EB），2-北行（NB），3-西行（WB），4-南行（SB）。
Movement	车辆的运动。 1-通过（TH），2-左转（LT），3-右转（RT）。
Preceding	同道前车的车辆编号。数值为0表示没有前面的车辆-发生在研究段的末尾和出匝道。
Following	在同一车道上跟随本车辆的车辆的车辆ID。值0表示没有跟随的车辆-在研究部分的开头和匝道发生。
Space_Headway	间距提供了车辆的前中心到前一辆车辆的前中心之间的距离（英尺）。
Time_Headway	时间进度（以秒为单位）提供了从车辆的前中心（以车辆的速度）行进到前一辆车辆的前中心的时间。
Location	街道名称或高速公路名称。

    v_Vel  v_Acc  Lane_ID     x_prime    y_prime  v_Class  Space_Headway

id
10_436 43.82 -1.59 1 93.445584 -1.861718 2 0.00
12_443 35.26 4.49 1 77.581354 -1.745590 2 52.05
13_432 39.48 6.21 2 100.954027 -5.892089 2 98.13
14_515 36.66 -11.20 5 106.701336 -15.726461 3 0.00
18_291 41.14 0.15 5 78.375053 -15.703906 2 92.93
20_414 40.01 0.00 3 61.464749 -8.023250 2 123.13
21_439 43.55 7.14 4 85.675927 -11.882628 2 82.24
22_441 34.92 0.09 2 80.107841 -5.302910 2 68.39
23_438 37.55 0.00 1 61.004501 -1.665427 2 54.39
25_436 44.98 0.00 4 55.262678 -11.570208 2 99.78
26_438 34.99 0.00 2 65.094002 -4.779874 2 49.26
27_432 40.00 0.00 1 34.377782 -1.819046 2 87.36
2_437 44.99 0.00 2 130.865270 -5.408676 2 0.00
31_465 35.02 -0.23 5 60.066326 -15.641117 2 60.07
32_438 34.41 -1.74 2 50.624842 -4.710684 2 47.47
34_451 40.01 0.28 4 37.907366 -11.704015 2 56.94
35_280 31.20 -2.39 5 43.132858 -16.138246 2 55.56
39_450 41.50 0.02 1 21.973032 -0.281026 2 40.70
40_391 43.69 -10.63 4 20.277430 -12.428220 2 57.84
47_428 40.00 0.00 3 14.348765 -8.414309 2 154.58
48_507 35.08 -1.87 5 32.537400 -15.481097 2 34.76
5_452 38.55 0.00 4 129.526284 -12.498629 2 0.00
8_448 39.97 0.09 4 110.742070 -12.588850 2 61.63
9_409 45.88 -6.52 3 98.994163 -8.774887 2 0.00

def test_make_data_loader():
    """Tests data loader produces same results for same input in different formats."""
    trajs = [
        types.Trajectory(
            obs=np.array([0, 1]),
            acts=np.array([100]),
            infos=None,
            terminal=True,
        ),
        types.Trajectory(
            obs=np.array([4, 5, 6]),
            acts=np.array([102, 103]),
            infos=None,
            terminal=True,
        ),
        types.Trajectory(
            obs=np.array([10, 11, 12, 13]),
            acts=np.array([104, 105, 106]),
            infos=None,
            terminal=False,
        ),
    ]
    trans = types.Transitions(
        obs=np.array([0, 4, 5, 10, 11, 12]),
        acts=np.array([100, 102, 103, 104, 105, 106]),
        next_obs=np.array([1, 5, 6, 11, 12, 13]),
        dones=np.array([True, False, True, False, False, False]),
        infos=np.array([{}] * 6),
    )
    trans_mapping = [
        {
            "obs": np.array([0, 4]),
            "acts": np.array([100, 102]),
            "next_obs": np.array([1, 5]),
            "dones": np.array([True, False]),
            "infos": np.array([{}, {}]),
        },
        {
            "obs": np.array([5, 10]),
            "acts": np.array([103, 104]),
            "next_obs": np.array([6, 11]),
            "dones": np.array([True, False]),
            "infos": np.array([{}, {}]),
        },
        {
            "obs": np.array([11, 12]),
            "acts": np.array([105, 106]),
            "next_obs": np.array([12, 13]),
            "dones": np.array([False]),
            "infos": np.array([{}, {}]),
        },
    ]

    for data in [trajs, trans, trans_mapping]:
        data_loader = base.make_data_loader(
            data,
            batch_size=2,
            data_loader_kwargs=dict(shuffle=False, drop_last=False),
        )
        for batch, expected_batch in zip(data_loader, trans_mapping):
            assert batch.keys() == expected_batch.keys()
            for k in batch.keys():
                v = batch[k]
                if isinstance(v, th.Tensor):
                    v = v.numpy()
                assert np.all(v == expected_batch[k])

Of course you don’t have to generate the demonstrations. This is just done in the examples to make them more self-contained. You can pass your trajectories as a sequence of imitation.data.types.Trajectory to GAIL/AIRL.

2026-06-10T16:18:37.526Z

1	from a2c_ppo_acktr.algo import gail

import copy
import glob
import os
import time
from collections import deque

import gym
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

from a2c_ppo_acktr import algo, utils
from a2c_ppo_acktr.algo import gail
from a2c_ppo_acktr.arguments import get_args
from a2c_ppo_acktr.envs import make_vec_envs
from a2c_ppo_acktr.model import Policy
from a2c_ppo_acktr.storage import RolloutStorage
from evaluation import evaluate


def main():
    args = get_args()

    torch.manual_seed(args.seed)
    torch.cuda.manual_seed_all(args.seed)

    if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
        torch.backends.cudnn.benchmark = False
        torch.backends.cudnn.deterministic = True

    log_dir = os.path.expanduser(args.log_dir)
    eval_log_dir = log_dir + "_eval"
    utils.cleanup_log_dir(log_dir)
    utils.cleanup_log_dir(eval_log_dir)

    torch.set_num_threads(1)
    device = torch.device("cuda:0" if args.cuda else "cpu")

    envs = make_vec_envs(args.env_name, args.seed, args.num_processes,
                         args.gamma, args.log_dir, device, False)

    actor_critic = Policy(
        envs.observation_space.shape,
        envs.action_space,
        base_kwargs={'recurrent': args.recurrent_policy})
    actor_critic.to(device)

    if args.algo == 'a2c':
        agent = algo.A2C_ACKTR(
            actor_critic,
            args.value_loss_coef,
            args.entropy_coef,
            lr=args.lr,
            eps=args.eps,
            alpha=args.alpha,
            max_grad_norm=args.max_grad_norm)
    elif args.algo == 'ppo':
        agent = algo.PPO(
            actor_critic,
            args.clip_param,
            args.ppo_epoch,
            args.num_mini_batch,
            args.value_loss_coef,
            args.entropy_coef,
            lr=args.lr,
            eps=args.eps,
            max_grad_norm=args.max_grad_norm)
    elif args.algo == 'acktr':
        agent = algo.A2C_ACKTR(
            actor_critic, args.value_loss_coef, args.entropy_coef, acktr=True)

    if args.gail:
        assert len(envs.observation_space.shape) == 1
        discr = gail.Discriminator(
            envs.observation_space.shape[0] + envs.action_space.shape[0], 100,
            device)
        file_name = os.path.join(
            args.gail_experts_dir, "trajs_{}.pt".format(
                args.env_name.split('-')[0].lower()))
        
        expert_dataset = gail.ExpertDataset(
            file_name, num_trajectories=4, subsample_frequency=20)
        drop_last = len(expert_dataset) > args.gail_batch_size
        gail_train_loader = torch.utils.data.DataLoader(
            dataset=expert_dataset,
            batch_size=args.gail_batch_size,
            shuffle=True,
            drop_last=drop_last)

    rollouts = RolloutStorage(args.num_steps, args.num_processes,
                              envs.observation_space.shape, envs.action_space,
                              actor_critic.recurrent_hidden_state_size)

    obs = envs.reset()
    rollouts.obs[0].copy_(obs)
    rollouts.to(device)

    episode_rewards = deque(maxlen=10)

    start = time.time()
    num_updates = int(
        args.num_env_steps) // args.num_steps // args.num_processes
    for j in range(num_updates):

        if args.use_linear_lr_decay:
            # decrease learning rate linearly
            utils.update_linear_schedule(
                agent.optimizer, j, num_updates,
                agent.optimizer.lr if args.algo == "acktr" else args.lr)

        for step in range(args.num_steps):
            # Sample actions
            with torch.no_grad():
                value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
                    rollouts.obs[step], rollouts.recurrent_hidden_states[step],
                    rollouts.masks[step])

            # Obser reward and next obs
            obs, reward, done, infos = envs.step(action)

            for info in infos:
                if 'episode' in info.keys():
                    episode_rewards.append(info['episode']['r'])

            # If done then clean the history of observations.
            masks = torch.FloatTensor(
                [[0.0] if done_ else [1.0] for done_ in done])
            bad_masks = torch.FloatTensor(
                [[0.0] if 'bad_transition' in info.keys() else [1.0]
                 for info in infos])
            rollouts.insert(obs, recurrent_hidden_states, action,
                            action_log_prob, value, reward, masks, bad_masks)

        with torch.no_grad():
            next_value = actor_critic.get_value(
                rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
                rollouts.masks[-1]).detach()

        if args.gail:
            if j >= 10:
                envs.venv.eval()

            gail_epoch = args.gail_epoch
            if j < 10:
                gail_epoch = 100  # Warm up
            for _ in range(gail_epoch):
                discr.update(gail_train_loader, rollouts,
                             utils.get_vec_normalize(envs)._obfilt)

            for step in range(args.num_steps):
                rollouts.rewards[step] = discr.predict_reward(
                    rollouts.obs[step], rollouts.actions[step], args.gamma,
                    rollouts.masks[step])

        rollouts.compute_returns(next_value, args.use_gae, args.gamma,
                                 args.gae_lambda, args.use_proper_time_limits)

        value_loss, action_loss, dist_entropy = agent.update(rollouts)

        rollouts.after_update()

        # save for every interval-th episode or for the last epoch
        if (j % args.save_interval == 0
                or j == num_updates - 1) and args.save_dir != "":
            save_path = os.path.join(args.save_dir, args.algo)
            try:
                os.makedirs(save_path)
            except OSError:
                pass

            torch.save([
                actor_critic,
                getattr(utils.get_vec_normalize(envs), 'obs_rms', None)
            ], os.path.join(save_path, args.env_name + ".pt"))

        if j % args.log_interval == 0 and len(episode_rewards) > 1:
            total_num_steps = (j + 1) * args.num_processes * args.num_steps
            end = time.time()
            print(
                "Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
                .format(j, total_num_steps,
                        int(total_num_steps / (end - start)),
                        len(episode_rewards), np.mean(episode_rewards),
                        np.median(episode_rewards), np.min(episode_rewards),
                        np.max(episode_rewards), dist_entropy, value_loss,
                        action_loss))

        if (args.eval_interval is not None and len(episode_rewards) > 1
                and j % args.eval_interval == 0):
            obs_rms = utils.get_vec_normalize(envs).obs_rms
            evaluate(actor_critic, obs_rms, args.env_name, args.seed,
                     args.num_processes, eval_log_dir, device)


if __name__ == "__main__":
    main()

import h5py
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from torch import autograd

from stable_baselines3.common.running_mean_std import RunningMeanStd

class Discriminator(nn.Module):
    def __init__(self, input_dim, hidden_dim, device):
        super(Discriminator, self).__init__()

        self.device = device

        self.trunk = nn.Sequential(
            nn.Linear(input_dim, hidden_dim), nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim), nn.Tanh(),
            nn.Linear(hidden_dim, 1)).to(device)

        self.trunk.train()

        self.optimizer = torch.optim.Adam(self.trunk.parameters())

        self.returns = None
        self.ret_rms = RunningMeanStd(shape=())

    def compute_grad_pen(self,
                         expert_state,
                         expert_action,
                         policy_state,
                         policy_action,
                         lambda_=10):
        alpha = torch.rand(expert_state.size(0), 1)
        expert_data = torch.cat([expert_state, expert_action], dim=1)
        policy_data = torch.cat([policy_state, policy_action], dim=1)

        alpha = alpha.expand_as(expert_data).to(expert_data.device)

        mixup_data = alpha * expert_data + (1 - alpha) * policy_data
        mixup_data.requires_grad = True

        disc = self.trunk(mixup_data)
        ones = torch.ones(disc.size()).to(disc.device)
        grad = autograd.grad(
            outputs=disc,
            inputs=mixup_data,
            grad_outputs=ones,
            create_graph=True,
            retain_graph=True,
            only_inputs=True)[0]

        grad_pen = lambda_ * (grad.norm(2, dim=1) - 1).pow(2).mean()
        return grad_pen

    def update(self, expert_loader, rollouts, obsfilt=None):
        self.train()

        policy_data_generator = rollouts.feed_forward_generator(
            None, mini_batch_size=expert_loader.batch_size)

        loss = 0
        n = 0
        for expert_batch, policy_batch in zip(expert_loader,
                                              policy_data_generator):
            policy_state, policy_action = policy_batch[0], policy_batch[2]
            policy_d = self.trunk(
                torch.cat([policy_state, policy_action], dim=1))

            expert_state, expert_action = expert_batch
            expert_state = obsfilt(expert_state.numpy(), update=False)
            expert_state = torch.FloatTensor(expert_state).to(self.device)
            expert_action = expert_action.to(self.device)
            expert_d = self.trunk(
                torch.cat([expert_state, expert_action], dim=1))

            expert_loss = F.binary_cross_entropy_with_logits(
                expert_d,
                torch.ones(expert_d.size()).to(self.device))
            policy_loss = F.binary_cross_entropy_with_logits(
                policy_d,
                torch.zeros(policy_d.size()).to(self.device))

            gail_loss = expert_loss + policy_loss
            grad_pen = self.compute_grad_pen(expert_state, expert_action,
                                             policy_state, policy_action)

            loss += (gail_loss + grad_pen).item()
            n += 1

            self.optimizer.zero_grad()
            (gail_loss + grad_pen).backward()
            self.optimizer.step()
        return loss / n

    def predict_reward(self, state, action, gamma, masks, update_rms=True):
        with torch.no_grad():
            self.eval()
            d = self.trunk(torch.cat([state, action], dim=1))
            s = torch.sigmoid(d)
            reward = s.log() - (1 - s).log()
            if self.returns is None:
                self.returns = reward.clone()

            if update_rms:
                self.returns = self.returns * masks * gamma + reward
                self.ret_rms.update(self.returns.cpu().numpy())

            return reward / np.sqrt(self.ret_rms.var[0] + 1e-8)


class ExpertDataset(torch.utils.data.Dataset):
    def __init__(self, file_name, num_trajectories=4, subsample_frequency=20):
        all_trajectories = torch.load(file_name)
        
        perm = torch.randperm(all_trajectories['states'].size(0))
        idx = perm[:num_trajectories]

        self.trajectories = {}
        
        # See https://github.com/pytorch/pytorch/issues/14886
        # .long() for fixing bug in torch v0.4.1
        start_idx = torch.randint(
            0, subsample_frequency, size=(num_trajectories, )).long()

        for k, v in all_trajectories.items():
            data = v[idx]

            if k != 'lengths':
                samples = []
                for i in range(num_trajectories):
                    samples.append(data[i, start_idx[i]::subsample_frequency])
                self.trajectories[k] = torch.stack(samples)
            else:
                self.trajectories[k] = data // subsample_frequency

        self.i2traj_idx = {}
        self.i2i = {}
        
        self.length = self.trajectories['lengths'].sum().item()

        traj_idx = 0
        i = 0

        self.get_idx = []
        
        for j in range(self.length):
            
            while self.trajectories['lengths'][traj_idx].item() <= i:
                i -= self.trajectories['lengths'][traj_idx].item()
                traj_idx += 1

            self.get_idx.append((traj_idx, i))

            i += 1
            
            
    def __len__(self):
        return self.length

    def __getitem__(self, i):
        traj_idx, i = self.get_idx[i]

        return self.trajectories['states'][traj_idx][i], self.trajectories[
            'actions'][traj_idx][i]

import numpy as np
import gym
from stable_baselines3 import PPO
from stable_baselines3.common.evaluation import evaluate_policy
from stable_baselines3.common.vec_env import DummyVecEnv
from stable_baselines3.ppo import MlpPolicy

from imitation.algorithms.adversarial.gail import GAIL
from imitation.data import rollout
from imitation.data.wrappers import RolloutInfoWrapper
from imitation.rewards.reward_nets import BasicRewardNet
from imitation.util.networks import RunningNorm
from imitation.util.util import make_vec_env

rng = np.random.default_rng(0)

env = gym.make("seals/CartPole-v0")
expert = PPO(policy=MlpPolicy, env=env, n_steps=64)
expert.learn(1000)

rollouts = rollout.rollout(
    expert,
    make_vec_env(
        "seals/CartPole-v0",
        n_envs=5,
        post_wrappers=[lambda env, _: RolloutInfoWrapper(env)],
        rng=rng,
    ),
    rollout.make_sample_until(min_timesteps=None, min_episodes=60),
    rng=rng,
)

venv = make_vec_env("seals/CartPole-v0", n_envs=8, rng=rng)
learner = PPO(env=venv, policy=MlpPolicy)
reward_net = BasicRewardNet(
    venv.observation_space,
    venv.action_space,
    normalize_input_layer=RunningNorm,
)
gail_trainer = GAIL(
    demonstrations=rollouts,
    demo_batch_size=1024,
    gen_replay_buffer_capacity=2048,
    n_disc_updates_per_round=4,
    venv=venv,
    gen_algo=learner,
    reward_net=reward_net,
)

gail_trainer.train(20000)
rewards, _ = evaluate_policy(learner, venv, 100, return_episode_rewards=True)
print("Rewards:", rewards)

TensorFlow

import argparse
import gym
import numpy as np
import tensorflow as tf
from network_models.policy_net import Policy_net
from network_models.discriminator import Discriminator
from algo.ppo import PPOTrain

def argparser():
    parser = argparse.ArgumentParser()
    parser.add_argument('--logdir', help='log directory', default='log/train/gail')
    parser.add_argument('--savedir', help='save directory', default='trained_models/gail')
    parser.add_argument('--gamma', default=0.95)
    parser.add_argument('--iteration', default=int(1e4))
    return parser.parse_args()


def main(args):
    env = gym.make('CartPole-v0')
    env.seed(0)
    ob_space = env.observation_space
    Policy = Policy_net('policy', env)
    Old_Policy = Policy_net('old_policy', env)
    PPO = PPOTrain(Policy, Old_Policy, gamma=args.gamma)
    D = Discriminator(env)

    # 得到专家的观测和行动
    expert_observations = np.genfromtxt('trajectory/observations.csv')
    expert_actions = np.genfromtxt('trajectory/actions.csv', dtype=np.int32)

    saver = tf.train.Saver()

    with tf.Session() as sess:
        writer = tf.summary.FileWriter(args.logdir, sess.graph)
        sess.run(tf.global_variables_initializer())

        obs = env.reset()
        success_num = 0

        for iteration in range(args.iteration):
            observations = []
            actions = []
            rewards = []
            v_preds = []
            run_policy_steps = 0

            while True:
                run_policy_steps += 1
                obs = np.stack([obs]).astype(dtype=np.float32)
                act, v_pred = Policy.act(obs = obs,stochastic = True)

                act = np.asscalar(act)
                v_pred = np.asscalar(v_pred)

                next_obs,reward,done,info = env.step(act)

                observations.append(obs)
                actions.append(act)
                rewards.append(reward)
                v_preds.append(v_pred)

                if done:
                    next_obs = np.stack([next_obs]).astype(dtype=np.float32)  # prepare to feed placeholder Policy.obs
                    _, v_pred = Policy.act(obs=next_obs, stochastic=True)
                    v_preds_next = v_preds[1:] + [np.asscalar(v_pred)]
                    obs = env.reset()
                    break
                else:
                    obs = next_obs

            writer.add_summary(tf.Summary(value=[tf.Summary.Value(tag='episode_length', simple_value=run_policy_steps)])
                               , iteration)
            writer.add_summary(tf.Summary(value=[tf.Summary.Value(tag='episode_reward', simple_value=sum(rewards))])
                               , iteration)

            if sum(rewards) >= 195:
                success_num += 1
                if success_num >= 100:
                    saver.save(sess, args.savedir + '/model.ckpt')
                    print('Clear!! Model saved.')
                    break
            else:
                success_num = 0

            observations = np.reshape(observations,newshape=[-1] + list(ob_space.shape))
            actions = np.array(actions).astype(dtype = np.int32)

            for i in range(2):
                D.train(expert_s = expert_observations,
                        expert_a = expert_actions,
                        agent_s = observations,
                        agent_a = actions)


            d_rewards = D.get_rewards(agent_s=observations,agent_a = actions)
            d_rewards = np.reshape(d_rewards,newshape=[-1]).astype(dtype=np.float32)

            gaes = PPO.get_gaes(rewards=d_rewards, v_preds=v_preds, v_preds_next=v_preds_next)
            gaes = np.array(gaes).astype(dtype=np.float32)
            # gaes = (gaes - gaes.mean()) / gaes.std()
            v_preds_next = np.array(v_preds_next).astype(dtype=np.float32)

            # train policy
            inp = [observations, actions, gaes, d_rewards, v_preds_next]
            PPO.assign_policy_parameters()
            for epoch in range(6):
                sample_indices = np.random.randint(low=0, high=observations.shape[0],
                                                   size=32)  # indices are in [low, high)
                sampled_inp = [np.take(a=a, indices=sample_indices, axis=0) for a in inp]  # sample training data
                PPO.train(obs=sampled_inp[0],
                          actions=sampled_inp[1],
                          gaes=sampled_inp[2],
                          rewards=sampled_inp[3],
                          v_preds_next=sampled_inp[4])

            summary = PPO.get_summary(obs=inp[0],
                                      actions=inp[1],
                                      gaes=inp[2],
                                      rewards=inp[3],
                                      v_preds_next=inp[4])

            writer.add_summary(summary, iteration)
        writer.close()


if __name__ == '__main__':
    args = argparser()
    main(args)

1	traj = Trajectory(observations, actions, infos=None, terminal=True)

–pedestrians

2026-06-10T16:18:37.526Z

概念

Docker包括三个基本概念：

镜像（Image）：Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

仓库（Repository）：仓库（Repository）类似Git的远程仓库，集中存放镜像文件。

三者关系可以用下图表示：

Docker的常用命令

服务

查看Docker版本信息

1	docker version

启动Docker

1	systemctl start docker

关闭docker

1	systemctl stop docker

设置开机启动

1	systemctl enable docker

重启docker服务

1	service docker restart

关闭docker服务

1	service docker stop

镜像

Docker Hub等镜像仓库上有大量的高质量的镜像可以用，可以从仓库获取镜像

检索镜像

1	docker search 关键字

拉取镜像

1	docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]

列出镜像

1 2	docker image ls docker images

删除镜像

1 2	# 删除指定镜像 docker rmi <镜像Id>

导出镜像

1 2	# 将镜像保存为归档文件 docker save

导入镜像

1	docker load

构建镜像

Dockerfile 是一个文本格式的配置文件，用户可以使用 Dockerfile 来快速创建自定义的镜像

Dockerfile 由一行行行命令语句组成，并且支持以＃开头的注释行.

一些常见的指令：

FROM：指定基础镜像
RUN：执行命令
COPY：复制文件
ADD：更高级的复制文件
CMD：容器启动命令
ENV：设置环境变量
EXPOSE：暴露端口

以下是一个Dockerfile实例：

FROM java:8
MAINTAINER "jinshw"com>
ADD mapcharts-0.0.1-SNAPSHOT.jar mapcharts.jar
EXPOSE 8080
CMD java -jar mapcharts.jar

构建镜像命令：

1	docker build [选项] <上下文路径/URL/->

# 指定Dockerfile路径
docker build -f /path/to/a/Dockerfile .
# 默认使用当前路径中的Dockerfile文件 
docker build . 
# -t，--tag 指定构建的镜像名和tag
docker build -t image-nginx:v1 .

镜像运行（容器运行）:

# 新建并启动
docker run [镜像ID]
# 启动已终止容器
docker start [容器ID]

容器

启动容器有两种方式，一种是基于镜像新建一个容器并启动，另外一个是将在终止状态（stopped）的容器重新启动。

1	docker run --name mynginx -it 01da99b6476c

-it 参数为该docker创建一个伪终端，这样就可以进入到容器的交互模式

查看容器

# 列出本机运行的容器
$ docker ps 
# 列出本机所有的容器（包括停止和运行）
$ docker ps -a

停止容器

# 停止运行的容器
docker stop [容器ID]
# 杀死容器进程
docker  kill [容器ID]

重启容器

1	docker restart [容器ID]

删除容器

1	docker rm [容器ID]

进入容器

# 如果从这个 stdin 中 exit，会导致容器的停止
docker attach [容器ID]
# 交互式进入容器
docker exec [容器ID]

docker exec后面跟的常见参数如下：

－ d, –detach 在容器中后台执行命令
－ i, –interactive=true I false ：打开标准输入接受用户输入命令

发布

容器运行成功后，就确认了 image 文件的有效性。这时，我们就可以考虑把 image 文件分享到网上，让其他人使用。

去 hub.docker.com 或 cloud.docker.com注册一个账户

1	docker login

为本地的 image 标注用户名和版本

1	docker image tag koa-demos:0.0.1 ruanyf/koa-demos:0.0.1

最后，发布 image 文件。

1	docker image push [username]/[repository]:[tag]

Demo

从零开始来创建一个新的镜像：

FROM registry.cn-beijing.aliyuncs.com/selfdriveguard/ubuntu_20_sumo:1.14.1

COPY ./requirements.txt /oasis_sumo/requirements.txt

RUN sed -i 's/archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list
RUN apt-get update && apt-get install -y python3.8 python3-pip && apt-get install libgeos-dev --assume-yes
RUN python3.8 -m pip install -i https://mirrors.aliyun.com/pypi/simple pip -U && \
    python3.8 -m pip config set global.index-url https://mirrors.aliyun.com/pypi/simple && \
    python3.8 -m pip install --no-cache-dir --upgrade -I -r /oasis_sumo/requirements.txt
    python3.8 -m pip install eventlet==0.33.1

使用 Dockerfile 文件，通过 docker build 命令来构建一个镜像

1 2	# 作为基础镜像 # docker build -t oasis-sumo-base:v0.1 .

查看创建的镜像

1	docker images

已经在列表中存在,镜像ID为860c279d2fec 使用新的镜像来创建容器

1
2
3

docker run -it oasis-sumo-base:v0.1
# 或者
docker run -it 860c279d2fec

查看容器运行情况

docker ps

进入服务器docker查看日志，启动交互式的 bash shell

1	docker exec -it 860c279d2fec bash

镜像可以简单理解为自定义的运行环境，容器为实例化后的镜像，运行中的进程

2026-06-10T16:18:37.525Z

背景

自动驾驶算法的调试和效果评测首先要在仿真环境中去做，因此，一个强大、灵活的仿真环境是开发、测试过程中必不可少的要素。我在查找可用的仿真工具时主要关注以下几个特性：

开源，免费
包含高速场景
可以便捷的控制、切换场景的环境，场景、环境尽可能的丰富与真实
可以便捷的控制、切换场景内移动物体（如车辆、行人等）的行为模式，行为模式尽可能的丰富与真实

CARLA是一个主要由英特尔实验室和巴塞罗那的计算机视觉中心开发的开源项目。包含了自动驾驶系统的3种方法：

经典模块化方法，包含基于视觉的感知模块，基于规则的规划器，还有行为控制器。
端到端的模仿学习方法。
端到端的强化学习方法。

特点：

针对3D的城市场景（urban driving），开源免费，支持感知、规划、控制。
基于Unreal Engine 4，server-client结构。
可安装于Linux和Windows。
Python API，没有C++ API。

架构

Carla 是一个开源的模拟器，可以模拟真实的交通环境，行人行为，汽车传感器信号等等。如下图所示，模拟器使用C++ 和虚幻 (Unreal) 引擎构成，使用者可以通过 Python API 使用 Python 脚本代码对模拟器的环境进行操作和控制。

Carla主要分为Server与Client两个模块，Server端用来建立这个仿真世界，而Client端则是由用户控制，用来调整、变化这个仿真世界。

Server: Server端负责任何与仿真本身相关的事情：从3D渲染汽车、街道、建筑，传感器模型的构建，到物理计算等等。它就像一个造物主， 将整个世界建造出来，并且根据Client 的外来指令更新这个世界。它本身是基于UnrealEnigne做出的3D渲染。
Client: 如果server构造了整个世界，那么这个世界不同时刻到底该如何运转（比如天气是什么样，有多少辆车在跑，速度是多少）则是由Client端控制的。用户通过书写Python脚本（最新版本C++ 也可以）来向Server端输送指令指导世界的变化，Server根据用户的指令去执行。Client端也可以接受Server端的信息，譬如某个照相机拍到的路面图片。

核心模块

Traffic Manager: 自动驾驶之所以难搞，很核心的一个原因就是现实世界车太多了！因此，Carla专门构造了Traffic Manager这个模块来模拟类似现实世界负责的交通环境。通过这个模块，用户可以定义N多不同车型、不同行为模式、不同速度的车辆在路上愉快地与你的自动驾驶汽车（Ego-Vehicle）一起玩耍。
Sensors: Carla里面有各种各样模拟真实世界的传感器模型，包括相机、激光雷达、声波雷达、IMU、GNSS等等。为了让仿真更接近真实世界，它里面的相机拍出的照片甚至还有畸变和动态模糊效果。用户一般将这些Sensor attach到不同的车辆上来收集各种数据。
Recorder： 俗话说的好，不能复现的仿真不是好仿真。这个模块就是用来记录仿真每一个时刻（Step)的状态，可以用来回顾、复现等等。
ROS bridge： 这个模块可以让Carla与ROS还有Autoware交互，正是这个模块的存在使得在仿真里测试你的自动驾驶系统变得可能，十分重要，后面也会详细讲解。
Open Assest：这个模块可以允许你为仿真世界添加customized的物体库，比如你可以在默认的汽车蓝图里再加一个真实世界不存在、外形酷炫的小飞汽车，用来给Client端调用。

环境

创建城市环境的3个步骤：

排布道路和人行道
放置房子、绿植、地形、交通基础设施
指定动态物体可以出现的地点

传感器

有camera，分别提供RGB图像、深度信息和语义分割信息，语义包含物体的12种分类。

提供有GPS坐标、朝向、速度、加速度、碰撞等数据，以及交通规则评估数据，如行驶过的轨迹占据错误的车道比例等，还提供了所有动态物体的准确位置和bounding boxes。

经典模块

局部规划仅依赖于感知探测到的环境。内部有状态机：车道跟随，左转，右转，路口前进，停车。

PID控制。

感知的语义分割基于RefineNet。

判断是否处于路口基于AlexNet二分类。

特性

通过服务器多客户端体系结构实现的可扩展性：同一节点或不同节点中的多个客户端可以控制不同的参与者。
灵活的 API: CARLA 提供了一个强大的 API，允许用户控制与模拟相关的所有方面，包括交通生成、行人行为、天气、传感器等等。
自动驾驶传感器套件支持：用户可以配置各种传感器套件，包括激光雷达、多摄像头、深度传感器和GPS等。
规划和控制的快速模拟：此模式禁用渲染，以提供不需要图形的交通模拟和道路行为的快速执行。
地图创建功能：用户可以通过 RoadRunner等工具轻松创建自己的符合 OpenDrive 标准的地图。
交通场景仿真：Engine ScenarioRunner 工具允许用户基于模块化行为定义和执行不同的交通场景的仿真。
ROS集成：通过我们的ROS-bridge为Carla提供与ROS的集成。
自动驾驶基线 baselines：我们在CARLA中提供作为可运行代理的自动驾驶基线，包括AutoWare代理和条件模仿学习代理。

安装

ubuntu环境下安装流程：

基础软件安装

sudo apt-get update &&
sudo apt-get install wget software-properties-common &&
sudo add-apt-repository ppa:ubuntu-toolchain-r/test &&
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add - &&
sudo apt-add-repository "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main" &&
sudo apt-get update

Ubuntu 20.04:

sudo apt-add-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
sudo apt-get install build-essential clang-10 lld-10 g++-7 cmake ninja-build libvulkan1 python python-dev python3-dev python3-pip libpng-dev libtiff5-dev libjpeg-dev tzdata sed curl unzip autoconf libtool rsync libxml2-dev git
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/lib/llvm-10/bin/clang++ 180 &&
sudo update-alternatives --install /usr/bin/clang clang /usr/lib/llvm-10/bin/clang 180

安装Unreal Engine：

git clone --depth 1 -b carla https://github.com/CarlaUnreal/UnrealEngine.git ~/UnrealEngine_4.26
cd ~/UnrealEngine_4.26
./Setup.sh && ./GenerateProjectFiles.sh && make
cd ~/UnrealEngine_4.26/Engine/Binaries/Linux && ./UE4Editor

编译Carla：

1 2	git clone https://github.com/carla-simulator/carla ./Update.sh

设置UE环境变量，直接写文件 gedit ~/.bashrc

1	export UE4_ROOT=~/UnrealEngine_4.26

编译Carla客户端，可指定版本

1	make PythonAPI ARGS="--python-version=3.7, 3.8"

生成两种不同的文件 egg文件和whl文件，egg免安装，whl和系统有关

1	pip3 install .whl

编译Carla服务端，并启动：

1	make launch

点击Play或执行测试脚本：

cd PythonAPI/examples
python3 -m pip install -r requirements.txt
python3 generate_traffic.py  

# Terminal B
cd PythonAPI/examples
python3 dynamic_weather.py

使用

可以使用Python来实现一个客户端来跟Carla仿真环境进行交互，而在Carla Python库中，是以 carla.Client 类来实现的

1 2	client = carla.Client("localhost", 2000) client.set_timeout(10.0)

client对象是跟Carla环境交互的唯一的入口，有了client对象以后，我们就可以获取到Carla环境中的世界（World）了，World对象确确实实的代表Carla环境中的世界，你想要在世界中创建任何东西，都是往这个World对象中添加

1	world = client.load_world('Town02')

客户端获取到了World对象，并使用了Town02这张由Carla官方提供的内置地图，Carla还提供了其他一些地图，我们可以通过更改load_world的参数来加载不同的地图.

有了world对象以后，我们来直观感受下，我们可以做什么样的交互，比如我们想控制世界的天气和时间（太阳的位置）。

weather = carla.WeatherParameters(
    cloudiness=0.0,
    precipitation=0.0,
    sun_altitude_angle=50.0)
world.set_weather(weather)

使用carla.WeatherParameters创建了一种天气，万里无云，没有降雨，太阳的角度为50，也就是说是一个大晴天，然后通过世界的set_weather方法修改了世界的天气。

Actors：

Actors我们可以称之为演员，在Carla世界中任何可以通过客户端创建的物体都称为Actors（演员），包括：车辆，行人，传感器等等

Blueprints：

创建一个Actor需要知道这些信息，也就是类似于需要使用一个模板，这个东西在Carla中叫做蓝图，即Blueprints

Carla中已经内置了一个蓝图库，里边包含了许多不同的Actors，比如我们可以创建一台特斯拉的Model 3，我们也可以创建一台BWM，或者雪铁龙等等。

创建一个白色的特斯拉蓝图（模板）：

1	model3_bp = world.get_blueprint_library().find('vehicle.tesla.model3') model3_bp.set_attribute('color', '255,255,255')

world.get_blueprint_library()可以获取到Carla内置的蓝图库，通过find方法找到model 3，我们也可以使用filter方法然后给定模糊匹配的方法获取到多个蓝图，比如，可以用world.get_blueprint_library().filter(‘vehicle.bmw.*’)获取到所有BMW的车型蓝图。每一个蓝图都可以使用set_attribute更改自身的属性，这里我们将颜色设置成了白色。

Actor的生命周期：

一个Actor可以被生成（Spawning），使用（Handling），以及销毁（Destruction）。

生成：有了蓝图之后，意味着我们有了模板，然后就需要使用这个模板生成一个或者多个演员（Actor），这一过程叫做Spawning，因为Actor是在世界中存在的一个物体，因此在生成的时候，需要告诉环境它的出生点在哪里。
使用：当Actor生成以后，就可以通过客户端来控制它的一些行为，比如可以让车子跑起来，并控制它的油门和转向。
销毁：当我们不在需要一个Actor的时候可以选择销毁它，这样可以释放仿真环境的资源，让环境运行更顺畅。

使用world对象的spawn_actor或者try_spawn_actor方法就可以生成一个Actor，不过上边提到，在生成Actor的时候，需要告诉世界它的出生点在哪里，出生点在Carla中抽象为carla.Transform，

1	transform = Transform(Location(x=230, y=195, z=40), Rotation(yaw=180)) actor = world.spawn_actor(blueprint, transform)

物体在世界中是有体积的，所以有可能你指定的地点上已经有其他物体了，比如，该位置已经有台车子，或者该位置是一个建筑物，这种情况下，Actor被生成的时候就会出现碰撞，为了避免这个问题，Carla提供了一个接口可以获取到所有空的出生点，只要在这些空的出生点上生成Actor就不会出现碰撞的问题了

1	spawn_points = world.get_map().get_spawn_points() model3_spawn_point = np.random.choice(spawn_points) model3 = world.spawn_actor(model3_bp, model3_spawn_point)

Actor被生成以后，生成方法会范围被生成的Actor对象，我们可以使用该对象控制Actor的行为。比如，我们可以让刚刚生成的Model 3动起来，使用下边的代码，让它按照交通规则在世界中行驶。

1	model3.set_autopilot(True)

还可以主动的把车挪动位置

1
2
3

location = model3.get_location() 
location.x += 10.0 
model3.set_location(location)

不同的Actor类型，可以控制的参数也不一样

不在需要某个Actor的时候，可以将其销毁，释放计算资源

1	destroyed_sucessfully = actor.destroy()

传感器 Sensors：

Sensor是一种特殊的Actor，它的蓝图也是可以在蓝图库里边找到的，目前Carla已经支持了很多传感器，比如

摄像头： Depth， RGB ， Semantic segmentation
探测器： Collision ， Lane invasion ， Obstacle
其他： GNSS ， IMU ， LIDAR raycast ， Radar

传感器跟其他的Actor最大的不同是，它们需要被安装在车上，因此在生成传感器的时候，需要将其附着到一个车辆类型的Actor上，而出生点是针对于这台车本身的坐标系给定的

1
2
3

camera_bp = world.get_blueprint_library().find('sensor.camera.rgb') 
camera = world.spawn_actor(camera_bp,                         carla.Transform(carla.Location(x=-5.5, z=2.5), carla.Rotation(pitch=8.0)), model3, carla.AttachmentType.SpringArm ) 
camera.listen(lambda image:image.save_to_disk('output/%06d.png' % image.frame)

首先从蓝图库中找到RGB摄像头模板，然后利用这个蓝图生成摄像头Actor，并将其附着到前边生成好的Model 3上，我们选择了摄像头附着类型为：carla.AttachmentType.SpringArm，并将其位置设置到后方，这样我们就可以像从一个第三者的角度排到行驶的车辆了。

每一个传感器都有一个listen方法，该方法接收一个callback作为参数，我们可以自定义callback里边的逻辑，callback将会在传感器拿到数据后被调用，并能够获取到这些数据。

观察者 spectator：

使用Python脚本生成了一台Model3 ，并让它行驶在路上，我们的Python脚本并没有能力输出视频，我们怎么来确认我们的 Model 3已经被创建，并在路上行驶呢

Carla给我们提供了一个所谓的观察者 Spectator，你可以将其理解为Carla环境的视角，我们可以通过修改观察者的参数，切换Carla环境的视角。

while running:
    spectator = world.get_spectator()
    transform = model3.get_transform()
    spectator.set_transform(carla.Transform(transform.location + carla.Location(z=50),
    carla.Rotation(pitch=-90)))
    time.sleep(5)

上边这段代码，将观察者的位置到我们的Model 3的正上方（z轴），并将视角调为-90度，即向下看，每隔5s中跟着Model 3的位置重置一下观察者的位置，这样就可以在Model 3的正上方追踪并观察这台车了。

这个项目最后会得到两个输出

我们设置了观察值来实时追踪Model 3的行驶，因此在Carla环境中可以看到车子在行驶
我们在摄像头的callback中添加了保存摄像头采集到的照片到output文件夹的动作，因此我们会在output文件夹中看到很多摄像头采集回来的照片

2026-06-10T16:18:36.437Z

项目

虚幻引擎项目（Project）保存着构成游戏所需的所有内容和代码。项目在你的电脑硬盘上由许多目录构成，例如蓝图和材质。你可以随时修改项目目录的名称和层级关系。

虚幻编辑器中的内容浏览器所展示的目录结构和你在硬盘上看到的项目目录结构相同。

每个项目都有一个与之对应的 .uproject 文件。.uproject 文件是你创建、打开或保存项目必须用到的文件。你可以创建任何数量的不同项目，并同时操作它们。

对象

在虚幻引擎中，最基本的类叫做 Object。换句话说，它就像最基本的构建单位，包含了资产的基本功能。虚幻引擎中的大多数类都继承自Object（或从中获取部分功能）。

在C++中，UObject 是所有Object的基类，包含各类功能，诸如垃圾回收、通过元数据（UProperty）将变量公开给编辑器，以及保存和加载时的序列化功能。

类

类（Class）用于定义虚幻引擎中Actor或对象的行为和属性。类可以被继承，这意味着某个类可以从其父类（衍生或派生出该类的类）获得信息，然后再将信息传递给子类。类可用C++代码或蓝图创建。

蓝图

蓝图可视化脚本（Blueprint Visual Scripting）系统（或缩写蓝图（Blueprints））是一种功能齐全的游戏脚本系统，它允许你在虚幻编辑器（Unreal Editor）中通过基于节点的界面来创建游戏元素。和许多常见脚本语言一样，你可以用它在引擎中定义面向对象的类或object。在使用UE4时，你会发现使用蓝图定义的类一般也统称蓝图。

Actor

所有可以放入关卡的对象都是 Actor，比如摄像机、静态网格体、玩家起始位置。Actor支持三维变换，例如平移、旋转和缩放。你可以通过游戏逻辑代码（C++或蓝图）创建（生成）或销毁Actor。

个人理解：关卡中各种抽象出来的组件（不限于实体，比如”玩家起始位置”）的基类

Pawn

Pawn是Actor的子类，它可以充当游戏中的化身或人物（例如游戏中的角色）。Pawn可以由玩家控制，也可以由游戏AI控制并以非玩家角色（NPC）的形式存在于游戏中。

当Pawn被人类玩家或AI玩家控制时，它被视为已被控制（Possessed）。相反，当Pawn未被人类玩家或AI玩家控制时，它被视为未被控制（Unpossessed）。

角色

角色（Character）是Pawn Actor的子类，旨在用作玩家角色。角色子类包括碰撞设置、双足运动的输入绑定，以及用于控制运动的附加代码。

组件

组件（Component）是可以添加到Actor上的一项功能。

当你为Actor添加组件后，该Actor便获得了该组件所提供的功能。例如：

聚光灯组件（Spot Light Component）允许你的Actor像聚光灯一样发光，
旋转移动组件（Rotating Movement Component）能使你的Actor四处旋转，
音频组件（Audio Component）将使你的Actor能够播放声音。

组件必须绑定在Actor身上，它们无法单独存在。

世界

世界场景（World）是一个容器，包含了游戏中的所有关卡。它可以处理关卡流送，还能生成（创建）动态Actor。

玩家控制器

玩家控制器（Player Controller）会获取游戏中玩家的输入信息，然后转换为交互效果，每个游戏中至少有一个玩家控制器。玩家控制器通常会控制一个Pawn或角色，将其作为玩家在游戏中的化身。

AI控制器

玩家控制器通过控制Pawn来表示游戏中的玩家，与此类似，AI控制器通过控制Pawn来表示游戏中的非玩家角色（NPC）。默认情况下，Pawn和角色最终都会由基本的AI控制器控制，除非它们被指定通过玩家控制器控制，或被告知不需要为它们自己创建AI控制器。

关联的C++类是 AIController

https://zhuanlan.zhihu.com/p/27448628

https://zhuanlan.zhihu.com/p/535829374

https://blog.csdn.net/brzzuibang/article/details/105823494

https://docs.unrealengine.com/4.27/zh-CN/InteractiveExperiences/Vehicles/VehicleUserGuide/

transform = carla.Transform(transform.location + carla.Location(0, 0, SPAWN_OFFSET_Z),
                                    transform.rotation)
        batch = []
        actor = carla.command.SpawnActor(blueprint, transform)
        try:
            if number_of_wheels == 4:
                # 车
                control = carla.VehicleControl()
                control.throttle = 23
                print("11111")
                print(type(actor))
                actor.apply_control(control)
        except Exception as e:
            print(e)
        batch.append(actor)
        # blueprint.
        batch.append(carla.command.SetSimulatePhysics(carla.command.FutureActor, False))

        response = self.client.apply_batch_sync(batch, False)[0]
        if response.error:
            logging.error('Spawn carla actor failed. %s', response.error)
            return INVALID_ACTOR_ID
        #

if number_of_wheels == 4:
    # 车
    control = carla.VehicleControl()
    control.throttle = 23
    vehicle.apply_control(control)
elif number_of_wheels == 2:
    control = carla.VehicleControl()
    control.throttle = 2
    vehicle.apply_control(control)

GetAnimInstance
check(VehicleAnim->GetWheeledVehicleMovementComponent() != nullptr)

  void ACarlaWheeledVehicle::SetSimulatePhysics(bool enabled) {
  if(!GetCarlaMovementComponent())
  {
    return;
  }

  UWheeledVehicleMovementComponent4W *Vehicle4W = Cast(
      GetVehicleMovement());
  check(Vehicle4W != nullptr);

  if(bPhysicsEnabled == enabled)
    return;

  SetActorEnableCollision(true);
  auto RootComponent = Cast(GetRootComponent());
  RootComponent->SetSimulatePhysics(enabled);
  RootComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);

  UVehicleAnimInstance *VehicleAnim = Cast(GetMesh()->GetAnimInstance());
  check(VehicleAnim != nullptr)

  GetWorld()->GetPhysicsScene()->GetPxScene()->lockWrite();
  if (enabled)
  {
    Vehicle4W->RecreatePhysicsState();
    VehicleAnim->ResetWheelCustomRotations();
  }
  else
  {
    Vehicle4W->DestroyPhysicsState();
  }

  GetWorld()->GetPhysicsScene()->GetPxScene()->unlockWrite();

  bPhysicsEnabled = enabled;

  ResetConstraints();

}



VehicleAnimInstance

carla里面新增一辆车

https://carla.readthedocs.io/en/latest/tuto_A_add_vehicle/

https://docs.unrealengine.com/4.27/zh-CN/InteractiveExperiences/Vehicles/VehicleUserGuide/

https://blog.csdn.net/qq_44905590/article/details/103034017

2026-06-10T16:18:36.419Z

SUMO ( Simulation of Urban Mobility) 是免费、开源的交通系统仿真软件，可以实现交通流的微观控制，即具体到道路上每一辆车的运行路线都可以单独规划。可模拟复杂环境中的交通流。

sumo中一个路网文件，分为路网net文件和交通需求（路径）route文件。net文件由node文件和edge文件组成。其中node表示节点，如一个交叉口。

节点文件 node file (.nod.xml)
连边文件 edge file (.edg.xml)
类型文件 edge type file (.type.xml)
基于上述三个文件创建路网文件 net file (.net.xml)
路由文件 route file (.rou.xml)

上述文件本质上都是 xml 文件，不过为了方便区分其作用，额外增加了一个后缀名。

假设我们要创建如下图所示的小型道路网络：

图中黑色节点对应交通路口，连边对应道路。每个路口所在位置坐标已给出。

node file

<nodes>
 <node id="n1" x="-500" y="0" type="priority"/>   
 <node id="n2" x="-250" y="0" type="traffic_light"/>
 <node id="n3" x="-150" y="200" type="traffic_light"/>
 <node id="n4" x="0" y="0"/>
 <node id="n5" x="150" y="200"/>
nodes>

edge file

<edges>
 <edge from="n1" to="n2" id="1to2" type="3L45"/>
 <edge from="n2" to="n3" id="2to3" type="2L15"/>
 <edge from="n3" to="n4" id="3to4" type="3L30"/>
 <edge from="n4" to="n5" id="out" type="3L30"/>
edges>

type file

<types>
 <type id="3L45" priority="3" numLanes="3" speed="45"/>
 <type id="2L15" priority="3" numLanes="2" speed="15"/>
 <type id="3L30" priority="2" numLanes="3" speed="30"/>
types>

基于以上三个文件，可以通过命令 netconvert 创建 net 文件，命令如下：

1	netconvert --node-files my_nodes.nod.xml --edge-files my_edge.edg.xml -t my_type.type.xml -o my_net.net.xml

route file

<routes>
   <route id="route0" edges="1to2 2to3"/>  # edges 中的基本格式为"edge1 edge2 edge3 ..."
   <route id="route1" edges="2to3 3to4"/>
   <route id="route2" edges="3to4 out"/>

   <vType accel="1.0" decel="5.0" id="Car" length="2.0" maxSpeed="100.0" sigma="0.0"/>
   <vType accel="1.0" decel="5.0" id="Bus" length="12.0" maxSpeed="1.0" sigma="0.0"/> #sigma随机程度，0 为无随机

   <vehicle id="veh0" depart="10" route="route0" type="Bus"/>
   <vehicle id="veh1" depart="10" route="route1" type="Car"/>
   <vehicle id="veh2" depart="30" route="route2" type="Car"/>
routes>

运行程序时需要送入一些参数，可以通过命令行形式送入，如果参数太多、太长，为了方便起见，可以将参数统一放到 xml config 文件中，在运行时，可以调用这个 config 文件。

定义 my_config_file.sumocfg

<configuration>
   <input>
     <net-file value="my_net.net.xml"/>
     <route-files value="my_route.rou.xml"/>
   input>
   <time>
     <begin value="0"/>
     <end value="2000"/>
   time>
configuration>

如果一个参数既出现在了 config 文件中，又在 command line 中，则采用 command line 的设置。

一切准备就绪，下边运行程序

1	sumo-gui my_config_file.sumocfg

然后将工具栏中的 Delay 设置为 100 ms，否则仿真开始之后瞬间结束。

在手动构造路网 net.xml 文件时，我们也可以用 SUMO 自带的 NETEDIT 程序，通过 NETEDIT GUI 编辑路网，可能效率更高一些

上述手动设置路网的方式只适用于比较简单的情况，如果要构造与现实世界比较接近的大型路网，我们可以用下边的从外部导入 OSM （Open Street Map）路网的方法。通过搜索城市、街道找到目标道路网，然后 export 即可。

转化成 SUMO 路网文件

1	netconvert --osm-files map.osm -o sjtu.net.xml

以上就得到了 .net.xml 文件，这里不是通过基于 node, edge, type 文件的整合，而是直接从 osm 地图转化过来。下边就是如何得到 route 文件。

对于这种大型的路网，手动创建 route 文件也很麻烦，这里我们用 SUMO 自带的 randomTrips.py 程序创建随机的 route 文件。

1	python <path_to_randomTrips.py> -n sjtu.net.xml -r sjtu.rou.xml -e 50 -l # -e 表示 end time

最后汇总sjtu.sumocfg

<configuration>
 <input>
 <net-file value="sjtu.net.xml"/>
 <route-files value="sjtu.rou.xml"/>
 input>
 <time>
 <begin value="0"/>
 <end value="2000"/>
 time>
configuration>

运行仿真，局部放大：

上边导入 osm 地图的方法还是比较麻烦，它主要包括 4 步：

从 osm 网站获取 osm 地图
用 netconvert 将 osm 地图转化成 SUMO 的 .net.xml 格式地图
用 randomTrip.py 生成随机 route 文件
开启仿真

实际上，SUMO 自带了一个 osmWebWizard.py 程序，整合了上述较为独立的步骤，在同一个操作界面，“一站式” 完成上述步骤。

用 osmWebWizard.py 运行仿真也是 SUMO tutorial 中的第一个项目。

1	python osmWebWizard.py

没有问题的话，应该会在浏览器中打开如下页面。这里初始地图位置是 Berlin。

首先是选定要仿真的地图环境。可以缩放、移动视图，通过右侧的 Select Area 可以选定一个区域。最好不要选择太大范围，否则仿真很占资源，甚至导致死机。

以上就设定好了地图和 route，点击右上方的 Generate Scenario，就可以进入仿真界面了。

安装

安装XQuartz ，启动sumo-gui和netedit需要

brew install --cask xquartz 
# 安装sumo
brew tap dlr-ts/sumo
brew install sumo
# 更改变量环境
touch ~/.bashrc; open ~/.bashrc
# 在最后一行添加，其中安装路径会在安装后的终端显示。
export SUMO_HOME=/your/path/to/sumo
# 测试变量环境 重启终端，并输入
echo $SUMO_HOME
# 安装一些mac下的应用包
brew install --cask sumo-gui
# 在下载页面下载SUMO launchers
# 终端启动XQuartz 或sumo-gui

Traci接口

Traci接口是用来和sumo模拟器通信的, 因为不可能总是在sumo-gui里点图形化界面, 肯定得通过python, java之类的语言来和sumo通信, 靠的就是traci接口。

import os
import sys
import traci
import random


def init_sumo(sumoBinary, sumocfg):
    if 'SUMO_HOME' in os.environ:
        tools = os.path.join(os.environ['SUMO_HOME'], 'tools')
        sys.path.append(tools)
        sumoCmd = [sumoBinary, "-c", sumocfg, "--tripinfo-output", "tripinfo.xml"]
        return sumoCmd
    else:
        sys.exit("please declare environment variable 'SUMO_HOME'")


def generate_routefile():
    random.seed(42)  # make tests reproducible
    N = 3600  # number of time steps
    # demand per second from different directions
    pWE = 1. / 10
    pEW = 1. / 11
    pNS = 1. / 30
    with open("data/cross.rou.xml", "w") as routes:
        print("""
        
guiShape="passenger"/>
        

        
        
        """, file=routes)
        vehNr = 0
        for i in range(N):
            if random.uniform(0, 1) < pWE:
                print('    ' % (
                    vehNr, i), file=routes)
                vehNr += 1
            if random.uniform(0, 1) < pEW:
                print('    ' % (
                    vehNr, i), file=routes)
                vehNr += 1
            if random.uniform(0, 1) < pNS:
                print('    ' % (
                    vehNr, i), file=routes)
                vehNr += 1
        print("", file=routes)


if __name__ == '__main__':
    sumoCmd = init_sumo("sumo-gui", os.getcwd()+"/data/cross.sumocfg")
    generate_routefile()

    traci.start(sumoCmd)
    step = 0
    # we start with phase 2 where EW has green
    traci.trafficlight.setPhase("0", 2)
    while traci.simulation.getMinExpectedNumber() > 0:
        traci.simulationStep()
        if traci.trafficlight.getPhase("0") == 2:
            # we are not already switching
            if traci.inductionloop.getLastStepVehicleNumber("0") > 0:
                # there is a vehicle from the north, switch
                traci.trafficlight.setPhase("0", 3)
            else:
                # otherwise try to keep green for EW
                traci.trafficlight.setPhase("0", 2)
        step += 1
    traci.close()

动力学模型

SUMO 中车辆动力学模型包括两方面

longitudinal model：纵向动力学模型，描述车辆加速和减速
lateral model：横向动力学模型，描述车辆换道

纵向动力学模型方面，SUMO 主要用于研究车辆的外部行为、多车交互和交通流，对于单个车辆建模精度要求不高，可以近似看作质点。采用比较简单的 car-following model (跟车模型) 来描述车辆速度和位置变化规律。跟车模型分为两种情况：有前车和无前车。

无前车的情形，车辆保持为最大速度，这里最大速度要至少考虑三方面的因素。三个最大速度中的最小值：

该类型车辆本身能够达到的最大物理速度
前一时刻速度经过最大加速之后在当前时刻所能达到的最大速度
当前行驶道路规定的最大速度

有前车的情形，要计算安全的行驶速度，保证任何情况下（尤其是前车急刹车时）车辆不会相撞。不同的跟车模型主要区别就在于如何计算安全行驶速度。目前 SUMO 中采用的为改进的 Krauss model.

横向动力学模型方面，SUMO采用lane changing model变道模型，简单地说就是以决策树的方式设定诸多换道条件，只要满足某些条件，就进行相应的换道操作。默认的 lane changing model 是瞬间换道，即在一个 simulation step 中完成换道，直观地看就是车辆在两个车道之间瞬移。更加精细的模型包括SublaneModel和Simple Continous lane-change model。

Krauss model

了解一下原始的 Krauss model 的建模思想。

泰勒展开近似替代后，得到估算值：

double MSCFModel_KraussOrig1::vsafe(double gap, double predSpeed, double /* predMaxDecel */) const {
    ...
     double vsafe = (double)(-1. * myTauDecel + sqrt( myTauDecel * myTauDecel + (predSpeed * predSpeed) + (2. * myDecel * gap) ));
     assert(vsafe >= 0);
     return vsafe;
 }

这一速度还不是最终车辆采用的跟车速度。与无前车情况类似，我们也要保证跟车速度不能超过允许的最大速度，因此要取安全速度和允许最大速度中的较小值.

改进模型与原始的 Krauss 模型的出发点是相同的：在保证不碰撞的前提下，车速尽量的快。但在计算安全速度方面，与原始 Krauss 完全不同.

没有采用泰勒展开方式近似表达刹车距离函数，而是直接数值计算。基本思想是找到一个安全跟车速度使得后车在此速度下刹车距离 (包括反应距离) 正好等于前车的刹车距离加上原本两车间距。

lane changing model

道路车辆微观驾驶动力学是由以下几种模型的相互作用决定的：

跟驰模型：根据前车的行为决定自身的速度。
交叉口通行模型：从通行权规则、间隙接受、避免路口堵塞等方面确定车辆在不同类型交叉口的行为。
换道模型：决定在多车道道路的车道选择和换道时的速度调整。

相比于其他的微观换道模型，该模型明确区分了四种不同的换道动机：

Strategic change 战略变道：每当车辆必须换道以便于能够驶向其行驶路径的下一条道路。
Cooperative change 协同变道：帮助另一辆车辆换道到他们所在的车道
Tactical change 战术变道：车辆试图避免跟随缓慢前车的动作，平衡从换车道中获得的预期速度收益和换车道的努力
Obligatory change 义务变道：清除超车车道的强迫行为可以被定义为义务行为

汽车变道规划的四个子步骤：

计算优选后继车道；
在保持当前车道的假设下，计算安全速度，并整合来自先前模拟步骤的车道变换相关速度请求；
车道变换模型计算变更请求（左，右，停留）；
执行换道操作或计算下一个模拟步骤的速度请求（包括提前计划多个步骤）。是否请求速度变化取决于变道请求的紧急程度；

评估子线路的标准：

bestLanes（不需要换道）
occupation（沿着最优道路的车辆密度）
bestLaneOffset（车道偏移量）

评估换道行为的紧急程度：

探究vechicle 与blocking vehicle的关系，并根据两者之间的关系来相应地改变行为：

每当由于阻挡车辆而不能执行期望的车道变换时，车辆可以调整其速度以允许车道变换在后续步骤中成功。此外，车辆可能对阻挡车辆的速度产生影响（实际上，这通常作为对观察自我车辆的转向信号的反应而发生）。

避免死锁：两车由于一些原因，同时到达道路的终点，此时两车都希望可以实现换道，这种情况便发生了死锁（deadlock）。

为了避免这种情况，对车进行分类（更靠近道路终点的称为blocking leader，另一个称为the blocking follower)。后者要预先进行减速，以为前车留出足够的距离进行变道操作。尽管采取这种操作，死锁仍然可能无法避免，因为会存在多车道的情况。因此，采用的方法是预留出20~40m范围进行变道。

2026-06-10T16:18:36.418Z

Ray

Ray是一个用于并行和分布式 Python 的开源项目，当我们将应用程序迁移到分布式设置时，传统编程概念会发生变化。比如用于模型培训的 TensorFlow、用于数据处理和 SQL 的 Spark 以及用于流处理的 Flink。这些工具提供更高层次的抽象，如神经网络、数据集和流。但是，由于它们与串行编程所使用的抽象不同，因此必须重新编写应用程序以利用它们。

Ray占据了一个独特的中间地带。而不是引入新的概念。Ray 获取函数和类的现有概念，并将它们作为任务和参与者转换为分布式设置。这种 API 选择允许串行应用程序并行化，而不需要进行重大修改。

Ray 可以用来在多个核心或机器上扩展 Python 应用。它有几个主要的优点，包括：

简单性：你可以扩展你的 Python 应用，而不需要重写，同样的代码可以在一台机器或多台机器上运行。
稳健性：应用程序可以优雅地处理机器故障和进程抢占。
性能：任务以毫秒级的延迟运行，可扩展到数万个内核，并以最小的序列化开销处理数值数据。

作为分布式计算系统，Ray仍旧遵循了典型的Master-Slave的设计：Master负责全局协调和状态维护，Slave执行分布式计算任务。不过和传统的分布式计算系统不同的是，Ray使用了混合任务调度的思路。

GlobalScheduler：Master上启动了一个全局调度器，用于接收本地调度器提交的任务，并将任务分发给合适的本地任务调度器执行。
RedisServer：Master上启动了一到多个RedisServer用于保存分布式任务的状态信息（ControlState），包括对象机器的映射、任务描述、任务debug信息等。
LocalScheduler：每个Slave上启动了一个本地调度器，用于提交任务到全局调度器，以及分配任务给当前机器的Worker进程。
Worker：每个Slave上可以启动多个Worker进程执行分布式任务，并将计算结果存储到ObjectStore。
ObjectStore：每个Slave上启动了一个ObjectStore存储只读数据对象，Worker可以通过共享内存的方式访问这些对象数据，这样可以有效地减少内存拷贝和对象序列化成本。ObjectStore底层由Apache Arrow实现。
Plasma：每个Slave上的ObjectStore都由一个名为Plasma的对象管理器进行管理，它可以在Worker访问本地ObjectStore上不存在的远程数据对象时，主动拉取其它Slave上的对象数据到当前机器

Ray的任务也是通过类似Spark中Driver的概念的方式进行提交的，有所不同的是：

Spark的Driver提交的是任务DAG，一旦提交则不可更改。
而Ray提交的是更细粒度的remote function，任务DAG依赖关系由函数依赖关系自由定制。

安装

1 2	pip install --upgrade pip pip install ray == 1.6.0

使用

1、ray.init() ,类似sparkSession

1 2	import ray ray.init()

如果是直连已有的Ray集群，只需要指定RedisServer的地址即可。

1	ray.init(redis_address="")

本地启动Ray时，可以看到Ray的WebUI的访问地址

2、ray.put()，类似Spark RDD并行化

使用ray.put()可以将Python对象存入本地ObjectStore，并且异步返回一个唯一的ObjectID。通过该ID，Ray可以访问集群中任一个节点上的对象

@ray.remote
def f(x):
    pass
 
x = "hello"
 
# 对象x往ObjectStore拷贝里10次
[f.remote(x) for _ in range(10)]
 
# 对象x仅往ObjectStore拷贝1次
x_id = ray.put(x)
[f.remote(x_id) for _ in range(10)]

3、ray.get()

使用ray.get()可以通过ObjectID获取ObjectStore内的对象并将之转换为Python对象。对于数组类型的对象，Ray使用共享内存机制减少数据的拷贝成本。而对于其它对象则需要将数据从ObjectStore拷贝到进程的堆内存中。

如果调用ray.get()操作时，对象尚未创建好，则get操作会阻塞，直到对象创建完成后返回。get操作的关键流程如下：

Driver或者Worker进程首先到ObjectStore内请求ObjectID对应的对象数据。
如果本地ObjectStore没有对应的对象数据，本地对象管理器Plasma会检查Master上的对象表查看对象是否存储其它节点的ObjectStore。
如果对象数据在其它节点的ObjectStore内，Plasma会发送网络请求将对象数据拉到本地ObjectStore。
如果对象数据还没有创建好，Master会在对象创建完成后通知请求的Plasma读取。
如果对象数据已经被所有的ObjectStore移除（被LRU策略删除），本地调度器会根据任务血缘关系执行对象的重新创建工作。
一旦对象数据在本地ObjectStore可用，Driver或者Worker进程会通过共享内存的方式直接将对象内存区域映射到自己的进程地址空间中，并反序列化为Python对象。

ray.get()可以一次性读取多个对象的数据

1 2	result_ids = [ray.put(i) for i in range(10)] ray.get(result_ids) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4、@ray.remote

Ray中使用注解@ray.remote可以声明一个remote function。remote函数时Ray的基本任务调度单元，remote函数定义后会立即被序列化存储到RedisServer中，并且分配了一个唯一的ID，这样就保证了集群的所有节点都可以看到这个函数的定义。这样对remote函数定义有了一个潜在的要求，即remote函数内如果调用了其它的用户函数，则必须提前定义，否则remote函数无法找到对应的函数定义内容。

调用remote函数的关键流程如下：

调用remote函数时，首先会创建一个任务对象，它包含了函数的ID、参数的ID或者值（Python的基本对象直接传值，复杂对象会先通过ray.put()操作存入ObjectStore然后返回ObjectID）、函数返回值对象的ID。
任务对象被发送到本地调度器。
本地调度器决定任务对象是在本地调度还是发送给全局调度器。如果任务对象的依赖（参数）在本地的ObejctStore已经存在且本地的CPU和GPU计算资源充足，那么本地调度器将任务分配给本地的WorkerProcess执行。否则，任务对象被发送给全局调度器并存储到任务表（TaskTable）中，全局调度器根据当前的任务状态信息决定将任务发给集群中的某一个本地调度器。
本地调度器收到任务对象后（来自本地的任务或者全局调度分配的任务），会将其放入一个任务队列中，等待计算资源和本地依赖满足后分配给WorkerProcess执行。
Worker收到任务对象后执行该任务，并将函数返回值存入ObjectStore，并更新Master的对象表（ObjectTable）信息。

@ray.remote注解有一个参数num_return_vals用于声明remote函数的返回值个数，基于此实现remote函数的多返回值机制

@ray.remote(num_return_vals=2)
def f():
    return 1, 2
 
x_id, y_id = f.remote()
ray.get(x_id)  # 1
ray.get(y_id)  # 2

@ray.remote注解的另一个参数num_gpus可以为任务指定GPU的资源

1
2
3

@ray.remote(num_gpus=1)
def gpu_method():
    return "This function is allowed to use GPUs {}.".format(ray.get_gpu_ids())

5、ray.wait()

ray.wait()操作支持批量的任务等待，基于此可以实现一次性获取多个ObjectID对应的数据。

# 启动5个remote函数调用任务
results = [f.remote(i) for i in range(5)]
# 阻塞等待4个任务完成，超时时间为2.5s
ready_ids, remaining_ids = ray.wait(results, num_returns=4, timeout=2500)

上述例子中，results包含了5个ObjectID，使用ray.wait操作可以一直等待有4个任务完成后返回，并将完成的数据对象放在第一个list类型返回值内，未完成的ObjectID放在第二个list返回值内。如果设置了超时时间，那么在超时时间结束后仍未等到预期的返回值个数，则已超时完成时的返回值为准。

6、ray.error_info()

使用ray.error_info()可以获取任务执行时产生的错误信息。

7、Actor

Ray的remote函数只能处理无状态的计算需求，有状态的计算需求需要使用Ray的Actor实现。在Python的class定义前使用@ray.remote可以声明Actor。

@ray.remote
class Counter(object):
    def __init__(self):
        self.value = 0
 
    def increment(self):
        self.value += 1
        return self.value

使用如下方式创建Actor对象。

1 2	a1 = Counter.remote() a2 = Counter.remote()

调用Actor对象的方法使用Actor

1 2	a1.increment.remote() # ray.get returns 1 a2.increment.remote() # ray.get returns 1

调用Actor对象的方法的流程为：

首先创建一个任务。
该任务被Driver直接分配到创建该Actor对应的本地执行器执行，这个操作绕开了全局调度器（Worker是否也可以使用Actor直接分配任务尚存疑问）。
返回Actor方法调用结果的ObjectID。

为了保证Actor状态的一致性，对同一个Actor的方法调用是串行执行的。

RLlib

RLlib是一个用于强化学习的开源库，它为各种应用程序提供了高可伸缩性(Scalable Reinforcement Learning)和统一API。RLlib本身支持TensorFlow、TensorFlow Eager和PyTorch，但它的大多数内部内容是框架无关的。RLlib之于Ray就如同MLlib之于Spark：

1
2
3

from ray importtune
from ray.rllib.agents.ppo importPPOTrainer
tune.run(PPOTrainer, config={"env": "CartPole-v0"})  #"log_level": "INFO" for verbose,

上面三行代码就可以训练一个玩平衡杆游戏的智能体

最底层的分布式计算任务是由Ray引擎支撑的。倒数第二层表明RLlib是对特定的强化学习任务进行的抽象。第二层表示面向开发者，我们可以自定义算法。最顶层是RLlib对一些应用的支持，比如：可以让智能体在离线的数据、Gym或者Unit3d的环境中进行交互等等

Policies,策略是RLlib中的核心概念.policies是定义agent 如何在环境中工作的Python类. Rollout workers查询策略以确定agent 的动作。在gym 中，只有一个agent 和policy。在vector envs中，策略推理是针对多个代理的，在多代理中，可能有多个策略，每个策略控制一个或多个代理:

Training 每个策略都定义了一个learn_on_batch()方法，该方法根据输入的样例批处理改进策略。对于TF和Torch策略，这是使用一个损失函数来实现的，该函数以样本批张量作为输入，并输出一个标量损失。

RLlib Trainer类协调分布式工作流（启动rollouts worker和策略优化）。它们利用Ray并行迭代器来实现所需的计算模式。下面的图显示了同步采样，这是这些模式中最简单的:

Trainer将数据广播给所有Workers，由他们与环境交互产生数据，经过抽样的方式返回Trainer进行训练。

RLlib使用Ray actor将训练从单个核扩展到集群中的数千个核。可以通过更改num_workers参数来配置用于培训的并行性。

RLlib几乎提供了自定义训练过程中所有方面的方法，包括环境(environment、神经网络模型(neural network model)、行动分布(action distribution)和策略定义(policy definitions):

超参数搜索库 Tune：

Ray Tune是一个用来实验执行和超参数调优的Python包，其中集成了网格搜索、随机搜索、贝叶斯优化搜索（BayesOptSearch）等搜索算法以及Optuna, Hyperopt等优化工具。Ray Tune调参的模型可以是基于PyTorch, XGBoost, TensorFlow或Keras等框架构建的模型。

安装

1	pip install 'ray[tune]'

使用tune，搜索lr的最佳超参值：

import torch.optim as optim
from ray import tune
from ray.tune.examples.mnist_pytorch import get_data_loaders, ConvNet, train, test


def train_mnist(config):
    train_loader, test_loader = get_data_loaders()
    model = ConvNet()
    optimizer = optim.SGD(model.parameters(), lr=config["lr"])
    for i in range(30):
        train(model, optimizer, train_loader)
        acc = test(model, test_loader)
        tune.track.log(mean_accuracy=acc)  # 添加的代码

# 添加如下代码
analysis = tune.run(
    train_mnist,
    num_samples=10,
    # Uncomment this to let each evaluation use 1 GPU
    # resources_per_trial={"CPU": 1, "GPU": 1},
    config={"lr": tune.grid_search([0.001, 0.01, 0.1])})

print("Best config: ", analysis.get_best_config(metric="mean_accuracy"))

# 获取结果的 dataframe
df = analysis.dataframe()

https://github.com/IntelLabs/coach
https://github.com/cjy1992/gym-carla
https://github.com/LovelyBuggies/sumo-gym
https://github.com/SaloniDash7/gym-sumo

https://github.com/LucasAlegre/sumo-rl


pip install git+https://github.com/DLR-RM/stable-baselines3@feat/gymnasium-support
pip install git+https://github.com/Stable-Baselines-Team/stable-baselines3-contrib@feat/gymnasium-support

pip install git+https://github.com/DLR-RM/stable-baselines3@feat/gymnasium-support
pip install git+https://github.com/Stable-Baselines-Team/stable-baselines3-contrib@feat/gymnasium-support


import gym
import matplotlib.pyplot as plt
import numpy as np
from gym import spaces
from imitation.algorithms.adversarial.gail import GAIL
from imitation.data import rollout
from imitation.data.types import Transitions
from imitation.data.wrappers import RolloutInfoWrapper
from imitation.rewards.reward_nets import BasicRewardNet
from imitation.util import logger as imit_logger
from imitation.util.networks import RunningNorm
from stable_baselines3 import PPO  # DQN coming soon
from stable_baselines3.common.env_checker import check_env
from stable_baselines3.common.env_util import make_vec_env
from stable_baselines3.common.evaluation import evaluate_policy
from stable_baselines3.common.vec_env import DummyVecEnv
from stable_baselines3.ppo import MlpPolicy
import torch as th

log_dir = "./tensorboard/Custom-Env"


class CustomEnv(gym.Env):

    def __init__(self, max_steps=8):
        super().__init__()
        self.observation_space = spaces.Box(low=-1, high=1, shape=(2,), dtype=np.float32)
        self.action_space = spaces.Box(low=-1, high=1, shape=(2,), dtype=np.float32)
        self.max_steps = max_steps
        self.n_steps = 0

    def reset(self):
        self.n_steps = 0
        return self.observation_space.sample()

    def step(self, action):
        self.n_steps += 1

        done = False
        reward = 0.0
        if self.n_steps >= self.max_steps:
            reward = 1.0
            done = True

        return self.observation_space.sample(), reward, done, {}

# 加载专家数据 从文件加载
# 暂时写成随机生成
def load_expert_transitions(env, length):
    obs = np.array([env.observation_space.sample() for _ in range(length)])
    acts = np.array([env.action_space.sample() for _ in range(length)])
    infos = np.array([{i: i} for i in range(length)])
    next_obs = np.array([env.observation_space.sample() for _ in range(length)])
    dones = np.zeros(length, dtype=bool)
    return Transitions(obs=obs, acts=acts, infos=infos, next_obs=next_obs, dones=dones)


if __name__ == "__main__":
    env = CustomEnv()
    if check_env(env):
        print("The Custom environment check done")
    device = th.device("cuda" if th.cuda.is_available() else "cpu")
    print(device)
    # 利用网络生成专家数据并采样
    transitions = sample_expert_transitions()
    # 从文件加载
    # transitions = load_expert_transitions(env, 2048)
    # 生成GAIL训练网络
    venv = make_vec_env(lambda: env)
    learner = PPO(
        env=venv,
        policy=MlpPolicy,
        batch_size=64,
        ent_coef=0.0,
        learning_rate=0.0003,
        n_epochs=10,
        device=device,
    )
    reward_net = BasicRewardNet(
        venv.observation_space, venv.action_space, normalize_input_layer=RunningNorm
    )
    custom_logger = imit_logger.configure(
        folder=log_dir,
        format_strs=["tensorboard", "stdout"],
    )

    gail_trainer = GAIL(
        demonstrations=transitions,
        demo_batch_size=2,
        gen_replay_buffer_capacity=2048,
        n_disc_updates_per_round=4,
        venv=venv,
        gen_algo=learner,
        reward_net=reward_net,
        log_dir=log_dir,
        init_tensorboard=False,
        init_tensorboard_graph=False,
        custom_logger=custom_logger
    )

    learner_rewards_before_training, _ = evaluate_policy(
        learner, venv, 10, return_episode_rewards=True
    )
    gail_trainer.train(20000)
    learner_rewards_after_training, _ = evaluate_policy(
        learner, venv, 10, return_episode_rewards=True
    )
    # # 对比训练前后奖励数据变化
    print(np.mean(learner_rewards_after_training))
    print(np.mean(learner_rewards_before_training))

    plt.hist(
        [learner_rewards_before_training, learner_rewards_after_training],
        label=["untrained", "trained"],
    )
    plt.legend()
    plt.show()
    # tensorboard --logdir ./tensorboard/Custom-Env
    # Export to ONNX
    learner.save("./gail.model")
    model = learner.load("./gail.model")
    print(model.predict(env.reset(), deterministic=True))

# 参考flow和sumo-rl的实现
# Environment 包含TrafficLight

self.simulation = TraCISimulation(self) # TraCI 的参数 sumo 如sim_step、simulation time、GUI属性信息 
# 静态的 但是仿真时间是动态的 用于存储一些仿真参数

self.network = TraCIKernelNetwork(self, sim_params) # edge、node、edge_max_speed、edge_length、sumo configuration files Perform no action of value (networks are static) 静态的
# 分为：edges_dict, conn_dict



self.vehicle = TraCIVehicle(self, sim_params) #车辆信息、__controlled_ids、到达的_num_arrived、previous_speeds、被控制的 self.__sumo_obs 车的位置

tc.VAR_LANE_INDEX, tc.VAR_LANEPOSITION,
            tc.VAR_ROAD_ID,
            tc.VAR_SPEED,
            tc.VAR_EDGES,
            tc.VAR_POSITION,
            tc.VAR_ANGLE,
            tc.VAR_SPEED_WITHOUT_TRACI,
            tc.VAR_FUELCONSUMPTION,
            tc.VAR_DISTANCE



self.traffic_light = TraCITrafficLight(self) #交通灯 traffic light data

# 真正参与构成强化学习训练的是

step里面执行仿真 以及update

https://github.com/zbzhu99/NGSIM_Imitation
https://github.com/wsjeon/multiagent-gail/tree/e7dd75f0dee17e33e55d7f4e24d40649fd648cf3

2026-06-10T16:18:36.417Z

LeNet-5

import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
import torchvision
import torchvision.transforms as transforms
import time
import matplotlib.pyplot as plt
import os
 
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
 
 
# 导入FashionMNIST数据集
mnist_train = torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=True, download=True, transform=transforms.ToTensor())
mnist_test = torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=False, download=True, transform=transforms.ToTensor())
 
 
# 处理数据集，把数据转换成张量，使数据可以输入下面我们搭建的网络
def load_data_fashion_mnist(mnist_train, mnist_test, batch_size):
    if sys.platform.startswith('win'):
        num_workers = 0
    else:
        num_workers = 4
    train_data = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_data = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)
    return train_data, test_data
 
 
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5), # in_channels, out_channels, kernel_size
            nn.LeakyReLU(0.1),
            nn.MaxPool2d(2, 2), # kernel_size, stride
            nn.Conv2d(6, 16, 5),
            nn.LeakyReLU(0.1),
            nn.MaxPool2d(2, 2)
        )
        self.fc = nn.Sequential(
            nn.Linear(16*4*4, 120),
            nn.LeakyReLU(0.1),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, 10)
        )
 
    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output
 
# 测试准确率计算
def evaluate_accuracy(data_iter, net, device=None):
    if device is None and isinstance(net, torch.nn.Module):
        # 如果没指定device就使用net的device
        device = list(net.parameters())[0].device
    acc_sum, n = 0.0, 0
    with torch.no_grad():
        for X, y in data_iter:
            net.eval()  # 评估模式, 这会关闭dropout
            acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
            net.train()  # 改回训练模式
            n += y.shape[0]
    return acc_sum / n
 
 
# 训练函数
def train(net, train_data, test_data, batch_size, optimizer, device, num_epochs):
    net = net.to(device)
    print("training on ", device)
    loss_function = torch.nn.CrossEntropyLoss()   # 定义损失函数（交叉熵损失函数）
    ax = []  # 保存等会更新的epoch，loss,train_acc,test_acc，用于绘制动态折线图
    ay1 = []
    ay2 = []
    ay3 = []
    plt.ion()
    # 开始训练
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n, batch_count, start = 0.0, 0.0, 0, 0, time.time()  # 初始化参数
        for X, y in train_data:
            X = X.to(device)      # 把参数导入GPU训练
            y = y.to(device)
            y_hat = net(X)
            l = loss_function(y_hat, y)   # 使用损失函数计算loss
            optimizer.zero_grad() # 把梯度置零，也就是把loss关于weight的导数变成0
            l.backward()   # 反向传播
            optimizer.step()
            train_l_sum += l.cpu().item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
            n += y.shape[0]
            batch_count += 1
        test_acc = evaluate_accuracy(test_data, net)  # 测试当个epoch的训练的网络
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'
              % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))
        # 绘制动态折线图（如果不想绘制，可以删掉）
        plt.clf()  # 清除刷新前的图表，防止数据量过大消耗内存
        ax.append(epoch + 1)  # 追加x坐标值
        ay1.append(train_l_sum / batch_count)  # 追加y坐标值
        ay2.append(train_acc_sum / n)
        ay3.append(test_acc)
        plt.plot(ax, ay1, 'g-')
        plt.plot(ax, ay2, 'r-')
        plt.plot(ax, ay3, '-')
        plt.ylabel("epoch")
        plt.plot(ax, ay1, label="loss")  # 在绘图函数添加一个属性label
        plt.plot(ax, ay2, label="train_acc")
        plt.plot(ax, ay3, label="test_acc")
        plt.legend(loc=2)  # 添加图例，loc为图例位置，1为右上角，2为左上角，3为左下角，4为右下角
        plt.grid()   # 添加网格
        plt.pause(5)  # 设置暂停时间，太快图表无法正常显示
        plt.ioff()  # 关闭画图的窗口，即关闭交互模式
    plt.show()  # 显示图片，防止闪退
 
 
if __name__ == '__main__':
    batch_size = 256   # 批量数大小
    train_data, test_data = load_data_fashion_mnist(mnist_train, mnist_test, batch_size)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 使用GPU,如果没有则使用CPU
    net = LeNet()    # 导入我们搭建好的网络
    lr, num_epochs = 0.001, 10
    optimizer = torch.optim.Adam(net.parameters(), lr=lr)  # 优化函数
    train(net, train_data, test_data, batch_size, optimizer, device, num_epochs)

AlexNet

class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
            nn.ReLU(),
            nn.MaxPool2d(3, 2), # kernel_size, stride
            # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(3, 2),
            # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(3, 2)
        )
        self.fc = nn.Sequential(
            nn.Linear(256*5*5, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 10),
        )

    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output

完整实现：

import time
import torch
from torch import nn, optim
import torchvision
import sys

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    if sys.platform.startswith('win'):
        num_workers = 0
    else:
        num_workers = 4
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())

    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)

    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

    return train_iter, test_iter

batch_size = 128
train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)

class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
            nn.ReLU(),
            nn.MaxPool2d(3, 2), # kernel_size, stride
            # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(3, 2),
            # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(3, 2)
        )
        self.fc = nn.Sequential(
            nn.Linear(256*5*5, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 10),
        )

    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output

net = AlexNet()

def evaluate_accuracy(data_iter, net, device=None):
    if device is None and isinstance(net, torch.nn.Module):
        # 如果没指定device就使用net的device
        device = list(net.parameters())[0].device
    acc_sum, n = 0.0, 0
    with torch.no_grad():
        for X, y in data_iter:
            net.eval() # 评估模式, 这会关闭dropout
            acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
            net.train() # 改回训练模式
            n += y.shape[0]
    return acc_sum / n


def train(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):
    net = net.to(device)
    print("training on ", device)
    loss = torch.nn.CrossEntropyLoss()
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n, batch_count, start = 0.0, 0.0, 0, 0, time.time()
        for X, y in train_iter:
            X = X.to(device)
            y = y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            optimizer.zero_grad()
            l.backward()
            optimizer.step()
            train_l_sum += l.cpu().item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
            n += y.shape[0]
            batch_count += 1
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'
              % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))

lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

2026-06-10T16:18:36.402Z

背景

GAIL算法存在的问题：

模态崩塌问题：指生成模型产生的生成样本塌缩于真实样本分布的某一模态下的子分布，而无法覆盖全部真实样本分布。
生成样本利用效率低：是GAIL假设策略为随机性策略并以无模型RL方法来学习策略。由于随机性策略采样动作的过程是不可微分的，因此反向传播的链式求导在策略模型万的动作节点处中断。在随机环境中，智能体的状态迁移过程是随机的。

InfoGAIL主要改进第一个问题，以自动驾驶为例，GAIL算法不能够很好处理不同驾驶风格的多专家数据场景。专家个体的不同，样本服从多个模态下的子分布，单一模态的假设不符合实际问题。

InfoGAIL

核心思想：InfoGAIL假设专家数据具有多个模态的分布，从专家数据中同时学习多种有效的模态，比如快速驾驶模态与安全驾驶模态，增加辅助网络用来对样本所属的模态类别进行分类。InfoGAIL将信息论中的互信息概念运用到GAIL模型中，通过最大化互信息的原来，能增强策略产生的样本与模态隐变量之间的相关性，进而实现无监督的多模态学习。

互信息表示一个随机变量x在给定另一变量y后所减少的不确定性或信息量。通俗来说，互信息表示x与y之间的相关性，互信息越大，两者越相关。公式表示为：

InfoGAIL在GAIL的基础上考虑最大化待学习策略产生的状态-动作与模态隐变量之前的互信息：

具体的目标函数由原始的GAIL的目标函数引入互信息的惩罚性形成：

由于缺少模态标签知识，互信息中的交叉熵无法直接计算，参考InfoGANs，将互信息放松为变分下界，并用网络模型Y近似后验概率。

对比原始GAN、GAIL、InfoGAN

InfoGAIL的训练框架：

在InfoGAIL训练机制中，判别器Ｄ发挥着与原始GAIL中的D一样的功能，D引导π 产生的样本拟合专家样本分布.推断器Y以策略π 产生的（s，a）为输入，推断样本的后验概率.Y并不输入和处理专家样本．Y遵循互信息最大化的原理，不断改进自身的推断模型，从而解释出与π产生的样本相关程度最大的模态隐变量．Y引导策略产生与隐变量相关的状态-动作对.

除此之外还有两点优化：

1、Reward Augmentation :引入先验知识。考虑到专家策略本身是次优的，那么学习到的策略就到不了最优水平。引入一个基于状态的奖励函数：

2、Improved Optimization：优化高维输入任务的表现及避免GAN网络的梯度消失问题，采用WGAN框架：

效果如下，BC算法的主要思想是直接克隆专家样本在各状态处的单步动作映射，BC会将细微的误差在序列的决策过程中逐步放大，GAIL算法假设所有的数据来源于一个专家，倾向于平均策略，InfoGAIL能够区分不同专家的行为：

2026-06-10T16:18:36.401Z

Generative Adversarial Imitation Learning – 这篇是首创GAIL的论文，数学比较多大概看一下就行不用读太深

GAIL-Imitating Driver Behavior with Generative Adversarial Networks 这篇是GAIl模型用在NPC车辆上的第一篇论文
Wasserstein-GAN 是GAIL的训练框架 GAN的变体
Info Gail是引入了隐变量，使一个模型可以训练出多种驾驶风格

RAIL是对强化学习的Reward Function进行了改动对危险驾驶行为进行了惩罚

模仿学习

模仿学习方法通过模仿专家演示的样本以解决决策问题，它不需要从环境中获得奖赏反馈，其反馈信息来自于专家的决策样本。在很多实际问题中，相较于设置合适的奖赏函数，获取专家样本往往更容易且代价更小。

模仿学习方法可以分为两类：行为克隆方法（Behavioral Cloning，简称 BC）和基于逆向强化学习的模仿学习方法（Imitation Learning via Inverse Reinforcement Learning,简称IRL-IL）

行为克隆方法的主要思想是直接克隆专家样本在各状态处的单步动作映射，即对专家样本进行监督学习．BC并不考虑当前状态之后的长远影响．在有足够多专家样本的前提下，它具有良好的表现．由于不考虑长远影响，BC会将细微的误差在序贯的决策过程中逐步放大，即产生级联误差问题。
逆向强化学习假设专家策略等价于由未知的真实奖赏函数推导出的最优策略。逆向强化学习是RL的逆向过程，它根据给定的专家样本求解未知的奖赏函数．基于解的奖赏函数，通过RL方法求解最优策略的方式，间接地还原专家策略．这种模仿专家的方式使IRL-IL具备了长远规划的能力

基于生成对抗网络的模仿学习方法（GANs-IL）从IRL-IL发展而来，是一类结合了生成对抗网络的模仿学习方法．两者的主要区别是奖赏函数、策略的表示模型以及模型的训练方式．GANs-IL用两个神经网络来表示IRL-IL中的奖赏函数和策略，并用对抗的方式来优化这两个网络的参数．原始的生成对抗网络由生成模型（又称生成器）和判别模型（又称判别器）这两个相对抗的网络模型共同构成．

模仿学习的目标是学习得到与专家尽可能相似的决策模型．因此，模仿学习的评价标准一般为学习得到的策略与专家策略的性能对比。

在模仿学习中，获取专家样本集合的方式主要有以下两种：1)由人类专家示范而获得专家样本集合；2)通过强化学习方法对专家手工定义的标准奖赏函数学习得到贪婪策略，再由贪婪策略得到专家样本集合。然而，RL方法获得的贪婪策略可能不等价于最优策略。因而，这些由不同RL方法得到的贪婪策略的性能也各不相同。因此，通过RL方法得到的专家样本集合并没有形成标准。

目前，模仿学习问题多以仿真实验环境为主，如仿真小车、虚拟机器人控制等。对于不同的模仿学习任务，专家样本集合的获取方式并不固定。对于一些难度较大的模仿学习任务，标准的奖赏函数往往难以定义。因此，通过专家亲身示范行为动作获取专家样本集合的方式更为直接。对于一些存在危险的模仿学习任务，在虚拟环境中通过RL方法获得专家样本集合的方式更为恰当。

GAIL

Generative Adversarial Imitation Learning 最早出现且最具代表性的 GANs-IL方法,2016年提出.在 GAIL中，根据输入状态输出动作的策略可类比为生成器，而根据输入专家样本或生成样本输出奖赏值的奖赏函数可类比为判别器．从而，GAIL将求解奖赏函数的过程类比作判别器的训练过程，将策略的学习过程类比作生成器的训练过程.

存在的问题：

模态崩塌问题：指生成模型产生的生成样本塌缩于真实样本分布的某一模态下的子分布，而无法覆盖全部真实样本分布。以图片样本为例，模态崩塌将导致生成模型产生的图片样本只能表现出单幅画面或单一风格，而丧失了样本的多样性
生成样本利用效率低：是GAIL假设策略为随机性策略并以无模型RL方法来学习策略。由于随机性策略采样动作的过程是不可微分的，因此反向传播的链式求导在策略模型万的动作节点处中断。在随机环境中，智能体的状态迁移过程是随机的。

ACGAIL

当专家样本服从多个模态下的子分布时，模仿学习的单一模态假设将导致模态崩塌。因此，假设专家具有多个模态的模仿学习方法更为合理。多模态的模仿学习放宽了单一模态的假设，它假设专家样本具有多个模态：专家演示的样本不限于单一模态而是来自不同模态下的多个子分布。基于多模态模仿学习的假设，GAIL的模态崩塌问题可以得到缓解。

在GAIL的基础上加入了辅助的网络模型，提出了带辅助分类器的生成对抗模仿学习（Generative Adversarial Imitation Leaming with Auxiliary Classifier,ACGAIL）,新的辅助网络用来对样本所属的模态类别进行分类，从而帮助原始GAIL的模型重构关于模态的条件信息.

InfoGAIL

基于互信息最大化的生成对抗模仿学习(Information Maximizing Generative Adversarial Imitation Learning,InfoGAIL)。InfoGAIL将信息论中的互信息概念运用到了GAIL中。通过最大化互信息的原理，InfoGAIL能增强策略产生的样本与模态隐变量之间的相关性，从而实现无监督的多模态学习。

ACGAIL与InfoGAIL两种方法的模态变量的先验分布假设是一致的。这两种方法均通过随机采样获得模态变量，且假设专家样本存在有限种模态，模态变量服从离散均匀分布。它们都在原始GAIL算法结构中引入了额外的分类模型，分别为分类器C和推断器Y。ACGAIL的分类器C能利用已有的模态标签进行有监督训练，而InfoGAIL的推断器能无监督地训练。不仅如此，分类器C和推断器Y均与判别器联合构成了奖赏函数。

MAGAIL

多智能体生成对抗模仿学习（Multi-Agent Genrative Adversarial Imitation Learning,MAGAIL）假设环境中存在ｋ个智能体，并有相应的ｋ个判别器．其中，每个判别器均对相应智能体的策略与该智能体的专家策略进行评分，并尽可能地给予专家策略较高的分值，同时给予智能体的策略较低的分值．每个智能体则尽可能产生能够欺骗判别器的行为，从而在判别器的引导下实现对专家策略的模仿学习.

在多智能体的学习问题中，智能体相互之间的关系存在着一定的先验假设．比如，各个智能体之间存在着合作、竞争或相混合的假设.在不同的假设前提下，多智能体问题中的判别器存在不同的假设形式。

集中式．当多智能体之间符合完全合作的关系时，MAGAIL中的智能体实际上共享着同一个判别器．此时，这种特殊情况可以被理解为原始的GAIL，而其学习得到的联合策略能够应用于所有智能体
分布式．当智能体之间没有存在奖赏的相关性假设时，每个智能体对应的判别器将采取各不相同的评分标准．然而，这些判别器由于不断地与环境进行间接的交互，它们相互之间也并非是完全独立的
零和博弈式．假设两个智能体之间处于完全竞争的关系，那么它们收到的奖赏互为相反数．在零和博弈中，智能体不需环境进行额外的交互，判别器直接对智能体与专家的联合样本进行判别训练。

WARNING: The repository located at mirrors.aliyun.com is not a trusted or secure host and is being ignored. If this repository is available via HTTPS we recommend you use HTTPS instead, otherwise you may silence this warning and allow it anyway with ‘–trusted-host mirrors.aliyun.com’.
ERROR: Could not find a version that satisfies the requirement carla (from versions: none)
ERROR: No matching distribution found for carla

2026-06-10T16:18:36.243Z

7、基于规则和网络结合的智能模型构建技术

传统的规则智能体往往采用行为树或者状态机的方式进行决策，尽管在某些场景下能取得一定的效果，但是智能体对决策空间的探索度低，智能性不高；而纯粹的强化学习智能体尽管有很强的探索性以及探索最优解的能力，但却通常会遇到学习困难、效果不稳定、动作建模复杂等问题。

为了能更好的应用于复杂的J事场景，本项目采用了知识规则融合模型智能体决策体系来对博弈智能体进行构建。

7.1 智能体构建框架

1、分层，高层智能体+有限状态机

在军事场景下，决策任务往往受到条令的限制，并且不同任务之间可能存在着先后顺序和依赖纠缠。为了更好地处理这种情况，我们将智能体的决策流程进行了分层设计。

在上层，有一个智能体负责粗粒度的决策。它的主要职责是判定任务类型和目标，并根据整体战略制定高级指令和计划，为下层智能体分配任务和优先级。

在下层，基于有限状态机，对任务进行了具体实现。有限状态机允许智能体根据当前的状态和环境条件，灵活地做出不同的决策，以适应任务需求。

这种分层设计使得决策系统更加有条理和灵活。上层智能体负责整体规划和任务分配，从宏观角度指导军事行动。而下层智能体通过有限状态机实现局部的决策，使得它们能够根据不同情况作出适时的反应。

由于整个战场决策分为预设任务与实时决策任务，同时为了在保证对抗效果的前提下最大化探索效率。最后实现的智能体结构如下

7.2 规则任务框架

前期规划

初始进攻策略生成
粗粒度目标分配
静态任务规划

实时决策

兵力调度
任务执行

即时分析

细粒度单位调度
细粒度目标分配
动态任务生成

为了更好地对场景任务进行抽象

通过分析智能体决策，将模型决策信息拆分为主语、谓语、宾语和其他信息

基础规则构建-规则配置：

一次性任务（任务可以对应为一条执行命令，执行完之后任务结束）

{
  "unit_ids": ["DDG 81“温斯特.S.丘吉尔”阿里伯克级Flight IIA导弹驱逐舰"],   # 主语，蓝方单位id
  "type": "NavalAsuWStrike_Naval",  # 谓语：舰对舰打击
  "target_ids": ["003"],  # 宾语，目标
}

持续性任务

一次性任务可以通过配置执行时间、重复次数转化为持续性任务

如：

{
  "unit_ids": ["DDG 81“温斯特.S.丘吉尔”阿里伯克级Flight IIA导弹驱逐舰"],   # 主语，蓝方单位id
  "type": "NavalAsuWStrike_Naval",  # 谓语：舰对舰打击
  "target_ids": ["003"],  # 宾语，目标
}

另一类持续性任务则对应需要多条执行命令来协同执行的任务

如空对舰打击，包含飞机起飞、移动、攻击、返航，需要按照执行阶段，对单位下发不同的指令，如

{
  "unit_ids": ["F35C-01", "F35C-02"],   # 主语，蓝方单位id
  "type": "AirIntercept",  # 谓语：空中拦截
  "target_ids": ["J-15c-01"],  # 宾语，目标
}

此外，在任务设计过程中，根据zz指令，还抽象出一些其他参数，用来实现特定的任务执行逻辑优化任务执行逻辑

"activation_time": "2022-02-12",  # 任务激活时间
"course": [position_1, position_2, ...],  # 航线
"attack_mode": AttackMode.Repeat,  # 打击模式
"block": False,   # 是否锁定单位，其他任务不可替换

任务有限状态机概览

在复杂的对空拦截任务中，不仅需要处理基本的飞机编队选择、起飞、移动、攻击和返航等基本动作，还需要考虑许多偶发性事件，比如遇到敌方飞机、油量不足或目标消失等突发情况。为了在实际执行中保证任务的有效执行效果，并能够即时做出动态决策，引入了固定任务和触发式任务的设计。

在更新有限状态机的过程中，将任务执行流程细化，并为不同的任务状态设定相应的转换条件。这样，能够更好地控制飞机在不同情况下的行为，以适应任务的复杂性和多变性。

为了保证任务的执行效果，设计了固定任务，这些任务是在任务开始前就确定的，包括基本的飞行行动和攻击计划。这些固定任务保证了飞机在任务执行过程中的基本行为和目标导向。

同时，为了应对偶发性事件，引入了触发式任务。当飞机遇到敌方飞机、油量不足或目标消失等特定情况时，相应的触发式任务会被激活。这样，能够即时做出针对性的动态决策，并根据实时信息调整飞机的行动策略。

通过这种细化的任务规划和触发式任务的引入，决策系统在面对复杂多变的对空拦截任务时，能够保证任务执行的效果，并具备适应和应对不同突发情况的能力。这种灵活性和实时性的设计为任务的成功执行提供了有力的支持，也使得智能体能够更好地应对多样化的战场挑战。

任务交互逻辑

7.3 多智能体分目标协作

在决策过程中，每次与环境交互都会触发一次数据打包与解析的过程。为了加快训练，通常需要采用较高的决策间隔来调用环境。

在训练过程中发现，对于不同任务类型，决策间隔的敏感度存在明显差异。具体而言，对于防空任务，决策窗口期通常<30s，决策对决策间隔极其敏感，过高的决策间隔会导致模型表现大幅下降。而在舰对舰打击任务中，决策对决策间隔的容忍度较高，允许较大的时间间隔。

然而，在单一模型的场景下，当决策间隔设置过低，例如每5秒一次，舰对舰打击任务中超过95%的action都将会由于武器耗尽/冷却而被视为无效命令，这给模型训练带来了极大困难。

为了克服这一问题，我们将原本一个智能体的决策流程拆分成多个智能体。每个智能体都有独立的决策间隔设置，并可以与环境进行交互。通过这种多智能体决策的方法，有效缓解决策频率对训练过程的不利影响。

训练效果

在对海场景想定（参考duitai_asuw2.1构建），模型决策间隔2分钟，每局产生200条数据，batch_size=4096场景下，单次训练10w局周期3天。硬件条件：35核cpu core，1 gpu，20采样节点

任务规划

任务-场景对应

命令类型	编队防空	海上防空	对海打击	模版-单位数量	模版-武器数量	初始航线规划
空中打击-空对空			√	2	/	避开威胁度最大区域
空中打击-空对海			√	2		避开威胁度最大区域

空中巡逻-空对空			√	2		前往威胁度最大区域

直接攻击-地对空（导弹）*	√				2
直接攻击-地对空（飞机）*	√				2
直接攻击-海对空（导弹）	√	√			2
直接攻击-海对空（飞机）	√	√			2
直接攻击-海对海			√		4/8根据目标类型生成
待命-空动作	√	√	√

编队场景将地面单位、海上单位视为同种类型单位进行联合调度

2026-06-10T16:18:36.236Z

{"name":"ai","services":{"ai-web":{"image":"uuv_web","ports":["36345:80"],"volumes":["D:/TianGong/ai/ai_ui/dist:/usr/share/nginx/html","./nginx-uuv.conf:/etc/nginx/conf.d/default.conf"]},"ai-mysql":{"image":"mysql:5.7.24","ports":["23306:3306"],"volumes":["./mysqld.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf"],"environment":["MYSQL_ROOT_PASSWORD=123456","MYSQL_DATABASE=zcdb"],"command":["--character-set-server=utf8mb4","--collation-server=utf8mb4_general_ci","--skip-character-set-client-handshake"]},"ai-server1":{"image":"uuv_server_v2","volumes":["D:/TianGong/ai/ai_server/code/zcProject:/home/zc"],"ports":["38045:8000"],"command":["/bin/bash","-c","python /home/zc/manage.py makemigrations\npython /home/zc/manage.py migrate\npython /home/zc/manage.py runserver 0.0.0.0:8000\n"],"tty":true,"restart":"always","depends_on":["ai-mysql","ai-web"]}}}

2026-06-10T16:18:36.235Z

{"name":"ray","services":{"work":{"image":"ray_server_v2","environment":["NVIDIA_VISIBLE_DEVICES=all"],"restart":"always","network_mode":"host","command":"/bin/bash -c \"/root/miniconda3/envs/train_uuv/bin/ray start --address='192.168.2.2:6379' --block\""}}}

2026-06-10T16:18:36.234Z

{"name":"ray","services":{"head":{"image":"ray_server_v2","network_mode":"host","volumes":["/home/user/uuv/code/:/home"],"environment":["NVIDIA_VISIBLE_DEVICES=all"],"command":"/bin/bash -c \"/root/miniconda3/envs/train_uuv/bin/ray start --head --node-ip-address='0.0.0.0' --dashboard-host='0.0.0.0' --dashboard-port=8265 --block\"","tty":true}}}

2026-06-10T16:18:36.130Z

背景

在强化学习解决问题的场景中，动作是体现学习效果最直接的因素，直接影响了智能体下一步的走向和对环境状态的改变。在应用强化学习解决实际问题时，往往不同于gym库中倒立摆那样的情况，而是存在很多的约束。例如，在t时刻智能体可选的动作为1,2,3，但是在t+1时刻只能选1,2.3处于不可用的状态。在这种情况下，就需要借助掩码mask来对智能体的动作进行处理。

有人会疑问：就不能制定相应的奖励函数使得智能体学习到这种约束吗？这样做是可以的，但是付出的训练代价很大，并且极其容易导致模型发散。因此，在大多数RL落地的场景下，都会使用MASK掩码方法解决动作约束的问题。

MASK的方法

Mask的核心就是在输出的动作或者值函数的向量上戴个“面具”，点乘一个{0,1}或者{−∞,1}的行向量，以规范化输出。这样智能体选出的动作就可以进行简单的规范化。

MASK的两个关键点

由于强化学习，尤其是深度强化学习，学的最后还是分布，因此只是单单的不让智能体选择不符合规则的动作并不能加速模型的收敛。

因此，MASK一般加在选择动作前的值函数向量或者其他数据向量上，并且会将MASK后的值传入神经网络训练。
两个关键点分别是：

1-mask分布
2-回传训练

具体做法

以openai中MASK星际争霸智能体的动作为例：首先是环境部分self.env，使用的是为每个agent提供一个available的动作集合，可以随时调用这个方法以获取agent此时的可执行动作：

然后在agent的动作选择阶段，使用inf代替不符合要求的部分，使得softmax选择的动作合理：

最后在policy学习更新的部分，同样利用-9999999作为不合理动作的替换，使得反向传播的概率分布与采样一致：

在星际争霸游戏中，任何时刻，整个动作空间中只有一小部分子集的动作可以执行。为了防止 AI 在某些时刻选取当前时刻无法执行的动作，需要对动作空间进行 mask。具体操作时，如果选择了当前时刻不可用的动作，就会执行 no-op（no operation，即不操作）

实现

第一步，自定义环境：

class MyParamActionEnv(gym.Env):
    def __init__(self, max_avail_actions):
        self.action_space = Discrete(max_avail_actions)
        self.observation_space = Dict({
            "action_mask": Box(0, 1, shape=(max_avail_actions, )), # 添加action_mask 尺寸与action_space一致
            "avail_actions": Box(-1, 1, shape=(max_avail_actions, action_embedding_sz)),
            "real_obs": ...,
        })

第二步，自定义网络：

class ParametricActionsModel(TFModelV2):
    def __init__(self,
                 obs_space,
                 action_space,
                 num_outputs,
                 model_config,
                 name,
                 true_obs_shape=(4,),
                 action_embed_size=2):
        super(ParametricActionsModel, self).__init__(
            obs_space, action_space, num_outputs, model_config, name)
        self.action_embed_model = FullyConnectedNetwork(...)

    def forward(self, input_dict, state, seq_lens):
        # Extract the available actions tensor from the observation.
        avail_actions = input_dict["obs"]["avail_actions"]
        action_mask = input_dict["obs"]["action_mask"]

        # Compute the predicted action embedding
        action_embed, _ = self.action_embed_model({
            "obs": input_dict["obs"]["cart"]
        })

        # Expand the model output to [BATCH, 1, EMBED_SIZE]. Note that the
        # avail actions tensor is of shape [BATCH, MAX_ACTIONS, EMBED_SIZE].
        intent_vector = tf.expand_dims(action_embed, 1)

        # Batch dot product => shape of logits is [BATCH, MAX_ACTIONS].
        action_logits = tf.reduce_sum(avail_actions * intent_vector, axis=2)

        # Mask out invalid actions (use tf.float32.min for stability)
        inf_mask = tf.maximum(tf.log(action_mask), tf.float32.min)
        return action_logits + inf_mask, state

参考例子：

第一步：自定义环境：

class ActionMaskEnv(RandomEnv):
    """A randomly acting environment that publishes an action-mask each step."""

    def __init__(self, config):
        super().__init__(config)
        # Masking only works for Discrete actions.
        assert isinstance(self.action_space, Discrete)
        # Add action_mask to observations.
        self.observation_space = Dict(
            {
                "action_mask": Box(0.0, 1.0, shape=(self.action_space.n,)),
                "observations": self.observation_space,
            }
        )
        self.valid_actions = None

    def reset(self, *, seed=None, options=None):
        obs, info = super().reset()
        self._fix_action_mask(obs)
        return obs, info

    def step(self, action):
        # Check whether action is valid.
        if not self.valid_actions[action]:
            raise ValueError(
                f"Invalid action sent to env! " f"valid_actions={self.valid_actions}"
            )
        obs, rew, done, truncated, info = super().step(action)
        self._fix_action_mask(obs)
        return obs, rew, done, truncated, info

    def _fix_action_mask(self, obs):
        # Fix action-mask: Everything larger 0.5 is 1.0, everything else 0.0.
        self.valid_actions = np.round(obs["action_mask"])
        obs["action_mask"] = self.valid_actions

第二步：自定义网络：

class TorchActionMaskModel(TorchModelV2, nn.Module):
    """PyTorch version of above ActionMaskingModel."""

    def __init__(
        self,
        obs_space,
        action_space,
        num_outputs,
        model_config,
        name,
        **kwargs,
    ):
        orig_space = getattr(obs_space, "original_space", obs_space)
        assert (
            isinstance(orig_space, Dict)
            and "action_mask" in orig_space.spaces
            and "observations" in orig_space.spaces
        )

        TorchModelV2.__init__(
            self, obs_space, action_space, num_outputs, model_config, name, **kwargs
        )
        nn.Module.__init__(self)

        self.internal_model = TorchFC(
            orig_space["observations"],
            action_space,
            num_outputs,
            model_config,
            name + "_internal",
        )

        # disable action masking --> will likely lead to invalid actions
        self.no_masking = False
        if "no_masking" in model_config["custom_model_config"]:
            self.no_masking = model_config["custom_model_config"]["no_masking"]

    def forward(self, input_dict, state, seq_lens):
        # Extract the available actions tensor from the observation.
        action_mask = input_dict["obs"]["action_mask"]

        # Compute the unmasked logits.
        logits, _ = self.internal_model({"obs": input_dict["obs"]["observations"]})

        # If action masking is disabled, directly return unmasked logits
        if self.no_masking:
            return logits, state

        # Convert action_mask into a [0.0 || -inf]-type mask.
        inf_mask = torch.clamp(torch.log(action_mask), min=FLOAT_MIN)
        masked_logits = logits + inf_mask

        # Return masked logits.
        return masked_logits, state

    def value_function(self):
        return self.internal_model.value_function()

torch.clamp 将输入input张量每个元素的夹紧到区间 [min,max]

inf_mask趋近于负无穷，使用inf代替不符合要求的部分，使得softmax选择的动作合理

forward中包含一个batchsize内的所有数据的输入，Discrete(100)时，包含0-99的每个action取值的概率。

全网VIP视频解析接口-开源-稳定CDN加速支持腾讯视频、爱奇艺、优酷等几十个平台

2026-06-10T16:18:36.120Z

全网解析支持站点

奇艺视频腾讯优酷土豆芒果乐视搜狐 PPTV 华数TV 风行咪咕哔哩哔哩 ACfun 暴风 CCTV CNTV 范特西 9i广场舞搜狐自媒体 M1905视频看看视频 27盘虎牙直播全民直播战旗直播人人视频爆米花今日头条天翼视频糖豆视频龙珠视频快手视频
一直播新浪视频 360小视频熊猫TV 斗鱼TV 花椒直播网易公开课音悦台秒拍网美拍网爱拍凤凰视频梨视频微录客人民微视频 17173视频优米视频 m3u8 mp4视频微博视频 YY视频私有云资源

https://cdn.yangju.vip/k/?url=后面加上播放的地址即可

https://cdn.yangju.vip/k/?url=

https://jx.lache.me/cc/?url=

https://api.653520.top/vip/?url=

https://jx.ab33.top/vip/?url=

https://vip.mpos.ren/v/?url=

https://jx.000180.top/jx/?url=

https://jx.km58.top/jx/?url=

https://api.smq1.com/?url=

https://jx.hezeshi.net/ce/jlexi.php?url=

https://www.kkflv.com/?url=

https://jx.618g.com/?url=

永久性，重要的是够稳定！而且CDN加速！！解析接口支持:URL模式

Redis之Stream队列

2026-06-10T16:18:36.117Z

Redis5.0开始引入了Stream这个数据结构，Stream可以很好地用于消息队列，它支持消息持久化，同时可以记录消费者的位置，即使客户端断开重连，也不会丢失消息。

使用 XADD 向队列添加消息，如果指定的队列不存在，则创建一个队列，XADD 语法格式：

XADD key ID field value [field value ...]
key ：队列名称，如果不存在就创建
ID ：消息 id，我们使用 * 表示由 redis 生成，可以自定义，但是要自己保证递增性。
field value ： 记录。

redis> XADD mystream * name Sara surname OConnor
"1601372323627-0"
redis> XADD mystream * field1 value1 field2 value2 field3 value3
"1601372323627-1"
redis> XLEN mystream
(integer) 2

XADD 中的key为队列ID，默认为*自动生成，也可以手动指定

1
2
3

XADD mystream 10000000 name Anna  
XADD mystream 10000001 name Bert  
XADD mystream 10000002 name Cathy

可以使用MAXLEN选项来限制Stream队列流中的最大元素数量。

读取Stream队列，想从数据流的开头读取多达100个条目：

1	XREAD COUNT 100 STREAMS mystream 0

Ray全局变量问题

2023-07-15T09:34:46.000Z

Ray的远程函数功能remote应该被认为是功能性和无副作用的。仅限于远程函数限制我们使用分布式函数式编程，这对于许多用例来说都很好，但实际上有点受限。
Ray使用Actor扩展了数据流模型。Actor本质上是一个有状态的worker（或服务）

假设我们有多个任务在同一个actor上调用方法。例如，我们可能有一个Actor记录来自许多任务的执行信息。我们可以将actor句柄作为参数传递给相关任务来实现这一点。

@ray.remote
class Actor(object):
    def method(self):
        pass

# 创建actor
actor = Actor.remote()

@ray.remote
def f(actor):
    # 激活actor的函数
    x_id = actor.method.remote()
    # 真正的阻塞调用返回结果
    return ray.get(x_id)

# 三个任务都会调用同一个actor的方法
f.remote(actor)
f.remote(actor)
f.remote(actor)

参考官方文档
https://docs.ray.io/en/latest/ray-core/patterns/global-variables.html#anti-pattern-using-global-variables-to-share-state-between-tasks-and-actors

全局变量共享是一种反模式的使用方法，不要使用全局变量与任务和参与者共享状态。相反，将全局变量封装在参与者中，并将参与者句柄传递给其他任务和参与者。

Ray 驱动程序、任务和 Actor 运行在不同的进程中，因此它们不共享相同的地址空间。这意味着，如果您在一个进程中修改全局变量，则更改不会反映在其他进程中

解决方案是使用Actor的实例变量来保存全局状态，并将参与者句柄传递到需要修改或访问状态的地方。

成功的示例：

@ray.remote
class GlobalVarActor:
    def __init__(self):
        self.global_var = []

    def set_global_var(self, var):
        self.global_var.append()

    def get_global_var(self):
        return self.global_var


@ray.remote
class Actor:
    def __init__(self, global_var_actor):
        self.global_var_actor = global_var_actor

    def f(self):
        return ray.get(self.global_var_actor.get_global_var.remote()) + 3


global_var_actor = GlobalVarActor.remote()
actor = Actor.remote(global_var_actor)
ray.get(global_var_actor.set_global_var.remote(4))
# This returns 7 correctly.
assert ray.get(actor.f.remote()) == 7

失败的示例：

pyinstaller 打包

2023-02-22T09:34:46.000Z

https://blog.csdn.net/qq_35722703/article/details/121117169

Tony Wang's blogs

基础

自定义环境

概念

服务

镜像

容器

发布

Demo

背景

架构

核心模块

环境

传感器

经典模块

特性

安装

使用

对象

类

蓝图

Actor

Pawn

角色

组件

世界

玩家控制器

AI控制器

安装

Traci接口

动力学模型

Krauss model

lane changing model

Ray

安装

使用

RLlib

LeNet-5

AlexNet

背景

InfoGAIL

模仿学习

GAIL

ACGAIL

InfoGAIL

MAGAIL

7、 基于规则和网络结合的智能模型构建技术

7.1 智能体构建框架

7.2 规则任务框架

基础规则构建-规则配置：

7.3 多智能体分目标协作

训练效果

任务规划

背景

MASK的方法

MASK的两个关键点

具体做法

实现

全网VIP视频解析接口-开源-稳定CDN加速 支持腾讯视频、爱奇艺、优酷等几十个平台

Redis之Stream队列

Ray全局变量问题

pyinstaller 打包

7、基于规则和网络结合的智能模型构建技术

全网VIP视频解析接口-开源-稳定CDN加速支持腾讯视频、爱奇艺、优酷等几十个平台