def train_classifier(netG, args, device, testset=None):
print('\nTraining a classifier')
loader = data_utils.DataLoader(range(args.netC_per_epoch),
batch_size=args.netC_batch_size,
shuffle=True,
num_workers=8)
netC = network.LeNet(args.image_size, args.nc, args.ny).to(device)
optimizerC = optim.Adam(netC.parameters(),
lr=args.netC_lr,
betas=(args.netC_beta1, args.netC_beta2))
criterionCE = nn.CrossEntropyLoss().to(device)
for epoch in range(1, args.netC_epochs + 1):
adjust_learning_rate(optimizerC, epoch, args.netC_lr,
args.netC_lr_period)
info = {'num': 0, 'loss_C': 0, 'acc': 0}
# train network
netC.train()
for i, x in enumerate(loader):
# forward
fake_z = make_z(len(x), args.nz).to(device) # B x nz
fake_y = make_y(len(x), args.ny).to(device) # B
with torch.no_grad():
fake_x = netG(fake_z, fake_y) # B x nc x H x W
out_fake = netC(fake_x) # B x nc
loss_C = criterionCE(out_fake, fake_y)
acc = accuracy(out_fake, fake_y)
# backward
optimizerC.zero_grad()
loss_C.backward()
optimizerC.step()
# update loss info
info['num'] += 1
info['loss_C'] += loss_C.item()
info['acc'] += acc
# evaluate performance
info = normalize_info(info)
message = "Epoch: {} C: {:.4f} acc (train): {:.4f}".format(
epoch, info['loss_C'], info['acc'])
if testset and epoch % args.netC_eval_period == 0:
test_acc = eval_classifier(netC, args, device, testset)
message += " acc (test): {:.4f}".format(test_acc)
print(message)
print('')
return netC
def fitting_capacity(samples, testset, nc=1, ny=10, epochs=40, eval_period=10, verbose=False):
netC = network.LeNet(32, nc, ny)
netC = nn.DataParallel(netC, [0]).cuda()
optimizerC = optim.Adam(netC.parameters(), lr=0.001, betas=(0.5, 0.999))
criterionCE = nn.CrossEntropyLoss()
loader = data_utils.DataLoader(samples, batch_size=128, shuffle=True, num_workers=8)
test_acc = 0
for epoch in range(1, epochs + 1):
adjust_learning_rate(optimizerC, epoch, 0.001, epochs//2)
info = {'num': 0, 'loss_C': 0, 'acc': 0}
# train network
netC.train()
for i, (x, y) in enumerate(loader):
# forward
x = x.cuda()
y = y.cuda()
out = netC(x) # B x nc
loss_C = criterionCE(out, y)
# backward
optimizerC.zero_grad()
loss_C.backward()
optimizerC.step()
# update loss info
info['num'] += 1
info['loss_C'] += loss_C.item()
info['acc'] += accuracy(out, y)
# evaluate performance
info = normalize_info(info)
message = "Epoch: {} C: {:.4f} acc (train): {:.4f}".format(epoch, info['loss_C'], info['acc'])
if epoch % eval_period == 0:
test_acc = eval_classifier(netC, testset)
message += " acc (test): {:.4f}".format(test_acc)
if verbose:
print(message)
return test_acc
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('--method', type=str, default='CDAN-E', choices=['CDAN', 'CDAN-E', 'DANN'])
parser.add_argument('--task', default='USPS2MNIST', help='task to perform')
parser.add_argument('--batch_size', type=int, default=256, help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size', type=int, default=1000, help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)')
parser.add_argument('--gpu_id', type=str,default="0", help='cuda device id')
parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)')
parser.add_argument('--log_interval', type=int, default=10, help='how many batches to wait before logging training status')
parser.add_argument('--random', type=bool, default=False, help='whether to use random')
parser.add_argument('--output_dir',type=str,default="digits/u2m")
parser.add_argument('--cla_plus_weight',type=float,default=0.3)
parser.add_argument('--cyc_loss_weight',type=float,default=0.01)
parser.add_argument('--weight_in_loss_g',type=str,default='1,0.01,0.1,0.1')
args = parser.parse_args()
torch.manual_seed(args.seed)
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
# train config
import os.path as osp
import datetime
config = {}
config['method'] = args.method
config["gpu"] = args.gpu_id
config['cyc_loss_weight'] = args.cyc_loss_weight
config['cla_plus_weight'] = args.cla_plus_weight
config['weight_in_loss_g'] = args.weight_in_loss_g
config["epochs"] = args.epochs
config["output_for_test"] = True
config["output_path"] = "snapshot/" + args.output_dir
if not osp.exists(config["output_path"]):
os.system('mkdir -p ' + config["output_path"])
config["out_file"] = open(osp.join(config["output_path"], "log_{}_{}.txt".
format(args.task,str(datetime.datetime.utcnow()))),
"w")
config["out_file"].write(str(config))
config["out_file"].flush()
source_list = '/data/usps/usps_train.txt'
target_list = '/data/mnist/mnist_train.txt'
test_list = '/data/mnist/mnist_test.txt'
start_epoch = 1
decay_epoch = 6
train_loader = torch.utils.data.DataLoader(
ImageList(open(source_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.batch_size, shuffle=True, num_workers=1, drop_last=True)
train_loader1 = torch.utils.data.DataLoader(
ImageList(open(target_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.batch_size, shuffle=True, num_workers=1, drop_last=True)
test_loader = torch.utils.data.DataLoader(
ImageList(open(test_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.test_batch_size, shuffle=True, num_workers=1)
model = network.LeNet()
# model = model.cuda()
class_num = 10
# 添加G，D，和额外的分类器
import itertools
from utils import ReplayBuffer
import net
z_dimension = 500
D_s = network.models["Discriminator_um"]()
# D_s = D_s.cuda()
G_s2t = network.models["Generator_um"](z_dimension, 500)
# G_s2t = G_s2t.cuda()
D_t = network.models["Discriminator_um"]()
# D_t = D_t.cuda()
G_t2s = network.models["Generator_um"](z_dimension, 500)
# G_t2s = G_t2s.cuda()
criterion_GAN = torch.nn.MSELoss()
criterion_cycle = torch.nn.L1Loss()
criterion_identity = torch.nn.L1Loss()
criterion_Sem = torch.nn.L1Loss()
optimizer_G = torch.optim.Adam(itertools.chain(G_s2t.parameters(), G_t2s.parameters()), lr=0.0003)
optimizer_D_s = torch.optim.Adam(D_s.parameters(), lr=0.0003)
optimizer_D_t = torch.optim.Adam(D_t.parameters(), lr=0.0003)
fake_S_buffer = ReplayBuffer()
fake_T_buffer = ReplayBuffer()
## 添加分类器
classifier1 = net.Net(500, class_num)
# classifier1 = classifier1.cuda()
classifier1_optim = optim.Adam(classifier1.parameters(), lr=0.0003)
if args.random:
random_layer = network.RandomLayer([model.output_num(), class_num], 500)
ad_net = network.AdversarialNetwork(500, 500)
# random_layer.cuda()
else:
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num() * class_num, 500)
# ad_net = ad_net.cuda()
optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=0.0005, momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(), lr=args.lr, weight_decay=0.0005, momentum=0.9)
for epoch in range(1, args.epochs + 1):
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.5
train(args, model, ad_net, random_layer, train_loader, train_loader1, optimizer, optimizer_ad, epoch, start_epoch, args.method,
D_s, D_t, G_s2t, G_t2s, criterion_Sem, criterion_GAN, criterion_cycle, criterion_identity, optimizer_G,
optimizer_D_t, optimizer_D_s,
classifier1, classifier1_optim, fake_S_buffer, fake_T_buffer
)
test(args,epoch,config, model, test_loader)
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('--method', type=str, default='CDAN-E', choices=['CDAN', 'CDAN-E', 'DANN'])
parser.add_argument('--task', default='MNIST2USPS', help='task to perform')
parser.add_argument('--batch_size', type=int, default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size', type=int, default=1000,
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--gpu_id', type=str, default='0',
help='cuda device id')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log_interval', type=int, default=10,
help='how many batches to wait before logging training status')
parser.add_argument('--random', type=bool, default=False,
help='whether to use random')
args = parser.parse_args()
torch.manual_seed(args.seed)
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
source_list = '/data/mnist/mnist_train.txt'
target_list = '/data/usps/usps_train.txt'
test_list = '/data/usps/usps_test.txt'
start_epoch = 1
decay_epoch = 5
train_loader = torch.utils.data.DataLoader(
ImageList(open(source_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.batch_size, shuffle=True, num_workers=1, drop_last=True)
train_loader1 = torch.utils.data.DataLoader(
ImageList(open(target_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.batch_size, shuffle=True, num_workers=1, drop_last=True)
test_loader = torch.utils.data.DataLoader(
ImageList(open(test_list).readlines(), transform=transforms.Compose([
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]), mode='L'),
batch_size=args.test_batch_size, shuffle=True, num_workers=1)
model = network.LeNet()
# model = model.cuda()
class_num = 10
if args.random:
random_layer = network.RandomLayer([model.output_num(), class_num], 500)
ad_net = network.AdversarialNetwork(500, 500)
# random_layer.cuda()
else:
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num() * class_num, 500)
# ad_net = ad_net.cuda()
optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=0.0005, momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(), lr=args.lr, weight_decay=0.0005, momentum=0.9)
for epoch in range(1, args.epochs + 1):
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.5
train(args, model, ad_net, random_layer, train_loader, train_loader1, optimizer, optimizer_ad, epoch, start_epoch, args.method)
test(args, model, test_loader)
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('--method',
type=str,
default='CDAN-E',
choices=['CDAN', 'CDAN-E', 'DANN'])
parser.add_argument('--task', default='USPS2MNIST', help='task to perform')
parser.add_argument('--batch_size',
type=int,
default=128,
help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size',
type=int,
default=1000,
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=550,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=5e-5,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--lr2',
type=float,
default=0.005,
metavar='LR2',
help='learning rate2 (default: 0.01)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--gpu_id',
type=str,
default='0',
help='cuda device id')
parser.add_argument(
'--log_interval',
type=int,
default=10,
help='how many batches to wait before logging training status')
parser.add_argument('--random',
type=bool,
default=False,
help='whether to use random')
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
if args.task == 'USPS2MNIST':
source_list, ordinary_train_dataset, target_list, test_list, ccp = data_loader(
task='U2M')
start_epoch = 50
decay_epoch = 600
elif args.task == 'MNIST2USPS':
source_list, ordinary_train_dataset, target_list, test_list, ccp = data_loader(
task='M2U')
start_epoch = 50
decay_epoch = 600
else:
raise Exception('task cannot be recognized!')
train_loader = torch.utils.data.DataLoader(dataset=source_list,
batch_size=args.batch_size,
shuffle=True,
num_workers=8,
drop_last=True)
train_loader1 = torch.utils.data.DataLoader(dataset=target_list,
batch_size=args.batch_size,
shuffle=True,
num_workers=8,
drop_last=True)
o_train_loader = torch.utils.data.DataLoader(
dataset=ordinary_train_dataset,
batch_size=args.test_batch_size,
shuffle=True,
num_workers=8)
test_loader = torch.utils.data.DataLoader(dataset=test_list,
batch_size=args.test_batch_size,
shuffle=True,
num_workers=8)
model = network.LeNet()
model = model.cuda()
class_num = 10
if args.random:
random_layer = network.RandomLayer([model.output_num(), class_num],
500)
ad_net = network.AdversarialNetwork(500, 500)
random_layer.cuda()
else:
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num() * class_num,
500)
ad_net = ad_net.cuda()
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(),
lr=args.lr2,
weight_decay=0.0005,
momentum=0.9)
save_table = np.zeros(shape=(args.epochs, 3))
for epoch in range(1, args.epochs + 1):
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.5
train(args, model, ad_net, random_layer, train_loader, train_loader1,
optimizer, optimizer_ad, epoch, start_epoch, args.method, ccp)
acc1 = test(args, model, o_train_loader)
acc2 = test(args, model, test_loader)
save_table[epoch - 1, :] = epoch - 50, acc1, acc2
np.savetxt(args.task + '_.txt', save_table, delimiter=',', fmt='%1.3f')
np.savetxt(args.task + '_.txt', save_table, delimiter=',', fmt='%1.3f')
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('method',
type=str,
default='CDAN-E',
choices=[
'CDAN', 'CDAN-E', 'DANN', 'IWDAN', 'NANN',
'IWDANORACLE', 'IWCDAN', 'IWCDANORACLE',
'IWCDAN-E', 'IWCDAN-EORACLE'
])
parser.add_argument('--task',
default='mnist2usps',
help='task to perform',
choices=['usps2mnist', 'mnist2usps'])
parser.add_argument('--batch_size',
type=int,
default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size',
type=int,
default=1000,
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=70,
metavar='N',
help='number of epochs to train (default: 70)')
parser.add_argument('--lr',
type=float,
default=0.0,
metavar='LR',
help='learning rate (default: 0.02)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--seed',
type=int,
default=42,
metavar='S',
help='random seed (default: 42)')
parser.add_argument(
'--log_interval',
type=int,
default=50,
help='how many batches to wait before logging training status')
parser.add_argument(
'--root_folder',
type=str,
default='data/usps2mnist/',
help="The folder containing the datasets and the lists")
parser.add_argument('--output_dir',
type=str,
default='results',
help="output directory")
parser.add_argument(
"-u",
"--mu",
help="Hyperparameter of the coefficient of the domain adversarial loss",
type=float,
default=1.0)
parser.add_argument('--ratio', type=float, default=0, help='ratio option')
parser.add_argument('--ma',
type=float,
default=0.5,
help='weight for the moving average of iw')
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Running the JSD experiment on fewer epochs for efficiency
if args.ratio >= 100:
args.epochs = 25
print('Running {} on {} for {} epochs on task {}'.format(
args.method, args.device, args.epochs, args.task))
# Set random number seed.
np.random.seed(args.seed)
torch.manual_seed(args.seed)
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
if args.task == 'usps2mnist':
# CDAN parameters
decay_epoch = 6
decay_frac = 0.5
lr = 0.02
start_epoch = 1
model = network.LeNet(args.ma)
build_dataset = build_uspsmnist
source_list = os.path.join(args.root_folder, 'usps_train.txt')
source_path = os.path.join(args.root_folder, 'usps_train_dataset.pkl')
target_list = os.path.join(args.root_folder, 'mnist_train.txt')
target_path = os.path.join(args.root_folder, 'mnist_train_dataset.pkl')
test_list = os.path.join(args.root_folder, 'mnist_test.txt')
test_path = os.path.join(args.root_folder, 'mnist_test_dataset.pkl')
elif args.task == 'mnist2usps':
decay_epoch = 5
decay_frac = 0.5
lr = 0.02
start_epoch = 1
model = network.LeNet(args.ma)
build_dataset = build_uspsmnist
source_list = os.path.join(args.root_folder, 'mnist_train.txt')
source_path = os.path.join(args.root_folder, 'mnist_train_dataset.pkl')
target_list = os.path.join(args.root_folder, 'usps_train.txt')
target_path = os.path.join(args.root_folder, 'usps_train_dataset.pkl')
test_list = os.path.join(args.root_folder, 'usps_test.txt')
test_path = os.path.join(args.root_folder, 'usps_test_dataset.pkl')
else:
raise Exception('Task cannot be recognized!')
out_log_file = open(os.path.join(args.output_dir, "log.txt"), "w")
out_log_file_train = open(os.path.join(args.output_dir, "log_train.txt"),
"w")
if not os.path.exists(args.output_dir):
os.mkdir(args.output_dir)
model = model.to(args.device)
class_num = 10
if args.lr > 0:
lr = args.lr
print('Starting loading data')
sys.stdout.flush()
t_data = time.time()
if os.path.exists(source_path):
print('Found existing dataset for source')
with open(source_path, 'rb') as f:
[source_samples, source_labels] = pickle.load(f)
source_samples, source_labels = torch.Tensor(source_samples).to(
args.device), torch.LongTensor(source_labels).to(args.device)
else:
print('Building dataset for source and writing to {}'.format(
source_path))
source_samples, source_labels = build_dataset(source_list, source_path,
args.root_folder,
args.device)
if os.path.exists(target_path):
print('Found existing dataset for target')
with open(target_path, 'rb') as f:
[target_samples, target_labels] = pickle.load(f)
target_samples, target_labels = torch.Tensor(target_samples).to(
args.device), torch.LongTensor(target_labels).to(args.device)
else:
print('Building dataset for target and writing to {}'.format(
target_path))
target_samples, target_labels = build_dataset(target_list, target_path,
args.root_folder,
args.device)
if os.path.exists(test_path):
print('Found existing dataset for test')
with open(test_path, 'rb') as f:
[test_samples, test_labels] = pickle.load(f)
test_samples, test_labels = torch.Tensor(test_samples).to(
args.device), torch.LongTensor(test_labels).to(args.device)
else:
print('Building dataset for test and writing to {}'.format(test_path))
test_samples, test_labels = build_dataset(test_list, test_path,
args.root_folder,
args.device)
print('Data loaded in {}'.format(time.time() - t_data))
if args.ratio == 1:
# RATIO OPTION 1
# 30% of the samples from the first 5 classes
print('Using option 1, ie [0.3] * 5 + [1] * 5')
ratios_source = [0.3] * 5 + [1] * 5
ratios_target = [1] * 10
elif args.ratio >= 200:
s_ = subsampling[int(args.ratio) % 100]
ratios_source = s_[0]
ratios_target = [1] * 10
print(
'Using random subset ratio {} of the source, with theoretical jsd {}'
.format(args.ratio, s_[1]))
elif 200 > args.ratio >= 100:
s_ = subsampling[int(args.ratio) % 100]
ratios_source = [1] * 10
ratios_target = s_[0]
print(
'Using random subset ratio {} of the target, with theoretical jsd {}'
.format(args.ratio, s_[1]))
else:
# ORIGINAL DATASETS
print('Using original datasets')
ratios_source = [1] * 10
ratios_target = [1] * 10
ratios_test = ratios_target
# Subsample dataset if need be
source_samples, source_labels = sample_ratios(source_samples,
source_labels, ratios_source)
target_samples, target_labels = sample_ratios(target_samples,
target_labels, ratios_target)
test_samples, test_labels = sample_ratios(test_samples, test_labels,
ratios_test)
# compute labels distribution on the source and target domain
source_label_distribution = np.zeros((class_num))
for img in source_labels:
source_label_distribution[int(img.item())] += 1
print("Total source samples: {}".format(np.sum(source_label_distribution)),
flush=True)
print("Source samples per class: {}".format(source_label_distribution))
source_label_distribution /= np.sum(source_label_distribution)
write_list(out_log_file, source_label_distribution)
print("Source label distribution: {}".format(source_label_distribution))
target_label_distribution = np.zeros((class_num))
for img in target_labels:
target_label_distribution[int(img.item())] += 1
print("Total target samples: {}".format(np.sum(target_label_distribution)),
flush=True)
print("Target samples per class: {}".format(target_label_distribution))
target_label_distribution /= np.sum(target_label_distribution)
write_list(out_log_file, target_label_distribution)
print("Target label distribution: {}".format(target_label_distribution))
test_label_distribution = np.zeros((class_num))
for img in test_labels:
test_label_distribution[int(img.item())] += 1
print("Test samples per class: {}".format(test_label_distribution))
test_label_distribution /= np.sum(test_label_distribution)
write_list(out_log_file, test_label_distribution)
print("Test label distribution: {}".format(test_label_distribution))
mixture = (source_label_distribution + target_label_distribution) / 2
jsd = (scipy.stats.entropy(source_label_distribution, qk=mixture) +
scipy.stats.entropy(target_label_distribution, qk=mixture)) / 2
print("JSD source to target : {}".format(jsd))
mixture_2 = (test_label_distribution + target_label_distribution) / 2
jsd_2 = (scipy.stats.entropy(test_label_distribution, qk=mixture_2) +
scipy.stats.entropy(target_label_distribution, qk=mixture_2)) / 2
print("JSD test to target : {}".format(jsd_2))
out_wei_file = open(
os.path.join(args.output_dir, "log_weights_{}.txt".format(jsd)), "w")
write_list(out_wei_file, [round(x, 4) for x in source_label_distribution])
write_list(out_wei_file, [round(x, 4) for x in target_label_distribution])
out_wei_file.write(str(jsd) + "\n")
true_weights = torch.tensor(target_label_distribution /
source_label_distribution,
dtype=torch.float,
requires_grad=False)[:, None].to(args.device)
print("True weights : {}".format(true_weights[:, 0].cpu().numpy()))
if 'CDAN' in args.method:
ad_net = network.AdversarialNetwork(model.output_num() * class_num,
500,
sigmoid='WDANN' not in args.method)
else:
ad_net = network.AdversarialNetwork(model.output_num(),
500,
sigmoid='WDANN' not in args.method)
ad_net = ad_net.to(args.device)
optimizer = optim.SGD(model.parameters(),
lr=lr,
weight_decay=0.0005,
momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(),
lr=lr,
weight_decay=0.0005,
momentum=0.9)
# Maintain two quantities for the QP.
cov_mat = torch.tensor(np.zeros((class_num, class_num), dtype=np.float32),
requires_grad=False).to(args.device)
pseudo_target_label = torch.tensor(np.zeros((class_num, 1),
dtype=np.float32),
requires_grad=False).to(args.device)
# Maintain one weight vector for BER.
class_weights = torch.tensor(1.0 / source_label_distribution,
dtype=torch.float,
requires_grad=False).to(args.device)
for epoch in range(1, args.epochs + 1):
start_time_test = time.time()
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * decay_frac
test(args,
epoch,
model,
test_samples,
test_labels,
start_time_test,
out_log_file,
name='Target test')
train(args, model, ad_net, source_samples, source_labels,
target_samples, target_labels, optimizer, optimizer_ad, epoch,
start_epoch, args.method, source_label_distribution,
out_wei_file, cov_mat, pseudo_target_label, class_weights,
true_weights)
test(args,
epoch + 1,
model,
test_samples,
test_labels,
start_time_test,
out_log_file,
name='Target test')
test(args,
epoch + 1,
model,
source_samples,
source_labels,
start_time_test,
out_log_file_train,
name='Source train')
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('--method',
type=str,
default='CDAN-E',
choices=['CDAN', 'CDAN-E', 'DANN'])
parser.add_argument('--task',
default='MNIST2USPS',
help='MNIST2USPS or MNIST2USPS')
parser.add_argument('--batch_size',
type=int,
default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size',
type=int,
default=1000,
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=100,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--gpu_id',
default='0',
type=str,
help='cuda device id')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log_interval',
type=int,
default=10,
help='how many batches to wait before logging training status')
parser.add_argument('--random',
type=bool,
default=False,
help='whether to use random')
parser.add_argument('--mdd_weight', type=float, default=0.05)
parser.add_argument('--entropic_weight', type=float, default=0)
parser.add_argument("--use_seed", type=bool, default=True)
args = parser.parse_args()
import random
if (args.use_seed):
torch.manual_seed(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
torch.backends.cudnn.deterministic = True
import os.path as osp
import datetime
config = {}
config["output_path"] = "snapshot/" + args.task
config['seed'] = args.seed
config["torch_seed"] = torch.initial_seed()
config["torch_cuda_seed"] = torch.cuda.initial_seed()
config["mdd_weight"] = args.mdd_weight
config["entropic_weight"] = args.entropic_weight
if not osp.exists(config["output_path"]):
os.system('mkdir -p ' + config["output_path"])
config["out_file"] = open(
osp.join(
config["output_path"],
"log_{}_{}.txt".format(args.task,
str(datetime.datetime.utcnow()))), "w")
torch.manual_seed(args.seed)
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
if args.task == 'USPS2MNIST':
source_list = 'data/usps2mnist/usps_train.txt'
target_list = 'data/usps2mnist/mnist_train.txt'
test_list = 'data/usps2mnist/mnist_test.txt'
start_epoch = 1
decay_epoch = 6
elif args.task == 'MNIST2USPS':
source_list = 'data/usps2mnist/mnist_train.txt'
target_list = 'data/usps2mnist/usps_train.txt'
test_list = 'data/usps2mnist/usps_test.txt'
start_epoch = 1
decay_epoch = 5
else:
raise Exception('task cannot be recognized!')
train_loader = torch.utils.data.DataLoader(ImageList(
open(source_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
train_loader1 = torch.utils.data.DataLoader(ImageList(
open(target_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
test_loader = torch.utils.data.DataLoader(ImageList(
open(test_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.test_batch_size,
shuffle=True,
num_workers=1)
model = network.LeNet()
model = model.cuda()
class_num = 10
if args.random:
random_layer = network.RandomLayer([model.output_num(), class_num],
500)
ad_net = network.AdversarialNetwork(500, 500)
random_layer.cuda()
else:
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num() * class_num,
500)
ad_net = ad_net.cuda()
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
config["out_file"].write(str(config) + "\n")
config["out_file"].flush()
for epoch in range(1, args.epochs + 1):
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.5
train(args, model, ad_net, random_layer, train_loader, train_loader1,
optimizer, optimizer_ad, epoch, start_epoch, args.method)
test(args, epoch, config, model, test_loader)
def main():
# Training settings
parser = argparse.ArgumentParser(description='CDAN USPS MNIST')
parser.add_argument('--method', type=str, default='DANN')
parser.add_argument('--task', default='MNIST2USPS', help='task to perform')
parser.add_argument('--batch_size',
type=int,
default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--test_batch_size',
type=int,
default=1000,
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=20,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--gpu_id',
type=str,
default='0',
help='cuda device id')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log_interval',
type=int,
default=10,
help='how many batches to wait before logging training status')
parser.add_argument('--random',
type=bool,
default=False,
help='whether to use random')
parser.add_argument('--weight',
type=int,
default=0,
help="whether use weights during transfer")
parser.add_argument('--temp_max',
type=float,
default=5.,
help="weight relaxation parameter")
parser.add_argument('--alpha',
type=float,
default=5.,
help="weight relaxation parameter")
args = parser.parse_args()
torch.manual_seed(args.seed)
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
if args.task == 'USPS2MNIST':
source_list = '../data/usps2mnist/usps_train_shift_20.txt'
target_list = '../data/usps2mnist/mnist_train.txt'
test_list = '../data/usps2mnist/mnist_test.txt'
start_epoch = 1
decay_epoch = 6
elif args.task == 'MNIST2USPS':
source_list = '../data/usps2mnist/mnist_train_shift_20.txt'
target_list = '../data/usps2mnist/usps_train.txt'
test_list = '../data/usps2mnist/usps_test.txt'
start_epoch = 1
decay_epoch = 5
else:
raise Exception('task cannot be recognized!')
train_loader = torch.utils.data.DataLoader(ImageList(
open(source_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
train_loader1 = torch.utils.data.DataLoader(ImageList(
open(target_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
test_loader = torch.utils.data.DataLoader(ImageList(
open(test_list).readlines(),
transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
]),
mode='L'),
batch_size=args.test_batch_size,
shuffle=True,
num_workers=1)
model = network.LeNet()
model = model.cuda()
class_num = 10
if args.method is 'DANN':
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num(), 500)
elif args.method is 'Y_DAN':
random_layer = None
ad_net = network.AdversarialNetwork(model.output_num(),
500,
output_dim=class_num)
elif args.method is 'CDAN':
if args.random:
random_layer = network.RandomLayer([model.output_num(), class_num],
500)
random_layer.cuda()
else:
random_layer = None
ad_net = network.AdversarialNetwork(500 * 10, 500)
else:
raise ValueError('Method cannot be recognized.')
ad_w_net = network.AdversarialNetwork(model.output_num(),
500,
output_dim=1)
ad_net = ad_net.cuda()
ad_w_net = ad_w_net.cuda()
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
optimizer_ad = optim.SGD(ad_net.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
optimizer_ad_w = optim.SGD(ad_w_net.parameters(),
lr=args.lr,
weight_decay=0.0005,
momentum=0.9)
for epoch in range(1, args.epochs + 1):
print("epoch", epoch)
if epoch % decay_epoch == 0:
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.5
train(args,
epoch,
model,
ad_net,
ad_w_net,
train_loader,
train_loader1,
optimizer,
optimizer_ad,
optimizer_ad_w,
epoch,
start_epoch,
args.method,
random_layer=random_layer)
test(args, model, test_loader)
