/// <summary>
/// For an op that takes `input_ops` as inputs, compute control inputs.
/// </summary>
/// <param name="input_ops">The data input ops for an op to be created.</param>
/// <returns>A list of control inputs for the op to be created.</returns>
private ITensorOrOperation[] _control_dependencies_for_inputs(ITensorOrOperation[] input_ops)
{
var ret = new ITensorOrOperation[0];
foreach (var controller in _control_dependencies_stack)
{
bool dominated = false;
// If any of the input_ops already depends on the inputs from controller,
// we say that the new op is dominated (by that input), and we therefore
// do not need to add control dependencies for this controller's inputs.
foreach (var op in input_ops)
{
if (controller.op_in_group(op))
{
dominated = true;
break;
}
}
if (!dominated)
{
ret = controller.control_inputs.Where(x => !input_ops.Contains(x)).ToArray();
}
}
return(ret);
}
public void Autocast_Case0()
{
var sess = tf.Session().as_default();
ITensorOrOperation operation = tf.global_variables_initializer();
// the cast to ITensorOrOperation is essential for the test of this method signature
var ret = sess.run(operation);
}
/// <summary>
/// Adds keys to a collection.
/// </summary>
/// <param name="val"The value to add per each key.></param>
/// <param name="collections">A collection of keys to add.</param>
/// <param name="default_collections">Used if collections is None.</param>
public void collect(ITensorOrOperation val, List <string> collections, List <string> default_collections)
{
if (collections == null)
{
collections = default_collections;
}
foreach (var key in collections)
{
ops.add_to_collection(key, val);
}
}
public _ElementFetchMapper(object[] fetches, Func <List <object>, object> contraction_fn)
{
var g = ops.get_default_graph();
ITensorOrOperation el = null;
foreach (var fetch in fetches)
{
el = g.as_graph_element(fetch, allow_tensor: true, allow_operation: true);
}
_unique_fetches.Add(el);
_contraction_fn = contraction_fn;
}
public static bool is_constant(ITensorOrOperation tensor_or_op)
{
if (tensor_or_op is Tensor tensor)
{
return(tensor.op.type == "Const");
}
else if (tensor_or_op is Operation op)
{
return(op.type == "Const");
}
else
{
throw new ValueError("is_constant");
}
}
public virtual NDArray run(ITensorOrOperation fetche, params FeedItem[] feed_dict)
{
var results = _run(fetche, feed_dict);
return(fetche is Tensor ? results[0] : null);
}
public bool op_in_group(ITensorOrOperation op)
{
return(_seen_nodes.Contains(op));
}
public void add_op(ITensorOrOperation op)
{
_seen_nodes.Add(op);
}
public virtual NDArray run(ITensorOrOperation fetche, params FeedItem[] feed_dict)
{
return(_run(fetche, feed_dict)[0]);
}
