使用SAC算法控制倒立摆-作业欢迎你将完成的作业分享到 AI Gallery Notebook 版块获得成长值，分享方法请查看此文档。题目描述请你调整步骤2中的训练参数，重新训练一个模型，使它在游戏中获得更好的表现提示：请在下文中搜索“# 请在此处实现代码”，注释所在之处就是你需要修改代码的地方；修改好代码之后，跑通整个案例代码，即可完成作业，请将完成的作业分享到AI Gallery，标题以“2021实战营”为开头命名；代码实现1. 程序初始化第1步：安装基础依赖!pip install gym pybullet第2步：导入相关的库import time import random import itertools import gym import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from torch.optim import Adam from torch.distributions import Normal import pybullet_envs2. 训练参数初始化本案例设置的 num_steps = 30000，可以达到200分，训练耗时约5分钟。# 请在此处实现代码3. 定义SAC算法第1步：定义Q网络，Q1和Q2，结构相同，为[256,256,256]的全连接层# Initialize Policy weights def weights_init_(m): if isinstance(m, nn.Linear): torch.nn.init.xavier_uniform_(m.weight, gain=1) torch.nn.init.constant_(m.bias, 0) class QNetwork(nn.Module): def __init__(self, num_inputs, num_actions): super(QNetwork, self).__init__() # Q1 architecture self.linear1 = nn.Linear(num_inputs + num_actions, 256) self.linear2 = nn.Linear(256, 256) self.linear3 = nn.Linear(256, 1) # Q2 architecture self.linear4 = nn.Linear(num_inputs + num_actions, 256) self.linear5 = nn.Linear(256, 256) self.linear6 = nn.Linear(256, 1) self.apply(weights_init_) def forward(self, state, action): xu = torch.cat([state, action], 1) x1 = F.relu(self.linear1(xu)) x1 = F.relu(self.linear2(x1)) x1 = self.linear3(x1) x2 = F.relu(self.linear4(xu)) x2 = F.relu(self.linear5(x2)) x2 = self.linear6(x2) return x1, x2第2步：Policy网络，采用高斯分布，两层[256,256]全连接+均值+标准差class GaussianPolicy(nn.Module): def __init__(self, num_inputs, num_actions, action_space=None): super(GaussianPolicy, self).__init__() self.linear1 = nn.Linear(num_inputs, 256) self.linear2 = nn.Linear(256, 256) self.mean_linear = nn.Linear(256, num_actions) self.log_std_linear = nn.Linear(256, num_actions) self.apply(weights_init_) # action rescaling if action_space is None: self.action_scale = torch.tensor(1.) self.action_bias = torch.tensor(0.) else: self.action_scale = torch.FloatTensor( (action_space.high - action_space.low) / 2.) self.action_bias = torch.FloatTensor( (action_space.high + action_space.low) / 2.) def forward(self, state): x = F.relu(self.linear1(state)) x = F.relu(self.linear2(x)) mean = self.mean_linear(x) log_std = self.log_std_linear(x) log_std = torch.clamp(log_std, min=LOG_SIG_MIN, max=LOG_SIG_MAX) return mean, log_std def sample(self, state): mean, log_std = self.forward(state) std = log_std.exp() normal = Normal(mean, std) # 重参数化技巧 (mean + std * N(0,1)) x_t = normal.rsample() y_t = torch.tanh(x_t) action = y_t * self.action_scale + self.action_bias log_prob = normal.log_prob(x_t) log_prob -= torch.log(self.action_scale * (1 - y_t.pow(2)) + epsilon) log_prob = log_prob.sum(1, keepdim=True) mean = torch.tanh(mean) * self.action_scale + self.action_bias return action, log_prob, mean def to(self, device): self.action_scale = self.action_scale.to(device) self.action_bias = self.action_bias.to(device) return super(GaussianPolicy, self).to(device)第3步： 定义sac训练部分class SAC(object): def __init__(self, num_inputs, action_space): self.alpha = alpha self.auto_entropy = auto_entropy self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # critic网络 self.critic = QNetwork(num_inputs, action_space.shape[0]).to(device=self.device) self.critic_optim = Adam(self.critic.parameters(), lr=lr) # critic_target网络 self.critic_target = QNetwork(num_inputs, action_space.shape[0]).to(self.device) hard_update(self.critic_target, self.critic) # Target Entropy = −dim(A) if auto_entropy is True: self.target_entropy = -torch.prod(torch.Tensor(action_space.shape).to(self.device)).item() self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device) self.alpha_optim = Adam([self.log_alpha], lr=lr) self.policy = GaussianPolicy(num_inputs, action_space.shape[0], action_space).to(self.device) self.policy_optim = Adam(self.policy.parameters(), lr=lr) def select_action(self, state): state = torch.FloatTensor(state).to(self.device).unsqueeze(0) action, _, _ = self.policy.sample(state) return action.detach().cpu().numpy()[0] def update_parameters(self, memory, batch_size, updates): # Sample a batch from memory state_batch, action_batch, reward_batch, next_state_batch, mask_batch = memory.sample(batch_size=batch_size) state_batch = torch.FloatTensor(state_batch).to(self.device) next_state_batch = torch.FloatTensor(next_state_batch).to(self.device) action_batch = torch.FloatTensor(action_batch).to(self.device) reward_batch = torch.FloatTensor(reward_batch).to(self.device).unsqueeze(1) mask_batch = torch.FloatTensor(mask_batch).to(self.device).unsqueeze(1) with torch.no_grad(): # 经过policy_network得到action next_state_action, next_state_log_pi, _ = self.policy.sample(next_state_batch) # 输入next_state,和next_action，经过target_critic_network得到Q值 qf1_next_target, qf2_next_target = self.critic_target(next_state_batch, next_state_action) min_qf_next_target = torch.min(qf1_next_target, qf2_next_target) - self.alpha * next_state_log_pi next_q_value = reward_batch + mask_batch * gamma * (min_qf_next_target) # 将当前state,action输入critic_network得到Q值 qf1, qf2 = self.critic(state_batch, action_batch) # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2] qf1_loss = F.mse_loss(qf1, next_q_value) # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2] qf2_loss = F.mse_loss(qf2, next_q_value) qf_loss = qf1_loss + qf2_loss self.critic_optim.zero_grad() qf_loss.backward() self.critic_optim.step() pi, log_pi, _ = self.policy.sample(state_batch) qf1_pi, qf2_pi = self.critic(state_batch, pi) min_qf_pi = torch.min(qf1_pi, qf2_pi) # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))] policy_loss = ((self.alpha * log_pi) - min_qf_pi).mean() self.policy_optim.zero_grad() policy_loss.backward() self.policy_optim.step() if self.auto_entropy: alpha_loss = -(self.log_alpha * (log_pi + self.target_entropy).detach()).mean() self.alpha_optim.zero_grad() alpha_loss.backward() self.alpha_optim.step() self.alpha = self.log_alpha.exp() else: alpha_loss = torch.tensor(0.).to(self.device) if updates % target_update_interval == 0: soft_update(self.critic_target, self.critic, tau) def soft_update(target, source, tau): for target_param, param in zip(target.parameters(), source.parameters()): target_param.data.copy_(target_param.data * (1.0 - tau) + param.data * tau) def hard_update(target, source): for target_param, param in zip(target.parameters(), source.parameters()): target_param.data.copy_(param.data)第4步：定义replay buffer，存储[s,a,r,s_,done]class ReplayMemory: def __init__(self, capacity): random.seed(seed) self.capacity = capacity self.buffer = [] self.position = 0 def push(self, state, action, reward, next_state, done): if len(self.buffer) < self.capacity: self.buffer.append(None) self.buffer[self.position] = (state, action, reward, next_state, done) self.position = (self.position + 1) % self.capacity def sample(self, batch_size): batch = random.sample(self.buffer, batch_size) state, action, reward, next_state, done = map(np.stack, zip(*batch)) return state, action, reward, next_state, done def __len__(self): return len(self.buffer)4. 训练模型初始化环境和算法# 创建环境 env = gym.make(env_name) # 设置随机数 env.seed(seed) env.action_space.seed(seed) torch.manual_seed(seed) np.random.seed(seed) # 创建agent agent = SAC(env.observation_space.shape[0], env.action_space) # replay buffer memory = ReplayMemory(replay_size) # 训练步数记录 total_numsteps = 0 updates = 0 max_reward = 0开始训练print('\ntraining...') begin_t = time.time() for i_episode in itertools.count(1): episode_reward = 0 episode_steps = 0 done = False state = env.reset() while not done: if start_steps > total_numsteps: # 随机采样过程 action = env.action_space.sample() else: # 根据策略采样 action = agent.select_action(state) if len(memory) > batch_size: # 每个step更新次数 for i in range(updates_per_step): agent.update_parameters(memory, batch_size, updates) updates += 1 # 执行该步 next_state, reward, done, _ = env.step(action) # 更新记录参数 episode_steps += 1 total_numsteps += 1 episode_reward += reward # -done mask = 1 if episode_steps == env._max_episode_steps else float(not done) # 存入buffer memory.push(state, action, reward, next_state, mask) # 更新state state = next_state # 达到终止条件后，停止 if total_numsteps > num_steps: break if episode_reward >= max_reward: max_reward = episode_reward print("current_max_reward {}".format(max_reward)) # 保存模型 torch.save(agent.policy, "model.pt") print("Episode: {}, total numsteps: {}, reward: {}".format(i_episode, total_numsteps,round(episode_reward, 2))) env.close() print("finish! time cost is {}s".format(time.time() - begin_t))5. 使用模型推理游戏由于本内核可视化依赖于OpenGL，需要窗口显示，但当前环境暂不支持，因此无法可视化，请将代码下载到本地，取消 env.render() 这行代码的注释，可查看可视化效果。# 可视化部分 model = torch.load("model.pt") model.eval() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") state = env.reset() # env.render() done = False episode_reward = 0 while not done: _, _, action = model.sample(torch.FloatTensor(state).to(device).unsqueeze(0)) action = action.detach().cpu().numpy()[0] next_state, reward, done, _ = env.step(action) episode_reward += reward # env.render() state = next_state print(episode_reward)可视化效果如下：

PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能：1、具有强大的GPU加速的张量计算（如NumPy）。2、包含自动求导系统的深度神经网络。2022年9月，扎克伯格亲自宣布，PyTorch 基金会已新鲜成立，并归入 Linux 基金会旗下。PyTorch的前身是Torch，其底层和Torch框架一样，但是使用Python重新写了很多内容，不仅更加灵活，支持动态图，而且提供了Python接口。它是由Torch7团队开发，是一个以Python优先的深度学习框架，不仅能够实现强大的GPU加速，同时还支持动态神经网络。PyTorch既可以看作加入了GPU支持的numpy，同时也可以看成一个拥有自动求导功能的强大的深度神经网络。除了Facebook外，它已经被Twitter、CMU和Salesforce等机构采用 。2022年9月，扎克伯格亲自宣布，PyTorch 基金会已新鲜成立，并归入 Linux 基金会旗下。PyTorch给用户提供Build级别的移动端定制化支持、增加分布式模型并行训练、让Java程序能够运行TorchScript等。此外还有JIT、C++、分布式训练、Eager前端、PyTorch Mobile等方面的功能改进和Bug修复。运行环境：Windows(CUDA,CPU)、MacOS(CPU)、Linux(CUDA,ROCm,CPU)优点：PyTorch是相当简洁且高效快速的框架设计追求最少的封装设计符合人类思维，它让用户尽可能地专注于实现自己的想法与google的Tensorflow类似，FAIR的支持足以确保PyTorch获得持续的开发更新PyTorch作者亲自维护的论坛 供用户交流和求教问题入门简单

PyTorch的安装十分简单，根据PyTorch官网，对系统选择和安装方式等灵活选择即可。这里以anaconda为例。Pytorch的安装经过了几次变化，请大家以官网的安装命令为准。另外需要说明的就是在1.2版本以后，Pytorch只支持cuda 9.2以上了，所以需要对cuda进行升级，部分显卡都可以用，包括笔记本的MX250也是可以顺利升级到cuda 10.1。此处使用Conda包管理器。注意：如果使用镜像站，请删除“-c pytorch”；安装CUDA（即GPU）版本时注意安装CUDNN运行库# 全部通用，ROCm仅支持Linuxconda install pytorch torchvision torchaudio cudatoolkit=10.2 -c pytorch    #CUDA 10.2conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch    #CUDA 11.3conda install pytorch torchvision torchaudio cpuonly -c pytorch #CPUpip3 install torch torchvision==0.11.2 -f https://download.pytorch.org/whl/rocm4.2/torch_stable.html# ROCm 4.2 （仅Linux）验证输入python 进入    import torchprint(torch.__version__)    #Pytorch版本print(torch.version.cuda)   #CUDA版本print(torch.backends.cudnn.version())   #CUDNN版本配置Jupyter Notebook新建的环境是没有安装安装ipykernel的所以无法注册到Jupyter Notebook中，所以先要准备环境    #安装ipykernelconda install ipykernel#写入环境python -m ipykernel install  --name pytorch --display-name "Pytorch for Deeplearning"下一步：定制 Jupyter Notebook    #切换回基础环境activate base#创建jupyter notebook配置文件jupyter notebook --generate-config## 这里会显示创建jupyter_notebook_config.py的具体位置打开文件，修改    c.NotebookApp.notebook_dir = '' 默认目录位置c.NotebookApp.iopub_data_rate_limit = 100000000 这个改大一些否则有可能报错测试至此，Pytorch 的开发环境安装完成，可以在开始菜单中打开Jupyter Notebook 在New 菜单中创建文件时选择Pytorch for Deeplearning 创建PyTorch的相关开发环境了 。

 9 月 12 日，PyTorch 和 Linux 基金会双双在自家的官网宣布，PyTorch 已经正式加入 Linux 基金会的消息。PyTorch 最初由 Meta 的 AI 团队孵化，在以社区为中心的管理之下，PyTorch 现已发展成为一个由贡献者和用户组成的庞大社区。截至 2022 年 8 月，PyTorch 是世界上与 Linux 内核和 Kubernetes 并列的五个增长最快的开源软件社区之一。从 2021 年 8 月到 2022 年 8 月，PyTorch 统计了超过 6.5 万次提交. 超过 2400 名贡献者以提交问题或 PR 或编写文档的方式参与了这项工作。这些数字使 PyTorch 成为历史上最成功的开源项目之一。“很高兴 Linux 基金会将成为我们的新家，因为他们在支持像我们这样的大型开源项目（例如 Kubernetes 和 NodeJS）方面拥有丰富的经验。”PyTorch 联合创始人 Soumith Chintala 称。“PyTorch 通过良好的维护和开源社区管理达到了目前的状态。我们不会改变 PyTorch 的任何优点。”Linux 基金会称。“PyTorch 将通过加入 Linux 基金会加强其治理。”PyTorch 联合创始人 Soumith Chintala 称。PyTorch 是 Facebook 开发的用于训练神经网络的 Python 包，也是 Facebook 倾力打造的首选深度学习框架。在 2017 年 1 月首次推出，Facebook 人工智能研究院（FAIR）在 GitHub 上开源了 PyTorch，迅速占领了 GitHub 热度榜榜首。Facebook 用 Python 重写了基于 Lua 语言的深度学习库 Torch，不仅使得 PyTorch 继承了 Torch 灵活、动态的编程环境和用户友好的界面，支持以快速和灵活的方式构建动态神经网络，还允许在训练过程中快速更改代码而不妨碍其性能，即支持动态图形等尖端 AI 模型的能力。2018 年 Caffe2 正式并入 PyTorch 后，PyTorch 的发展势头更呈不可阻挡之势。据 Meta 称，自 PyTorch 创建以来，约有 2,400 名贡献者在该框架上构建了超过 150,000 个项目。因此，PyTorch 已成为人工智能研究和商业生产使用的领先平台之一，包括作为亚马逊网络服务、微软 Azure 和 OpenAI 的技术基础。    在人工智能和机器学习领域，开源是重中之重。Linux 基金会是开源生态系统的一个重要组成部分。目前，Linux 基金会在世界各地拥有数千名成员，拥有 850 多个开源项目。这些项目要么直接为基础 AI/ML 项目（LF AI 和数据）做出贡献，要么为其用例做出贡献并与其平台集成。（例如，LF Networking、AGL、Delta Lake、RISC-V、CNCF、Hyperledger）。“PyTorch 的精髓之处（以及它的维护者的功劳）在于，它的确是如今许多 AI 和 ML 项目的基础平台，它是一把真正的瑞士军刀。”Linux 基金会称。正如开发人员在 Linux 之上构建了我们今天所知的大量技术一样，许多 AI/ML 社区也是在 PyTorch 之上构建而成。PyTorch 进一步支持了新兴技术和不断变化的用户需求。Linux 基金会表示，作为 Linux 基金会的一部分，PyTorch 及其社区将受益于我们的许多计划和支持社区，例如培训和认证计划（我们已经在进行中）、社区研究（例如我们的项目旅程报告），当然还有其他社区活动等。PyTorch 社区将在 Linux 基金会内部和周围工作，PyTorch 社区也有一个可以访问 LFX 协作门户的入口，我们将为 PyTorch 社区提供指导并帮助 PyTorch 社区确定未来的领导者、寻找潜在的员工、并观察共享的社区动态。“像 PyTorch 这样有可能成为关键技术基础平台的项目，保持中立对它更有益处。中立性和真正的社区所有权使 Linux 和 Kubernetes 在变得更加成熟的同时继续加速和增长，从而超越预期。用户、维护者和社区开始将它们视为可以永久依赖和信任的公共资源的。”Linux 基金会称。“PyTorch 通过良好的维护和开源社区管理达到了目前的状态。我们不会改变 PyTorch 的任何优点。”Linux 基金会称。来源：https://pytorch.org/blog/PyTorchfoundation/https://venturebeat.com/ai/pytorch-has-a-new-home-meta-announces-independent-foundation/https://linuxfoundation.org/zh/blog/welcoming-pytorch-to-the-linux-foundation/

