internal Gpu4DTensor(CudaProvider provider, IReadOnlyList <I3DTensor> tensorList)
{
var first = tensorList.First();
_cuda = provider;
_rows = first.RowCount;
_columns = first.ColumnCount;
_depth = first.Depth;
_count = tensorList.Count;
provider.Register(this);
_data = _cuda.CreateZeroMatrix(_rows * _columns * _depth, _count);
_subVector = new Lazy <List <GpuVector[]> >(_GetSubVectors);
_tensorInfo = new Lazy <TensorInput>(_GetInput);
for (var i = 0; i < _count; i++)
{
_data.Column(i).AddInPlace(tensorList[i].ConvertToVector());
}
#if DEBUG
if (_id == _badAlloc)
{
Debugger.Break();
}
#endif
}
public IMatrix Convert(IMatrix matrix)
{
if (matrix == null)
{
return(null);
}
var ret = new List <IVector>();
IVector curr = null;
var size = _layer._descriptor.FilterSize;
for (int i = 0, len = matrix.ColumnCount; i < len; i++)
{
var column = matrix.Column(i);
if (i % size == 0)
{
curr = column;
ret.Add(curr);
}
else
{
curr.AddInPlace(column);
}
}
using (var ret2 = _layer._lap.Create(ret))
return(ret2.Transpose());
}
public I3DTensor ConvertToTensor(IMatrix matrix)
{
var sliceList = new List <IMatrix>();
for (int i = 0, len = matrix.ColumnCount; i < len; i++)
{
using (var vector = matrix.Column(i)) {
var parts = vector.Split(_inputWidth);
//var sliceMatrix = _lap.Create(parts).Transpose();
var sliceMatrix = _lap.Create(parts);
sliceList.Add(sliceMatrix);
foreach (var part in parts)
{
part.Dispose();
}
}
}
var ret = _lap.CreateTensor(sliceList);
foreach (var slice in sliceList)
{
slice.Dispose();
}
return(ret);
}
public IReadOnlyList <IMatrix> GetSubMatrices()
{
var ret = new IMatrix[Depth];
for (var i = 0; i < Depth; i++)
{
ret[i] = _matrix.Column(i).ReshapeAsMatrix(Rows, Columns);
}
return(ret);
}
List <GpuVector[]> _GetSubVectors()
{
var ret = new List <GpuVector[]>();
for (var i = 0; i < _data.ColumnCount; i++)
{
ret.Add(_data.Column(i).Split(_depth).Cast <GpuVector>().ToArray());
}
return(ret);
}
public static IEnumerable <IEnumerable <Element <T> > > Columns <T>(this IMatrix <T> matrix)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
for (var columnIndex = 0; columnIndex < matrix.ColumnCount; columnIndex++)
{
yield return(matrix.Column(columnIndex));
}
}
public I3DTensor GetAt(int index)
{
var matrixList = _data.Column(index)
.Split(_depth)
.Select(v => v.ConvertInPlaceToMatrix(_rows, _columns))
.Cast <GpuMatrix>()
.ToList()
;
return(new Gpu3DTensor(_cuda, _rows, _columns, _depth, matrixList));
}
public IReadOnlyList <IMatrix> GetSubMatrices()
{
var ret = new List <IMatrix>();
for (var j = 0; j < Count; j++)
{
var matrix = _matrix.Column(j);
using var tensor = matrix.ReshapeAs3DTensor(Rows, Columns, Depth);
for (var i = 0; i < Depth; i++)
{
ret.Add(tensor.GetMatrixAt(i));
}
}
return(ret);
}
public TensorOutput(CudaProvider cuda, int rows, int columns, int depth, int count, bool setToZero)
{
_cuda = cuda;
_rows = rows;
_columns = columns;
_depth = depth;
_count = count;
// allocate space for the output
_data = setToZero
? cuda.CreateZeroMatrix(rows * columns * depth, count)
: cuda.CreateMatrix(rows * columns * depth, count)
;
// get the pointers
for (var i = 0; i < count; i++)
{
var tensor = _data.Column(i).Split(depth).Cast <GpuVector>().Select(v => v.Memory).ToArray();
_ptr.Add(tensor);
}
}
private void UpdateClassificationResults()
{
float[,] meanSubVals = new float[numGroups, subVals.ColumnCount];
for (int group = 0; group < numGroups; group++)
{
for (int sub = 0; sub < subVals.ColumnCount; sub++)
{
int[] correctRows = Global.IntArray(group * numPerGroup, (group + 1) * numPerGroup);
IMatrix <double> membersOfGroup = subVals.Rows(correctRows);
double[] substrateFromGroup = membersOfGroup.Column(sub);
float meanVal = (float)Global.Sum(substrateFromGroup) / substrateFromGroup.Length;
meanSubVals[group, sub] = meanVal;
}
}
Global.LastClassificationResults.meanSubValues.Add(meanSubVals);
}
