tf global variables initializer

[ferreirafabio]

In the demos we can see that tf.global_variables_initializer() is called before every model execution. Since one might be interested in batch-wise computation, it would be good to know whether there's a work around to this requirement.

Specifically, not calling the initialization line before running EncodeProcessDecode model yields:

FailedPreconditionError (see above for traceback): Attempting to use uninitialized value EncodeProcessDecode/graph_independent/edge_model/edge_output/b

Is there a more efficient way to run the model on the input / target placeholders?

[alvarosg]

From the sort demo, tf.global_variables_initializer is only executed once right after creating the interactive session:

sess = tf.Session()
sess.run(tf.global_variables_initializer())

Once the session is created and the variables initialized once, you should be able to evaluate the network for any other values of the placeholders without any additional requirements to call the initializers again (Just like in any other TF model).

If you do not want to deal with variable initialization explicitly, you may be interested on using tf.train.MonitoredSession or tf.train.SingularMonitoredSession instead of tf.Session, and they will do variable intialization automatically.

Hope this helps :)

[ferreirafabio]

Thank you for your answer, Alvaro.

I should clarify my issue a little better:
A typical method from the graph_net examples is to initialize a model with placeholders so that shapes are known for building the computation graph. Once this model has been initialized, the global variables are initialized and the previously initialized model is re-used during the training cycles for feeding.

However, when we initialize our model, e.g. (from the physics demo):

output_ops_tr = model(input_graph_tr, num_processing_steps_tr)

we assume the number of predictions/estimations are fixed (num_processing_steps_tr).

Now, what can one do if the number of model estimations varies during training? The only idea which comes to my mind is to set the num_processing_steps_tr to the highest number that occurs during training and computing the loss only over the required estimation length.

Is there a more elegant way to do this?

[alvarosg]

As you said, the easy solution is to have a fixed maximum number of num_processing_steps. This is actually the option with the fastest inference as well, however it is not only not very elegant, but if you make the number of thinking steps arbitrarily high, the time it takes to build the graph will grow linearly with that,

The alternative solution is to have a placeholder that contains the number of processing steps, so you can change the value dynamically. However, this would mean that now the exact number of processing steps is not known at graph definition time, so you cannot longer use a python for loop to build the thinking steps in the graph. Instead you would have to use a tf.while_loop that defines an in-graph loop with a number of iterations that can change dynamically as function of a tensor.