Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
@staticmethod
def _flops(h, w, C_in, C_out, kernel_size=3, stride=1, dilation=1, groups=1):
assert stride in [1, 2]
layer = BasicResidual_downup_2x(C_in, C_out, kernel_size, stride, dilation, groups, slimmable=False)
flops, params = profile(layer, inputs=(torch.randn(1, C_in, h, w),))
return flops
m.bias.data.fill_(0)
elif isinstance(m, nn.Linear):
m.weight.data.normal_(0, 0.01)
m.bias.data.zero_()
if __name__ == '__main__':
import thop
vgg = VGG()
input = torch.randn(1, 3, 32, 32)
output = vgg(input)
print(output.shape)
flops, params = thop.profile(vgg, inputs=(input,), verbose=False)
flops, params = thop.clever_format([flops, params], "%.3f")
print(flops, params)
mIoU02 = state["mIoU02"]; latency02 = state["latency02"]; obj02 = objective_acc_lat(mIoU02, latency02)
mIoU12 = state["mIoU12"]; latency12 = state["latency12"]; obj12 = objective_acc_lat(mIoU12, latency12)
if obj02 > obj12: last = [2, 0]
else: last = [2, 1]
lasts.append(last)
model.build_structure(last)
logging.info("net: " + str(model))
for b in last:
if len(config.width_mult_list) > 1:
plot_op(getattr(model, "ops%d"%b), getattr(model, "path%d"%b), width=getattr(model, "widths%d"%b), head_width=config.stem_head_width[idx][1], F_base=config.Fch).savefig(os.path.join(config.save, "ops_%d_%d.png"%(arch_idx,b)), bbox_inches="tight")
else:
plot_op(getattr(model, "ops%d"%b), getattr(model, "path%d"%b), F_base=config.Fch).savefig(os.path.join(config.save, "ops_%d_%d.png"%(arch_idx,b)), bbox_inches="tight")
plot_path_width(model.lasts, model.paths, model.widths).savefig(os.path.join(config.save, "path_width%d.png"%arch_idx))
plot_path_width([2, 1, 0], [model.path2, model.path1, model.path0], [model.widths2, model.widths1, model.widths0]).savefig(os.path.join(config.save, "path_width_all%d.png"%arch_idx))
flops, params = profile(model, inputs=(torch.randn(1, 3, 1024, 2048),))
logging.info("params = %fMB, FLOPs = %fGB", params / 1e6, flops / 1e9)
logging.info("ops:" + str(model.ops))
logging.info("path:" + str(model.paths))
model = model.cuda()
#####################################################
print(config.save)
latency = compute_latency(model, (1, 3, config.image_height, config.image_width))
logging.info("FPS:" + str(1000./latency))
def _flops(h, w, C_in, C_out, kernel_size=3, stride=1, dilation=1, groups=1):
layer = BasicResidual1x(C_in, C_out, kernel_size, stride, dilation, groups, slimmable=False)
flops, params = profile(layer, inputs=(torch.randn(1, C_in, h, w),))
return flops
trainset = FER2013(split = 'Training', transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=opt.train_bs, shuffle=True, num_workers=1)
PrivateTestset = FER2013(split = 'PrivateTest', transform=transform_test)
PrivateTestloader = torch.utils.data.DataLoader(PrivateTestset, batch_size=opt.test_bs, shuffle=False, num_workers=1)
# Model
if opt.model == 'VGG19':
net = VGG('VGG19')
elif opt.model == 'Resnet18':
net = ResNet18()
elif opt.model == 'EdgeCNN':
print ("This is EdgeCNN ")
net = EdgeCNN()
flops, params = profile(net, input_size=(1, 3, 44,44))
print("The FLOS of this model is %0.3f M" % float(flops/1024/1024))
print("The params of this model is %0.3f M" % float(params/1024/1024))
if opt.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isdir(path), 'Error: no checkpoint directory found!'
Private_checkpoint = torch.load(os.path.join(path,'PrivateTest_model.t7'))
best_PrivateTest_acc = Private_checkpoint['best_PrivateTest_acc']
best_PrivateTest_acc_epoch = Private_checkpoint['best_PrivateTest_acc_epoch']
print ('best_PrivateTest_acc is '+ str(best_PrivateTest_acc))
net.load_state_dict(Private_checkpoint['net'], strict=False)
start_epoch = Private_checkpoint['best_PrivateTest_acc_epoch'] + 1
@staticmethod
def _flops(h, w, C_in, C_out, stride=1):
layer = FactorizedReduce(C_in, C_out, stride, slimmable=False)
flops, params = profile(layer, inputs=(torch.randn(1, C_in, h, w),))
return flops
def _flops(h, w, C_in, C_out, kernel_size=3, stride=1, dilation=1, groups=1):
assert stride in [1, 2]
layer = BasicResidual_downup_2x(C_in, C_out, kernel_size, stride, dilation, groups, slimmable=False)
flops, params = profile(layer, inputs=(torch.randn(1, C_in, h, w),))
return flops
dists, angles = collect_error(marking_points, pred_points,
config.CONFID_THRESH_FOR_POINT)
position_errors += dists
direction_errors += angles
logger.log(iter=iter_idx, total_loss=total_loss)
precisions, recalls = util.calc_precision_recall(
ground_truths_list, predictions_list, match_marking_points)
average_precision = util.calc_average_precision(precisions, recalls)
if args.enable_visdom:
logger.plot_curve(precisions, recalls)
sample = torch.randn(1, 3, config.INPUT_IMAGE_SIZE,
config.INPUT_IMAGE_SIZE)
flops, params = profile(dp_detector, inputs=(sample.to(device), ))
logger.log(average_loss=total_loss / len(psdataset),
average_precision=average_precision,
flops=flops,
params=params)
shape = None
if config["dataset"] in ["Cifar10", "Cifar100"]:
shape = (1, 3, 32, 32)
else:
print(f"Unknown dataset {config['dataset']} input size to compute # FLOPS")
return
try:
from thop import profile
except:
print("Please `pip install thop` to compute # FLOPS")
return
model = model.train()
input_data = torch.rand(*shape)
num_flops, num_params = profile(model, inputs=(input_data, ))
print("Number of FLOPS:", human_format(num_flops))
x = self.mobilenet0_conv25(x)
x26 = self.mobilenet0_conv26(x)
result_[1]=x10
result_[2]=x22
result_[3]=x26
return result_
if __name__ == "__main__":
from thop import profile
net = mobileV1()
torch.save(net.state_dict(),'a.ttt')
from thop import profile
from thop import clever_format
# x = torch.randn(1,3,320,320)
input = torch.randn(1, 3, 224, 224)
flops, params = profile(net, inputs=(input, ))
flops, params = clever_format([flops, params], "%.3f")
print(params)
print(flops)