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); }