24/8/17算法笔记 MPC算法

于 2024-08-17 21:57:04 发布
阅读量356 收藏 3
点赞数 6
文章标签： 算法 笔记 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyyy2711/article/details/141286424
版权

MPC算法，在行动前推演一下

MPC（Model Predictive Control，模型预测控制）是一种先进的控制策略，它利用未来预测模型来优化当前的控制动作。MPC的核心思想是，在每一个控制步骤中，都基于当前系统状态的测量值，通过预测模型向前看若干步，并计算出一个使未来输出最优化的控制序列。然后，只应用这个序列的第一个控制动作，并在下一个时间步重复这个过程。

MPC算法的主要特点包括：

  1. 滚动时域优化：MPC在每一个控制步骤中解决一个有限时间范围内的优化问题，而不是试图直接解决整个控制任务。

  2. 模型预测：利用系统模型来预测未来的行为。这个模型可以是物理模型，也可以是基于数据的模型。

  3. 约束处理：MPC可以自然地处理系统的输入和输出约束，例如，限制控制输入的最大和最小值，或者状态变量的运行范围。

  4. 优化目标：通常包括跟踪预定轨迹、最小化能耗、保证系统稳定性等。

  5. 反馈校正：由于实际系统与模型之间存在差异，MPC通常会在每个控制周期中使用最新的测量状态来更新预测并重新优化。

MPC算法的一般步骤包括：

  1. 状态测量：获取当前系统状态的实际测量值。

  2. 模型预测：使用当前状态和预测模型来预测未来的状态和输出。

  3. 优化问题设置：定义目标函数和约束条件，设置优化问题。

  4. 求解优化问题：求解优化问题，得到最优控制序列。

  5. 应用控制动作：将优化问题的解，即控制序列的第一个控制动作应用到系统上。

  6. 重复过程：在下一个控制周期，重复上述步骤。

MPC算法广泛应用于化工、石油、交通、航空等众多领域，特别是在需要考虑复杂约束和多步预测的场合。然而，MPC算法的性能在很大程度上依赖于模型的准确性和优化算法的选择。随着计算能力的提升和优化算法的发展，MPC在实际工业应用中的使用越来越广泛。

import gym
#创建环境
env = gym.make('Pendulum-v1')

定义样本池对象

import numpy as np
import torch

class Pool:
    def __init__(self,limit):
        #样本池
        self.datas = []
        self.limit = limit
    def add(self,state,action,reward,next_state,over):
        if isinstance(state,np.ndarray) or isinstance(state,torch.Tensor):#检查变量 state 是否是 bo.ndarray 或者 torch.Tensor 类型
            state = state.reshape(3).tolist()
        action = float(action)
        reward = float(reward)
        
        if isinstance(next_state,np.ndarray) or isinstance(
                next_state,torch.Tensor):
            next_state = next_state.reshape(3).tolist()
        over = bool(over)
        self.datas.appen((state,action,reward,next_state,over))
        #数据上限，超出时从最古老的开始删除
        while len(self.datas)>self.limit:
            self.datas.pop(0)
        #获取一批数据样本
    def get_sample(self):

        samples = self.datas
            
        state = torch.FloatTensor([i[0] for i in samples]).reshape(-1,3)
        action = torch.FloatTensor([i[1] for i in samples]).reshape(-1,1)
        reward = torch.FloatTensor([i[2] for i in samples]).reshape(-1,1)     
        next_state = torch.FloatTensor([i[3]for i in samples]).reshape(-1,3)
        over = torch.LongTensor([i[4]for i in samples]).reshape(-1,1)
        input = torch.cat([state,action],dim=1)
        label = torch.cat([rewarrd,next_state-state],dim=1)
        return input,label
    def _len_(self):
        return len(self_datas)

初始化样本池，并添加一局游戏的数据

pool = Pool(1000000)

#初始化一局游戏的数据
def _():
    #初始化游戏
    state = env.reset()
    
    #玩到游戏结束为止
    over = False
    while not over:
        #随机一个动作
        action = env.action_space.sample()[0]
        #执行动作，得到反馈
        next_state,reward,over,_ = env.step([action])
        
        #记录数据样本
        pool.add(state,action,reward,next_state,over)
        
        #更新游戏状态，开始下一个动作
        state = next_state

