def __init__(self,
layers=50,
bins=(1, 2, 3, 6),
dropout=0.1,
classes=2,
zoom_factor=8,
use_ppm=True,
criterion=nn.CrossEntropyLoss(ignore_index=255),
pretrained=True):
super(PSPNet, self).__init__()
assert layers in [50, 101, 152]
assert 2048 % len(bins) == 0
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
self.use_ppm = use_ppm
self.criterion = criterion
if layers == 50:
resnet = models.resnet50(pretrained=pretrained)
elif layers == 101:
resnet = models.resnet101(pretrained=pretrained)
else:
resnet = models.resnet152(pretrained=pretrained)
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
fea_dim = 2048
if use_ppm:
self.ppm = PPM(fea_dim, int(fea_dim / len(bins)), bins)
fea_dim *= 2
self.cls = nn.Sequential(
nn.Conv2d(fea_dim, 512, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(512), nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout), nn.Conv2d(512, classes, kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(1024, 256, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(256), nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout), nn.Conv2d(256, classes,
kernel_size=1))
def __init__(self, num_classes, last_stride=2, bn_neck=False):
"""
:param num_classes:
:param last_stride: set to 1 (trick from Luo et al., 2019 Bag of Tricks...)
:param bn_neck: BNNeck (trick from Luo et al., 2019 Bag of Tricks...)
"""
super().__init__()
self.bn_neck = bn_neck
self.model = resnet50(pretrained=True,
num_classes=num_classes,
last_stride=last_stride,
bn_neck=bn_neck)
def __init__(self, input_channel=3, num_classes=2, n_segment=5, pretrained=False):
super(TSM, self).__init__()
self.model = resnet50(pretrained=pretrained, n_segment=n_segment, input_channel=input_channel)
# make_non_local(self.model, n_segment=5)
self.model.fc = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(2048, num_classes),
)
self.divsegment = DivSegment(num_classes=num_classes, n_segment=n_segment)
self.consensus = SegmentConsensus(consensus_type='avg')
def __init__(self, n_class, pretrained=True):
super(MA_quality_check_res50, self).__init__()
self.base = resnet.resnet50(pretrained=pretrained)
self.num_att = n_class
# print ((self.base))
# exit()
self.classifier = nn.Linear(2048, self.num_att)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
def __init__(self,
device,
dataloader,
backbone,
head,
log_dir,
model_dir,
batch_size,
embedding_size=512):
self.step = 0
self.device = device
self.batch_size = batch_size
self.embedding_size = embedding_size
self.train_loader, self.class_num = dataloader.get_loader()
self.model_dir = model_dir
self.log_dir = log_dir
print('class number: ', self.class_num)
if backbone == 'vgg':
self.backbone = vgg19().to(self.device)
self.margin = 5
elif backbone == 'resnet':
self.backbone = resnet50().to(self.device)
self.margin = 10
self.head = ArcMarginProduct(embedding_size, self.class_num,
self.margin).to(self.device)
print('backbone: ', backbone, 'margin: ', self.margin)
self.optimizer = optim.SGD([{
'params': self.backbone.parameters()
}, {
'params': self.head.parameters()
}],
weight_decay=5e-4,
lr=0.1,
momentum=0.9)
#self.exp_lr_scheduler = lr_scheduler.StepLR(self.optimizer, step_size=10, gamma=0.1)
self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_pair, self.cfp_fp_pair, self.lfw_pair = get_val_data(
Path('data/eval/'))
self.writer = SummaryWriter(log_dir)
self.print_preq = 100
self.board_loss_every = len(self.train_loader) // 5
self.evaluate_every = len(self.train_loader) // 5
self.save_every = len(self.train_loader) // 1
def __init__(self, layers=50, dropout=0.1, classes=1, zoom_factor=8, criterion=nn.CrossEntropyLoss(ignore_index=255), BatchNorm=nn.BatchNorm2d, pretrained=True, args=None):
super(MGLNet, self).__init__()
assert layers in [50, 101, 152]
assert classes == 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
self.criterion = criterion
self.args = args
models.BatchNorm = BatchNorm
self.gamma = 1.0
if layers == 50:
resnet = models.resnet50(pretrained=pretrained)
elif layers == 101:
resnet = models.resnet101(pretrained=pretrained)
else:
resnet = models.resnet152(pretrained=pretrained)
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2, resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
self.dim = 512
self.pred = nn.Sequential(
nn.Conv2d(2048, self.dim, kernel_size=3, padding=1, bias=False),
BatchNorm(self.dim),
nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(self.dim, classes, kernel_size=1)
)
self.region_conv = self.pred[0:4] # 2048 -> 512
self.edge_cat = ConcatNet(BatchNorm) # concat low-level feature map to predict edge
# cascade mutual net
self.mutualnet0 = MutualNet(BatchNorm, dim=self.dim, num_clusters=args.num_clusters, dropout=dropout)
if args.stage == 1:
self.mutualnets = nn.ModuleList([self.mutualnet0])
elif args.stage == 2:
self.mutualnet1 = MutualNet(BatchNorm, dim=self.dim, num_clusters=args.num_clusters, dropout=dropout)
self.mutualnets = nn.ModuleList([self.mutualnet0, self.mutualnet1])
def get_model(model_type='resnet50', num_classes=1000):
# TODO: Add more backbones
if model_type == 'resnet34':
model = resnet.resnet34(pretrained=True)
elif model_type == 'resnet50':
model = resnet.resnet50(pretrained=True)
elif model_type == 'resnet101':
model = resnet.resnet101(pretrained=True)
elif model_type == 'resnet152':
model = resnet.resnet152(pretrained=True)
elif model_type == 'resnext50_32x4d':
model = resnet.resnext50_32x4d(pretrained=True)
elif model_type == 'resnext101_32x8d':
model = resnet.resnext101_32x8d(pretrained=True)
elif model_type == 'res2net_v1b_50':
model = res2net50_v1b_26w_4s(pretrained=True)
elif model_type == 'res2net_v1b_101':
model = res2net101_v1b_26w_4s(pretrained=True)
elif model_type == 'res2net50_26w_4s':
model = res2net50_26w_4s(pretrained=True)
elif model_type == 'res2net101_26w_4s':
model = res2net101_26w_4s(pretrained=True)
elif model_type == 'res2next50':
model = res2next50(pretrained=True)
elif model_type == 'senet154':
model = senet.senet154(num_classes=num_classes, pretrained='imagenet')
elif model_type == 'resnest50':
model = resnest50(pretrained=True)
elif model_type == 'resnest101':
model = resnest101(pretrained=True)
elif model_type == 'resnest200':
model = resnest200(pretrained=True)
elif model_type == 'resnest269':
model = resnest269(pretrained=True)
else:
model = resnet.resnet50(pretrained=True)
return model
def test(args):
# np.random.seed(args.seed)
# torch.manual_seed(args.seed)
# cudnn.benchmark = True
test_loader, test_cls_list, test_attrs = get_test_data(
args.data_dir, args.batch_size)
model = resnet50(pretrained=False,
cut_at_pooling=False,
num_features=1024,
norm=False,
dropout=0,
num_classes=300)
# model = ResNet50M(num_classes=300)
print(model)
model = nn.DataParallel(model).cuda()
checkpoint = load_checkpoint(
osp.join(args.model_dir, 'checkpoint_bi1901_1402.pth.tar'))
model.module.load_state_dict(checkpoint['state_dict'])
model.eval()
feat, name = [], []
for i, d in enumerate(test_loader):
imgs, fnames = d
inputs = Variable(imgs)
_, outputs, _ = model(inputs)
# outputs = F.sigmoid(outputs)
feat.append(outputs.data.cpu().numpy())
name.extend(fnames)
feat = np.vstack(feat)
# name = name.hstack(name)
dist = compute_dist(feat, test_attrs, 'cosine')
result = []
for i, v in enumerate(dist):
max = v.max()
v = list(v)
index = v.index(max)
result.append('{}\tZJL{}'.format(name[i].strip(),
test_cls_list[index]))
print(result[:10])
s = open(
'/home/stage/yuan/ZSL/submit_{}.txt'.format(
datetime.datetime.now().strftime('%Y%m%d_%H%M%S')), 'w')
for i in result:
s.write(i + '\n')
print(len(result))
print()
def test():
##
engine = Engine()
config = getConfig()
data_config = getDatasetConfig(config.dataset)
# define dataset
transform_test = transforms.Compose([
transforms.Resize((config.image_size, config.image_size)),
transforms.CenterCrop(config.input_size),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
val_dataset = CustomDataset(data_config['val'],
data_config['val_root'],
transform=transform_test)
val_loader = DataLoader(val_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True)
# define model
if config.model_name == 'inception':
net = inception_v3_bap(pretrained=True, aux_logits=False)
elif config.model_name == 'resnet50':
net = resnet50(pretrained=True)
in_features = net.fc_new.in_features
new_linear = torch.nn.Linear(in_features=in_features,
out_features=val_dataset.num_classes)
net.fc_new = new_linear
# load checkpoint
use_gpu = torch.cuda.is_available() and config.use_gpu
if use_gpu:
net = net.cuda()
gpu_ids = [int(r) for r in config.gpu_ids.split(',')]
if use_gpu and len(gpu_ids) > 1:
net = torch.nn.DataParallel(net, device_ids=gpu_ids)
#checkpoint_path = os.path.join(config.checkpoint_path,'model_best.pth.tar')
net.load_state_dict(torch.load(config.checkpoint_path)['state_dict'])
# define loss
# define loss
criterion = torch.nn.CrossEntropyLoss()
if use_gpu:
criterion = criterion.cuda()
prec1, prec5 = engine.test(val_loader, net, criterion)
def __init__(self, im_width, im_height, pretrained=True):
super(MotFRCNN, self).__init__()
self.rpn_out_ch=512
self.track_rpn_out_ch=512
self.features_out_ch=256
self.fetch_config()
self.bound=(im_width, im_height)
self.out_size=(im_width//self.stride, im_height//self.stride)
self.num_anchors=self.K*(self.rpn_conv_size**2)
self.fpn=fpn.FPN(self.features_out_ch)
self.features=resnet.resnet50(pretrained=pretrained)
self.make_rpn()
def __init__(self, device, dataloader, backbone, head, regular, log_dir, model_dir, batch_size, embedding_size, is_decouple):
self.step = 0
self.device = device
self.batch_size = batch_size
self.embedding_size = embedding_size
self.train_loader, self.class_num = dataloader.get_loader()
self.model_dir = model_dir
self.log_dir = log_dir
self.regular = regular
self.is_decouple = is_decouple
if backbone == 'vgg':
self.backbone = vgg19(is_decouple=self.is_decouple).to(self.device)
self.scale = 5
elif backbone == 'resnet':
self.backbone = resnet50().to(self.device)
self.scale = 10
else:
self.backbone = None
if head == 'arcface':
self.head = ArcMarginProduct(embedding_size, self.class_num, self.scale, regular=self.regular).to(self.device)
else:
self.head = None
self.optimizer = optim.SGD([
{'params' : self.backbone.parameters()},
{'params' : self.head.parameters()}], weight_decay=5e-4
, lr=0.1, momentum=0.9)
self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_pair, self.cfp_fp_pair, self.lfw_pair = get_val_data(Path('data/eval/'))
self.writer = SummaryWriter(log_dir)
self.print_preq = 100
self.board_loss_every = len(self.train_loader) // 5
self.evaluate_every = len(self.train_loader) // 5
self.save_every = len(self.train_loader) // 1
print('class number: ', self.class_num)
print('backbone: ', backbone, 'scale: ', self.scale)
def main():
transformations = transforms.Compose([
transforms.ToTensor(),
# transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
train_dataset = CifarDataset(TRAIN_CSV_PATH, TRAIN_IMG_PATH,
transformations)
train_loader = CifarDataloader(train_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
test_dataset = CifarDataset(TEST_CSV_PATH, TEST_IMG_PATH, transformations)
test_loader = CifarDataloader(test_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
model = resnet50(pretrained=True, num_classes=10)
criterion = nn.CrossEntropyLoss()
if USE_GPU:
model = model.cuda()
criterion = criterion.cuda()
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
# load_checkpoint(os.path.join('checkpoint', 'last_checkpoint.pth.tar'), model, optimizer)
for epoch in range(EPOCHS):
train(train_loader,
model,
criterion,
optimizer,
epoch + 1,
USE_GPU,
writer=writer)
test(test_loader, model, USE_GPU)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}, os.path.join('checkpoint'))
def __init__(self, config):
super(MaskRCNN, self).__init__()
self.config = config
self.__mode = 'train'
feature_channels = 128
# define modules (set of layers)
# self.feature_net = FeatureNet(cfg, 3, feature_channels)
self.feature_net = resnet50().cuda()
#self.rpn_head = RpnMultiHead(cfg,feature_channels)
self.rpn = RPN(256, len(self.config.RPN_ANCHOR_RATIOS),
self.config.RPN_ANCHOR_STRIDE)
#self.rcnn_crop = CropRoi(cfg, cfg.rcnn_crop_size)
self.rcnn_head = RCNNHead(config)
#self.mask_crop = CropRoi(cfg, cfg.mask_crop_size)
self.mask_head = MaskHead(config)
self.anchors = generate_pyramid_anchors(self.config.RPN_ANCHOR_SCALES,
self.config.RPN_ANCHOR_RATIOS,
self.config.BACKBONE_SHAPES,
self.config.BACKBONE_STRIDES,
self.config.RPN_ANCHOR_STRIDE)
self.anchors = self.anchors.astype(np.float32)
self.proposal_count = self.config.POST_NMS_ROIS_TRAINING
# FPN
self.fpn_c5p5 = nn.Conv2d(
512 * 4, 256, kernel_size=1, stride=1, padding=0)
self.fpn_c4p4 = nn.Conv2d(
256 * 4, 256, kernel_size=1, stride=1, padding=0)
self.fpn_c3p3 = nn.Conv2d(
128 * 4, 256, kernel_size=1, stride=1, padding=0)
self.fpn_c2p2 = nn.Conv2d(
64 * 4, 256, kernel_size=1, stride=1, padding=0)
self.fpn_p2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p4 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p5 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.scale_ratios = [4, 8, 16, 32]
self.fpn_p6 = nn.MaxPool2d(
kernel_size=1, stride=2, padding=0, ceil_mode=False)
def __init__(self, embedding_size, num_classes, backbone='resnet50'):
super(background_resnet, self).__init__()
self.backbone = backbone
# copying modules from pretrained models
if backbone == 'resnet50':
self.pretrained = resnet.resnet50(pretrained=False)
elif backbone == 'resnet101':
self.pretrained = resnet.resnet101(pretrained=False)
elif backbone == 'resnet152':
self.pretrained = resnet.resnet152(pretrained=False)
elif backbone == 'resnet18':
self.pretrained = resnet.resnet18(pretrained=False)
elif backbone == 'resnet34':
self.pretrained = resnet.resnet34(pretrained=False)
else:
raise RuntimeError('unknown backbone: {}'.format(backbone))
self.fc0 = nn.Linear(512, embedding_size)
self.bn0 = nn.BatchNorm1d(embedding_size)
self.relu = nn.ReLU()
self.last = nn.Linear(embedding_size, num_classes)
def valid(val_loader, val_cls_list, val_attrs, model_dir):
model = resnet50(pretrained=False,
cut_at_pooling=False,
num_features=1024,
norm=False,
dropout=0,
num_classes=300)
# model = get_network(num_classes=30, depth=50)
# model = ResNet50M(num_classes=300)
model = nn.DataParallel(model).cuda()
checkpoint = load_checkpoint(
osp.join(model_dir, 'checkpoint_bi_1901.pth.tar'))
model.module.load_state_dict(checkpoint['state_dict'])
model.eval()
feat, label = [], []
for i, d in enumerate(val_loader):
imgs, _, l = d
inputs = Variable(imgs)
_, outputs, _ = model(inputs)
outputs = F.relu(outputs)
feat.append(outputs.data.cpu().numpy())
label.extend(l)
feat = np.vstack(feat)
# name = name.hstack(name)
dist = compute_dist(feat, val_attrs, 'cosine')
result = []
for i, v in enumerate(dist):
max = v.max()
v = list(v)
index = v.index(max)
result.append((int(label[i]), val_cls_list[index]))
n = 0
for tar, pre in result:
if pre == tar:
n = n + 1
print('the acc by cos is {}/{}'.format(n, len(result)))
return n
def __init__(self,
layers,
in_channels=192,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1),
pretrained=False,
deep_base=False) -> None:
super(ResNetDCT_2345, self).__init__()
self.layers = layers
if layers == 18:
resnet = resnet18(pretrained, deep_base, strides=strides, dilations=dilations)
elif layers == 34:
resnet = resnet34(pretrained, deep_base, strides=strides, dilations=dilations)
elif layers == 50:
resnet = resnet50(pretrained, deep_base, strides=strides, dilations=dilations)
elif layers == 101:
resnet = resnet101(pretrained, deep_base, strides=strides, dilations=dilations)
self.layer1, self.layer2, self.layer3, self.layer4, self.avgpool, self.fc = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4, resnet.avgpool, resnet.fc
self.relu = nn.ReLU(inplace=True)
if layers in [18, 34]:
in_ch = self.layer1[0].conv1.in_channels
self.down_layer = nn.Sequential(
nn.Conv2d(in_channels, in_ch, kernel_size=1, stride=1, bias=False),
nn.BatchNorm2d(in_ch),
nn.ReLU(inplace=True)
)
# initialize the weight for only one layer
for m in self.down_layer.modules():
init_weight(m)
else:
out_ch = self.layer1[0].conv1.out_channels
self.layer1[0].conv1 = nn.Conv2d(in_channels, out_ch, kernel_size=1, stride=1, bias=False)
init_weight(self.layer1[0].conv1)
out_ch = self.layer1[0].downsample[0].out_channels
self.layer1[0].downsample[0] = nn.Conv2d(in_channels, out_ch, kernel_size=1, stride=1, bias=False)
init_weight(self.layer1[0].downsample[0])
def __init__(self, im_width, im_height, pretrained=True):
super(FasterRCNN, self).__init__()
self.frcnn_roi_size = cfg.FRCNN_ROI_SIZE
self.batch_size = cfg[cfg.PHASE].IMS_PER_BATCH
self.rpn_out_ch = 512
self.features_out_ch = 256
self.im_width = im_width
self.im_height = im_height
self.bound = (im_width, im_height)
self.stride = cfg.STRIDE
self.K = len(cfg.RATIOS) * len(cfg.SCALES)
self.use_bn = not cfg.IMAGE_NORMALIZE
self.out_width = self.im_width // self.stride
self.out_height = self.im_height // self.stride
self.out_size = (self.out_width, self.out_height)
self.num_anchors = self.K * (self.out_width * self.out_height)
self.fpn = fpn.FPN(self.features_out_ch)
self.features = resnet.resnet50(pretrained=pretrained)
self.make_net()
def test(test_loader, test_cls_list, test_attrs, model_dir):
model = resnet50(pretrained=False,
cut_at_pooling=False,
num_features=1024,
norm=False,
dropout=0,
num_classes=30)
model = nn.DataParallel(model).cuda()
checkpoint = load_checkpoint(osp.join(model_dir, 'checkpoint.pth.tar'))
model.module.load_state_dict(checkpoint['state_dict'])
model.eval()
feat, name = [], []
for i, d in enumerate(test_loader):
imgs, fnames, _ = d
inputs = Variable(imgs)
_, outputs = model(inputs)
# outputs = F.sigmoid(outputs)
feat.append(outputs.data.cpu().numpy())
name.extend(fnames)
feat = np.vstack(feat)
# name = name.hstack(name)
dist = compute_dist(feat, test_attrs, 'cosine')
result = []
for i, v in enumerate(dist):
max = v.max()
v = list(v)
index = v.index(max)
result.append((int(name[i][:3]), test_cls_list[index]))
n = 0
for pre, tar in result:
if pre == tar:
n = n + 1
print('the acc is {}/{}'.format(n, len(result)))
def train(args):
# np.random.seed(args.seed)
# torch.manual_seed(args.seed)
# cudnn.benchmark = True
train_loader, val_loader, val_cls_list, val_attrs, attr_mat = get_data(
args.data_dir, args.batch_size)
model = resnet50(pretrained=True,
cut_at_pooling=False,
num_features=1024,
norm=False,
dropout=0,
num_classes=300)
# model = get_network(num_classes=30, depth=50)
# model = ResNet50M(num_classes=300)
print(model)
model = nn.DataParallel(model).cuda()
#
# checkpoint = load_checkpoint(osp.join(args.model_dir, 'checkpoint_64.pth.tar'))
# model.module.load_state_dict(checkpoint['state_dict'])
if hasattr(model.module, 'base'):
base_param_ids = set(map(id, model.module.base.parameters()))
new_params = [
p for p in model.parameters() if id(p) not in base_param_ids
]
param_groups = [{
'params': model.module.base.parameters(),
'lr_mult': 0.1
}, {
'params': new_params,
'lr_mult': 1.0
}]
else:
param_groups = model.parameters()
# Optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(param_groups,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
def adjust_lr(epoch):
if epoch in [
70,
]:
lr = 0.1 * args.lr
print('=====> adjust lr to {}'.format(lr))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# valid(val_loader, val_cls_list, val_attrs, args.model_dir)
attr_mat = Variable(attr_mat.t().cuda())
attr_mat = normalize(attr_mat, axis=1)
t = [
0.01, 0.01, 0.002, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
0.001, 0.001, 0.001, 0.001, 0.001, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
for epoch in range(0, args.epochs):
adjust_lr(epoch)
model.train()
losses = AverageMeter()
loss1 = AverageMeter()
loss2 = AverageMeter()
iteration = 116 * epoch
# print(iteration)
for i, d in enumerate(train_loader):
iteration += 1
imgs, fnames, attrs, labels = d
inputs = Variable(imgs)
labels = Variable(labels.cuda())
attr_targets = Variable(torch.stack(attrs, 1).cuda())
attr_targets = attr_targets.detach()
f, outputs, w = model(inputs)
f_ = torch.mm(attr_targets, w)
mse_loss = get_mse_loss(f, f_, args.batch_size)
loss1.update(mse_loss.data[0], attr_targets.size(0))
cls_output = torch.mm(outputs, attr_mat)
cls_loss = criterion(cls_output, labels)
loss2.update(cls_loss.data[0], attr_targets.size(0))
# if epoch < 5:
# loss = cls_loss
# else:
loss = t[epoch] * mse_loss + cls_loss
losses.update(loss.data[0], attr_targets.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
vis.line(X=torch.ones((1, )) * iteration,
Y=torch.Tensor((losses.avg, )),
win='loss of network',
update='append' if iteration > 0 else None,
opts=dict(xlabel='iteration',
title='Loss',
legend=['Loss']))
vis.line(X=torch.ones((1, )) * iteration,
Y=torch.Tensor((loss1.avg, )),
win='sigmod loss of network',
update='append' if iteration > 0 else None,
opts=dict(xlabel='iteration',
title='Loss1',
legend=['Loss']))
vis.line(X=torch.ones((1, )) * iteration,
Y=torch.Tensor((loss2.avg, )),
win='biliner loss of network',
update='append' if iteration > 0 else None,
opts=dict(xlabel='iteration',
title='Loss2',
legend=['Loss']))
if (i + 1) % args.print_freq == 0:
print(
'Epoch: [{}][{}/{}]\t Loss {:.6f} ({:.6f})\t Loss_ml {:.6f} ({:.6f})\t Loss_cl {:.6f} ({:.6f})\t'
.format(epoch, i + 1, len(train_loader), losses.val,
losses.avg, loss1.val, loss1.avg, loss2.val,
loss2.avg))
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': 0,
},
False,
fpath=osp.join(args.model_dir, 'checkpoint_bi_1901.pth.tar'))
nu = valid(val_loader, val_cls_list, val_attrs, args.model_dir)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': 0,
},
False,
fpath=osp.join(args.model_dir,
'checkpoint_bi1901_{}.pth.tar'.format(nu)))
vis.line(X=torch.ones((1, )) * epoch,
Y=torch.Tensor((nu, )),
win='acc',
update='append' if iteration > 0 else None,
opts=dict(xlabel='epoch', title='acc', legend=['acc']))
def __init__(self, args, train_dataset, device, input_channel, num_classes):
# Hyper Parameters
self.batch_size = 128
learning_rate = args.lr
if args.forget_rate is None:
if args.noise_type == "asymmetric":
forget_rate = args.noise_rate / 2
else:
forget_rate = args.noise_rate
else:
forget_rate = args.forget_rate
self.noise_or_not = train_dataset.noise_or_not
# Adjust learning rate and betas for Adam Optimizer
mom1 = 0.9
mom2 = 0.1
self.alpha_plan = [learning_rate] * args.n_epoch
self.beta1_plan = [mom1] * args.n_epoch
for i in range(args.epoch_decay_start, args.n_epoch):
self.alpha_plan[i] = float(args.n_epoch - i) / (args.n_epoch - args.epoch_decay_start) * learning_rate
self.beta1_plan[i] = mom2
# define drop rate schedule
self.rate_schedule = np.ones(args.n_epoch) * forget_rate
self.rate_schedule[:args.num_gradual] = np.linspace(0, forget_rate ** args.exponent, args.num_gradual)
self.device = device
self.num_iter_per_epoch = args.num_iter_per_epoch
self.print_freq = args.print_freq
self.co_lambda = args.co_lambda
self.n_epoch = args.n_epoch
self.train_dataset = train_dataset
if args.model_type == "cnn":
if args.dataset == 'mnist':
self.model1 = CNN(input_channel=input_channel, n_outputs=num_classes, linear_num=144)
self.model2 = CNN(input_channel=input_channel, n_outputs=num_classes, linear_num=144)
else:
self.model1 = CNN(input_channel=input_channel, n_outputs=num_classes)
self.model2 = CNN(input_channel=input_channel, n_outputs=num_classes)
elif args.model_type == "mlp":
self.model1 = MLPNet()
self.model2 = MLPNet()
elif args.model_type == 'resnet50':
self.model1 = resnet50(pretrained=True, num_classes=num_classes)
self.model2 = resnet50(pretrained=True, num_classes=num_classes)
self.model1.to(device)
print(self.model1.parameters)
self.model2.to(device)
print(self.model2.parameters)
if args.optimizer == 'Adam' or args.optimizer == 'adam':
self.optimizer = torch.optim.Adam(list(self.model1.parameters()) + list(self.model2.parameters()),
lr=learning_rate)
elif args.optimizer == "SGD" or args.optimizer == 'sgd':
self.optimizer = torch.optim.SGD(list(self.model1.parameters()) + list(self.model2.parameters()),
lr=learning_rate, momentum=0.9, weight_decay=1e-3)
else:
raise NotImplementedError("ERROR: Optimizer {} not been implemented!".format(args.optimizer))
self.loss_fn = loss_jocor
self.adjust_lr = args.adjust_lr
def train():
data_transform = transforms.Compose([
transforms.Resize((224, 224)),
#transforms.RandomHorizontalFlip(p=0.2),
#transforms.ColorJitter(contrast=1),
transforms.ToTensor(),
#transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
print("dataset root", DATASET_ROOT)
train_set = IMAGE_Dataset(Path(DATASET_ROOT), data_transform)
print("train_set.numclasses: {}".format(train_set.num_classes))
print("len of train_set", len(train_set))
# If out of memory , adjusting the batch size smaller
data_loader = DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True, num_workers=1)
#print(train_set.num_classes)
#model = VGG16(num_classes=train_set.num_classes)
#model = resnet50(pretrained=False, num_classes=train_set.num_classes)
model = resnet50(pretrained=True)
# transfer learning
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, train_set.num_classes)
model = model.cuda(CUDA_DEVICES)
model.train()
best_model_params = copy.deepcopy(model.state_dict())
best_acc = 0.0
# Training epochs
criterion = nn.CrossEntropyLoss()
# Optimizer setting
optimizer = torch.optim.SGD(params=model.parameters(), lr=init_lr, momentum=0.9)
#optimizer = torch.optim.Adam(params=model.parameters(), lr=init_lr)
# Log
with open('TrainingAccuracy.txt','w') as fAcc:
print('Accuracy\n', file = fAcc)
with open('TrainingLoss.txt','w') as fLoss:
print('Loss\n', file = fLoss)
#record loss & accuracy
loss_record = list()
acc_record = list()
for epoch in range(num_epochs):
localtime = time.asctime( time.localtime(time.time()) )
print('Epoch: {}/{} --- < Starting Time : {} >'.format(epoch + 1,num_epochs,localtime))
print('-' * len('Epoch: {}/{} --- < Starting Time : {} >'.format(epoch + 1,num_epochs,localtime)))
training_loss = 0.0
training_corrects = 0
adjust_lr(optimizer, epoch)
for i, (inputs, labels) in enumerate(data_loader):
inputs = Variable(inputs.cuda(CUDA_DEVICES))
labels = Variable(labels.cuda(CUDA_DEVICES))
optimizer.zero_grad()
outputs = model(inputs)
#print("outputs: {}, label: {}".format(outputs.size(), labels))
_, preds = torch.max(outputs.data, 1)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
training_loss += float(loss.item() * inputs.size(0))
training_corrects += torch.sum(preds == labels.data)
print("preds : ", preds)
print("labels : ", labels)
training_loss = training_loss / len(train_set)
training_acc = training_corrects.double() /len(train_set)
print('Training loss: {:.4f}\taccuracy: {:.4f}\n'.format(training_loss,training_acc))
loss_record.append(training_loss)
acc_record.append(training_acc)
#save model each 10 epochs
if epoch % 10 == 0:
epoch_model = copy.deepcopy(model.state_dict())
model.load_state_dict(epoch_model)
model_name = './weights/epoch_models/model-{:.1f}epoch.pth'.format(epoch)
torch.save(model, model_name)
# Check best accuracy model ( but not the best on test )
if training_acc > best_acc:
best_acc = training_acc
best_model_params = copy.deepcopy(model.state_dict())
with open('TrainingAccuracy.txt','a') as fAcc:
print('{:.4f} '.format(training_acc), file = fAcc)
with open('TrainingLoss.txt','a') as fLoss:
print('{:.4f} '.format(training_loss), file = fLoss)
# Checkpoint
if (epoch + 1) % checkpoint_interval == 0:
torch.save(model, 'Checkpoint/model-epoch-{:d}-train.pth'.format(epoch + 1))
#draw the loss & acc curve
draw_plot(loss_record, acc_record)
# Save best training/valid accuracy model ( not the best on test )
model.load_state_dict(best_model_params)
best_model_name = './weights/model-{:.2f}-best_train_acc.pth'.format(best_acc)
torch.save(model, best_model_name)
print("Best model name : " + best_model_name)
if args.layer == '18':
net = resnet18(pretrained=False,
progress=True,
activate=activate,
hidden=hidden,
num_classes=10)
elif args.layer == '34':
net = resnet34(pretrained=False,
progress=True,
activate=activate,
hidden=hidden,
num_classes=10)
elif args.layer == '50':
net = resnet50(pretrained=False,
progress=True,
activate=activate,
hidden=hidden,
num_classes=10)
elif args.layer == '101':
net = resnet101(pretrained=False,
progress=True,
activate=activate,
hidden=hidden,
num_classes=10)
elif args.layer == '152':
net = resnet152(pretrained=False,
progress=True,
activate=activate,
hidden=hidden,
num_classes=10)
else:
def main(argus):
argus.cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if argus.cuda else "cpu") # 查看是否具有GPU
print('*' * 80)
print(device) # 输出当前设备名
tokenizer = BertTokenizer.from_pretrained(
argus.bert_token_path) # 加载Bert的token
# 解压文件
unzip.unzip_text()
unzip.unzip_annotation()
unzip.unzip_image()
# 预处理文件,如果不需要则跳过,此步时间较长
preprocessdata = preprocess.preprocess_data(argus.text_path,
argus.annotation_path,
argus.image_path,
argus.mini_character,
argus.spacy_model)
preprocessdata.get_sentence()
# preprocessdata.get_imageannotations()
preprocessdata.resize_image()
# 加载数据集
Dataset = dataset.MutimodelDataset(loaddata=loaddata.Load_data(
data_path_text=argus.text_path,
data_path_annotation=argus.annotation_path,
data_path_image=argus.image_path,
datasize=argus.data_size),
tokenizer=tokenizer,
image_number=argus.image_number,
make_batch=Transformer.Batch)
# construct neural network
treelstm = TreeLstm.SimilarityTreeLSTM(vocab_size=argus.vocab_size,
in_dim=argus.tree_embed_dim,
mem_dim=argus.tree_mem_dim,
hidden_dim=argus.tree_hidden_dim,
sparsity=argus.sparse,
freeze=argus.freeze_embed)
# tree-lstm
resnet50 = resnet.resnet50(save_path=argus.save_resnet,
pretrained=argus.pretrain_resnet,
image_embed=argus.image_embed)
# resnet
attention_bilstm = attention_Bilstm.BiLSTM(
lstm_hidden_dim=argus.lstm_hidden_dim,
vocabsize=argus.vocab_size,
embed_dim=argus.lstm_embed_dim,
lstm_num_layers=argus.lstm_num_layers,
batchsize=argus.batch_size,
negative_slope=argus.LeakyRelu_slope)
tran_en_ffn = Transformer.PositionwiseFeedForward(d_model=argus.d_model,
d_ff=argus.d_ff,
dropout=argus.dropout)
tran_en_mutihead = Transformer.MultiHeadedAttention(h=argus.head,
d_model=argus.d_model)
trans_encodelayer = Transformer.EncoderLayer(d_model=argus.d_model,
self_attn=tran_en_mutihead,
feed_forward=tran_en_ffn,
dropout=argus.dropout)
trans_encode = Transformer.Encoder(layer=trans_encodelayer,
N=argus.encoder_layer)
tran_en_embeding = Transformer.Embeddings(d_model=argus.d_model,
vocab=argus.vocab_size)
tran_en_position = Transformer.PositionalEncoding(d_model=argus.d_model,
dropout=argus.dropout)
tran_en_embed = nn.Sequential(tran_en_embeding, tran_en_position)
trans_encoder = Transformer.Transformer_encoder(
encoder=trans_encode, src_embed=tran_en_embed) # transformer的编码器
tran_de_ffn = deepcopy(tran_en_ffn)
tran_de_mutihead1 = deepcopy(tran_en_mutihead)
tran_de_mutihead2 = deepcopy(tran_en_mutihead)
tran_decoderlayer = Transformer.DecoderLayer(d_model=argus.d_model,
self_attn=tran_de_mutihead1,
src_attn=tran_de_mutihead2,
feed_forward=tran_de_ffn,
dropout=argus.dropout)
tran_de_embedding = deepcopy(tran_en_embeding)
tran_de_position = deepcopy(tran_en_position)
tran_de_embed = nn.Sequential(tran_de_embedding, tran_de_position)
trans_decode = Transformer.Decoder(layer=tran_decoderlayer,
N=argus.decoder_layer)
trans_decoder = Transformer.Transformer_decoder(
decoder=trans_decode, tgt_embed=tran_de_embed) # transformer解码器
# model encoder
encoder = Mutimodel.Encoder(image_encoder=resnet50,
tran_encoder=trans_encoder,
treelstm=treelstm,
Bilstm=attention_bilstm,
res_embed=argus.image_embed,
trans_embed=argus.d_model,
tree_embed=argus.tree_hidden_dim,
bilstm_embed=argus.lstm_embed_dim,
negative_slope=argus.LeakyRelu_slope,
device=device).to(device)
# model decoder
decoder = Mutimodel.Decoder(
tran_decoder=trans_decoder,
encoder_embed=argus.lstm_hidden_dim,
decoder_embed=argus.d_model,
negative_slope=argus.LeakyRelu_slope).to(device)
# model generator
generator = Mutimodel.Generator(d_model=argus.d_model,
vocab=argus.vocab_size).to(device)
model = Mutimodel.Mutimodel(encoder=encoder,
decoder=decoder,
generation=generator)
criterion = nn.CrossEntropyLoss().to(device) # Loss function
optimizer = torch.optim.Adam(params=model.parameters(),
lr=argus.lr,
weight_decay=argus.wd) # optimize
# 构建训练器
trainer = train.Trainer(model=model,
criterion=criterion,
optimizer=optimizer,
datasize=Dataset.size,
batchsize=argus.batch_size,
device=device,
tokenizer=tokenizer)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# Start training
for epoch in range(argus.epochs):
train_loss = trainer.train(Dataset[0])
logger.info('==> Epoch {}, Train \tLoss: {}'.format(epoch, train_loss))
test_loss, R_score1, R_score2 = trainer.test(Dataset[1])
checkpoint = {
'epoch': epoch,
'Loss ': train_loss,
'R_1': R_score1,
'R_2': R_score2,
'text': test_loss
}
logger.debug('==> New optimum found, checkpointing everything now...')
file = open(os.path.join(argus.save_log, argus.log_file),
'a',
encoding='utf-8')
save = json.dumps(checkpoint)
file.write(save)
file.write('\n')
file.close()
shuffle=True)
num_classes = 10
else:
assert False, 'cifar100 | cifar10 are allowed only.'
if args.checkpoint:
chk = torch.load(args.checkpoint)
model = chk['model']
e = chk['e']
writer = chk['writer']
args = chk['args']
else:
if args.optimizer == 'adam':
_optimizer = torch.optim.Adam
if args.model == 'resnet':
model = resnet50(num_classes=num_classes)
elif args.model == 'lambdaresnet':
model = lambdaresnet50(num_classes=num_classes)
optimizer = _optimizer(model.parameters())
writer = {}
e = 0
import json
with open(f'{savefolder}/args.json', 'w') as f:
json.dump(args.__dict__, f)
lossf = nn.CrossEntropyLoss()
if device == 'cuda':
model = model.to(device)
for e in range(e, epoch):
operate('train')
operate('val')
torch.save(
def __init__(self, num_classes=20):
super(FashionNet, self).__init__()
self.resnet = resnet50(True)
self.fc = nn.Linear(2048, num_classes)
def main(args):
# np.random.seed(args.seed)
# torch.manual_seed(args.seed)
# cudnn.benchmark = True
train_loader, val_loader, val_cls_list, val_attrs = get_data(
args.data_dir, args.batch_size)
model = resnet50(pretrained=True,
cut_at_pooling=False,
num_features=1024,
norm=False,
dropout=0,
num_classes=30)
# model = get_network(num_classes=30, depth=50)
print(model)
model = nn.DataParallel(model).cuda()
checkpoint = load_checkpoint(
osp.join(args.model_dir, 'checkpoint_ms6.pth.tar'))
model.module.load_state_dict(checkpoint['state_dict'])
# Optimizer
if hasattr(model.module, 'base'):
base_param_ids = set(map(id, model.module.base.parameters()))
new_params = [
p for p in model.parameters() if id(p) not in base_param_ids
]
param_groups = [{
'params': model.module.base.parameters(),
'lr_mult': 0.1
}, {
'params': new_params,
'lr_mult': 0.1
}]
else:
param_groups = model.parameters()
optimizer = torch.optim.SGD(param_groups,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
def adjust_lr(epoch):
if epoch in [20]:
lr = 0.1 * args.lr
print('=====> adjust lr to {}'.format(lr))
for g in optimizer.param_groups:
g['lr'] = lr * g.get('lr_mult', 1)
# valid(val_loader, val_cls_list, val_attrs, args.model_dir)
for epoch in range(0, args.epochs):
adjust_lr(epoch)
model.train()
loss = AverageMeter()
iteration = 467 * epoch
# print(iteration)
for i, d in enumerate(train_loader):
iteration += 1
imgs, fnames, attrs, labels = d
inputs = Variable(imgs)
attr_targets = Variable(torch.stack(attrs, 1).cuda())
attr_targets = attr_targets.detach()
_, outputs = model(inputs)
mse_loss = nn.MultiLabelSoftMarginLoss(size_average=False)(
outputs, attr_targets)
mse_loss = mse_loss / (2 * args.batch_size)
loss.update(mse_loss.data[0], attr_targets.size(0))
optimizer.zero_grad()
mse_loss.backward()
optimizer.step()
vis.line(X=torch.ones((1, )) * iteration,
Y=torch.Tensor((loss.avg, )),
win='reid softmax loss of network',
update='append' if iteration > 0 else None,
opts=dict(xlabel='iteration',
title='Loss',
legend=['Loss']))
if (i + 1) % args.print_freq == 0:
print('Epoch: [{}][{}/{}]\t Loss {:.6f} ({:.6f})\t'.format(
epoch, i + 1, len(train_loader), loss.val, loss.avg))
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': 0,
},
False,
fpath=osp.join(args.model_dir, 'checkpoint_ms6.pth.tar'))
valid(val_loader, val_cls_list, val_attrs, args.model_dir)
type=str,
default="CE",
help='loss function during model evaluation')
device = "cuda"
args = parser.parse_args()
print('dataset %s source %s target %s network %s' %
(args.dataset, args.source, args.target, args.net))
target_loader_unl, class_list = return_dataset_test_unseen(args)
use_gpu = torch.cuda.is_available()
if args.net == 'resnet34':
G = resnet34()
inc = 512
elif args.net == 'resnet50':
G = resnet50()
inc = 2048
elif args.net == "alexnet":
G = AlexNetBase()
inc = 4096
elif args.net == "vgg":
G = VGGBase()
inc = 4096
else:
raise ValueError('Model cannot be recognized.')
if "resnet" in args.net:
F1 = Predictor_deep(num_class=len(class_list), inc=inc)
else:
F1 = Predictor(num_class=len(class_list), inc=inc, temp=args.T)
"""
args.snapshot_dir = os.path.join(
args.snapshot_dir,
datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) #拼接路徑
os.makedirs(args.snapshot_dir)
if args.test:
if args.snapshot is None:
print(
">>> Sorry, please set snapshot path while extracting features"
)
exit()
else:
print('\n>>> Loading model from [%s]...' % args.snapshot)
checkpoint = torch.load('{}_checkpoint.pth.tar'.format(
args.snapshot))
Model = model.resnet50(args)
Model.load_state_dict(checkpoint['Model'])
Extract_Feature(Model, args)
elif args.train:
print("Parameters:")
for attr, value in sorted(args.__dict__.items()):
text = "\t{}={}\n".format(attr.upper(), value)
print(text)
with open('{}/Parameters.txt'.format(args.snapshot_dir), 'a') as f:
f.write(text)
if args.train_csv_file is None or args.val_csv_file is None:
print(
">>> Sorry, please set csv-file for your training/validation data"
)
exit()
def run(global_rank,
world_size,
local_rank,
max_epoch,
batch_size,
model,
data,
sgd,
graph,
verbosity,
dist_option='fp32',
spars=None):
dev = device.create_cuda_gpu_on(local_rank)
dev.SetRandSeed(0)
np.random.seed(0)
if data == 'cifar10':
from data import cifar10
train_x, train_y, val_x, val_y = cifar10.load()
elif data == 'cifar100':
from data import cifar100
train_x, train_y, val_x, val_y = cifar100.load()
elif data == 'mnist':
from data import mnist
train_x, train_y, val_x, val_y = mnist.load()
num_channels = train_x.shape[1]
image_size = train_x.shape[2]
data_size = np.prod(train_x.shape[1:train_x.ndim]).item()
num_classes = (np.max(train_y) + 1).item()
#print(num_classes)
if model == 'resnet':
from model import resnet
model = resnet.resnet50(num_channels=num_channels,
num_classes=num_classes)
elif model == 'xceptionnet':
from model import xceptionnet
model = xceptionnet.create_model(num_channels=num_channels,
num_classes=num_classes)
elif model == 'cnn':
from model import cnn
model = cnn.create_model(num_channels=num_channels,
num_classes=num_classes)
elif model == 'alexnet':
from model import alexnet
model = alexnet.create_model(num_channels=num_channels,
num_classes=num_classes)
elif model == 'mlp':
import os, sys, inspect
current = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
parent = os.path.dirname(current)
sys.path.insert(0, parent)
from mlp import module
model = module.create_model(data_size=data_size,
num_classes=num_classes)
# For distributed training, sequential gives better performance
if hasattr(sgd, "communicator"):
DIST = True
sequential = True
else:
DIST = False
sequential = False
if DIST:
train_x, train_y, val_x, val_y = partition(global_rank, world_size,
train_x, train_y, val_x,
val_y)
'''
# check dataset shape correctness
if global_rank == 0:
print("Check the shape of dataset:")
print(train_x.shape)
print(train_y.shape)
'''
if model.dimension == 4:
tx = tensor.Tensor(
(batch_size, num_channels, model.input_size, model.input_size),
dev, tensor.float32)
elif model.dimension == 2:
tx = tensor.Tensor((batch_size, data_size), dev, tensor.float32)
np.reshape(train_x, (train_x.shape[0], -1))
np.reshape(val_x, (val_x.shape[0], -1))
ty = tensor.Tensor((batch_size, ), dev, tensor.int32)
num_train_batch = train_x.shape[0] // batch_size
num_val_batch = val_x.shape[0] // batch_size
idx = np.arange(train_x.shape[0], dtype=np.int32)
# attached model to graph
model.set_optimizer(sgd)
model.compile([tx], is_train=True, use_graph=graph, sequential=sequential)
dev.SetVerbosity(verbosity)
# Training and Evaluation Loop
for epoch in range(max_epoch):
start_time = time.time()
np.random.shuffle(idx)
if global_rank == 0:
print('Starting Epoch %d:' % (epoch))
# Training Phase
train_correct = np.zeros(shape=[1], dtype=np.float32)
test_correct = np.zeros(shape=[1], dtype=np.float32)
train_loss = np.zeros(shape=[1], dtype=np.float32)
model.train()
for b in range(num_train_batch):
# Generate the patch data in this iteration
x = train_x[idx[b * batch_size:(b + 1) * batch_size]]
if model.dimension == 4:
x = augmentation(x, batch_size)
if (image_size != model.input_size):
x = resize_dataset(x, model.input_size)
y = train_y[idx[b * batch_size:(b + 1) * batch_size]]
# Copy the patch data into input tensors
tx.copy_from_numpy(x)
ty.copy_from_numpy(y)
# Train the model
out, loss = model(tx, ty, dist_option, spars)
train_correct += accuracy(tensor.to_numpy(out), y)
train_loss += tensor.to_numpy(loss)[0]
if DIST:
# Reduce the Evaluation Accuracy and Loss from Multiple Devices
reducer = tensor.Tensor((1, ), dev, tensor.float32)
train_correct = reduce_variable(train_correct, sgd, reducer)
train_loss = reduce_variable(train_loss, sgd, reducer)
if global_rank == 0:
print('Training loss = %f, training accuracy = %f' %
(train_loss, train_correct /
(num_train_batch * batch_size * world_size)),
flush=True)
# Evaluation Phase
model.eval()
for b in range(num_val_batch):
x = val_x[b * batch_size:(b + 1) * batch_size]
if model.dimension == 4:
if (image_size != model.input_size):
x = resize_dataset(x, model.input_size)
y = val_y[b * batch_size:(b + 1) * batch_size]
tx.copy_from_numpy(x)
ty.copy_from_numpy(y)
out_test = model(tx)
test_correct += accuracy(tensor.to_numpy(out_test), y)
if DIST:
# Reduce the Evaulation Accuracy from Multiple Devices
test_correct = reduce_variable(test_correct, sgd, reducer)
# Output the Evaluation Accuracy
if global_rank == 0:
print('Evaluation accuracy = %f, Elapsed Time = %fs' %
(test_correct / (num_val_batch * batch_size * world_size),
time.time() - start_time),
flush=True)
dev.PrintTimeProfiling()
def __init__(self,
layers=50,
bins=(1, 2, 3, 6),
dropout=0.1,
classes=2,
zoom_factor=8,
use_ppm=True,
criterion=nn.CrossEntropyLoss(ignore_index=255),
BatchNorm=nn.BatchNorm2d,
pretrained=True):
super(PSPNet, self).__init__()
assert layers in [18, 50, 101, 152]
assert 2048 % len(bins) == 0
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
self.use_ppm = use_ppm
self.criterion = criterion
self.criterion_reg = nn.MSELoss(reduce=False)
models.BatchNorm = BatchNorm
if layers == 18:
resnet = models_origin.resnet18(pretrained=True)
elif layers == 50:
resnet = models.resnet50(pretrained=pretrained)
elif layers == 101:
resnet = models.resnet101(pretrained=pretrained)
else:
resnet = models.resnet152(pretrained=pretrained)
'''self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
fea_dim = 512
if use_ppm:
self.ppm = PPM(fea_dim, int(fea_dim/len(bins)), bins, BatchNorm)
fea_dim *= 2'''
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
fea_dim = 2048
if use_ppm:
self.ppm = PPM(fea_dim, int(fea_dim / len(bins)), bins, BatchNorm)
fea_dim *= 2
'''self.cls = nn.Sequential(
nn.Conv2d(fea_dim, 512, kernel_size=3, padding=1, bias=False),
BatchNorm(512),
nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(512, classes, kernel_size=1)
)'''
self.cls3 = nn.Sequential(
nn.Conv2d(fea_dim, 512, kernel_size=3, padding=1, bias=False),
BatchNorm(512), nn.ReLU(inplace=True),
nn.Conv2d(512, 96 * 2, kernel_size=1), BatchNorm(96 * 2),
nn.ReLU(inplace=True))
self.cls2 = nn.Sequential(
nn.Conv2d(96 * 2 + 96, 96, kernel_size=3, padding=1, bias=False),
BatchNorm(96), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(96, classes, kernel_size=1))
self.reg = nn.Sequential(
nn.Conv2d(fea_dim, 512, kernel_size=3, padding=1, bias=False),
BatchNorm(512), nn.ReLU(inplace=True),
nn.Conv2d(512, 96, kernel_size=1))
self.reg2 = nn.Sequential(
nn.Conv2d(96, 96, kernel_size=3, padding=1, bias=False),
BatchNorm(96), nn.ReLU(inplace=True),
nn.Conv2d(96, 96, kernel_size=1), nn.ReLU(inplace=True))
self.reg3 = nn.Sequential(
nn.Conv2d(96, 96, kernel_size=3, padding=1, bias=False),
BatchNorm(96), nn.ReLU(inplace=True),
nn.Conv2d(96, 96, kernel_size=1), nn.ReLU(inplace=True))
self.bn = BatchNorm(96)
self.bn2 = BatchNorm(96)
self.mean = torch.tensor(np.load('../data/meanvar/mean.npy'),
requires_grad=False)
self.var = torch.tensor(np.sqrt(np.load('../data/meanvar/var.npy')),
requires_grad=False)
self.mean_2d = torch.tensor(np.load('../data/meanvar/mean_2d.npy'),
requires_grad=False) #.cuda().float()
self.var_2d = torch.tensor(np.sqrt(
np.load('../data/meanvar/var_2d.npy')),
requires_grad=False) #.cuda().float()
self.var = self.var[0, :]
self.mean = torch.unsqueeze(self.mean, 0)
self.mean = torch.unsqueeze(self.mean, 2)
self.mean = torch.unsqueeze(self.mean, 2)
self.mean = self.mean.repeat(1, 1, 60, 60)
self.var = torch.unsqueeze(self.var, 0)
self.var = torch.unsqueeze(self.var, 2)
self.var = torch.unsqueeze(self.var, 2)
self.var = self.var.repeat(1, 1, 60, 60)