软硬件环境ubuntu 18.04 64bitopenvino_2020.3.341yolov5 4.0openvino是什么openvino是一个用于解决在intel硬件平台上进行深度学习部署的方案，支持windows、linux和macOS。openvino环境搭建下载地址：https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit/download.html下载后解压并进入目录tar xvf l_openvino_toolkit_p_2020.3.341.tgzcd l_openvino_toolkit_p_2020.3.341执行脚本开始按提示安装# 或者使用带GUI界面的安装脚本sudo ./install_GUI.shsudo ./install.sh按回车键继续选2，不同意收集我的信息按回车键继续同意并开始安装按回车键继续至此，安装结束接下来测试下安装是否成功cd /opt/intel/openvino/deployment_tools/demo./demo_security_barrier_camera.sh./demo_security_barrier_camera.sh -d GPU(测试gpu环境)这就说明，openvino的环境安装成功了。这里需要注意下，由于，在安装过程中，脚本已经帮我们设置了相关的环境，所以我们去测试时无需做任何设置。但是如果下次开机，或者打开新的terminal，我们就需要重新来设置环境，执行source /opt/intel/openvino/bin/setupvars.sh或者直接将上述命令写入~/.bashrc中，就不用每次手动敲了。目录/opt/intel下有openvino和openvino_2020.3.3412个目录，其实它们是同一个东西，openvino是个软链接文件。pt转onnx首先准备依赖pip install onnx coremltools networkx defusedxml由于目前openvino的版本对onnx opset 11 版本后的支持有问题，因此需要修改文件model/export.py，将原来opset_version由12改为10，如下torch.onnx.export(model, img, f, verbose=False, opset_version=10, input_names=['images'], output_names=['classes', 'boxes'] if y is None else ['output'])接下来就可以将yolov5的pt模型转换成onnx格式了，这里使用其自带的yolov5s.pt模型进行测试python models/export.py --weights weights/yolov5s.pt --img-size 640 --batch-size 1转换结束后，就会在weights文件夹下生成yolov5s.onnxonnx转irir即Intermediate Representation，openvino的模型优化器(Model Optimizer)会将给定的模型转化为标准的ir格式，并对其进行优化。使用openvino自带的脚本，就可以完成从.onnx到.bin和.xml的转换，命令如下mo.py --input_model weights/yolov5s.onnx可以看到在当前目前生成了yolov5s.bin和yolov5s.xmlopenvino测试这里使用c++语言编写测试程序，下载地址：https://github.com/fb029ed/yolov5_cpp_openvino，非常感谢作者fb029ed的分享cd yolov5_cpp_openvino/demomkdir buildcmake ..make./detect_test需要将前面生成的yolov5s.bin、yolov5s.xml和一张测试图片拷贝到res目录下，图片重命名为bus.jpg文章转自： 迷途小书童的Note

在yolov3的demo上直接更改模型换成yolov5的模型，想看看性能，为啥会报错在进行模型转换时是这样写的

导入包和版本查询import torchimport torch.nn as nnimport torchvisionprint(torch.__version__)print(torch.version.cuda)print(torch.backends.cudnn.version())print(torch.cuda.get_device_name(0))可复现性在硬件设备（CPU、GPU）不同时，完全的可复现性无法保证，即使随机种子相同。但是，在同一个设备上，应该保证可复现性。具体做法是，在程序开始的时候固定torch的随机种子，同时也把numpy的随机种子固定。np.random.seed(0)torch.manual_seed(0)torch.cuda.manual_seed_all(0)torch.backends.cudnn.deterministic = Truetorch.backends.cudnn.benchmark = False显卡设置# Device configurationdevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')如果需要指定多张显卡，比如0，1号显卡。import osos.environ['CUDA_VISIBLE_DEVICES'] = '0,1'也可以在命令行运行代码时设置显卡：CUDA_VISIBLE_DEVICES=0,1 python train.py清除显存torch.cuda.empty_cache()也可以使用在命令行重置GPU的指令nvidia-smi --gpu-reset -i [gpu_id]

