DAGGER算法实战:如何用Python实现模仿学习中的数据聚合

Julia数据工程实战:高性能Transformation层构建指南 数据工程中的Transformation层是ETL流程的核心瓶颈,涉及高频数据清洗、聚合与特征计算,其性能与可维护性直接决定数仓SLA。传统方案依赖Python Pandas或Spark SQL,常面临内存膨胀、序列化开销大、嵌套结构处理弱等痛点。Julia凭借类型推导+JIT编译+零拷贝内存模型,在该层提供原生高性能替代路径,尤其适配Arrow内存布局、流式JSON解析与分布式数据流编排。结合DataFrames.jl、Arrow.jl和Dagger.jl,可实现单语言覆盖交互探索、批处理、UDF及服务化 阅读详情

DAGGER算法实战:用Python构建你的模仿学习智能体

模仿学习领域里,一个经典的难题始终困扰着实践者:我们辛辛苦苦收集的专家演示数据,其状态分布与智能体在实际运行中遇到的状态分布往往大相径庭。这就好比一个飞行员只在模拟器中练习过晴空万里的起降,一旦遇到真实的雷暴天气,便可能手足无措。这种“分布漂移”问题,直接导致了早期行为克隆方法在实际部署中的性能断崖式下跌。直到一种名为DAGGER的算法出现,它通过一种巧妙的“数据聚合”思想,为模仿学习开辟了一条更为稳健的路径。今天,我们不谈复杂的数学推导,而是直接动手,用Python从零开始,一步步实现DAGGER算法,看看它如何通过迭代式的数据收集与策略更新,教会我们的智能体在“真实世界”中也能游刃有余。

1. 理解DAGGER:从理论直觉到工程实现

在深入代码之前,我们需要先建立起对DAGGER算法核心思想的直观理解。想象一下,你正在教一个新手学习一项复杂技能,比如下围棋。传统的行为克隆就像是你自己下了一百盘棋,录成视频让他反复观看学习。他可能学得有模有样,但一旦真正坐到棋盘前,面对对手从未在视频中出现过的怪招,他立刻就会懵掉。因为视频里的棋局(状态分布)和他实际对弈时遇到的棋局,完全是两回事。

DAGGER则采取了一种更聪明的“陪练”方式。首先,你还是让他看你的棋谱(专家数据)进行初步学习,得到他的第一个策略。然后,你让他亲自去下一盘棋,你在一旁观战。在他下棋的每一步,你都记录下他当时面临的棋盘局面(状态),并告诉他如果是你,这一步会怎么走(专家动作)。这盘棋下完后,你把他自己下棋时遇到的所有新棋盘局面,连同你给出的正确走法,都添加到他的学习资料库中。接着,他用这个更丰富的资料库重新学习,得到一个新的、更好的策略。如此循环往复,他下棋的经验越来越丰富,遇到的局面越来越接近真实对弈,学到的策略也就越来越稳健。

这个过程中,数据聚合是灵魂。它不是简单地将新旧数据堆在一起,而是在智能体自身策略诱导出的状态分布下,持续补充专家的纠正标签。这确保了训练数据的状态覆盖范围,能够动态地跟随智能体策略的演化而扩展,从而有效缓解分布不匹配的问题。

从算法层面看,DAGGER是一个元算法框架,其核心步骤如下:

  1. 初始化:使用初始的专家演示数据集 ( D ) 训练第一个策略 ( \pi_1 )(通常通过行为克隆)。
  2. 迭代循环(对于 ( n = 1, 2, ... )): a. 数据收集:使用当前策略 ( \pi_n ) 在环境中运行(或模拟运行),收集一系列轨迹。 b. 专家标注:对于收集到的轨迹中的每一个状态 ( s ),查询专家(或一个专家策略)给出在该状态下的最优动作 ( a^* )。 c. 数据聚合:将新的状态-动作对 ( (s, a^*) ) 添加到总数据集 ( D ) 中。 d. 策略更新:在聚合后的数据集 ( D ) 上,重新训练(或微调)策略,得到新的策略 ( \pi_{n+1} )。
  3. 终止:达到预设的迭代次数或策略性能收敛。

注意:这里的“专家”在实践中可能是一个预训练好的完美模型、一个规则系统,甚至是人类在回放录像中的实时标注。算法的有效性很大程度上依赖于专家标注的质量和可靠性。

理解了这些,我们就可以开始搭建我们的实战环境了。我们将选择一个经典的控制问题作为我们的“棋盘”——OpenAI Gym的 CartPole-v1 环境。在这个环境中,智能体需要控制一个小车左右移动,以保持其顶部的杆子竖直不倒。

2. 环境搭建与基础策略模型构建

工欲善其事,必先利其器。我们首先需要准备好算法实现所需的所有工具和框架。我们将使用 PyTorch 来构建神经网络策略,Gym 来提供训练环境,并使用 Matplotlib 进行结果可视化。

