TensorFlow：如何恢复基于T-GCN细胞的训练模型权重和偏差？

Question

我在特定的数据集上训练了一个模型并将其保存为元数据，我想还原该模型，并在代码不是我的另一个数据集上使用其权重和偏差，但是我试图在此之后还原体系结构被保存到图元文件中，TGCN由lehaifeng设计，用于预测图形边缘的速度。 您可以通过以下链接找到属于lehaifeng及其队友的源代码：

https://github.com/lehaifeng/T-GCN

我尝试了许多变通办法，但遇到很多错误，无法在此发布所有错误，是否可以使用我在上面发布的模型进行迁移学习，因为我无法在新数据集中使用此架构

我尝试过使用tf.get_collection(tf.GraphKeys.GLOBAL/TRAINABLE_VARIABLES)来将全局变量设置为恢复的模型全局变量，然后将其传递给优化器，这告诉我恢复的图中没有变量。

另一个问题是，除非我使用急切执行并且必须使用tf.map_fn，否则模型无法遍历张量，当从训练模型中调用占位符作为张量时，就不能使用急切执行graph.get_tensor_by_name()

import pickle as pkl
import tensorflow as tf
import pandas as pd
import numpy as np
import math
import os
import numpy.linalg as la
from input_data import preprocess_data,load_doha_data,load_los_data
from tgcn import tgcnCell
###from gru import GRUCell 

from visualization import plot_result,plot_error
from sklearn.metrics import mean_squared_error,mean_absolute_error
import matplotlib.pyplot as plt
import time

time_start = time.time()
####Settings####
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_float('learning_rate', 0.003, 'Initial learning rate.')
flags.DEFINE_integer('training_epoch', 10, 'Number of epochs to train.')
flags.DEFINE_integer('gru_units', 100, 'hidden units of gru.')
flags.DEFINE_integer('seq_len',4  , '  time length of inputs.')
flags.DEFINE_integer('pre_len', 1, 'time length of prediction.')
flags.DEFINE_float('train_rate', 0.8, 'rate of training set.')
flags.DEFINE_integer('batch_size', 64, 'batch size.')
flags.DEFINE_string('dataset', 'los', 'doha or los.')
flags.DEFINE_string('model_name', 'tgcn', 'tgcn')
model_name = FLAGS.model_name
data_name = FLAGS.dataset
train_rate =  FLAGS.train_rate
seq_len = FLAGS.seq_len
output_dim = pre_len = FLAGS.pre_len
batch_size = FLAGS.batch_size
lr = FLAGS.learning_rate
training_epoch = FLAGS.training_epoch
gru_units = FLAGS.gru_units

###### load data ######
if data_name == 'los':
data, adj = load_los_data('los')

time_len = data.shape[0]
print(time_len)
num_nodes = data.shape[1]
print(num_nodes)
data1 =np.mat(data,dtype=np.float32)

#### normalization
max_value = np.max(data1)
data1  = data1/max_value
trainX, trainY, testX, testY = preprocess_data(data1, time_len, train_rate, seq_len, pre_len)

totalbatch = int(trainX.shape[0]/batch_size)
training_data_count = len(trainX)

def TGCN(_X, _weights, _biases):
###
cell_1 = tgcnCell(gru_units, adj, num_nodes=num_nodes)
cell = tf.nn.rnn_cell.MultiRNNCell([cell_1], state_is_tuple=True)
_X = tf.unstack(_X, axis=1)
outputs, states = tf.nn.static_rnn(cell, _X, dtype=tf.float32)
m = []
for i in outputs:
    o = tf.reshape(i,shape=[-1,num_nodes,gru_units])
    o = tf.reshape(o,shape=[-1,gru_units])
    m.append(o)
last_output = m[-1]
output = tf.matmul(last_output, _weights['out2']) + _biases['out2']
output = tf.reshape(output,shape=[-1,num_nodes,pre_len])
output = tf.transpose(output, perm=[0,2,1])
output = tf.reshape(output, shape=[-1,num_nodes])
return output, m, states

