def main(config):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean = (0.5, 0.5, 0.5), std = (0.5, 0.5, 0.5))
])
use_cuda = torch.cuda.is_available()
device = torch.device('cuda' if use_cuda else 'cpu')
model = DANN().cuda()
state = torch.load(config.ckp_path)
model.load_state_dict(state['state_dict'])
filenames = glob.glob(os.path.join(config.img_dir, '*.png'))
filenames = sorted(filenames)
out_filename = config.save_path
os.makedirs(os.path.dirname(config.save_path), exist_ok=True)
model.eval()
with open(out_filename, 'w') as out_file:
out_file.write('image_name,label\n')
with torch.no_grad():
for fn in filenames:
data = Image.open(fn).convert('RGB')
data = transform(data)
data = torch.unsqueeze(data, 0)
data = data.cuda()
output, _ = model(data, 1)
pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability
out_file.write(fn.split('/')[-1] + ',' + str(pred.item()) + '\n')
item_pr = 'Epoch: [{}/{}], classify_loss: {:.4f}, domain_loss_s: {:.4f}, domain_loss_t: {:.4f}, domain_loss: {:.4f},total_loss: {:.4f}'.format(
epoch, args.nepoch, err_s_label.item(), err_s_domain.item(),
err_t_domain.item(), err_domain.item(), err.item())
print(item_pr)
fp = open(args.result_path, 'a')
fp.write(item_pr + '\n')
# test
acc_src = test(model, args.source, epoch)
acc_tar = test(model, args.target, epoch)
test_info = 'Source acc: {:.4f}, target acc: {:.4f}'.format(
acc_src, acc_tar)
fp.write(test_info + '\n')
print(test_info)
fp.close()
if best_acc < acc_tar:
best_acc = acc_tar
if not os.path.exists(args.model_path):
os.mkdirs(args.model_path)
torch.save(model, '{}/mnist_mnistm.pth'.format(args.model_path))
print('Test acc: {:.4f}'.format(best_acc))
if __name__ == '__main__':
torch.random.manual_seed(10)
loader_src, loader_tar = data_loader.load_data()
model = DANN(DEVICE).to(DEVICE)
optimizer = optim.SGD(model.parameters(), lr=args.lr)
train(model, optimizer, loader_src, loader_tar)
_, domain_output = model(input_data=t_img, alpha=alpha)
err_t_domain = loss_domain(domain_output, domain_label)
err = err_s_label + err_t_domain + err_s_domain
err.backward()
optimizer.step()
if i % LOG_INTERVAL == 0:
print(
'Epoch: [{}/{}], Batch: [{}/{}], err_s_label: {:.4f}, err_s_domain: {:.4f}, err_t_domain: {:.4f}'.format(
epoch, N_EPOCH, i, len_dataloader, err_s_label.item(), err_s_domain.item(),
err_t_domain.item()))
i += 1
# Save model, and test using the source and target
if not os.path.exists(MODEL_ROOT):
os.mkdir(MODEL_ROOT)
torch.save(model, '{}/mnist_mnistm_model_epoch_{}.pth'.format(MODEL_ROOT, epoch))
acc_src = test(model, DATA_SRC, epoch)
acc_tar = test(model, DATA_TAR, epoch)
result.append([acc_src, acc_tar])
np.savetxt('result.csv', np.array(result), fmt='%.4f', delimiter=',')
if __name__ == '__main__':
torch.random.manual_seed(100)
loader_src, loader_tar = load_data()
model = DANN().to(DEVICE)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
train(model, optimizer, loader_src, loader_tar)
IMAGE_DIM,
DIR)
max_batches = min(len(source_dataloader), len(target_dataloader))
# Instantiate Dicts
i = 0
labels_loss = []
source_domain_loss = []
target_domain_loss = []
batch = []
# Instantiate Tensor Board Writer
writer = SummaryWriter()
# Instantiate Model
model = DANN(image_dim=28)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
# Load Optimizer and Loss Functions
optimizer = optim.Adam(model.parameters(), LR)
# instantiate 2 loss functions
class_loss_criterion = nn.CrossEntropyLoss()
domain_loss_criterion = nn.CrossEntropyLoss()
for epoch in range(EPOCHS):
print(f'Epoch {epoch + 1:04d} / {EPOCHS:04d}', end='\n=================\n')
source_domain_iterator = iter(source_dataloader)
target_domain_iterator = iter(target_dataloader)
fp.write(item_pr + '\n')
# test
acc_src = test(model, tar = False)/100.
acc_tar = test(model, tar = True)/100.
train_acc_list.append(acc_src)
test_acc_list.append(acc_tar)
test_info = 'Source acc: {:.4f}, target acc: {:.4f}'.format(acc_src, acc_tar)
fp.write(test_info + '\n')
print(test_info)
fp.close()
if best_acc < acc_tar:
best_acc = acc_tar
if not os.path.exists(args.model_path):
os.mkdir(args.model_path)
torch.save(model, '{}/save_model.pth'.format(args.model_path))
print('Test acc: {:.4f}'.format(best_acc))
return train_acc_list, test_acc_list
if __name__ == '__main__':
loader_src, loader_tar = data_loader.load_data(person=args.person)
model = DANN(DEVICE).to(DEVICE)
# optimizer = optim.SGD(model.parameters(), lr=args.lr)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
train_acc_list, test_acc_list = train(model, optimizer, loader_src, loader_tar)
jd = {"train_acc": train_acc_list, "test_acc": test_acc_list}
with open(str(args.seed)+'/acc'+str(args.person)+'.json', 'w') as f:
json.dump(jd, f)
class Solver(object):
def __init__(self,
src_trainset_loader,
src_valset_loader,
tgt_trainset_loader=None,
config=None):
self.use_cuda = torch.cuda.is_available()
self.device = torch.device('cuda' if self.use_cuda else 'cpu')
self.src_trainset_loader = src_trainset_loader
self.src_valset_loader = src_valset_loader
self.tgt_trainset_loader = tgt_trainset_loader
self.num_iters = config.num_iters
self.resume_iters = config.resume_iters
self.lr = config.lr
self.beta1 = config.beta1
self.beta2 = config.beta2
self.src_only = config.src_only
self.exp_name = config.name
os.makedirs(config.ckp_dir, exist_ok=True)
self.ckp_dir = os.path.join(config.ckp_dir, self.exp_name)
os.makedirs(self.ckp_dir, exist_ok=True)
self.log_interval = config.log_interval
self.save_interval = config.save_interval
self.use_wandb = config.use_wandb
self.build_model()
def build_model(self):
self.model = DANN().to(self.device)
self.optimizer = torch.optim.Adam(self.model.parameters(),
lr=self.lr,
betas=[self.beta1, self.beta2])
def save_checkpoint(self, step):
state = {
'state_dict': self.model.state_dict(),
'optimizer': self.optimizer.state_dict()
}
new_checkpoint_path = os.path.join(self.ckp_dir,
'{}-dann.pth'.format(step + 1))
torch.save(state, new_checkpoint_path)
print('model saved to %s' % new_checkpoint_path)
def load_checkpoint(self, resume_iters):
print(
'Loading the trained models from step {}...'.format(resume_iters))
new_checkpoint_path = os.path.join(self.ckp_dir,
'{}-dann.pth'.format(resume_iters))
state = torch.load(new_checkpoint_path)
self.model.load_state_dict(state['state_dict'])
self.optimizer.load_state_dict(state['optimizer'])
print('model loaded from %s' % new_checkpoint_path)
def reset_grad(self):
"""Reset the gradient buffers."""
self.optimizer.zero_grad()
def train(self):
criterion = nn.NLLLoss()
best_acc = 0
best_loss = 1e15
iteration = 0
if self.resume_iters:
print("resuming step %d ..." % self.resume_iters)
iteration = self.resume_iters
self.load_checkpoint(self.resume_iters)
best_loss, best_acc = self.eval()
while iteration < self.num_iters:
self.model.train()
self.optimizer.zero_grad()
try:
data, label = next(src_data_iter)
except:
src_data_iter = iter(self.src_trainset_loader)
data, label = next(src_data_iter)
data, label = data.to(self.device), label.to(self.device)
src_batch_size = data.size(0)
p = float(iteration) / (self.num_iters)
alpha = 2. / (1. + np.exp(-10 * p)) - 1
src_domain = torch.zeros((src_batch_size, ),
dtype=torch.long,
device=self.device)
class_output, domain_output = self.model(data, alpha)
src_c_loss = criterion(class_output, label)
src_d_loss = criterion(domain_output, src_domain)
loss = src_c_loss + src_d_loss
if self.src_only:
tgt_d_loss = torch.zeros(1)
else:
try:
tgt_data, _ = next(tgt_data_iter)
except:
tgt_data_iter = iter(self.tgt_trainset_loader)
tgt_data, _ = next(tgt_data_iter)
tgt_data = tgt_data.to(self.device)
tgt_batch_size = tgt_data.size(0)
tgt_domain = torch.ones((tgt_batch_size, ),
dtype=torch.long,
device=self.device)
_, domain_output = self.model(tgt_data, alpha)
tgt_d_loss = criterion(domain_output, tgt_domain)
loss += tgt_d_loss
loss.backward()
self.optimizer.step()
# Output training stats
if (iteration + 1) % self.log_interval == 0:
print(
'Iteration: {:5d}\tloss: {:.6f}\tloss_src_class: {:.6f}\tloss_src_domain: {:.6f}\tloss_tgt_domain: {:.6f}'
.format(iteration + 1, loss.item(), src_c_loss.item(),
src_d_loss.item(), tgt_d_loss.item()))
if self.use_wandb:
import wandb
wandb.log(
{
"loss": loss.item(),
"loss_src_class": src_c_loss.item(),
"loss_src_domain": src_d_loss.item(),
"loss_tgt_domain": tgt_d_loss.item()
},
step=iteration + 1)
# Save model checkpoints
if (iteration + 1) % self.save_interval == 0 and iteration > 0:
val_loss, val_acc = self.eval()
if self.use_wandb:
import wandb
wandb.log({
"val_loss": val_loss,
"val_acc": val_acc
},
step=iteration + 1,
commit=False)
self.save_checkpoint(iteration)
if (val_acc > best_acc):
print('val acc: %.2f > %.2f' % (val_acc, best_acc))
best_acc = val_acc
if (val_loss < best_loss):
print('val loss: %.4f < %.4f' % (val_loss, best_loss))
best_loss = val_loss
iteration += 1
def eval(self):
criterion = nn.CrossEntropyLoss()
self.model.eval()
val_loss = 0.0
correct = 0.0
with torch.no_grad():
for data, label in self.src_valset_loader:
data, label = data.to(self.device), label.to(self.device)
output, _ = self.model(data)
val_loss += criterion(output, label).item()
pred = torch.exp(output).max(1, keepdim=True)[1]
correct += pred.eq(label.view_as(pred)).sum().item()
val_loss /= len(self.src_valset_loader)
val_acc = 100. * correct / len(self.src_valset_loader.dataset)
print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.
format(val_loss, correct, len(self.src_valset_loader.dataset),
val_acc))
return val_loss, val_acc
def build_model(self):
self.model = DANN().to(self.device)
self.optimizer = torch.optim.Adam(self.model.parameters(),
lr=self.lr,
betas=[self.beta1, self.beta2])
def fit_with_adaptation():
pass
def eval(model, val_dataloader):
model.eval()
pass
if __name__ == '__main__':
transformation = transforms.Compose([
transforms.Resize(230),
transforms.CenterCrop(224),
transforms.ToTensor(),
# transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) # Normalizes tensor with mean and standard deviation of IMAGENET
])
pacs = PACS(root=PACS_PATH,
transform=transformation,
num_workers=4,
batch_size=BATCH_SIZE)
dann = DANN(pretrained=True, num_domains=2, num_classes=7)
fit_simple(dann,
epochs=5,
train_dataloader=pacs[SOURCE_DOMAIN],
val_dataloader=pacs[TARGET_DOMAIN])