python将txt转为json_将maskrcnn_benchmark的python模型转为C++ libtorch的模型

最新推荐文章于 2024-06-27 17:35:15 发布
原创 最新推荐文章于 2024-06-27 17:35:15 发布 · 161 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python将txt转为json

本文介绍如何将Python的Mask R-CNN模型转换为C++可用的模型，包括模型权重的保存与加载，以及如何使用libtorch进行模型整合。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

8f583023363ad800ed53c79233afcada.png

深度学习需要巨大的计算量，对于开发原型可以用python,matlab比较方便，但是真正实用化的话，c++作为底层语言明显更具优势。

目前大部分的优秀的深度学习项目仍然是以python为主流语言，但随着libtorch的出现，相信未来会有更多利用C++作为深度学习开发的项目。

这篇文章主要是给大家介绍如何将经典的maskrcnn_benchmark的模型转为libtorch可以用的C++模型。

maskrcnn的整体框架图如下

6a0bda9baf4fb3c0c92944d70e5004d7.png
maskrcnn框架图

利用torch.jit.trace保存模型权重值

import argparse
import torch

import os

from maskrcnn_benchmark.config import cfg
from maskrcnn_benchmark.modeling.detector import build_detection_model
from maskrcnn_benchmark.utils.checkpoint import DetectronCheckpointer


class wrapper(torch.nn.Module):
    def __init__(self, model):
        super(wrapper, self).__init__()
        self.model = model
    
    def forward(self, input):
        output = self.model(input)
        return tuple(output)



def output_tuple_or_tensor(model, tensor):
    output = model(tensor)
    if isinstance(output, (torch.Tensor, tuple)):
        return model
    elif isinstance(output, list):
        return wrapper(model)