由于mikel-brostrom在github上发布的Yolov5_DeepSort_Pytorch更新，使整个代码封装性更好，进而允许采用多种REID特征识别模型，完善了deepsort在检测跟踪方面的性能。本博文记录如何使用此版本Yolov5_DeepSort_Pytorch的过程，同时给出ZQPei REID模型的修改方法，以适应mikel-brostrom更新版本。使用Yolov5_DeepSort_Pytorch默认的osnet REID实现跟踪track.pyYolov5_DeepSort_Pytorch中包含了两个链接目录yolov5和reid，不能一次性把github中的代码克隆下来，因此，需分别将三个github代码克隆到本地。Yolov5_DeepSort_Pytorch: git clone https://github.com/mikel-brostrom/Yolov5_DeepSort_PytorchYolov5: git clone https://github.com/ultralytics/yolov5REID: git clone https://github.com/KaiyangZhou/deep-person-reid假定你的deepsort目录为your_dir，是第一个克隆下来的目录。第二个克隆目录是yolov5，将yolov5目录放在your_dir目录下，即your_dir/yolov5。第三个克隆目录是reid，放到your_dir/deep_sort/deep目录下，your_dir/deep_sort/deep/reid。假定已经安装了conda和虚拟环境，且安装好运行Yolov5_DeepSort_Pytorch所需的模块。进入reid目录，运行python setup.py develop1如此，即安装好KaiyangZhou的REID环境。下载yolov5模型权重，放入目录your_dir/yolov5/weights从KaiyangZhou的github中，Model zoo里下载权重文件，例如osnet_x1_0.pth，放到checkpoint目录：your_dir/deep_sort/deep/checkpoint。（1）修改deep_sort/configs/deep_sort.yamlDEEPSORT:  MODEL_TYPE: "osnet_x1_0"      REID_CKPT:  '~/your_dir/deep_sort/deep/checkpoint/osnet_x1_0_imagenet.pth'  MAX_DIST: 0.1 # 0.2 The matching threshold. Samples with larger distance are considered an invalid match  MAX_IOU_DISTANCE: 0.7 # 0.7 Gating threshold. Associations with cost larger than this value are disregarded.  MAX_AGE: 90 # 30 Maximum number of missed misses before a track is deleted  N_INIT: 3 # 3  Number of frames that a track remains in initialization phase  NN_BUDGET: 100 # 100 Maximum size of the appearance descriptors gallery  MIN_CONFIDENCE: 0.75  NMS_MAX_OVERLAP: 1.0这里，增加REID_CKPT，把某些参数设置放到yaml文件中，尽可能减少track.py命令行中的输入参数。（2）修改track.py中DeepSort类实例的参数定义deepsort = DeepSort(    cfg.DEEPSORT.MODEL_TYPE,                        cfg.DEEPSORT.REID_CKPT,   # 添加checkpoint路径                        device,                        max_dist=cfg.DEEPSORT.MAX_DIST,                        max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,                        max_age=cfg.DEEPSORT.MAX_AGE,                         n_init=cfg.DEEPSORT.N_INIT,                         nn_budget=cfg.DEEPSORT.NN_BUDGET,                        )此处增加了一个reid权重文件路径参数，故也需在DeepSort类定义中增加该参数model_path，修改deep_sort/deep_sort.py，__init__():class DeepSort(object):    def __init__(self, model_type, model_path, device, max_dist=0.2, min_confidence=0.3, nms_max_overlap=1.0, max_iou_distance=0.7, max_age=70, n_init=3, nn_budget=100, use_cuda=True):        self.min_confidence = min_confidence        self.nms_max_overlap = nms_max_overlap        self.extractor = FeatureExtractor(            model_name=model_type,            model_path = model_path,            device=str(device)        )        max_cosine_distance = max_dist        metric = NearestNeighborDistanceMetric(            "cosine", max_cosine_distance, nn_budget)        self.tracker = Tracker(            metric, max_iou_distance=max_iou_distance, max_age=max_age, n_init=n_init)注：mikel好像又改了有关model_path的引入方法，我感觉太复杂，故还是用以上的修改办法，其目的就是从deep_sort/deep/checkpoint中找到权重文件路径，避免从网上下载权重文件，或者从本地缓存.torch中去找权重。（3）运行deepsort跟踪程序，命令行选项中给出一种比较全的选项python track.py --yolo_model ~/your_dir/yolov5/weights/yolov5s.pt \   // yolov5权文件                --source  ~/your_dir/video_demo.mp4 \           // 输入视频文件                --show-vid \            // 显示跟踪视频                --classes 0 2   \           // 0 = 行人类别， 2=小汽车类别。                --save-txt    \           // 输出兼容MOT16格式文件                --save-vid  \           // 保存跟踪视频其中，classes 0 表示yolov5检测对象为行人，类型号0。更改ZQPei REID模型文件此模型文件命名为model_ZQP.py，放入目录 deep_sort/deep/reid/torchreid/models模型更改只需添加一个定义函数 def ZQP()import torchimport torch.nn as nnimport torch.nn.functional as Fclass BasicBlock(nn.Module):    def __init__(self, c_in, c_out, is_downsample=False):        super(BasicBlock, self).__init__()        self.is_downsample = is_downsample        if is_downsample:            self.conv1 = nn.Conv2d(                c_in, c_out, 3, stride=2, padding=1, bias=False)        else:            self.conv1 = nn.Conv2d(                c_in, c_out, 3, stride=1, padding=1, bias=False)        self.bn1 = nn.BatchNorm2d(c_out)        self.relu = nn.ReLU(True)        self.conv2 = nn.Conv2d(c_out, c_out, 3, stride=1,                               padding=1, bias=False)        self.bn2 = nn.BatchNorm2d(c_out)        if is_downsample:            self.downsample = nn.Sequential(                nn.Conv2d(c_in, c_out, 1, stride=2, bias=False),                nn.BatchNorm2d(c_out)            )        elif c_in != c_out:            self.downsample = nn.Sequential(                nn.Conv2d(c_in, c_out, 1, stride=1, bias=False),                nn.BatchNorm2d(c_out)            )            self.is_downsample = True    def forward(self, x):        y = self.conv1(x)        y = self.bn1(y)        y = self.relu(y)        y = self.conv2(y)        y = self.bn2(y)        if self.is_downsample:            x = self.downsample(x)        return F.relu(x.add(y), True)def make_layers(c_in, c_out, repeat_times, is_downsample=False):    blocks = []    for i in range(repeat_times):        if i == 0:            blocks += [BasicBlock(c_in, c_out, is_downsample=is_downsample), ]        else:            blocks += [BasicBlock(c_out, c_out), ]    return nn.Sequential(*blocks)class Net(nn.Module):                 def __init__(self, num_classes=751, pretrained=True, loss = 'softmax', **kwargs):   # market1501=751, dukemtmcreid=702        super(Net, self).__init__()   # Net        # 3 128 64        self.conv = nn.Sequential(            nn.Conv2d(3, 64, 3, stride=1, padding=1),            nn.BatchNorm2d(64),            nn.ELU(inplace=True),        )        self.layer1 = make_layers(64, 64, 2, False)        self.layer2 = make_layers(64, 128, 2, True)        self.layer3 = make_layers(128, 256, 2, True)        self.layer4 = make_layers(256, 512, 2, True)        #self.avgpool = nn.AvgPool2d((8,4),1)        self.adaptiveavgpool = nn.AdaptiveAvgPool2d(1)        self.classifier = nn.Sequential(            nn.Linear(512, 256),            nn.BatchNorm1d(256),            nn.ReLU(inplace=True),            nn.Dropout(),            nn.Linear(256, num_classes),        )    def forward(self, x):        x = self.conv(x)        x = self.layer1(x)        x = self.layer2(x)        x = self.layer3(x)        x = self.layer4(x)        #x = self.avgpool(x)        x = self.adaptiveavgpool(x)   #        x = x.view(x.size(0),-1)        # B x 128        if not self.training:            x = x.div(x.norm(p=2,dim=1,keepdim=True))               return x        # classifier        x = self.classifier(x)        return xdef ZQP(num_classes=751, pretrained=True, loss='softmax', **kwargs):    model = Net(        num_classes=num_classes,         pretrained = pretrained,        loss = 'softmax',        **kwargs    )    return modelif __name__ == '__main__':    net = Net(pretrained=True)  # Net    x = torch.randn(4, 3, 256, 256)  # 128, 64    y = net(x)下面将模型ZQP添加到REID的定义文件中deep_sort/deep/reid/torchreid/models/__init__.py中引入ZQP模型文件，添加：from .model_ZQP import *1在字典__model_factory中添加模型名称ZQP:__model_factory = {# image classification models    'resnet18': resnet18,    'resnet34': resnet34,    'resnet50': resnet50,......    'ZQP': ZQP现在，只要修改deep_sort/configs/deep_sort.yaml中的MODEL_TYPE和REID_CKPT路径，就可运行ZQPei的reid模型ckpt.t7。  MODEL_TYPE: "ZQP"      REID_CKPT:  '~/your_dir/deep_sort/deep/checkpoint/ckpt.t7'另外，由于ZQPei reid模型训练中resize为128x64（hxw），故需修改deep_sort/deep/reid/torchreid/utils/feature_extractor.py中的image_sizedef __init__(        self,        model_name='',        model_path='',        image_size=(128, 64),           #(256, 128)  (h, w)        pixel_mean=[0.485, 0.456, 0.406],        pixel_std=[0.229, 0.224, 0.225],        pixel_norm=True,        device='cuda',        verbose=True    ):至此，我们完成了添加ZQP reid模型到KaiyangZhou REID模型中的整个过程，并可以用同样的命令行参数，运行track.pyreid模型训练deepsort中有两个神经网络模型，一个是目标检测模型yolov5，另一个是特征识别模型reid。yolov5模型训练有很多文章可参考，省略，此处侧重谈谈reid模型的训练。KaiyangZhou给出识别行人特征的reid模型训练方法，训练程序deep_sort/deep/reid/scripts/main.py。训练可分别采用两个数据集:Market-1501和DukeMTMC-reID。Market-1501数据集：训练数据集”bounding_box_train“有751个行人ID，包含 12,936 张图像，平均每人有17.2张训练数据；测试集“bounding_box_test”有750个行人ID，包含19,732张图像，平均每人有26.3张测试数据。查询集gally从测试集中挑选出750个行人在6个摄像头下的图片，共3368 张查询图像。dukemtmc-reid数据集：“bounding_box_test”——用于测试集的 702 人，包含 17,661 张图像（随机采样，702 ID + 408 distractor ID）“bounding_box_train”——用于训练集的 702 人，包含 16,522 张图像（随机采样）“query”——为测试集中的 702 人在每个摄像头中随机选择一张图像作为 query，共有 2,228 张图像只要从网上下载这两个数据集，使用其安排好的目录结构无需更改，只要指出数据集的根目录。以下给出ZQPei模型在dukemtmc-reid数据集的训练方法构造配置文件：deep_sort/deep/reid/configs/ZQP_128x64.yamlmodel:  name: 'ZQP'  pretrained: True #Truedata:  type: 'image'  sources: ['dukemtmcreid']  targets: ['dukemtmcreid']       # market1501,  dukemtmcreid  height: 128  width: 64  combineall: False  transforms: ['random_flip']    #random_flip random_erase  color_jitter  save_dir: 'deep_sort/deep/reid/log/ZQP'loss:  name: 'softmax'  softmax:    label_smooth: Truetrain:  optim: 'amsgrad'  lr: 0.0015  max_epoch: 40  #150  batch_size: 64  fixbase_epoch: 10   #10  open_layers: ['classifier']  #'classifier'  lr_scheduler: 'cosine'# stepsize: [60]test:  batch_size: 300  dist_metric: 'euclidean'  normalize_feature: False  evaluate:  False  #test only  eval_freq: -1  rerank: False运行训练程序main.pypython main.py \    --config-file  deep_sort/deep/reid/configs/ZQP_128x64.yaml   \    --root  ~/your_datasets/dukemtmc_reid   \    model.load_weights ~/your_dir/deep_sort/deep/checkpoint/ckpt.t7这里，在配置文件ZQP_128x64.yaml中pretrained = True，表示需加载预先训练的权重ckpt.t7。如果从头开始训练，则pretrained = False，并在命令行中删除model.load_weights项。命令行指定配置文件ZQP_128x64.yaml，数据集根目录dukemtmc_reid。此外，采用dukemtmc训练数据集行人ID数为702，所以，需更改特征类型为702, 即模型文件model_ZQP.py中num_classes=702。数据集目录组成应为：~/your_datasets/dukemtmc_reid/dukemtmc-reid/DukeMTMC-reID/bounding_box_test, bounding_box_train, query用逗号分开的项目表示在DukeMTMC-reID目录下有三个子目录bounding_box_test、bounding_box_train和query。用自己的数据集训练reid要利用KaiyangZhou reid训练程序，需要将数据集构造成market-1501的结构形式，即bounding_box_train, bounding_box_test, guery。下面是一个例子，用veri-wild提供的小汽车数据集来构造符合market-1501构成形式的数据集。veri-wild提供了包含40多万张4万辆汽车的id图片，每个汽车ID目录下有多张不同摄像机和不同时刻获取的汽车图片。假定选择800个汽车ID组成训练集，另外800个汽车ID组成测试集，从测试集中取出每个汽车ID在每个摄像头下的图片，组成query。（1）从veri-wild中分别抽取800个ID放入train_800和test_800，每个ID的图片在20-30张之间。（2）对train_800和test_800图片进行resize，压缩数据集容量。（3）按照market-1501文件命名规则更改数据集图片名称，并从test数据集挑选图片放入query。由此，仿照market-1501构成训练reid的小汽车数据集，进行汽车特征的reid特征识别模型。参考程序如下：import osfrom shutil import copyfile, copytree, rmtreefrom torch.functional import broadcast_shapesfrom PIL import Imageimport matplotlib.pyplot as pltimport randomimport shutildef get_cam_n(f_list):      # 构造列表[file_name, camera_ID]，列表抽取，每个camera_ID只取一项。    A = []    for cam_n in range(1,7):        for j in range(len(f_list)):            B = f_list[j][1]             if (f_list[j][1] == cam_n):                A.append(f_list[j])                break    return Adef make_fileprefix(src_dir, tar_dir, gallary_dir):   # src_dir 带ID子目录的数据集目录，ID子目录下是同一ID的图片。    for subdir in os.listdir( src_dir ):   # ID子目录名称        src=src_dir+"/"+subdir        f_list = []        for file_name in os.listdir(src):  # 提取ID子目录内文件名称            fileprefix= os.path.splitext(file_name)[0]            cam_n = random.randint(1,6)            A1=[fileprefix, cam_n]            f_list.append(A1)            file_name1 = subdir+ "_c"+str( cam_n) +"_f" +    fileprefix + ".jpg"            copyfile(src+"/"+file_name, tar_dir+"/"+file_name1)  #将各子目录文件添加prefix，拷贝到一个目标文件夹tar_dir            print("copyfile: ", file_name1)        f_cam=get_cam_n(f_list)           # 列表[file_name, camera_ID]，每个camera_ID只有一张图片。        for i in range(len(f_cam)):       # 从 test中抽取图片到query            file_prefix = f_cam[i][0]            cam_n = f_cam[i][1]            file_name1 = subdir+ "_c"+str( cam_n) +"_f" +    file_prefix + ".jpg"            file_name0 = src+"/"+file_prefix+'.jpg'            copyfile(file_name0, gallary_dir+"/"+file_name1)  #将各子目录文件添加prefix，拷贝到一个目标文件夹tar_dir    returndef image_resize(src_dir, tar_dir):    for subdir in os.listdir( src_dir ):   # ID子目录名称        src=src_dir+"/"+subdir        tar_ID_dir=tar_dir+"/"+subdir        if  os.path.isdir(tar_ID_dir):            rmtree(tar_ID_dir)        os.mkdir(tar_ID_dir)            for file_name in os.listdir(src):  # 提取ID子目录中文件名称            img=Image.open(src+"/"+file_name)            w, h =img.size        #img.show()            imax = max(h,w)            if imax < 280:                copyfile(src+"/"+file_name, tar_ID_dir+"/"+file_name)            else:                rate_hw = 280/imax                w,h = int(rate_hw*w), int(rate_hw*h)                new_img = img.resize((w, h),Image.BILINEAR)            #new_img.show()                new_img.save(tar_ID_dir+"/"+file_name)            print(tar_ID_dir+"/"+file_name)        returnif __name__ == '__main__':    src_dir = "~/your_datasets/resize/train_800"    tar_dir = "~/your_datasets/train_box"    if  os.path.isdir(tar_dir):        rmtree(tar_dir)    os.mkdir(tar_dir)    gallary_dir = "your_datasets/resize/gallary"    if  os.path.isdir(gallary_dir):        rmtree(gallary_dir)    os.mkdir(gallary_dir)    make_fileprefix(src_dir, tar_dir, gallary_dir)    ————————————————版权声明：本文为CSDN博主「王定邦」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/weixin_44238733/article/details/123805195

