def __init__(self, nclass, backbone, aux, se_loss, dilated=True, norm_layer=None,
base_size=576, crop_size=608, mean=[.485, .456, .406],
std=[.229, .224, .225], root='./pretrain_models',
multi_grid=False, multi_dilation=None):
super(BaseNet, self).__init__()
self.nclass = nclass
self.aux = aux
self.se_loss = se_loss
self.mean = mean
self.std = std
self.base_size = base_size
self.crop_size = crop_size
# copying modules from pretrained models
if backbone == 'resnet50':
self.pretrained = resnet.resnet50(pretrained=False, dilated=dilated,
norm_layer=norm_layer, root=root,
multi_grid=multi_grid, multi_dilation=multi_dilation)
elif backbone == 'resnet101':
self.pretrained = resnet.resnet101(pretrained=True, dilated=dilated,
norm_layer=norm_layer, root=root,
multi_grid=multi_grid,multi_dilation=multi_dilation)
elif backbone == 'resnet152':
self.pretrained = resnet.resnet152(pretrained=True, dilated=dilated,
norm_layer=norm_layer, root=root,
multi_grid=multi_grid, multi_dilation=multi_dilation)
else:
raise RuntimeError('unknown backbone: {}'.format(backbone))
# bilinear upsample options
self._up_kwargs = up_kwargs
def __init__(self, model_name='resnet', classes_number=20, is_train=False):
"""
:param model_name: pre-train model name. a str
:param classes_number: number of classes. a int
"""
super(Classifier, self).__init__()
self.model_name = model_name
self.is_train = is_train
if model_name == 'resnet':
self.feature_net = resnet101(pretrained=is_train)
elif model_name == 'mobilenet':
net = MobileNetV2(n_class=1000)
if is_train:
state_dict = torch.load('./models/mobilenet_v2.pth.tar') # add map_location='cpu' if no gpu
net.load_state_dict(state_dict)
self.feature_net = net.features
else:
print('Error: wrong model name.')
exit()
if model_name == 'mobilenet':
self.avgpool = torch.nn.AdaptiveAvgPool2d((1, 1))
self.drop_out = torch.nn.Dropout(0.5)
self.fc = torch.nn.Linear(1280, classes_number)
else:
self.drop_out = torch.nn.Dropout(0.5)
self.fc = torch.nn.Linear(2048, classes_number)
self.fc.weight.data.normal_(0, 0.1)
def deeplabv3_resnet101(pretrained=False, progress=True,
num_classes=21, aux_loss=None, **kwargs):
backbone = resnet101(pretrained=True, replace_stride_with_dilation=[False, True, True])
return_layers = {'layer4': 'out'}
#if aux_loss:
# return_layers['layer3'] = 'aux'
backbone = IntermediateLayerGetter(backbone, return_layers=return_layers)
aux_classifier = None
#if aux_loss:
# inplanes = 1024
# aux_classifier = FCNHead(inplanes, num_classes)
model_map = {
'deeplabv3': (DeepLabHead, DeepLabV3)
}
inplanes = 2048
classifier = model_map["deeplabv3"][0](inplanes, num_classes)
base_model = model_map["deeplabv3"][1]
model = base_model(backbone, classifier, aux_classifier)
return model
def __init__(self,
nclass,
backbone,
aux,
se_loss,
dilated=True,
norm_layer=None,
base_size=576,
crop_size=608,
mean=[.485, .456, .406],
std=[.229, .224, .225],
root='./pretrain_models',
multi_grid=False,
multi_dilation=None):
super(BaseNet, self).__init__()
self.nclass = nclass
self.aux = aux
self.se_loss = se_loss
self.mean = mean
self.std = std
self.base_size = base_size
self.crop_size = crop_size
# copying modules from pretrained models
self.pretrained = resnet101(pretrained=True,
dilated=dilated,
norm_layer=norm_layer,
root=root,
multi_grid=multi_grid,
multi_dilation=multi_dilation)
def __init__(self, nclass, backbone):
super(DeepTen, self).__init__()
self.backbone = backbone
# copying modules from pretrained models
if self.backbone == 'resnet50':
self.pretrained = resnet50(pretrained=True, dilated=False)
elif self.backbone == 'resnet101':
self.pretrained = resnet101(pretrained=True, dilated=False)
elif self.backbone == 'resnet152':
self.pretrained = resnet152(pretrained=True, dilated=False)
else:
raise RuntimeError('unknown backbone: {}'.format(self.backbone))
self.scalenum = 4
n_codes = 32
self.fc = nn.Sequential(
Normalize(),
nn.Linear(64 * 64, 128),
)
self.classifier = nn.Sequential(Normalize(),
nn.Linear(128 * self.scalenum, nclass))
self.head1 = self.make_layer_head_customize(256, n_codes, 56)
self.head2 = self.make_layer_head_customize(512, n_codes, 28)
self.head3 = self.make_layer_head_customize(1024, n_codes, 14)
self.head4 = self.make_layer_head_customize(2048, n_codes, 7)
self.pool1 = self.make_layer_pooling_customize(256, 56)
self.pool2 = self.make_layer_pooling_customize(512, 28)
self.pool3 = self.make_layer_pooling_customize(1024, 14)
self.pool4 = self.make_layer_pooling_customize(2048, 7)
def __init__(
self,
last_conv_stride=1,
last_conv_dilation=1,
num_stripes=6,
local_conv_out_channels=256,
num_classes=0
):
super(PCBModel, self).__init__()
self.base = resnet101(
pretrained=False,
last_conv_stride=last_conv_stride,
last_conv_dilation=last_conv_dilation)
self.num_stripes = num_stripes
print (self.base)
self.local_conv_list = nn.ModuleList()
for _ in range(num_stripes):
self.local_conv_list.append(nn.Sequential(
nn.Conv2d(4096, local_conv_out_channels, 1),
nn.BatchNorm2d(local_conv_out_channels),
#nn.ReLU(inplace=True)
))
if num_classes > 0:
self.fc_list = nn.ModuleList()
for _ in range(num_stripes):
fc = nn.Linear(local_conv_out_channels, num_classes)
init.normal(fc.weight, std=0.001)
init.constant(fc.bias, 0)
self.fc_list.append(fc)
def get_model(model_name, pho_size=299, num_classes=110):
if model_name == "vgg16":
model = VGG(num_classes=num_classes, pho_size=299)
elif model_name == "resnet101":
model = resnet101(num_classes=num_classes)
elif model_name == "densenet":
model = DenseNet(growth_rate=12,
block_config=[(100 - 4) // 6 for _ in range(3)],
num_classes=num_classes,
small_inputs=False,
efficient=True,
pho_size=pho_size)
elif model_name == "InceptionResNetV2":
model = InceptionResNetV2(num_classes=num_classes)
elif model_name == "InceptionV4":
model = InceptionV4(num_classes=num_classes)
elif model_name == "Inception3":
model = Inception3(num_classes=num_classes)
elif model_name == "denoise":
model = get_denoise()
elif model_name == "Mymodel":
model = Mymodel()
elif model_name == 'Comdefend':
model = ComDefend()
elif model_name == 'Rectifi':
model = Rectifi()
return model
def __init__(self, backbone=resnet101(pretrained=True)):
super(FPN, self).__init__()
self.backbone = backbone
self.conv6 = nn.Conv2d(2048, 256, kernel_size=3, stride=2, padding=1)
self.conv7 = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1)
self.latlayer1 = nn.Conv2d(2048,
256,
kernel_size=1,
stride=1,
padding=0)
self.latlayer2 = nn.Conv2d(1024,
256,
kernel_size=1,
stride=1,
padding=0)
self.latlayer3 = nn.Conv2d(512,
256,
kernel_size=1,
stride=1,
padding=0)
self.toplayer1 = nn.Conv2d(256,
256,
kernel_size=3,
stride=1,
padding=1)
self.toplayer2 = nn.Conv2d(256,
256,
kernel_size=3,
stride=1,
padding=1)
def __init__(self, n_classes=19):
super(DeepLabV3Plus, self).__init__()
self.out_channels = 256
self.backbone = resnet101(
pretrained=True,
replace_stride_with_dilation=[False, False, False])
self.stem = nn.Sequential(*list(self.backbone.children())[:4])
self.block1 = self.backbone.layer1
self.block2 = self.backbone.layer2
self.block3 = self.backbone.layer3
self.block4 = self.backbone.layer4
self.low_level_features_in_channels = 256
self.low_level_features_out_channels = 48
self.low_level_features_conv = ConvBlock(
self.low_level_features_in_channels,
self.low_level_features_out_channels,
kernel_size=1)
self.aspp = AtrousSpatialPyramidPooling(2048, self.out_channels)
self.decoder = nn.Sequential(
ConvBlock(self.low_level_features_out_channels + self.out_channels,
self.out_channels,
kernel_size=3),
nn.Dropout(0.5),
ConvBlock(self.out_channels, self.out_channels, kernel_size=3),
nn.Dropout(0.1),
nn.Conv2d(self.out_channels, n_classes, kernel_size=1),
)
def build_net(phase, size=321, num_classes=21):
if phase != "test" and phase != "train":
print("ERROR: Phase: " + phase + " not recognized")
return
base_, head_ = multibox(resnet101(), mbox[str(size)], num_classes)
extras_ = add_extras(base_, size=size)
return ACD(phase, size, base_, extras_, head_, num_classes)
def main():
net_path = 'logs/modelnet/modelnet_int_norm'
dump_path = 'output_data/modelnet_errors'
dataset_location = 'datasets' # TODO update to dataset path
device = torch.device('cpu')
dataset = ModelNetSo3.ModelNetSo3(dataset_location)
dataset_eval = dataset.get_eval()
base = resnet101()
model = ResnetHead(base, 10, 32, 512, 9)
loggers = logger.Logger(net_path, ModelNetSo3.ModelNetSo3, load=True)
loggers.load_network_weights(49, model, device)
model.eval()
if not os.path.exists(dump_path):
os.makedirs(dump_path)
idx = np.arange(len(dataset_eval))
sampler = ListSampler(idx)
dataloader = torch.utils.data.DataLoader(dataset_eval,
sampler=sampler,
batch_size=32,
drop_last=False)
stats = logger.SubsetLogger(
None, None, 0, False
) # not intended use, need to look over how to set up logger differently
i = 0
for batch in tqdm.tqdm(dataloader):
# if i > 1:
# break
i += 1
image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch
image = image.to(device)
R = extrinsic[:, :3, :3].to(device)
R = R.clone()
class_idx = class_idx_cpu.to(device)
out = model(image, class_idx)
losses, Rest = loss_func(out, R)
loss = torch.mean(losses)
stats.add_samples(image, losses, out.view(-1, 3, 3), R, Rest,
class_idx_cpu, hard)
easy_stats, hard_stats = get_errors(stats.angular_errors,
stats.class_indices, stats.hard,
ModelNetSo3.ModelNetSo3Classes)
per_class = easy_stats[1]
for k, v in per_class.items():
savefile = os.path.join(dump_path, '{}.txt'.format(k))
all_errors = v[4]
with open(savefile, 'w') as f:
for e in all_errors:
f.write('{}\n'.format(e))
with open(os.path.join(dump_path, 'all.pkl'), 'wb') as f:
pickle.dump(easy_stats, f)
errs = per_class['bathtub'][4]
plt.hist(errs, 100)
plt.show()
def visualize_random_errors():
net_path = 'logs/pascal/pascal_new_norm_full'
image_dir_out = 'plots/random_errors'
dataset_location = 'datasets' # TODO update with dataset path
device = torch.device('cpu')
dataset = Pascal3D.Pascal3D(train_all=True)
dataset_vis = dataset.get_eval()
base = resnet101()
model = ResnetHead(base, 13, 32, 512, 9)
loggers = logger.Logger(net_path, Pascal3D.PascalClasses, load=True)
loggers.load_network_weights(119, model, device)
model.eval()
if not os.path.exists(image_dir_out):
os.makedirs(image_dir_out)
np.random.seed(9001)
idx = np.arange(len(dataset_vis))
np.random.shuffle(idx)
sampler = ListSampler(idx)
dataloader = torch.utils.data.DataLoader(dataset_vis,
sampler=sampler,
batch_size=1,
drop_last=False)
fig, axs = plt.subplots(3, 4, figsize=(10, 7.5), dpi=100 * 4)
for i, batch in enumerate(dataloader):
if i == 12:
break
ax = axs[i // 4][i % 4]
image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch
extrinsic_np = extrinsic[0].numpy()
intrinsic_np = intrinsic[0].numpy()
im_np = image[0].numpy().transpose(1, 2, 0)
R_gt = extrinsic[0, :3, :3].numpy()
out = model(image, class_idx_cpu).view(-1, 3, 3)
R_est = loss.batch_torch_A_to_R(out).detach().cpu().view(3, 3).numpy()
err = loss.angle_error_np(R_gt, R_est)
extr_est = np.copy(extrinsic_np)
extr_est[:3, :3] = R_est
points_est = proj_axis(extr_est, intrinsic_np)
points_true = proj_axis(extrinsic_np, intrinsic_np)
ax.imshow(im_np)
for p, c in zip(points_est[:, 1:].transpose(), ['r', 'g', 'b']):
x = [points_est[0, 0], p[0]]
y = [points_est[1, 0], p[1]]
ax.plot(x, y, c, linewidth=5)
for p, c in zip(points_true[:, 1:].transpose(), ['m', 'y', 'c']):
x = [points_true[0, 0], p[0]]
y = [points_true[1, 0], p[1]]
ax.plot(x, y, c, linewidth=2)
ax.title.set_text("error: {:3.2f}".format(err))
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
image_out = os.path.join(image_dir_out, 'im_errors.pdf')
plt.savefig(image_out)
def main():
"""Sample main function"""
model = resnet101(pretrained=True)
model.eval()
ori_top1, ori_top5 = model_forward(model, batch_size=32, iterations=5)
# Quantize configurations
args_shape = [(1, 3, 224, 224)]
input_data = tuple([torch.randn(arg_shape) for arg_shape in args_shape]) # pylint: disable=E1101
if torch.cuda.is_available():
input_data = tuple([data.to('cuda') for data in input_data])
model.to('cuda')
config_json_file = os.path.join(TMP, 'config.json')
skip_layers = []
batch_num = 2
amct.create_quant_config(config_json_file, model, input_data, skip_layers,
batch_num)
# Phase1: do conv+bn fusion, weights calibration and generate
# calibration model
record_file = os.path.join(TMP, 'record.txt')
modified_model = os.path.join(TMP, 'modified_model.onnx')
calibration_model = amct.quantize_model(config_json_file,
modified_model,
record_file,
model,
input_data,
input_names=['input'],
output_names=['output'],
dynamic_axes={
'input': {
0: 'batch_size'
},
'output': {
0: 'batch_size'
}
})
# Phase2: do calibration
model_forward(calibration_model, batch_size=32, iterations=batch_num)
if torch.cuda.is_available():
torch.cuda.empty_cache()
# Phase3: save final model, one for onnx do fake quant test, one
# deploy model for ATC
result_path = os.path.join(OUTPUTS, 'resnet-101')
amct.save_model(modified_model, record_file, result_path)
# Phase4: run fake_quant model test
quant_top1, quant_top5 = onnx_forward(
'%s_%s' % (result_path, 'fake_quant_model.onnx'),
batch_size=32,
iterations=5)
print('[INFO] ResNet101 before quantize top1:{:>10} top5:{:>10}'.format(
ori_top1, ori_top5))
print('[INFO] ResNet101 after quantize top1:{:>10} top5:{:>10}'.format(
quant_top1, quant_top5))
def init_net(self):
net_args = {
"pretrained": True,
"n_input_channels": len(self.kwargs["static"]["imagery_bands"])
}
# https://pytorch.org/docs/stable/torchvision/models.html
if self.kwargs["net"] == "resnet18":
self.model = resnet.resnet18(**net_args)
elif self.kwargs["net"] == "resnet34":
self.model = resnet.resnet34(**net_args)
elif self.kwargs["net"] == "resnet50":
self.model = resnet.resnet50(**net_args)
elif self.kwargs["net"] == "resnet101":
self.model = resnet.resnet101(**net_args)
elif self.kwargs["net"] == "resnet152":
self.model = resnet.resnet152(**net_args)
elif self.kwargs["net"] == "vgg11":
self.model = vgg.vgg11(**net_args)
elif self.kwargs["net"] == "vgg11_bn":
self.model = vgg.vgg11_bn(**net_args)
elif self.kwargs["net"] == "vgg13":
self.model = vgg.vgg13(**net_args)
elif self.kwargs["net"] == "vgg13_bn":
self.model = vgg.vgg13_bn(**net_args)
elif self.kwargs["net"] == "vgg16":
self.model = vgg.vgg16(**net_args)
elif self.kwargs["net"] == "vgg16_bn":
self.model = vgg.vgg16_bn(**net_args)
elif self.kwargs["net"] == "vgg19":
self.model = vgg.vgg19(**net_args)
elif self.kwargs["net"] == "vgg19_bn":
self.model = vgg.vgg19_bn(**net_args)
else:
raise ValueError("Invalid network specified: {}".format(
self.kwargs["net"]))
# run type: 1 = fine tune, 2 = fixed feature extractor
# - replace run type option with "# of layers to fine tune"
if self.kwargs["run_type"] == 2:
layer_count = len(list(self.model.parameters()))
for layer, param in enumerate(self.model.parameters()):
if layer <= layer_count - 5:
param.requires_grad = False
# Parameters of newly constructed modules have requires_grad=True by default
# get existing number for input features
# set new number for output features to number of categories being classified
# see: https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html
if "resnet" in self.kwargs["net"]:
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, self.ncats)
elif "vgg" in self.kwargs["net"]:
num_ftrs = self.model.classifier[6].in_features
self.model.classifier[6] = nn.Linear(num_ftrs, self.ncats)
def __init__(self, num_class = 9, input_channel = 3, output_stride=16, layer=101):
super(resnet_backbone, self).__init__()
if layer == 101:
self.resnet = resnet101(pretrained=True, output_stride=output_stride)
elif layer == 152:
self.resnet = resnet152(pretrained=True, output_stride=output_stride)
self.conv1 = self.resnet.conv1
def build_model(self):
print('==> Build model and setup loss and optimizer')
#build model
self.model = resnet101(pretrained= True, channel=self.channel).cuda()
#print self.model
#Loss function and optimizer
self.criterion = nn.CrossEntropyLoss().cuda()
self.optimizer = torch.optim.SGD(self.model.parameters(), self.lr, momentum=0.9)
self.scheduler = ReduceLROnPlateau(self.optimizer, 'min', patience=1,verbose=True)
def main_worker(gpu_index, gpu_num, args):
"""main_worker"""
# Phase initialization.
# If multi-card distributed training is used, initialize the training
# process.
if args.distributed:
dist.init_process_group(backend='nccl',
init_method=args.dist_url,
world_size=gpu_num,
rank=gpu_index)
# Generate training dataset and validation dataset loader.
train_loader, train_sampler, val_loader = create_data_loader(
args.train_set, args.eval_set, args)
# Phase origin model accuracy.
# Step 1: Create model.
print("=> Create pre-trained model 'resnet101'")
# Choose whether to use the model downloaded online or
# the model modified locally.
# 1. use the resnet101 model downloaded online.
model = models.__dict__['resnet101'](pretrained=True)
# 2. use the resnet101 model modified locally.
model = resnet101(pretrained=True)
# Step 2: Calculate origin model's accuracy.
ori_top1, ori_top5 = cal_original_model_accuracy(model, gpu_index,
val_loader, args)
# Phase retrain the model.
# Step 3: Generate the retraining model in default graph and create the
# quantization factor record_file.
print('==> AMCT step2: create_quant_retrain_model..')
record_file = os.path.join(TMP, 'record.txt')
model = amct.create_compressed_retrain_model(
model, get_input_data([(1, 3, SIZE, SIZE)], model),
args.config_defination, record_file)
# Step 4: Retraining compressed model and inferencing.
train_and_val(model, gpu_index, train_loader, train_sampler, val_loader,
args)
# Step 5: Save the compressed model and infer the accuracy of the
# compressed model.
if not args.distributed or (args.distributed and gpu_index == 0):
quant_top1, quant_top5 = cal_quant_model_accuracy(
model, gpu_index, val_loader, args, record_file)
print(
'[INFO] ResNet-101 before compress retrain top1:{:.2f}% top5:{:.2f}%'
.format(ori_top1, ori_top5))
print(
'[INFO] ResNet-101 after compress retrain top1:{:.2f}% top5:{:.2f}%'
.format(quant_top1, quant_top5))
def __init__(self, *args, **kwargs):
super(ContextPath, self).__init__()
self.resnet = resnet101(pretrained=False)
self.arm16 = AttentionRefinementModule(1024, 128) #256 1024
self.arm32 = AttentionRefinementModule(2048, 128) # 512 2048
self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
self.conv_avg = ConvBNReLU(2048, 128, ks=1, stride=1,
padding=0) #512 2048
self.init_weight()
def Generator(net):
if net == 'lenet':
return lenet.Feature()
if net == 'resnet18':
return resnet.resnet18(pretrained=True)
if net == 'resnet50':
return resnet.resnet50(pretrained=True)
if net == 'resnet101':
return resnet.resnet101(pretrained=True)
if net == 'alexnet':
return alexnet.alexnet(pretrained=True)
def build_model(model_name, pretrained=False):
if model_name == 'resnet34':
model = resnet.resnet34(pretrained=False)
elif model_name == 'resnet50':
model = resnet.resnet50(pretrained=False)
elif model_name == 'resnet101':
model = resnet.resnet101(pretrained=False)
elif model_name == 'resnet152':
model = resnet.resnet152(pretrained=False)
if model_name == 'resnet18':
model.conv1 = nn.Conv2d(2,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
model.avg_pool = nn.AdaptiveAvgPool2d(1)
model.last_linear = nn.Linear(512, 8)
elif model_name == 'resnet34':
model.conv1 = nn.Conv2d(2,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
model.avgpool = nn.AdaptiveAvgPool2d(1)
model.fc = nn.Linear(512, 8) # Nx8
else:
model.conv1 = nn.Conv2d(2,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
model.avgpool = nn.AdaptiveAvgPool2d(1)
model.fc = nn.Linear(2048, 8) # Nx8
if pretrained == True:
exclude_dict = ['conv1.weight', 'fc.weight', 'fc.bias']
pretrained_dict = model_zoo.load_url(model_urls[model_name])
model_dict = model.state_dict()
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k not in exclude_dict
}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
return model
def visualize_probs():
net_path = 'logs/upna/upna_int_norm'
image_dir_out = 'plots/probs'
dataset_location = 'datasets' # TODO update to dataset path
device = torch.device('cpu')
dataset = UPNA.UPNA(dataset_location)
dataset_vis = dataset.get_eval()
base = resnet101()
model = ResnetHead(base, 1, 0, 512, 9)
loggers = logger.Logger(net_path, ModelNetSo3.ModelNetSo3Classes, load=True)
loggers.load_network_weights(119, model, device)
model.eval()
if not os.path.exists(image_dir_out):
os.makedirs(image_dir_out)
np.random.seed(29001)
idx = np.arange(len(dataset_vis))
np.random.shuffle(idx)
# idx = [2822, 8446, 6171, 3479]
sampler = ListSampler(idx)
dataloader = torch.utils.data.DataLoader(
dataset_vis,
sampler=sampler,
batch_size=1,
drop_last=False)
errors = []
load_pkl = False
if load_pkl and os.path.exists('UPNA_errors.pkl'):
with open('UPNA_errors.pkl', 'rb') as f:
errors = pickle.load(f)
else:
print(len(dataloader))
for i, (idx, batch) in enumerate(zip(idx, dataloader)):
print(i)
image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch
extrinsic_np = extrinsic[0].numpy()
intrinsic_np = intrinsic[0].numpy()
im_np = image[0].numpy().transpose(1,2,0)
R_gt = extrinsic[0, :3,:3].numpy()
out = model(image, class_idx_cpu).view(-1,3,3)
R_est = loss.batch_torch_A_to_R(out).detach().cpu().view(3,3).numpy()
err = loss.angle_error_np(R_gt, R_est)
errors.append(err)
print(err)
with open('UPNA_errors.pkl', 'wb') as f:
pickle.dump(errors, f)
print(np.mean(errors))
print(np.median(errors))
plt.hist(errors,100)
plt.show()
def __init__(self, num_classes=3):
super(pair_cnn, self).__init__()
#self.resnet101_union = resnet.resnet101()
self.resnet101_a = resnet.resnet101()
#self.resnet101_b = self.resnet101_a
#self.bboxes = nn.Linear(10, 256)
self.fc6 = nn.Linear(2048 + 2048, 4096)
self.fc7 = nn.Linear(4096, num_classes)
self.ReLU = nn.ReLU(False)
self.Dropout = nn.Dropout()
self._initialize_weights()
def __init__(self, class_num, bn_momentum=0.01, pretrained=False):
super(PSPNet, self).__init__()
self.pool_scales = [1, 2, 3, 6]
self.fc_dim = 2048
resnet101 = resnet.resnet101(pretrained=pretrained)
self.backbone = nn.Sequential(*list(resnet101.children())[:-2])
self.psp_layer = PyramidPooling('psp', out_planes=class_num, fc_dim=self.fc_dim,
pool_scales=self.pool_scales, norm_layer=nn.BatchNorm2d)
self.cls_head = nn.Sequential(
ConvBnRelu(self.fc_dim + len(self.pool_scales) * 512, 512, size=3, stride=1, pad=1,
has_bn=True, has_relu=True, has_bias=False, norm_layer=nn.BatchNorm2d),
nn.Dropout2d(0.1, inplace=False),
nn.Conv2d(512, class_num, kernel_size=1)
)
def __init__(self, k=7, classes=None, debug=False, training=False):
super(FasterRCNN, self).__init__()
if classes is not None:
self.classes = classes
self.n_classes = len(classes)
self.k = k
self.training = training
self.resnet = resnet101()
self.rpn = RPN()
self.conv_new_1 = Conv2d(in_channels=2048,
out_channels=1024,
kernel_size=1,
stride=1,
relu=True)
self.rfcn_cls = nn.Conv2d(in_channels=1024,
out_channels=self.n_classes * self.k *
self.k,
kernel_size=1,
stride=1,
padding=0,
bias=False)
self.rfcn_bbox = nn.Conv2d(in_channels=1024,
out_channels=8 * self.k * self.k,
kernel_size=1,
stride=1,
padding=0,
bias=False) #--class-agnostic
self.psroipooling_cls = PSRoIPool(pooled_height=self.k,
pooled_width=self.k,
spatial_scale=1 / 32.0,
group_size=self.k,
output_dim=self.n_classes)
self.psroipooling_loc = PSRoIPool(pooled_height=self.k,
pooled_width=self.k,
spatial_scale=1 / 32.0,
group_size=self.k,
output_dim=2 *
4) #----class-agnostic
self.pooling = nn.AvgPool2d(kernel_size=self.k, stride=self.k)
# loss
self.cross_entropy = None
self.loss_box = None
# for log
self.debug = debug
def main():
# [b, 32, 32, 3] => [b, 1, 1, 512]
model = resnet101()
model.build(input_shape=(None, 32, 32, 3))
model.summary()
optimizer = optimizers.Adam(lr=1e-3)
for epoch in range(50):
for step, (x,y) in enumerate(train_db):
with tf.GradientTape() as tape:
# [b, 32, 32, 3] => [b, 100]
logits = model(x)
# [b] => [b, 100]
y_onehot = tf.one_hot(y, depth=100)
# compute loss
loss = tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True)
loss = tf.reduce_mean(loss)
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
if step %50 == 0:
print(epoch, step, 'loss:', float(loss))
total_num = 0
total_correct = 0
for x,y in test_db:
logits = model(x)
prob = tf.nn.softmax(logits, axis=1)
pred = tf.argmax(prob, axis=1)
pred = tf.cast(pred, dtype=tf.int32)
correct = tf.cast(tf.equal(pred, y), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_num += x.shape[0]
total_correct += int(correct)
acc = total_correct / total_num
print(epoch, 'acc:', acc)
def __init__(self, num_classes=1000):
super(Resnet101_8s, self).__init__()
# Load the pretrained weights, remove avg pool
# layer and get the output stride of 8
resnet101_8s = resnet.resnet101(fully_conv=True,
pretrained=True,
output_stride=8,
remove_avg_pool_layer=True)
# Randomly initialize the 1x1 Conv scoring layer
resnet101_8s.fc = nn.Conv2d(resnet101_8s.inplanes, num_classes, 1)
self.resnet101_8s = resnet101_8s
self._normal_initialization(self.resnet101_8s.fc)
def main(opt):
# モデル定義
model = resnet.resnet101(pretrained=True)
if torch.cuda.is_available(): # GPUが利用可能か確認
device = 'cuda'
else:
device = 'cpu'
print('device is {0}'.format(device))
# print(model.weight.type)
model.to(device)
if opt.trained:
print('load pretrained model')
model.fc = nn.Linear(2048, opt.ftclass)
model_data = torch.load(opt.model)
model.load_state_dict(model_data)
model.eval()
# 絶対パスに変換
outpath = os.path.abspath(opt.output)
apath = os.path.abspath(opt.input)
video_names = sorted(glob.glob(os.path.join(apath, '*')))
if os.path.exists('tmp'):
subprocess.call('rm -rf tmp', shell=True)
for vpath in video_names:
vname = os.path.splitext(os.path.basename(vpath))[0]
subprocess.call('mkdir tmp', shell=True)
subprocess.call(
'ffmpeg -loglevel warning -i {} -r 5 tmp/image_%05d.jpg'.format(
vpath),
shell=True)
images = sorted(glob.glob('tmp/*.jpg'))
print('extract {}\'s DeepFeatrue'.format(vname))
outputs = input_image(images, model)
# ファイルに保存
if not os.path.exists(outpath):
subprocess.call('mkdir {}'.format(outpath), shell=True)
savename = os.path.join(outpath, vname + '.npy')
np.save(savename, outputs)
subprocess.call('rm -rf tmp', shell=True)
def __init__(self, num_classes, deep_base=True):
super(Baseline, self).__init__()
resnet = resnet101(pretrained=False,
deep_base=deep_base,
norm_layer=norm_layer)
if deep_base:
resnet.load_state_dict(torch.load(res101_csail_path))
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu1,
resnet.conv2, resnet.bn2, resnet.relu2,
resnet.conv3, resnet.bn3, resnet.relu3,
resnet.maxpool)
else:
resnet.load_state_dict(torch.load(res101_path))
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
self.layer1 = resnet.layer1
self.layer2 = resnet.layer2
self.layer3 = resnet.layer3
self.layer4 = resnet.layer4
self.m1_3 = Module1(2048, 1024)
self.m1_2 = Module1(1024, 512)
self.m1_1 = Module1(512, 256)
self.m2_4 = Module2(2048, 128, (5, 7, 9))
self.m2_3 = Module2(1024, 128, (10, 14, 18))
self.m2_2 = Module2(512, 128, (20, 28, 36))
self.m2_1 = Module2(256, 128, (40, 56, 72))
self.decoder4 = DecoderBlock(128, 128)
self.decoder3 = DecoderBlock(128, 128)
self.decoder2 = DecoderBlock(128, 128)
self.decoder1 = DecoderBlock(128, 128)
self.pred = nn.Sequential(
nn.ConvTranspose2d(128, 32, 4, 2, 1), relu,
nn.Conv2d(32, 32, kernel_size=3, padding=1), relu,
nn.Conv2d(32, num_classes, kernel_size=3, padding=1))
self.aux1 = nn.Conv2d(128, num_classes, kernel_size=1)
self.aux2 = nn.Conv2d(128, num_classes, kernel_size=1)
self.aux3 = nn.Conv2d(128, num_classes, kernel_size=1)
self.aux4 = nn.Conv2d(128, num_classes, kernel_size=1)
def __init__(self,
n_class=21, # include background
roi_pooling_size=7):
super(RCNN, self).__init__()
self.n_class = n_class
self.feature_stride = 16.0
self.roi_pooling_szie = roi_pooling_size
"""
self.classifier = nn.Sequential(
nn.Linear(1024 * 7 * 7, 1024),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(1024, 2048),
nn.ReLU(True),
nn.Dropout(),
)
for m in self.classifier.modules():
if isinstance(m, (nn.Conv2d, nn.Linear)):
nn.init.xavier_uniform_(m.weight)
"""
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters(): p.requires_grad = False
resnet = resnet101(pretrained=True)
self.rcnn_top = nn.Sequential(resnet.layer4)
#self.rcnn_top = nn.Sequential(resnet101().layer4)
#self.rcnn_top.apply(set_bn_fix)
self.roi_pooling = RoIPooling2D(self.roi_pooling_szie, self.roi_pooling_szie, 1. / self.feature_stride)
self.cls_loc = nn.Linear(2048, self.n_class * 4)
self.cls_score = nn.Linear(2048, self.n_class)
"""
normal_init(self.cls_loc, 0, 0.001)
normal_init(self.cls_score, 0, 0.01)
"""
xavier_init(self.cls_loc)
xavier_init(self.cls_score)
def __init__(
self,
last_conv_stride=1,
last_conv_dilation=1,
num_stripes=6, # number of sub-parts
used_levels=[1, 1, 1, 1, 1, 1],
num_conv_out_channels=128,
global_conv_out_channels=256,
num_classes=0
):
super(Pyramid, self).__init__()
print("num_stripes:{}".format(num_stripes))
print("num_conv_out_channels:{},".format(num_conv_out_channels))
self.base = resnet101(
pretrained=True,
last_conv_stride=last_conv_stride,
last_conv_dilation=last_conv_dilation)
self.dropout_layer = nn.Dropout(p=0.2)
# ============================================================================== pyramid
self.num_classes = num_classes
self.num_stripes = num_stripes
self.used_levels = used_levels
# ==============================================================================pyramid
input_size = 2048
self.pyramid_conv_list0 = nn.ModuleList()
self.pyramid_fc_list0 = nn.ModuleList()
Pyramid.register_basic_branch(self, num_conv_out_channels,
input_size,
self.pyramid_conv_list0,
self.pyramid_fc_list0)
# ==============================================================================pyramid
input_size1 = 1024
self.pyramid_conv_list1 = nn.ModuleList()
self.pyramid_fc_list1 = nn.ModuleList()
Pyramid.register_basic_branch(self, num_conv_out_channels,
input_size1,
self.pyramid_conv_list1,
self.pyramid_fc_list1)
