def summarize(self):
# Print summary of model
summary(self, (3, 32, 32))
return
def print_summary(self):
print('Model Summary')
summary(self, input_size=(3, 224, 224))
print('\n')
def test():
model = UNetResNetV6(34, num_filters=32, inchannel=3).cuda()
# inputs = torch.randn(2,3,128,128)
summary(model, (3, 128, 128))
dataset = PlanDataset(root_dir="data/deep_cardinality")
dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
train_size = int(len(dataset) * 0.8)
test_size = len(dataset) - train_size
# train_temp = [dataset[i] for i in range(10)]
# test_temp = [dataset[i] for i in range(5)]
train_dataset, test_dataset = random_split(dataset, [train_size, test_size])
# train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True, num_workers=2)
# test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=2)
encoder = Encoder(d_feature=9 + 6 + 64, d_model=256, d_ff=128, N=4).double()
summary(encoder)
criterion = nn.MSELoss()
optimizer = optim.Adam(encoder.parameters(), lr=0.001)
epoch_size = 2
def train():
result = []
for epoch in range(epoch_size):
print("epoch : ", epoch)
running_loss = 0.0
for i, data in enumerate(train_dataset):
tree, nodemat, leafmat, label = data
optimizer.zero_grad()
import torch
from torchsummary import summary
from nets.yolo3 import YoloBody
from utils.config import Config
if __name__ == "__main__":
# 需要使用device来指定网络在GPU还是CPU运行
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
config = {
"model_params": {
"backbone_name": "darknet_53"
},
"yolo": {
"anchors": [[1, 2, 3], [2, 3, 4], [3, 4, 5]],
"classes": 80
}
}
m = YoloBody(config).to(device)
summary(m, input_size=(3, 416, 416))
nn.Linear(500, 500),
nn.BatchNorm1d(500),
nn.ReLU(),
# ------------------------------------------------------
nn.Linear(500, 500),
nn.BatchNorm1d(500),
nn.ReLU(),
# ------------------------------------------------------
nn.Linear(500, 50),
nn.BatchNorm1d(50),
nn.ReLU(),
# ------------------------------------------------------
nn.Linear(50, out_num),
nn.ReLU6())
def forward(self, x):
x = self.FC(x)
return x / 6
if __name__ == '__main__':
import torchsummary
if torch.cuda.is_available():
generator = GeneratorNet().cuda()
else:
generator = GeneratorNet()
params = list(generator.parameters())
print(len(params))
torchsummary.summary(generator, tuple([29]))
def train(args):
# Setup Dataloader ============================================================
data_loader_seg = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
v_loader = data_loader_seg(data_path, is_transform=True, split='val', img_size=(args.img_rows, args.img_cols), \
img_norm=args.img_norm)
n_classes = v_loader.n_classes
valloader = data.DataLoader(v_loader, batch_size=1, num_workers=8) \
# IN VALIDATION WE CALCULATE ALL OF THE IMAGES ONE BY ONE => MADE BATCH SIZE 1 PREVIOUSLY IT WAS BATCHSIZE
# Setup Metrics =================================
running_metrics = runningScore(n_classes)
# Setup Model=======================================================================================================
model_features = get_model('resnet', n_classes)
model_segment = get_model('segment', n_classes)
model_reconstruct = get_model('reconstruct', n_classes=3)
model_depth = get_model('depth', n_classes=1)
#move model to cuda
model_features = torch.nn.DataParallel(model_features,
device_ids=range(
torch.cuda.device_count()))
model_features.cuda()
model_segment = torch.nn.DataParallel(model_segment,
device_ids=range(
torch.cuda.device_count()))
model_segment.cuda()
model_reconstruct = torch.nn.DataParallel(model_reconstruct,
device_ids=range(
torch.cuda.device_count()))
model_reconstruct.cuda()
model_depth = torch.nn.DataParallel(model_depth,
device_ids=range(
torch.cuda.device_count()))
model_depth.cuda()
#Initializer.initialize(model=model_segment, initialization=init.xavier_uniform)
#print the model outputs
summary(model_features, (3, args.img_rows, args.img_cols))
summary(model_segment, (512, 8, 16))
#summary(model_reconstruct, (512, 8, 16))
#summary(model_classify, (512, 8, 16))
# Load the pretrained =============================================================================================
if args.resume_feature:
print("Loading model and optimizer from checkpoint '{}'".format(
args.resume_feature))
# FEATURE NETWORK
checkpoint_feature = torch.load(args.resume_feature)
model_features.load_state_dict(checkpoint_feature['model_state'])
print("Loaded checkpoint '{}' (epoch {})".format(
args.resume_feature, checkpoint_feature['epoch']))
if args.resume_segment:
print("Loading model and optimizer from checkpoint '{}'".format(
args.resume_segment))
# SEGMENTATION NETWORK
checkpoint_segment = torch.load(args.resume_segment)
model_segment.load_state_dict(checkpoint_segment['model_state'],
strict=False)
print("Loaded checkpoint '{}' (epoch {})".format(
args.resume_segment, checkpoint_segment['epoch']))
if args.resume_reconstruct:
print("Loading model and optimizer from checkpoint '{}'".format(
args.resume_reconstruct))
# RECONSTRUCTION NETWORK
checkpoint_reconstruct = torch.load(args.resume_reconstruct)
model_reconstruct.load_state_dict(
checkpoint_reconstruct['model_state'], strict=False)
print("Loaded checkpoint '{}' (epoch {})".format(
args.resume_reconstruct, checkpoint_reconstruct['epoch']))
if args.resume_depth:
# DEPTH NETWORK
checkpoint_depth = torch.load(args.resume_depth)
model_depth.load_state_dict(checkpoint_depth['model_state'],
strict=False)
print("Loaded checkpoint '{}' (epoch {})".format(
args.resume_depth, checkpoint_depth['epoch']))
png_jpg_flag = args.quality #0 means PNG, 95, 90, 85, 80 mean the JPG quantization
# START Testing ===================================================================================================
model_features.eval()
model_segment.eval()
model_reconstruct.eval()
model_depth.eval()
for i_val, (images_val, labels_val, obj_label_val,
images_val_not_normalized,
depth_val) in (enumerate(valloader)): #tqdm
images_val = Variable(images_val.cuda(), volatile=True)
images_val_not_normalized = Variable(images_val_not_normalized.cuda(),
volatile=True)
labels_val = Variable(labels_val.cuda(), volatile=True)
depth_val = Variable(depth_val.cuda(), volatile=True)
#feed forward -> features
features_val = model_features(images_val)
# Quantization (returns the integer features in the range of 0-255)
features_val, features_val_255, max_to_encode, min_to_encode = Quantize_center_VALIDATION(
features_val)
features_val_255_numpy = features_val_255.data.cpu().numpy()
#Dumping
featue_file_name = './dumped_features/temp/val_comp' + str(
i_val) # +'.bin'
features_val = dump_feature_2D(features_val_255_numpy,
featue_file_name, max_to_encode,
min_to_encode, png_jpg_flag)
#==========================================================
# feed forward -> Tasks
outputs_segment_val = model_segment(features_val)
outputs_reconstruct_val = model_reconstruct(features_val)
outputs_depth_val = model_depth(features_val)
gt_label = labels_val.data.cpu().numpy()
pred_label = outputs_segment_val.data.max(1)[1].cpu().numpy()
depth_val_gt = depth_val.data.cpu().numpy()
depth_val_pred = outputs_depth_val.data.cpu().numpy()
depth_val_pred = depth_val_pred[0, :, :, :]
# Visualize
if args.visualize:
#depth_val_pred = depth_val_pred[0,:,:,:]
depth_val_pred_plt = depth_val_pred.transpose((1, 2, 0))
depth_val_pred_plt = depth_val_pred_plt[:, :,
0] #np.squeeze(depth_val_pred, axis=2)
depth_val_gt_plt = depth_val_gt.transpose((1, 2, 0))
depth_val_gt_plt = depth_val_gt_plt[:, :, 0]
images_debug = images_val_not_normalized.data.cpu().numpy()
images_debug = images_debug[0, :, :, :]
images_debug = images_debug.transpose((1, 2, 0))
outputs_reconstruct_val_clamp = torch.clamp(
outputs_reconstruct_val, 0.0, 1.0)
recons_debug = outputs_reconstruct_val_clamp.data.cpu().numpy()
recons_debug = recons_debug[0, :, :, :]
recons_debug = recons_debug.transpose((1, 2, 0))
seg_pred_color = decode_segmap_mine(pred_label[0, :, :])
seg_gt_color = decode_segmap_mine(gt_label[0, :, :])
f2, axar = plt.subplots(1, 6)
axar[0].imshow((images_debug * 255).astype(np.uint8))
axar[0].axis('off')
axar[1].imshow(seg_gt_color)
axar[1].axis('off')
axar[2].imshow(((depth_val_gt_plt).astype(np.int32)),
cmap=cm.coolwarm)
axar[2].axis('off')
axar[3].imshow(recons_debug)
axar[3].axis('off')
axar[4].imshow(seg_pred_color)
axar[4].axis('off')
axar[5].imshow(((depth_val_pred_plt).astype(np.int32)),
cmap=cm.coolwarm)
axar[5].axis('off')
f2.savefig('./dumped_images/val_figure' + str(i_val) + '.png',
dpi=300)
#plt.show()
running_metrics.update(gt_label, pred_label,\
images_val_not_normalized , outputs_reconstruct_val,
depth_val_gt,depth_val_pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
running_metrics.reset()
def test_summary(self):
print(summary(self.model, (3, 64, 64), device="cpu"))
def run(args):
with open(args.cfg_path) as f:
cfg = edict(json.load(f))
if args.verbose is True:
print(json.dumps(cfg, indent=4))
if not os.path.exists(args.save_path):
os.mkdir(args.save_path)
if args.logtofile is True:
logging.basicConfig(filename=args.save_path + '/log.txt',
filemode="w",
level=logging.INFO)
else:
logging.basicConfig(level=logging.INFO)
if not args.resume:
with open(os.path.join(args.save_path, 'cfg.json'), 'w') as f:
json.dump(cfg, f, indent=1)
device_ids = list(map(int, args.device_ids.split(',')))
num_devices = torch.cuda.device_count()
if num_devices < len(device_ids):
raise Exception('#available gpu : {} < --device_ids : {}'.format(
num_devices, len(device_ids)))
device = torch.device('cuda:{}'.format(device_ids[0]))
model = Classifier(cfg)
if args.verbose is True:
from torchsummary import summary
if cfg.fix_ratio:
h, w = cfg.long_side, cfg.long_side
else:
h, w = cfg.height, cfg.width
summary(model.to(device), (3, h, w))
model = DataParallel(model, device_ids=device_ids).to(device).train()
if args.pre_train is not None:
if os.path.exists(args.pre_train):
ckpt = torch.load(args.pre_train, map_location=device)
model.module.load_state_dict(ckpt)
optimizer = get_optimizer(model.parameters(), cfg)
src_folder = os.path.dirname(os.path.abspath(__file__)) + '/../'
dst_folder = os.path.join(args.save_path, 'classification')
rc, size = subprocess.getstatusoutput('du --max-depth=0 %s | cut -f1' %
src_folder)
if rc != 0:
raise Exception('Copy folder error : {}'.format(rc))
rc, err_msg = subprocess.getstatusoutput('cp -R %s %s' %
(src_folder, dst_folder))
if rc != 0:
raise Exception('copy folder error : {}'.format(err_msg))
copyfile(cfg.train_csv, os.path.join(args.save_path, 'train.csv'))
copyfile(cfg.dev_csv, os.path.join(args.save_path, 'dev.csv'))
dataloader_train = DataLoader(ImageDataset(cfg.train_csv,
cfg,
mode='train'),
batch_size=cfg.train_batch_size,
num_workers=args.num_workers,
drop_last=True,
shuffle=True)
dataloader_dev = DataLoader(ImageDataset(cfg.dev_csv, cfg, mode='dev'),
batch_size=cfg.dev_batch_size,
num_workers=args.num_workers,
drop_last=False,
shuffle=False)
dev_header = dataloader_dev.dataset._label_header
summary_train = {'epoch': 0, 'step': 0}
summary_dev = {'loss': float('inf'), 'acc': 0.0}
summary_writer = SummaryWriter(args.save_path)
epoch_start = 0
best_dict = {
"acc_dev_best": 0.0,
"auc_dev_best": 0.0,
"loss_dev_best": float('inf'),
"fused_dev_best": 0.0,
"best_idx": 1
}
if args.resume:
ckpt_path = os.path.join(args.save_path, 'train.ckpt')
ckpt = torch.load(ckpt_path, map_location=device)
model.module.load_state_dict(ckpt['state_dict'])
summary_train = {'epoch': ckpt['epoch'], 'step': ckpt['step']}
best_dict['acc_dev_best'] = ckpt['acc_dev_best']
best_dict['loss_dev_best'] = ckpt['loss_dev_best']
best_dict['auc_dev_best'] = ckpt['auc_dev_best']
epoch_start = ckpt['epoch']
for epoch in range(epoch_start, cfg.epoch):
lr = lr_schedule(cfg.lr, cfg.lr_factor, summary_train['epoch'],
cfg.lr_epochs)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
summary_train, best_dict = train_epoch(summary_train, summary_dev, cfg,
args, model, dataloader_train,
dataloader_dev, optimizer,
summary_writer, best_dict,
dev_header)
time_now = time.time()
summary_dev, predlist, true_list = test_epoch(summary_dev, cfg, args,
model, dataloader_dev)
time_spent = time.time() - time_now
auclist = []
for i in range(len(cfg.num_classes)):
y_pred = predlist[i]
y_true = true_list[i]
fpr, tpr, thresholds = metrics.roc_curve(y_true,
y_pred,
pos_label=1)
auc = metrics.auc(fpr, tpr)
auclist.append(auc)
summary_dev['auc'] = np.array(auclist)
loss_dev_str = ' '.join(
map(lambda x: '{:.5f}'.format(x), summary_dev['loss']))
acc_dev_str = ' '.join(
map(lambda x: '{:.3f}'.format(x), summary_dev['acc']))
auc_dev_str = ' '.join(
map(lambda x: '{:.3f}'.format(x), summary_dev['auc']))
logging.info('{}, Dev, Step : {}, Loss : {}, Acc : {}, Auc : {},'
'Mean auc: {:.3f} '
'Run Time : {:.2f} sec'.format(
time.strftime("%Y-%m-%d %H:%M:%S"),
summary_train['step'], loss_dev_str, acc_dev_str,
auc_dev_str, summary_dev['auc'].mean(), time_spent))
for t in range(len(cfg.num_classes)):
summary_writer.add_scalar('dev/loss_{}'.format(dev_header[t]),
summary_dev['loss'][t],
summary_train['step'])
summary_writer.add_scalar('dev/acc_{}'.format(dev_header[t]),
summary_dev['acc'][t],
summary_train['step'])
summary_writer.add_scalar('dev/auc_{}'.format(dev_header[t]),
summary_dev['auc'][t],
summary_train['step'])
save_best = False
mean_acc = summary_dev['acc'][cfg.save_index].mean()
if mean_acc >= best_dict['acc_dev_best']:
best_dict['acc_dev_best'] = mean_acc
if cfg.best_target == 'acc':
save_best = True
mean_auc = summary_dev['auc'][cfg.save_index].mean()
if mean_auc >= best_dict['auc_dev_best']:
best_dict['auc_dev_best'] = mean_auc
if cfg.best_target == 'auc':
save_best = True
mean_loss = summary_dev['loss'][cfg.save_index].mean()
if mean_loss <= best_dict['loss_dev_best']:
best_dict['loss_dev_best'] = mean_loss
if cfg.best_target == 'loss':
save_best = True
if save_best:
torch.save(
{
'epoch': summary_train['epoch'],
'step': summary_train['step'],
'acc_dev_best': best_dict['acc_dev_best'],
'auc_dev_best': best_dict['auc_dev_best'],
'loss_dev_best': best_dict['loss_dev_best'],
'state_dict': model.module.state_dict()
},
os.path.join(args.save_path,
'best{}.ckpt'.format(best_dict['best_idx'])))
best_dict['best_idx'] += 1
if best_dict['best_idx'] > cfg.save_top_k:
best_dict['best_idx'] = 1
logging.info('{}, Best, Step : {}, Loss : {}, Acc : {},'
'Auc :{},Best Auc : {:.3f}'.format(
time.strftime("%Y-%m-%d %H:%M:%S"),
summary_train['step'], loss_dev_str, acc_dev_str,
auc_dev_str, best_dict['auc_dev_best']))
torch.save(
{
'epoch': summary_train['epoch'],
'step': summary_train['step'],
'acc_dev_best': best_dict['acc_dev_best'],
'auc_dev_best': best_dict['auc_dev_best'],
'loss_dev_best': best_dict['loss_dev_best'],
'state_dict': model.module.state_dict()
}, os.path.join(args.save_path, 'train.ckpt'))
summary_writer.close()
x = F.avg_pool2d(x,4)
# tensor.view() is like reshape() with the size -1 is inferred from other dimensions
# e.g. (4,4) --->view(16,-1) == (16,1) --->view(8,-1) == (8,2)
# basically it's like x.flatten() == x.view(x.size(0),-1)
x = x.view(x.size(0),-1)
x = self.fc(x)
return x
# define model
model = ResNet(ResidualBlock,[2,2,2,2]).to(device)
"""# model summary"""
from torchsummary import summary
summary(model.cpu(),input_size=(3,32,32))
# loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
# updating learning rate
def update_lr(optimizer,lr):
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# train model
per_epoch_total_step = len(trainloader)
current_lr = learning_rate
sum_loss = 0.0
total_label = 0
import torchvision.transforms as transforms
import torchvision.datasets as datasets
# default whether choose cuda
#th.long = torch.cuda.LongTensor
#th.double = torch.cuda.DoubleTensor
#th.int = torch.cuda.IntTensor
#th.short = torch.cuda.ShortTensor
#th.byte = torch.cuda.ByteTensor
#th.half = torch.cuda.HalfTensor
#th.char = torch.cuda.CharTensor
#th.float = torch.cuda.FloatTensor
# add summary to torch.nn.Module
nn.Module.summary = lambda self, inputShape=None, group=None, ganNoise=False:summary(self, inputShape or getModelDefaultInputShape(self, group, ganNoise) ,device=['cuda', 'cpu']['cpu' in str(getpara(self).device)])
def dedp(model):
'''get raw model instead of torch.nn.DataParallel '''
return model.module if isinstance(model, torch.nn.DataParallel) else model
if 'Module' in str(torch.nn.Module.load_state_dict):
torch.rawModule = rawModule = torch.nn.Module.load_state_dict
else :
rawModule = torch.rawModule
def tryLoad(self, state_dict, strict=True):
try:
rawModule(self, state_dict, strict)
except (KeyError,RuntimeError) :
print('\x1b[31m%s\x1b[0m' % '\n"try strict=False! in Module.load_state_dict() " messge from boxx.ylth \n')
loss = lossFunction(output,labels) # calculate loss
loss.backward() # backpropagate
optimizer.step() # update weights
total_samples += labels.size(0)
total_loss += loss.item()
if idx % 100 == 0:
print("Running loss:", total_loss)
final_time = (time()-time0)/60
print("Model trained in ", final_time, "minutes on ", total_samples, "samples")
model = Net()
print(summary(Net().cuda(), input_size=(1, 28 ,28), batch_size=-1))
train(model, train_loader)
def test(model, test_loader):
"""Test neural net"""
correct = 0
total = 0
with torch.no_grad():
for idx, (images, labels) in enumerate(test_loader):
images = images.view(images.shape[0],-1) # flatten
output = model(images)
values, indices = torch.max(output.data, 1)
total += labels.size(0)
def show_model_summary(self):
summary(self.model, (3, 32, 32))
from mod_decomposer import *
from models.custom_models import *
from torchsummary import summary
device = 'cuda'
net = torch.load('prova.pth')
net = net.cpu()
layer = net.conv2
layer_cmp = pytorch_tucker_layer_decomposition(layer)
print(summary(net.to(device), (3, 32, 32)))
net.conv2 = layer_cmp
print(summary(net.to(device), (3, 32, 32)))
torch.save(net, 'decomposed.pth')
self.stage4 = nn.Sequential(
DownSampling(160, 3, 2),
NormalBlock(320, 3, 1),
NormalBlock(320, 3, 1),
NormalBlock(320, 3, 1),
)
self.embedding = Embedding(320, num_classes)
def forward(self, x):
x = self.conv1(x)
x = self.head(x)
x = self.stage2(x)
x = self.stage3(x)
x = self.stage4(x)
out = self.embedding(x)
return out
if __name__ == '__main__':
model = VarGFaceNet()
input = torch.randn(1, 3, 112, 112)
out = model(input)
print(out.shape)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
summary(model, (3, 112, 112)) # 必须开cuda，不需要传入batch_size
def cifar10_testloader(root='./data', batch_size=32, num_workers=0):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
testset = datasets.CIFAR10(root, train=False, download=True, transform=transform)
return data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
input_size = (3, 32, 32)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # PyTorch v0.4.0
#model = Keras_Cifar2(20, 5)
model = Keras_Cifar_AllConv()
model = LenetZhang()
if len(sys.argv) == 3:
print("Loading model from " + str(sys.argv[2]))
model = torch.load(sys.argv[2])
model_path = sys.argv[1]
model = torch.load(model_path)
model.cpu()
model.eval()
#print(torch_summarize(model))
print('Number of trainable params: ',sum([param.nelement() for param in model.parameters()]))
print(summary(model.to(device), input_size))
print("model loaded. Now testing...")
test_model_cifar10(cifar10_testloader(), model)
def resnet34(norm_layer='bn', **kwargs):
model = ResNet(BasicBlock, [3, 4, 6, 3], norm_layer=norm_layer, **kwargs)
return model
def resnet50(norm_layer='bn', **kwargs):
model = ResNet(Bottleneck, [3, 4, 6, 3], norm_layer=norm_layer, **kwargs)
return model
def resnet101(norm_layer='bn', **kwargs):
model = ResNet(Bottleneck, [3, 4, 23, 3], norm_layer=norm_layer, **kwargs)
return model
def resnet152(norm_layer='bn', **kwargs):
model = ResNet(Bottleneck, [3, 8, 36, 3], norm_layer=norm_layer, **kwargs)
return model
def resnet200(norm_layer=None, **kwargs):
model = ResNet(Bottleneck, [3, 24, 36, 3], norm_layer=norm_layer, **kwargs)
return model
if __name__ == '__main__':
from torchsummary import summary
model = resnet101(norm_layer='frn')
summary(model.cuda(), (3, 256, 256))
if __name__ == "__main__":
in_channel_1 = 32
in_channel_2 = 64
in_channel_thin = 1
out_channel_thin = 32
model = CombNet(in_channel_1=in_channel_1,
in_channel_2=in_channel_2,
in_channel_thin=in_channel_thin,
out_channel_thin=out_channel_thin,
num_class=14)
input_1_shape = [in_channel_1, 512, 512, 8 * 4]
input_2_shape = [in_channel_2, 128, 256, 256, 8 * 2]
input_thin_shape = [in_channel_thin, 128, 128, 8]
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
from torchsummary import summary
summary(model, [input_1_shape, input_2_shape, input_thin_shape])
input_1_dummy = torch.rand(input_1_shape).to(device)
input_2_dummy = torch.rand(input_2_shape).to(device)
input_thin_dummy = torch.rand(input_thin_shape).to(device)
print("Device:", device)
print("Input:", input_1_dummy.shape, input_2_dummy.shape,
input_thin_dummy.shape)
#output = model(input_1_dummy, input_2_dummy, input_thin_dummy)
print("Output :", output.size())
in_channels = 3
for x in cfg:
if x == 'M':
layers += [nn.MaxPool2d(2, 2)]
else:
conv2d = nn.Conv2d(in_channels=in_channels,
out_channels=x,
kernel_size=3,
stride=1,
padding=1)
# batch_norm이 true
if batch_norm:
layers += [
conv2d,
nn.BatchNorm2d(x),
nn.ReLU(inplace=True)
] # inplace 메모리 감소 -> 따로 찾아볼것
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = x
return nn.Sequential(*layers)
if __name__ == "__main__":
from torchsummary import summary
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
net = VGGNet('VGG16').to(device)
summary(net, (3, 224, 224), 30)
nn.ReLU(inplace=True)
]
elif Ltype == 'N':
layers += [
nn.Conv2d(self.in_channels,
F,
kernel_size=K,
padding=K // 2),
nn.BatchNorm2d(F),
nn.ReLU(inplace=True)
]
self.in_channels = F
net = NET(netType).to(device)
summary(net, (1, 3, 32, 32))
#flops, params = profile(net, input_size=(1, 3, 32,32), custom_ops={xCNN: count_op_xCNN, xCNNlow: count_op_xCNNlow})
#print(flops,params)
criterion = nn.CrossEntropyLoss()
opt = optim.Adam(net.parameters(), lr=lrate)
if os.path.isfile(load_path) and load_ckpt:
checkpoint = torch.load(load_path)
net.load_state_dict(checkpoint['model_state_dict'])
opt.load_state_dict(checkpoint['opt'])
start_epoch = checkpoint['epoch'] + 1
print('model loaded')
for epoch in range(start_epoch,
def main(args):
train_dataset = UrbanSound8KDataset('UrbanSound8K_train.pkl', "LMC")
training_class_counts = np.array(
[6295, 1825, 6248, 5121, 5682, 6282, 1112, 5886, 5819, 6299])
class_weights = 1 / training_class_counts
data_weights = []
for i in range(0, len(train_dataset)):
features, label, filename, labelname = train_dataset.__getitem__(i)
data_weight = class_weights[label]
data_weights.append(data_weight)
sampler = torch.utils.data.sampler.WeightedRandomSampler(
torch.tensor(data_weights), len(train_dataset))
train_loader = torch.utils.data.DataLoader(
train_dataset,
shuffle=False,
batch_size=args.batch_size,
pin_memory=True,
num_workers=args.worker_count,
sampler=sampler,
)
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', "LMC"),
shuffle=False,
batch_size=args.batch_size,
num_workers=args.worker_count,
pin_memory=True,
)
model = LMCNet(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout)
## TASK 8: Redefine the criterion to be softmax cross entropy
criterion = nn.CrossEntropyLoss()
## TASK 11: Define the optimizer
optimizer = optim.Adam(model.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999),
weight_decay=0.004)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(str(log_dir), flush_secs=5)
trainer = Trainer(model, train_loader, test_loader, criterion, optimizer,
summary_writer, DEVICE)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary(model, input_size=(1, 85, 41))
summary_writer.close()
def train():
if args.dataset == 'CARPLATE_ONLY_FOUR_CORNERS_WITH_BORDER':
cfg = carplate
if args.input_size == 512:
cfg = change_cfg_for_ssd512(cfg)
dataset = CARPLATE_FOUR_CORNERSDetection(
root=args.dataset_root,
transform=SSDAugmentation_four_corners(cfg['min_dim'], MEANS),
dataset_name='trainval')
from data import CARPLATE_FOUR_CORNERS_CLASSES as labelmap
eval_dataset = CARPLATE_FOUR_CORNERSDetection(
root=args.dataset_root,
transform=BaseTransform(args.input_size, MEANS),
target_transform=CARPLATE_FOUR_CORNERSAnnotationTransform(
keep_difficult=True),
dataset_name='test')
if args.visdom:
import visdom
global viz
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
# summary
summary(net, input_size=(3, int(cfg['min_dim']), int(cfg['min_dim'])))
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load('weights/' + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.conf.apply(weights_init)
ssd_net.four_corners.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optimizer = optim.Adam(net.parameters(), lr=args.lr, betas=(0.9, 0.999),
# weight_decay=args.weight_decay)
criterion = MultiBoxLoss_only_four_corners_with_CIoU(
cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda)
net.train()
# loss counters
conf_loss = 0
four_corners_loss = 0
border_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = [
'Conf Loss', 'Four Corners Loss', 'Border Loss', 'Total Loss'
]
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
lr = args.lr
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
epoch += 1
update_vis_plot(epoch, conf_loss, four_corners_loss, border_loss,
epoch_plot, None, 'append', epoch_size)
# reset epoch loss counters
conf_loss = 0
four_corners_loss = 0
border_loss = 0
if iteration in cfg['lr_steps']:
step_index += 1
lr = adjust_learning_rate(optimizer, args.gamma, epoch, step_index,
iteration, epoch_size)
# load train data
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
if args.cuda:
images = Variable(images.cuda())
with torch.no_grad():
targets = [Variable(ann.cuda()) for ann in targets]
else:
images = Variable(images)
with torch.no_grad():
targets = [Variable(ann) for ann in targets]
# forward
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
loss_c, loss_four_corners, loss_border = criterion(out, targets)
loss = loss_c + loss_four_corners + loss_border
loss.backward()
optimizer.step()
t1 = time.time()
conf_loss += loss_c.item()
four_corners_loss += loss_four_corners.item()
border_loss += loss_border.item()
if iteration % 100 == 0:
log.l.info('''
Timer: {:.5f} sec.\t LR: {}.\t Iter: {}.\t Loss_c: {:.5f}.\t Loss_four_corners: {:.5f}.\t Loss_border: {:.5f}.\t Loss: {:.5f}.
'''.format(
(t1 - t0),
lr,
iteration,
loss_c.item(),
loss_four_corners.item(),
loss_border.item(),
loss_c.item() + loss_four_corners.item() + loss_border.item(),
))
if args.visdom:
update_vis_plot(iteration, loss_c.item(), loss_four_corners.item(),
loss_border.item(), iter_plot, epoch_plot,
'append')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(
ssd_net.state_dict(), 'weights/' + args.save_folder + 'ssd' +
str(args.input_size) + '_' + repr(iteration) + '.pth')
# load net for evaluation
num_classes = len(labelmap) + 1 # +1 for background
eval_net = build_ssd('test', args.input_size,
num_classes) # initialize SSD
eval_net.load_state_dict(
torch.load('weights/' + args.save_folder + 'ssd' +
str(args.input_size) + '_' + repr(iteration) +
'.pth'))
eval_net.eval()
print('Finished loading model!')
if args.cuda:
eval_net = eval_net.cuda()
cudnn.benchmark = True
# evaluation begin
eval_results.test_net(args.eval_save_folder,
args.obj_type,
args.dataset_root,
'test',
labelmap,
eval_net,
args.cuda,
eval_dataset,
BaseTransform(eval_net.size, MEANS),
args.top_k,
args.input_size,
thresh=args.confidence_threshold)
torch.save(
ssd_net.state_dict(), 'weights/' + args.save_folder + '' +
args.dataset + str(args.input_size) + '.pth')
# load net for evaluation for the final model
num_classes = len(labelmap) + 1 # +1 for background
eval_net = build_ssd('test', args.input_size,
num_classes) # initialize SSD
eval_net.load_state_dict(
torch.load('weights/' + args.save_folder + '' + args.dataset +
str(args.input_size) + '.pth'))
eval_net.eval()
print('Finished loading model!')
if args.cuda:
eval_net = eval_net.cuda()
cudnn.benchmark = True
# evaluation begin
eval_results.test_net(args.eval_save_folder,
args.obj_type,
args.dataset_root,
'test',
labelmap,
eval_net,
args.cuda,
eval_dataset,
BaseTransform(eval_net.size, MEANS),
args.top_k,
args.input_size,
thresh=args.confidence_threshold)
x_wc3 = self.wc3(x_res2)
x_wc4 = self.wc4(x_res3)
x = self.wc5(x)
x = self.dec4(x, x_wc4)
x = self.dec3(x, x_wc3)
x = self.score(x)
# with torch.no_grad():
x = self.score_u8(x)
return x
if __name__ == "__main__":
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = DF1SegX22(classes=19).to(device)
summary(model, (3, 352, 480))
x = torch.randn(2, 3, 512, 1024).to(device)
from fvcore.nn.jit_handles import batchnorm_flop_jit
from fvcore.nn.jit_handles import generic_activation_jit
supported_ops = {
"aten::batch_norm": batchnorm_flop_jit,
}
flop_dict, _ = flop_count(model, (x,), supported_ops)
flops_count, params_count = get_model_complexity_info(model, (3, 512, 1024),
as_strings=False,
print_per_layer_stat=True)
input = x
macs, params = profile(model, inputs=(input,))
def main():
"""
Training and validation.
"""
global best_bleu4, epochs_since_improvement, checkpoint, start_epoch, fine_tune_encoder, data_name, word_map
# Read word map
word_map_file = os.path.join(data_folder, 'WORDMAP_' + data_name + '.json')
with open(word_map_file, 'r') as j:
word_map = json.load(j)
# Initialize / load checkpoint
if checkpoint is None:
decoder = DecoderRNN_SEN(emb_dim, decoder_dim, len(word_map), number_layers)
# print(len(word_map))
decoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, decoder.parameters()),
lr=decoder_lr)
encoder = EncoderCNN_SEN(emb_dim)
encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),
lr=encoder_lr) if fine_tune_encoder else None
else:
checkpoint = torch.load(checkpoint)
start_epoch = checkpoint['epoch'] + 1
epochs_since_improvement = checkpoint['epochs_since_improvement']
best_bleu4 = checkpoint['bleu-4']
decoder = checkpoint['decoder']
decoder_optimizer = checkpoint['decoder_optimizer']
encoder = checkpoint['encoder']
encoder_optimizer = checkpoint['encoder_optimizer']
if fine_tune_encoder is True and encoder_optimizer is None:
encoder.fine_tune(fine_tune_encoder)
encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),
lr=encoder_lr)
# Move to GPU, if available
decoder = decoder.to(device)
encoder = encoder.to(device)
# Loss function
criterion = nn.CrossEntropyLoss().to(device)
# Custom dataloaders
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
'''
去掉num_workers 不使用多线程解决报错 TypeError: h5py objects cannot be pickled
train_loader = torch.utils.data.DataLoader(
CaptionDataset_tra(data_folder, data_name, 'TRAIN', transform=transforms.Compose([normalize])),
batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)
'''
train_loader = torch.utils.data.DataLoader(
CaptionDataset_tra(data_folder, data_name, 'TRAIN', transform=transforms.Compose([normalize])),
batch_size=batch_size, shuffle=True, pin_memory=True, drop_last=True) # set drop_last=True to solve the error:
val_loader = torch.utils.data.DataLoader(
CaptionDataset_tra(data_folder, data_name, 'VAL', transform=transforms.Compose([normalize])),
batch_size=32, shuffle=True, pin_memory=True, drop_last=True)
# torchsummary
summary(encoder, input_size=(3, 224, 224))
# Epochs
for epoch in range(start_epoch, epochs):
# Decay learning rate if there is no improvement for 8 consecutive epochs, and terminate training after 20
if epochs_since_improvement == 10:
break
if epochs_since_improvement > 0 and epochs_since_improvement % 8 == 0:
adjust_learning_rate(decoder_optimizer, 0.8)
if fine_tune_encoder:
adjust_learning_rate(encoder_optimizer, 0.8)
# One epoch's training
train(train_loader=train_loader,
encoder=encoder,
decoder=decoder,
criterion=criterion,
encoder_optimizer=encoder_optimizer,
decoder_optimizer=decoder_optimizer,
epoch=epoch)
# One epoch's validation
recent_bleu4 = validate(val_loader=val_loader,
encoder=encoder,
decoder=decoder,
criterion=criterion)
# Check if there was an improvement
is_best = recent_bleu4 > best_bleu4
best_bleu4 = max(recent_bleu4, best_bleu4)
if not is_best:
epochs_since_improvement += 1
print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement,))
else:
epochs_since_improvement = 0
# Save checkpoint
save_checkpoint_tra(data_name, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer,
decoder_optimizer, recent_bleu4,
is_best) # add 'checkpoint' to save the model and parameters By zjx
def disp_summary(model):
#use_cuda= torch.cuda.is_available()
#device=torch.device('cuda' if use_cuda else 'cpu')
##model=Net().to(device)
summary(model, input_size=(3, 32, 32))
nn.ReLU(True))
self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),
nn.ReLU(True))
self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim),
nn.ReLU(True))
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x
model = neural_network(28 * 28, 300, 100, 10)
if use_gpu: model = model.cuda()
summary(model, (1, 28 * 28))
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# start training
for epoch in range(1, num_epochs + 1):
print('*' * 20)
print(f'epoch {epoch}')
sum_loss = .0
sum_acc = .0
model.train()
for i, data in enumerate(train_loader, 1):
img, label = data
img = img.view(img.size(0), -1)
if use_gpu:
def __extract_features_rgb(begin_num=None, end_num=None):
root_path = c.DATA_ROOT_PATH
annotation_path = '%s/Charades/annotation/frames_dict_trimmed_multi_label_i3d_160_frames.pkl' % (
root_path)
features_root_path = '%s/Charades/features_i3d_charades_rgb_mixed_5c_trimmed_20_frames' % (
root_path)
video_frames_root_path = '%s/Charades/frames/Charades_v1_rgb' % (root_path)
model_path = '%s/Charades/baseline_models/i3d/rgb_charades.pt' % (
root_path)
feature_name = 'Mixed_5c'
(video_frames_dict_tr,
video_frames_dict_te) = utils.pkl_load(annotation_path)
video_frames_dict = dict()
video_frames_dict.update(video_frames_dict_tr)
video_frames_dict.update(video_frames_dict_te)
video_names = video_frames_dict.keys()
n_videos = len(video_names)
frame_count = 0
if not os.path.exists(features_root_path):
print('Sorry, path does not exist: %s' % (features_root_path))
return
t1 = time.time()
print('extracting training features')
print('start time: %s' % utils.timestamp())
# aync reader, and get load images for the first video
img_reader = image_utils.AsyncImageReaderCharadesForI3DTorchModel(
n_threads=20)
img_reader.load_imgs_in_batch(
__get_video_frame_pathes(video_names[0], video_frames_root_path,
video_frames_dict))
# load the model
model = __load_i3d_model_rgb(model_path)
torchsummary.summary(model, input_size=(3, 160, 224, 224))
# loop on list of videos
for idx_video in range(n_videos):
video_num = idx_video + 1
if begin_num is not None and end_num is not None:
if video_num <= begin_num or video_num > end_num:
continue
video_name = video_names[idx_video]
# wait untill the image_batch is loaded
t1 = time.time()
while img_reader.is_busy():
threading._sleep(0.1)
t2 = time.time()
duration_waited = t2 - t1
print('...... video %d/%d: %s, waited: %d' %
(video_num, n_videos, video_name, duration_waited))
# get the video frames
video_frames = img_reader.get_images()
# pre-load for the next video
if video_num < n_videos:
next_video_name = video_names[idx_video + 1]
img_reader.load_imgs_in_batch(
__get_video_frame_pathes(next_video_name,
video_frames_root_path,
video_frames_dict))
video_features_path = '%s/%s.pkl' % (features_root_path, video_name)
# if os.path.exists(video_features_path):
# print ('... features for video already exist: %s.pkl' % (video_name))
# continue
if len(video_frames) != 160:
print('... wrong n frames: %d' % (video_num))
continue
# transpose to have the channel_first (160, 224, 224, 3) => (3, 160, 224, 224)
video_frames = np.transpose(video_frames, (3, 0, 1, 2))
# add one dimension to represent the batch size
video_frames = np.expand_dims(video_frames, axis=0)
# prepare input variable
with torch.no_grad():
# extract features
input_var = torch.from_numpy(video_frames).cuda()
output_var = model(input_var)
output_var = output_var.cpu()
features = output_var.data.numpy() # (1, 1024, 20, 7, 7)
# don't forget to clean up variables
del input_var
del output_var
# squeeze to remove the dimension of the batch_size
features = features[0] # (1024, 20, 7, 7)
# transpose to have the channel_last
features = np.transpose(features, (1, 2, 3, 0)) # (20, 7, 7, 1024)
# path to save the features
utils.pkl_dump(features, video_features_path, is_highest=True)
# increment counts
frame_count += len(video_frames)
t2 = time.time()
print('finish extracting %d features in %d seconds' %
(frame_count, t2 - t1))
print('end time: %s' % utils.timestamp())
def print_summary(self):
print('Model Summary')
summary(self, input_size=(1, 40, 801))
print('\n')
label = label.to(device=device, dtype=torch.float32)
# image, label = Variable(image, requires_grad=False), Variable(label, requires_grad=False)
# image, label = Variable(image.cuda(), requires_grad=False), Variable(label.cuda(),
# requires_grad=False)
# 使用网络参数，输出预测结果
pred = net(image)
# 计算loss
loss = criterion(pred, label)
print('Loss/train', loss.item())
# 保存loss值最小的网络参数
if loss < best_loss:
best_loss = loss
torch.save(net.state_dict(), 'best_model.pth')
# 更新参数
loss.backward()
optimizer.step()
if __name__ == "__main__":
# 选择设备，有cuda用cuda，没有就用cpu
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 加载网络，图片单通道1，分类为1。
net = UNet(n_channels=1, n_classes=1)
# 将网络拷贝到deivce中
net.to(device=device)
summary(net, (1, 512, 512))
# 指定训练集地址，开始训练
data_path = r"data/train/"
train_net(net, device, data_path)
nn.InstanceNorm2d(conv_dim * 2 ** i, affine=True, track_running_stats=True),
nn.LeakyReLU(negative_slope=0.2, inplace=True)
))
in_channels = conv_dim * 2 ** i
self.conv = nn.Sequential(*layers)
feature_size = image_size // 2**n_layers
self.fc_adv = nn.Sequential(
nn.Linear(conv_dim * 2 ** (n_layers - 1) * feature_size ** 2, fc_dim),
nn.LeakyReLU(negative_slope=0.2, inplace=True),
nn.Linear(fc_dim, 1)
)
self.fc_att = nn.Sequential(
nn.Linear(conv_dim * 2 ** (n_layers - 1) * feature_size ** 2, fc_dim),
nn.LeakyReLU(negative_slope=0.2, inplace=True),
nn.Linear(fc_dim, attr_dim),
)
def forward(self, x):
y = self.conv(x)
y = y.view(y.size()[0], -1)
logit_adv = self.fc_adv(y)
logit_att = self.fc_att(y)
return logit_adv, logit_att
if __name__ == '__main__':
gen = Generator(5, n_layers=6, shortcut_layers=5, use_stu=True, one_more_conv=True)
summary(gen, [(3, 384, 384), (5,)], device='cpu')
dis = Discriminator(image_size=384, attr_dim=5)
summary(dis, (3, 384, 384), device='cpu')
def _test():
from torchsummary import summary
model = DenseNet264()
model = model.cuda()
summary(model,input_size=(3,224,224))
def train(args):
# initialize visdomX
vis = VisdomX()
# prepare the MNIST dataset
train_dataset = datasets.MNIST(root="./data/",
train=True,
transform=transforms.ToTensor(),
download=True)
test_dataset = datasets.MNIST(root="./data/",
train=False,
transform=transforms.ToTensor())
# create the data loader
train_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
shuffle=True, drop_last=True)
test_loader = DataLoader(dataset=test_dataset,
batch_size=args.batch_size,
shuffle=False)
# turn on the CUDA if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = Net().to(device)
loss_op = nn.CrossEntropyLoss()
optim = torch.optim.Adam(net.parameters(), lr=args.lr)
# model summary via torchsummary
summary(net, (1, 28, 28))
for epoch in range(args.max_epochs):
net.train()
for step, inputs in enumerate(train_loader):
images = inputs[0].to(device)
labels = inputs[1].to(device)
# forward-propagation
outputs = net(images)
loss = loss_op(outputs, labels)
# back-propagation
optim.zero_grad()
loss.backward()
optim.step()
acc = evaluate(net, test_loader, device)
# plot loss and acc by visdom
vis.add_scalars(loss.item(), epoch,
title="Loss",
ylabel="Loss", xlabel="Epoch")
vis.add_scalars(acc, epoch,
title="Accuracy",
ylabel="Accuracy", xlabel="Epoch")
print("Epoch [{}/{}] loss: {:.5f} test acc: {:.3f}"
.format(epoch+1, args.max_epochs, loss.item(), acc))
torch.save(net.state_dict(), "mnist-final.pth")
validate_loader = torch.utils.data.DataLoader(dataset=validate_imgs,
pin_memory=use_cuda,
shuffle=True,
batch_size=batch_size)
conf = dict()
conf['noise_level'] = noise_level
conf['lr'] = lr
conf['kl_factor'] = kl_factor
conf['norm_mean'] = mean
conf['norm_std'] = std
vae = VAE(n_channel=3,
img_size=img_size,
z_dim=z_dim,
use_cuda=use_cuda,
conf=conf)
summary(vae, input_size=(3, 64, 64), batch_size=batch_size)
tbar = tqdm(range(num_epochs))
fid = open('losses', 'w')
for epoch in tbar:
train_rec, train_kl = vae.one_epoch(train_loader)
valid_rec, valid_kl = vae.evaluate(validate_loader)
vae.eval()
bx_train, _ = iter(train_loader).next()
bx_valid, _ = iter(validate_loader).next()
bx_train = bx_train[:8]
bx_valid = bx_valid[:8]
rand_samp = vae.random_sample(num_samples=8)
rec_train = vae.reconstruct_img(bx_train)
rec_valid = vae.reconstruct_img(bx_valid)
bx_train = vae.unnormalize(bx_train)
# net = CPD_All_Conv(int(args.ranks[0]), int(args.ranks[1]), int(args.ranks[2]), relu=False)
# net = Keras_Cifar_classic()
net = LenetZhang()
# net = CPD_Zhang(int(args.ranks[0]), int(args.ranks[1]), int(args.ranks[2]), relu=False)
# GPU
if args.model:
net = torch.load(args.model)
if args.state:
net.load_state_dict(torch.load(args.state))
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = net.to(device)
print('###################')
print(summary(net, (3, 32, 32)))
print('Number of trainable params:',
sum([param.nelement() for param in net.parameters()]))
########################################################################
# 3. Define a Loss function and optimizer
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# Let's use a Classification Cross-Entropy loss and SGD with momentum
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
if args.opt == 'Adam':
optimizer = optim.Adam(net.parameters(), lr=0.001)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=15, gamma=0.1)
def summary(self, shape):
return summary(self, shape, device='cpu')
