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