def __debug_nuse_nn_fcn__(): import torchstat m = FCN() torchstat.stat(m, (3, 64, 64)) x = torch.zeros(1, 3, 64, 64) assert x.size(2) == m(x).size(2) assert x.size(3) == m(x).size(3)
def test(): net = PreActResNet50(num_classes=1000) y = net((torch.randn(1, 3, 224, 224))) print(y.size()) from torchstat import stat stat(net, (3, 224, 224))
def main(): # parse arguments args = parse_args() if args is None: exit() # if args.gpu_mode and not torch.cuda.is_available(): # raise Exception("No GPU found, please run without --gpu_mode=False") # print 'scale factor = ', scale_factor, \ # '\ntest_dir =', args.test_dataset,\ from network import Net as net #from network import Net as net model = net(num_channels=1, scale_factor=4, d=32, s=5, m=1) #model = net(num_channels=1, scale_factor=4, d=32, s=5, m=5) #model.load_state_dict(torch.load(args.pretrained_model, map_location = torch.device('cpu'))) #In GPU type model.load_state_dict(torch.load(args.pretrained_model, map_location='cpu')) # for param_tensor in model.state_dict(): # #print(param_tensor) # #print(model.state_dict()[param_tensor].size()) # if 'act' in param_tensor: # print(param_tensor) # print(model.state_dict()[param_tensor]) # print(model) x = torch.randn(1, 1, 1024, 768, requires_grad=False).type(torch.float) stat(model, (1, 1024, 768))
def demo(): net = resnet50(num_classes=100) y = net(torch.randn(2,3,224,224)) print(y.size()) from torchstat import stat stat(net, (3, 224, 224)) # demo()
def demo(): from torchstat import stat st = time.perf_counter() for i in range(1): net = adaptive_learn_resnet50(num_classes=365) y = net(torch.randn(2, 3, 224, 224)) print(y.size()) # print("CPU time: {}".format(time.perf_counter() - st)) stat(net, (3, 224, 224))
def demo(): net = wide_resnet50_2() y = net(torch.randn(2, 3, 224, 224)) print(y.size()) from torchstat import stat stat(net, (3, 224, 224)) # demo()
def main(): database = RetrievalModel(args=args) logging.info("db param size = %fMB", utils.count_parameters_in_MB(database)) logging.info(stat(database,(3,224,224))) genotype = eval("genotypes.%s" % args.arch) model = Network(args.init_channels, args.code_size, args.layers, args.auxiliary, genotype) model.drop_path_prob = args.drop_path_prob logging.info("query param size = %fMB", utils.count_parameters_in_MB(model)) logging.info(stat(model,(3,224,224)))
def demo(): from torchstat import stat for i in range(1): net = resnext50(4, 64) y = net(torch.ones(2, 3, 224, 224)) print(y.size()) stat(net, (3, 224, 224)) # demo()
def main(): m = torch.load( '../../../work_dirs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x/epoch_12.pth' ) print(get_parameter_number(m['state_dict'])) model = init_detector( '../../../configs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x.py', '../../../work_dirs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x/epoch_12.pth' ) # count_params(model, (3, 800, 1333)) stat(model, fake_data(model, '../../../demo/normal_demo.jpg')) stat(model, fake_data(model, '../../../demo/defective_demo.jpg'))
def main(): genotype = eval("genotypes.%s" % args.arch) model = Network(args.init_channels, CLASSES, args.layers, args.auxiliary, genotype) #start_epochs = 0 model.drop_path_prob = 0 stat(model, (3, 224, 224)) genotype = eval("genotypes.%s" % "MY_DARTS") model = Network(args.init_channels, CLASSES, args.layers, args.auxiliary, genotype) model.drop_path_prob = 0 stat(model, (3, 224, 224))
def main(): args = arg() try: spec = importlib.util.spec_from_file_location('models', args.file) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) model = getattr(module, args.model)() except Exception: import traceback print(f'Tried to import {args.model} from {args.file}. but failed.') traceback.print_exc() import sys sys.exit() input_size = tuple(int(x) for x in args.size.split('x')) stat(model, input_size, query_granularity=1)
def main(): #统计神经网络 args = parser.parse_args() model = SENet.se_resnet50(num_classes=365) stat(model, (3, 224, 224)) model = SENet.se_resnet152(num_classes=365) stat(model, (3, 224, 224)) ''' traindir = os.path.join(args.data, 'train') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_loader = torch.utils.data.DataLoader( datasets.ImageFolder(traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) ''' print(time.asctime(time.localtime(time.time())))
def get_model_statics(model_name): compress_rate = [ 0.95, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.9, 0.9, 0.9, 0.9, 0.8, 0.8 ] model_state = torch.load('D:\\datasets\\saved_model\\hrprine\\' + model_name, map_location=device) net = VGG(num_classes=10, init_weights=False, cfg=None, compress_rate=compress_rate) if 'state_dict' in model_state.keys(): net.load_state_dict(model_state['state_dict']) else: net.load_state_dict(model_state) print(stat(net, (3, 32, 32)))
def main(): global args, best_prec1 global viz, train_lot, test_lot args = parser.parse_args() print("args", args) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) random.seed(args.seed) # create model if args.arch == "resnet": model = ResidualNet5('ImageNet', args.depth, 1000, args.att_type) # define loss function (criterion) and optimizer if 0: from torchstat import stat stat(model, (3, 224, 224)) exit() # model = model.cuda() # print ("model") # print (model) criterion = nn.CrossEntropyLoss().cuda() if args.loss_type == 'mse': criterion2 = cam_loss_mse_topk().cuda() elif args.loss_type == 'kd': criterion2 = cam_loss_kd_topk().cuda() optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) model = torch.nn.DataParallel(model, device_ids=list(range(args.ngpu))) #model = torch.nn.DataParallel(model).cuda() model = model.cuda() print("model") print(model) # get the number of model parameters print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) if 'optimizer' in checkpoint: optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'train') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # import pdb # pdb.set_trace() val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( valdir, transforms.Compose([ transforms.Scale(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, criterion2, 0) return train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomSizedCrop(224), # transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_sampler = None train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch prec1_train, loss_train = train(train_loader, model, criterion, criterion2, optimizer, epoch, args.weight) # evaluate on validation set prec1, loss_test = validate(val_loader, model, criterion, criterion2, epoch, args.weight) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best, args.prefix) print("best_prec1: ", best_prec1)
# 测试组件作用 model = ResNet(BasicBlock, [2, 2, 2, 2], num_classes) if pretrained: # pretrained_dict = torch.load(url) pretrained_dict = load_url("https://download.pytorch.org/models/resnet18-5c106cde.pth") model_dict = model.state_dict().copy() pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} model_dict.update(pretrained_dict) model.load_state_dict(model_dict) return model # def EHANet34(num_classes=19, url=None, pretrained=True): # model = ResNet(BasicBlock, [3, 4, 6, 3], num_classes) # if pretrained: # pretrained_dict = load_url("https://download.pytorch.org/models/resnet34-333f7ec4.pth") # # pretrained_dict = torch.load(url) # model_dict = model.state_dict().copy() # pretrained_dict = {k: v for k, # v in pretrained_dict.items() if k in model_dict} # model_dict.update(pretrained_dict) # model.load_state_dict(model_dict) # return model if __name__ == '__main__': from torchstat import stat net = EHANet18(pretrained=False) stat(net, (3, 256, 256))
def stat(self): stat(self.net, (3, self.config.ss_size, self.config.ss_size)) pass
bn.running_mean.data.numpy().tofile(f) bn.running_var.data.numpy().tofile(f) conv.weight.data.numpy().tofile(f) else: conv = model[0] if conv.bias.is_cuda: convert2cpu(conv.bias.data).numpy().tofile(f) convert2cpu(conv.weight.data).numpy().tofile(f) else: conv.bias.data.numpy().tofile(f) conv.weight.data.numpy().tofile(f) elif self.blocks[i+1]['type'] == 'shortcut': pass elif self.blocks[i+1]['type'] == 'route': pass elif self.blocks[i+1]['type'] == 'upsample': pass elif self.blocks[i+1]['type'] == 'yolo': pass else: print("Unknown layer type:{}".format(self.blocks[i+1]['type'])) if __name__=="__main__": darknet = Darknet("./data/yolo_v3.cfg") device = "cuda" if torch.cuda.is_available() else "cpu" from torchstat import stat stat(darknet, (3, 416, 416)) # summary(darknet, (3, 416, 416))
from transformers import BertModel from torchstat import stat if __name__ == '__main__': bert = BertModel.from_pretrained( "/Volumes/PortableSSD/bert模型/bert-base-chinese") print(stat(bert, ( 64, 500, )))
x1 = self.up1(x1) x1 = self.Conv_out1(x1) return x1 def count_param(model): param_count = 0 for param in model.parameters(): param_count += param.view(-1).size()[0] return param_count if __name__ == "__main__": # A full forward pass from torchstat import stat # from torchsummary import summary from thop import profile device = torch.device('cuda') # image_size = 128 # out = None # x = torch.rand((1, 1, 64, 64), device=device) # print("x size: {}".format(x.size())) model = CleanU_Net(4, 2,70) # flops, params = profile(model, inputs=(x, out)) # print("***********") # print(flops, params) # print("***********") # print(count_param(model)) # summary(model, input_size=(1, 256, 256), batch_size=1, device="cuda") stat(model, (1, 512, 512))
return locs, cls_scores from thop import profile, clever_format from torchstat import stat if __name__ == '__main__': #M = MobileNet() #for index, feat in enumerate(M.layers): # print(index) # print(feat) ''' model = SSD(class_num=7, backbone='VGG', device='cpu') print(model) image = torch.randn(3, 3, 300, 300) model(image) ''' #torch.save(model.state_dict(), 'temp.pth') ''' image = torch.randn(1, 3, 300, 300) model = SSD(class_num=6, backbone='MobileNetV1', device='cpu') flops, params = profile(model, inputs=(image,)) flops, params = clever_format([flops, params], "%.3f") print(flops, params) ''' model = SSD512(class_num=7, backbone='MobileNetV3_Small', device='cpu') stat(model, (3, 512, 512))
nums=2) self.fc = nn.Linear(2048, 10) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, sqrt(2. / n)) def make_layer(self, block, in_channels, out_channels, stride, nums): layers = [] for i in range(nums - 1): layers.append(block(in_channels, in_channels, 1)) layers.append(block(in_channels, out_channels, stride)) return nn.Sequential(*layers) def forward(self, x): x = self.input(x) x = self.res_block1(x) x = self.res_block2(x) x = self.res_block3(x) x = self.res_block4(x) x = self.avepool(x) x = x.view((x.shape[0], -1)) return self.fc(x) if __name__ == '__main__': net = resnet18() from torchstat import stat stat(net, (3, 32, 32))
Implementation of the OCR module: We aggregate the global object representation to update the representation for each pixel. """ def __init__(self, in_channels, key_channels, out_channels, scale=1, dropout=0.1, bn_type=None): super(SpatialOCR_Module, self).__init__() self.object_context_block = ObjectAttentionBlock(in_channels, key_channels, scale, bn_type) _in_channels = 2 * in_channels self.conv_bn_dropout = nn.Sequential( nn.Conv2d(_in_channels, out_channels, kernel_size=1, padding=0, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Dropout2d(dropout) ) def forward(self, feats, proxy_feats): context = self.object_context_block(feats, proxy_feats) output = self.conv_bn_dropout(torch.cat([context, feats], 1)) return output if __name__ == '__main__': net = SpatialOCR_Module(2048, 256, 256) from torchstat import stat stat(net, [(2048, 32, 32), (2048, 32, 32)])
gt_landmark = gt[idx, 5:] loss_landmark = self.mse(pred_landmark, gt_landmark) loss_landmark = torch.mean(loss_landmark, dim=1) # ohem n_keep = int(self.ohem * loss_landmark.shape[0]) loss_landmark = torch.mean(torch.topk(loss_landmark, n_keep)[0]) ## total loss loss_total = self.cls * loss_cls + self.bbox * loss_bbox + self.landmark * loss_landmark return loss_total, loss_cls, loss_bbox, loss_landmark loss_coef = { 'PNet': [1.0, 0.5, 0.5], 'RNet': [1.0, 0.5, 0.5], 'ONet': [1.0, 0.5, 1.0], } if __name__ == "__main__": from torchstat import stat stat(PNet(False), (3, 16, 16)) stat(RNet(False), (3, 24, 24)) stat(ONet(False), (3, 48, 48)) PNet() RNet() ONet()
self.branch3 = nn.Conv2d(192, out_channels, 1, 1) def forward(self, x1, x2, x3): y1 = self.branch1(x1) y2 = self.branch2(x2) y3 = self.branch3(x3) return y1, y2, y3 class BaseModel(nn.Module): def __init__(self, num_classes, is_mobile=True): super(BaseModel, self).__init__() # box + obj + 类别数 out_channels = (4 + 1 + num_classes) * 3 self.body = Body(is_mobile=is_mobile) self.head = Head(out_channels) def forward(self, x): y1, y2, y3 = self.body(x) y1, y2, y3 = self.head(y1, y2, y3) return y1, y2, y3 if __name__ == '__main__': from torchstat import stat model = BaseModel(2, True) stat(model, (3, 255, 255))
self.stage_block_cpm = stage_block_CPM(channel_scale, channel_scale) self.stage_block_paf = stage_block_PAF(channel_scale, channel_scale) self.stage_last_cpm = stage_last_CPM(channel_scale, channel_scale) self.stage_last_paf = stage_last_PAF(channel_scale, channel_scale) def forward(self, input): y = self.stage_first(input) cpm_1 = self.stage_block_cpm(y) paf_1 = self.stage_block_paf(y) y = torch.cat((y, cpm_1, paf_1), 1) cpm = self.stage_last_cpm(y) paf = self.stage_last_paf(y) # y = torch.cat((self.stage_last_cpm(y), self.stage_last_paf(y)), 1) return cpm_1, paf_1, cpm, paf if __name__ == '__main__': import torchstat # compute model size and FLOPs model = RTNet_Half() model = RTNet() torchstat.stat(model, (3, 368, 368)) # plot model graph # x = torch.randn(1, 3, 368, 368).requires_grad_(True) # y = model(x) # cc = make_dot(y, params=dict(list(model.named_parameters()) + [('x', x)])) # compute model params size # summary(model, (3, 368, 368), device='cpu')
self.aspp_18 = _DenseASPPConv(in_channels + inter_channels2 * 3, inter_channels1, inter_channels2, 18, 0.1, norm_layer, norm_kwargs) self.aspp_24 = _DenseASPPConv(in_channels + inter_channels2 * 4, inter_channels1, inter_channels2, 24, 0.1, norm_layer, norm_kwargs) def forward(self, x): aspp3 = self.aspp_3(x) x = torch.cat([aspp3, x], dim=1) aspp6 = self.aspp_6(x) x = torch.cat([aspp6, x], dim=1) aspp12 = self.aspp_12(x) x = torch.cat([aspp12, x], dim=1) aspp18 = self.aspp_18(x) x = torch.cat([aspp18, x], dim=1) aspp24 = self.aspp_24(x) x = torch.cat([aspp24, x], dim=1) return x model = PAmodule(19) # model = ASPP() # model = _DenseASPPHead(2048, 19) stat(model, (2048, 54, 54))
Upsampler(scale, n_feats, act=None, group=group), nn.Conv2d( n_feats, n_colors, kernel_size=3, padding=kernel_size // 2) ]) def forward(self, x): x = self.sub_mean(x) x = self.head(x) b1 = self.b1(x) c1 = torch.cat([x, b1], dim=1) o1 = self.act(self.c1(c1)) b2 = self.b2(o1) c2 = torch.cat([c1, b2], dim=1) o2 = self.act(self.c2(c2)) b3 = self.b3(o2) c3 = torch.cat([c2, b3], dim=1) o3 = self.act(self.c3(c3)) x = self.tail(o3) x = self.add_mean(x) return x from torchstat import stat net = E_CARN() stat(net, (3, 10, 10))
d4_ = F.interpolate(d4, size=(img_h, img_w), mode='bilinear', align_corners=False) d3_ = F.interpolate(d3, size=(img_h, img_w), mode='bilinear', align_corners=False) d2_ = F.interpolate(d2, size=(img_h, img_w), mode='bilinear', align_corners=False) side_4 = self.side_4(d4_) side_3 = self.side_3(d3_) side_2 = self.side_2(d2_) d = self.fu1 * d1 + self.fu2 * side_2 + self.fu3 * side_3 + self.fu4 * side_4 # train d branch and test only d1 branch return [torch.sigmoid(d), torch.sigmoid(d1), torch.sigmoid(side_2), torch.sigmoid(side_3), \ torch.sigmoid(side_4)] if __name__ == '__main__': from torchstat import stat input_size = (784, 1168) net = MDMNet(input_size=input_size) stat(net, (3, ) + input_size)
def demo(): from torchstat import stat net = resnet50(num_classes=365) y = net(torch.randn(1, 3, 224, 224)) print(y.size()) stat(net, (3, 224, 224))
def torch_stat(self): stat(self.encoder.to('cpu'), input_size=(3, self.feed_width, self.feed_height))