【MADRL】反事实多智能体策略梯度法(COMA)算法

news2024/11/23 12:25:14

        本篇文章是博主强化学习RL领域学习时,用于个人学习、研究或者欣赏使用,并基于博主对相关等领域的一些理解而记录的学习摘录和笔记,若有不当和侵权之处,指出后将会立即改正,还望谅解。文章分类在强化学习专栏:

       强化学习(1)---《【MADRL】反事实多智能体策略梯度法(COMA)算法》

【MADRL】反事实多智能体策略梯度法(COMA)算法

目录

0.介绍

1.算法背景和思想

2.公式推导

3.COMA 算法步骤

4.优势

5.应用场景

 [Python] COMA 算法实现


0.介绍

        反事实多智能体策略梯度法COMA (Counterfactual Multi-Agent Policy Gradient) 是一种面向多智能体协作问题的强化学习算法,旨在通过减少策略梯度的方差,来提升去中心化智能体的学习效果。

        COMA 算法最早由 DeepMind 团队提出,论文标题为 "Counterfactual Multi-Agent Policy Gradients",由 Jakob Foerster 等人于 2017 年在 AAAI 会议上发表。适用于局部观察、去中心化决策的多智能体环境,特别是策略梯度方法下的合作问题。

参考文献:Counterfactual Multi-Agent Policy Gradients


1.算法背景和思想

        在多智能体强化学习场景中,每个智能体在某一时刻只掌握局部的信息,无法全局观测环境状态。为了促进合作,各个智能体的动作对全局奖励有不同的贡献,因此需要一种有效的方法来分配奖励。COMA 引入了“反事实基线”(Counterfactual Baseline)的概念,专门用于降低多智能体策略梯度方法中的方差。

        COMA 的核心思想是通过引入一个基线,该基线模拟在固定其他智能体动作的前提下,某个智能体选择不同动作时对全局奖励的影响,从而更精确地衡量当前动作的贡献,减少策略梯度更新中的方差。

07286bd3fb604b36a2acc3ac5d29a5e5.png


2.公式推导

  1. 全局策略梯度:对于多智能体问题,每个智能体eq?%28%20i%20%29的策略梯度可以表示为:

    eq?%5B%20%5Cnabla_%7B%5Ctheta_i%7D%20J%28%5Ctheta_i%29%20%3D%20%5Cmathbb%7BE%7D%5Cleft%5B%20%5Cnabla_%7B%5Ctheta_i%7D%20%5Clog%20%5Cpi_%7B%5Ctheta_i%7D%28a_i%7Cs%29%20Q_i%28s%2C%20a%29%20%5Cright%5D%20%5D

    其中,eq?%28%20%5Cpi_%7B%5Ctheta_i%7D%28a_i%7Cs%29%20%29是智能体eq?%28%20i%20%29在状态eq?%28%20s%20%29下选择动作eq?%28%20a_i%20%29的概率,eq?%28%20Q_i%28s%2C%20a%29%20%29是该智能体在执行动作eq?%28%20a_i%20%29时的动作价值函数。

  2. 反事实基线:为了减小方差,COMA 提出了反事实基线eq?%28%20b%28s%2C%20a_%7B-i%7D%29%20%29,该基线衡量在保持其他智能体动作eq?%28%20a_%7B-i%7D%20%29不变的情况下,智能体eq?%28%20i%20%29 选择其他动作时的期望收益。具体公式为:

    eq?%5B%20b%28s%2C%20a_%7B-i%7D%29%20%3D%20%5Csum_%7Ba_i%7D%20%5Cpi_%7B%5Ctheta_i%7D%28a_i%7Cs%29%20Q_i%28s%2C%20a_i%2C%20a_%7B-i%7D%29%20%5D

    这里的eq?%28%20a_%7B-i%7D%20%29表示除智能体eq?%28%20i%20%29之外,其他智能体的动作组合。

  3. 策略更新:有了反事实基线之后,COMA 中智能体eq?%28%20i%20%29的策略更新公式变为:

    eq?%5B%20%5Cnabla_%7B%5Ctheta_i%7D%20J%28%5Ctheta_i%29%20%3D%20%5Cmathbb%7BE%7D%5Cleft%5B%20%5Cnabla_%7B%5Ctheta_i%7D%20%5Clog%20%5Cpi_%7B%5Ctheta_i%7D%28a_i%7Cs%29%20%28Q_i%28s%2C%20a%29%20-%20b%28s%2C%20a_%7B-i%7D%29%29%20%5Cright%5D%20%5D

    其中,eq?%28%20Q_i%28s%2C%20a%29%20%29是在当前状态下,所有智能体执行一组动作eq?%28%20a%20%29时的全局奖励,而eq?%28%20b%28s%2C%20a_%7B-i%7D%29%20%29是该动作的反事实基线。

  4. 全局值函数:COMA 中的值函数 eq?%28%20Q%28s%2C%20a%29%20%29和基线 eq?%28%20b%28s%2C%20a_%7B-i%7D%29%20%29都是通过集中化的学习进行优化的,虽然决策是去中心化的,但值函数和基线都依赖于全局的状态和动作信息。


