def __init__(self, env, args):
# define some important
self.env = env
self.args = args
# trying to define the network
self.net = Net(self.env.action_space.n)
self.target_net = Net(self.env.action_space.n)
# make sure the target net has the same weights as the network
self.target_net.load_state_dict(self.net.state_dict())
if self.args.cuda:
self.net.cuda()
self.target_net.cuda()
# define the optimizer
self.optimizer = torch.optim.Adam(self.net.parameters(),
lr=self.args.lr)
# define the replay memory
self.buffer = replay_memory(self.args.buffer_size)
# define the linear schedule of the exploration
self.exploration_schedule = linear_schedule(int(self.args.total_timesteps * self.args.exploration_fraction), \
self.args.final_ratio, self.args.init_ratio)
# create the folder to save the models
if not os.path.exists(self.args.save_dir):
os.mkdir(self.args.save_dir)
# set the environment folder
self.model_path = os.path.join(self.args.save_dir, self.args.env_name)
if not os.path.exists(self.model_path):
os.mkdir(self.model_path)
def __init__(self, train_loader, test_loader, config):
self.config = config
self.device = config.device
self.train_loader = train_loader
self.test_loader = test_loader
self.n_epoch = config.n_epoch
self.lr = config.lr
self.gamma = config.gamma
self.device = config.device
# self.start_epoch = 1
self.start_itr = 1
n_classes = len(self.train_loader.dataset.classes)
self.model = Net(n_classes=n_classes).to(self.device)
print(self.model)
print('Initialized model...\n')
self.optim = torch.optim.Adadelta(self.model.parameters(), self.lr)
self.scheduler = StepLR(self.optim, step_size=1, gamma=self.gamma)
# if not self.config.model_state_path == '':
# self._load_models(self.config.model_state_path)
self.writer = SummaryWriter(log_dir=self.config.log_dir)
def _setup(self, config):
print("Loading word vectors...")
word2index, word_vecs = process_word_vecs(FAST_TEXT)
# Note that the word embeddings are normalized.
self.wv = WV(F.normalize(word_vecs), word2index)
# wv = WV(word_vecs, word2index)
print("Done.")
self.corpus_size = config["corpus_size"]
bigram_fn_name = "diff"
out_bigram_dim = 300
dist_fn_name = "cos_dist"
loss_fn_name = "mrl"
margin = config["margin"]
self.lr = config["lr"]
self.num_epochs = config["num_epochs"]
self.batch_size = config["batch_size"]
self.test_model = True
self.test_freq = config["test_freq"]
with open(PROCESSED / "train.{}.pkl".format(str(self.corpus_size)), "rb") as f:
wiki_train = pickle.load(f)
with open(PROCESSED / "valid.pkl", "rb") as f:
wiki_valid = pickle.load(f)
wiki_combined = wiki_train + wiki_valid
self.corpus = Corpus("wiki", wiki_combined, self.wv, filter_stopwords=True)
self.model = Net(
self.wv.vecs.size(1), BigramEncoder(bigram_fn_name), out_bigram_dim
)
self.model.to(device)
self.dist_fn = DistanceFunction(dist_fn_name)
self.loss_fn = LossFunction(loss_fn_name, margin=margin)
self.device = device
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr)
torch.manual_seed(config["seed"])
print("Traninig on Wikipedia corpus of size {}".format(self.corpus_size))
def evaluate():
if mx.context.num_gpus() > 0:
ctx = mx.gpu()
else:
ctx = mx.cpu(0)
# loading configs
args = Options().parse()
cfg = Configs(args.config_path)
# set logging level
logging.basicConfig(level=logging.INFO)
# images
content_image = tensor_load_rgbimage(cfg.content_image,
ctx,
size=cfg.val_img_size,
keep_asp=True)
style_image = tensor_load_rgbimage(cfg.style_image,
ctx,
size=cfg.val_style_size)
style_image = preprocess_batch(style_image)
# model
style_model = Net(ngf=cfg.ngf)
style_model.collect_params().load(cfg.val_model, ctx=ctx)
# forward
output = style_model(content_image, style_image)
# save img
tensor_save_bgrimage(output[0], cfg.output_img)
logging.info("Save img to {}".format(cfg.output_img))
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch Vec2Color Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=1500, metavar='N',
help='number of epochs to train (default: 1500)')
parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
help='learning rate (default: 1.0)')
parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
help='Learning rate step gamma (default: 0.7)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=False,
help='For Saving the current Model')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
file_names = ('capitalize', 'lower', 'upper', 'title')
x_df = pd.concat([pd.read_csv('doc2color/data/{}.csv'.format(file_name)) for file_name in file_names])
y_df = pd.concat([pd.read_csv('doc2color/data/rgb.csv')] * len(file_names))
tensor_x = torch.stack([torch.from_numpy(np.array(i)) for i in x_df.values.astype(np.float32)])
tensor_y = torch.stack([torch.from_numpy(np.array(i)) for i in y_df.values.astype(np.float32) / 255.0])
x_train, x_test, y_train, y_test = train_test_split(
tensor_x, tensor_y, test_size=0.01, random_state=args.seed)
train_dataset = torch.utils.data.TensorDataset(x_train, y_train)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size, shuffle=True, **kwargs)
test_dataset = torch.utils.data.TensorDataset(x_test, y_test)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=args.test_batch_size, shuffle=True, **kwargs)
model = Net().to(device)
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_loader, optimizer, epoch)
test(args, model, device, test_loader)
scheduler.step()
if args.save_model:
torch.save(model.state_dict(), "doc2color/pt_objects/vec2color.pt")
def __init__(self, envs, args):
self.envs = envs
self.args = args
# define the network
self.net = Net(self.envs.action_space.n)
if self.args.cuda:
self.net.cuda()
# define the optimizer
self.optimizer = torch.optim.RMSprop(self.net.parameters(),
lr=self.args.lr,
eps=self.args.eps,
alpha=self.args.alpha)
if not os.path.exists(self.args.save_dir):
os.mkdir(self.args.save_dir)
# check the saved path for envs..
self.model_path = self.args.save_dir + self.args.env_name + '/'
if not os.path.exists(self.model_path):
os.mkdir(self.model_path)
# get the obs..
self.batch_ob_shape = (self.args.num_processes * self.args.nsteps,
) + self.envs.observation_space.shape
self.obs = np.zeros(
(self.args.num_processes, ) + self.envs.observation_space.shape,
dtype=self.envs.observation_space.dtype.name)
self.obs[:] = self.envs.reset()
self.dones = [False for _ in range(self.args.num_processes)]
def create_optimizer(args, model: Net):
from torch.optim import Adam
from torch.optim.lr_scheduler import StepLR
opt1 = Adam(model.partial_parameters(True), lr=args.lr_ddr)
opt2 = Adam(model.partial_parameters(False), lr=args.lr)
lrs1 = StepLR(opt1, args.lr_steps, args.lr_gamma)
lrs1.last_epoch = args.start_epoch - 1
lrs2 = StepLR(opt2, args.lr_steps, args.lr_gamma)
lrs2.last_epoch = args.start_epoch - 1
return opt1, opt2, lrs1, lrs2
def initialize_networks(self):
self.networks = []
self.optimizers = []
for i in range(self.n_models):
model = Net()
model.apply(self.init_weights)
self.networks.append(model)
self.optimizers.append(
optim.SGD(model.parameters(),
lr=self.learning_rate,
momentum=self.momentum))
self.criterion = nn.CrossEntropyLoss()
def main(argv=sys.argv): f = Face() n = Net() o = Output() if(len(argv) >= 2): argv.pop(0) for arg in argv: print(arg) d = Input(arg) o.outFaces(f.detect(d.getImage(Input.FACES))) dogs,cats = n.result(d.getImage(Input.PREDICTION)) o.outAnimals(dogs,cats)
def main():
args = get_args()
print(args)
# set device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# device = 'cpu'
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
net = Net(device=device, mode=args.target, target_mode=args.target_mode)
net = net.eval()
net = net.to(device)
load_model(
net,
device,
fullpath='trained_models/Net_continuous_trained/checkpoint_274.pth.tar'
)
imgs_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Real-Images/png'
imgs_filelist = [
os.path.join(imgs_dir, img) for img in os.listdir(imgs_dir)
if img.endswith('.png')
]
for i, img in enumerate(imgs_filelist):
# x,x_paths, y, y_paths = data
x = plt.imread(img)
x = np.expand_dims(x, 0)
x = np.transpose(x, (0, 3, 1, 2))
x = x[:, :, 2:-2, 8:-8]
x = torch.Tensor(x).to(device)
with torch.no_grad():
out = net(x)
out = out.detach().cpu().numpy()
x = x.detach().cpu().numpy()
plt.figure(1)
if args.target_mode == 'discrete':
out = np.argmax(out, axis=1)
out = out[0]
# out = np.squeeze(out,0)
out = (out - np.min(out)) / (np.max(out) - np.min(out))
ax1 = plt.subplot(1, 3, 1)
# x = (x + 1) / 2
ax1.imshow(np.transpose(x[0], (1, 2, 0)))
ax3 = plt.subplot(1, 3, 3, sharex=ax1, sharey=ax1)
ax3.imshow(out, cmap='jet')
# plt.suptitle(label, fontsize="large")
plt.show()
def main(args):
train_loader, val_loader = create_dataloaders(args.batch_size)
model = Net().to(device)
optim = torch.optim.Adam(model.parameters())
lr_schedule = torch.optim.lr_scheduler.ReduceLROnPlateau(optim,
patience=1,
verbose=True)
criterion = torch.nn.CrossEntropyLoss()
best_accuracy = 0
for epoch in range(1, args.epochs + 1):
model.train()
train_loss, train_accuracy = do_epoch(model,
train_loader,
criterion,
optim=optim)
model.eval()
with torch.no_grad():
val_loss, val_accuracy = do_epoch(model,
val_loader,
criterion,
optim=None)
tqdm.write(
f'EPOCH {epoch:03d}: train_loss={train_loss:.4f}, train_accuracy={train_accuracy:.4f} '
f'val_loss={val_loss:.4f}, val_accuracy={val_accuracy:.4f}')
if val_accuracy > best_accuracy:
print('Saving model...')
best_accuracy = val_accuracy
torch.save(model.state_dict(), 'trained_models/source.pt')
lr_schedule.step(val_loss)
def main(size, epoch, lr, name, kind, mode):
net = Net(name, kind, mode, size, epoch, lr)
if mode == 'train':
net.get_params_number()
net.train()
else:
net.test()
def __init__(self,
n_s,
n_a,
hiddens=(128, 64),
epsilon=1.0,
epsilon_min=0.005,
epsilon_decay=0.05,
gamma=0.99,
batch_size=64,
memory_capacity=100000,
lr=0.001,
is_dueling=False,
is_prioritize=True,
replace_iter=100,
is_soft=False,
tau=0.01,
e=0.01,
a=0.6,
b=0.4):
self.n_s = n_s
self.n_a = n_a
self.epsilon = epsilon
self.epsilon_min = epsilon_min
self.epsilon_decay = epsilon_decay
self.replace_iter = replace_iter
self.lr = lr
self.gamma = gamma
self.batch_size = batch_size
self.memory_capacity = memory_capacity
self.is_soft = is_soft
self.is_prioritize = is_prioritize
self.tau = tau
if use_gpu:
self.eval_net = Net(n_s,
n_a,
hiddens=hiddens,
is_dueling=is_dueling).cuda()
self.target_net = Net(n_s,
n_a,
hiddens=hiddens,
is_dueling=is_dueling).cuda()
else:
self.eval_net = Net(n_s,
n_a,
hiddens=hiddens,
is_dueling=is_dueling)
self.target_net = Net(n_s,
n_a,
hiddens=hiddens,
is_dueling=is_dueling)
if is_prioritize:
self.memory = Memory(memory_capacity, e, a, b)
else:
self.memory = np.zeros((memory_capacity, self.n_s * 2 + 2))
self.memory_count = 0
self.learn_count = 0
self.loss_func = nn.MSELoss()
self.optimizer = optim.Adam(self.eval_net.parameters(), lr=self.lr)
def training(share_exp, oracle):
env_config = env_configs[args.env]
env = Terrain(env_config.map_index)
policy = []
value = []
oracle_network = {}
for i in range(env.num_task):
policy_i = StochasticPiNet(env_config.Policy)
policy.append(policy_i)
value_i = Net(env_config.Value)
value.append(value_i)
for i in range(env.num_task - 1):
for j in range(i + 1, env.num_task):
oracle_network[i, j] = StochasticPiNet(env_config.Z)
multitask_agent = MultitaskPolicy(env=env,
env_config=env_config,
policy=policy,
value=value,
oracle_network=oracle_network,
share_exp=share_exp,
oracle=oracle)
multitask_agent.train()
def main():
# Load model and data
net = Net()
trainloader, testloader = load_data()
class CifarClient(fl.client.NumPyClient):
def get_parameters(self):
return [val.cpu().numpy() for _, val in net.state_dict().items()]
def set_parameters(self, parameters):
params_dict = zip(net.state_dict().keys(), parameters)
state_dict = OrderedDict(
{k: torch.tensor(v)
for k, v in params_dict})
net.load_state_dict(state_dict, strict=True)
def fit(self, parameters, config):
self.set_parameters(parameters)
train(net, trainloader, epochs=1)
return self.get_parameters(), len(trainloader), {}
def evaluate(self, parameters, config):
self.set_parameters(parameters)
loss = test(net, testloader)
return float(loss), len(testloader), {}
fl.client.start_numpy_client("[::]:8080", client=CifarClient())
def do_convert(args, logdir):
# Load graph
model = Net()
df = NetDataFlow(hp.convert.data_path, hp.convert.batch_size)
ckpt = '{}/{}'.format(logdir, args.ckpt) if args.ckpt else tf.train.latest_checkpoint(logdir)
session_inits = []
if ckpt:
session_inits.append(SaverRestore(ckpt))
pred_conf = PredictConfig(
model=model,
input_names=get_eval_input_names(),
output_names=get_eval_output_names(),
session_init=ChainInit(session_inits))
predictor = OfflinePredictor(pred_conf)
audio, y_audio = convert(predictor, df)
soundfile.write("a.wav", y_audio[0], 16000, format="wav", subtype="PCM_16")
soundfile.write("b.wav", audio[0], 16000, format="wav", subtype="PCM_16")
# Write the result
tf.summary.audio('A', y_audio, hp.default.sr, max_outputs=hp.convert.batch_size)
tf.summary.audio('B', audio, hp.default.sr, max_outputs=hp.convert.batch_size)
writer = tf.summary.FileWriter(logdir)
with tf.Session() as sess:
summ = sess.run(tf.summary.merge_all())
writer.add_summary(summ)
writer.close()
def main():
# models
net = Net(base=opt.base)
net = nn.DataParallel(net).cuda()
sdict = torch.load('./net.pth')
net.load_state_dict(sdict)
val_loader = torch.utils.data.DataLoader(ImageFiles(opt.img_dir,
opt.prior_dir,
size=256,
mean=mean,
std=std),
batch_size=opt.b,
shuffle=False,
num_workers=4,
pin_memory=True)
validate(val_loader, net, 'results', opt.gt_dir)
def __init__(self, args):
self.args = args
self.num_channels = NUM_CHANNELS
if args.netType == 1:
self.net = Net(self.num_channels, args)
elif args.netType == 2:
self.net = Net2(self.num_channels, args)
if args.cuda:
self.net = self.net.cuda()
self.load_dataset_from_folder()
self.writer = SummaryWriter()
self.unique_tok = str(time.time())
self.init_weights()
def main(args):
# GET DATA
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
dataset = datasets.ImageFolder(args.train_dir, transform=transform)
# GET MODEL
model = Net(n_class=10)
# TRAINING
print('Start Training')
with mlflow.start_run():
for k, v in vars(args).items():
mlflow.log_param(k, v)
for epoch in range(args.epochs): # loop over the dataset multiple times
train_size = int(.8 * len(dataset))
test_size = len(dataset) - train_size
train_set, val_set = torch.utils.data.random_split(dataset, [train_size, test_size])
trainloader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True)
valloader = torch.utils.data.DataLoader(val_set, batch_size=args.batch_size, shuffle=False)
train(epoch, model, trainloader)
test(epoch, model, valloader)
print('Finished Training')
mlflow.pytorch.log_model(model, artifact_path="pytorch-model", pickle_module=pickle)
print("\nThe model is logged at:\n%s" % os.path.join(mlflow.get_artifact_uri(), "pytorch-model"))
def debug_me():
# Define network
net = Net()
print(net)
data_transform = transforms.Compose(
[Rescale(250), RandomCrop(224),
Normalize()])
aww_dataset = FacialKeypointsDataset(
csv_file='data/aww_frames_keypoints.csv',
root_dir='data/aww/',
transform=data_transform)
sample = aww_dataset[0]
print(sample['image'].shape, sample['keypoints'].shape)
print(np.max(sample['keypoints']))
aww_loader = DataLoader(aww_dataset,
batch_size=10,
shuffle=True,
num_workers=4)
aww_images, aww_outputs, gt_pts = net_sample_output(net, aww_loader)
visualize_output(aww_images, aww_outputs, gt_pts, 1)
'''
def get_model(args):
''' define model '''
model = None
if args.model == 'Net':
model = Net()
elif args.model == 'FCNet':
model = FCNet()
elif args.model == 'ConvNet':
model = ConvNet()
else:
raise ValueError('The model is not defined!!')
print('---Model Information---')
print('Net:', model)
print('Use GPU:', args.use_cuda)
return model.to(args.device)
def main():
print('Training Process\nInitializing...\n')
config.init_env()
val_dataset = view_data(config.view_net.data_root,
status=STATUS_TEST,
base_model_name=config.base_model_name)
val_loader = DataLoader(val_dataset,
batch_size=config.view_net.test.batch_sz,
num_workers=config.num_workers,
shuffle=True)
# create model
net = Net(pretrained=True)
net = net.to(device=config.device)
net = nn.DataParallel(net)
print(f'loading pretrained model from {config.view_net.ckpt_file}')
checkpoint = torch.load(config.view_net.ckpt_file)
net.module.load_state_dict(checkpoint['model'])
with torch.no_grad():
validate(val_loader, net)
print('test Finished!')
def main(self):
num_of_neurons = 151
num_of_hidden_layers = 2
learning_rate = 0.001
epochs = 10
args = dict()
args['num_of_neurons'], args['num_of_hidden_layers'], args[
'learning_rate'], args[
'epochs'] = num_of_neurons, num_of_hidden_layers, learning_rate, epochs
loss = self.objective(args)
print(loss)
net = Net(num_of_neurones=num_of_neurons,
num_of_hidden_layers=num_of_hidden_layers,
num_of_inputs=self.hw_model.inputs,
num_of_outputs=self.hw_model.outputs)
net = net.to(self.device)
print(self.test(net))
def main():
if not os.path.exists(args.output):
os.makedirs(args.output)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net()
trainer = Trainer(model, device=device, lr=args.lr, epoch=args.epoch)
trainer.train_and_eval()
def load_model():
"""
Get the newest checkpoint (best one) in the checkpoint directory
For more detail about torch's load/save progress, see:
https://stackoverflow.com/questions/42703500/best-way-to-save-a-trained-model-in-pytorch
:param filename:
:return: model (with training progress, can be used for either inference or further training)
"""
model = Net(int(args['in_size']), int(args['hidden_size']),
int(args['out_size']), int(args['nb_lstm_layers']),
int(args['batch_size']), int(bool(args['bidirectional'])))
newest_dir = [
xxx for xxx in subprocess.check_output("ls -t checkpoints/".split(
" ")).decode("utf8").strip().split("\n")
if os.path.isdir("checkpoints/" + xxx)
][0] # | head -n 1"])
print(newest_dir)
newest_pth = [
"checkpoints/{}/{}".format(newest_dir, xxx)
for xxx in subprocess.check_output("ls -t checkpoints/{}/".format(
newest_dir).split(" ")).decode("utf8").strip().split("\n")
if os.path.isfile("checkpoints/{}/{}".format(newest_dir, xxx))
]
list_file = {
get_epoch_from_filename(filename)[0]:
get_epoch_from_filename(filename)[1]
for filename in newest_pth
}
best_epoch = max(list_file.keys())
best_loss = list_file[best_epoch]
print(best_epoch, best_loss)
state = torch.load("checkpoints/{}/checkpoint_epoch{}_{}".format(
newest_dir, best_epoch, best_loss),
map_location='cpu')
model.load_state_dict(state['state_dict'])
optimizer = optim.RMSprop(model.parameters())
optimizer.load_state_dict(state['optimizer'])
return model, optimizer
def symmetry_loss(prediction, target):
gc_pred, nb_pred_o, coords_pred_o = Net.extract_data(prediction)
gc_target, nb_target, coords_target = Net.extract_data(target)
rot = deque(range(4))
losses = []
corner_losses = [] # for logging puproses
for i in range(len(rot)):
nb_pred = nb_pred_o[:, rot]
coords_pred = [v[:, rot] for v in coords_pred_o]
coord_corners_loss = torch.sum((coords_target[0] - coords_pred[0])**2 +
(coords_target[1] - coords_pred[1])**2,
dim=1)
corner_losses.append(coord_corners_loss)
mse_coord_neighborhood_t = (coords_target[2] - coords_pred[2])**2 + (
coords_target[3] - coords_pred[3])**2
neighborhood_loss = torch.sum(
F.binary_cross_entropy_with_logits(nb_pred, nb_target) +
nb_target * mse_coord_neighborhood_t,
dim=1)
loss = coord_corners_loss + neighborhood_loss
losses.append(loss)
rot.rotate(1)
sym_loss = torch.min(torch.stack(losses), dim=0)[0]
g_t = gc_target[:, 0]
c_t = gc_target[:, 1]
g_p = gc_pred[:, 0]
c_p = gc_pred[:, 1]
color_loss = F.binary_cross_entropy_with_logits(c_p, c_t)
loss = F.binary_cross_entropy_with_logits(
g_p, g_t) + g_t * (color_loss + sym_loss)
return loss, torch.min(torch.stack(corner_losses), dim=0)[0]
def parse_hgr(hgr_file):
with open(hgr_file) as hgr:
num_nets, num_cells = integerify(hgr.readline().split())
nets = []
for i in range(num_nets):
net = Net(i+1, integerify(hgr.readline().split()))
nets.append(net)
return num_cells, nets
def main(args):
epochs = args.epochs
batch_size = args.batch_size
val_frac = args.val_frac
lr = args.lr
momentum = args.momentum
total_it = args.total_it
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print(device)
dataset_train = HomographyDataset(val_frac=val_frac, mode='train')
dataset_eval = HomographyDataset(val_frac=val_frac, mode='eval')
dataloader_train = DataLoader(dataset_train,
batch_size=batch_size,
shuffle=True,
num_workers=4)
dataloader_eval = DataLoader(dataset_eval,
batch_size=batch_size,
shuffle=False,
num_workers=2)
net = Net()
net.to(device)
criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), momentum=momentum, lr=lr)
log_every = len(dataloader_train) // 2
n_it, lr_it = 0, 0
while n_it < total_it:
train(dataloader_train, device, net, criterion, optimizer)
n_it += len(dataloader_train)
test(dataloader_eval, device, net, criterion, n_it)
if lr_it >= 30000:
d = optimizer.state_dict()
d['param_groups'][0]['lr'] /= 10.0
optimizer.load_state_dict(d)
lr_it = 0
def create_model(args):
model = Net()
if args.start_epoch:
path = os.path.join(args.checkpoints_dir,
f'checkpoint-{args.start_epoch}.pth')
model.load_state_dict(torch.load(path))
else:
model.load_pretrained(args.ddr_weights)
return model.to(args.device)
def main(args):
if args.adapt_setting == 'svhn2mnist':
target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
]))
elif args.adapt_setting == 'mnist2usps':
target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
]))
else:
raise NotImplementedError
dataloader = DataLoader(target_dataset, batch_size=args.batch_size, shuffle=False,
drop_last=False, num_workers=1, pin_memory=True)
model = Net().to(device)
model.load_state_dict(torch.load(args.MODEL_FILE))
model.eval()
total_accuracy = 0
with torch.no_grad():
for x, y_true in tqdm(dataloader, leave=False):
x, y_true = x.to(device), y_true.to(device)
y_pred = model(x)
total_accuracy += (y_pred.max(1)[1] == y_true).float().mean().item()
mean_accuracy = total_accuracy / len(dataloader)
print(f'Accuracy on target data: {mean_accuracy:.4f}')
def load_model(dir):
"""
Loads models
:param dir: directory to load the models from
:return: a list of all the models in the directory
"""
networks = []
for filename in os.listdir(dir):
net = Net()
net.load_state_dict(torch.load(os.path.join(dir, filename)))
net.train(True)
net.cuda()
networks.append(net)
return networks