# 基础环境依赖安装(假设使用pip)
pip install gym==0.26.2
pip install torch==2.0.1
pip install numpy==1.24.3
pip install matplotlib==3.7.1

接下来,我们定义项目的核心组件。首先是一个简单的专家策略。在 CartPole 环境中,我们可以用一个基于规则的控制器来模拟“专家”。这个专家并不完美,但足够好,能为我们生成高质量的演示数据。

import gym
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from collections import deque, namedtuple
import random
import matplotlib.pyplot as plt

# 定义一个简单的规则专家策略
class ExpertPolicy:
    def __init__(self, env_name='CartPole-v1'):
        self.env = gym.make(env_name)
        
    def act(self, state):
        """基于规则的专家动作:一个简单的PD控制器"""
        cart_pos, cart_vel, pole_angle, pole_vel = state
        # 简单的控制逻辑:如果杆子向右倾,则小车向右加速(动作1),反之向左(动作0)
        # 加入速度项以增加稳定性
        if pole_angle + 0.1 * pole_vel > 0:
            return 1  # 向右
        else:
            return 0  # 向左
    
    def generate_demonstrations(self, num_episodes=50):
        """生成初始专家演示数据集"""
        demonstrations = []
        for episode in range(num_episodes):
            state, _ = self.env.reset()
            done = False
            episode_data = []
            while not done:
                action = self.act(state)
                next_state, reward, terminated, truncated, _ = self.env.step(action)
                done = terminated or truncated
                # 存储 (state, expert_action)
                episode_data.append((state, action))
                state = next_state
            demonstrations.extend(episode_data)
        self.env.close()
        states, actions = zip(*demonstrations)
        return np.array(states), np.array(actions)

有了专家,我们需要一个可以学习的智能体策略。这里我们使用一个简单的多层感知机(MLP)来参数化策略,它将环境状态映射到动作的概率分布上。

class ImitationPolicy(nn.Module):
    """用于模仿学习的神经网络策略"""
    def __init__(self, state_dim, action_dim, hidden_dim=128):
        super(ImitationPolicy, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, action_dim)
        )
        
    def forward(self, x):
        logits = self.net(x)
        return logits  # 输出的是未归一化的logits
    
    def get_action(self, state, deterministic=False):
        """根据状态选择动作"""
        state_tensor = torch.FloatTensor(state).unsqueeze(0)
        logits = self.forward(state_tensor)
        if deterministic:
            # 确定性策略:选择概率最大的动作
            action = torch.argmax(logits, dim=1).item()
        else:
            # 随机策略:根据softmax概率采样
            probs = torch.softmax(logits, dim=1)
            action = torch.multinomial(probs, 1).item()
        return action

现在,基础组件已就位。我们有了一个能生成数据的“专家”,和一个等待被训练的“学生”神经网络。接下来,我们将进入DAGGER算法的核心循环。

3. DAGGER核心循环的Python实现

DAGGER的魅力在于其迭代式的学习过程。下面,我们将把之前描述的算法步骤,转化为具体的Python代码。我们会创建一个 DAGGERTrainer 类来封装整个训练流程。