def main():
    parser = argparse.ArgumentParser(description="PyTorch Object Detection jit")
    parser.add_argument(
        "--config-file",
        default="/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml",
        metavar="FILE",
        help="path to config file",
    )
    parser.add_argument(
        "--weight_path",
        help="weight file path"
    )
    parser.add_argument(
        "--output_path",
        help="jit output path",
        type=str,
        default='./'
    )
    args = parser.parse_args()

    cfg.merge_from_file(args.config_file)
    model = build_detection_model(cfg)
    checkpoint = DetectronCheckpointer(cfg, model, save_dir=cfg.OUTPUT_DIR)
    _ = checkpoint.load(args.weight_path, None)
    
    #backbone save
    backbone_tensor = torch.zeros(2, 3, 320, 320)
    tmp_model = output_tuple_or_tensor(model.backbone, backbone_tensor)
    for i, j in model.named_parameters():
        print(i)
    print("-------------------------------------------------------------------------------------------------")
    for i, j in model.named_buffers():
        print(i)
    backbone_jit = torch.jit.trace(tmp_model, backbone_tensor)
    backbone_jit.save(os.path.join(args.output_path, 'backbone.pth'))

    #rpn
    #conv
    conv_in_channels = model.rpn.head.conv.weight.shape[1]
    conv_tensor = torch.zeros(2, conv_in_channels, 10, 10)
    conv_jit = torch.jit.trace(model.rpn.head.conv, conv_tensor)
    conv_jit.save(os.path.join(args.output_path, 'rpn_conv.pth'))

    #cls_logits
    logits_in_channels = model.rpn.head.cls_logits.weight.shape[1]
    logits_tensor = torch.zeros(2, logits_in_channels, 10, 10)
    logits_jit = torch.jit.trace(model.rpn.head.cls_logits, logits_tensor)
    logits_jit.save(os.path.join(args.output_path, 'rpn_logits.pth'))

    #bbox_pred
    bbox_in_channels = model.rpn.head.bbox_pred.weight.shape[1]
    bbox_tensor = torch.zeros(2, bbox_in_channels, 10, 10)
    bbox_jit = torch.jit.trace(model.rpn.head.bbox_pred, bbox_tensor)
    bbox_jit.save(os.path.join(args.output_path, 'rpn_bbox.pth'))

    #box_head
    #feature extractor
    for k, v in model.roi_heads.box.feature_extractor._modules.items():
        if 'head' in k:
            #resnet head
            extractor_in_channels = v._modules['layer4'][0]._modules['downsample'][0].weight.shape[1]
            extractor_tensor = torch.zeros(2, extractor_in_channels, 10, 10)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_' + k + '.pth'))
        elif 'fc' in k:
            extractor_in_channels = v.weight.shape[1]
            extractor_tensor = torch.zeros(2, extractor_in_channels)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_' + k + '.pth'))
        elif 'conv' in k:
            extractor_in_channels = v.weight.shape[1]
            extractor_tensor = torch.zeros(2, extractor_in_channels, 10, 10)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_' + k + '.pth'))

    #box_head
    #predictor
    cls_score_in_channels = model.roi_heads.box.predictor.cls_score.weight.shape[1]
    cls_score_tensor = torch.zeros(2, cls_score_in_channels)
    cls_score_jit = torch.jit.trace(model.roi_heads.box.predictor.cls_score, cls_score_tensor)
    cls_score_jit.save(os.path.join(args.output_path, 'cls_score.pth'))

    bbox_pred_in_channels = model.roi_heads.box.predictor.bbox_pred.weight.shape[1]
    bbox_pred_tensor = torch.zeros(2, bbox_pred_in_channels)
    bbox_pred_jit = torch.jit.trace(model.roi_heads.box.predictor.bbox_pred, bbox_pred_tensor)
    bbox_pred_jit.save(os.path.join(args.output_path, 'bbox_pred.pth'))


    #mask_head
    #feature extractor
    for k, v in model.roi_heads.mask.feature_extractor._modules.items():
        if 'head' in k:
            #resnet head
            extractor_in_channels = v._modules['layer4'][0]._modules['downsample'][0].weight.shape[1]
            extractor_tensor = torch.zeros(2, extractor_in_channels, 10, 10)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_mask_' + k + '.pth'))
        elif 'fc' in k:
            extractor_in_channels = v.weight.shape[1]
            extractor_tensor = torch.zeros(256, extractor_in_channels,3,3)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_mask_' + k + '.pth'))
        elif 'conv' in k:
            extractor_in_channels = v.weight.shape[1]
            extractor_tensor = torch.zeros(2, extractor_in_channels, 10, 10)
            extractor_jit = torch.jit.trace(v, extractor_tensor)
            extractor_jit.save(os.path.join(args.output_path, 'extractor_mask_' + k + '.pth'))

    #mask head
    #predictor
    mask_cls_score_in_channels = model.roi_heads.mask.predictor.conv5_mask.weight.shape[1]
    #print(mask_cls_score_in_channels)
    mask_cls_score_tensor = torch.zeros(2, mask_cls_score_in_channels,2,2)
    mask_cls_score_jit = torch.jit.trace(model.roi_heads.mask.predictor.conv5_mask, mask_cls_score_tensor)
    mask_cls_score_jit.save(os.path.join(args.output_path, 'mask_cls_score.pth'))

    mask_pred_in_channels = model.roi_heads.mask.predictor.mask_fcn_logits.weight.shape[1]
    mask_pred_tensor = torch.zeros(2, mask_pred_in_channels,2,2)
    mask_pred_jit = torch.jit.trace(model.roi_heads.mask.predictor.mask_fcn_logits, mask_pred_tensor)
    mask_pred_jit.save(os.path.join(args.output_path, 'mask_pred.pth'))


if __name__ == "__main__":
    main()
    print('Complete!')

注意！我们这边的操作仅仅是把模型的权重给保存下来，由于torch.jit.trace功能并不能将动态图和控制流等操作保存下来，所以并不能直接形成一个python一样的端到端的模型！所以我们这边退而求其次的保存模型权重，其他的操作在C++部分完成（比如NMS等）。

我们可以在python端，通过打印模型的named_parameters()和named_buffers知道我们要保存哪些权重信息。

在得到各个模块trace的模型之后，我们利用libtorch将所有模型整合在一起：

由于整体的代码工程较为庞大（我们把整个maskrcnn_benchmark的代码转为了C++版本的），所以我们附上其中模型转换比较核心的部分和大家交流。

其中

modeling::GeneralizedRCNN model = modeling::BuildDetectionModel();

是根据python版maskrcnn_benchmark写的一个C++的模型类，内容完全一样，只是语言不同。