描述CrowdDet （目标检测/Pytorch）1. 概述此模型基于Detection in Crowded Scenes: One Proposal, Multiple Predictions中提出的模型结构实现，该算法会载入在CrowdHuman上的预训练模型，在用户数据集上做迁移学习。我们提供了训练代码和可用于训练的模型，用于实际场景的微调训练。训练后生成的模型可直接在ModelArts平台部署成在线服务。以识别**为目标的检测的评估手段一般用AP​， MR-2和JI(Jaccard Index)指标，详细描述可参考原论文或下表。指标描述AP​Averaged precision of detection.MR-2Log-average miss rate on false positive per image.JI​Jaccard Index.本算法其他信息如下表所示：项目说明参考论文Detection in Crowded Scenes: One Proposal, Multiple Predictions使用框架Pytorch-1.4.0 （在ModelArts上使用Pytorch-1.4.0创建训练作业，然后在训练开始之前将Pytorch升级为1.5.0）训练集CrowdHuman annotation_train.odgt + images训练总epoch数25 (from scratch)训练batch_size8卡训练，每张卡batch_size = 2训练硬件及耗时8*v100，约11小时测试集CrowdHuman annotation_val.odgt + images输入图像尺寸CrowdHuman: [3236, 4856, 3]原论文指标AP = 90.7%, MR-2 = 41.4%, JI = 82.3%​本算法指标AP = 90.6%, MR-2 = 41.3%, JI = 83.4%2. 训练2.1. 算法基本信息任务类型：（**）目标检测支持的框架引擎：PyTorch-1.4.0-python3.6（在ModelArts上使用Pytorch-1.4.0创建训练作业，然后在训练开始之前将Pytorch升级为1.5.0)算法输入：存储在OBS上的数据集，必须按照CrowdHuman数据集的格式进行储存，详情请查看下文第4节。CrowdHuman预训练模型，在CrowdHuman验证集上的AP​是90.96%。算法输出：用于Pytorch推理的pth模型，在验证集上的推理结果代码结构src |-- download/ # 算法运行时将OBS中储存的数据将加载到此目录 | |-- annotation_train.odgt | |-- annotation_val.odgt | |-- images/ | | |-- 1066405,100a000985ef070.jpg |-- pre-trained_weights/ | |-- resnet50_fbaug.pth # 训练模型所需要的backbone起点 |-- trained_model/ | |-- model/ | | |-- model_config.py # 模型和训练默认参数配置 | | |-- network.py # 模型结构 | | |-- config.json # 模型部署文件 | | |-- customize_service.py # 模型部署文件 | | |-- model_final.pth # 训练得到的模型，用于模型部署 | | |-- model_lib/ # 开源包、模型构建、数据集加载等文件 | | | |--... |-- tools/ | |-- run_infer.py # 推理 | |-- run_train.py # 训练模型 | |-- run_test.py # 在验证集上推理并输出评价指标 |-- config_env.sh # 运行前环境配置（升级Pytorch-1.5.0） |-- train.py # 算法执行文件 |-- evaluation.py # 输出业界评价标准2.2. 训练参数说明名称默认值类型是否必填是否可修改描述load_weight…/trained_model/model/model_final.pthstring否是训练起始模型，eval模式下则为测试模型，可以为obs路径total_epoch1int否是训练总轮数nr_images_epoch40000int否是每一轮训练用的图片数mini_batch_size2int否是每张卡的batch_sizewamr_iter1000int否是warmup循环数momentum0.9float否是SGD优化参数base_lr1.25e-3float否是具体learning rate根据实际GPU数计算log_dump_interval1int否是log打印频率weight_decay1e-4float否是SGD优化参数random_seed7int否是随机数种子evalfalsestring否是若设为1，则只从确定的模型pth在验证集上推理并计算评价指标2.3. 训练输出文件eval参数决定是否进行训练或跳过训练直接用现有模型在CrowdHuman验证集上推理评价。eval = 0训练模型，打印日志将模型储存在本地和train_url指定的路径（创建训练作业时指定的训练出入路径）所有输出在工作目录如下所示src |-- trained_model/ | |-- model/ |-- ...所有输出在obs上的目录如下所示|-- train_url/ | |-- model/eval = 1用指定的模型进行推理验证，若用户指定模型，必须保证load_weight是obs中模型.pth文件的绝对路径。用户指定的data_url（创建训练作业时指定的训练输入路径）中可以只包含.jpg格式的图片，也可以包含annotation_val.odgt文件，若为后者，则输出的文件中包含eval_results.txt为业界评价标准，否则只输出pred_results.json和pred_results目录。支持用户自定义OBS上的数据集路径，若需要输出评价指标，则需要包含符合格式要求的annotation_val.odgt文件，若不需要输出评价指标，可以直接将data_url指向只包含图片的OBS文件夹。所有输出在OBS的目录如下所示|-- train_url/ # 创建训练作业时指定的训练出入路径 | |-- eval_dump/ | | |-- pred_results.json # 模型推理结果 | | |-- eval_results.txt # 相应的评价指标结果 | | |-- pred_results/ # 对每个图片的推理结果 | | | |-- 1066405,100a000985ef070.json | | | |-- ...3. GPU/CPU本算法仅支持GPU运行。4. 数据准备从CrowdHuman下载CrowdHuman_train01.zip, CrowdHuman_train02.zip CrowdHuman_train03.zip, CrowdHuman_val.zip, annotation_train.odgt, annotation_val.odgt文件，将所有图片解压到同一个文件夹，最终保证在data_url（创建训练作业时指定的训练输入路径）中的目录如下所示|-- data_url/ # 创建训练作业时指定的训练出入路径 | |-- images/ # 所有解压得到的图片 | | |-- 1066405,100a000985ef070.jpg | | |-- ... | |-- annotation_train.odgt # 训练集标注文件 | |-- annotation_val.odgt # 验证集标注文件5. 案例指导本算法的详细使用方法，请查看ModelArts AI Gallery CrowdDet算法指导。交付交付方式华为云ModelArts交付区域华北-北京一、华北-北京四、华东-上海一、华南-广州、亚太-**

