モデル全体をリメイクするのではなく、ディープラーニングモデルで隠れノードの数を変更できますか？

Question

私は、TensorFlow DeepLearningモデルにある隠れノードの最適な数を見つけるためにブルートフォースグリッド検索を試みています。プログラムがどれくらい時間がかかるか心配しているわけではありませんが、tf.variablesがすべて作られているためにプログラムがメモリ不足になっていることがわかりました。私のモデルを構築するコードは次の通りです：

def hiddenLayer(input_data, num_nodes, num_inputs, layer_num): 
    #Initialize all weights as the standard deviation of the input 
    weights = tf.Variable(tf.truncated_normal([num_inputs, num_nodes], 
     stddev=1.0/math.sqrt(float(num_inputs))), name='hidden' + str(layer_num) + '_weights') 
    #Initialize all biases as zero 
    biases = tf.Variable(tf.zeros([num_nodes]), name='hidden' + str(layer_num) + '_biases') 
    #Using RELU, return a linear combination of the biases and weights 
    return tf.nn.relu(tf.matmul(input_data, weights) + biases) 



def softmaxOutput(input_data, num_inputs, num_outputs): 
    #Initialize all weights as the standard deviation of the input 
    weights = tf.Variable(tf.truncated_normal([num_inputs, num_outputs], 
     stddev=1.0/math.sqrt(float(num_inputs))), name='output_weights') 
    #Initialize all baises as zero 
    biases = tf.Variable(tf.zeros([num_outputs]), name='output_biases') 
    #Squash the linear combination using softmax to give you LOGITS 
    return tf.nn.softmax(tf.matmul(input_data, weights) + biases) 

def calculate_loss(logits, labels): 
    labels = tf.to_int64(labels) 
    return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
     logits, labels, name = 'xentropy')) 


class SingleDNNClassifier(object): 
    def __init__(self, num_nodes, num_inputs, num_outputs, batch_size, layer_num=1, lr=0.01): 
    #Defining the features and labels variables 
     self.x = x = tf.placeholder(tf.float32, shape=(batch_size, num_inputs)) 
     self.y = y = tf.placeholder(tf.int32, shape=(batch_size)) 
     #Run the input data through the first hidden layer 
     x = hiddenLayer(x, num_nodes, num_inputs, layer_num) 
     #Run the output from the first hidden layer with softmax to get predicted logits 
     self.logits = logits = softmaxOutput(x, num_nodes, num_outputs) 
     #Get the predicted labels 
     self.predictions = tf.argmax(logits,1) 
     #Calculate the loss 
     self.loss = xeloss = calculate_loss(logits, y) 
     #Define the training operation for this model 
     self.train_op = tf.train.GradientDescentOptimizer(lr).minimize(xeloss) 


def train(sess, model, data, batch_size): 
    epoch_size = int(data.num_samples/batch_size) 
    losses = [] 

    for step in xrange(epoch_size): 
     #The way you get batches now shuffles the data, check to see if this is correct 
     train_x, train_y = data.next_batch(batch_size) 
     loss, _ = sess.run([model.loss, model.train_op], 
      {model.x: train_x, model.y: train_y}) 
     losses.append(loss) 
     if step % (epoch_size/5) == 5: 
      tf.logging.info("%.2f: %.3f", step * 1.0/epoch_size, np.mean(losses)) 
    return np.mean(losses) 


def evaluate(sess, model, data, batch_size): 
    predicted_values = [] 
    actual_values = [] 

    for i in xrange(int(data.num_samples/batch_size)): 
     val_x, val_y = data.next_batch(batch_size) 
     predictions = sess.run(model.predictions, {model.x: val_x, model.y: val_y}) 
     predicted_values.append(predictions) 
     actual_values.append(val_y) 
    predicted_values = np.concatenate(predicted_values).ravel() 
    actual_values = np.concatenate(actual_values).ravel() 

    return roc_auc_score(actual_values, predicted_values) 

ご覧のとおり、私のモデルはかなりシンプルです。 softmax出力の単層ネットワーク。しかし、私はこのコードを実行していますので、隠れノードの最適な数を知りたい：

sess = tf.InteractiveSession() 

hidden_nodes = 100 
epochs = 100 
increment = 100 
max_hidden_nodes = 20000 

while (hidden_nodes <= max_hidden_nodes): 
    print ("HIDDEN NODES: %d\n" %(hidden_nodes)) 
    output_file = open('AUC_SingleLayer/SingleLayer_' + str(hidden_nodes) + '.txt', 'w') 
    model = SingleDNNClassifier(hidden_nodes,16000,2,100) 

    tf.initialize_all_variables().run() 

    for i in range(epochs): 
     print ("\tEPOCH: %d\n" %(i+1)) 
     train(sess, model, dataset.training, 100) 
     valid_auc = DLM.evaluate(sess, model, dataset.testing, 100) 
     output_file.write('EPOCH %d: %.5f' % (i+1, valid_auc)) 
     if (i < epochs-1): 
      output_file.write('\n') 
    hidden_nodes += increment 

しかし、私はそれが重みを再初期化しておく必要があるため、私のLinuxワークステーションがメモリ不足エラーを取得しておきます私のhiddenLayer関数内の変数を偏らせます。当然ながら、ノードの数が増えるにつれて、各変数が取るメモリが増えます。

私は、このリンクのように何かをしようとしている：私はちょうど私が変更しています次元のサイズの指定されていないプレースホルダに値を渡しますが、それはするかどうかわからないことができhttps://github.com/tensorflow/tensorflow/issues/2311

作業。私はこれに助けや指導を感謝します。

TLDR：メモリが不足しているため変数の再初期化を停止する必要がありますが、変数のサイズはwhileループの繰り返しごとに変更されます。

Answer 1

これは完璧な答えではありませんが、私は回避策を見つけることができました。私はseq starting_numberを使用して私の間隔に基づいて数字の範囲を取得するシェルスクリプトを書いたbegin_numberと私のpythonコードにコマンドラインパラメータとして各値を与えました。これはメモリの問題を回避します。なぜなら、各繰り返しはPythonプロセスを終了することで終了し、メモリの問題を回避するからです。