private INDArray CheckNice(INDArray array, string paramName = "unspecified")
{
if (!Enabled)
{
return(array);
}
if (array == null)
{
Report($"ndarray \"{paramName}\" is null.");
}
else
{
if (array.Rank != array.Shape.Length)
{
Report($"ndarray \"{paramName}\" has inconsistent rank ({array.Rank}) / shape (length {array.Length}).", array);
}
if (CheckNaN && UnderlyingHandler.IsNaN(array))
{
Report($"ndarray \"{paramName}\" contains NaN values.", array);
}
if (CheckInfinite && UnderlyingHandler.IsNotFinite(array))
{
Report($"ndarray \"{paramName}\" contains infinite values.", array);
}
}
return(array);
}
private INumber CheckNice(INumber number, string paramName = "unspecified")
{
if (!Enabled)
{
return(number);
}
if (number == null)
{
Report($"number {paramName} is null.");
}
else
{
if (CheckNaN && UnderlyingHandler.IsNaN(number))
{
Report($"number {paramName} is a NaN value.", number);
}
if (CheckInfinite && UnderlyingHandler.IsNotFinite(number))
{
Report($"number {paramName} is an infinite value.", number);
}
}
return(number);
}
public INDArray NDArray(params long[] shape)
{
INDArray array = UnderlyingHandler.NDArray(shape);
CheckNice(array);
return(array);
}
public INDArray NDArray <TOther>(TOther[] values, params long[] shape)
{
INDArray array = UnderlyingHandler.NDArray(values, shape);
CheckNice(array);
return(array);
}
public INDArray MergeBatch(params INDArray[] arrays)
{
for (int i = 0; i < arrays.Length; i++)
{
CheckNice(arrays[i], $"arrays[{i}]");
}
return(CheckNice(UnderlyingHandler.MergeBatch(arrays)));
}
/// <inheritdoc />
public INDArray RowWise(INDArray array, Func <INDArray, INDArray> function)
{
if (function == null)
{
Report("function was null");
}
return(CheckNice(UnderlyingHandler.RowWise(CheckNice(array), function)));
}
/// <inheritdoc />
public TOther[] RowWiseTransform <TOther>(INDArray array, Func <INDArray, TOther> transformFunction)
{
if (transformFunction == null)
{
Report("transform function was null");
}
return(UnderlyingHandler.RowWiseTransform(CheckNice(array), transformFunction));
}
/// <inheritdoc />
public INDArray FlattenTimeAndFeatures(INDArray array)
{
if (Enabled && array.Rank < 3)
{
Report($"ndarray needs to have a rank of 3 or higher (was {array.Rank}) for {nameof(FlattenTimeAndFeatures)} operation", array);
}
return(CheckNice(UnderlyingHandler.FlattenTimeAndFeatures(CheckNice(array))));
}
public INDArray FlattenTime(INDArray array)
{
if (Enabled && array.Rank < 2) // two or three? technically 2 is enough ([BT]F) but 3 makes more sense
{
Report($"ndarray needs to have a rank of 2 or higher (was {array.Rank}) for {nameof(FlattenTime)} operation", array);
}
return(CheckNice(UnderlyingHandler.FlattenTime(CheckNice(array))));
}
/// <inheritdoc />
public void FillWithProbabilityMask(INDArray array, double probability)
{
if (Enabled && (probability < 0.0 || probability > 1.0))
{
Report($"probability for fill with probability mask should be 0.0 <= p <= 1.0 (was {probability}).");
}
UnderlyingHandler.FillWithProbabilityMask(CheckNice(array), probability);
CheckNice(array);
}
public INDArray Dot(INDArray a, INDArray b)
{
CheckMatrix(a, "dot product");
CheckMatrix(b, "dot product");
if (Enabled && a.Shape[1] != b.Shape[0])
{
Report($"ndarray a.Shape[1] (={a.Shape[1]}) should be b.Shape[0] (={b.Shape[0]}) for operation matrix dot product", a, b);
}
return(CheckNice(UnderlyingHandler.Dot(CheckNice(a), CheckNice(b))));
}
public INDArray StackRows(int numberRows, INDArray row)
{
if (numberRows < 1)
{
Report($"number of rows must be >= 1 but was {numberRows}", numberRows);
}
if (!row.IsVector)
{
Report($"row must be vector", row);
}
return(CheckNice(UnderlyingHandler.StackRows(numberRows, CheckNice(row))));
}
public INDArray GetSlice(INDArray array, int rowIndex, int columnIndex, int rowLength, int columnLength)
{
if (Enabled)
{
if (rowIndex < 0 || columnIndex < 0)
{
Report($"row index and column index must be > 0, but were {rowIndex} and {columnIndex}", array, rowIndex, columnIndex);
}
if (rowLength <= 0 || columnLength <= 0)
{
Report($"row and column length must be > 0, but were {rowLength} and {columnLength}", array, rowLength, columnLength);
}
if (rowIndex + rowLength > array.Shape[0] || columnIndex + columnLength > array.Shape[1])
{
Report($"row index and column index must be < ndarray.shape[i], but were {rowIndex + rowLength} and {columnIndex + columnLength} (bounds were {array.Shape[0]} and {array.Shape[1]})", array, rowIndex, columnIndex, rowLength, columnLength);
}
}
CheckMatrix(array, "get slice from matrix");
return(CheckNice(UnderlyingHandler.GetSlice(CheckNice(array), rowIndex, columnIndex, rowLength, columnLength)));
}
/// <inheritdoc />
public void FreeLimbo(INDArray array)
{
UnderlyingHandler.FreeLimbo(array);
}
/// <inheritdoc />
public void MarkLimbo(INDArray array)
{
UnderlyingHandler.MarkLimbo(array);
}
/// <inheritdoc />
public void ClearSession()
{
UnderlyingHandler.ClearSession();
}
/// <inheritdoc />
public void EndSession()
{
UnderlyingHandler.EndSession();
}
/// <inheritdoc />
public void BeginSession()
{
UnderlyingHandler.BeginSession();
}
/// <inheritdoc />
public INDArray SoftMax(INDArray array)
{
return(CheckNice(UnderlyingHandler.SoftMax(CheckNice(array))));
}
/// <inheritdoc />
public bool IsNotFinite(INumber number)
{
return(UnderlyingHandler.IsNotFinite(number));
}
/// <inheritdoc />
public TTraceable ClearTrace <TTraceable>(TTraceable traceable) where TTraceable : ITraceable
{
return(UnderlyingHandler.ClearTrace(traceable));
}
/// <inheritdoc />
public TTraceable Trace <TTraceable>(TTraceable traceable, uint traceTag) where TTraceable : ITraceable
{
return(UnderlyingHandler.Trace(traceable, traceTag));
}
/// <inheritdoc />
public INDArray Clip(INDArray array, INumber minValue, INumber maxValue)
{
return(CheckNice(UnderlyingHandler.Clip(CheckNice(array), CheckNice(minValue), CheckNice(maxValue))));
}
/// <inheritdoc />
public INumber Variance(INDArray array)
{
return(CheckNice(UnderlyingHandler.Variance(CheckNice(array))));
}
/// <inheritdoc />
public INumber StandardDeviation(INDArray array)
{
return(CheckNice(UnderlyingHandler.StandardDeviation(CheckNice(array))));
}
/// <inheritdoc />
public bool IsNaN(INDArray array)
{
return(UnderlyingHandler.IsNaN(array));
}
/// <inheritdoc />
public bool IsNaN(INumber number)
{
return(UnderlyingHandler.IsNaN(number));
}
/// <inheritdoc />
public void ComputeDerivativesTo(ITraceable traceable)
{
UnderlyingHandler.ComputeDerivativesTo(traceable);
}
/// <inheritdoc />
public uint BeginTrace()
{
return(UnderlyingHandler.BeginTrace());
}
/// <inheritdoc />
public TTraceable GetDerivative <TTraceable>(TTraceable traceable) where TTraceable : ITraceable
{
return(UnderlyingHandler.GetDerivative(traceable));
}