定义主模型

import random
#定义主模型
class Model(torch.nn.Module):
    
    #swish激活函数
    class Swish(torch.nn.Module):
        def __init__(self):
            super().__init__()
        def forward(self,x):
            return X*torch.sigmoid(x)

主模型中的FC层

#定义一个工具层
class FCLayer(torch.nn.Module):
    def __init__(self,in_size,out_size):
        super().__init__()
        self.in_size = in_size
        #初始化参数
        std  = in_size**0.5
        std *=2
        std = 1/std
        
        weight = torch.empty(5, in_size,out_size)
        torch.nn.init.normal_(weight,mean=0.0,std=std)
        
        self.weight = torch.nn.Parameter(weighr)
        
        self.bias = torch.nn.Parameter(torch.zeros(5,1,out_size))
    def forward(self,x):
        x = torch.bmm(x,self.weight)
        x = x+self.bias
        return x

主模型初始化函数

def __init__(self):
    super().__init__()
    
    self.sequential = torch.nn.Sequential(
        self.FCLayer(4,200), #全连接层（线性层）
        self.Swish(), #激活函数层
        self.FCLayer(200,200),
        self.Swish(),
        self.FCLayer(200,200),
        self.Swish(), 
        self.FCLayer(200,200),
        self.Swish(),
        self.FCLayer(200,8),
        torch.nn.Identity(),
    )
    self.softplus = torch.nn.Softplus() #Softplus 是一个平滑的ReLU激活函数
    self.optimizer = torch.optim.Adam(self.parameters(),lr=1e-3)

主模型计算过程,计算结果是一个均值和log方差，对logvar的加减操作是为了调整logvar的最大最小值

def forward(self,x):
    x = self.sequential(x)
    mean  = x[...,:4]
    
    logvar = x[...,4:]
    
    logvar = 0.5 - logvar
    
    logva = 0.5 -self.softplus(logvar)
    
    logvar = logvar+10
    
    logvar = self.softplus(logvar)-10
    return mean,logvar

主模型的训练函数

