def main(cfg):
os.environ['CUDA_VISIBLE_DEVICES'] = str(cfg.gpu_id)
# ---------------------------------------------------------------
# Set random seed
print('=> pre-porcessing')
seed = 123
np.random.seed(seed)
tf.set_random_seed(seed)
# ---------------------------------------------------------------
num_blocks = 3
num_supports = 2
placeholders = {
'features': tf.placeholder(tf.float32, shape=(None, 3), name='features'),
'img_inp': tf.placeholder(tf.float32, shape=(3, 224, 224, 3), name='img_inp'),
'labels': tf.placeholder(tf.float32, shape=(None, 6), name='labels'),
'support1': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support2': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support3': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'faces': [tf.placeholder(tf.int32, shape=(None, 4)) for _ in range(num_blocks)],
'edges': [tf.placeholder(tf.int32, shape=(None, 2)) for _ in range(num_blocks)],
'lape_idx': [tf.placeholder(tf.int32, shape=(None, 10)) for _ in range(num_blocks)], # for laplace term
'pool_idx': [tf.placeholder(tf.int32, shape=(None, 2)) for _ in range(num_blocks - 1)], # for unpooling
'dropout': tf.placeholder_with_default(0., shape=()),
'num_features_nonzero': tf.placeholder(tf.int32),
'sample_coord': tf.placeholder(tf.float32, shape=(43, 3), name='sample_coord'),
'cameras': tf.placeholder(tf.float32, shape=(3, 5), name='Cameras'),
'faces_triangle': [tf.placeholder(tf.int32, shape=(None, 3)) for _ in range(num_blocks)],
'sample_adj': [tf.placeholder(tf.float32, shape=(43, 43)) for _ in range(num_supports)],
}
root_dir = os.path.join(cfg.save_path, cfg.name)
model_dir = os.path.join(cfg.save_path, cfg.name, 'models')
log_dir = os.path.join(cfg.save_path, cfg.name, 'logs')
plt_dir = os.path.join(cfg.save_path, cfg.name, 'plt')
if not os.path.exists(root_dir):
os.mkdir(root_dir)
print('==> make root dir {}'.format(root_dir))
if not os.path.exists(model_dir):
os.mkdir(model_dir)
print('==> make model dir {}'.format(model_dir))
if not os.path.exists(log_dir):
os.mkdir(log_dir)
print('==> make log dir {}'.format(log_dir))
if not os.path.exists(plt_dir):
os.mkdir(plt_dir)
print('==> make plt dir {}'.format(plt_dir))
summaries_dir = os.path.join(cfg.save_path, cfg.name, 'summaries')
train_loss = open('{}/train_loss_record.txt'.format(log_dir), 'a')
train_loss.write('Net {} | Start training | lr = {}\n'.format(cfg.name, cfg.lr))
# -------------------------------------------------------------------
print('=> build model')
# Define model
model = MeshNet(placeholders, logging=True, args=cfg)
# ---------------------------------------------------------------
print('=> load data')
data = DataFetcher(file_list=cfg.train_file_path, data_root=cfg.train_data_path,
image_root=cfg.train_image_path, is_val=False, mesh_root=cfg.train_mesh_root)
data.setDaemon(True)
data.start()
# ---------------------------------------------------------------
print('=> initialize session')
sesscfg = tf.ConfigProto()
sesscfg.gpu_options.allow_growth = True
sesscfg.allow_soft_placement = True
sess = tf.Session(config=sesscfg)
sess.run(tf.global_variables_initializer())
train_writer = tf.summary.FileWriter(summaries_dir, sess.graph, filename_suffix='train')
# ---------------------------------------------------------------
if cfg.load_cnn:
print('=> load pre-trained cnn')
model.loadcnn(sess=sess, ckpt_path=cfg.pre_trained_cnn_path, step=cfg.cnn_step)
if cfg.restore:
print('=> load model')
model.load(sess=sess, ckpt_path=model_dir, step=cfg.init_epoch)
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
pkl = pickle.load(open('data/iccv_p2mpp.dat', 'rb'))
# Construct Feed dict
feed_dict = construct_feed_dict(pkl, placeholders)
# ---------------------------------------------------------------
train_number = data.number
step = 0
tflearn.is_training(True, sess)
print('=> start train stage 2')
for epoch in range(cfg.epochs):
current_epoch = epoch + 1 + cfg.init_epoch
epoch_plt_dir = os.path.join(plt_dir, str(current_epoch))
if not os.path.exists(epoch_plt_dir):
os.mkdir(epoch_plt_dir)
mean_loss = 0
all_loss = np.zeros(train_number, dtype='float32')
for iters in range(train_number):
step += 1
# Fetch training data
# need [img, label, pose(camera meta data), dataID]
img_all_view, labels, poses, data_id, mesh = data.fetch()
feed_dict.update({placeholders['features']: mesh})
feed_dict.update({placeholders['img_inp']: img_all_view})
feed_dict.update({placeholders['labels']: labels})
feed_dict.update({placeholders['cameras']: poses})
# ---------------------------------------------------------------
_, dists, summaries, out1l, out2l = sess.run([model.opt_op, model.loss, model.merged_summary_op, model.output1l, model.output2l], feed_dict=feed_dict)
# ---------------------------------------------------------------
all_loss[iters] = dists
mean_loss = np.mean(all_loss[np.where(all_loss)])
print('Epoch {}, Iteration {}, Mean loss = {}, iter loss = {}, {}, data id {}'.format(current_epoch, iters + 1, mean_loss, dists, data.queue.qsize(), data_id))
train_writer.add_summary(summaries, step)
if (iters + 1) % 1000 == 0:
plot_scatter(pt=out2l, data_name=data_id, plt_path=epoch_plt_dir)
# ---------------------------------------------------------------
# Save model
model.save(sess=sess, ckpt_path=model_dir, step=current_epoch)
train_loss.write('Epoch {}, loss {}\n'.format(current_epoch, mean_loss))
train_loss.flush()
# ---------------------------------------------------------------
data.shutdown()
print('CNN-GCN Optimization Finished!')
def main(cfg):
os.environ['CUDA_VISIBLE_DEVICES'] = str(0)
# ---------------------------------------------------------------
# Set random seed
print('=> pre-porcessing')
seed = 123
np.random.seed(seed)
tf.set_random_seed(seed)
# ---------------------------------------------------------------
num_blocks = 3
num_supports = 2
placeholders = {
'features':
tf.placeholder(tf.float32, shape=(None, 3), name='features'),
'img_inp':
tf.placeholder(tf.float32, shape=(3, 224, 224, 3), name='img_inp'),
'labels':
tf.placeholder(tf.float32, shape=(None, 6), name='labels'),
'support1':
[tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support2':
[tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support3':
[tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'faces':
[tf.placeholder(tf.int32, shape=(None, 4)) for _ in range(num_blocks)],
'edges':
[tf.placeholder(tf.int32, shape=(None, 2)) for _ in range(num_blocks)],
'lape_idx': [
tf.placeholder(tf.int32, shape=(None, 10))
for _ in range(num_blocks)
], # for laplace term
'pool_idx': [
tf.placeholder(tf.int32, shape=(None, 2))
for _ in range(num_blocks - 1)
], # for unpooling
'dropout':
tf.placeholder_with_default(0., shape=()),
'num_features_nonzero':
tf.placeholder(tf.int32),
'sample_coord':
tf.placeholder(tf.float32, shape=(43, 3), name='sample_coord'),
'cameras':
tf.placeholder(tf.float32, shape=(3, 5), name='Cameras'),
'faces_triangle':
[tf.placeholder(tf.int32, shape=(None, 3)) for _ in range(num_blocks)],
'sample_adj': [
tf.placeholder(tf.float32, shape=(43, 43))
for _ in range(num_supports)
],
}
# step = cfg.test_epoch
# root_dir = os.path.join(cfg.save_path, cfg.name)
model1_dir = os.path.join('results', 'coarse_mvp2m', 'models')
model2_dir = os.path.join('results', 'refine_p2mpp', 'models')
# predict_dir = os.path.join(cfg.save_path, cfg.name, 'predict', str(step))
# if not os.path.exists(predict_dir):
# os.makedirs(predict_dir)
# print('==> make predict_dir {}'.format(predict_dir))
# -------------------------------------------------------------------
print('=> build model')
# Define model
model1 = MVP2MNet(placeholders, logging=True, args=cfg)
model2 = P2MPPNet(placeholders, logging=True, args=cfg)
# ---------------------------------------------------------------
print('=> load data')
demo_img_list = [
'data/demo/plane1.png', 'data/demo/plane2.png', 'data/demo/plane3.png'
]
img_all_view = load_demo_image(demo_img_list)
cameras = np.loadtxt('data/demo/cameras.txt')
# data = DataFetcher(file_list=cfg.test_file_path, data_root=cfg.test_data_path, image_root=cfg.test_image_path, is_val=True)
# data.setDaemon(True)
# data.start()
# ---------------------------------------------------------------
print('=> initialize session')
sesscfg = tf.ConfigProto()
sesscfg.gpu_options.allow_growth = True
sesscfg.allow_soft_placement = True
sess = tf.Session(config=sesscfg)
sess.run(tf.global_variables_initializer())
# sess2 = tf.Session(config=sesscfg)
# sess2.run(tf.global_variables_initializer())
# ---------------------------------------------------------------
model1.load(sess=sess, ckpt_path=model1_dir, step=50)
model2.load(sess=sess, ckpt_path=model2_dir, step=10)
# exit(0)
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
pkl = pickle.load(open('data/iccv_p2mpp.dat', 'rb'))
# Construct Feed dict
feed_dict = construct_feed_dict(pkl, placeholders)
# ---------------------------------------------------------------
tflearn.is_training(False, sess)
print('=> start test stage 1')
feed_dict.update({placeholders['img_inp']: img_all_view})
feed_dict.update({placeholders['labels']: np.zeros([10, 6])})
feed_dict.update({placeholders['cameras']: cameras})
stage1_out3 = sess.run(model1.output3, feed_dict=feed_dict)
print('=> start test stage 2')
feed_dict.update({placeholders['features']: stage1_out3})
vert = sess.run(model2.output2l, feed_dict=feed_dict)
vert = np.hstack((np.full([vert.shape[0], 1], 'v'), vert))
face = np.loadtxt('data/face3.obj', dtype='|S32')
mesh = np.vstack((vert, face))
pred_path = 'data/demo/predict.obj'
np.savetxt(pred_path, mesh, fmt='%s', delimiter=' ')
print('=> save to {}'.format(pred_path))
def main(cfg):
physical_devices = tf.config.list_physical_devices('GPU')
try:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
except:
# Invalid device or cannot modify virtual devices once initialized.
pass
os.environ['CUDA_VISIBLE_DEVICES'] = str(cfg.gpu_id)
# pre-processing
print('=> pre-processing:参数初始化ing')
seed = 123
np.random.seed(seed)
# ---------------------------------------------------------------
#num_blocks = 3
#num_supports = 2
#name: 'coarse_mvp2m'
#save_path: 'results'
root_dir = os.path.join(cfg.save_path, cfg.name)
print(cfg.save_path)
model_dir = os.path.join(cfg.save_path, cfg.name, 'models')
log_dir = os.path.join(cfg.save_path, cfg.name, 'logs')
plt_dir = os.path.join(cfg.save_path, cfg.name, 'plt')
if not os.path.exists(root_dir):
os.makedirs(root_dir)
print('==> make root dir {}'.format(root_dir))
if not os.path.exists(model_dir):
os.makedirs(model_dir)
print('==> make model dir {}'.format(model_dir))
if not os.path.exists(log_dir):
os.makedirs(log_dir)
print('==> make log dir {}'.format(log_dir))
if not os.path.exists(plt_dir):
os.makedirs(plt_dir)
print('==> make plt dir {}'.format(plt_dir))
train_loss = open('{}/train_loss_record.txt'.format(log_dir), 'a')
train_loss.write('Net {} | Start training | lr = {}\n'.format(
cfg.name, cfg.lr))
#data_loading
print("=> data loading:数据加载ing")
data = DataFetcher(file_list=cfg.train_file_path,
data_root=cfg.train_data_path,
image_root=cfg.train_image_path,
is_val=False)
data.setDaemon(True)
data.start()
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
pkl = pickle.load(open('data/iccv_p2mpp.dat', 'rb'))
# Construct Feed dict
edges, faces, features, support1, support2, support3, pool_idx, lape_idx, faces_triangle, sample_adj, sample_coord = tools.construct_feed_dict(
pkl)
num_features_nonzero = None
dropout = 0
# ---------------------------------------------------------------
#Define model
print("=> model loading:模型加载ing")
features = tf.convert_to_tensor(features, dtype=tf.float32)
#-------------------------------
#是否加载预训练模型 Default：False
#-------------------------------
pre_train = False
if pre_train == True:
model = tf.keras.models.load_model(
'/workspace/3D/tf2_gcn-main/results/coarse_mvp2m/models/20200222model'
)
else:
model = GCN.GCN_model(placeholders_features=features,
num_features_nonzero=num_features_nonzero,
placeholder_dropout=dropout,
pool_idx=pool_idx,
args=cfg,
support1=support1,
support2=support2,
support3=support3,
lape_idx=lape_idx,
edges=edges,
faces_triangle=faces_triangle)
print('模型加载完成')
#-------------------------------
#是否加载预训练权重 Default：False
#-------------------------------
pre_weight = True
if pre_weight == True:
model.load_weights(
'/workspace/3D/tf2_gcn-main/results/coarse_mvp2m/models/20200223model_weights/epoch1'
)
#权重保存位置
model_weights_save_path = '/workspace/3D/tf2_gcn-main/results/coarse_mvp2m/models/20200223model_weights/epoch'
print('=> start train ')
def get_loss(output1, output2, output3, output1_2, output2_2, features,
trainable_variables, labels, edges, faces_triangle, lape_idx):
'''损失函数'''
# # Weight decay loss
loss = tf.zeros([])
# Cross entropy error
# Pixel2mesh loss
loss += mesh_loss(pred=output1,
labels=labels,
edges=edges,
faces_triangle=faces_triangle,
block_id=1)
loss += mesh_loss(pred=output2,
labels=labels,
edges=edges,
faces_triangle=faces_triangle,
block_id=2)
loss += mesh_loss(pred=output3,
labels=labels,
edges=edges,
faces_triangle=faces_triangle,
block_id=3)
loss += laplace_loss(pred1=features,
pred2=output1,
lape_idx=lape_idx,
block_id=1)
loss += laplace_loss(pred1=output1_2,
pred2=output2,
lape_idx=lape_idx,
block_id=2)
loss += laplace_loss(pred1=output2_2,
pred2=output3,
lape_idx=lape_idx,
block_id=3)
# Weight decay loss
#conv_layers = list(range(1, 15)) + list(range(17, 31)) + list(range(33, 48))
#for layer_id in conv_layers:
for var1 in trainable_variables:
for var in var1:
loss += 5e-6 * tf.nn.l2_loss(var)
return loss
optimizer = tf.keras.optimizers.Adam(lr=cfg.lr)
@tf.function(experimental_relax_shapes=True)
def train_step(img_with_cameras, labels):
with tf.GradientTape() as tape:
output1, output2, output3, output1_2, output2_2, trainable_variables = model(
img_with_cameras)
loss = get_loss(output1, output2, output3, output1_2, output2_2,
features, trainable_variables, labels, edges,
faces_triangle, lape_idx)
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
return loss, output3
train_number = data.number
step = 0
for epoch in range(cfg.epochs):
# 在下一个epoch开始时，重置评估指标
current_epoch = epoch + 1 + cfg.init_epoch
epoch_plt_dir = os.path.join(plt_dir, str(current_epoch))
if not os.path.exists(epoch_plt_dir):
os.mkdir(epoch_plt_dir)
mean_loss = 0
all_loss = np.zeros(train_number, dtype='float32')
#for iters in range(train_number):
for iters in range(50):
#train_number 35010
step += 1
img_all_view, labels, cameras, data_id, mesh = data.fetch()
img_with_cameras = {}
img_with_cameras.update({'img_all_view': img_all_view})
img_with_cameras.update({'cameras': cameras})
#cameras : [3,5]
loss, output3 = train_step(img_with_cameras, labels)
all_loss[iters] = loss
mean_loss = np.mean(all_loss[np.where(all_loss)])
if iters % 100 == 0:
print(
'Epoch {}, Iteration {}, Mean loss = {}, iter loss = {}, {}, data id {}'
.format(current_epoch, iters + 1, mean_loss, loss,
data.queue.qsize(), data_id))
if iters + 1 % 1000 == 0:
train_loss.write(
'Epoch {}, Iteration {}, Mean loss = {}, iter loss = {}, {}, data id {}\n'
.format(current_epoch, iters + 1, mean_loss, loss,
data.queue.qsize(), data_id))
plot_scatter(pt=output3,
data_name=data_id,
plt_path=epoch_plt_dir)
train_loss.flush()
model.save_weights(model_weights_save_path + str(current_epoch))
print('模型保存完成，保存路径：', model_weights_save_path)
# ---------------------------------------------------------------
data.shutdown()
#model save
print('CNN-GCN Optimization Finished!')
def main(cfg):
os.environ['CUDA_VISIBLE_DEVICES'] = str(cfg.gpu_id)
# ---------------------------------------------------------------
# Set random seed
print('=> pre-porcessing')
seed = 123
np.random.seed(seed)
tf.set_random_seed(seed)
# ---------------------------------------------------------------
num_blocks = 3
num_supports = 2
placeholders = {
'features': tf.placeholder(tf.float32, shape=(None, 3), name='features'),
'img_inp': tf.placeholder(tf.float32, shape=(3, 224, 224, 3), name='img_inp'),
'labels': tf.placeholder(tf.float32, shape=(None, 6), name='labels'),
'support1': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support2': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'support3': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)],
'faces': [tf.placeholder(tf.int32, shape=(None, 4)) for _ in range(num_blocks)],
'edges': [tf.placeholder(tf.int32, shape=(None, 2)) for _ in range(num_blocks)],
'lape_idx': [tf.placeholder(tf.int32, shape=(None, 10)) for _ in range(num_blocks)], # for laplace term
'pool_idx': [tf.placeholder(tf.int32, shape=(None, 2)) for _ in range(num_blocks - 1)], # for unpooling
'dropout': tf.placeholder_with_default(0., shape=()),
'num_features_nonzero': tf.placeholder(tf.int32),
'sample_coord': tf.placeholder(tf.float32, shape=(43, 3), name='sample_coord'),
'cameras': tf.placeholder(tf.float32, shape=(3, 5), name='Cameras'),
'faces_triangle': [tf.placeholder(tf.int32, shape=(None, 3)) for _ in range(num_blocks)],
'sample_adj': [tf.placeholder(tf.float32, shape=(43, 43)) for _ in range(num_supports)],
}
step = cfg.test_epoch
root_dir = os.path.join(cfg.save_path, cfg.name)
model_dir = os.path.join(cfg.save_path, cfg.name, 'models')
predict_dir = os.path.join(cfg.save_path, cfg.name, 'predict', str(step))
if not os.path.exists(predict_dir):
os.makedirs(predict_dir)
print('==> make predict_dir {}'.format(predict_dir))
# -------------------------------------------------------------------
print('=> build model')
# Define model
model = MeshNetMVP2M(placeholders, logging=True, args=cfg)
# ---------------------------------------------------------------
print('=> load data')
data = DataFetcher(file_list=cfg.test_file_path, data_root=cfg.test_data_path, image_root=cfg.test_image_path, is_val=True)
data.setDaemon(True)
data.start()
# ---------------------------------------------------------------
print('=> initialize session')
sesscfg = tf.ConfigProto()
sesscfg.gpu_options.allow_growth = True
sesscfg.allow_soft_placement = True
sess = tf.Session(config=sesscfg)
sess.run(tf.global_variables_initializer())
# ---------------------------------------------------------------
model.load(sess=sess, ckpt_path=model_dir, step=step)
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
pkl = pickle.load(open('data/iccv_p2mpp.dat', 'rb'))
# Construct Feed dict
feed_dict = construct_feed_dict(pkl, placeholders)
# ---------------------------------------------------------------
test_number = data.number
tflearn.is_training(False, sess)
print('=> start test stage 1')
for iters in range(test_number):
# Fetch training data
# need [img, label, pose(camera meta data), dataID]
img_all_view, labels, poses, data_id, mesh = data.fetch()
feed_dict.update({placeholders['img_inp']: img_all_view})
feed_dict.update({placeholders['labels']: labels})
feed_dict.update({placeholders['cameras']: poses})
# ---------------------------------------------------------------
out1, out2, out3 = sess.run([model.output1, model.output2, model.output3], feed_dict=feed_dict)
# ---------------------------------------------------------------
# save GT
label_path = os.path.join(predict_dir, data_id.replace('.dat', '_ground.xyz'))
np.savetxt(label_path, labels)
# save 1
# out1_path = os.path.join(predict_dir, data_id.replace('.dat', '_predict_1.xyz'))
# np.savetxt(out1_path, out1)
# # save 2
# out2_path = os.path.join(predict_dir, data_id.replace('.dat', '_predict_2.xyz'))
# np.savetxt(out2_path, out2)
# save 3
out3_path = os.path.join(predict_dir, data_id.replace('.dat', '_predict.xyz'))
np.savetxt(out3_path, out3)
print('Iteration {}/{}, Data id {}'.format(iters + 1, test_number, data_id))
# ---------------------------------------------------------------
data.shutdown()
print('CNN-GCN Optimization Finished!')
def main(cfg):
physical_devices = tf.config.list_physical_devices('GPU')
try:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
except:
# Invalid device or cannot modify virtual devices once initialized.
pass
os.environ['CUDA_VISIBLE_DEVICES'] = str(cfg.gpu_id)
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
# Construct Feed dict
print('=> pre-processing:参数初始化ing')
# ---------------------------------------------------------------
#num_blocks = 3
#num_supports = 2
#name: 'coarse_mvp2m'
#save_path: 'results'
root_dir = os.path.join(cfg.save_path, cfg.name)
print(cfg.save_path)
model_dir = os.path.join(cfg.save_path, cfg.name, 'models')
log_dir = os.path.join(cfg.save_path, cfg.name, 'logs')
plt_dir = os.path.join(cfg.save_path, cfg.name, 'plt')
if not os.path.exists(root_dir):
os.makedirs(root_dir)
print('==> make root dir {}'.format(root_dir))
if not os.path.exists(model_dir):
os.makedirs(model_dir)
print('==> make model dir {}'.format(model_dir))
if not os.path.exists(log_dir):
os.makedirs(log_dir)
print('==> make log dir {}'.format(log_dir))
if not os.path.exists(plt_dir):
os.makedirs(plt_dir)
print('==> make plt dir {}'.format(plt_dir))
train_loss = open('{}/train_loss_record.txt'.format(log_dir), 'a')
train_loss.write('Net {} | Start training | lr = {}\n'.format(
cfg.name, cfg.lr))
#data_loading
print("=> data loading:数据加载ing")
# ---------------------------------------------------------------
# Load init ellipsoid and info about vertices and edges
pkl = pickle.load(open('data/iccv_p2mpp.dat', 'rb'))
# Construct Feed dict
edges, faces, features, support1, support2, support3, pool_idx, lape_idx, faces_triangle, sample_adj, sample_coord = tools.construct_feed_dict(
pkl)
num_features_nonzero = None
dropout = 0
# ---------------------------------------------------------------
#Define model
print("=> model loading:模型加载ing")
#数据类型转换为Tensor类型!
features = tf.convert_to_tensor(features, dtype=tf.float32)
pre_train = False
if pre_train == True:
model = tf.keras.models.load_model(
'/workspace/3D/tf2_gcn-main/results/coarse_mvp2m/models/20200222model'
)
else:
model = GCN.GCN_model(placeholders_features=features,
num_features_nonzero=num_features_nonzero,
placeholder_dropout=dropout,
pool_idx=pool_idx,
args=cfg,
support1=support1,
support2=support2,
support3=support3,
lape_idx=lape_idx,
edges=edges,
faces_triangle=faces_triangle)
model.load_weights(
'/workspace/3D/tf2_gcn-main/results/coarse_mvp2m/models/20200223model_weights_epoch/1'
)
print('=> build model complete')
print('=> start demo ')
# -------------------------------------------------------------------
# ---------------------------------------------------------------
print('=> load data')
demo_img_list = [
'data/demo/plane1.png', 'data/demo/plane2.png', 'data/demo/plane3.png'
]
img_all_view = tools.load_demo_image(demo_img_list)
cameras = np.loadtxt('data/demo/cameras.txt')
img_with_cameras = {}
img_with_cameras.update({'img_all_view': img_all_view})
img_with_cameras.update({'cameras': cameras})
output1, output2, output3, output1_2, output2_2, trainable_variables = model(
img_with_cameras)
#loss = get_loss(output1,output2,output3,output1_2,output2_2,features,trainable_variables,labels,edges,faces_triangle,lape_idx)
vert = output3
vert = np.hstack((np.full([vert.shape[0], 1], 'v'), vert))
face = np.loadtxt('data/face3.obj', dtype='|S32')
mesh = np.vstack((vert, face))
pred_path = 'data/demo/predict.obj'
np.savetxt(pred_path, mesh, fmt='%s', delimiter=' ')
print('=> save to {}'.format(pred_path))
