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 get_prediction(image_bytes):
model = Net()
model.load_state_dict(torch.load('model.pt', map_location='cpu'),
strict=False)
model.eval()
tensor = transform_image(image_bytes=image_bytes)
outputs = F.softmax(model(tensor), dim=1)
top_p, top_class = outputs.topk(1, dim=1)
return top_p, top_class
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():
model = Net()
model.load_state_dict(torch.load(checkpoint_path))
model.eval()
tar = prep_data()
output = model(Variable(tar))
res = output.cpu().data.numpy()
res_ = np.squeeze(res)
num = np.argwhere(res_ == np.max(res_))
print(int(num))
def main():
# load in a haar cascade classifier for detecting frontal faces
face_cascade = cv2.CascadeClassifier(
'detector_architectures/haarcascade_frontalface_default.xml')
model = Net()
model.load_state_dict(torch.load('./saved_models/keypoints_model_1.pt'))
model.eval()
show_webcam(model, face_cascade)
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
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 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 main():
use_cuda = torch.cuda.is_available() and args.cuda
device = torch.device('cuda' if use_cuda else 'cpu')
print('Loading model ...')
model = Net(device)
if args.load is not None:
print('Loading checkpoint ...')
model.load_state_dict(torch.load(args.load))
if use_cuda:
model.cuda()
print('Loading data ...')
data_loader = get_data_loader(args.data_root, args.stage, args.batch_size)
print('Preparation done')
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
betas=(0.9, 0.999))
criterion = nn.CrossEntropyLoss()
if args.stage == 'train':
train(model, data_loader, optimizer, criterion)
def main(args):
X_target, y_target = preprocess_test()
target_dataset = torch.utils.data.TensorDataset(X_target, y_target)
target_loader = DataLoader(target_dataset, batch_size=args.batch_size,
shuffle=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(target_loader, 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(target_loader)
print(f'Accuracy on target data: {mean_accuracy:.4f}')
def pred_homography(batch,
patch_size,
model_file='homography_model.pytorch',
scale=32):
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
batch = normalize_batch(batch).to(device)
net = Net()
net.load_state_dict(torch.load(model_file))
net.eval().to(device)
with torch.no_grad():
output = net(batch).detach().cpu().numpy() * scale
mean_shift = np.mean(output, axis=0)
pts1 = np.float32(
[0, 0, patch_size, 0, patch_size, patch_size, 0,
patch_size]).reshape(-1, 1, 2)
pts2 = mean_shift.reshape(-1, 1, 2) + pts1
h = np.linalg.inv(cv2.findHomography(pts1, pts2)[0])
return h
def main(args):
dataset = MNISTM(train=False)
dataloader = DataLoader(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}')
class dueling_agent:
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)
# start to do the training
def learn(self):
episode_reward = [0.0]
obs = np.array(self.env.reset())
td_loss = 0
for timestep in range(self.args.total_timesteps):
explore_eps = self.exploration_schedule.get_value(timestep)
with torch.no_grad():
obs_tensor = self._get_tensors(obs)
action_value = self.net(obs_tensor)
# select actions
action = select_actions(action_value, explore_eps)
# excute actions
obs_, reward, done, _ = self.env.step(action)
obs_ = np.array(obs_)
# tryint to append the samples
self.buffer.add(obs, action, reward, obs_, float(done))
obs = obs_
# add the rewards
episode_reward[-1] += reward
if done:
obs = np.array(self.env.reset())
episode_reward.append(0.0)
if timestep > self.args.learning_starts and timestep % self.args.train_freq == 0:
# start to sample the samples from the replay buffer
batch_samples = self.buffer.sample(self.args.batch_size)
td_loss = self._update_network(batch_samples)
if timestep > self.args.learning_starts and timestep % self.args.target_network_update_freq == 0:
# update the target network
self.target_net.load_state_dict(self.net.state_dict())
if len(episode_reward[-101:-1]) == 0:
mean_reward_per_100 = 0
else:
mean_reward_per_100 = np.mean(episode_reward[-101:-1])
num_episode = len(episode_reward) - 1
if done and num_episode % self.args.display_interval == 0:
print('[{}] Frames: {}, Episode: {}, Mean: {:.3f}, Loss: {:.3f}'.format(datetime.now(), timestep, num_episode, \
mean_reward_per_100, td_loss))
torch.save(self.net.state_dict(),
self.model_path + '/model.pt')
# update the network
def _update_network(self, samples):
obses, actions, rewards, obses_next, dones = samples
# convert the data to tensor
obses = self._get_tensors(obses)
actions = torch.tensor(actions, dtype=torch.int64).unsqueeze(-1)
rewards = torch.tensor(rewards, dtype=torch.float32).unsqueeze(-1)
obses_next = self._get_tensors(obses_next)
dones = torch.tensor(1 - dones, dtype=torch.float32).unsqueeze(-1)
# convert into gpu
if self.args.cuda:
actions = actions.cuda()
rewards = rewards.cuda()
dones = dones.cuda()
# calculate the target value
with torch.no_grad():
q_value_temp = self.net(obses_next)
action_max_idx = torch.argmax(q_value_temp, dim=1, keepdim=True)
target_action_value = self.target_net(obses_next)
target_action_max_value = target_action_value.gather(
1, action_max_idx)
target_action_max_value = target_action_max_value.detach()
# target
expected_value = rewards + self.args.gamma * target_action_max_value * dones
# get the real q value
action_value = self.net(obses)
real_value = action_value.gather(1, actions)
loss = (expected_value - real_value).pow(2).mean()
# start to update
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
return loss.item()
# get tensors
def _get_tensors(self, obs):
if obs.ndim == 3:
obs = np.transpose(obs, (2, 0, 1))
obs = np.expand_dims(obs, 0)
elif obs.ndim == 4:
obs = np.transpose(obs, (0, 3, 1, 2))
obs = torch.tensor(obs, dtype=torch.float32)
if self.args.cuda:
obs = obs.cuda()
return obs
def main():
warnings.filterwarnings("ignore")
#######################################################################################################################
"""Command line interface"""
parser = argparse.ArgumentParser()
# parser.add_argument('--dataset', required=False, help='cifar10 | mnist | fmnist '| svhn', default='mnist')
# parser.add_argument('--dataroot', required=False, help='path to dataset', default='./data/data.csv')
parser.add_argument('--workers',
type=int,
help='number of data loading workers',
default=6)
# parser.add_argument('--batchSize', type=int, default=32, help='input batch size')
parser.add_argument('--len',
type=int,
default=64,
help='the height / width of the input to network')
# parser.add_argument('--saveInt', type=int, default=14, help='number of epochs between checkpoints')
parser.add_argument('--cuda',
action='store_true',
help='enables cuda',
default=True)
# parser.add_argument('--outf', default='output', help='folder to output images and model checkpoints')
parser.add_argument('--manualSeed', type=int, help='manual seed')
parser.add_argument('--net',
help="path to net (to continue training)",
default='./net_epoch_196.pth')
parser.add_argument('--nc',
default=20,
help="number of channels",
type=int)
opt = parser.parse_args()
with open("FocusMuseDataset_mean_std.pkl", "rb") as f:
mean = pickle.load(f)
std = pickle.load(f)
######################################################################################################################
if opt.manualSeed is None:
opt.manualSeed = random.randint(1, 10000)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
if opt.cuda:
torch.cuda.manual_seed_all(opt.manualSeed)
cudnn.benchmark = True
if torch.cuda.is_available() and not opt.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
device = torch.device("cuda" if opt.cuda else "cpu")
######################################################################################################################
"""Server"""
HOST = ''
PORT = 65531
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
print("binding")
s.listen(5)
conn, addr = s.accept()
print('Connected by', addr)
while True:
data = conn.recv(16184)
if not data:
break
test_x = np.fromstring(data, dtype=np.float).reshape(20, -1)
test_x = torch.Tensor(test_x)
print("test data: ", type(test_x), test_x.shape)
# """Dataset loading"""
# tensor_test_x = torch.stack([torch.Tensor(i) for i in test_x]) # transform to torch tensors
#
# dataset = vdata.TensorDataset(tensor_test_x) # create your datset
# testloader = DataLoader(dataset, drop_last=False) # create your dataloader
#######################################################################################################################
net = Net(insize=opt.len,
output_size=128,
nc=opt.nc,
hidden_size=64,
n_layers=2)
# net.apply(weights_init)
if opt.net != '':
print("loading trained net...")
net.load_state_dict(torch.load(opt.net))
# print(net)
if opt.cuda:
net.cuda()
test_x.cuda()
# total, nonzero = 0, 0
test_x = Variable(test_x)
outputs = net(test_x)
predicted = torch.argmax(outputs, dim=1)
# if opt.cuda:
# p2 = predicted.cpu().detach().numpy()
# else:
# p2 = predicted.numpy()
# nonzero += np.count_nonzero(p2)
# total += p2.shape[0]
#
# ratio = ((total - nonzero) / total) * 100
# ratio = _test(opt=opt, net=net, testloader=testloader)
conn.send(outputs[1].encode())
conn.close()
# you may also need to change the width of the rectangle drawn depending on image resolution
cv2.rectangle(image_with_detections,(x,y),(x+w,y+h),(255,0,0),3)
fig = plt.figure(figsize=(9,9))
plt.imshow(image_with_detections)
# ************************** Load Pre-trained Model ****************************************
import torch
from models import Net
net = Net()
net.load_state_dict(torch.load('saved_models/keypoints_model_1.pt'))
## print out your net and prepare it for testing (uncomment the line below)
net.eval()
# ************************** Display Keypoints Generated by model onto image ****************
image_copy = np.copy(image)
# loop over the detected faces from your haar cascade
for (x,y,w,h) in faces:
# Select the region of interest that is the face in the image
roi = image_copy[y:y+h, x:x+w]
# Convert the face region from RGB to grayscale
def main(args):
source_model = Net().to(device)
source_model.load_state_dict(torch.load(args.MODEL_FILE))
source_model.eval()
set_requires_grad(source_model, requires_grad=False)
clf = source_model
source_model = source_model.feature_extractor
target_model = Net().to(device)
target_model.load_state_dict(torch.load(args.MODEL_FILE))
target_model = target_model.feature_extractor
target_clf = clf.classifier
discriminator = nn.Sequential(nn.Linear(320, 50), nn.ReLU(),
nn.Linear(50, 20), nn.ReLU(),
nn.Linear(20, 1)).to(device)
half_batch = args.batch_size // 2
source_dataset = MNIST(config.DATA_DIR / 'mnist',
train=True,
download=True,
transform=Compose([GrayscaleToRgb(),
ToTensor()]))
source_loader = DataLoader(source_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True)
target_dataset = MNISTM(train=False)
target_loader = DataLoader(target_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True)
discriminator_optim = torch.optim.Adam(discriminator.parameters())
target_optim = torch.optim.Adam(target_model.parameters())
criterion = nn.BCEWithLogitsLoss()
for epoch in range(1, args.epochs + 1):
batch_iterator = zip(loop_iterable(source_loader),
loop_iterable(target_loader))
total_loss = 0
total_accuracy = 0
target_label_accuracy = 0
for _ in trange(args.iterations, leave=False):
# Train discriminator
set_requires_grad(target_model, requires_grad=False)
set_requires_grad(discriminator, requires_grad=True)
for _ in range(args.k_disc):
(source_x, _), (target_x, _) = next(batch_iterator)
source_x, target_x = source_x.to(device), target_x.to(device)
source_features = source_model(source_x).view(
source_x.shape[0], -1)
target_features = target_model(target_x).view(
target_x.shape[0], -1)
discriminator_x = torch.cat([source_features, target_features])
discriminator_y = torch.cat([
torch.ones(source_x.shape[0], device=device),
torch.zeros(target_x.shape[0], device=device)
])
preds = discriminator(discriminator_x).squeeze()
loss = criterion(preds, discriminator_y)
discriminator_optim.zero_grad()
loss.backward()
discriminator_optim.step()
total_loss += loss.item()
total_accuracy += ((
preds >
0).long() == discriminator_y.long()).float().mean().item()
# Train classifier
set_requires_grad(target_model, requires_grad=True)
set_requires_grad(discriminator, requires_grad=False)
for _ in range(args.k_clf):
_, (target_x, target_labels) = next(batch_iterator)
target_x = target_x.to(device)
target_features = target_model(target_x).view(
target_x.shape[0], -1)
# flipped labels
discriminator_y = torch.ones(target_x.shape[0], device=device)
preds = discriminator(target_features).squeeze()
loss = criterion(preds, discriminator_y)
target_optim.zero_grad()
loss.backward()
target_optim.step()
target_label_preds = target_clf(target_features)
target_label_accuracy += (target_label_preds.cpu().max(1)[1] ==
target_labels).float().mean().item()
mean_loss = total_loss / (args.iterations * args.k_disc)
mean_accuracy = total_accuracy / (args.iterations * args.k_disc)
target_mean_accuracy = target_label_accuracy / (args.iterations *
args.k_clf)
tqdm.write(
f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, '
f'discriminator_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}'
)
# Create the full target model and save it
clf.feature_extractor = target_model
torch.save(clf.state_dict(), 'trained_models/adda.pt')
transforms.RandomVerticalFlip(p=0.5),
transforms.Resize(256),
transforms.ToTensor(),
])
device = torch.device(DEVICE if torch.cuda.is_available() else "cpu")
refine_net = Net()
weights = torch.load("/content/weights_net_df2.pth", map_location='cpu')
state_dict = {}
for k, v in weights.items():
k = k.split('.')[1:]
k = ".".join(k)
state_dict.update({k: v})
# import pdb; pdb.set_trace()
refine_net.load_state_dict(state_dict)
vgg = VGG16(requires_grad=False)
vgg.to(device)
if torch.cuda.device_count() > 1 and MULTI_GPU:
print("Using {} GPUs...".format(torch.cuda.device_count()))
refine_net = nn.DataParallel(refine_net)
else:
print("GPU ID: {}".format(device))
refine_net = refine_net.to(device)
d_loss_fn = nn.BCELoss()
d_loss_fn = d_loss_fn.to(device)
refine_loss_fn = CustomLoss()
refine_loss_fn = refine_loss_fn.to(device)
class NNet():
"""
Wrapper to manage neural net.
"""
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 init_weights(self):
"""
Initialize by Xavier weights
"""
self.net.apply(init_weights)
def load_dataset_from_folder(self):
"""
Load complete dataset
"""
all_data_path = self.args.all_data_path
validation_split_size = self.args.validation_split_size
batch_size = self.args.batch_size
num_workers = self.args.num_workers
shuffle = self.args.shuffle
all_data = ImageFolder(root=all_data_path, transform=TRANSFORM)
classes = all_data.classes
self.classes = classes
validation_size = int(validation_split_size * len(all_data))
test_size = int(validation_split_size * len(all_data))
train_size = len(all_data) - 2 * validation_size
train_dataset, val_dataset, test_dataset = random_split(
all_data, [train_size, validation_size, test_size])
training_data_loader = DataLoader(train_dataset,
batch_size=batch_size,
num_workers=num_workers,
shuffle=shuffle)
validation_dataset_loader = DataLoader(val_dataset,
batch_size=batch_size,
num_workers=num_workers,
shuffle=shuffle)
test_dataset_loader = DataLoader(test_dataset,
batch_size=batch_size,
num_workers=num_workers,
shuffle=shuffle)
self.train_loader = training_data_loader
self.val_loader = validation_dataset_loader
self.test_loader = test_dataset_loader
def train(self):
"""
Train Neural Net
"""
if self.args.optim == 'RMSprop':
optimizer = optim.RMSprop(self.net.parameters(),
lr=self.args.lr,
momentum=self.args.momentum,
weight_decay=self.args.l2_regularization)
elif self.args.optim == 'SGD':
optimizer = optim.SGD(self.net.parameters(),
lr=self.args.lr,
momentum=self.args.momentum)
elif self.args.optim == 'Adam':
optimizer = optim.Adam(self.net.parameters(), lr=self.args.lr)
criterion = nn.CrossEntropyLoss()
# scheduler = optim.lr_scheduler.StepLR(
# optimizer, step_size=self.args.scheduler_step_size, gamma=self.args.scheduler_gamma)
self.net.train()
for epoch in range(self.args.epoch):
start_time = time.time()
running_loss_t = 0.0
num_batches = 0
y_true = []
y_pred = []
# print('Epoch: {} , LR: {}'.format(epoch+1, scheduler.get_lr()))
for data in tqdm(self.train_loader):
inputs, labels = data
labels_cp = labels.clone()
# imshow(torchvision.utils.make_grid(inputs[:,:3,:,:]))
if len(inputs) < 2:
continue
if self.args.cuda:
inputs = inputs.cuda()
labels = labels.cuda()
outputs = self.net(inputs)
loss = criterion(outputs, labels)
_, predicted = torch.max(outputs, 1)
predicted = predicted.cpu()
for i, pred in enumerate(predicted):
y_pred.append(pred)
y_true.append(labels_cp[i])
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss_t += loss.item()
num_batches += 1
end_time = time.time()
train_f1 = f1_score(y_true, y_pred, average='weighted')
# scheduler.step()
self.save(epoch + 1)
self.writer.add_scalar('Loss/train', running_loss_t / num_batches,
epoch + 1)
self.writer.add_scalar('F1/train', train_f1, epoch + 1)
loss_v, val_f1 = self.get_validation_loss(criterion)
self.writer.add_scalar('Loss/val', loss_v, epoch + 1)
self.writer.add_scalar('F1/val', val_f1, epoch + 1)
print(
"Epoch {} Time {:.2f}s Train-Loss {:.3f} Val-Loss {:.3f} Train-F1 {:.3f} Val-F1 {:.3f}"
.format(epoch + 1, end_time - start_time,
running_loss_t / num_batches, loss_v, train_f1,
val_f1))
def get_validation_loss(self, criterion):
"""
Check validation loss
"""
running_loss = 0.0
num_batches = 0
self.net.eval()
y_true = []
y_pred = []
with torch.no_grad():
for data in tqdm(self.val_loader):
images, labels = data
labels_cp = labels.clone()
if self.args.cuda:
images = images.cuda()
labels = labels.cuda()
outputs = self.net(images)
_, predicted = torch.max(outputs, 1)
predicted = predicted.cpu()
for i, pred in enumerate(predicted):
y_pred.append(pred)
y_true.append(labels_cp[i])
loss = criterion(outputs, labels)
running_loss += loss.item()
num_batches += 1
self.net.train()
val_f1 = f1_score(y_true, y_pred, average='weighted')
return running_loss / num_batches, val_f1
def get_test_accuracy(self):
"""
Check overall accuracy of model
"""
y_true = []
y_pred = []
class_correct = list(0. for i in range(4))
class_total = list(0. for i in range(4))
with torch.no_grad():
for data in tqdm(self.test_loader):
images, labels = data
labels_cp = labels.clone()
if self.args.cuda:
images = images.cuda()
labels = labels.cuda()
outputs = self.net(images)
_, predicted = torch.max(outputs, 1)
predicted = predicted.cpu()
for i, pred in enumerate(predicted):
y_pred.append(pred)
y_true.append(labels_cp[i])
c = (predicted == labels_cp).squeeze()
for i in range(min(self.args.batch_size, len(labels_cp))):
label = labels_cp[i]
class_correct[label] += c[i].item()
class_total[label] += 1
print("Test F1: ", f1_score(y_true, y_pred, average='weighted'))
def save(self, epochs, folder_path="../models/"):
"""
Save Model
"""
dict_save = {'params': self.net.state_dict(), 'classes': self.classes}
name = folder_path + self.unique_tok + '_' + str(epochs) + '.model'
torch.save(dict_save, name)
print('Model saved at {}'.format(name))
return name
def load(self, path):
"""
Load a saved model
"""
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
dict_load = torch.load(path, map_location=torch.device(device))
self.net.load_state_dict(dict_load['params'])
return dict_load['classes']
def predict(self, inp):
"""
Predict using net
"""
if self.args.cuda:
inp = inp.cuda()
self.net.eval()
with torch.no_grad():
vals = self.net(inp)
print(vals)
_, predicted = torch.max(vals, 1)
predicted = predicted.cpu()
result_class = self.classes[predicted]
return result_class
class TrainBigramNN(tune.Trainable):
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 _train(self):
result = train(
self.wv,
self.corpus.ix_sents[: self.corpus_size],
self.corpus.sent_lengths[: self.corpus_size],
self.corpus.ix_sents[self.corpus_size :],
self.corpus.sent_lengths[self.corpus_size :],
self.model,
self.wv.vecs,
self.dist_fn,
self.loss_fn,
self.optimizer,
self.lr,
self.num_epochs,
self.batch_size,
self._iteration,
self.test_model,
self.test_freq,
self.device,
)
return result
def _save(self, tmp_checkpoint_dir):
checkpoint_path = str(Path(tmp_checkpoint_dir) / "model.pth")
torch.save(self.model.state_dict(), checkpoint_path)
return checkpoint_path
def _restore(self, tmp_checkpoint_dir):
checkpoint_path = str(Path(tmp_checkpoint_dir) / "model.pth")
self.model.load_state_dict(torch.load(checkpoint_path))
def test(pathModel, nnClassCount, testTensor, trBatchSize):
print("\n\n\n")
print("Inside test funtion")
CLASS_NAMES = ['Broken', 'Normal']
# cudnn.benchmark = True
model = Net()
# model = model.cuda()
# -------------------- SETTINGS: NETWORK ARCHITECTURE, MODEL LOAD
print("Is model==None:", model is None)
print("Is pathModel==None:", pathModel is None)
# cudnn.benchmark = True
# if pathModel!=None:
# model = Trainer.loadModel(nnArchitecture, nnClassCount, nnIsTrained)
# #model = torch.nn.DataParallel(model)
# model.to(device)
if os.path.isfile(pathModel):
print("=> loading checkpoint: ", pathModel)
modelCheckpoint = torch.load(pathModel, map_location='cpu')
model.load_state_dict(modelCheckpoint['state_dict'], strict=False)
print("=> loaded checkpoint: ", pathModel)
else:
print("=> no checkpoint found: ")
print(
"\n============================ Loading data into RAM ======================================== "
)
testImage = testTensor
testSize = testImage.size()[0]
print(
"============================= Evaluation of model starts ===================================="
)
model.eval()
broken = 0
normal = 0
batchID = 1
with torch.no_grad():
for i in range(0, testSize, trBatchSize):
if (batchID % 1) == 0:
print("batchID:" + str(batchID) + '/' +
str(testImage.size()[0] / trBatchSize))
if i + trBatchSize >= testSize:
input = testImage[i:]
else:
input = testImage[i:i + trBatchSize]
input = trans_test(input)
input = input.type(torch.FloatTensor)
varInput = torch.autograd.Variable(input)
out = model(varInput)
_, predicted = torch.max(out.data, 1)
print(predicted)
if i + trBatchSize <= testSize:
for k in range(trBatchSize):
if (predicted[k] == 1):
normal += 1
elif (predicted[k] == 0):
broken += 1
else:
for k in range(testSize % trBatchSize):
if (predicted[k] == 1):
normal += 1
elif (predicted[k] == 0):
broken += 1
batchID += 1
print(' Number of broken grains in sample : ', broken)
print(' Number of normal grains in sample :', normal)
def main(args):
clf_model = Net().to(device)
clf_model.load_state_dict(torch.load(args.MODEL_FILE))
feature_extractor = clf_model.feature_extractor
discriminator = clf_model.classifier
critic = nn.Sequential(nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20),
nn.ReLU(), nn.Linear(20, 1)).to(device)
half_batch = args.batch_size // 2
source_dataset = MNIST(config.DATA_DIR / 'mnist',
train=True,
download=True,
transform=Compose([GrayscaleToRgb(),
ToTensor()]))
source_loader = DataLoader(source_dataset,
batch_size=half_batch,
drop_last=True,
shuffle=True,
num_workers=0,
pin_memory=True)
target_dataset = MNISTM(train=False)
target_loader = DataLoader(target_dataset,
batch_size=half_batch,
drop_last=True,
shuffle=True,
num_workers=0,
pin_memory=True)
critic_optim = torch.optim.Adam(critic.parameters(), lr=1e-4)
clf_optim = torch.optim.Adam(clf_model.parameters(), lr=1e-4)
clf_criterion = nn.CrossEntropyLoss()
for epoch in range(1, args.epochs + 1):
batch_iterator = zip(loop_iterable(source_loader),
loop_iterable(target_loader))
total_loss = 0
total_accuracy = 0
for _ in trange(args.iterations, leave=False):
(source_x, source_y), (target_x, _) = next(batch_iterator)
# Train critic
set_requires_grad(feature_extractor, requires_grad=False)
set_requires_grad(critic, requires_grad=True)
source_x, target_x = source_x.to(device), target_x.to(device)
source_y = source_y.to(device)
with torch.no_grad():
h_s = feature_extractor(source_x).data.view(
source_x.shape[0], -1)
h_t = feature_extractor(target_x).data.view(
target_x.shape[0], -1)
for _ in range(args.k_critic):
gp = gradient_penalty(critic, h_s, h_t)
critic_s = critic(h_s)
critic_t = critic(h_t)
wasserstein_distance = critic_s.mean() - critic_t.mean()
critic_cost = -wasserstein_distance + args.gamma * gp
critic_optim.zero_grad()
critic_cost.backward()
critic_optim.step()
total_loss += critic_cost.item()
# Train classifier
set_requires_grad(feature_extractor, requires_grad=True)
set_requires_grad(critic, requires_grad=False)
for _ in range(args.k_clf):
source_features = feature_extractor(source_x).view(
source_x.shape[0], -1)
target_features = feature_extractor(target_x).view(
target_x.shape[0], -1)
source_preds = discriminator(source_features)
clf_loss = clf_criterion(source_preds, source_y)
wasserstein_distance = critic(source_features).mean() - critic(
target_features).mean()
loss = clf_loss + args.wd_clf * wasserstein_distance
clf_optim.zero_grad()
loss.backward()
clf_optim.step()
mean_loss = total_loss / (args.iterations * args.k_critic)
tqdm.write(f'EPOCH {epoch:03d}: critic_loss={mean_loss:.4f}')
torch.save(clf_model.state_dict(), 'trained_models/wdgrl.pt')
def main(args):
# TODO: add DTN model
model = Net().to(device)
model.load_state_dict(torch.load(args.MODEL_FILE))
feature_extractor = model.feature_extractor
clf = model.classifier
discriminator = nn.Sequential(GradientReversal(), nn.Linear(320, 50),
nn.ReLU(), nn.Linear(50, 20), nn.ReLU(),
nn.Linear(20, 1)).to(device)
half_batch = args.batch_size // 2
if args.adapt_setting == 'mnist2mnistm':
source_dataset = MNIST(config.DATA_DIR / 'mnist',
train=True,
download=True,
transform=Compose(
[GrayscaleToRgb(),
ToTensor()]))
target_dataset = MNISTM(train=False)
elif args.adapt_setting == 'svhn2mnist':
source_dataset = ImageClassdata(txt_file=args.src_list,
root_dir=args.src_root,
img_type=args.img_type,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
]))
target_dataset = ImageClassdata(txt_file=args.tar_list,
root_dir=args.tar_root,
img_type=args.img_type,
transform=transforms.Compose([
transforms.ToTensor(),
]))
elif args.adapt_setting == 'mnist2usps':
source_dataset = ImageClassdata(txt_file=args.src_list,
root_dir=args.src_root,
img_type=args.img_type,
transform=transforms.Compose([
transforms.ToTensor(),
]))
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
source_loader = DataLoader(source_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True,
drop_last=True)
target_loader = DataLoader(target_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True,
drop_last=True)
optim = torch.optim.Adam(
list(discriminator.parameters()) + list(model.parameters()))
if not os.path.exists('logs'): os.makedirs('logs')
f = open(f'logs/{args.adapt_setting}_{args.name}.txt', 'w+')
for epoch in range(1, args.epochs + 1):
batches = zip(source_loader, target_loader)
n_batches = min(len(source_loader), len(target_loader))
total_domain_loss = total_label_accuracy = 0
target_label_accuracy = 0
for (source_x,
source_labels), (target_x,
target_labels) in tqdm(batches,
leave=False,
total=n_batches):
x = torch.cat([source_x, target_x])
x = x.to(device)
domain_y = torch.cat([
torch.ones(source_x.shape[0]),
torch.zeros(target_x.shape[0])
])
domain_y = domain_y.to(device)
label_y = source_labels.to(device)
features = feature_extractor(x).view(x.shape[0], -1)
domain_preds = discriminator(features).squeeze()
label_preds = clf(features[:source_x.shape[0]])
domain_loss = F.binary_cross_entropy_with_logits(
domain_preds, domain_y)
label_loss = F.cross_entropy(label_preds, label_y)
loss = domain_loss + label_loss
optim.zero_grad()
loss.backward()
optim.step()
total_domain_loss += domain_loss.item()
total_label_accuracy += (
label_preds.max(1)[1] == label_y).float().mean().item()
target_label_preds = clf(features[source_x.shape[0]:])
target_label_accuracy += (target_label_preds.cpu().max(1)[1] ==
target_labels).float().mean().item()
mean_loss = total_domain_loss / n_batches
mean_accuracy = total_label_accuracy / n_batches
target_mean_accuracy = target_label_accuracy / n_batches
tqdm.write(
f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, '
f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}'
)
f.write(
f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, '
f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}\n'
)
torch.save(
model.state_dict(),
f'trained_models/{args.adapt_setting}_{args.name}_ep{epoch}.pt')
f.close()
DEVICE_ID = 1
DEVICE = "cuda"
MEAN = np.array([0.485, 0.456, 0.406])
STD = np.array([0.229, 0.224, 0.225])
mask_transform = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomVerticalFlip(p=0.5),
transforms.Resize(256),
transforms.ToTensor(),
])
device = torch.device(DEVICE if torch.cuda.is_available() else "cpu")
refine_net = Net()
refine_net.load_state_dict(
torch.load("exp_2/weights/weights_net_epoch_20.pth", map_location='cpu'))
vgg = VGG16(requires_grad=False)
vgg.to(device)
if torch.cuda.device_count() > 1 and MULTI_GPU:
print("Using {} GPUs...".format(torch.cuda.device_count()))
refine_net = nn.DataParallel(refine_net)
else:
print("GPU ID: {}".format(device))
refine_net = refine_net.to(device)
d_loss_fn = nn.BCELoss()
d_loss_fn = d_loss_fn.to(device)
refine_loss_fn = CustomLoss()
refine_loss_fn = refine_loss_fn.to(device)
# loop over the detected faces, mark the image where each face is found
for (x, y, w, h) in faces:
# draw a rectangle around each detected face
# change the width of the rectangle drawn depending on image resolution
cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (255, 0, 0),
3)
fig = plt.figure(figsize=(9, 9))
plt.imshow(image_with_detections)
## Loading in a trained model
net = Net()
# load saved model parameters
net.load_state_dict(torch.load('saved_models/test_run_2.pt'))
# print out the net and prepare it for testing
net.eval()
# Keypoint detection
### Transform each detected face into an input Tensor
# perform the following steps for each detected face:
# 1. Convert the face from RGB to grayscale
# 2. Normalize the grayscale image so that its color range falls in [0,1] instead of [0,255]
# 3. Rescale the detected face to be the expected square size for your CNN (224x224, suggested)
# 4. Reshape the numpy image into a torch image.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import cv2
import torch
from torch.utils.data import DataLoader
from torchvision import transforms
from data_load import FacialKeypointsDataset, Rescale, RandomCrop, Normalize, ToTensor
from models import Net
net = Net()
net.load_state_dict(
torch.load(
r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontaltrainedmodel_10epoch.pth'
))
## print out your net and prepare it for testing (uncomment the line below)
net.eval()
data_transform = transforms.Compose(
[Rescale(225), RandomCrop(224),
Normalize(), ToTensor()])
transformed_dataset = FacialKeypointsDataset(
csv_file=
r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontalpoints.csv',
root_dir=
r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\ceasar_mat',
transform=data_transform)
# load training data in batches
batch_size = 10
img = cv2.imread('../img/ys.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
face_cascade = cv2.CascadeClassifier('../detector_architectures/haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(img, 1.2, 2)
img_with_detections = img.copy()
for (x,y,w,h) in faces:
cv2.rectangle(img_with_detections, (x,y), (x+w,y+h), (255,0,0),3)
net = Net()
print(net)
net.load_state_dict(torch.load('../saved_models/facial_keypoint_detection.pt'))
net.eval()
image_copy = np.copy(img)
for (x,y,w,h) in faces:
height, width = image_copy.shape[:2]
h_start = int(max(y-h/2, 0))
h_end = int(min(y+h+h/2, height))
w_start = int(max(x-w/2, 0))
w_end = int(min(x+w+w/2, width))
roi = image_copy[h_start:h_end, w_start:w_end]
roi = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY)
roi = roi / 255.0
obs = np.transpose(obs, (2, 0, 1))
obs = np.expand_dims(obs, 0)
obs = torch.tensor(obs, dtype=torch.float32)
return obs
if __name__ == '__main__':
args = get_args()
# create the environment
env = make_atari(args.env_name)
env = wrap_deepmind(env, frame_stack=True)
# create the network
net = Net(env.action_space.n)
# model path
model_path = args.save_dir + args.env_name + '/model.pt'
# load the models
net.load_state_dict(
torch.load(model_path, map_location=lambda storage, loc: storage))
# start to test the demo
obs = env.reset()
for _ in range(2000):
env.render()
with torch.no_grad():
obs_tensor = get_tensors(obs)
action_value = net(obs_tensor)
action = torch.argmax(action_value.squeeze()).item()
obs, reward, done, _ = env.step(action)
if done:
obs = env.reset()
env.close()
# make a copy of the original image to plot detections on
image_with_detections = image.copy()
# loop over the detected faces, mark the image where each face is found
for (x, y, w, h) in faces:
# draw a rectangle around each detected face
# you may also need to change the width of the rectangle drawn depending on image resolution
cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (255, 0, 0),
3)
fig = plt.figure(figsize=(9, 9))
plt.savefig("saved_images/face_detected_img.jpg")
net = Net()
net.load_state_dict(torch.load('keypoints_model_final.pt'))
## print out your net and prepare it for testing
net.eval()
image_copy = np.copy(image)
# loop over the detected faces from your haar cascade
count = 0
for (x, y, w, h) in faces:
count += 1
# Select the region of interest that is the face in the image
roi = image_copy[y:y + h, x:x + w]
roi_gray = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY)
roi_gray_copy = np.copy(roi_gray)
def main(args):
model = Net().to(device)
model.load_state_dict(torch.load(args.MODEL_FILE))
feature_extractor = model.feature_extractor
clf = model.classifier
discriminator = nn.Sequential(GradientReversal(), nn.Linear(320, 50),
nn.ReLU(), nn.Linear(50, 20), nn.ReLU(),
nn.Linear(20, 1)).to(device)
half_batch = args.batch_size // 2
source_dataset = MNIST(config.DATA_DIR / 'mnist',
train=True,
download=True,
transform=Compose([GrayscaleToRgb(),
ToTensor()]))
source_loader = DataLoader(source_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True)
target_dataset = MNISTM(train=False)
target_loader = DataLoader(target_dataset,
batch_size=half_batch,
shuffle=True,
num_workers=1,
pin_memory=True)
optim = torch.optim.Adam(
list(discriminator.parameters()) + list(model.parameters()))
for epoch in range(1, args.epochs + 1):
batches = zip(source_loader, target_loader)
n_batches = min(len(source_loader), len(target_loader))
total_domain_loss = total_label_accuracy = 0
target_label_accuracy = 0
for (source_x,
source_labels), (target_x,
target_labels) in tqdm(batches,
leave=False,
total=n_batches):
x = torch.cat([source_x, target_x])
x = x.to(device)
domain_y = torch.cat([
torch.ones(source_x.shape[0]),
torch.zeros(target_x.shape[0])
])
domain_y = domain_y.to(device)
label_y = source_labels.to(device)
features = feature_extractor(x).view(x.shape[0], -1)
domain_preds = discriminator(features).squeeze()
label_preds = clf(features[:source_x.shape[0]])
domain_loss = F.binary_cross_entropy_with_logits(
domain_preds, domain_y)
label_loss = F.cross_entropy(label_preds, label_y)
loss = domain_loss + label_loss
optim.zero_grad()
loss.backward()
optim.step()
total_domain_loss += domain_loss.item()
total_label_accuracy += (
label_preds.max(1)[1] == label_y).float().mean().item()
target_label_preds = clf(features[source_x.shape[0]:])
target_label_accuracy += (target_label_preds.cpu().max(1)[1] ==
target_labels).float().mean().item()
mean_loss = total_domain_loss / n_batches
mean_accuracy = total_label_accuracy / n_batches
target_mean_accuracy = target_label_accuracy / n_batches
tqdm.write(
f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, '
f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}'
)
torch.save(model.state_dict(), 'trained_models/revgrad.pt')
def main(args):
source_model = Net().to(device)
source_model.load_state_dict(torch.load(args.MODEL_FILE))
source_model.eval()
set_requires_grad(source_model, requires_grad=False)
clf = source_model
source_model = source_model.feature_extractor
target_model = Net().to(device)
target_model.load_state_dict(torch.load(args.MODEL_FILE))
target_model = target_model.feature_extractor
classifier = clf.classifier
discriminator = nn.Sequential(nn.Linear(EXTRACTED_FEATURE_DIM, 64),
nn.ReLU(), nn.BatchNorm1d(64),
nn.Linear(64, 1), nn.Sigmoid()).to(device)
#half_batch = args.batch_size // 2
batch_size = args.batch_size
# X_source, y_source = preprocess_train()
X_source, y_source = preprocess_train_single(1)
source_dataset = torch.utils.data.TensorDataset(X_source, y_source)
source_loader = DataLoader(source_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=1,
pin_memory=True)
X_target, y_target = preprocess_test(args.person)
target_dataset = torch.utils.data.TensorDataset(X_target, y_target)
target_loader = DataLoader(target_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=1,
pin_memory=True)
discriminator_optim = torch.optim.Adam(discriminator.parameters())
target_optim = torch.optim.Adam(target_model.parameters(), lr=3e-6)
criterion = nn.BCEWithLogitsLoss()
criterion_class = nn.CrossEntropyLoss()
best_tar_acc = test(args, clf)
final_accs = []
for epoch in range(1, args.epochs + 1):
source_loader = DataLoader(source_loader.dataset,
batch_size=batch_size,
shuffle=True)
target_loader = DataLoader(target_loader.dataset,
batch_size=batch_size,
shuffle=True)
batch_iterator = zip(loop_iterable(source_loader),
loop_iterable(target_loader))
total_loss = 0
adv_loss = 0
total_accuracy = 0
second_acc = 0
total_class_loss = 0
for _ in trange(args.iterations, leave=False):
# Train discriminator
set_requires_grad(target_model, requires_grad=False)
set_requires_grad(discriminator, requires_grad=True)
discriminator.train()
for _ in range(args.k_disc):
(source_x, source_y), (target_x, _) = next(batch_iterator)
source_y = source_y.to(device).view(-1)
source_x, target_x = source_x.to(device), target_x.to(device)
source_features = source_model(source_x).view(
source_x.shape[0], -1)
target_features = target_model(target_x).view(
target_x.shape[0], -1)
discriminator_x = torch.cat([source_features, target_features])
discriminator_y = torch.cat([
torch.ones(source_x.shape[0], device=device),
torch.zeros(target_x.shape[0], device=device)
])
preds = discriminator(discriminator_x).squeeze()
loss = criterion(preds, discriminator_y)
discriminator_optim.zero_grad()
loss.backward()
discriminator_optim.step()
total_loss += loss.item()
total_accuracy += ((preds >= 0.5).long() == discriminator_y.
long()).float().mean().item()
# Train feature extractor
set_requires_grad(target_model, requires_grad=True)
set_requires_grad(discriminator, requires_grad=False)
target_model.train()
for _ in range(args.k_clf):
_, (target_x, _) = next(batch_iterator)
target_x = target_x.to(device)
target_features = target_model(target_x).view(
target_x.shape[0], -1)
source_features = target_model(source_x).view(
source_x.shape[0], -1)
source_pred = classifier(source_features) # (batch_size, 4)
# flipped labels
discriminator_y = torch.ones(target_x.shape[0], device=device)
preds = discriminator(target_features).squeeze()
second_acc += ((preds >= 0.5).long() == discriminator_y.long()
).float().mean().item()
loss_adv = criterion(preds, discriminator_y)
adv_loss += loss_adv.item()
loss_class = criterion_class(source_pred, source_y)
total_class_loss += loss_class.item()
loss = loss_adv #+ 0.001*loss_class
target_optim.zero_grad()
loss.backward()
target_optim.step()
mean_loss = total_loss / (args.iterations * args.k_disc)
mean_adv_loss = adv_loss / (args.iterations * args.k_clf)
total_class_loss = total_class_loss / (args.iterations * args.k_clf)
dis_accuracy = total_accuracy / (args.iterations * args.k_disc)
sec_acc = second_acc / (args.iterations * args.k_clf)
clf.feature_extractor = target_model
tar_accuarcy = test(args, clf)
final_accs.append(tar_accuarcy)
if tar_accuarcy > best_tar_acc:
best_tar_acc = tar_accuarcy
torch.save(clf.state_dict(), 'trained_models/adda.pt')
tqdm.write(
f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, adv_loss = {mean_adv_loss:.4f}, '
f'discriminator_accuracy={dis_accuracy:.4f}, tar_accuary = {tar_accuarcy:.4f}, best_accuracy = {best_tar_acc:.4f}, '
f'sec_acc = {sec_acc:.4f}, total_class_loss: {total_class_loss:.4f}'
)
# Create the full target model and save it
clf.feature_extractor = target_model
#torch.save(clf.state_dict(), 'trained_models/adda.pt')
jd = {"test_acc": final_accs}
with open(str(args.seed) + '/acc' + str(args.person) + '.json', 'w') as f:
json.dump(jd, f)