class DAGGER:
    def __init__(self, env_name, expert_policy, state_dim, action_dim, device='cpu'):
        self.env = gym.make(env_name)
        self.expert = expert_policy
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.device = device
        
        # 初始化策略网络
        self.policy = ImitationPolicy(state_dim, action_dim).to(device)
        self.optimizer = optim.Adam(self.policy.parameters(), lr=1e-3)
        self.criterion = nn.CrossEntropyLoss()  # 分类任务,使用交叉熵损失
        
        # 用于存储聚合数据
        self.aggregated_states = []
        self.aggregated_expert_actions = []
        
        # 记录训练历史
        self.training_losses = []
        self.eval_returns = []
    
    def collect_data_with_current_policy(self, num_rollouts=10):
        """使用当前策略在环境中运行,收集轨迹,并请专家标注状态"""
        new_states = []
        new_expert_actions = []
        
        for _ in range(num_rollouts):
            state, _ = self.env.reset()
            done = False
            while not done:
                # 使用当前策略与环境交互
                with torch.no_grad():
                    action = self.policy.get_action(state, deterministic=True)
                next_state, reward, terminated, truncated, _ = self.env.step(action)
                done = terminated or truncated
                
                # 关键步骤:对于策略遇到的这个状态,询问专家应该采取什么动作
                expert_action = self.expert.act(state)
                
                # 收集 (state, expert_action) 对
                new_states.append(state)
                new_expert_actions.append(expert_action)
                
                state = next_state
        
        return np.array(new_states), np.array(new_expert_actions)
    
    def update_policy_with_aggregated_data(self, batch_size=64, epochs=5):
        """使用当前聚合的所有数据(包括新旧数据)重新训练策略"""
        if len(self.aggregated_states) == 0:
            return
        
        # 转换为PyTorch张量
        states_tensor = torch.FloatTensor(np.array(self.aggregated_states)).to(self.device)
        actions_tensor = torch.LongTensor(np.array(self.aggregated_expert_actions)).to(self.device)
        
        dataset = torch.utils.data.TensorDataset(states_tensor, actions_tensor)
        dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
        
        epoch_losses = []
        for epoch in range(epochs):
            total_loss = 0
            for batch_states, batch_actions in dataloader:
                self.optimizer.zero_grad()
                logits = self.policy(batch_states)
                loss = self.criterion(logits, batch_actions)
                loss.backward()
                self.optimizer.step()
                total_loss += loss.item()
            avg_loss = total_loss / len(dataloader)
            epoch_losses.append(avg_loss)
        
        self.training_losses.extend(epoch_losses)
        return np.mean(epoch_losses)
    
    def evaluate_policy(self, num_episodes=20):
        """评估当前策略的性能(平均回报)"""
        total_returns = 0
        for _ in range(num_episodes):
            state, _ = self.env.reset()
            done = False
            episode_return = 0
            while not done:
                with torch.no_grad():
                    action = self.policy.get_action(state, deterministic=True)
                next_state, reward, terminated, truncated, _ = self.env.step(action)
                done = terminated or truncated
                episode_return += reward
                state = next_state
            total_returns += episode_return
        avg_return = total_returns / num_episodes
        self.eval_returns.append(avg_return)
        return avg_return
    
    def train(self, num_dagger_iterations=10, rollouts_per_iter=5, initial_demos=100):
        """执行完整的DAGGER训练流程"""
        print("=== 开始DAGGER训练 ===")
        
        # 步骤1: 使用初始专家演示进行行为克隆(初始化)
        print(f"迭代 0: 收集初始专家演示 ({initial_demos} 条轨迹)...")
        init_states, init_actions = self.expert.generate_demonstrations(num_episodes=initial_demos)
        self.aggregated_states = list(init_states)
        self.aggregated_expert_actions = list(init_actions)
        
        print(f"迭代 0: 在 {len(init_states)} 个样本上进行行为克隆...")
        init_loss = self.update_policy_with_aggregated_data(epochs=10)
        init_return = self.evaluate_policy()
        print(f"初始策略 - 损失: {init_loss:.4f}, 评估回报: {init_return:.2f}")
        
        # 步骤2: DAGGER主循环
        for iteration in range(1, num_dagger_iterations + 1):
            print(f"\n--- DAGGER 迭代 {iteration}/{num_dagger_iterations} ---")
            
            # a. 使用当前策略收集数据
            print(f"  使用当前策略收集 {rollouts_per_iter} 条轨迹...")
            new_states, new_expert_actions = self.collect_data_with_current_policy(num_rollouts=rollouts_per_iter)
            
            # b. 将新数据聚合到总数据集中
            print(f"  将 {len(new_states)} 个新样本聚合到数据集中...")
            self.aggregated_states.extend(new_states)
            self.aggregated_expert_actions.extend(new_expert_actions)
            print(f"  总数据集大小: {len(self.aggregated_states)} 个样本")
            
            # c. 在聚合数据上更新策略
            print(f"  在聚合数据上重新训练策略...")
            train_loss = self.update_policy_with_aggregated_data(epochs=5)
            
            # d. 评估新策略
            eval_return = self.evaluate_policy()
            print(f"  迭代结果 - 训练损失: {train_loss:.4f}, 评估回报: {eval_return:.2f}")
        
        self.env.close()
        print("\n=== DAGGER训练完成 ===")

这个 DAGGER 类清晰地勾勒出了算法的骨架。collect_data_with_current_policy 方法对应着“数据收集”和“专家标注”,update_policy_with_aggregated_data 方法则完成了“数据聚合”与“策略更新”。train 方法将它们串联起来,形成了完整的迭代循环。

现在,让我们初始化并运行这个训练器,看看效果如何。

# 初始化并运行DAGGER训练
env_name = 'CartPole-v1'
test_env = gym.make(env_name)
state_dim = test_env.observation_space.shape[0]
action_dim = test_env.action_space.n
test_env.close()

expert = ExpertPolicy(env_name)
dagger_trainer = DAGGER(env_name, expert, state_dim, action_dim, device='cpu')

# 运行训练:10次DAGGER迭代,每次用当前策略收集5条轨迹,初始使用50条专家轨迹
dagger_trainer.train(num_dagger_iterations=10, rollouts_per_iter=5, initial_demos=50)

运行这段代码,你会看到控制台输出训练过程。理想情况下,随着迭代进行,评估回报应该逐步上升并趋于稳定,这表明策略正在通过接触自身错误并获取专家纠正而不断改进。

4. 结果分析与实战调优技巧