def train(self,input,label):
    #反复训练N次
    for _ in range(len(input)//64*20):
        #从全量数据中抽样64个，反复抽5遍，形成5份数据
        select = [torch.randperm(len(input))[:64] for _ in range(5)]
        select =torch.stack(select)
        
        input_select = input[select]
        label_select = label[select]
        del select
        
        #模型计算
        mean,logvar = model(input_select)
        
        #计算loss
        mse_loss = (mean - label_select)**2*(-logvar).exp()
        
        mse_loss = mse_loss.mean(dim=1).mean()
        var_loss+logvar.mean(dim=1).mean()
        
        loss =mse_loss+var_loss
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

初始化主模型

model = Model()

a,b = model(torch.randn(5,64,4))
a.shape,b.shape

MPC fake step函数，功能是根据state和action估计reward和next_state

class MPC:
    def _fake_step(self,state,action):
        
        input = torch.cat([state,action],dim=1)
        
        #重复5遍
        input = input.unsqueeze(dim=0).repeat([5,1,1])
        
        #模型计算
        with torch.no_grad():
            mean,std = model(input)
        std = std.exp().sqrt()
        del input
        
        #means的后3列加上环境数据
        mean[:,:,1:]+=state
        
        #重采样
        sample = torch.distributions.Normal(0,1).sample(mean.shape)
        
        #0-4的值域采样b个元素
        select = [random.choice(range(5))for _ in range(mean.shape[1])]
        
        #重采样结果，第0个维度，0-4随机选择，第二个维度，0-b顺序选择
        sample = sample[select,range(mean.shape[1])]
        
        #切分一下，就成了rewards,next_state
        reward,next_state = sample[:,:1],sample[:,1:]
        return reward,next_state

MPC cem优化函数，虚拟N条动作链，并优化M次，求与孤寂结果最佳的分布

    def _cem_optimizer(self,state,mean):
        state = torch.FloatTensor(state).reshape(1,3)
        var = torch.ones(25)
        
        #当前游戏的环境信息，复制50次
        state = state.repeat(50,1)
        
        #循环5次，寻找最优解
        for _ in range(5):
            #采样50个标准正态分布数据作为action
            actions = torch.distributions.Normal(0,1).sample([50,25])
            
            #乘以标准差，加上均值
            actions *=var**0.5
            actions +=mean
            
            #计算每条动作序列的累计奖励
            
            reward_sum = torch.zeros(50,1)
            
            #遍历25个动作
            for i in range(25):
                action = actions[:,i].unsqueeze(dim=1)
                
                #现在是不能真的去玩游戏的，只能去预测reward和next_state
                reward,next_state = self._fake_step(state,action)
                
                reward_sum += reward
                
                state = next_state
            #按照reward_sum从小到大排序
            select = torch.sort(reward_sum.squeeze(dim=1)).indices
            actions = actions[select]
            del select
            
            #取发聩最优的10个动作链
            actions = actions[-5:]
            
            #在下一次随机动作时，希望贴近这些动作的分布
            new_mean = actions.mean(dim= 0)
            new_var = actions.var(dim=0)
            
            #增量更新
            mean = 0.1*mean +0.9*new_mean
            var = 0.1*var+0.9*new_var
        return mean

MPC mpc函数，每次动作都预演N次，求预演结果最佳的分布

def mpc(self):
    #初始化动作的分布均值都是0
    mean = torch.zeros(25)
    
    reward_sum = 0
    state = env.reset()
    over = False
    while not over:
        #当前状态下，找25个最优都知道均值
        actions = self._cem_optimize(state,mean)
        #执行第一个动作
        action = actions[0].item()
        
        #执行动作
        next_state,reward,over,_ = env.step([action])
        
        #增加数据
        pool.add(state,action,reward,next_state,over)
        
        state = next_state
        reward_sum +=reward
        
        #下个动作的均值，在当前动作均值的基础上寻找
        mean = torch.empty(actions.shape)
        mean[:-1] = actions[1:]
        mean[-1] = 0
    return reward_sum

初始化MPC对象

mpc = MPC()
a,b = mpc._fake_step(torch.randn(200,3),torch.randn(200,1))
print(a.shape,b.shape)
print(mpc._cem_optimize(torch.randn(1,3),,torch.zeros(25)).shape)

训练

for i in range(10):
    input,label = pool.get_sample()
    model.train(input,label)
    reward_sum = mpc.mpc()
    print(i,len(pool),reward_sum)
青椒大仙KI11
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【MPC】pub-多变量动态矩阵控制器（DMC）.zip
05-22
包含一个基于MATLAB语言编写的多变量动态矩阵控制（DMC）算法的程序和对应的笔记（包含详细的笔记和公式推导过程）。参考的资料是席裕庚的《预测控制》，算法中考虑了模型的不确定性和扰动，但暂时未考虑约束。
MATLAB简单飞行器模拟笔记.md
09-08
### MATLAB简单飞行器模拟笔记 #### 一、引言 本文档旨在介绍如何利用MATLAB进行复杂的多输入多输出（MIMO）控制系统的设计与优化，特别聚焦于控制一架复杂的飞行器，确保其在不同飞行模式下的稳定运行。通过本指南...
SML入门/基于SPU迁移机器学习算法实践学习笔记
m0_68514117的博客
06-21 1522
训练完成后，你可以使用SML的库函数来评估模型的性能，比如计算准确率、精确率和召回率等。总结来说，基于SPU迁移机器学习算法的实践学习过程包括学习SML基本语法、导入机器学习库、数据预处理、特征选择、模型训练和评估、模型优化等步骤。模型优化：如果模型性能不理想，你可以使用SML的库函数来进行模型优化，比如使用交叉验证、调整超参数等。你还可以使用SML的库函数来进行特征选择和模型集成等操作，以提高模型的性能。特征选择：在训练模型之前，你可能还需要对数据进行特征选择操作，以减少特征的数量并提高模型的性能。
【隐私计算篇】SML入门/基于SPU实现明文算法迁移密文模型的实践
weixin_65514978的博客
06-20 1424
SPU、明文模型改造成密文模型、aby3、cheetah、semi2k、定点数
Motion Plan之搜索算法笔记
liangwqi的博客
11-20 1524
本文介绍了motion plan学院派的框架： 1.前端路径规划 2.后端轨迹生成 3.不确定障碍物预估规划 并且详细介绍了前端路径规划常用的搜索规划，介绍了搜索规划的一些前置知识： 1.c-space，为了方便物体质点化处理，建图时把物体形状构建转移到图 2.各种不同图如何构建成适合搜索算法的数据格式，以及不同图适合的搜索算法 3.搜索算法的三个基本框架：深度搜索、广度搜索、贪心搜索 详细介绍了了几种贪心搜索算法原理和实现思路： 1.Dijkstra算法： 2.A*搜索 3.跳点搜索 并且介绍了：累计成本
MIT四足机器狗MPC算法学习笔记
wills9的博客
08-04 5183
暑假去机器人相关单位实习，学习运动控制相关内容。现学现卖，磨出了一篇学习笔记。由于非相关专业，估计会有不少错误，欢迎批评指正！
ESO+LTV MPC算法笔记
记录老板的每次pua，分享领导每天的毒鸡汤...
12-14 1027
问题起因： 理想模型的输入无时延，实际模型中，因为伺服电机的存在，所以存在惯性，可以将这个惯性时间常数当作一个纯时延。 解决办法：在ESO的u输入当添加一个delay模块，调整时延系数以适应实际系统输入的惯性导致的时延。 ...
多机器人路径规划CBS/ECBS等 libmultiRobotPlanning 代码阅读笔记
lovebc的博客
06-20 4194
CBS阅读代码
【模型预测控制MPC】：深蓝路径规划课程P8笔记
weixin_47765522的博客
10-18 1255
简介：模型预测控制在机器人学的应用，涉及线性MPC、非线性MPC以及粒子群优化算法的JLT问题求解。
MPC与LQR详细分析比较
zxy_ZXY123的博客
02-28 2682
本文主要针对MPC和LQR进行对比，分析各自的特点。
MPC学习笔记（1）——原理
DalaoHub
10-30 2361
在自动驾驶或机器人领域中，模型预测控制(Model Predictive Control, MPC)解决的是轨迹规划的问题。其前提条件是环境地图、载体位姿已知，根据MPC算法，得到一条轨迹，轨迹中包含载体运行所需的每一时刻的速度信息，最终实现对载体的控制。
基于Matlab实现模型预测控制(MPC)源码+项目说明.zip
01-13
([笔记推导](./MPC_notes.pdf)) 在控制的教材中，常常考虑参考信号为0的简化情况。在参考信号不为0的情况下，可以通过引入误差$e=z-z_{d}$，将误差作为新的状态量，可以将问题重新转换为参考信号=0的情况(参考误差...
考古apollo3.0 EMplanner笔记rawio
02-18
这个组件可能采用了非动态规划的方法，如模型预测控制（Model Predictive Control, MPC），以适应不断变化的驾驶环境。 4. **PathDecider**: 路径决策器负责处理来自上层规划模块的指令，生成适合车辆行驶的具体...
carsim2019学习笔记，观看B站视频
04-25
MPC（Model Predictive Control，模型预测控制）是一种常用的控制算法，用于控制汽车的运动。Carsim 软件提供了 MPC 跟踪圆形轨迹的功能，用户可以使用该功能来模拟汽车的运动。 3. Carsim 中 cpar 知识 Carsim ...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 374
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
【LeetCode】字母异位词分组
最新发布
LittleFishC的博客
08-14 263
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
【算法】有效的字母异位词
时清云的博客
08-13 280
针对字母异位词的问题，还有一种较为直观且高效的解法，那就是使用哈希映射（在 JavaScript 中通常是对象或 Map）。要判断两个字符串s和t是否是字母异位词，核心思想是检查两个字符串中每个字符出现的次数是否完全相同。要判断两个字符串s和t是否是字母异位词，核心思想是检查两个字符串中每个字符出现的次数是否完全相同。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 543
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值