class Triplet(nn.Module):
def __init__(self, dropout=True, normalization=True):
super(Triplet, self).__init__()
self.siamese = Siamese(dropout=dropout, normalization=normalization)
linear_layer = nn.Linear(2, 1)
init_weights = torch.Tensor([[50, -50]])
init_bias = torch.Tensor([[0]])
init_weights = init_weights.float()
init_bias = init_bias.float()
init_weights.requires_grad = False
init_bias.requires_grad = False
linear_layer.weight = torch.nn.Parameter(init_weights)
linear_layer.bias = torch.nn.Parameter(init_bias)
self.final_layer = nn.Sequential(linear_layer, nn.Sigmoid())
def forward(self, query, near, far):
# TODO: we can optimize this by only calculating the left/imitation branch once
near_output = self.siamese(query, near)
far_output = self.siamese(query, far)
near_reshaped = near_output.view(len(near_output), -1)
far_reshaped = far_output.view(len(far_output), -1)
concatenated = torch.cat((near_reshaped, far_reshaped), dim=1)
output = self.final_layer(concatenated)
return output.view(-1)
def load_siamese(self, model: nn.Module):
self.siamese.load_state_dict(model.state_dict())
**kwargs)
manualSeed = 9302 #random.randint(1, 10000) # fix seed
print("Random Seed: ", manualSeed)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
g_config = get_config()
model_dir = args.model_dir
setupLogger(os.path.join(model_dir, 'log.txt'))
g_config.model_dir = model_dir
criterion = nn.HingeEmbeddingLoss()
model = Siamese()
# load model snapshot
load_path = args.load_path
if load_path is not '':
snapshot = torch.load(load_path)
# loadModelState(model, snapshot)
model.load_state_dict(snapshot['state_dict'])
logging('Model loaded from {}'.format(load_path))
train_model(model,
criterion,
train_loader,
test_loader,
g_config,
use_cuda=False)
from models.siamese import Siamese
load_from_torch7 = False
print('Loading model...')
model_dir = 'models/snapshot/'
model_load_path = os.path.join(model_dir, 'snapshot_epoch_1.pt')
gConfig = get_config()
gConfig.model_dir = model_dir
criterion = nn.HingeEmbeddingLoss()
model = Siamese()
package = torch.load(model_load_path)
model.load_state_dict(package['state_dict'])
model.eval()
print('Model loaded from {}'.format(model_load_path))
logging('Model configuration:\n{}'.format(model))
modelSize, nParamsEachLayer = modelSize(model)
logging('Model size: {}\n{}'.format(modelSize, nParamsEachLayer))
params = model.parameters()
for i, a_param in enumerate(params):
print a_param
exit(0)
print('====> Test set loss: {:.4f}'.format(test_loss))
writer.add_scalar('data/test_loss', test_loss, epoch)
def save(epoch):
state = {'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'epoch': epoch + 1}
save_dir = 'checkpoints/siamese/lr_{}_decay_{}'.format(int(lr*1000), int(decay*100))
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
torch.save(state, os.path.join(save_dir, 'ae_{}.pth.tar'.format(epoch)))
start_epoch = 1
resume = True
if resume:
state = torch.load('./checkpoints/best_siamese.pth.tar', map_location=lambda storage, loc: storage)
model.load_state_dict(state['state_dict'])
optimizer.load_state_dict(state['optimizer'])
start_epoch = state['epoch']
print('Begin train...')
for epoch in range(start_epoch, args.epochs + 1):
train(epoch)
test(epoch)
save(epoch)
# Adjust learning rate
for param_group in optimizer.param_groups:
param_group['lr'] = param_group['lr'] * decay