public (Tensor, Tensor) __call__(Tensor inputs,
Tensor training = null,
VariableScope scope = null)
{
_set_scope(scope);
_graph = ops._get_graph_from_inputs(new Tensor[] { inputs }, graph: _graph);
variable_scope scope_context_manager = null;
if (built)
{
}
else
{
scope_context_manager = tf.variable_scope(_scope,
reuse: _reuse,
auxiliary_name_scope: false);
}
(Tensor, Tensor)outputs = (null, null);
tf_with(scope_context_manager, scope2 =>
{
_current_scope = scope2;
// Actually call layer
outputs = base.__call__(new Tensor[] { inputs }, training: training);
});
// Update global default collections.
_add_elements_to_collection(_updates.ToArray(), new string[] { tf.GraphKeys.UPDATE_OPS });
return(outputs);
}
static (Tensor xywh, Tensor conf, Tensor prob) DecodeCommon(
Tensor convOut, int outputSize, int classCount,
ReadOnlySpan <int> strides, Tensor <int> anchors,
int scaleIndex, ReadOnlySpan <float> xyScale)
{
var varScope = new variable_scope("scale" + scaleIndex.ToString(System.Globalization.CultureInfo.InvariantCulture));
using var _ = varScope.StartUsing();
Tensor batchSize = tf.shape(convOut)[0];
convOut = tf.reshape_dyn(convOut, new object[] { batchSize, outputSize, outputSize, 3, 5 + classCount });
Tensor[] raws = tf.split(convOut, new[] { 2, 2, 1, classCount }, axis: -1);
var(convRawDxDy, convRawDwDh, convRawConf, convRawProb) = raws;
var meshgrid = tf.meshgrid(tf.range_dyn(outputSize), tf.range_dyn(outputSize));
meshgrid = tf.expand_dims(tf.stack(meshgrid, axis: -1), axis: 2); // [gx, gy, 1, 2]
Tensor xyGrid = tf.tile_dyn(
tf.expand_dims(meshgrid, axis: 0),
new object[] { tf.shape(convOut)[0], 1, 1, 3, 1 });
xyGrid = tf.cast(xyGrid, tf.float32);
var predictedXY = ((tf.sigmoid(convRawDxDy) * xyScale[scaleIndex]) - 0.5 * (xyScale[scaleIndex] - 1) + xyGrid) * strides[scaleIndex];
var predictedWH = tf.exp(convRawDwDh) * tf.cast(anchors[scaleIndex], tf.float32);
var predictedXYWH = tf.concat(new[] { predictedXY, predictedWH }, axis: -1);
var predictedConf = tf.sigmoid(convRawConf);
var predictedProb = tf.sigmoid(convRawProb);
return(predictedXYWH, conf : predictedConf, prob : predictedProb);
}
public Tensor __call__(Tensor inputs,
Tensor training = null,
VariableScope scope = null)
{
_set_scope(scope);
_graph = ops._get_graph_from_inputs(new List <Tensor> {
inputs
}, graph: _graph);
variable_scope scope_context_manager = null;
if (built)
{
}
else
{
scope_context_manager = tf.variable_scope(_scope,
auxiliary_name_scope: false);
}
Python.with(scope_context_manager, scope2 => _current_scope = scope2);
// Actually call layer
var outputs = base.__call__(inputs, training: training);
// Update global default collections.
_add_elements_to_collection(_updates.ToArray(), new string[] { ops.GraphKeys.UPDATE_OPS });
return(outputs);
}
public Tensor __call__(Tensor inputs,
VariableScope scope = null)
{
_set_scope(scope);
_graph = ops._get_graph_from_inputs(new List <Tensor> {
inputs
}, graph: _graph);
variable_scope scope_context_manager = null;
if (built)
{
}
else
{
scope_context_manager = tf.variable_scope(_scope,
auxiliary_name_scope: false);
}
Python.with(scope_context_manager, scope2 => _current_scope = scope2);
// Actually call layer
var outputs = base.__call__(inputs);
throw new NotImplementedException("");
}
public static Tensor ClipButPassGradient(Tensor input, float min, float max)
{
using var _ = new variable_scope("clip_val_pass_grad").StartUsing();
Tensor clippedMax = tf.cast(input > max, tf.float32);
Tensor clippedMin = tf.cast(input < min, tf.float32);
return(input + tf.stop_gradient(((max - input) * clippedMax)
+ ((min - input) * clippedMin)));
}
public void ReenterVariableScope()
{
variable_scope vs = null;
with(tf.variable_scope("foo"), v => vs = v);
// Re-enter the variable scope.
with(tf.variable_scope(vs, auxiliary_name_scope: false), v =>
{
var vs1 = (VariableScope)v;
// Restore the original name_scope.
with(tf.name_scope(vs1.original_name_scope), delegate
{
var v1 = tf.get_variable("v", new TensorShape(1));
Assert.AreEqual(v1.name, "foo/v:0");
var c1 = tf.constant(new int[] { 1 }, name: "c");
Assert.AreEqual(c1.name, "foo/c:0");
});
});
}
public Tensors __call__(Tensors inputs,
Tensor state = null,
Tensor training = null,
VariableScope scope = null)
{
_set_scope(scope);
_graph = ops._get_graph_from_inputs(inputs, graph: _graph);
variable_scope scope_context_manager = null;
if (built)
{
scope_context_manager = tf.variable_scope(_scope,
reuse: true,
auxiliary_name_scope: false);
}
else
{
scope_context_manager = tf.variable_scope(_scope,
reuse: _reuse,
auxiliary_name_scope: false);
}
Tensors outputs = null;
tf_with(scope_context_manager, scope2 =>
{
_current_scope = scope2;
// Actually call layer
outputs = base.Apply(inputs,
state: state,
is_training: training == null ? false : false);
});
// Update global default collections.
_add_elements_to_collection(updates.ToArray(), new string[] { tf.GraphKeys.UPDATE_OPS });
return(outputs);
}
public static Tensor GaussianLikelihood(Tensor input, Tensor mu, Tensor logStd, string?name = null)
{
if (input is null)
{
throw new ArgumentNullException(nameof(input));
}
if (mu is null)
{
throw new ArgumentNullException(nameof(mu));
}
if (logStd is null)
{
throw new ArgumentNullException(nameof(logStd));
}
using var _ = new variable_scope("gaussian_likelihood").StartUsing();
var preSum = (tf.square((input - mu) / (tf.exp(logStd) + Epsilon))
+ logStd * 2
+ MathF.Log(2 * MathF.PI))
* -0.5;
return(tf.reduce_sum(preSum, axis: 1, name: name));
}
