def train(config): ''' SETTING HYPERPARAMETER (DEFAULT) ''' training_epoch = config.training_epoch z_dim = config.z_dim batch_size = config.batch_size n_data = mnist.train.num_examples total_batch = int(mnist.train.num_examples / batch_size) total_iteration = training_epoch * total_batch # Build Network CVAE = cvae.CVAE(config) CVAE.build() # Optimize Network CVAE.optimize(config) sess = tf.Session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() print("Total the number of Data : " + str(n_data)) print("Total Step per 1 Epoch: {}".format(total_batch)) print("The number of Iteration: {}".format(total_iteration)) for epoch in range(training_epoch): avg_cost = 0 avg_recons = 0 avg_regular = 0 for i in range(total_batch): batch_xs, batch_ys = mnist.train.next_batch(batch_size) _cost, _, _recons, _regular = sess.run( [CVAE.cost, CVAE.optimizer, CVAE.recons, CVAE.regular], feed_dict={ CVAE.X: batch_xs, CVAE.Y: batch_ys }) avg_cost += _cost / total_batch avg_recons += _recons / total_batch avg_regular += _regular / total_batch if epoch % 10 == 0: print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost), 'Recons_Loss =', '{:.9f}'.format(avg_recons), 'Regular_Loss =', '{:.9f}'.format(avg_regular)) print("Training Complete!") save_dir = './mode_z_dim_{}'.format(z_dim) if not os.path.exists(save_dir): os.makedirs(save_dir) save_path = '{}/CVAE.ckpt'.format(save_dir) saver.save(sess, save_path) print("Saved Model") return CVAE, sess
def get_model(model_type, layers=[32, 64], latent_dim=256, input_shape=32, use_bn=False, std=0.05): if model_type == 'AE': model = ae.AE(layers, latent_dim, input_shape, use_bn) elif model_type == 'CVAE': model = cvae.CVAE(layers, latent_dim, input_shape, std, use_bn) elif model_type == 'VAE': model = vae.VAE(layers, latent_dim) elif model_type == 'SBVAE': model = sbvae.SBVAE(layers, latent_dim) elif model_type == 'SBAE': model = sbae.SBAE(layers, latent_dim, input_shape, use_bn) elif model_type == 'SBAE_cl': model = sbae.SBAE(layers, latent_dim, input_shape, use_bn, classification=True) elif model_type == 'KVAE': model = KVAE.KVAE(layers, latent_dim, input_shape) elif model_type == 'RKN': model = RKN.RKN(layers, latent_dim, input_shape) elif model_type == 'KAST': model = KAST() else: print("Model type is not good") return model
10 02880940 Bowl 186 ''' random.seed(488) tf.random.set_seed(488) cf_cat_prefixes = ut.cf_cat_prefixes = ['04379243','03001627','03636649','03325088','03046257','02876657','03593526','03642806','02818832','03797390','02880940'] # ['04379243','03001627','03636649','03642806'] #,'03636649','03325088','03046257','02876657','03593526','03642806'] cf_num_classes = len(cf_cat_prefixes) cf_vox_size = 64 cf_latent_dim = 128 cf_max_loads_per_cat = 10000 if remote else 50 cf_batch_size = 40 cf_learning_rate = 4e-4 cf_limits=[cf_vox_size, cf_vox_size, cf_vox_size] ut.readMeta() #%% Make model and print info model = cv.CVAE(cf_latent_dim, cf_vox_size, cf_learning_rate, training=True) model.setLR(cf_learning_rate) model.printMSums() model.printIO() #%% Setup logger info train_from_scratch = False if train_from_scratch : lg = logger.logger(trainMode=cf.REMOTE, txtMode=False) else : shp_run_id = '0209-0306' root_dir = os.path.join(cf.SHAPE_RUN_DIR, shp_run_id) lg = logger.logger(root_dir) lg.setupCP(encoder=shapemodel.enc_model, generator=shapemodel.gen_model, opt=shapemodel.optimizer) lg.restoreCP()
shuffle=test_cfg["shuffle"], batch_size=test_cfg["batch_size"], num_workers=test_cfg["num_workers"], drop_last=True) h_matrix = np.genfromtxt(DIR_INPUT + 'H.txt') device = cfg['train_params']['device'] torch.cuda.set_device(device) tensorboard_file = cfg['train_params']['tensorboard_path'] train_writer = SummaryWriter(tensorboard_file) # 建立模型 model = cvae.CVAE(cnn_model=cfg["model_params"]["model_cnn"], channels=3, cont_dim=256) # load weight if there is a pretrained model checkpoint_path = cfg["model_params"]["checkpoint_path"] if checkpoint_path: checkpoint = torch.load(checkpoint_path) model.load_state_dict(checkpoint['model_state_dict']) logger.info(checkpoint_path, "loaded") model.to(device) learning_rate = cfg["model_params"]["lr"] optimizer = optim.Adam(model.parameters(), lr=learning_rate) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5000, gamma=0.8) logger.info(f'device {device}') # raster_size = (640, 480)
allow_pickle=True) val_data = np.load(os.path.join(cf.DATA_DIR, 'val_data.npy'), allow_pickle=True) all_data = np.load(os.path.join(cf.DATA_DIR, 'all_data.npy'), allow_pickle=True) #%% ################################################# ## ## Set up the model ## - load current state or ## - train from scratch ##################################################### model = cv.CVAE(cf_latent_dim, cf_img_size, learning_rate=cf_learning_rate, kl_weight=cf_kl_weight, training=True) ### instance of model used in GOAT blog #model = cv.CVAE_EF(cf_latent_dim, cf_img_size, cf_learning_rate, training=True) model.print_model_summary() model.print_model_IO() if JUPYTER_NOTEBOOK: tf.keras.utils.plot_model(model.enc_model, show_shapes=True, show_layer_names=True) tf.keras.utils.plot_model(model.gen_model, show_shapes=True, show_layer_names=True)
num_layers = 4 embed_size = 300 hidden_size = 300 latent_size = 300 num_epochs = 30 anneal = utils.kl_anneal_linear eos = EN.vocab.stoi["</s>"] bos = EN.vocab.stoi["<s>"] pad = EN.vocab.stoi["<pad>"] filter_beam = [pad, bos] model = cvae.CVAE(len(DE.vocab), len(EN.vocab), embed_size, hidden_size, latent_size, num_layers) if gpu: model.cuda() print("Number of parameters: {}".format(utils.count_parameters(model))) train.train(model, model_name, train_iter, val_iter, DE, EN, anneal, num_epochs, gpu, checkpoint=checkpoint)
train_cfg = cfg["train_data_loader"] train_zarr = ChunkedDataset(dm.require(train_cfg["key"])).open( cached=False) # to prevent run out of memory train_dataset = AgentDataset(cfg, train_zarr, rasterizer) train_dataloader = DataLoader(train_dataset, shuffle=train_cfg["shuffle"], batch_size=train_cfg["batch_size"], num_workers=train_cfg["num_workers"]) print(train_dataset, len(train_dataset)) train_writer = SummaryWriter('../log/CVAE', comment='CVAE') # 建立模型 model = cvae.CVAE(cfg, traj_dim=256, cont_dim=256, latent_dim=128, mode_dim=3, v_dim=4) weight_path = cfg["model_params"]["weight_path"] if weight_path: model.load_state_dict(torch.load(weight_path)) print(weight_path, 'loaded') # print(model) model.cuda() learning_rate = cfg["model_params"]["lr"] optimizer = optim.Adam(model.parameters(), lr=learning_rate) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=1000, gamma=0.96) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(f'device {device}')
def makeShapeModel(): model_in_dir = os.path.join(os.getcwd(), 'models/autoencoder') shapemodel = cv.CVAE(128, 64, training=False) shapemodel.loadMyModel(model_in_dir, 195) return shapemodel
train_cfg = cfg["train_data_loader"] train_zarr = ChunkedDataset(dm.require(train_cfg["key"])).open( cached=False) # to prevent run out of memory train_dataset = AgentDataset(cfg, train_zarr, rasterizer) train_dataloader = DataLoader(train_dataset, shuffle=train_cfg["shuffle"], batch_size=train_cfg["batch_size"], num_workers=train_cfg["num_workers"]) print(train_dataset, len(train_dataset)) train_writer = SummaryWriter('../log/CVAEGAN', comment='CVAEGAN') device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # 建立模型 generator = cvae.CVAE(cfg, traj_dim=256, cont_dim=256, mode_dim=3, v_dim=4) discriminator = cgan.discriminator(cfg, h_dim=256, cont_dim=256) weight_path_g = cfg["model_params"]["weight_path_g"] if weight_path_g: generator.load_state_dict(torch.load(weight_path)) weight_path_d = cfg["model_params"]["weight_path_d"] if weight_path_d: discriminator.load_state_dict(torch.load(weight_path)) generator.cuda() discriminator.cuda() g_loss_fn = utils.g_loss d_loss_fn = utils.d_loss learning_rate_g = cfg["model_params"]["lr_g"] learning_rate_d = cfg["model_params"]["lr_d"] optimizer_g = optim.Adam(generator.parameters(), lr=learning_rate_g)
kl_coef = 1 num_epochs = 50 batch_size = 64 share_encoder = True train_iter, val_iter, test, DE, EN = utils.torchtext_extract( d=device, MAX_LEN=max_len, BATCH_SIZE=batch_size) anneal = utils.kl_anneal_custom model = cvae.CVAE(len(DE.vocab), len(EN.vocab), embed_size, hidden_size, latent_size, num_layers, dpt, share_params=share_encoder) if gpu: model.cuda() print("Number of parameters: {}".format(utils.count_parameters(model))) train.train(model, model_name, train_iter, val_iter, DE, EN, anneal=anneal,
update the model's parameters. """ with tf.GradientTape() as tape: loss = lf.compute_loss(model, x, details) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # set the dimensionality of the latent space to a plane for visualization later # keeping the random vector constant for generation (prediction) so # it will be easier to see the improvement. random_vector_for_generation = tf.random.normal( shape=[num_examples_to_generate, latent_dim]) model = cv.CVAE(latent_dim,details_dim) if to_load: model.load_weights(latest) # Pick a sample of the test set for generating output images assert batch_size >= num_examples_to_generate epoch = 0 for epoch in range(1, epochs + 1): start_time = time.time() details_iteration = iter(train_details_dataset) for train_x in train_dataset: train_details_x = details_iteration.get_next() train_step(model, train_x, train_details_x[:, :7], optimizer) end_time = time.time()
signs_eq = sum( np.sign(pred[index]) == np.sign(tl[index])) / pred[index].shape[0] print( '\nStats for this comparison\n{:3d} Loss: {:.3f} Sum pred: {:.3f} Sum lab: {:.3f} Same Sign: {:.1f}%' .format(index, l, np.sum(pred[index]), np.sum(tl[index]), 100 * signs_eq)) #%% Get test set loss for tx, tl in train_ds.shuffle(100000).take(1000): pass txtmodel.model.training = False pred = txtmodel.sample(tx) losses = np.mean(txtmodel.compute_loss(pred, tl)) print(losses) #%% Load shape model shapemodel = cv.CVAE(cf_latent_dim, cf_vox_size) shapemodel.printMSums() shapemodel.printIO() shp_run_id = '0209-0306' root_dir = os.path.join(cf.SHAPE_RUN_DIR, shp_run_id) lg = logger.logger(root_dir) lg.setupCP(encoder=shapemodel.enc_model, generator=shapemodel.gen_model, opt=shapemodel.optimizer) lg.restoreCP() # Method for going from text to voxels def getVox(text): ptv = padEnc(text)
reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor=monitor, factor=0.5, verbose=1, patience=patience_cvae, min_lr=min_lr) checkpointer = ModelCheckpoint(filepath=path_to_save + '_CVAE', verbose=0, save_best_only=True, monitor=monitor) cb = [reduce_lr, checkpointer] parameters['optimizer'] = optim2 parameters['alpha'] = alpha_cvae parameters['zy_dim'] = zy_dim cvae_instance = cvae.CVAE(parameters) print(' Initializing encoder network ') init_encoder_ff_Y = cvae_instance.init_feedforward(L_enc_Y, activations_enc, pDrop, BN, 'encY_last_layer') print(' Initializing decoder network ') init_decoder_ff_Y = cvae_instance.init_feedforward(L_dec_Y, activations_dec, pDrop, BN, 'reconstructed_y') w_decY_init = init_decoder_ff_Y.get_weights() w_encY_init = init_encoder_ff_Y.get_weights() print(' Initializing CVAE ') cvae_instance.init(init_encoder_ff_Y, init_decoder_ff_Y, encX_mean, encX_var, feat_dim_X, feat_dim_Y) print(' Training CVAE ')