描述PointRend（图像分割/Pytorch）1.概述此模型基于PointRend: Image Segmentation as Rendering中提出的模型结构实现，该算法会载入在Cityscape上的预训练模型，在用户数据集上做迁移学习。我们提供了训练代码和可用于训练的模型，用于实际场景的微调训练。训练后生成的模型可直接在ModelArts平台部署成在线服务。图像分割的评估手段一般使用AP，详细说明请参考：https://github.com/mcordts/cityscapesScripts#evaluation本算法的其他信息如下表所示：项目说明参考论文PointRend: Image Segmentation as Rendering使用框架Pytorch1.4.0训练集Cityscapes leftImg8bit_trainvaltest.zip中的trainepoch65（通过控制maxiter*batchsize/nums of picturesbatchsize8，对应config文件夹下的yaml中IMS_PER_BATCH训练硬件及耗时1*v100，12小时测试集Cityscapes leftImg8bit_trainvaltest.zip中的test推理硬件及速度CPU，1.85s/pic输入图像尺寸1024*2048，3通道原论文APAP=35.8本算法APAP=36.2722.训练2.1算法基本信息任务类型：图像分割支持的框架引擎：PyTorch-1.4.0-python3.6算法输入：存储在OBS上的数据集，必须按照Cityscape数据集的格式进行存储，详情请查看下文第4节案例指导Cityscape预训练模型，在Cityscape上的AP是36.2728算法输出用于Pytorch推理的pth模型，CPU推理速度：1.85s/pic代码结构PointRend|-configs#配置文件，包括其他数据集|-InstanceSegmentation|-…|-SemanticSegmentation|-…|-Base-RCNN-FPN.yaml|-datasets#此文件夹为空，上传数据集时会自动同步至云端本目录|-detectron2#开源包|-…|-inputimage#空文件夹，用于运行demo.py时自动同步待预测的影像|-model#用于部署在线服务、批量服务|-customize_service.py#用于部署在线服务、批量服务|-iteration_24000_mAP_36.3.pth#最优模型参数|-config.json#配置文件|-…|-output#空文件夹，训练和评估时暂存模型结果，最后会同步至obs|-outputimage#空文件夹，运行demo.py时暂存输出影像，同步obs|-point_rend#模型其他包|-…|-pre-trained_weights#预训练参数|R-50.pkl|-config.json|-demo.py#预测整个文件夹的影像|-matches.json#预测整个文件夹影像的json结果文件|-pip-requirements.txt|-train_net.py#包括train和eval|-detectron2-0.3+cu102-cp36-cp36m-linux_x86_64.whl#detectron2包###2.2参数说明名称默认值类型是否必填是否可修改描述说明config-fileconfigs/InstanceSegmentation/pointrend_rcnn_R_50_FPN_1x_cityscapes.yamlstring是是配置文件路径，不配置时，默认路径为本算法代码内的路径eval-only0int否是训练时设置值为0，评估时设置值为1MODELWEIGHTSmodelweight/model_final.pthstring否是仅仅评估时才需要这个参数并设置值为默认值maxiter2400int否是最大迭代次数，可以控制epoch=maxiter*batchsize/影像总数batchsize8int否是批大小num-gpus1int否是gpu的数目注意：eval参数有以下两种取值：（1）0，本算法执行模型训练过程；（2）1，本算法加载load_weight参数指定的模型，然后执行模型评估过程。模型评估需要支持以下三种输入情况：2a) 创建训练作业时指定的数据存储位置data_url目录下，如果同时有图片和ground_truth，则模型评估过程输出pred_results目录和eval_result.txt文件，前者存放所有图片的预测结果，后者存放模型评估的精度指标；2b) 创建训练作业时指定的数据存储位置data_url目录下，如果只有图片，则模型评估过程输出pred_results目录，存放所有图片的预测结果；2c) 创建训练作业时指定的数据存储位置data_url目录下，如果没有图片，则模型评估过程报错；MODELWEIGHTS参数有以下两种取值：（1）固定的默认路径，默认加载本算法源码目录中的modelweight/model_final.pth继续训练，加载成功会打印日志；（2）可变的OBS路径，用户可指定OBS上的一个模型文件路径，然后本算法会加载该模型继续训练，加载成功会打印日志。##2.3. 训练输出文件当仅添加config-file并设置为configs/InstanceSegmentation/pointrend_rcnn_R_50_FPN_1x_cityscapes.yaml时为训练（此路径也支持用户的obs路径），训练完成后会输出可部署的model文件夹以及config.yaml、log.txt，文件结构如下： |-config.yaml配置文件 |-log.txt日志文件 |-model |-customize_service.py#用于部署在线服务、批量服务 |-model_final.pth#用户训练得到的模型参数 |-config.json#配置文件 |-...除config-file之外，如果添加超参数eval-only并设置为True,且添加超参数MODELWEIGHTS并设置为model/iteration_24000_mAP_36.3.pth（此路径也支持用户的obs路径）输出文件如下（pred_results和eval_result.txt都保存在指定的训练输出OBS目录下）：|-eval_result.txt#评估结果，只有用户上传的数据集包括groundtruth才会有这个文件 |-pred_results;预测影像文件夹 |-frankfurt_000000_000294_leftImg8bit.png |-frankfurt_000000_000576_leftImg8bit.png |-...#3. GPU/CPU推理元模型来源 选择 从训练中选择，选择训练作业及版本。注意：推理配置文件config.json中的runtime字段为pytorch1.4-python3.7，表示该模型可同时在CPU或GPU运行。#4. 案例指导本算法的详细使用方法，请查看《ModelArts AI Gallery算法PointRend使用指导》。交付交付方式华为云ModelArts交付区域华北-北京一、华北-北京四、华东-上海一、华南-广州、亚太-**