训练完成后,我们不能只看最终分数,深入分析训练过程和数据变化,才能更好地理解DAGGER的工作原理并对其进行优化。让我们可视化训练过程中的关键指标。

def plot_training_progress(dagger_trainer):
    """绘制DAGGER训练过程中的损失和回报曲线"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
    
    # 绘制训练损失
    ax1.plot(dagger_trainer.training_losses)
    ax1.set_xlabel('训练步骤')
    ax1.set_ylabel('交叉熵损失')
    ax1.set_title('策略训练损失变化')
    ax1.grid(True, alpha=0.3)
    
    # 绘制评估回报
    iterations = range(len(dagger_trainer.eval_returns))
    ax2.plot(iterations, dagger_trainer.eval_returns, marker='o')
    ax2.set_xlabel('DAGGER迭代次数')
    ax2.set_ylabel('平均回报')
    ax2.set_title('策略性能随迭代变化')
    ax2.grid(True, alpha=0.3)
    # 在CartPole-v1中,回报达到500表示完美解决
    ax2.axhline(y=500, color='r', linestyle='--', alpha=0.5, label='目标回报 (500)')
    ax2.legend()
    
    plt.tight_layout()
    plt.show()

# 绘制我们刚刚训练的结果
plot_training_progress(dagger_trainer)

通过图表,我们可以直观地看到DAGGER的迭代效应。损失曲线可能会在每次新数据加入时产生波动,但总体应呈下降趋势。回报曲线则应稳步上升,最终接近或达到环境的最大回报(CartPole-v1为500)。如果曲线没有如预期般改善,那么可能是时候进行调优了。

实战调优技巧与常见问题解决

在实际项目中,直接套用基础DAGGER实现可能不会一帆风顺。以下是一些关键的调优点和常见陷阱:

  • 专家质量至关重要:如果专家策略本身不完美或有噪声,DAGGER会将这些错误也学过来,甚至放大。务必确保你的专家数据或标注机制尽可能可靠。
  • 数据聚合策略:基础DAGGER是简单地将所有新旧数据合并。但在某些情况下,这可能导致数据集过于庞大或包含大量冗余/过时样本。可以考虑以下变体:
    • 加权聚合:给新收集的数据或专家确信度高的数据更高权重。
    • 缓冲区采样:维护一个固定大小的回放缓冲区,优先保留那些当前策略容易出错的“困难”样本。
  • 策略过拟合与正则化:随着数据集增长,神经网络可能会过拟合到早期收集的、分布已不再具有代表性的数据上。除了使用标准的L2权重衰减外,可以考虑:
    • 迭代式微调:每次迭代不是从头训练,而是在上一轮模型参数的基础上进行微调,学习率可以设置得更小。
    • 早停法:在每次迭代的重新训练中,使用一个验证集(可以从当前聚合数据中划分)来防止过拟合。
  • 探索与利用的平衡:在 collect_data_with_current_policy 阶段,我们使用了确定性策略(deterministic=True)来收集数据。这确保了数据来自当前策略的典型行为。然而,有时引入一点随机性(探索)可能有助于发现策略分布边缘的脆弱状态。你可以尝试以一定概率使用随机策略,或者添加噪声到状态中。

提示:一个实用的调试技巧是,在每次DAGGER迭代后,不仅评估整体回报,还可视化智能体运行的一两条轨迹。观察它在哪些状态下开始出现不稳定或错误,这能帮助你判断是专家标注有问题,还是策略模型容量不足,或是需要调整数据收集的规模。

为了更系统地对比不同配置的效果,我们可以设计一个小实验:

配置项选项A(基础)选项B(增加探索)选项C(使用缓冲区)
数据收集策略确定性策略ε-贪婪策略 (ε=0.1)确定性策略
数据聚合方法全部保留全部保留固定大小优先队列 (容量=5000)
策略更新方式从头训练5轮微调3轮 (低学习率)从头训练5轮
预期优势实现简单能发现更多边缘状态关注最新、最相关的数据
潜在风险计算成本随迭代线性增长可能收集到过多无关的探索数据可能遗忘重要的早期基础技能

你可以根据具体任务的计算资源和问题特性,选择合适的配置进行组合实验。

5. 超越基础DAGGER:高级变体与扩展应用

基础的DAGGER算法已经为我们提供了一个强大的模仿学习框架。但研究并未止步,许多高级变体被提出以解决更复杂的问题或提升算法效率。理解这些变体,能帮助我们在面对不同挑战时,拥有更多的工具箱。

1. 自适应数据聚合 (Adaptive DAGGER) 基础DAGGER在每次迭代中收集固定数量的新数据。自适应版本则根据当前策略的性能或不确定性,动态决定需要收集多少新数据。例如,当策略性能提升缓慢或模型对自身预测的不确定性很高时,可以增加数据收集量。

2. 基于不确定性的采样 (Uncertainty-Aware Sampling) 在收集数据时,不是均匀地使用策略运行完整轨迹,而是优先去探索那些策略模型“不确定”的状态区域。这可以通过查询模型的预测概率分布,或者使用集成模型来计算预测方差来实现。这样能更高效地收集到对策略改进最有价值的样本。

3. 与强化学习结合 (Hybrid RL/IL) 纯粹的模仿学习受限于专家水平。将DAGGER与强化学习结合,可以在专家数据的基础上,利用环境奖励信号进一步优化策略,甚至超越专家。一种常见模式是:先用DAGGER快速获得一个不错的初始策略,然后使用PPO、SAC等强化学习算法进行微调或继续优化。

4. 应用于更复杂的领域 DAGGER的思想并不局限于简单的控制任务。它已被成功应用于:

  • 机器人操作:让机器人学习复杂的抓取、装配技能,通过多次迭代纠正其在实际尝试中出现的错误姿态。
  • 自动驾驶:在模拟器中,让车辆策略不断驾驶,并在其遇到的所有场景下由规则系统或安全驾驶员提供纠正信号,以学习如何处理各种边缘案例。
  • 游戏AI:训练智能体玩复杂的视频游戏,通过不断与游戏环境交互并获取“外挂”般的专家动作建议(例如,在某个游戏状态下,由更高级的搜索算法给出最优动作),来快速提升水平。

为了让你对这些扩展有更具体的认识,这里提供一个基于不确定性的DAGGER数据收集的简化代码片段,作为思路的启发:

def collect_data_with_uncertainty_sampling(self, num_rollouts=10, uncertainty_threshold=0.2):
    """基于模型预测不确定性的数据收集"""
    new_states = []
    new_expert_actions = []
    
    for _ in range(num_rollouts):
        state, _ = self.env.reset()
        done = False
        while not done:
            state_tensor = torch.FloatTensor(state).unsqueeze(0)
            with torch.no_grad():
                logits = self.policy(state_tensor)
                probs = torch.softmax(logits, dim=1)
            
            # 计算不确定性:这里使用预测概率的熵 (entropy)
            # 熵越高,表示模型越不确定
            entropy = -torch.sum(probs * torch.log(probs + 1e-10), dim=1).item()
            
            # 如果不确定性高于阈值,则记录该状态并向专家请教
            if entropy > uncertainty_threshold:
                expert_action = self.expert.act(state)
                new_states.append(state)
                new_expert_actions.append(expert_action)
            
            # 无论是否记录,都根据当前策略采取动作继续交互
            action = torch.argmax(logits, dim=1).item()  # 这里用确定性动作
            next_state, reward, terminated, truncated, _ = self.env.step(action)
            done = terminated or truncated
            state = next_state
    
    return np.array(new_states), np.array(new_expert_actions)

这段代码展示了如何在交互过程中,实时计算策略对当前状态预测的“困惑度”(熵),并只对那些模型感到困惑的状态进行专家查询和记录。这可以显著提高数据收集的效率和针对性。

最后,记住DAGGER的核心精神是交互式学习和数据分布的主动对齐。当你面对一个模仿学习任务,并且拥有一个可以反复查询的“专家”时,DAGGER及其变体通常是比一次性行为克隆更优的选择。它要求更多的环境交互(或模拟交互)成本,但回报是一个更稳健、更能泛化到真实运行分布的策略。在实际项目中,我通常会先用少量专家数据跑通行为克隆的基线,然后快速切换到DAGGER框架进行迭代优化,这往往能带来显著的性能提升,尤其是在状态空间复杂、分布漂移严重的任务上。

流水线冒险:从CPU设计到软件工程的性能与正确性挑战 在计算机体系结构中,流水线技术通过指令重叠执行来提升处理器的吞吐量,其核心原理是将任务分解为多个阶段并行处理。然而,任务间的数据与控制依赖会引发流水线冒险,导致性能下降甚至结果错误,这一概念深刻影响着高并发系统的设计。从技术价值看,理解冒险机制是构建可靠、高效分布式系统的基石,尤其在确保数据一致性与流程正确性方面至关重要。其应用场景广泛,从CPU的乱序执行、操作数转发,到软件领域的CI/CD流程、大数据处理框架(如Apache Spark/Flink)的状态管理,都涉及对各类冒险的化解。本文聚焦于**数据冒 阅读详情

相关推荐

Neural Whole-Body Control: HOVER & ExBody2 神经全身控制实战第二部分:HOVER核心原理2.3 训练目标与损失函数(深入推导)

本文档提供了HOVER与ExBody2神经全身控制框架中多目标强化学习训练与教师-学生蒸馏的完整技术实现。高维PPO改进:针对21-34自由度人形机器人设计的自适应裁剪机制,通过监控梯度范数动态调整ϵ 阈值,平衡训练稳定性与样本效率。多目标奖励设计:整合任务跟踪精度、能量效率正则化与软安全约束的分层奖励结构,通过可配置权重实现运动自然度与跟踪性能的权衡。渐进式特权蒸馏。

u012133341的博客 44

DAGGER算法实战:如何用Python实现模仿学习中的动态数据聚合

本文深入探讨了DAGGER算法在模仿学习中的应用,重点解析了其通过动态数据聚合解决分布漂移问题的核心机制。文章提供了完整的Python实现框架,从算法原理、核心代码搭建,到动态数据聚合策略优化与可视化调试,为机器学习实践者提供了将DAGGER理论转化为实战能力的详尽指南。

qsc901234的博客 185

【信息科学与工程学】【运营科学】第二篇 C4信息与通信网络运营 (C4) ——数据中心网络运营06

13 | 司法诉讼 | 原告律师 | 争取和解优势 | 证据披露的序贯博弈 | 策略性证据释放 | 持有证据集E = {强证据e_s, 中证据e_m, 弱证据e_w}。设公众原有认知人格向量为 Pold​​=(p1​,p2​,...,pk​), 其中p_i为负面特质(如“不敬业”)。危机后, 通过行为序列 {At​}和宣传, 将公众认知向新向量 Pnew​​引导, 使得在关键维度上, Pnew​​与 Pold​​的余弦相似度降低, 并与一个正面的、可接受的“原型”(如“浪子回头”、“慈父”)对齐。

weixin_49199313的博客 1498

用PyTorch实现模仿学习:从零开始构建你的第一个AI模仿者(附完整代码)

本文通过PyTorch实战,详细介绍了模仿学习的核心思想与实现方法。文章以经典的CartPole环境为例,从零开始构建了一个基于行为克隆的AI模仿者,涵盖环境搭建、专家数据生成、神经网络模型设计、训练评估全流程,并提供了完整的代码示例。最后探讨了分布偏移、模型优化等实践挑战,为开发者入门模仿学习提供了清晰的路径。

mqtt6iot的博客 801

chrome-win64-159.0.8145.0(Canary).zip

内容概要:Chrome for Testing 官方 chrome 159.0.8145.0 win64 平台(金丝雀版通道),原版未修改,附来源说明。 适合人群:Windows 64 位 上的自动化测试工程师、爬虫开发者、CI 环境搭建者。 使用场景及目标:①Chrome for Testing 官方浏览器本体,供自动化测试使用;②与同版本 chromedriver 配套;③CI/容器环境的浏览器运行时。 其他说明:Chrome for Testing 为 Google 官方发布、允许自由分发的文件;本资源为第三方整理的下载便利服务。

chrome-headless-shell-win64-157.0.8103.38(Stable).zip

Chrome for Testing 官方指定版本的 Chrome 浏览器、ChromeDriver 与 Headless Shell 压缩包,适用于 Selenium、Playwright 等自动化测试环境搭建,覆盖 Windows、macOS、Linux 多平台,解压即可使用,无需额外安装或配置。

Python 深度强化学习第二版(六)

我们通过了解模仿学习是什么以及监督模仿学习如何运作来开始本章内容。接下来,我们学习了 DAgger 算法,在该算法中,我们将通过一系列迭代获得的数据集进行聚合,并学习最优策略。在看完 DAgger 后,我们学习了 DQfD,其中我们通过专家演示预填充回放缓冲区,并在训练阶段之前用专家演示预训练智能体。接下来,我们学习了逆向强化学习(IRL)。我们理解到,在强化学习中,我们尝试根据奖励函数寻找最优策略,而在 IRL 中,我们则是根据专家示范来学习奖励函数。

龙哥盟 1668

自考计算机系统原理(第六章计算机系统概论)-13015

名词解释 I/O 硬件 I/O软件 用户空间I/O软件 内核空间I/O 软件 系统调用处理程序 系统调用服务例程 设备驱动程序 中断服务程序 系统级1/O函数 虚拟文件系统 文件描述符 文件元数据 流缓冲区 索引节点 目录文件 目录项 系统打开文件表 磁盘高速缓存 高速缓存 RAM I / O 控制方式 程序直接控制I/O 就绪状态 中断控制I/O 中断屏蔽字 多重中断 中断嵌套 DMA 方式 DMA 控制器 设备控制器 I/O端口 控制端口 数据端口 状态端口 I/O 地址空间 独立编址方式 统一编址方

qq_23872947的博客 1154

模仿学习实战:用Python+PyTorch复现Behavior Cloning(附完整代码)

本文详细介绍了如何使用Python和PyTorch实现模仿学习中的Behavior Cloning技术,构建自动驾驶控制模型。通过环境配置、数据加载、模型设计、训练优化及部署实践,帮助开发者掌握从理论到实战的全流程,特别针对专家数据有限场景提供了数据增强和模型优化的实用技巧。

weixin_29170327的博客 203

QDMA工程搭建/windows驱动编译与性能测试

请注意,根据您的目标操作系统,您可能需要在windows启动配置中启用测试签名的驱动程序,以便启用此驱动程序的安装。右键单击设备,选择更新驱动程序软件,然后选择构建的QDMA驱动程序的文件夹(通常为。创建一个新工程,在IP Catalog中搜索QDMA,双击创建qdma ip核。驱动程序安装安装驱动程序最简单的方法是通过Windows的“设备管理器”。如果系统提示未经验证的驱动程序发布者,请选择无论如何安装此驱动程序软件。本节主要介绍QDMA驱动在Windows系统的源文件、编译和安装过程。

qq_28455081的博客 2290

GEE APP:基于Sentinel-1 SAR数据的洪水检测与制图系统:利用GEE平台实现洪涝区域提取、面积统计及矢量栅格化导出

本文介绍了一个基于Google Earth Engine平台的Sentinel-1 SAR洪水监测应用,通过自动化流程实现洪水淹没区域的精准检测与分析。系统采用Refined Lee滤波降噪和Otsu自适应阈值算法,结合SRTM地形数据消除干扰,可自动计算淹没面积并生成可视化结果。该工具提供用户友好的交互界面,支持多格式数据导出,适用于灾害应急响应、环境监测和城市规划等领域,具有云平台处理、算法鲁棒性强和操作简便等技术优势。

此星光明博客 328

从论文到代码:agile_autonomy项目核心技术全揭秘

agile_autonomy项目是"Learning High-Speed Flight in the Wild"论文的开源实现,专注于无人机在复杂自然环境中的高速自主飞行技术。该项目通过结合模型预测控制(MPC)与深度学习算法,使无人机能够在森林、山地等复杂地形中实现避障导航和高速飞行。 ## 🚀 项目核心功能展示 无人机在自然环境中的高速飞行一直是 robotics 领域的挑战。agil

gitblog_00061的博客 753

【unity实战】Unity手搓脚本工具实现合并网格功能

本文介绍了在Unity中优化网格性能的方法,通过合并重复网格减少绘制调用。主要使用Mesh.CombineMeshes方法实现网格合并,支持统一材质和多材质处理。核心内容包括:1)基础合并脚本实现,将子网格合并到父对象并禁用原网格;2)统一材质设置,支持自定义或默认材质;3)多材质合并方案,通过设置mergeSubMeshes=false保留子网格材质索引。文章还提供了完整代码示例和操作演示,适用于实际项目中的网格优化需求。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 563

2025 Python数据管道实战:从脚本到工业级数据服务

数据管道是现代数据栈的核心基础设施,其本质是将原始数据通过采集、清洗、转换、加载等环节,转化为可信、及时、可审计的业务资产。随着实时性要求升级至亚秒级、成本管控日趋严格、合规审计成为刚性需求,传统基于pandas+cron的Python脚本模式已难以满足生产环境的SLA、可观测性与契约保障。本文聚焦Python在数据管道中的新定位——作为轻量编排层,协同Polars、DuckDB等高性能引擎,并依托Pydantic Schema定义、Great Expectations质量守门、OpenTelemetry全

494

【C2000系列DSP的双向DC-DC电源】基于TMS320F28034的DC-DC项目开发流程

理解DC-DC 双向电源(基于 TMS320F28034)的开发流程,需要从功能拆解、开发步骤、验证 / 测试项

昔时扬尘处 325

22、狭义相对论与曲线坐标空间相关知识解析

本文深入解析了狭义相对论与曲线坐标空间的核心概念,涵盖能量-动量张量的定义与守恒、曲线坐标系下的度量张量与基向量性质、协变与逆变张量的变换规则,并介绍了克里斯托费尔符号与协变导数的计算方法。进一步探讨了在弯曲空间中进行微积分运算的基础理论及其在广义相对论中的关键应用,如爱因斯坦场方程如何描述物质-能量对时空曲率的影响,为理解黑洞等引力现象提供了理论框架。

lambda的博客 119

RLinf:面向具身智能的工业级强化学习流式架构

强化学习框架正从算法实验走向真实机器人部署,其核心挑战在于异构硬件协同、多模态感知-动作闭环与在线持续学习。RLinf 提出‘流式转换’(flow transformation)范式,将传统单体训练流程解耦为 Rollout Server、Update Server、Policy Server 和 Reward Server 四大可编排服务,支持跨设备调度、C++ 加速奖励计算、VLA 模型即插即用及真机低延迟策略部署。该架构天然适配具身智能场景,如 ManiSkill3 仿真训练、Franka 机械臂 S

weixin_34006468的博客 409

全志V3S嵌入式驱动开发(解决kernel 5.2.y wifi驱动问题)

​【 声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】 wifi模块,之前测试的时候,开发板上用的是esp8089,当时内核时4.14.y,测试也是通过的。链接地址在这里, https://blog.csdn.net/feixiaoxing/article/details/131178420?spm=1001.2014.3001.5501 那个时候测试的时候,我们就说过,wifi驱动可能是除了镜像制作之外,最复杂的一个

嵌入式-老费,一个分享专业嵌入式知识的blog 1162

安卓通话安全新趋势:从被动防御到主动验证的技术实现

在移动通信领域,通话安全始终是用户关注的核心问题。传统方案主要依赖云端数据库和众包标记,对来电进行被动识别与拦截,存在防护滞后、依赖网络等局限。其技术原理是通过收集用户标记数据,在云端建立信誉库,实现风险号码的识别。随着设备端AI与隐私计算技术的发展,移动安全理念正从被动防御向主动验证演进,开始覆盖拨出电话的实时风险评估。这种技术价值在于能够在呼叫发起侧就阻断异常,保护通信链路双方,有效应对伪基站和号码篡改等新型威胁。应用场景已从社交、金融App扩展到系统级通话防护。本文以谷歌Pixel的拨出电话防护功能为

weixin_33824363的博客 421

vue2 - 最新详细实现高德地图绘制动态热力图详细教程,在某区域或城市地图上做“热力图层“展示人流量、旅游人口密度、热量图、全国地区地理热力图,利用颜色的深浅表示密度或强度等场景(详细示例代码教程)

vue2,nuxt2,高德地图,热力图,绘制热力图层,报错,卡顿,出不来怎么办,无法关闭,怎么解决这个问题,出错,城市名称,城市某个街道,城区,省份,市区,县城,乡镇,村,各省份的热力图,交通流量,人口流量,密度,旅游出行,人口数量,颜色介绍,深浅代表,人流量,vue2使用高德地图实现某个区域热力图,vue高德地图api加载热力图及关闭,接收热力图数据并渲染热力图,关掉热力图,Vue使用高德API制作热力图,热力图加载不出来,电子围栏围住热力图,vue2中使用高德地图渲染热力图组件,高德地图使用热力图详细教

✅ 精选推荐文章 4204

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

从工具到工程:Harness Engineering如何重塑软件测试与部署体系

在软件工程领域,测试工具和部署脚本是保障软件质量与交付效率的基础设施。然而,随着微服务架构和云原生技术的普及,传统的离散化工具链往往导致环境不一致、脚本难以复用和团队协作摩擦增大。其核心原理在于通过工程化方法,将测试、部署等任务进行标准化、模块化和自动化编排,从而构建一套可复用、可观测的‘连接体系’。这一实践的技术价值在于显著提升交付流水线的可靠性、可重复性,并降低维护成本。其典型应用场景包括复杂微服务系统的集成测试、多环境一致性验证以及持续交付流水线的构建。通过引入声明式任务定义、统一环境管理和智能编排引

weixin_30698527的博客 344

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Julia与PySpark大文件读写性能实测:6.5GB CSV单机IO深度对比

CSV文件读写是数据工程 pipeline 的第一道关卡,其性能直接决定ETL启动延迟与资源占用。本文聚焦单机环境下GB级CSV的I/O瓶颈,解析底层原理:CSV解析本质是字符流切分、类型推断与内存映射的协同过程;性能差异不仅源于语言范式(JIT编译 vs JVM优化),更取决于缓冲策略、线程调度、schema预设等工程细节。技术价值在于揭示‘配置即性能’——Julia的CSV.jl通过threaded=true和buffer_size调优可提升34%读取速度,PySpark则依赖spark.sql.fil

weixin_33871366的博客 978

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

3分钟极速部署:Hermes WebUI Docker容器化完整指南

想在几分钟内拥有一个功能强大的AI助手界面吗?Hermes WebUI正是你需要的终极解决方案!这个基于Docker的Web界面工具让任何人都能轻松地从网页或手机访问Hermes Agent的强大功能。无论你是开发者、项目经理还是普通用户,通过本文的完整指南,你将在3分钟内完成Hermes WebUI的Docker部署并开始使用。 ## 🔍 为什么选择Hermes WebUI Docker部署

gitblog_00232的博客 972

我的2018年终总结(进阶之路)| 掘金年度征文

前言 成为一名优秀的Android开发,需要一份完备的知识体系,在这里,让我们一起成长为自己所想的那样~。 更好的阅读体验请跳转到个人博客站点 今天,已经是2018年最后一天的工作日了,回想2018学习路上的点点滴滴,有收获和喜悦,也有烦恼与焦虑,但是,总的来说,这一年,我在技术上的提升还是比较大的,因此,我感觉,我的付出是值得的,接下来,回顾一下2018年我的成长轨迹。 一、回顾我的2018年 ...

weixin_34162629的博客 445
上一篇: Jetson工业级应用避坑指南:AGX Orin与Orin NX的实战对比
下一篇: 【算法竞赛实战】资金流动预测:从Baseline优化到特征工程进阶
辟谣的大舌头LONG
博客等级 码龄10年 78粉丝 8867原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址