###### placeholders ######
inputs = tf.placeholder(tf.float32, shape=[None, seq_len, num_nodes],name="inputs1")
labels = tf.placeholder(tf.float32, shape=[None, pre_len, num_nodes],name="lables1")

# Graph weights 
weights = {
'out2': tf.Variable(tf.random_normal([gru_units, pre_len], mean=1.0), name='weight_o')}
biases = {
'out2': tf.Variable(tf.random_normal([pre_len]),name='bias_o')}

if model_name == 'tgcn':
pred,ttts,ttto = TGCN(inputs, weights, biases)

y_pred = pred


###### optimizer ######
lambda_loss = 0.0010
Lreg = lambda_loss * sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables())
label = tf.reshape(labels, [-1,num_nodes])
##loss
loss = tf.reduce_mean(tf.nn.l2_loss(y_pred-label) + Lreg)
##rmse
error = tf.sqrt(tf.reduce_mean(tf.square(y_pred-label)))
optimizer = tf.train.AdamOptimizer(lr).minimize(loss)

###### Initialize session ######
variables = tf.global_variables()

#Create a saver object which will save all the variables
saver = tf.train.Saver(tf.global_variables())
init = tf.global_variables_initializer()
sess = tf.Session()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
sess.run(init)


out = 'out2/%s'%(model_name)
#out = 'out/%s_%s'%(model_name,'perturbation')
path1 = '%s_%s_lr%r_batch%r_unit%r_seq%r_pre%r_epoch%r'%(model_name,data_name,lr,batch_size,gru_units,seq_len,pre_len,training_epoch)
path = os.path.join(out,path1)
if not os.path.exists(path):
os.makedirs(path)

###### evaluation ######
def evaluation(a,b):
rmse = math.sqrt(mean_squared_error(a,b))
mae = mean_absolute_error(a, b)
F_norm = la.norm(a-b,'fro')/la.norm(a,'fro')
r2 = 1-((a-b)**2).sum()/((a-a.mean())**2).sum()
var = 1-(np.var(a-b))/np.var(a)
return rmse, mae, 1-F_norm, r2, var


x_axe,batch_loss,batch_rmse,batch_pred = [], [], [], []
test_loss,test_rmse,test_mae,test_acc,test_r2,test_var,test_pred = [],[],[],[],[],[],[]

for epoch in range(training_epoch):
for m in range(totalbatch):
    mini_batch = trainX[m * batch_size : (m+1) * batch_size]
    mini_label = trainY[m * batch_size : (m+1) * batch_size]
    _, loss1, rmse1, train_output = sess.run([optimizer, loss, error, y_pred],
                                             feed_dict = {inputs:mini_batch, labels:mini_label})
    batch_loss.append(loss1)
    batch_rmse.append(rmse1 * max_value)

 # Test completely at every epoch
 loss2, rmse2, test_output = sess.run([loss, error, y_pred],
                                     feed_dict = {inputs:testX, labels:testY})
test_label = np.reshape(testY,[-1,num_nodes])
rmse, mae, acc, r2_score, var_score = evaluation(test_label, test_output)
test_label1 = test_label * max_value
test_output1 = test_output * max_value
test_loss.append(loss2)
test_rmse.append(rmse * max_value)
test_mae.append(mae * max_value)
test_acc.append(acc)
test_r2.append(r2_score)
test_var.append(var_score)
test_pred.append(test_output1)

print('Iter:{}'.format(epoch),
      'train_rmse:{:.4}'.format(batch_rmse[-1]),
     'test_loss:{:.4}'.format(loss2),
    'test_rmse:{:.4}'.format(rmse),
     'test_acc:{:.4}'.format(acc))

saver.save(sess, './TGCNpretrain.model')
print (tf.contrib.framework.list_variables('./TGCNpretrain.model'))
time_end = time.time()
print(time_end-time_start,'s')

因此，总结一下我的问题，如何恢复该模型并将其加载到另一个数据集上。 您可以从源代码链接下载所有其他代码回调函数和数据集，以确保更改路径，以便main.py可以导入其输入矩阵。预先感谢

p.s我尤其是Tesnorflow的极端入门者，并且通常是Python的入门者。所以请原谅我在表达问题上的经验。