描述GFocal loss- Generalized Focal Loss1.概述此模型基于Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection中提出的模型结构实现。该算法基于任意one-stage 检测器上，调整框本身与框质量估计的表示，同时用泛化版本的GFocal Loss训练该改进的表示，无cost提升AP（约1%的提升）。本算法使用COCO2017trainval数据集进行训练和验证，测试数据集为COCO2017test-dev数据集，数据集详情参考COCOdataset官网，最终在CODALAB官网在线测试论文table4中最后一行模型的复现结果如下表所示。APAP50AP75APsmallAPmediumAPlarge0.4820.6720.5240.2930.5150.604本算法其他信息如下表所示项目说明参考论文Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection使用框架pytorch训练集coco2017 trainval训练总epoch数24训练batch_size2*8，其中2为训练参数中的samples_per_gpu每个GPU承担的图像数量,8为GPU_num即训练用到的GPU数目训练硬件8 * Tesla V100训练耗时32h 26min测试集coco2017 test-dev推理硬件1 * Tesla V100推理速度10.1 pic/s，此为在单GPUTesla-V100下，backbone为https://github.com/open-mmlab/mmdetection/blob/master/configs/gfl/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco.py2.训练2.1算法基本信息任务类型：目标检测支持的框架引擎：PyTorch-1.4.0-python3.6算法输入：存储在OBS上的数据集，必须按照COCO2017数据集的格式进行存储，详情请查看下文案例指导算法输出：用于Pytorch推理的pth模型，GPU推理速度：10.1s/pic2.2代码结构src |- pre-trained_weights |- checkpoints #主干网络预训练文件夹 |- trained_model |- model |- config.json |- customize_service.py |- best_model.pth |- start_alg_ctrl.py # 训练和预测启动文件 |- configs # mmdetection模型配置文件 |- ... |- gfl |- ... # GFocal模型配置文件 |- ... #mmdetection其他配置文件###2.3训练参数说明|参数 |类型 |是否可调整|默认值|是否必须|说明|| ------------ | ------------ | ------------ | ------------ |------------ ||train_epoch|Integer|true|1|true|数据集迭代次数||GPU_num|Integer|true|1|true|训练使用的GPU数量||samples_per_gpu|Integer|true|2|true|每个GPU承担的任务数，batchsize为其和GPU数的乘积||load_weight|String|true|trained_model/best_model.pth|true|load_weight参数有以下两种取值：（1）固定的默认路径，默认加载本算法源码目录中的trained_model/model/best_model.pth继续训练，加载成功会打印日志；（2）可变的OBS路径，用户可指定OBS上的一个模型文件路径，然后本算法会加载该模型继续训练，加载成功会打印日志。|eval|String|true|False|true|eval参数有以下两种取值：（1）False，本算法执行模型训练过程；（2）True，本算法加载load_weight参数指定的模型，然后执行模型评估过程。模型评估需要支持以下三种输入情况：2a) 创建训练作业时指定的数据存储位置data_url目录下，如果同时有图片和ground_truth，则模型评估过程输出pred_results目录和eval_result.txt文件，前者存放所有图片的预测结果，后者存放模型评估的精度指标；2b) 创建训练作业时指定的数据存储位置data_url目录下，如果只有图片，则模型评估过程输出pred_results目录，存放所有图片的预测结果；2c) 创建训练作业时指定的数据存储位置data_url目录下，如果没有图片，则模型评估过程报错；||warmup_ratio|String|true|0.001|true|初始学习率||lr|String|true|0.01|true|最终学习率|注意：如果eval为true，train_input中可以不需要train2017.zip和val2017.zip如果eval为false，train_input中可以不需要test2017.zip###2.4训练输出文件|- model |- customize_service.py |- config.json |- latest.pth # 训练所得模型 |- GFocal # mmdetection 和 GFocal配置文件3.GPU推理“元模型来源”从训练中选择，和从输出的OBS中选择均可。训练输出文件夹可直接用于导入模型部署各种服务###4.案例指导本算法的详细使用方法，请查看《ModelArts AI Gallery算法GFocal使用指导》交付交付方式华为云ModelArts交付区域华北-北京一、华北-北京四、华东-上海一、华南-广州、亚太-**

