public void Add(TKey key, TValue value)
{
if (!keyToValue.ContainsKey(key))
{
keyToValue.Add(key, value);
}
if (!valueToKey.ContainsKey(value))
{
valueToKey.Add(value, key);
}
}
public Tensor[] ComputeGradient(long[] target_tensor_ids,
long[] source_tensor_ids,
UnorderedMap <long, TapeTensor> sources_that_are_targets,
Tensor[] output_gradients)
{
var result = new List <Tensor>(source_tensor_ids.Length);
var sources_set = new UnorderedSet <long>(source_tensor_ids);
var gradients_size = new UnorderedMap <long, long>();
var state = PrepareBackprop(
target_tensor_ids, tensor_tape_, op_tape_, sources_set, persistent_);
var op_stack = InitialStack(state.op_tape, state.op_missing_tensor);
var gradients = InitialGradients(target_tensor_ids, sources_that_are_targets,
output_gradients,
tensor_tape_,
state.op_tape);
while (op_stack.Count > 0)
{
var op = op_stack.Dequeue();
if (!state.op_tape.find(op, out var trace))
{
continue;
}
state.op_tape.erase(op);
var out_gradients = new List <Tensor>(trace.output_tensor_info.Length);
var unneeded_gradients = new List <long>();
for (int i = 0; i < trace.input_tensor_id.Length; i++)
{
var in_tensor_id = trace.input_tensor_id[i];
if (!tensor_tape_.find(in_tensor_id) &&
!sources_set.find(in_tensor_id))
{
unneeded_gradients.Add(i);
}
}
bool any_gradient_nonzero = false;
var zero_indices = new List <int>();
for (int i = 0; i < trace.output_tensor_info.Length; ++i)
{
var id = trace.output_tensor_info[i].GetID();
if (!gradients.find(id, out var grad_it))
{
throw new NotImplementedException("FunctionsAcceptingNoneForIndicesMap");
}
else
{
any_gradient_nonzero = true;
var new_gradients = grad_it.Count == 1 ?
grad_it[0] :
gen_math_ops.add_n(grad_it.ToArray()); // vspace.AggregateGradients
if (!sources_set.find(id))
{
gradients.Remove(id);
}
else
{
grad_it.Clear();
grad_it.Add(new_gradients);
// vspace.MarkAsResult(new_gradients);
}
out_gradients.Add(new_gradients);
}
}
Tensor[] in_gradients;
if (any_gradient_nonzero)
{
foreach (var i in zero_indices)
{
out_gradients[i] = trace.output_tensor_info[i].ZerosLike();
}
in_gradients = CallBackwardFunction(trace.backward_function,
unneeded_gradients,
out_gradients);
if (in_gradients.Count() != trace.input_tensor_id.Count())
{
throw new RuntimeError($"Recorded operation '{trace.op_type}' returned too few gradients. Expected {trace.input_tensor_id.Length} but received {in_gradients.Count()}");
}
if (!persistent_)
{
// trace.backward_function_deleter(trace.backward_function);
}
}
else
{
throw new NotImplementedException("");
}
for (int i = 0; i < in_gradients.Length; ++i)
{
var id = trace.input_tensor_id[i];
if (in_gradients[i] != null)
{
var unaggregated_grads = gradients[id];
unaggregated_grads.Add(in_gradients[i]);
if (unaggregated_grads.Count > kMinAggregateCount)
{
if (!gradients_size.ContainsKey(id))
{
}
else
{
}
throw new NotImplementedException("");
}
}
if (!state.tensor_usage_counts.find(id))
{
continue;
}
state.tensor_usage_counts[id]--;
if (state.tensor_usage_counts[id] > 0)
{
continue;
}
if (!tensor_tape_.find(id, out var tape_it))
{
if (gradients.find(id, out var grad_it))
{
// foreach (var g in grad_it)
// DeleteGradient(g);
gradients.erase(id);
}
continue;
}
var op_id = tape_it;
if (op_id == -1)
{
continue;
}
if (state.op_missing_tensor.find(op_id, out var missing_it))
{
state.op_missing_tensor[op_id]--;
if (state.op_missing_tensor[op_id] == 0)
{
op_stack.Enqueue(op_id);
}
}
}
}
if (state.op_tape.Count > 0)
{
throw new RuntimeError("Invalid tape state.");
}
var used_gradient_ids = new List <long>(source_tensor_ids.Length);
foreach (var id in source_tensor_ids)
{
if (!gradients.find(id, out var grad_it))
{
result.Add(null);
}
else
{
if (grad_it.Count > 1)
{
var grad = gen_math_ops.add_n(grad_it.ToArray());
grad_it.Clear();
grad_it.Add(grad);
}
result.Add(grad_it[0]);
used_gradient_ids.Add(id);
}
}
/*foreach(var grad_pair in gradients)
* {
* if(!used_gradient_ids.Contains(grad_pair.Key))
* {
* foreach(var g in grad_pair.Value)
* {
* vspace.DeleteGradient(g);
* }
* }
* }*/
return(result.ToArray());
}
