torch.backends.cudnn.benchmark = False
if __name__ == '__main__':
parser = ArgumentParser(description='Generative Query Network on Shepard Metzler Example')
parser.add_argument('--n_epochs', type=int, default=200, help='number of epochs run (default: 200)')
parser.add_argument('--batch_size', type=int, default=1, help='multiple of batch size (default: 1)')
parser.add_argument('--data_dir', type=str, help='location of data', default="train")
parser.add_argument('--log_dir', type=str, help='location of logging', default="log")
parser.add_argument('--fraction', type=float, help='how much of the data to use', default=1.0)
parser.add_argument('--workers', type=int, help='number of data loading workers', default=4)
parser.add_argument('--data_parallel', type=bool, help='whether to parallelise based on data (default: False)', default=False)
args = parser.parse_args()
# Create model and optimizer
#model = GenerativeQueryNetwork(x_dim=3, v_dim=7, r_dim=256, h_dim=128, z_dim=64, L=8).to(device)
model = GenerativeQueryNetwork(x_dim=3, v_dim=7, r_dim=256, h_dim=64, z_dim=32, L=3).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
optimizer = torch.optim.Adam(model.parameters(), lr=5 * 10 ** (-5))
# Rate annealing schemes
sigma_scheme = Annealer(2.0, 0.7, 80000)
mu_scheme = Annealer(5 * 10 ** (-6), 5 * 10 ** (-6), 1.6 * 10 ** 5)
# Load the dataset
train_dataset = ShepardMetzler(root_dir=args.data_dir, fraction=args.fraction)
valid_dataset = ShepardMetzler(root_dir=args.data_dir, fraction=args.fraction, train=False)
kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {}
train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
valid_loader = DataLoader(valid_dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
from torch.distributions import Normal
from torch.utils.data import DataLoader
from torchvision.utils import make_grid
# TensorboardX
from tensorboardX import SummaryWriter
from gqn import GenerativeQueryNetwork, partition, Annealer
from shepardmetzler import ShepardMetzler
#from placeholder import PlaceholderData as ShepardMetzler
cuda = torch.cuda.is_available()
device = torch.device("cuda" if cuda else "cpu")
#print(cuda)
#print(device)
# Random seeding
random.seed(99)
torch.manual_seed(99)
if cuda: torch.cuda.manual_seed(99)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
if __name__ == '__main__':
model = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=8).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
args = parser.parse_args()
dataset = ShepardMetzler(root_dir=args.data_dir,
target_transform=transform_viewpoint)
# Pixel variance
sigma_f, sigma_i = 0.7, 2.0
# Learning rate
mu_f, mu_i = 5 * 10**(-5), 5 * 10**(-4)
mu, sigma = mu_f, sigma_f
# Create model and optimizer
model = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=12).to(device)
# Model optimisations
model = nn.DataParallel(model) if args.data_parallel else model
model = model.half() if args.fp16 else model
optimizer = torch.optim.Adam(model.parameters(), lr=mu)
# Load the dataset
kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {}
loader = DataLoader(dataset,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
def main(step, dataset, data_dir):
global args
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Pixel variance
global sigma_f, sigma_i
sigma_f, sigma_i = 0.7, 2.0
# Learning rate
global mu_f, mu_i
mu_f, mu_i = 5 * 10**(-5), 5 * 10**(-4)
global mu, sigma
mu, sigma = mu_i, sigma_i
s = 0
if step > 0:
file_dir = data_dir + '/rate/model_' + str(step) + '_hyper.txt'
temp = np.loadtxt(file_dir)
mu = temp[0]
sigma = temp[1]
s = int(temp[2])
# Create model and optimizer
model = GenerativeQueryNetwork(x_dim=3,
v_dim=5,
r_dim=256,
h_dim=128,
z_dim=64,
L=12)
n_parameters = sum([p.data.nelement() for p in model.parameters()])
print(' + Number of params GQN: {}'.format(n_parameters))
# Model optimisations
model.set_multiple_gpus()
if step > 0:
model_dir = data_dir + '/model/model_' + str(step) + '.pkl'
model.load_state_dict(torch.load(model_dir))
if args.cuda:
model.cuda()
cudnn.benchmark = True
optimizer = torch.optim.Adam(model.parameters(), lr=mu)
# Load the dataset
kwargs = {'num_workers': 0, 'pin_memory': True} if args.cuda else {}
train_loader_spatial = torch.utils.data.DataLoader(
ShepardMetzler(root_dir=data_dir + '/torch' +
'/train/'), #, target_transform=transform_viewpoint
batch_size=args.batch_size,
shuffle=True,
**kwargs)
lRecord = []
reconstruction_loss_train = []
kl_divergence_train = []
temp_loss_train = []
full_loss_train = []
for epoch in range(step + 1, args.epochs + step + 1):
hyper = []
print('------------------Spatial-------------------------')
train_loader = train_loader_spatial
lRecord.append('------------------Spatial-------------------------')
reconstruction_loss, kl_divergence, temp_loss, full_loss = train(
model, train_loader, optimizer, epoch, lRecord)
s = s + 1
reconstruction_loss_train.append(reconstruction_loss)
kl_divergence_train.append(kl_divergence)
temp_loss_train.append(temp_loss)
full_loss_train.append(full_loss)
# Anneal learning rate
mu = max(mu_f + (mu_i - mu_f) * (1 - s / (1.6 * 10**6)), mu_f)
for group in optimizer.param_groups:
group["lr"] = mu * math.sqrt(1 - 0.999**s) / (1 - 0.9**s)
# Anneal pixel variance
sigma = max(sigma_f + (sigma_i - sigma_f) * (1 - s / (2 * 10**5)),
sigma_f)
hyper.append(mu)
hyper.append(sigma)
hyper.append(s)
if epoch % args.log_interval_record == 0:
SaveRecord(data_dir, epoch, model, reconstruction_loss_train,
kl_divergence_train, temp_loss_train, full_loss_train,
lRecord, hyper)
# Load dataset
from shepardmetzler import ShepardMetzler
from torch.utils.data import DataLoader
from gqn import GenerativeQueryNetwork, partition
dataset = ShepardMetzler(
"./shepard_metzler_5_parts") ## <= Choose your data location
loader = DataLoader(dataset, batch_size=1, shuffle=True)
# Load model parameters onto CPU
state_dict = torch.load("./20_epoch_run/checkpoint_model_20.pth",
map_location="cpu") ## <= Choose your model location
# Initialise new model with the settings of the trained one
model_settings = dict(x_dim=3, v_dim=7, r_dim=256, h_dim=128, z_dim=64, L=8)
model = GenerativeQueryNetwork(**model_settings)
# Load trained parameters, un-dataparallel if needed
if True in ["module" in m for m in list(state_dict().keys())]:
model = nn.DataParallel(model)
model.load_state_dict(state_dict())
model = model.module
else:
model.load_state_dict(state_dict())
model
# We load a batch of a single image containing a single object seen from 15 different viewpoints.
def deterministic_partition(images, viewpoints, indices):
default=1.0)
parser.add_argument('--workers',
type=int,
help='number of data loading workers',
default=4)
parser.add_argument(
'--data_parallel',
type=bool,
help='whether to parallelise based on data (default: False)',
default=False)
args = parser.parse_args()
# Create model and optimizer
model = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=8).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
torch.save(model.state_dict(), "model/gqn_model")
optimizer = torch.optim.Adam(model.parameters(), lr=5 * 10**(-5))
# Rate annealing schemes
sigma_scheme = Annealer(2.0, 0.7, 80000)
mu_scheme = Annealer(5 * 10**(-6), 5 * 10**(-6), 1.6 * 10**5)
# Load the dataset
train_dataset = ShepardMetzler(root_dir=args.data_dir,
fraction=args.fraction)
valid_dataset = ShepardMetzler(root_dir=args.data_dir,
fraction=args.fraction,
import numpy as np
import cv2
import torch
valid_dataset = GQN_Dataset(root_dir="../data/rooms_ring_camera/", train=False)
x, v = valid_dataset[4]
x = x.view((1, *x.shape))
v = v.view((1, *v.shape))
max_m = 5
x, v, x_q, v_q = partition(x, v, max_m, 4)
batch, *_ = x.shape
device = torch.device("cpu")
model = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=10).to(device)
models = glob.glob("../checkpoints/checkpoint_model_*.pth")
models.sort(key=lambda x: os.path.getmtime(x))
last_checkpoint = models[-1]
checkpoint = torch.load(last_checkpoint, map_location="cpu")
model.load_state_dict(checkpoint)
scenes = [1, 2]
for scene in scenes:
x_sc = x[scene]
x_sc = x_sc.repeat(36, 1, 1, 1, 1)
v_sc = v[scene]
coord1, coord2, coord3, _, _, p1, p2 = v_q[scene]
ax[0].imshow(image1)
ax[1].set_title(r"Yaw: " + str(yaw))
ax[1].imshow(image2)
plt.show()
plt.pause(0.01)
# model path
modelName = "gqn_model_cp_ep51_13perc_shepardMetzler_7_parts"
modelPath = "D:\\Projekte\\MachineLearning\\generative-query-network-pytorch\\model\\"
modelFullPath = modelPath + modelName
model_trained = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=8)
pretrained_dict = torch.load(modelFullPath, map_location='cpu') #.to(device)
model_trained.load_state_dict(pretrained_dict)
model_trained = model_trained.to(device)
# datapath
datapath = "D:\\Projekte\\MachineLearning\\DataSets\\shepard_metzler_7_parts"
valid_dataset = ShepardMetzler(root_dir=datapath, fraction=1.0, train=False)
valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)
valid_imgs, valid_viewpoints = next(iter(valid_loader))
part_valid_imgs, part_valid_viewpoints, part_context_imgs, part_context_viewpoints = partition(
valid_imgs, valid_viewpoints)
ax[0].imshow(image1)
ax[1].imshow(image2)
#fig.canvas.draw()
plt.show()
plt.pause(1.0)
# model path
modelName = "gqn_model_rooms_n_ep48_49perc"
#modelPath = "D:\\Projekte\\MachineLearning\\generative-query-network-pytorch\\model\\"
modelPath = "Y:\\"
modelFullPath = modelPath + modelName
model = GenerativeQueryNetwork(x_dim=3,
v_dim=7,
r_dim=256,
h_dim=128,
z_dim=64,
L=8)
pretrained_dict = torch.load(modelFullPath, map_location='cpu') #.to(device)
model.load_state_dict(pretrained_dict)
model = model.to(device)
# datapath
#datapath = "D:\\Projekte\\MachineLearning\\DataSets\\shepard_metzler_7_parts"
#datapath = "D:\\Projekte\\MachineLearning\\DataSets\\temp"
datapath = "Z:\\Datasets\\rooms_free_camera_no_object_rotations\\rooms_free_camera_no_object_rotations\\temp"
valid_dataset = ShepardMetzler(root_dir=datapath, fraction=1.0, train=False)
valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)
valid_imgs, valid_viewpoints = next(iter(valid_loader))
part_valid_imgs, part_valid_viewpoints, part_context_imgs, part_context_viewpoints = partition(
x_q, v_q = images[:, query_idx], viewpoints[:, query_idx]
return x, v, x_q, v_q
dataset = ShepardMetzler(
"data/shepard_metzler_5_parts/") ## <= Choose your data location
loader = DataLoader(dataset, batch_size=1, shuffle=True)
# Load model parameters onto CPU
state_dict = torch.load("./model-checkpoint.pth",
map_location="cpu") ## <= Choose your model location
# Initialise new model with the settings of the trained one
model_settings = dict(x_dim=3, v_dim=7, r_dim=256, h_dim=128, z_dim=64, L=8)
model = GenerativeQueryNetwork(**model_settings)
# Load trained parameters, un-dataparallel if needed
if True in ["module" in m for m in list(state_dict.keys())]:
model = nn.DataParallel(model)
model.load_state_dict(state_dict)
model = model.module
else:
model.load_state_dict(state_dict)
# Load data
train_images = []
train_labels = []
for scene_id in range(30):
print("Loading scene " + str(scene_id))
x, v = next(iter(loader))