该autograd包提供自动求导为上张量的所有操作。它是一个按运行定义的框架，这意味着您的反向传播是由您的代码运行方式定义的，并且每次迭代都可以不同。torch.autograd.function （函数的反向传播）torch.autograd.functional （计算图的反向传播）torch.autograd.gradcheck （数值梯度检查）torch.autograd.anomaly_mode （在自动求导时检测错误产生路径）torch.autograd.grad_mode （设置是否需要梯度）model.eval() 与 torch.no_grad()torch.autograd.profiler （提供 function 级别的统计信息）「下面使用 Autograd 进行反向传播。」如果requires_grad=True，则 Tensor 对象会跟踪它是如何创建的。x = torch.tensor([1., 2., 3.], requires_grad = True) print('x: ', x) y = torch.tensor([10., 20., 30.], requires_grad = True) print('y: ', y) z = x + y print('\nz = x + y') print('z:', z) x: tensor([1., 2., 3.], requires_grad=True) y: tensor([10., 20., 30.], requires_grad=True) z = x + y z: tensor([11., 22., 33.], grad_fn=<AddBackward0>)因为requires_grad=True，z知道它是通过增加两个张量的产生z = x + y。s = z.sum() print(s) tensor(66., grad_fn=<SumBackward0>)s是由它的数字总和创建的。当我们调用.backward()，反向传播从s开始运行。然后可以计算梯度。s.backward() print('x.grad: ', x.grad) print('y.grad: ', y.grad) x.grad: tensor([1., 1., 1.]) y.grad: tensor([1., 1., 1.])下面例子是计算log(x)的导数为1 / ximport torch x = torch.tensor([0.5, 0.75], requires_grad=True) # 1 / x y = torch.log(x[0] * x[1]) y.backward() x.grad # tensor([2.0000, 1.3333])

什么是 PyTorch？PyTorch是一个基于Python的科学计算包，提供最大灵活性和速度的深度学习研究平台。张量张量类似于NumPy 的n 维数组，此外张量也可以在 GPU 上使用以加速计算。让我们构造一个简单的张量并检查输出。首先让我们看看我们如何构建一个 5×3 的未初始化矩阵：import torch x = torch.empty(5, 3) print(x)输出如下：tensor([[2.7298e+32, 4.5650e-41, 2.7298e+32], [4.5650e-41, 0.0000e+00, 0.0000e+00], [0.0000e+00, 0.0000e+00, 0.0000e+00], [0.0000e+00, 0.0000e+00, 0.0000e+00], [0.0000e+00, 0.0000e+00, 0.0000e+00]])现在让我们构造一个随机初始化的矩阵：x = torch.rand(5, 3) print(x)输出：tensor([[1.1608e-01, 9.8966e-01, 1.2705e-01], [2.8599e-01, 5.4429e-01, 3.7764e-01], [5.8646e-01, 1.0449e-02, 4.2655e-01], [2.2087e-01, 6.6702e-01, 5.1910e-01], [1.8414e-01, 2.0611e-01, 9.4652e-04]])直接从数据构造张量：x = torch.tensor([5.5, 3]) print(x)输出：tensor([5.5000, 3.0000])创建一个统一的长张量。x = torch.LongTensor(3, 4) x tensor([[94006673833344, 210453397554, 206158430253, 193273528374], [ 214748364849, 210453397588, 249108103216, 223338299441], [ 210453397562, 197568495665, 206158430257, 240518168626]])「浮动张量。」x = torch.FloatTensor(3, 4) x tensor([[-3.1152e-18, 3.0670e-41, 3.5032e-44, 0.0000e+00], [ nan, 3.0670e-41, 1.7753e+28, 1.0795e+27], [ 1.0899e+27, 2.6223e+20, 1.7465e+19, 1.8888e+31]])「在范围内创建张量」torch.arange(10, dtype=torch.float) tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])「重塑张量」x = torch.arange(10, dtype=torch.float) x tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])使用 .view重塑张量。x.view(2, 5) tensor([[0., 1., 2., 3., 4.], [5., 6., 7., 8., 9.]])-1根据张量的大小自动识别维度。x.view(5, -1) tensor([[0., 1.], [2., 3.], [4., 5.], [6., 7.], [8., 9.]])「改变张量轴」改变张量轴：两种方法view和permuteview改变张量的顺序，而permute只改变轴。x1 = torch.tensor([[1., 2., 3.], [4., 5., 6.]]) print("x1: \n", x1) print("\nx1.shape: \n", x1.shape) print("\nx1.view(3, -1): \n", x1.view(3 , -1)) print("\nx1.permute(1, 0): \n", x1.permute(1, 0)) x1: tensor([[1., 2., 3.], [4., 5., 6.]]) x1.shape: torch.Size([2, 3]) x1.view(3, -1): tensor([[1., 2.], [3., 4.], [5., 6.]]) x1.permute(1, 0): tensor([[1., 4.], [2., 5.], [3., 6.]])张量运算在下面的示例中，我们将查看加法操作：y = torch.rand(5, 3) print(x + y)输出：tensor([[0.5429, 1.7372, 1.0293], [0.5418, 0.6088, 1.0718], [1.3894, 0.5148, 1.2892], [0.9626, 0.7522, 0.9633], [0.7547, 0.9931, 0.2709]])调整大小：如果你想调整张量的形状，你可以使用“torch.view”：x = torch.randn(4, 4) y = x.view(16) # 大小-1是从其他维度推断出来的 z = x.view(-1, 8) print(x.size(), y.size(), z.size())输出：torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

NumPy 是Python 编程语言的库，增加了对大型、多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数集合。将Torch中Tensor 转换为 NumPy 数组，反之亦然是轻而易举的！Torch Tensor 和 NumPy 数组将共享它们的底层内存位置 ，改变一个将改变另一个。「将 Torch 张量转换为 NumPy 数组：」a = torch.ones(5) print(a)输出：tensor([1., 1., 1., 1., 1.])b = a.numpy() print(b)输出：[1., 1., 1., 1., 1.]让我们执行求和运算并检查值的变化：a.add_(1) print(a) print(b)输出：tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]「将 NumPy 数组转换为 Torch 张量：」import numpy as no a = np.ones(5) b = torch.from_numpy(a) np.add(a, 1, out=a) print(a) print(b)输出：[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

pt->onnx->pb->om发现有不支持的算子,要怎么解决