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))