def main(args):
model = AutoEncoder()
use_gpu = torch.cuda.is_available()
if use_gpu:
print('cuda is available!')
model.cuda()
weight_file = args.path_weight_file
model = AutoEncoder()
model.load_state_dict(
torch.load(weight_file, map_location=lambda storage, loc: storage))
test_dataset = dataloader('dogs_cats', 'test')
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=args.batch_size, shuffle=False)
images, _ = iter(test_loader).next()
images = Variable(images, volatile=True)
imshow(torchvision.utils.make_grid(images.data[:25], nrow=5))
outputs = model(images)
imshow(torchvision.utils.make_grid(outputs.data[:25], nrow=5))
def main(options):
if options.num_classes == 2:
TRAINING_PATH = 'train_2classes.txt'
else:
TRAINING_PATH = 'train.txt'
IMG_PATH = './Image'
dset_train = AD_3DRandomPatch(IMG_PATH, TRAINING_PATH)
train_loader = DataLoader(dset_train,
batch_size=options.batch_size,
shuffle=True,
num_workers=4,
drop_last=True)
sparsity = 0.05
beta = 0.5
mean_square_loss = nn.MSELoss()
kl_div_loss = nn.KLDivLoss(reduce=False)
use_gpu = len(options.gpuid) >= 1
autoencoder = AutoEncoder()
if (use_gpu):
autoencoder = autoencoder.cuda()
else:
autoencoder = autoencoder.cpu()
optimizer = torch.optim.Adam(autoencoder.parameters(),
lr=options.learning_rate,
weight_decay=options.weight_decay)
train_loss = 0.
for epoch in range(options.epochs):
print("At {0}-th epoch.".format(epoch))
for i, patches in enumerate(train_loader):
print(i)
print(len(patches))
pre_train_path = args.load_weight_dir
pretrained_dict = torch.load(pre_train_path) #load pre train model
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
} #load the layer only same with the target model
model_dict.update(pretrained_dict)
print('===================================')
print('load pre_train weight successfully')
print('===================================')
except:
print('===================================')
print(' random init the weight ')
print('===================================')
autoencoder.load_state_dict(model_dict)
autoencoder.cuda()
autoencoder.train()
'''opt setting'''
optimizer = torch.optim.Adam(
autoencoder.parameters(),
lr=args.learning_rate) # optimize all cnn parameters
loss_func = nn.MSELoss()
'''folder for saving weight and loss history'''
save_path = args.save_weight_dir
'''training code'''
for epoch in range(EPOCH):
loss_iter = 0
for step, (x, b_label) in enumerate(train_data):
x_in = torch.tensor(x).cuda()
decoded = autoencoder(x_in)
print(all_embeddings.size()[0])
embed_batches = [all_embeddings[:, i:i + batch_size]\
for i in range(0, all_embeddings.size()[1], batch_size)]
#embed_batch1 = all_embeddings[:, 260:280]
#embed_batch2 = all_embeddings[:, 280:300]
#embed_batches = [embed_batch1, embed_batch2]
for d, embeds in enumerate(embed_batches):
dim_start = d * batch_size
dim_end = (d+1) * batch_size
print("Initializing AutoEncoder for dims %i to %i"\
% (dim_start, dim_end))
model = AutoEncoder(embeds, word2class, class2word, USE_CUDA)
model = model.cuda() if USE_CUDA else model
# Ignore any parameters with requires_grad = False
# aka the pretrained embeddings
params = filter(lambda x: x.requires_grad, model.parameters())
optimizer = torch.optim.SGD(params, lr=lr)
num_dims = model.embedding_dims
num_words = model.num_words
num_classes = model.num_classes
last_loss = float("inf")
for i in range(epochs):
print("Epoch %i" % i)
optimizer.zero_grad()
def main(args):
## load datasets
train_dataset = dataloader('dogs_cats', 'train')
## split train and validation
num_train = len(train_dataset)
indices = list(range(num_train))
split = 5000
validation_idx = np.random.choice(indices, size=split, replace=False)
train_idx = list(set(indices) - set(validation_idx))
train_sampler = SubsetRandomSampler(train_idx)
validation_sampler = SubsetRandomSampler(validation_idx)
## train and validation loader
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler)
valid_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=validation_sampler)
## debug
if args.debug:
images, _ = next(iter(train_loader))
grid = torchvision.utils.make_grid(images[:25], nrow=5)
imshow(grid, 'train')
images, _ = next(iter(valid_loader))
grid = torchvision.utils.make_grid(images[:25], nrow=5)
imshow(grid, 'valid')
## define model
model = AutoEncoder()
use_gpu = torch.cuda.is_available()
if use_gpu:
print('cuda is available!')
model.cuda()
## loss and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(
model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-5)
## log
log_dir = 'logs'
if not os.path.isdir('logs'):
os.mkdir('logs')
## train and valid
best_val = 5
loss_list = []
val_loss_list = []
for epoch in range(args.n_epochs):
loss = train(model, criterion, optimizer, train_loader, use_gpu)
val_loss = valid(model, criterion, valid_loader, use_gpu)
print('epoch {:d}, loss: {:.4f} val_loss: {:.4f}'.format(epoch, loss, val_loss))
if val_loss < best_val:
print('val_loss improved from {:.5f} to {:.5f}!'.format(best_val, val_loss))
best_val = val_loss
model_file = 'epoch{:03d}-{:.3f}.pth'.format(epoch, val_loss)
torch.save(model.state_dict(), os.path.join(log_dir, model_file))
loss_list.append(loss)
val_loss_list.append(val_loss)
def main(options):
if options.num_classes == 3:
TRAINING_PATH = '/media/ailab/Backup Plus/ADNI/data/train_3classes.txt'
else:
TRAINING_PATH = '/media/ailab/Backup Plus/ADNI/data/train_3classes.txt'
IMG_PATH = '/media/ailab/Backup Plus/ADNI/data/image'
dset_train = AD_3DRandomPatch(IMG_PATH, TRAINING_PATH)
train_loader = DataLoader(dset_train,
batch_size=options.batch_size,
shuffle=True,
num_workers=0,
drop_last=True)
sparsity = 0.05
beta = 0.5
mean_square_loss = nn.MSELoss()
#kl_div_loss = nn.KLDivLoss(reduce=False)
use_gpu = len(options.gpuid) >= 1
autoencoder = AutoEncoder()
if (use_gpu):
autoencoder = autoencoder.cuda()
else:
autoencoder = autoencoder.cpu()
#autoencoder.load_state_dict(torch.load("./autoencoder_pretrained_model19"))
optimizer = torch.optim.Adam(autoencoder.parameters(),
lr=options.learning_rate,
weight_decay=options.weight_decay)
last_train_loss = 1e-4
f = open("autoencoder_loss", 'a')
for epoch in range(options.epochs):
train_loss = 0.
print("At {0}-th epoch.".format(epoch))
for i, patches in enumerate(train_loader):
patch = patches['patch']
for b, batch in enumerate(patch):
batch = Variable(batch).cuda()
#batch = out.view(-1, 343)
output, s_ = autoencoder(batch)
batch = batch.view(-1, 343)
loss1 = mean_square_loss(output, batch)
s = Variable(torch.ones(s_.shape) * sparsity).cuda()
loss2 = (s * torch.log(s / (s_ + 1e-8)) + (1 - s) * torch.log(
(1 - s) / ((1 - s_ + 1e-8)))).sum() / options.batch_size
#kl_div_loss(mean_activitaion, sparsity)
loss = loss1 + beta * loss2
train_loss += loss
logging.info(
"batch {0} training loss is : {1:.5f}, {2:.5f}".format(
i * 1000 + b, loss1.data[0], loss2.data[0]))
f.write("batch {0} training loss is : {1:.3f}\n".format(
i * 1000 + b, loss.data[0]))
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_avg_loss = train_loss / (len(train_loader) * 1000)
print(
"Average training loss is {0:.5f} at the end of epoch {1}".format(
train_avg_loss.data[0], epoch))
if (abs(train_avg_loss.data[0] - last_train_loss) <=
options.estop) or ((epoch + 1) % 20 == 0):
torch.save(autoencoder.state_dict(),
open("autoencoder_pretrained_model" + str(epoch), 'wb'))
last_train_loss = train_avg_loss.data[0]
f.close()