这边转换的核心思想是，将模型中的named_parameters和named_buffers中带有backbone，rpn和roi_heads.box关键词的权重读到这个实体类中。

调用jit_to_cpp.h中的jit_to_cpp(模型权重存放位置, 模型的yaml配置文件, 模型权重名<向量形式>）就可以整合出C++的模型。

通过搜索关键词，将模型中的权重信息整合起来

jit_to_cpp.h

#pragma once
#include <torch/torch.h>
#include <torch/script.h>

#include <defaults.h>
#include <modeling.h>

#include <iostream>
#include <bisect.h>


namespace rcnn{
namespace utils{

void recur(torch::jit::script::Module& module, std::string name, std::map<std::string, torch::Tensor>& saved);

template<typename T>
void jit_to_cpp(std::string weight_dir, std::string config_path, std::vector<std::string> weight_files){
  T mapper = T();
  std::map<std::string, torch::Tensor> saved;
  std::set<std::string> updated;
  std::map<std::string, std::string> mapping;

  rcnn::config::SetCFGFromFile(config_path);
  modeling::GeneralizedRCNN model = modeling::BuildDetectionModel();
  torch::NoGradGuard guard;

  for(auto& weight_file : weight_files){
    auto module_part = torch::jit::load(weight_dir + "/" + weight_file);
    recur(module_part, weight_file.substr(0, weight_file.size()-4), saved);
  }
  for (auto i : saved) {
      std::cout << i.first << "n";
  }
  for(auto& i : model->named_parameters()){
      std::cout << i.key() << "n";
    std::string new_name;
    if(i.key().find("backbone") != std::string::npos){
      new_name = mapper.backboneMapping(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else if(i.key().find("rpn") != std::string::npos){
      new_name = mapper.rpn(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else if((i.key().find("roi_heads.box") != std::string::npos)||(i.key().find("roi_heads.mask") != std::string::npos)){
      new_name = mapper.roiHead(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else{
      assert(false);
    }
  }
  
  for(auto& i : model->named_buffers()){
    std::string new_name;
    if(i.key().find("backbone") != std::string::npos){
      new_name = mapper.backboneMapping(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else if(i.key().find("rpn") != std::string::npos){
      new_name = mapper.rpn(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else if((i.key().find("roi_heads.box") != std::string::npos) || (i.key().find("roi_heads.mask") != std::string::npos)) {
      new_name = mapper.roiHead(i.key(), i.value(), saved);
      updated.insert(i.key());
      mapping[i.key()] = new_name;
    }
    else{
      assert(false);
    }
  }

  torch::serialize::OutputArchive archive;
  for(auto& i : model->named_parameters()){
    std::cout << i.key() << " parameter loaded from " << mapping[i.key()] << "n";
    assert(updated.count(i.key()));
    assert((saved.at(mapping[i.key()]) != i.value()).sum().item<int>() == 0);
    archive.write(i.key(), i.value());
  }

  for(auto& i : model->named_buffers()){
      std::cout << i.key() << " buffer loaded from " << mapping[i.key()] << "n";
    assert(updated.count(i.key()));
    if(i.key().find("anchor_generator") == std::string::npos){
      assert( (saved.at(mapping[i.key()]) != i.value()).sum().item<int>() == 0);
    }
    archive.write(i.key(), i.value(), true);
  }
  archive.save_to("../models/new_pth_from_python_cpp.pth");
  std::cout << "saved as /models/new_pth_from_python_cpp.pthn"; 
}

class ResNetMapper{

public:
  ResNetMapper() = default;
  std::string backboneMapping(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);
  std::string roiHead(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);
  std::string rpn(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);

};

class VoVNetMapper{

public:
  VoVNetMapper() = default;
  std::string backboneMapping(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);
  std::string roiHead(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);
  std::string rpn(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved);
};


}
}

jit_to_cpp.cpp：

#include "jit_to_cpp.h"

#include <cassert>
#include <iostream>


namespace rcnn{
namespace utils{

void recur(torch::jit::script::Module& module, std::string name, std::map<std::string, torch::Tensor>& saved){
  std::string new_name;
  if(name.compare("") != 0)
    new_name = name + ".";
  
  for(auto u : module.get_parameters()){
    torch::Tensor tensor = u.value().toTensor();;
    saved[new_name + u.name()] = tensor;
  }
  for(auto u : module.get_attributes()){

    torch::Tensor tensor = u.value().toTensor();
    saved[new_name + u.name()] = tensor;
  }
  for(auto i : module.get_modules())
    recur(i, new_name + i.name().name(), saved);
}

std::string ResNetMapper::backboneMapping(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved){
  std::string new_name = name.substr(20);
  if(name.find("fpn") != std::string::npos){
    new_name = new_name.substr(0, 14);
    if(name.find("weight") != std::string::npos){
      new_name += ".weight";
    }
    else{
      new_name += ".bias";
    }
  }

  for(auto s = saved.begin(); s != saved.end(); ++s){
    if((s->first).find(new_name) != std::string::npos){
      value.copy_(s->second);
      return s->first;
      // updated.insert(i.key());
      // mapping[i.key()] = s->first;
    }
  }
  assert(false);
}

std::string ResNetMapper::roiHead(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved){
  std::string new_name;
      if (name.find("cls_score") != std::string::npos) {
          if (name.find("weight") != std::string::npos)
              new_name = "cls_score.weight";
          else
              new_name = "cls_score.bias";
          value.copy_(saved.at(new_name));
          return new_name;
      }
      else if (name.find("bbox_pred") != std::string::npos) {
          if (name.find("weight") != std::string::npos)
              new_name = "bbox_pred.weight";
          else
              new_name = "bbox_pred.bias";
          value.copy_(saved.at(new_name));
          // updated.insert(i.key());
          // mapping[i.key()] = name;
          return new_name;
      }
      else if (name.find(".head.") != std::string::npos) {
          new_name = name.substr(39);
          for (auto s = saved.begin(); s != saved.end(); ++s) {
              if ((s->first).find(new_name) != std::string::npos) {
                  value.copy_(s->second);
                  // updated.insert(i.key());
                  // mapping[i.key()] = s->first;
                  return s->first;
              }
          }
          assert(false);
      }
      else if (name.find("conv5_mask") != std::string::npos) {
          if (name.find("weight") != std::string::npos)
              new_name = "mask_cls_score.weight";
          else
              new_name = "mask_cls_score.bias";
          value.copy_(saved.at(new_name));
          // updated.insert(i.key());
          // mapping[i.key()] = name;
          return new_name;
      }
      else if (name.find("mask_fcn_logits") != std::string::npos) {
          if (name.find("weight") != std::string::npos)
              new_name = "mask_pred.weight";
          else
              new_name = "mask_pred.bias";
          value.copy_(saved.at(new_name));
          // updated.insert(i.key());
          // mapping[i.key()] = name;
          return new_name;
      }
      else if (name.find("mask_fcn") != std::string::npos) {
          new_name = "extractor_mask_" + name.substr(name.find("mask_fcn"));
          new_name.erase(new_name.begin() + 24, new_name.begin() + 26);
          value.copy_(saved.at(new_name));
          // updated.insert(i.key());
          // mapping[i.key()] = name;
          return new_name;
      }
      else if (name.find("fc") != std::string::npos) {
          new_name = "extractor_" + name.substr(name.find("fc"));
          value.copy_(saved.at(new_name));
          // updated.insert(i.key());
          // mapping[i.key()] = name;
          return new_name;
      }
  else{
    assert(false);
  }
}

std::string ResNetMapper::rpn(const std::string& name, torch::Tensor& value, std::map<std::string, torch::Tensor>& saved){
  std::string new_name;
  if(name.find("conv") != std::string::npos){
    if(name.find("weight") != std::string::npos)
      new_name = "rpn_conv.weight";
    else
      new_name = "rpn_conv.bias";
    value.copy_(saved.at(new_name));
    return new_name;
  }
  else if(name.find("bbox") != std::string::npos){
    if(name.find("weight") != std::string::npos)
      new_name = "rpn_bbox.weight";
    else
      new_name = "rpn_bbox.bias";
    value.copy_(saved.at(new_name));
    // updated.insert(i.key());
    // mapping[i.key()] = name;
    return new_name;
  }
  else if(name.find("logits") != std::string::npos){
    if(name.find("weight") != std::string::npos)
      new_name = "rpn_logits.weight";
    else
      new_name = "rpn_logits.bias";
    value.copy_(saved.at(new_name));
    return new_name;
  }
  else if (name.find("anchors") != std::string::npos) {
      new_name = name;
      return new_name;
  }
  else{
    assert(false);
 }
}

}
}
c++使用libtorch 库运行python下pytorch保存的模型
qq_43790749的博客
12-24 1663
1.到pytorch的官网下载libtorch,可放在任意位置. 2.在python下保存c++可调用的模型.保存代码如下: net.cpu().eval() # An example input you would normally provide to your model's forward() method. #example = torch.rand(1, 4) example = to...
LLM 大模型学习必知必会系列(十一)：大模型自动评估理论和实战以及大模型评估框架详解
丨汀、的博客
05-24 2583
LLM 大模型学习必知必会系列(十一)：大模型自动评估理论和实战以及大模型评估框架详解
【Detectron2】使用 Detectron2 训练基于 coco 数据集的目标检测网络
呆呆的猫的博客
06-15 1万+
用 Detectron2 训练基于 coco 数据集的目标检测网络
MaskRCNN-Benchmark(Pytorch版本)训练自己的数据以及避坑指南
HuangQinJian
05-01 2万+
一、安装 首先要阅读官网说明的环境要求，千万不要一股脑直接安装，不然后面程序很有可能会报错！！！ PyTorch 1.0 from a nightly release. It will not work with 1.0 nor 1.0.1. Installation instructions can be found in https://pytorch.org/get-started/lo...
Mask_RCNN的TensorRT加速
幸福回头的博客
08-14 7011
现有的网络上，主流的Mask RCNN主要有两个，一个是matterport的Keras版本https://github.com/matterport/Mask_RCNN，有13.5K的star，一个是facebookresearch的PyTorch版本6.2K的star，链接如下https://github.com/facebookresearch/maskrcnn-bench...
pytorch torch.jit.trace()使用模型转换要注意的问题
xingtianyao的博客
09-28 1万+
https://www.jianshu.com/p/8206b198533d 如果代码中有if条件控制，尽量避免使用torch.jit.trace来转换代码，因为它不能处理变化条件，如果非要用trace的话，可以把if条件控制改成别的形式，比如： def f(x): if x > 0: return False else: return True 可以改成: def f(x): return x <= 0 jit不能转换第三方Py...
c++ python混合编程 restful_聊聊C++ Restful API 框架库
weixin_39531183的博客
12-16 1024
以前为了完成课程作业，临时学了不少Python和Java的Web编程技术，如Django、Spring Boot，这两个框架可以很容易编写Restful接口供前端调用，而且这个也是我在编写C++程序所从未使用过的，所以我十分好奇C++是否可以编写Restful接口呢？于是我到GitHub上逛了一圈：GitHub上的C++ Rest库果然，开源社区有不少用C++编写的Restful接口的库，star...
python场景重建_ScanNet 室内场景3D重建丰富标记数据集
weixin_39963523的博客
12-20 665
ScanNetScanNet is an RGB-D video dataset containing 2.5 million views in more than 1500 scans, annotated with 3D camera poses, surface reconstructions, and instance-level semantic segmentations.ScanNe...
c++客户端 grpc_gRPC应用C++
weixin_40006133的博客
12-21 1562
1． gRPC简述RPC，远程方法调用，就是像调用本地方法一样调用远程方法。gRPC是Google实现的一种RPC框架，基于HTTP/2标准设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C...
克服资源障碍：大模型量化技术与高效部署策略全解析
2401_82700030的博客
06-27 2268
本文综述了大模型量化的方法、适用场景以及最新的研究进展，为读者解决部署使用大模型时遇到的计算资源不足的情景提供了一种视角
2.1【Pytorch版(torch-cuda版 ) Mask-RCNN 训练自己的数据集】
木易进
05-15 1万+
写在前面：由于课程试验要求，需要基于pytorch实现maskrcnn，so最近又跑了一下pytorch版的maskrcnn，官方已经给出了详细的教程，虽然说支持cpu推理，但是不支持cpu训练啊，奈何手头上只有一个cpu本，也没有nvida显卡，只有intel的集显，so整理一波本次训练maskrcnn的过程。 这篇blog是按照常规的torch版的maskrcnn的训练教程写的，理论上，所依赖的是torch-cuda版本，后续还有一篇是基于torch-cpu版本的。因为在试验过程中先踩了这部分的坑，.
深度学习模型剪枝的实现
weixin_60360239的博客
03-16 1919
对于深度学习来说，比较复杂的模型往往有着不错的识别效果，但是复杂的模型往往对算力要求也比较高，在一些对于实时性要求比较高或者算力比较小的应用场景中，这时复杂的模型往往不能很好达到预期效果，这时候就要进行模型的剪枝，提高模型的运算速度。剪枝也就是将这个参数置为0，消除这些节点与后面的联系，从而降低运算量，本文主要基于对于模型剪枝的实战展开。
Caffe2 - (二十) Detectron 之 config.py 文件参数
长风破浪会有时，直挂云帆济沧海
03-22 7269
Caffe2 - (二十) Detectron 之 config.py 文件 给出了 Detectron 的默认参数，其位于 lib/core/config.py. 类似于 Faster R-CNN 中对应的形式.一般不更改该文件参数，可以根据设置 yaml 文件并利用 merge_cfg_from_file (yaml_file) 来加载自定义参数
maskrcnn用于目标检测_maskrcnn-benchmark
weixin_35986497的博客
12-29 1495
Faster R-CNN and Mask R-CNN in PyTorch 1.0This project aims at providing the necessary building blocks for easilycreating detection and segmentation models using PyTorch 1.0.How to install, 安装教程 (Supp...
Pytorch中的register_buffer()
热门推荐
weixin_46197934的博客
08-09 2万+
Pytorch中的register_buffer1.register_buffer( )的使用随着例子边看边讲例子1：使用类成员变量（类成员变量并不会在我们的model.state_dict()，即无法保存）例子2：使用类成员变量（类成员变量并不会随着model.cuda()复制到gpu上）例子3：使用register_buffer()总结2.与pa 1.register_buffer( )的使用 回顾模型保存：torch.save(model.state_dict())，model.state_dict(
Pytorch 容器 - 2. Module的属性访问 modules(), children(), parameters(), buffers()等
Aaron_neil的博客
04-16 923
Module类内置了很多函数，其中本文主要介绍常用的属性访问函数，包括： modules(), named_modules(), buffers(), named_buffers(), children(), named_children(), parameters(), named_parameters()。
Mask RCNN裁剪后移植到Android端，报错解决方案
Jverson2009的专栏
12-06 735
模型是在tensorflow r1.12中训练的，所以使用tensorflow r1.12的源码编译libtensorflow_inference.so来配套移植到Android端，结果报了以下两个错误： 1. Op type not registered 'NonMaxSuppressionV3' in binary running on localhost. Make sure the Op...
facebook-pytorch maskrcnn-benchmark 实现 （anaconda+python3.7+cuda8.0）
无左无右的博客
06-03 1806
作者github地址：https://github.com/facebookresearch/maskrcnn-benchmark 作者提供的install Requirements: PyTorch 1.0 from a nightly release. It will not work with 1.0 nor 1.0.1. Installation instructions can ...
caffe学习（四）：py-faster-rcnn配置，运行测试程序（Ubuntu）
hongbin_xu的博客
07-26 1万+
上一篇博客中讲了在Ubuntu下安装caffe的经验总结（各种问题，简直怀疑人生了）。博客链接：点我打开 faster-rcnn有两个版本，分别是python的和MATLAB的。这里介绍python版本的faster-rcnn的配置。 网上有很多相关的教程，起初我在配置时也被一些博客坑了，这里分享一下调试和解决问题的过程。下载工程输入指令：Git clone --recursive https
如何在vscode中将python文件转化为cpython文件运行来提高运行速率
最新发布
03-25
CPython是解释器，而Cython是静态编译器，可以将Python代码转为C，再编译成共享库，供Python调用。此外，需要确保用户正确安装Cython和构建工具，如setuptools和C编译器（如GCC或MSVC）。 另外，用户可能希望了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值