def loading_data():
mean_std = cfg.DATA.MEAN_STD
train_simul_transform = own_transforms.Compose([
own_transforms.Scale(int(cfg.TRAIN.IMG_SIZE[0] / 0.875)),
own_transforms.RandomCrop(cfg.TRAIN.IMG_SIZE),
own_transforms.RandomHorizontallyFlip()
])
val_simul_transform = own_transforms.Compose([
own_transforms.Scale(int(cfg.TRAIN.IMG_SIZE[0] / 0.875)),
own_transforms.CenterCrop(cfg.TRAIN.IMG_SIZE)
])
img_transform = standard_transforms.Compose([
standard_transforms.ToTensor(),
standard_transforms.Normalize(*mean_std)
])
target_transform = standard_transforms.Compose([
own_transforms.MaskToTensor(),
own_transforms.ChangeLabel(cfg.DATA.IGNORE_LABEL, cfg.DATA.NUM_CLASSES - 1)
])
restore_transform = standard_transforms.Compose([
own_transforms.DeNormalize(*mean_std),
standard_transforms.ToPILImage()
])
train_set = CityScapes('train', simul_transform=train_simul_transform, transform=img_transform,
target_transform=target_transform)
train_loader = DataLoader(train_set, batch_size=cfg.TRAIN.BATCH_SIZE, num_workers=16, shuffle=True)
val_set = CityScapes('val', simul_transform=val_simul_transform, transform=img_transform,
target_transform=target_transform)
val_loader = DataLoader(val_set, batch_size=cfg.VAL.BATCH_SIZE, num_workers=16, shuffle=False)
return train_loader, val_loader, restore_transform
def __getitem__(self, item):
fn = self.image_path[item].split('/')
filename = fn[-1]
image = Image.open(self.image_path[item]).convert('RGB')
image_w, image_h = int(image.size[0]), int(image.size[1])
depth = Image.open(self.depth_path[item]).convert('L')
# data augmentation
if self.mode == 'train':
label = Image.open(self.label_path[item]).convert('L')
random_size = scale_size
new_img = trans.Scale((random_size, random_size))(image)
new_depth = trans.Scale((random_size, random_size))(depth)
new_label = trans.Scale((random_size, random_size), interpolation=Image.NEAREST)(label)
# random crop
w, h = new_img.size
if w != img_size and h != img_size:
x1 = random.randint(0, w - img_size)
y1 = random.randint(0, h - img_size)
new_img = new_img.crop((x1, y1, x1 + img_size, y1 + img_size))
new_depth = new_depth.crop((x1, y1, x1 + img_size, y1 + img_size))
new_label = new_label.crop((x1, y1, x1 + img_size, y1 + img_size))
# random flip
if random.random() < 0.5:
new_img = new_img.transpose(Image.FLIP_LEFT_RIGHT)
new_depth = new_depth.transpose(Image.FLIP_LEFT_RIGHT)
new_label = new_label.transpose(Image.FLIP_LEFT_RIGHT)
new_img = self.transform(new_img)
new_depth = self.depth_transform(new_depth)
new_depth = new_depth.expand(3, img_size, img_size)
label_256 = self.t_transform(new_label)
if self.label_32_transform is not None and self.label_64_transform is not None and self.label_128_transform is\
not None:
label_32 = self.label_32_transform(new_label)
label_64 = self.label_64_transform(new_label)
label_128 = self.label_128_transform(new_label)
return new_img, new_depth, label_256, label_32, label_64, label_128, filename
else:
image = self.transform(image)
depth = self.depth_transform(depth)
depth = depth.expand(3, img_size, img_size)
return image, depth, image_w, image_h, self.image_path[item]
def main():
normalize = trans.Normalize(mean=[0.4001, 0.4401, 0.4687],
std=[0.229, 0.224, 0.225])
transform = trans.Compose([
trans.Scale((224,224)),
trans.ToTensor(),
normalize,
])
classes = {int(key): value for (key, value)
in parse_json(configs.class_info_dir).items()}
vgg_cam = models.vgg_cam()
vgg_cam = vgg_cam.cuda()
checkpoint = torch.load(configs.best_ckpt_dir)
vgg_cam.load_state_dict(checkpoint['state_dict'])
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
finalconv_name = 'classifier' # this is the last conv layer of the network
vgg_cam._modules.get(finalconv_name).register_forward_hook(hook_feature)
# get the softmax weight
params = list(vgg_cam.parameters())
weight_softmax = np.squeeze(params[-1].data.cpu().numpy())
img_path = 'playing_guitar_023.jpg'
save_fig_dir = 'cam_' + img_path
img_pil = Image.open(img_path)
img_tensor = transform(img_pil)
img_variable = Variable(img_tensor.unsqueeze(0).cuda())
transformed_img = img_variable.data.cpu().numpy()[0]
transformed_img = untransform(transformed_img)
outputs, _ = vgg_cam(img_variable)
h_x = F.softmax(outputs).data.squeeze()
probs, idx = h_x.sort(0, True)
top_number = 5
prob = probs.cpu().numpy()[:top_number]
idx_ = idx.cpu().numpy()[:top_number]
OUT_CAM = returnCAM(features_blobs[-1],weight_softmax,idx_,prob)
plt.figure(1, figsize=(8, 6))
ax = plt.subplot(231)
ax.imshow(transformed_img[:,:,(2,1,0)])
for b_index, (idx,prob_in,cam) in enumerate(zip(idx_,prob,OUT_CAM)):
cl = str(classes[idx])
height, width, _ = transformed_img.shape
heatmap = cv2.applyColorMap(cv2.resize(cam, (width, height)), cv2.COLORMAP_JET)
result = heatmap * 0.3 + transformed_img * 0.7
ax = plt.subplot(2,3,b_index+2)
ax.imshow(result.astype(np.uint8)[:,:,(2,1,0)])
ax.set_title(('{}:{}').format(cl,('%.3f' % prob_in)), fontsize=8)
plt.savefig(save_fig_dir)
def test_render_scene(self):
"""Test we can render a pixel in a simple scene"""
# Inner sphere size 0.5, centered on the origin
s1 = shapes.Sphere()
s1.set_transform(transforms.Scale(0.5,0.5,0.5))
# Outer sphere centered on the origin, size 1.0
s2 = shapes.Sphere()
s2.material = materials.Material(
color=colors.Color(0.8, 1.0, 0.6), diffuse=0.7, specular=0.2)
l1 = lights.Light(
position=points.Point(-10, 10, -10),
intensity=colors.Color(1, 1, 1)
)
scene = scenes.Scene(
objects = [s1, s2],
lights = [l1]
)
cam = cameras.Camera(11, 11, math.pi/2)
from_point = points.Point(0, 0, -5)
to_point = points.Point(0, 0, 0)
up = vectors.Vector(0, 1, 0)
cam.transform = transforms.ViewTransform(from_point, to_point, up)
image = cam.render(scene)
self.assertEqual(image.get(5, 5),
colors.Color(0.3807, 0.4758, 0.2855))
def test_rotate_camera(self):
"""A view transformation matrix looking in the +ve z direction"""
from_point = points.Point(0, 0, 0)
to_point = points.Point(0, 0, 1)
up = vectors.Vector(0, 1, 0)
result = transforms.ViewTransform(from_point, to_point, up)
self.assertEqual(result, transforms.Scale(-1, 1, -1))
def test_scaling_reflection(self):
"""Test we can reflect a point about an axis using the scaling matrix"""
S = transforms.Scale(-1, 1, 1)
p = points.Point(-4, 6, 8)
p2 = S * p
self.assertEqual(p2, points.Point(4, 6, 8))
def test_chained_transforms(self):
"""Test we can chain together transforms with the apply function"""
point = points.Point(1, 0, 1)
p2 = point.apply(transforms.RotateX(math.pi/2)) \
.apply(transforms.Scale(5, 5, 5)) \
.apply(transforms.Translate(10, 5, 7))
self.assertEqual(p2, points.Point(15, 0, 7))
def test_refractive_index_intersections(self):
"""Test we can calculate the refractive indices between intersections"""
# Set up a scene with three glass spheres. One at the origin with size
# 2 then inside of that 2 that are offset along z by different amounts
A = shapes.Sphere(material=materials.Material(refractive_index=1.5,
transparency=1.0))
B = shapes.Sphere(material=materials.Material(refractive_index=2.0,
transparency=1.0))
C = shapes.Sphere(material=materials.Material(refractive_index=2.5,
transparency=1.0))
A.set_transform(transforms.Scale(2, 2, 2))
B.set_transform(transforms.Translate(0, 0, -0.25))
C.set_transform(transforms.Translate(0, 0, 0.25))
r = rays.Ray(points.Point(0, 0, -4), vectors.Vector(0, 0, 1))
xs = intersections.Intersections(intersections.Intersection(A, 2),
intersections.Intersection(B, 2.75),
intersections.Intersection(C, 3.25),
intersections.Intersection(B, 4.75),
intersections.Intersection(C, 5.25),
intersections.Intersection(A, 6))
expected_results = [
{
"n1": 1.0,
"n2": 1.5
},
{
"n1": 1.5,
"n2": 2.0
},
{
"n1": 2.0,
"n2": 2.5
},
{
"n1": 2.5,
"n2": 2.5
},
{
"n1": 2.5,
"n2": 1.5
},
{
"n1": 1.5,
"n2": 1.0
},
]
for index, expected in enumerate(expected_results):
comps = xs.intersections[index].precompute(r, all_intersections=xs)
self.assertDictEqual(expected, {"n1": comps.n1, "n2": comps.n2})
def test_pattern_transformation(self):
"""Test that pattern is affected by a pattern transform"""
shape = shapes.Sphere()
p = patterns.StripePattern(WHITE, BLACK)
p.set_transform(transforms.Scale(2, 2, 2))
self.assertEqual(p.pattern_at_shape(shape, points.Point(1.5, 0, 0)),
WHITE)
def test_pattern_object_transformation(self):
"""Test that pattern is affected by pattern and object transforms"""
shape = shapes.Sphere()
shape.set_transform(transforms.Scale(2, 2, 2))
p = patterns.StripePattern(WHITE, BLACK)
p.set_transform(transforms.Translate(0.5, 0, 0))
self.assertEqual(p.pattern_at_shape(shape, points.Point(2.5, 0, 0)),
WHITE)
def test_net(net):
for test_dir_img in test_lists:
test_loader = get_loader(test_dir_img,
img_size,
1,
mode='test',
num_thread=1)
print('''
Starting testing:
dataset: {}
Testing size: {}
'''.format(
test_dir_img.split('/')[-1], len(test_loader.dataset)))
for i, data_batch in enumerate(test_loader):
print('{}/{}'.format(i, len(test_loader.dataset)))
images, depths, image_w, image_h, image_path = data_batch
images, depths = Variable(images.cuda()), Variable(depths.cuda())
outputs_image, outputs_depth = net(images, depths)
_, _, _, _, _, imageBran_output = outputs_image
_, _, _, _, _, depthBran_output = outputs_depth
image_w, image_h = int(image_w[0]), int(image_h[0])
output_imageBran = F.sigmoid(imageBran_output)
output_depthBran = F.sigmoid(depthBran_output)
output_imageBran = output_imageBran.data.cpu().squeeze(0)
output_depthBran = output_depthBran.data.cpu().squeeze(0)
transform = trans.Compose(
[transforms.ToPILImage(),
trans.Scale((image_w, image_h))])
outputImageBranch = transform(output_imageBran)
outputDepthBranch = transform(output_depthBran)
dataset = image_path[0].split('RGBdDataset_processed')[1].split(
'/')[1]
filename = image_path[0].split('/')[-1].split('.')[0]
# save image branch output
save_test_path = save_test_path_root + dataset + '/' + test_model + '/'
if not os.path.exists(save_test_path):
os.makedirs(save_test_path)
outputImageBranch.save(
os.path.join(save_test_path, filename + '.png'))
def test_normal_at__transformed(self):
"""Test we can calculate normal vectors on a transformed sphere"""
s = shapes.Sphere()
s.set_transform(transforms.Translate(0, 1, 0))
n = s.normal_at(points.Point(0, 1.70711, -0.70711))
self.assertEqual(n, vectors.Vector(0, 0.70711, -0.70711))
s.set_transform(
transforms.Scale(1, 0.5, 1) * transforms.RotateZ(math.pi / 5))
n = s.normal_at(points.Point(0, math.sqrt(2) / 2, -math.sqrt(2) / 2))
self.assertEqual(n, vectors.Vector(0, 0.97014, -0.24254))
def test_ray_transforms(self):
"""Test that we can transform a ray"""
origin = points.Point(1, 2, 3)
direction = vectors.Vector(0, 1, 0)
r = rays.Ray(origin, direction)
r2 = r.transform(transforms.Translate(3, 4, 5))
self.assertEqual(r2.origin, points.Point(4, 6, 8))
self.assertEqual(r2.direction, vectors.Vector(0, 1, 0))
r3 = r.transform(transforms.Scale(2, 3, 4))
self.assertEqual(r3.origin, points.Point(2, 6, 12))
self.assertEqual(r3.direction, vectors.Vector(0, 3, 0))
def test_simple_scaling(self):
"""Test that we can scale a point"""
S = transforms.Scale(2, 3, 4)
p = points.Point(-4, 6, 8)
v = vectors.Vector(-4, 6, 8)
p2 = S * p
self.assertEqual(p2, points.Point(-8, 18, 32))
p3 = S * v
self.assertEqual(p3, vectors.Vector(-8, 18, 32))
p4 = S.inverse() * p
self.assertEqual(p4, points.Point(-2, 2, 2))
def test_intersections_with_transformed_ray__scaling(self):
"""Test we get the correct intersections after adding a scaling
to a shape
"""
s = shapes.Sphere()
s.set_transform(transforms.Scale(2, 2, 2))
r = rays.Ray(points.Point(0, 0, -5), vectors.Vector(0, 0, 1))
result = s.intersect(r)
self.assertEqual(result.intersections[0].t, 3)
self.assertEqual(result.intersections[1].t, 7)
self.assertEqual(result.intersections[0].shape, s)
self.assertEqual(result.intersections[1].shape, s)
def main():
in_z = 0
test_volpath = os.path.join(args.datapath, 'test')
out_file = os.path.join(args.datapath, 'fakes')
checkpoint_path = os.path.join(args.datapath, 'checkpoint.pth')
test_segpath = test_volpath
double_vol = False
model = models.Net23(2)
cuda = args.cuda
if cuda:
model.cuda()
model.load_state_dict(torch.load(checkpoint_path))
batch_size = args.batch_size
orig_dim = 256
sqr = transforms.Square()
center = transforms.CenterCrop2(224)
scale = transforms.Scale(orig_dim)
transform_plan = [sqr, scale, center]
num_labels = 2
series_names = ['Mag']
seg_series_names = ['AV']
f = preprocess.gen_filepaths(test_segpath)
mult_inds = []
for i in f:
if 'volume' in i:
mult_inds.append(int(re.findall('\d+', i)[0]))
mult_inds = sorted(mult_inds)
mult_inds = np.unique(mult_inds)
mult_inds = mult_inds[0:5]
volpaths, segpaths = utils.get_paths(mult_inds, f, series_names, \
seg_series_names, test_volpath, test_segpath)
out = utils.test_net_cheap(mult_inds, in_z, model,\
transform_plan, orig_dim, batch_size, out_file, num_labels,\
volpaths, segpaths, nrrd=True, vol_only=double_vol,\
get_dice=True, make_niis=False, cuda=cuda)
out_csv = os.path.join(args.datapath, 'out.csv')
out.to_csv(out_csv, index=False)
def __init__(self, data_path, split, augment=True, load_everything=True):
self.count = 0
file_path = os.path.join(data_path, 'miniplaces_256_{}.h5'.format(split))
self.dataset = h5py.File(file_path)
self.normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = [
transforms.Scale(256),
transforms.RandomCrop(224),
# transforms.RandomResizedCrop(224)
]
if augment:
transform.extend([
transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05),
transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
])
transform += [transforms.ToTensor()]
if augment:
transform.append(
affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant')
)
# if augment:
# transform.append(
# affine_transforms.Affine(rotation_range=10.0, translation_range=0.1, zoom_range=(0.5, 1.0), fill_mode='constant')
# )
transform += [
self.normalize]
self.preprocess = transforms.Compose(transform)
self.split = split
if split != 'test':
self.labels = np.array(self.dataset['labels'])
self.load_everything = load_everything
if self.load_everything:
self.images = np.array(self.dataset['images'])
def setUp(self):
"""Set up a default scene for quick testing"""
# Inner sphere size 0.5, centered on the origin
self.s1 = shapes.Sphere()
self.s1.set_transform(transforms.Scale(0.5, 0.5, 0.5))
# Outer sphere centered on the origin, size 1.0
self.s2 = shapes.Sphere()
self.s2.material = materials.Material(color=colors.Color(
0.8, 1.0, 0.6),
diffuse=0.7,
specular=0.2)
self.l1 = lights.Light(position=points.Point(-10, 10, -10),
intensity=colors.Color(1, 1, 1))
self.default_scene = scenes.Scene(objects=[self.s1, self.s2],
lights=[self.l1])
def main():
######### configs ###########
best_metric = 0
pretrain_deeplab_path = os.path.join(configs.py_dir, 'model/deeplab_coco.pth')
###### load datasets ########
train_transform_det = trans.Compose([
trans.Scale((321, 321)),
])
val_transform_det = trans.Compose([
trans.Scale((321,321)),
])
train_data = voc_dates.VOCDataset(configs.train_img_dir,configs.train_label_dir,
configs.train_txt_dir,'train',transform=True,
transform_med = train_transform_det)
train_loader = Data.DataLoader(train_data,batch_size=configs.batch_size,
shuffle= True, num_workers= 4, pin_memory= True)
val_data = voc_dates.VOCDataset(configs.val_img_dir,configs.val_label_dir,
configs.val_txt_dir,'val',transform=True,
transform_med = val_transform_det)
val_loader = Data.DataLoader(val_data, batch_size= configs.batch_size,
shuffle= False, num_workers= 4, pin_memory= True)
###### build models ########
deeplab = models.deeplab()
deeplab_pretrain_model = utils.load_deeplab_pretrain_model(pretrain_deeplab_path)
deeplab.init_parameters(deeplab_pretrain_model)
deeplab = deeplab.cuda()
params = list(deeplab.parameters())
#########
if resume:
checkpoint = torch.load(configs.best_ckpt_dir)
deeplab.load_state_dict(checkpoint['state_dict'])
print('resum sucess')
######### optimizer ##########
######## how to set different learning rate for differern layer #########
optimizer = torch.optim.SGD(
[
{'params': get_parameters(deeplab, bias=False)},
{'params': get_parameters(deeplab, bias=True),
'lr': configs.learning_rate * 2, 'weight_decay': 0},
],lr=configs.learning_rate, momentum=configs.momentum,weight_decay=configs.weight_decay)
######## iter img_label pairs ###########
for epoch in range(20):
utils.adjust_learning_rate(configs.learning_rate,optimizer,epoch)
for batch_idx, batch in enumerate(train_loader):
img_idx, label_idx, filename,height,width = batch
img,label = Variable(img_idx.cuda()),Variable(label_idx.cuda())
prediction,weights = deeplab(img)
loss = utils.cross_entropy2d(prediction,label,size_average=False)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (batch_idx) % 20 == 0:
print("Epoch [%d/%d] Loss: %.4f" % (epoch, batch_idx, loss.data[0]))
if (batch_idx) % 4000 == 0:
current_metric = validate(deeplab, val_loader, epoch)
print current_metric
current_metric = validate(deeplab, val_loader,epoch)
if current_metric > best_metric:
torch.save({'state_dict': deeplab.state_dict()},
os.path.join(configs.save_ckpt_dir, 'deeplab' + str(epoch) + '.pth'))
shutil.copy(os.path.join(configs.save_ckpt_dir, 'deeplab' + str(epoch) + '.pth'),
os.path.join(configs.save_ckpt_dir, 'model_best.pth'))
best_metric = current_metric
if epoch % 5 == 0:
torch.save({'state_dict': deeplab.state_dict()},
os.path.join(configs.save_ckpt_dir, 'deeplab' + str(epoch) + '.pth'))
def main():
configs = config.VOC_config()
transform_det = trans.Compose([
trans.Scale((321, 321)),
])
pretrain_model = os.path.join(configs.save_ckpt_dir,
'deeplab_model_best_iu0.57.pth')
test_data = dates.VOCDataset(configs.val_img_dir,
configs.val_label_dir,
configs.val_txt_dir,
'val',
transform=True,
transform_med=transform_det)
test_loader = Data.DataLoader(test_data,
batch_size=configs.batch_size,
shuffle=False,
num_workers=4,
pin_memory=True)
######### build vgg model ##########
deeplab = models.deeplab()
deeplab = deeplab.cuda()
checkpoint = torch.load(pretrain_model)
deeplab.load_state_dict(checkpoint['state_dict'])
params = list(deeplab.parameters())
save_pred_dir = os.path.join(configs.save_pred_dir, 'weights')
if not os.path.exists(save_pred_dir):
os.mkdir(save_pred_dir)
deeplab.eval()
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
finalconv_name = 'conv5' # this is the last conv layer of the network
deeplab._modules.get(finalconv_name).register_forward_hook(hook_feature)
for batch_idx, batch in enumerate(test_loader):
inputs, targets, filename, height, width = batch
inputs, targets = inputs.cuda(), targets.cuda()
height, width, filename = height.numpy()[0], width.numpy(
)[0], filename[0]
transformed_img = inputs.cpu().numpy()[0]
transformed_img = untransform(transformed_img)
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
outputs, cnn_features = deeplab(inputs)
transforms_rgb_rescal = cv2.resize(transformed_img, (width, height))
#conv5_features = features_blobs[-1]
#cnn_features_numpy = cnn_features.data.cpu().numpy()
weights = weights_generation(cnn_features)
save_weights_dir = os.path.join(save_pred_dir, filename)
if batch_idx < 10:
weights_numpy = weights.data.cpu().numpy()
loc_weights = utils.attention_weights_collection(weights_numpy)
utils.attention_weights_visulize(loc_weights,
transforms_rgb_rescal,
save_weights_dir)
else:
break
def main_tr(args, crossVal):
dataLoad = ld.LoadData(args.data_dir, args.classes)
data = dataLoad.processData(crossVal, args.data_name)
# load the model
model = net.MiniSeg(args.classes, aux=True)
if not osp.isdir(osp.join(args.savedir + '_mod' + str(args.max_epochs))):
os.mkdir(args.savedir + '_mod' + str(args.max_epochs))
if not osp.isdir(
osp.join(args.savedir + '_mod' + str(args.max_epochs),
args.data_name)):
os.mkdir(
osp.join(args.savedir + '_mod' + str(args.max_epochs),
args.data_name))
saveDir = args.savedir + '_mod' + str(
args.max_epochs) + '/' + args.data_name + '/' + args.model_name
# create the directory if not exist
if not osp.exists(saveDir):
os.mkdir(saveDir)
if args.gpu and torch.cuda.device_count() > 1:
#model = torch.nn.DataParallel(model)
model = DataParallelModel(model)
if args.gpu:
model = model.cuda()
total_paramters = sum([np.prod(p.size()) for p in model.parameters()])
print('Total network parameters: ' + str(total_paramters))
# define optimization criteria
weight = torch.from_numpy(
data['classWeights']) # convert the numpy array to torch
if args.gpu:
weight = weight.cuda()
criteria = CrossEntropyLoss2d(weight, args.ignore_label) #weight
if args.gpu and torch.cuda.device_count() > 1:
criteria = DataParallelCriterion(criteria)
if args.gpu:
criteria = criteria.cuda()
# compose the data with transforms
trainDataset_main = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(args.width, args.height),
myTransforms.RandomCropResize(int(32. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale1 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 1.5), int(args.height * 1.5)),
myTransforms.RandomCropResize(int(100. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale2 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 1.25), int(args.height * 1.25)),
myTransforms.RandomCropResize(int(100. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale3 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 0.75), int(args.height * 0.75)),
myTransforms.RandomCropResize(int(32. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
valDataset = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(args.width, args.height),
myTransforms.ToTensor()
])
# since we training from scratch, we create data loaders at different scales
# so that we can generate more augmented data and prevent the network from overfitting
trainLoader = torch.utils.data.DataLoader(myDataLoader.Dataset(
data['trainIm'], data['trainAnnot'], transform=trainDataset_main),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale1 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale1),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale2 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale2),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale3 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale3),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
valLoader = torch.utils.data.DataLoader(myDataLoader.Dataset(
data['valIm'], data['valAnnot'], transform=valDataset),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
pin_memory=True)
max_batches = len(trainLoader) + len(trainLoader_scale1) + len(
trainLoader_scale2) + len(trainLoader_scale3)
if args.gpu:
cudnn.benchmark = True
start_epoch = 0
if args.pretrained is not None:
state_dict = torch.load(args.pretrained)
new_keys = []
new_values = []
for idx, key in enumerate(state_dict.keys()):
if 'pred' not in key:
new_keys.append(key)
new_values.append(list(state_dict.values())[idx])
new_dict = OrderedDict(list(zip(new_keys, new_values)))
model.load_state_dict(new_dict, strict=False)
print('pretrained model loaded')
if args.resume is not None:
if osp.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
args.lr = checkpoint['lr']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
log_file = osp.join(saveDir, 'trainValLog_' + args.model_name + '.txt')
if osp.isfile(log_file):
logger = open(log_file, 'a')
else:
logger = open(log_file, 'w')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write("\n%s\t%s\t\t%s\t%s\t%s\t%s\tlr" %
('CrossVal', 'Epoch', 'Loss(Tr)', 'Loss(val)',
'mIOU (tr)', 'mIOU (val)'))
logger.flush()
optimizer = torch.optim.Adam(model.parameters(),
args.lr, (0.9, 0.999),
eps=1e-08,
weight_decay=1e-4)
maxmIOU = 0
maxEpoch = 0
print(args.model_name + '-CrossVal: ' + str(crossVal + 1))
for epoch in range(start_epoch, args.max_epochs):
# train for one epoch
cur_iter = 0
train(args, trainLoader_scale1, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale1)
train(args, trainLoader_scale2, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale2)
train(args, trainLoader_scale3, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale3)
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr, lr = \
train(args, trainLoader, model, criteria, optimizer, epoch, max_batches, cur_iter)
# evaluate on validation set
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = \
val(args, valLoader, model, criteria)
torch.save(
{
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
'lr': lr
},
osp.join(
saveDir, 'checkpoint_' + args.model_name + '_crossVal' +
str(crossVal + 1) + '.pth.tar'))
# save the model also
model_file_name = osp.join(
saveDir, 'model_' + args.model_name + '_crossVal' +
str(crossVal + 1) + '_' + str(epoch + 1) + '.pth')
torch.save(model.state_dict(), model_file_name)
logger.write(
"\n%d\t\t%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.7f" %
(crossVal + 1, epoch + 1, lossTr, lossVal, mIOU_tr, mIOU_val, lr))
logger.flush()
print("\nEpoch No. %d:\tTrain Loss = %.4f\tVal Loss = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f\n" \
% (epoch + 1, lossTr, lossVal, mIOU_tr, mIOU_val))
if mIOU_val >= maxmIOU:
maxmIOU = mIOU_val
maxEpoch = epoch + 1
torch.cuda.empty_cache()
logger.flush()
logger.close()
return maxEpoch, maxmIOU
from PIL import Image
import transforms
size = 64
channel = 3
max_no = 202599
img_key = 'img_raw'
file_tpl = '%6d.jpg'
home_dir = os.path.expanduser('~')
celeb_source = os.path.join(home_dir, "Pictures/img_align_celeba")
default_attribs = {img_key: tf.FixedLenFeature([], tf.string)}
default_transf = transforms.Compose([
transforms.Scale(size),
transforms.CenterCrop(size),
transforms.ToFloat(),
transforms.Normalize(0.5, 0.5)
])
def process_celebA(dest='celebA',
celeb_source=celeb_source,
force=False,
transform=default_transf,
files=None):
dest_file = '%s.tfr' % dest
if os.path.exists(dest_file) and not force:
return dest_file
def get_loader(img_root,
label_root,
img_size,
batch_size,
mode='train',
num_thread=1):
shuffle = False
mean = torch.Tensor(3, 256, 256)
mean[0, :, :] = 125.5325
mean[1, :, :] = 118.1743
mean[2, :, :] = 101.3507
# mean = torch.Tensor([123.68, 116.779, 103.939]).view(3, 1, 1) / 255
if mode == 'train':
transform = trans.Compose([
trans.Scale((img_size, img_size)),
# trans.ToTensor image -> [0,255]
trans.ToTensor(),
trans.Lambda(lambda x: x - mean)
])
t_transform = trans.Compose([
trans.Scale((img_size, img_size)),
# transform.ToTensor label -> [0,1]
transforms.ToTensor(),
# transforms.Lambda(lambda x: torch.round(x)) # TODO: it maybe unnecessary
])
label_32_transform = trans.Compose([
trans.Scale((32, 32)),
transforms.ToTensor(),
])
label_64_transform = trans.Compose([
trans.Scale((64, 64)),
transforms.ToTensor(),
])
label_128_transform = trans.Compose([
trans.Scale((128, 128)),
transforms.ToTensor(),
])
shuffle = True
else:
# define transform to images
transform = trans.Compose([
trans.Scale((img_size, img_size)),
trans.ToTensor(),
trans.Lambda(lambda x: x - mean)
])
# define transform to ground truth
t_transform = trans.Compose([
trans.Scale((img_size, img_size)),
transforms.ToTensor(),
#transforms.Lambda(lambda x: torch.round(x)) # TODO: it maybe unnecessary
])
if mode == 'train':
dataset = ImageData(img_root, label_root, transform, t_transform,
label_32_transform, label_64_transform,
label_128_transform)
# print(dataset.image_path)
data_loader = data.DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_thread)
return data_loader
else:
dataset = ImageData(img_root,
label_root,
transform,
t_transform,
label_32_transform=None,
label_64_transform=None,
label_128_transform=None)
# print(dataset.image_path)
data_loader = data.DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_thread)
return data_loader
def main():
######### config ###########
best_metric = 0
pretrain_vgg16_path = os.path.join(configs.py_dir,
'model/vgg16_from_caffe.pth')
######## load training data ########
######### action 40 ############
normalize = trans.Normalize(mean=[0.4001, 0.4401, 0.4687],
std=[0.229, 0.224, 0.225])
#std=[1, 1, 1])
train_transform = trans.Compose([
trans.RandomCrop(224, padding=4),
trans.RandomHorizontalFlip(),
trans.ToTensor(),
normalize,
])
val_transform = trans.Compose([
trans.Scale((224, 224)),
trans.ToTensor(),
normalize,
])
train_data = imgfolder.ImageFolder(os.path.join(configs.data_dir,
'img/train'),
transform=train_transform)
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=configs.batch_size,
shuffle=True,
num_workers=4,
pin_memory=True)
val_data = imgfolder.ImageFolder(os.path.join(configs.data_dir, 'img/val'),
transform=val_transform)
val_loader = Data.DataLoader(val_data,
batch_size=configs.batch_size,
shuffle=False,
num_workers=4,
pin_memory=True)
######### build vgg model ##########
vgg_cam = models.vgg_cam()
vgg_pretrain_model = utils.load_pretrain_model(pretrain_vgg16_path)
vgg_cam.copy_params_from_pretrain_vgg(vgg_pretrain_model,
init_fc8=configs.init_random_fc8)
vgg_cam = vgg_cam.cuda()
######## resume ###########
if resume:
checkpoint = torch.load(
'/media/cheer/2T/train_pytorch/cam/ckpt/model_best.pth')
vgg_cam.load_state_dict(checkpoint['state_dict'])
########## optim ###########
optimizer = torch.optim.SGD(vgg_cam.parameters(),
lr=configs.learning_rate,
momentum=configs.momentum,
weight_decay=configs.weight_decay)
#optimizer = torch.optim.Adam(vgg_cam.parameters(),lr=configs.learning_rate,weight_decay=configs.weight_decay)
loss_fun = nn.CrossEntropyLoss()
for epoch in range(200):
adjust_learning_rate(optimizer, epoch)
for step, (img_x, label_x) in enumerate(train_loader):
img, label = Variable(img_x.cuda()), Variable(label_x.cuda())
predict, _ = vgg_cam(img)
loss = loss_fun(predict, label)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (step) % 20 == 0:
print("Epoch [%d/%d] Loss: %.4f" % (epoch, step, loss.data[0]))
current_metric = test(vgg_cam, val_loader, loss_fun)
if current_metric > best_metric:
torch.save({'state_dict': vgg_cam.state_dict()},
os.path.join(configs.save_ckpt_dir,
'cam' + str(epoch) + '.pth'))
shutil.copy(
os.path.join(configs.save_ckpt_dir,
'cam' + str(epoch) + '.pth'),
os.path.join(configs.save_ckpt_dir, 'model_best.pth'))
best_metric = current_metric
if epoch % 10 == 0:
torch.save({'state_dict': vgg_cam.state_dict()},
os.path.join(configs.save_ckpt_dir,
'cam' + str(epoch) + '.pth'))
def main():
in_z = 0
volpath = os.path.join(args.datapath, 'train')
segpath = volpath
batch_size = args.batch_size
orig_dim = 256
sqr = transforms.Square()
aff = transforms.Affine()
crop = transforms.RandomCrop(224)
scale = transforms.Scale(orig_dim)
rotate = transforms.Rotate(0.5, 30)
noise = transforms.Noise(0.02)
flip = transforms.Flip()
transform_plan = [sqr, scale, aff, rotate, crop, flip, noise]
lr = 1e-4
series_names = ['Mag']
seg_series_names = ['AV']
model = models.Net23(2)
model.cuda()
optimizer = optim.RMSprop(model.parameters(), lr=lr)
out_z, center_crop_sz = utils.get_out_size(orig_dim, in_z,\
transform_plan, model)
t0 = time.time()
counter = 0
print_interval = args.log_interval
model.train()
for i in range(200000000000000000000000000000000):
weight = torch.FloatTensor([0.2, 0.8]).cuda()
vol, seg, inds = preprocess.get_batch(volpath, segpath, batch_size, in_z,\
out_z, center_crop_sz, series_names, seg_series_names,\
transform_plan, 8, nrrd=True)
vol = torch.unsqueeze(vol, 1)
vol = Variable(vol).cuda()
seg = Variable(seg).cuda()
out = model(vol).squeeze()
loss = F.cross_entropy(out, seg, weight=weight)
optimizer.zero_grad()
loss.backward()
optimizer.step()
counter += 1
sys.stdout.write('\r{:.2f}%'.format(counter * batch_size /
print_interval))
sys.stdout.flush()
if counter * batch_size >= print_interval and i > 0:
seg_hot = utils.get_hot(seg.data.cpu().numpy(), out.size()[-3])
seg_hot = np.transpose(seg_hot, axes=[1, 0, 2, 3])
out_hot = np.argmax(out.data.cpu().numpy(), axis=1)
out_hot = utils.get_hot(out_hot, out.size()[-3])
out_hot = np.transpose(out_hot, axes=[1, 0, 2, 3])
dce2 = utils.dice(seg_hot[:, 1:], out_hot[:, 1:])
vol_ind = utils.get_liver(seg)
v = vol.data.cpu().numpy()[vol_ind].squeeze()
real_seg = seg[vol_ind].data.cpu().numpy()
out_plt = out.data.cpu().numpy()[vol_ind]
out_plt = np.argmax(out_plt, axis=0)
fake_seg = out_plt
masked_real = utils.makeMask(v, real_seg, out.size()[-3], 0.5)
masked_fake = utils.makeMask(v, fake_seg, out.size()[-3], 0.5)
fig = plt.figure(1)
fig.suptitle('Volume {} ; Dice = {:.2f}'.format(\
inds[vol_ind],dce2))
v = fig.add_subplot(1, 2, 1)
v.set_title('real')
plt.imshow(masked_real)
sreal = fig.add_subplot(1, 2, 2)
sreal.set_title('fake')
plt.imshow(masked_fake)
outfile = os.path.join(args.datapath, 'out.png')
plt.savefig(outfile, dpi=200)
plt.clf()
print(('\rIteration {}: Block completed in {:.2f} sec ; Loss = {:.2f}')\
.format(i*batch_size,time.time()-t0, loss.data.cpu()[0]))
checkpoint_file = os.path.join(args.datapath,\
'model_checkpoint.pth')
torch.save(model.state_dict(), checkpoint_file)
counter = 0
t0 = time.time()
batch_size = 24
checkpoint_path = 'path to model checkpoint'
test_volpath = 'path to test volumes'
test_segpath = 'path to test segmentations'
num_labels = 3 #labels: lateral annulus, medial annulus, background
crop_size = 224
original_size = 256
out_file = 'path to store output'
################################################################
sqr = transforms.Square()
center = transforms.CenterCrop2(crop_size)
scale = transforms.Scale(original_size)
transform_plan = [sqr, scale, center]
series_names = ['echo']
seg_series_names = ['echo']
model = models.Net23(num_labels)
model.cuda()
model.load_state_dict(torch.load(checkpoint_path))
f_s = preprocess.gen_filepaths(test_segpath)
f_v = preprocess.gen_filepaths(test_volpath)
mult_inds = []
for i in f_s:
if 'segmentation' in i:
def get_loader(img_root, img_size, batch_size, mode='train', num_thread=1):
shuffle = False
mean_bgr = torch.Tensor(3, 256, 256)
mean_bgr[0, :, :] = 104.008 # B
mean_bgr[1, :, :] = 116.669 # G
mean_bgr[2, :, :] = 122.675 # R
depth_mean_bgr = torch.Tensor(1, 256, 256)
depth_mean_bgr[0, :, :] = 115.8695
if mode == 'train':
transform = trans.Compose([
# trans.ToTensor image -> [0,255]
trans.ToTensor_BGR(),
trans.Lambda(lambda x: x - mean_bgr)
])
depth_transform = trans.Compose([
# trans.ToTensor image -> [0,255]
trans.ToTensor(),
trans.Lambda(lambda x: x - depth_mean_bgr)
])
t_transform = trans.Compose([
# transform.ToTensor label -> [0,1]
transforms.ToTensor(),
])
label_32_transform = trans.Compose([
trans.Scale((32, 32), interpolation=Image.NEAREST),
transforms.ToTensor(),
])
label_64_transform = trans.Compose([
trans.Scale((64, 64), interpolation=Image.NEAREST),
transforms.ToTensor(),
])
label_128_transform = trans.Compose([
trans.Scale((128, 128), interpolation=Image.NEAREST),
transforms.ToTensor(),
])
shuffle = True
else:
transform = trans.Compose([
trans.Scale((img_size, img_size)),
trans.ToTensor_BGR(),
trans.Lambda(lambda x: x - mean_bgr)
])
depth_transform = trans.Compose([
trans.Scale((img_size, img_size)),
trans.ToTensor(),
trans.Lambda(lambda x: x - depth_mean_bgr)
])
t_transform = trans.Compose([
trans.Scale((img_size, img_size), interpolation=Image.NEAREST),
transforms.ToTensor(),
])
if mode == 'train':
dataset = ImageData(img_root, transform, depth_transform, t_transform, label_32_transform, label_64_transform, label_128_transform, mode)
else:
dataset = ImageData(img_root, transform, depth_transform, t_transform, label_32_transform=None, label_64_transform=None, label_128_transform=None, mode=mode)
data_loader = data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_thread)
return data_loader
def main():
######## load training data ########
######### action 40 ############
normalize = trans.Normalize(mean=[0.4001, 0.4401, 0.4687],
std=[0.229, 0.224, 0.225])
transform = trans.Compose([
trans.Scale((224, 224)),
trans.ToTensor(),
normalize,
])
test_data = imgfolder.ImageFolder(os.path.join(configs.data_dir,
'img/test'),
transform=transform)
test_loader = Data.DataLoader(test_data,
batch_size=configs.batch_size,
shuffle=False,
num_workers=4,
pin_memory=True)
classes = {
int(key): value
for (key, value) in parse_json(configs.class_info_dir).items()
}
######### build vgg model ##########
vgg_cam = models.vgg_cam()
vgg_cam = vgg_cam.cuda()
checkpoint = torch.load(configs.best_ckpt_dir)
vgg_cam.load_state_dict(checkpoint['state_dict'])
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
finalconv_name = 'classifier' # this is the last conv layer of the network
vgg_cam._modules.get(finalconv_name).register_forward_hook(hook_feature)
# get the softmax weight
params = list(vgg_cam.parameters())
weight_softmax = np.squeeze(params[-1].data.cpu().numpy())
save_cam_dir = os.path.join(configs.py_dir, 'predict')
if not os.path.exists(save_cam_dir):
os.mkdir(save_cam_dir)
top_number = 5
correct = 0
total = 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
inputs, targets = inputs.cuda(), targets.cuda()
transformed_img = inputs.cpu().numpy()[0]
target_name = classes[targets.cpu().numpy()[0]]
transformed_img = untransform(transformed_img)
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
outputs, _ = vgg_cam(inputs)
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
h_x = F.softmax(outputs).data.squeeze()
probs, idx = h_x.sort(0, True)
prob = probs.cpu().numpy()[:top_number]
idx_ = idx.cpu().numpy()[:top_number]
OUT_CAM = returnCAM(features_blobs[-1], weight_softmax, idx_, prob)
save_fig_dir = os.path.join(save_cam_dir,
'cam_' + str(batch_idx) + '.jpg')
plt.figure(1, figsize=(8, 6))
ax = plt.subplot(231)
img1 = transformed_img[:, :, (2, 1, 0)]
ax.set_title(('{}').format(target_name), fontsize=14)
ax.imshow(img1)
for b_index, (idx, prob_in, cam) in enumerate(zip(idx_, prob,
OUT_CAM)):
cl = str(classes[idx])
#save_fig_dir1 = os.path.join(save_cam_dir, 'cam_cv_' + str(batch_idx) + '_' + cl + '.jpg')
height, width, _ = transformed_img.shape
heatmap = cv2.applyColorMap(cv2.resize(cam, (width, height)),
cv2.COLORMAP_JET)
result = heatmap * 0.3 + transformed_img * 0.7
ax = plt.subplot(2, 3, b_index + 2)
ax.imshow(result.astype(np.uint8)[:, :, (2, 1, 0)])
ax.set_title(('{}:{}').format(cl, ('%.3f' % prob_in)), fontsize=8)
plt.savefig(save_fig_dir)
print batch_idx
print(100. * correct / total)
model.load_state_dict(snapshot['model'])
# If this doesn't work, can use optimizer.load_state_dict
# optimizer.load_state_dict(snapshot['optimizer'])
print('==> snapshot "{0}" loaded (epoch {1})'.format(
args.path, epoch))
else:
raise FileNotFoundError('no snapshot found at "{0}"'.format(
args.path))
else:
epoch = 0
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
preprocess = transforms.Compose([
transforms.Scale(256),
transforms.RandomCrop(224),
transforms.ColorJitter(brightness=0.1,
contrast=0.0,
saturation=0.3,
hue=0.05),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
affine_transforms.Affine(rotation_range=5.0,
zoom_range=(0.85, 1.0),
fill_mode='constant'), normalize
])
# testing the model
images = np.load('./preprocess/miniplaces_256_test.npz')['arr_0']
# print(images.files)
'checkpoint':'60000',
'val_size': [800, 288],
'save_results': True,
'deep_base': True,
}
mean = [0.3598, 0.3653, 0.3662]
std = [0.2573, 0.2663, 0.2756]
img_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
mask_transform = extend_transforms.MaskToTensor()
to_pil = transforms.ToPILImage()
val_joint_transform = extend_transforms.Scale(args['val_size'])
criterion = torch.nn.CrossEntropyLoss(weight=torch.Tensor([0.4, 1, 1, 1, 1]).cuda(), size_average=True,
ignore_index=culane.ignore_label)
criterion = criterion.cuda()
def main():
net = Baseline(num_classes=culane.num_classes, deep_base=args['deep_base']).cuda()
print('load checkpoint \'%s.pth\' for evaluation' % args['checkpoint'])
pretrained_dict = torch.load(os.path.join(ckpt_path, exp_name, args['checkpoint'] + '_checkpoint.pth'))
pretrained_dict = {k[7:]: v for k, v in pretrained_dict.items()}
net.load_state_dict(pretrained_dict)
