/// <inheritdoc />
public INDArray Pow(INDArray array, INumber value)
{
TNDArray internalArray = InternaliseArray(array);
TNumber internalValue = InternaliseNumber(value);
return(CreateArrayFromHandle(DNDArray.Pow(internalArray.Handle, internalValue.Handle)));
}
/// <inheritdoc />
public INDArray Pow <TOther>(INDArray array, TOther value)
{
TNDArray internalArray = InternaliseArray(array);
float internalValue = (float)System.Convert.ChangeType(value, typeof(float));
return(CreateArrayFromHandle(DNDArray.Pow(internalArray.Handle, internalValue)));
}
/// <inheritdoc />
public INDArray Divide(INDArray a, INDArray b)
{
TNDArray internalA = InternaliseArray(a);
TNDArray internalB = InternaliseArray(b);
return(CreateArrayFromHandle(DNDArray.op_DotDivide(internalA.Handle, internalB.Handle)));
}
/// <inheritdoc />
public override INumber AsNumber(INDArray array, params long[] indices)
{
ADFloat32NDArray internalArray = InternaliseArray(array);
long flatIndex = NDArrayUtils.GetFlatIndex(array.Shape, array.Strides, indices);
return(new ADFloat32Number(DNDArray.ToDNumber(internalArray.Handle, (int)flatIndex)));
}
protected override void Reinitialise(long[] shape, long[] strides)
{
_adArrayHandle = _adArrayHandle.ShallowCopy();
base.Reinitialise(shape, strides);
_adArrayHandle.Buffer.Shape = shape;
}
public override INDArray Reshape(params long[] newShape)
{
if (Length != ArrayUtils.Product(newShape))
{
throw new ArgumentException("Reshaping cannot change total ndarray length, only array shape.");
}
return(new CudaFloat32NDArray(DNDArray.Reshape(Handle, newShape)));
}
public ADNDFloat32Array(DNDArray adArrayHandle) : base((IDataBuffer <float>)adArrayHandle.Buffer.DataBuffer, adArrayHandle.Buffer.Shape)
{
if (adArrayHandle == null)
{
throw new ArgumentNullException(nameof(adArrayHandle));
}
_adArrayHandle = adArrayHandle;
_adArrayHandle.Buffer.Shape = Shape;
}
/// <inheritdoc />
public INDArray PermuteBatchAndTime(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
// swap batch and time dimensions
int[] permutedDimensions = ArrayUtils.Range(0, array.Rank - 1);
permutedDimensions[1] = 0;
permutedDimensions[0] = 1;
return(CreateArrayFromHandle(DNDArray.Permute(internalArray.Handle, permutedDimensions)));
}
/// <inheritdoc />
public INDArray Clip(INDArray array, INumber minValue, INumber maxValue)
{
TNDArray internalArray = InternaliseArray(array);
TNumber internalMinValue = InternaliseNumber(minValue);
TNumber internalMaxValue = InternaliseNumber(maxValue);
DNDArray lowerClipped = DNDArray.Max(internalMinValue.Handle, internalArray.Handle);
DNDArray clipped = DNDArray.Min(internalMaxValue.Handle, lowerClipped);
return(CreateArrayFromHandle(clipped));
}
public CudaFloat32NDArray(DNDArray adArrayHandle) : base(CheckCudaBuffer(adArrayHandle.Buffer.DataBuffer), adArrayHandle.Buffer.Shape)
{
if (adArrayHandle == null)
{
throw new ArgumentNullException(nameof(adArrayHandle));
}
Handle = adArrayHandle;
Handle.Buffer.Shape = Shape;
_underlyingCudaBuffer = (CudaSigmaDiffDataBuffer <float>)Data;
}
/// <inheritdoc />
protected override bool _RowWiseOptimised(ref CudaFloat32NDArray array, Func <INDArray, INDArray> function)
{
if (function == SoftMax)
{
CudaFloat32NDArray internalArray = InternaliseArray(array);
array = CreateArrayFromHandle(DNDArray.CustomOp(internalArray.Handle, new CudaFloat32BackendHandle.CustomOpHandle(CudaFloat32BackendHandle.CustomOpType.RowWiseSoftmax)));
return(true);
}
return(false);
}
public static void Main(string[] args)
{
DNumber a = new DNumber(1.0f).GetReverse(0);
DNumber b = a * 2;
DNDArray array = new DNDArray(new Util.NativeDataBuffer <double>(new double[] { 1, 2, 3, 4, 5, 6 }), new long[] { 2, 3 });
DNumber c = AD.Sum(array * b);
Float64.DOps.reverseProp(new DNumber(1.0f).asADD, c.asADD);
Console.WriteLine(b.A.Value);
Console.ReadKey();
}
/// <summary>
/// Use the <see cref="RowWise"/> operation directly and internally without any optimisation fallbacks.
/// </summary>
/// <param name="array">The array.</param>
/// <param name="internalArray">The array as an internal array handle.</param>
/// <param name="function">The function to apply row-wise.</param>
/// <returns></returns>
protected virtual INDArray _RowWiseDirect(INDArray array, TNDArray internalArray, Func <INDArray, INDArray> function)
{
INDArray[] rows = SliceRowWise(array, internalArray);
for (int i = 0; i < rows.Length; i++)
{
rows[i] = function.Invoke(rows[i]);
}
DNDArray[] internalRowHandles = new DNDArray[rows.Length];
for (int i = 0; i < rows.Length; i++)
{
internalRowHandles[i] = InternaliseArray(rows[i]).Handle;
}
return(CreateArrayFromHandle(new DNDArray(DNDArray.OfRows(internalRowHandles, DiffsharpBackendHandle))));
}
/// <inheritdoc />
public INumber Determinate(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateNumberFromHandle(DNDArray.Det(internalArray.Handle)));
}
/// <inheritdoc />
public INumber Min(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateNumberFromHandle(new DNumber(internalArray.Data.GetValue(DNDArray.MinIndex(internalArray.Handle)))));
}
/// <inheritdoc />
public INDArray StackRows(int numberRows, INDArray row)
{
TNDArray internalArray = InternaliseArray(row);
return(CreateArrayFromHandle(DNDArray.OfRows(numberRows, internalArray.Handle, _diffsharpBackendHandle)));
}
/// <inheritdoc />
public int MinIndex(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(DNDArray.MinIndex(internalArray.Handle));
}
/// <inheritdoc />
public INDArray SquareRoot(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateArrayFromHandle(DNDArray.Sqrt(internalArray.Handle)));
}
/// <inheritdoc />
public INumber Variance(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateNumberFromHandle(DNDArray.Variance(internalArray.Handle)));
}
/// <inheritdoc />
public INumber StandardDeviation(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateNumberFromHandle(DNDArray.StandardDev(internalArray.Handle)));
}
/// <inheritdoc />
protected override ADFloat32NDArray CreateArrayFromHandle(DNDArray handle)
{
return(new ADFloat32NDArray(handle));
}
/// <inheritdoc />
public override INDArray AsNDArray(INumber number)
{
ADFloat32Number internalNumber = InternaliseNumber(number);
return(AssignTag(new ADFloat32NDArray(DNDArray.OfDNumber(internalNumber.Handle, DiffsharpBackendHandle))));
}
/// <inheritdoc />
public INDArray SoftMax(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateArrayFromHandle(DNDArray.SoftMax(internalArray.Handle)));
}
/// <inheritdoc />
public INDArray Tanh(INDArray array)
{
TNDArray internalArray = InternaliseArray(array);
return(CreateArrayFromHandle(DNDArray.Tanh(internalArray.Handle)));
}
/// <summary> /// Create an ndarray from a SigmaDiff float32 ndarray handle. /// </summary> /// <param name="handle">The handle.</param> /// <returns>The ndarray.</returns> protected abstract TNDArray CreateArrayFromHandle(DNDArray handle);