3.COMA 算法步骤

  1. 初始化智能体策略和集中式的全局值函数。
  2. 智能体与环境交互,收集经验数据。
  3. 使用经验数据更新全局值函数 eq?%28%20Q%28s%2C%20a%29%20%29
  4. 计算反事实基线 eq?%28%20b%28s%2C%20a_%7B-i%7D%29%20%29
  5. 计算每个智能体的策略梯度,并更新策略参数。
  6. 重复上述过程,直至智能体策略收敛。

4.优势

  • 减少策略梯度的方差:通过引入反事实基线,有效地减少了策略更新过程中的高方差问题,使得策略更新更加稳定。
  • 适合多智能体协作环境:COMA 尤其适合智能体需要紧密合作的场景,比如多智能体联合行动或团队任务。

5.应用场景

  • 多智能体合作任务,如多机器人协作、多无人机编队等。
  • 需要去中心化控制、但全局奖励信息可用的场景。

 [Python] COMA 算法实现

主要代码:

import torch
import os
from network.base_net import RNN
from network.commnet import CommNet
from network.g2anet import G2ANet
from network.coma_critic import ComaCritic
from common.utils import td_lambda_target


class COMA:
    def __init__(self, args):
        self.n_actions = args.n_actions
        self.n_agents = args.n_agents
        self.state_shape = args.state_shape
        self.obs_shape = args.obs_shape
        actor_input_shape = self.obs_shape  # actor网络输入的维度,和vdn、qmix的rnn输入维度一样,使用同一个网络结构
        critic_input_shape = self._get_critic_input_shape()  # critic网络输入的维度
        # 根据参数决定RNN的输入维度
        if args.last_action:
            actor_input_shape += self.n_actions
        if args.reuse_network:
            actor_input_shape += self.n_agents
        self.args = args

        # 神经网络
        # 每个agent选动作的网络,输出当前agent所有动作对应的概率,用该概率选动作的时候还需要用softmax再运算一次。
        if self.args.alg == 'coma':
            print('Init alg coma')
            self.eval_rnn = RNN(actor_input_shape, args)
        elif self.args.alg == 'coma+commnet':
            print('Init alg coma+commnet')
            self.eval_rnn = CommNet(actor_input_shape, args)
        elif self.args.alg == 'coma+g2anet':
            print('Init alg coma+g2anet')
            self.eval_rnn = G2ANet(actor_input_shape, args)
        else:
            raise Exception("No such algorithm")

        # 得到当前agent的所有可执行动作对应的联合Q值,得到之后需要用该Q值和actor网络输出的概率计算advantage
        self.eval_critic = ComaCritic(critic_input_shape, self.args)
        self.target_critic = ComaCritic(critic_input_shape, self.args)

        if self.args.cuda:
            self.eval_rnn.cuda()
            self.eval_critic.cuda()
            self.target_critic.cuda()

        self.model_dir = args.model_dir + '/' + args.alg + '/' + args.map
        # 如果存在模型则加载模型
        if self.args.load_model:
            if os.path.exists(self.model_dir + '/rnn_params.pkl'):
                path_rnn = self.model_dir + '/rnn_params.pkl'
                path_coma = self.model_dir + '/critic_params.pkl'
                map_location = 'cuda:0' if self.args.cuda else 'cpu'
                self.eval_rnn.load_state_dict(torch.load(path_rnn, map_location=map_location))
                self.eval_critic.load_state_dict(torch.load(path_coma, map_location=map_location))
                print('Successfully load the model: {} and {}'.format(path_rnn, path_coma))
            else:
                raise Exception("No model!")

        # 让target_net和eval_net的网络参数相同
        self.target_critic.load_state_dict(self.eval_critic.state_dict())

        self.rnn_parameters = list(self.eval_rnn.parameters())
        self.critic_parameters = list(self.eval_critic.parameters())

        if args.optimizer == "RMS":
            self.critic_optimizer = torch.optim.RMSprop(self.critic_parameters, lr=args.lr_critic)
            self.rnn_optimizer = torch.optim.RMSprop(self.rnn_parameters, lr=args.lr_actor)
        self.args = args

        # 执行过程中,要为每个agent都维护一个eval_hidden
        # 学习过程中,要为每个episode的每个agent都维护一个eval_hidden
        self.eval_hidden = None

    def _get_critic_input_shape(self):
        # state
        input_shape = self.state_shape  # 48
        # obs
        input_shape += self.obs_shape  # 30
        # agent_id
        input_shape += self.n_agents  # 3
        # 所有agent的当前动作和上一个动作
        input_shape += self.n_actions * self.n_agents * 2  # 54

        return input_shape

    def learn(self, batch, max_episode_len, train_step, epsilon):  # train_step表示是第几次学习,用来控制更新target_net网络的参数
        episode_num = batch['o'].shape[0]
        self.init_hidden(episode_num)
        for key in batch.keys():  # 把batch里的数据转化成tensor
            if key == 'u':
                batch[key] = torch.tensor(batch[key], dtype=torch.long)
            else:
                batch[key] = torch.tensor(batch[key], dtype=torch.float32)
        u, r, avail_u, terminated = batch['u'], batch['r'],  batch['avail_u'], batch['terminated']
        mask = (1 - batch["padded"].float()).repeat(1, 1, self.n_agents)  # 用来把那些填充的经验的TD-error置0,从而不让它们影响到学习
        if self.args.cuda:
            u = u.cuda()
            mask = mask.cuda()
        # 根据经验计算每个agent的Q值,从而跟新Critic网络。然后计算各个动作执行的概率,从而计算advantage去更新Actor。
        q_values = self._train_critic(batch, max_episode_len, train_step)  # 训练critic网络,并且得到每个agent的所有动作的Q值
        action_prob = self._get_action_prob(batch, max_episode_len, epsilon)  # 每个agent的所有动作的概率

        q_taken = torch.gather(q_values, dim=3, index=u).squeeze(3)  # 每个agent的选择的动作对应的Q值
        pi_taken = torch.gather(action_prob, dim=3, index=u).squeeze(3)  # 每个agent的选择的动作对应的概率
        pi_taken[mask == 0] = 1.0  # 因为要取对数,对于那些填充的经验,所有概率都为0,取了log就是负无穷了,所以让它们变成1
        log_pi_taken = torch.log(pi_taken)


        # 计算advantage
        baseline = (q_values * action_prob).sum(dim=3, keepdim=True).squeeze(3).detach()
        advantage = (q_taken - baseline).detach()
        loss = - ((advantage * log_pi_taken) * mask).sum() / mask.sum()
        self.rnn_optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.rnn_parameters, self.args.grad_norm_clip)
        self.rnn_optimizer.step()
        # print('Training: loss is', loss.item())
        # print('Training: critic params')
        # for params in self.eval_critic.named_parameters():
        #     print(params)
        # print('Training: actor params')
        # for params in self.eval_rnn.named_parameters():
        #     print(params)

    def _get_critic_inputs(self, batch, transition_idx, max_episode_len):
        # 取出所有episode上该transition_idx的经验
        obs, obs_next, s, s_next = batch['o'][:, transition_idx], batch['o_next'][:, transition_idx],\
                                   batch['s'][:, transition_idx], batch['s_next'][:, transition_idx]
        u_onehot = batch['u_onehot'][:, transition_idx]
        if transition_idx != max_episode_len - 1:
            u_onehot_next = batch['u_onehot'][:, transition_idx + 1]
        else:
            u_onehot_next = torch.zeros(*u_onehot.shape)
        # s和s_next是二维的,没有n_agents维度,因为所有agent的s一样。其他都是三维的,到时候不能拼接,所以要把s转化成三维的
        s = s.unsqueeze(1).expand(-1, self.n_agents, -1)
        s_next = s_next.unsqueeze(1).expand(-1, self.n_agents, -1)
        episode_num = obs.shape[0]
        # 因为coma的critic用到的是所有agent的动作,所以要把u_onehot最后一个维度上当前agent的动作变成所有agent的动作
        u_onehot = u_onehot.view((episode_num, 1, -1)).repeat(1, self.n_agents, 1)
        u_onehot_next = u_onehot_next.view((episode_num, 1, -1)).repeat(1, self.n_agents, 1)

        if transition_idx == 0:  # 如果是第一条经验,就让前一个动作为0向量
            u_onehot_last = torch.zeros_like(u_onehot)
        else:
            u_onehot_last = batch['u_onehot'][:, transition_idx - 1]
            u_onehot_last = u_onehot_last.view((episode_num, 1, -1)).repeat(1, self.n_agents, 1)

        inputs, inputs_next = [], []
        # 添加状态
        inputs.append(s)
        inputs_next.append(s_next)
        # 添加obs
        inputs.append(obs)
        inputs_next.append(obs_next)
        # 添加所有agent的上一个动作
        inputs.append(u_onehot_last)
        inputs_next.append(u_onehot)

        # 添加当前动作
        '''
        因为coma对于当前动作,输入的是其他agent的当前动作,不输入当前agent的动作,为了方便起见,每次虽然输入当前agent的
        当前动作,但是将其置为0相量,也就相当于没有输入。
        '''
        action_mask = (1 - torch.eye(self.n_agents))  # th.eye()生成一个二维对角矩阵
        # 得到一个矩阵action_mask,用来将(episode_num, n_agents, n_agents * n_actions)的actions中每个agent自己的动作变成0向量
        action_mask = action_mask.view(-1, 1).repeat(1, self.n_actions).view(self.n_agents, -1)
        inputs.append(u_onehot * action_mask.unsqueeze(0))
        inputs_next.append(u_onehot_next * action_mask.unsqueeze(0))

        # 添加agent编号对应的one-hot向量
        '''
        因为当前的inputs三维的数据,每一维分别代表(episode编号,agent编号,inputs维度),直接在后面添加对应的向量
        即可,比如给agent_0后面加(1, 0, 0, 0, 0),表示5个agent中的0号。而agent_0的数据正好在第0行,那么需要加的
        agent编号恰好就是一个单位矩阵,即对角线为1,其余为0
        '''
        inputs.append(torch.eye(self.n_agents).unsqueeze(0).expand(episode_num, -1, -1))
        inputs_next.append(torch.eye(self.n_agents).unsqueeze(0).expand(episode_num, -1, -1))

        # 要把inputs中的5项输入拼起来,并且要把其维度从(episode_num, n_agents, inputs)三维转换成(episode_num * n_agents, inputs)二维
        inputs = torch.cat([x.reshape(episode_num * self.n_agents, -1) for x in inputs], dim=1)
        inputs_next = torch.cat([x.reshape(episode_num * self.n_agents, -1) for x in inputs_next], dim=1)
        return inputs, inputs_next

    def _get_q_values(self, batch, max_episode_len):
        episode_num = batch['o'].shape[0]
        q_evals, q_targets = [], []
        for transition_idx in range(max_episode_len):
            inputs, inputs_next = self._get_critic_inputs(batch, transition_idx, max_episode_len)
            if self.args.cuda:
                inputs = inputs.cuda()
                inputs_next = inputs_next.cuda()
            # 神经网络输入的是(episode_num * n_agents, inputs)二维数据,得到的是(episode_num * n_agents, n_actions)二维数据
            q_eval = self.eval_critic(inputs)
            q_target = self.target_critic(inputs_next)

            # 把q值的维度重新变回(episode_num, n_agents, n_actions)
            q_eval = q_eval.view(episode_num, self.n_agents, -1)
            q_target = q_target.view(episode_num, self.n_agents, -1)
            q_evals.append(q_eval)
            q_targets.append(q_target)
        # 得的q_evals和q_targets是一个列表,列表里装着max_episode_len个数组,数组的的维度是(episode个数, n_agents,n_actions)
        # 把该列表转化成(episode个数, max_episode_len, n_agents,n_actions)的数组
        q_evals = torch.stack(q_evals, dim=1)
        q_targets = torch.stack(q_targets, dim=1)
        return q_evals, q_targets

    def _get_actor_inputs(self, batch, transition_idx):
        # 取出所有episode上该transition_idx的经验,u_onehot要取出所有,因为要用到上一条
        obs, u_onehot = batch['o'][:, transition_idx], batch['u_onehot'][:]
        episode_num = obs.shape[0]
        inputs = []
        inputs.append(obs)
        # 给inputs添加上一个动作、agent编号

        if self.args.last_action:
            if transition_idx == 0:  # 如果是第一条经验,就让前一个动作为0向量
                inputs.append(torch.zeros_like(u_onehot[:, transition_idx]))
            else:
                inputs.append(u_onehot[:, transition_idx - 1])
        if self.args.reuse_network:
            # 因为当前的inputs三维的数据,每一维分别代表(episode编号,agent编号,inputs维度),直接在dim_1上添加对应的向量
            # 即可,比如给agent_0后面加(1, 0, 0, 0, 0),表示5个agent中的0号。而agent_0的数据正好在第0行,那么需要加的
            # agent编号恰好就是一个单位矩阵,即对角线为1,其余为0
            inputs.append(torch.eye(self.args.n_agents).unsqueeze(0).expand(episode_num, -1, -1))
        # 要把inputs中的三个拼起来,并且要把episode_num个episode、self.args.n_agents个agent的数据拼成40条(40,96)的数据,
        # 因为这里所有agent共享一个神经网络,每条数据中带上了自己的编号,所以还是自己的数据
        inputs = torch.cat([x.reshape(episode_num * self.args.n_agents, -1) for x in inputs], dim=1)
        return inputs

    def _get_action_prob(self, batch, max_episode_len, epsilon):
        episode_num = batch['o'].shape[0]
        avail_actions = batch['avail_u']  # coma不用target_actor,所以不需要最后一个obs的下一个可执行动作
        action_prob = []
        for transition_idx in range(max_episode_len):
            inputs = self._get_actor_inputs(batch, transition_idx)  # 给obs加last_action、agent_id
            if self.args.cuda:
                inputs = inputs.cuda()
                self.eval_hidden = self.eval_hidden.cuda()
            outputs, self.eval_hidden = self.eval_rnn(inputs, self.eval_hidden)  # inputs维度为(40,96),得到的q_eval维度为(40,n_actions)
            # 把q_eval维度重新变回(8, 5,n_actions)
            outputs = outputs.view(episode_num, self.n_agents, -1)
            prob = torch.nn.functional.softmax(outputs, dim=-1)
            action_prob.append(prob)
        # 得的action_prob是一个列表,列表里装着max_episode_len个数组,数组的的维度是(episode个数, n_agents,n_actions)
        # 把该列表转化成(episode个数, max_episode_len, n_agents,n_actions)的数组
        action_prob = torch.stack(action_prob, dim=1).cpu()

        action_num = avail_actions.sum(dim=-1, keepdim=True).float().repeat(1, 1, 1, avail_actions.shape[-1])   # 可以选择的动作的个数
        action_prob = ((1 - epsilon) * action_prob + torch.ones_like(action_prob) * epsilon / action_num)
        action_prob[avail_actions == 0] = 0.0  # 不能执行的动作概率为0

        # 因为上面把不能执行的动作概率置为0,所以概率和不为1了,这里要重新正则化一下。执行过程中Categorical会自己正则化。
        action_prob = action_prob / action_prob.sum(dim=-1, keepdim=True)
        # 因为有许多经验是填充的,它们的avail_actions都填充的是0,所以该经验上所有动作的概率都为0,在正则化的时候会得到nan。
        # 因此需要再一次将该经验对应的概率置为0
        action_prob[avail_actions == 0] = 0.0
        if self.args.cuda:
            action_prob = action_prob.cuda()
        return action_prob

    def init_hidden(self, episode_num):
        # 为每个episode中的每个agent都初始化一个eval_hidden
        self.eval_hidden = torch.zeros((episode_num, self.n_agents, self.args.rnn_hidden_dim))

    def _train_critic(self, batch, max_episode_len, train_step):
        u, r, avail_u, terminated = batch['u'], batch['r'], batch['avail_u'], batch['terminated']
        u_next = u[:, 1:]
        padded_u_next = torch.zeros(*u[:, -1].shape, dtype=torch.long).unsqueeze(1)
        u_next = torch.cat((u_next, padded_u_next), dim=1)
        mask = (1 - batch["padded"].float()).repeat(1, 1, self.n_agents)  # 用来把那些填充的经验的TD-error置0,从而不让它们影响到学习
        if self.args.cuda:
            u = u.cuda()
            u_next = u_next.cuda()
            mask = mask.cuda()
        # 得到每个agent对应的Q值,维度为(episode个数, max_episode_len, n_agents,n_actions)
        # q_next_target为下一个状态-动作对应的target网络输出的Q值,没有包括reward
        q_evals, q_next_target = self._get_q_values(batch, max_episode_len)
        q_values = q_evals.clone()  # 在函数的最后返回,用来计算advantage从而更新actor
        # 取每个agent动作对应的Q值,并且把最后不需要的一维去掉,因为最后一维只有一个值了

        q_evals = torch.gather(q_evals, dim=3, index=u).squeeze(3)
        q_next_target = torch.gather(q_next_target, dim=3, index=u_next).squeeze(3)
        targets = td_lambda_target(batch, max_episode_len, q_next_target.cpu(), self.args)
        if self.args.cuda:
            targets = targets.cuda()
        td_error = targets.detach() - q_evals
        masked_td_error = mask * td_error  # 抹掉填充的经验的td_error

        # 不能直接用mean,因为还有许多经验是没用的,所以要求和再比真实的经验数,才是真正的均值
        loss = (masked_td_error ** 2).sum() / mask.sum()
        # print('Loss is ', loss)
        self.critic_optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.critic_parameters, self.args.grad_norm_clip)
        self.critic_optimizer.step()
        if train_step > 0 and train_step % self.args.target_update_cycle == 0:
            self.target_critic.load_state_dict(self.eval_critic.state_dict())
        return q_values

    def save_model(self, train_step):
        num = str(train_step // self.args.save_cycle)
        if not os.path.exists(self.model_dir):
            os.makedirs(self.model_dir)
        torch.save(self.eval_critic.state_dict(), self.model_dir + '/' + num + '_critic_params.pkl')
        torch.save(self.eval_rnn.state_dict(),  self.model_dir + '/' + num + '_rnn_params.pkl')

     文章若有不当和不正确之处,还望理解与指出。由于部分文字、图片等来源于互联网,无法核实真实出处,如涉及相关争议,请联系博主删除。如有错误、疑问和侵权,欢迎评论留言联系作者,或者关注VX公众号:Rain21321,联系作者。

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2123236.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

前端开发的观察者模式

什么是观察者设计模式 观察者模式(Observer Pattern)是前端开发中常用的一种设计模式。它定义了一种一对多的依赖关系,使得当一个对象的状态发生改变时,其所有依赖对象都能收到通知并自动更新。观察者模式广泛应用于事件驱动的系…

56页PPT | 大数据决策分析平台怎么建设?经典实践方案推荐

一、现状和目标 企业用户现状:数据分散,利用率低,业务需求变化快但IT响应慢。 问题:数据展示不及时、不准确,缺乏深入分析工具,报表制作效率低下。 目标:建设统一的数据整合平台,…

四款数据恢复精灵好用之处及使用感受~

在数字化的时代,数据的重要性不言而喻;不慎删除重要文件、格式化磁盘后数据丢失、存储设备故障……这些情况都可能让我们痛心疾首;这时,数据恢复软件就显得尤为重要了,今天,就为大家介绍四款备受好评的数据…

服装|基于Java+vue的服装定制系统(源码+数据库+文档)

服装定制系统 目录 基于Javavue的服装定制系统 一、前言 二、系统设计 三、系统功能设计 系统功能实现 管理员功能模块 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源码获取: 博主介绍:✌️大厂码农|毕设布…

Linux——redis主从复制、集群模式、哨兵模式

主从复制 部署至少两个redis的实例 // 提供数据冗余和备份 两个独立服务器两个虚拟机两个容器一个redis的master 节点可以有多个redis的replica 从节点, 而从节点也可以成为其他从节点的主节点 // 方便对于主复制架构进行扩展提供数据灾备,当red…

复赛总榜TOP1方案Champion Chasing Boy分享

关联比赛: 2020数字中国创新大赛—算法赛:智慧海洋建设 写在前面的话 大家好,我是 Champion Chasing Boy的DOTA,在队友 鱼遇雨欲语与余、 尘沙杰少、林有夕、嗯哼哼唧 的Carry下,最终在本届智能算法赛拿到了复赛总榜单Top1的成绩…

Java通过jna调用c++动态库

1、pom文件添加jna依赖 <dependency><groupId>net.java.dev.jna</groupId><artifactId>jna</artifactId><version>5.14.0</version></dependency> 2、注意问题 要实现Java调用C的动态库&#xff0c;需要使用"extern C&…

Script-server: 一款开源的脚本管理工具,为你的Python脚本提供一个直观的 Web UI

在日常工作中&#xff0c;我们经常会使用各种脚本来自动化任务&#xff0c;提升效率。但传统的脚本管理方式往往伴随着一些困扰&#xff1a;复杂的命令行操作、难以理解的脚本参数、缺乏直观的反馈等等。这些问题&#xff0c;让原本应该便捷的脚本管理变得繁琐。 Script-server…

Qt-QWidget的focusPolicy属性(20)

目录 描述 相关API 使用 描述 这里引入了焦点的概念&#xff0c;这个很重要&#xff0c;也是伴随后面介绍中的一个很重要的概念 拿魔兽世界来举例&#xff0c;如下我们在操作兵种的时候&#xff0c;需要先选中单位&#xff0c;然后才能对这些单位进行命令的下达 这一点在笔…

[极客大挑战 2019]Http

1、访问题目链接 2、查看页面源码发现一个Secret.php的跳转页面 3、访问Secret.php发现页面有提示&#xff0c;它说它不是来自这个网页 4、抓包修改来源 添加&#xff1a;Referer: https://Sycsecret.buuoj.cn 发送查看响应 5、修改User-Agent为&#xff1a;Syclover 6、添加X-…

Catia的插件不能调用CAA 的API问题

今天到客户实施Catia二开软件&#xff0c;发现在客户的电脑上调用CAA的API出现调用失败的问题。 根据经验&#xff0c;想到大概是用户电脑上的Catia授权有问题&#xff0c;但是Catia的一大堆授权中需要哪些授权呢&#xff0c;最后花了半天的时间使用二分法测试出&#xff0c;C…

产线工控安全之防勒索病毒杀手锏

在当今数字化时代&#xff0c;数据安全已成为企业运营中不可或缺的一部分。勒索病毒和内部泄密事件的频发&#xff0c;使得企业必须采取更为严格的安全措施来保护其关键数据和运营系统。苏州深信达网络科技推出的MCK主机加固解决方案&#xff0c;正是为了应对这些挑战而设计的。…

十三、创建Uss血条样式

一、控制StyleSheet 1、点击左上角USS文件&#xff08;创建&#xff09; 2、双击style里面的黄色progress-bar 3、在USS文件夹中添加代码实现 4、在主UI上有一个margin&#xff08;外&#xff09;和padding(里) 在Spacing中进行修改 5、只有文字可以在这里进行修改 6、在Atrib…

车载以太网之SOME/IP

整体介绍 SOME/IP(全称为:Scalable service-Oriented MiddlewarE over IP),是运行在车载以太网协议栈基础之上的中间件,或者也可以称为应用层软件。 ​发展历程 AUTOSAR 4.0 - 完成宝马SOME/IP消息的初步集成;AUTOSAR 4.1 - 支持SOME/IP-SD及其发布/订阅功能;AUTOSAR 4.…

自动驾驶相关的理论基础

本文主要参考论文《基于计算机视觉和深度学习的自动驾驶方法研究_白辰甲》&#xff0c;记录一些理论知识。 自动驾驶定义 自动驾驶是指车辆通过传感器感知周围环境&#xff0c;在没有人为干预的情况下&#xff0c;实时改变驾驶行为&#xff0c;完成驾驶任务。 基于计算机视觉…

在树莓派上构建和部署 Node.js 项目

探索在Raspberry Pi上构建和部署Node.js项目的最佳实践。通过我们的专业提示和技巧&#xff0c;克服常见挑战&#xff0c;使您的项目顺利运行。 去年圣诞节&#xff0c;我收到了一份极其令人着迷的礼物&#xff0c;它占据了我许多周末的时间&#xff0c;甚至让我夜不能寐。它就…

SpringBoot打包部署,打包成jar和war有所不同?

1. 我的一个springboot项目&#xff0c;用mvn install打包成jar&#xff0c;换一台有jdk的机器就直接可以用java -jar 项目名.jar的方式运行&#xff0c;没任何问题&#xff0c;为什么这里不需要tomcat也可以运行了&#xff1f; 2. 然后我打包成war放进tomcat运行&#xff0c;…

云服务器部署DB-GPT项目

本文收录于《DB-GPT项目》专栏&#xff0c;专栏总目录&#xff1a; 点击这里。 文章目录 项目介绍 一、登录云服务器 1. 进入控制台 2.点击容器实例&#xff08;点数字&#xff09; 二、创建容器实例 1. 等待容器实例创建好&#xff0c;创建好的容器实例如下&#xff1a;…

多个微信是怎么进行管理的?

随着微信逐渐成为企业商务沟通的重要平台&#xff0c;对于业务咨询量较大的行业&#xff08;例如教育培训、旅游、美容以及医疗等&#xff09;而言&#xff0c;在利用微信进行营销活动和客户服务的过程中&#xff0c;往往会遭遇多微信管理的困境。 在此情形下&#xff0c;选用工…

fwt变换模板

在算法竞赛中&#xff0c;FWT 是用于解决对下标进行位运算卷积问题的方法。 公式&#xff1a; 1.ij|k(j,k相或等于i) void Or(ll * a, ll type) { // 迭代实现&#xff0c;常数更小 for (ll x 2; x < n; x << 1) { ll k x >> 1; …