public override NdArray[] Forward(bool verbose = true, [NotNull] params NdArray[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
return(SingleInputForward(xs[0]));
}
public void BackwardDI(params NdArray <T>[] ys)
{
NdArray <T>[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 2)
{
throw new Exception("引数が正しくありません");
}
#endif
InitGrad();
BackwardCountUp();
xs[0].UseCount--;
if (xs[0].Grad == null)
{
xs[0].InitGrad();
}
UsedPrevInputs.Add(xs);
DualOutputBackward(ys[0], xs[0], xs[1].Data[0]);
if (PrevInputs.Count == 0)
{
PrevInputs.AddRange(UsedPrevInputs);
UsedPrevInputs.Clear();
}
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
InitGrad();
BackwardCountUp();
foreach (NdArray x in xs)
{
x.UseCount--;
if (x.Grad == null)
{
x.InitGrad();
}
}
UsedPrevInputs.Add(xs);
MultiOutputBackward(ys[0], xs);
//使い切ったら復活
if (PrevInputs.Count == 0)
{
PrevInputs.AddRange(UsedPrevInputs);
UsedPrevInputs.Clear();
}
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 1)
{
throw new Exception("引数が正しくありません");
}
#endif
InitGrad();
BackwardCountUp();
xs[0].UseCount--;
if (xs[0].Grad == null)
{
xs[0].InitGrad();
}
UsedPrevInputs.Add(xs);
SingleOutputBackward(ys[0], xs[0]);
//使い切ったら復活
if (PrevInputs.Count == 0)
{
PrevInputs.AddRange(UsedPrevInputs);
UsedPrevInputs.Clear();
}
}
public override NdArray[] Forward(params NdArray[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
return(new[] { SingleInputForward(xs[0]) });
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 2)
{
throw new Exception("引数が正しくありません");
}
#endif
InitGrad();
BackwardCountUp();
xs[0].UseCount--;
xs[1].UseCount--;
if (xs[0].Grad == null)
{
xs[0].ClearGrad();
}
if (xs[1].Grad == null)
{
xs[1].ClearGrad();
}
DualOutputBackward(ys[0], xs[0], xs[1]);
}
public NdArray <T>[] ForwardDI(params NdArray <T>[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
return(new[] { DualInputForward(xs[0], xs[1].Data[0]) });
}
public NdArray <T>[] ForwardBase(params NdArray <T>[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
return(new[] { SingleInputForward(xs[0]) });
}
public override NdArray[] Forward(bool verbose = true, [NotNull] params NdArray[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
xs[1].UseCount++;
return(new[] { DualInputForward(xs[0], xs[1]) });
}
public override NdArray[] Forward(params NdArray[] xs)
{
PrevInputs.Add(xs);
foreach (NdArray x in xs)
{
x.UseCount++;
}
return(new[] { MultiInputForward(xs) });
}
public override NdArray[] Forward(bool verbose = true, [NotNull] params NdArray[] xs)
{
PrevInputs.Add(xs);
foreach (NdArray x in xs)
{
x.UseCount++;
}
return(new[] { MultiInputForward(xs) });
}
public NdArray <T>[] ForwardMI(params NdArray <T>[] xs)
{
PrevInputs.Add(xs);
foreach (NdArray <T> x in xs)
{
x.UseCount++;
}
return(MultiInputForward(xs));
}
public NdArray <T>[] ForwardMO(params NdArray <T>[] xs)
{
PrevInputs.Add(xs);
xs[0].UseCount++;
xs[0].UseCount++;
NdArray <T>[] result = SingleInputForward(xs[0]);
PrevOutputs.Add(result);
return(result);
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
BackwardCountUp();
foreach (NdArray x in xs)
{
x.UseCount--;
}
MultiOutputBackward(ys[0], xs);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Backwards the given ys. </summary>
///
/// <exception cref="Exception"> Thrown when an exception error condition occurs. </exception>
///
/// <param name="ys"> A variable-length parameters list containing ys. </param>
///
/// <seealso cref="M:KelpNet.Common.Functions.Function.Backward(params NdArray[])"/>
////////////////////////////////////////////////////////////////////////////////////////////////////
public override void Backward(bool verbose = true, params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 1)
{
throw new Exception(string.Intern("Invalid argument"));
}
#endif
BackwardCountUp();
xs[0].UseCount--;
SingleOutputBackward(ys, xs[0]);
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 1)
{
throw new Exception("引数が正しくありません");
}
#endif
BackwardCountUp();
xs[0].UseCount--;
SingleOutputBackward(ys[0], xs[0]);
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
#if DEBUG
if (xs == null || xs.Length != 2)
{
throw new Exception("Invalid argument");
}
#endif
BackwardCountUp();
xs[0].UseCount--;
xs[1].UseCount--;
DualOutputBackward(ys[0], xs[0], xs[1]);
}
public void BackwardMO(params NdArray <T>[] ys)
{
NdArray <T>[] xs = PrevInputs[PrevInputs.Count - 1];
#if DEBUG
if (xs == null || xs.Length != 1)
{
throw new Exception("引数が正しくありません");
}
#endif
xs[0].UseCount--;
//出力した両方で使用が終わったら
if (xs[0].UseCount <= 0)
{
if (xs[0].Grad == null)
{
xs[0].InitGrad();
}
InitGrad();
BackwardCountUp();
PrevInputs.RemoveAt(PrevInputs.Count - 1);
NdArray <T>[] prevys = PrevOutputs[PrevOutputs.Count - 1];
PrevOutputs.RemoveAt(PrevOutputs.Count - 1);
UsedPrevInputs.Add(xs);
UsedPrevOutputs.Add(prevys);
MultiOutputBackward(prevys, xs[0]);
if (PrevInputs.Count == 0)
{
PrevInputs.AddRange(UsedPrevInputs);
UsedPrevInputs.Clear();
}
if (PrevOutputs.Count == 0)
{
PrevOutputs.AddRange(UsedPrevOutputs);
UsedPrevOutputs.Clear();
}
}
}
public override void Backward(params NdArray[] ys)
{
NdArray[] xs = PrevInputs[PrevInputs.Count - 1];
PrevInputs.RemoveAt(PrevInputs.Count - 1);
InitGrad();
BackwardCountUp();
foreach (NdArray x in xs)
{
x.UseCount--;
if (x.Grad == null)
{
x.ClearGrad();
}
}
MultiOutputBackward(ys[0], xs);
}
