public I4DTensor ReverseMaxPool(I4DTensor indices, int outputRows, int outputColumns, int filterWidth, int filterHeight, int xStride, int yStride)
{
Debug.Assert(IsValid);
var indicesPtr = ((IHaveDeviceMemory)indices).Memory;
var ret = _cuda.TensorReverseMaxPool(_data, indicesPtr, _rows, _columns, _depth, _count, outputRows, outputColumns, filterWidth, filterHeight, xStride, yStride);
return(new Gpu4DTensor(_cuda, outputRows, outputColumns, _depth, _count, ret, true));
}
public I4DTensor ReverseMaxPool(I4DTensor indices, int outputRows, int outputColumns, int filterWidth, int filterHeight, int xStride, int yStride)
{
var ret = new List <IIndexable3DTensor>();
for (var i = 0; i < Count; i++)
{
var result = GetTensorAt(i).ReverseMaxPool(indices.GetTensorAt(i), outputRows, outputColumns, filterWidth, filterHeight, xStride, yStride);
ret.Add(result.AsIndexable());
}
return(new Cpu4DTensor(ret));
}
public I3DTensor TransposeThisAndMultiply(I4DTensor tensor)
{
var other = (Gpu4DTensor)tensor;
#if DEBUG
Debug.Assert(tensor.Count == Depth && IsValid && other.IsValid);
#endif
var ptr = Memory.DevicePointer;
var ptr2 = other.Memory.DevicePointer;
int rowsA = _rows, columnsA = _columns, columnsB = other.Depth,
rowsB = other.RowCount * other.ColumnCount, blockSize2 = columnsB * rowsB;
float alpha = 1.0f, beta = 0.0f;
var output = new Gpu3DTensor(_cuda, _columns, columnsB, _depth,
_cuda.Allocate(_columns * columnsB * _depth), true);
var status = CudaBlasNativeMethods.cublasSgemmStridedBatched(_cuda.Blas.CublasHandle,
Operation.Transpose, Operation.NonTranspose, columnsA, columnsB, rowsB, ref alpha, ptr,
rowsA, _blockSize, ptr2, rowsB, blockSize2, ref beta, output.Memory.DevicePointer, columnsA,
_columns * columnsB, _depth);
if (status != CublasStatus.Success)
{
throw new CudaBlasException(status);
}
return(output);
//var output = Enumerable.Range(0, _depth).Select(i => new GpuMatrix(_cuda, _columns, columnsB, _cuda.Allocate(_columns * columnsB), true)).ToList();
//using (var aPtrs = new PtrToDeviceMemoryList(Enumerable.Range(0, _depth).Select(i => ptr + i * _blockSize * CudaProvider.FLOAT_SIZE).ToArray()))
//using (var bPtrs = new PtrToDeviceMemoryList(Enumerable.Range(0, _depth).Select(i => ptr2 + i * blockSize2 * CudaProvider.FLOAT_SIZE).ToArray()))
//using (var cPtrs = new PtrToDeviceMemoryList(output.Select(m => m.Memory.DevicePointer).ToArray())) {
// var status = CudaBlasNativeMethods.cublasSgemmBatched(_cuda.Blas.CublasHandle,
// Operation.Transpose,
// Operation.NonTranspose,
// columnsA,
// columnsB,
// rowsB,
// ref alpha,
// aPtrs.DevicePointer,
// rowsA,
// bPtrs.DevicePointer,
// rowsB,
// ref beta,
// cPtrs.DevicePointer,
// columnsA,
// _depth
// );
// if (status != CublasStatus.Success)
// throw new CudaBlasException(status);
//}
//return _cuda.Create3DTensor(output);
}
public Backpropagation(MaxPool source, I4DTensor indices, int inputColumns, int inputRows, int outputColumns, int outputRows, int depth, int filterWidth, int filterHeight, int xStride, int yStride)
: base(source)
{
_indices = indices;
_inputColumns = inputColumns;
_inputRows = inputRows;
_outputColumns = outputColumns;
_outputRows = outputRows;
_depth = depth;
_filterWidth = filterWidth;
_filterHeight = filterHeight;
_xStride = xStride;
_yStride = yStride;
}
I4DTensor _FormIntoTensor(ILinearAlgebraProvider lap, IVector vector, I4DTensor tensor)
{
var indexableVector = vector.AsIndexable();
var tensorList = new List <I3DTensor>();
for (var i = 0; i < tensor.Count; i++)
{
var matrixList = new List <IMatrix>();
for (var j = 0; j < tensor.Depth; j++)
{
matrixList.Add(lap.CreateMatrix(tensor.RowCount, tensor.ColumnCount, indexableVector[j]));
}
tensorList.Add(lap.Create3DTensor(matrixList));
}
return(lap.Create4DTensor(tensorList));
}
public Tensor4DGraphData(I4DTensor tensor) : this(tensor.ReshapeAsMatrix(), tensor.RowCount,
tensor.ColumnCount, tensor.Depth)
{
}
public Tensor4DGraphData(I4DTensor tensor) :
this(tensor.ConvertToMatrix(), tensor.RowCount, tensor.ColumnCount, tensor.Depth)
{
}
public Backpropagation(TransposeAndCombineSignal source, I4DTensor tensor) : base(source)
{
_tensor = tensor;
}
/// <summary>
/// Converts the 4D tensor to a generic IGraphData
/// </summary>
/// <param name="tensor">Tensor to convert</param>
public static IGraphData AsGraphData(this I4DTensor tensor)
{
return(new Tensor4DGraphData(tensor));
}
