public void TestRandomProjection()
{
var a = _lap.CreateMatrix(256, 256, (x, y) => x * y).AsIndexable();
var projector = _lap.CreateRandomProjection(256, 32);
var projections = projector.Compute(a);
Assert.IsTrue(projections.ColumnCount == 32);
Assert.IsTrue(projections.RowCount == 256);
}
public void TensorConvertToVector()
{
Load();
using var cpuTensor = _cpu.Create3DTensor(Enumerable.Range(0, 3).
Select(i => _cpu.CreateMatrix(4, 4, (j, k) => (i + 1) * (j + 1) * (k + 1))).ToList());
using var gpuTensor = _cuda.Create3DTensor(cpuTensor.Data);
using var cpuVector = cpuTensor.ReshapeAsVector();
using var gpuVector = gpuTensor.ReshapeAsVector();
FloatingPointHelper.AssertEqual(cpuVector.AsIndexable(), gpuVector.AsIndexable());
Cleanup();
}
/// <summary>
/// Create a matrix from a list of row vectors
/// </summary>
/// <param name="lap"></param>
/// <param name="rowList">List of indexable vectors (each vector becomes a row in the new matrix)</param>
/// <returns></returns>
public static IMatrix CreateMatrixFromRows(this ILinearAlgebraProvider lap, IReadOnlyList <IIndexableVector> rowList)
{
int rows = rowList.Count;
var columns = rowList[0].Count;
return(lap.CreateMatrix(rows, columns, (x, y) => rowList[x][y]));
}
/// <summary>
/// Create a matrix from a list of column vectors
/// </summary>
/// <param name="lap"></param>
/// <param name="columnList">List of indexable vectors (each vector becomes a column in the new matrix)</param>
/// <returns></returns>
public static IMatrix CreateMatrixFromColumns(this ILinearAlgebraProvider lap, IReadOnlyList <IIndexableVector> columnList)
{
int columns = columnList.Count;
var rows = columnList[0].Count;
return(lap.CreateMatrix(rows, columns, (x, y) => columnList[y][x]));
}
/// <summary>
/// Create a matrix
/// </summary>
/// <param name="lap"></param>
/// <param name="rowList">List of vectors (each vector becomes a row in the new matrix)</param>
/// <returns></returns>
public static IMatrix CreateMatrix(this ILinearAlgebraProvider lap, IReadOnlyList <FloatVector> rowList)
{
int rows = rowList.Count;
var size = rowList[0].Size;
return(lap.CreateMatrix(rows, size, (x, y) => rowList[x].Data[y]));
}
public float[] Predict(IReadOnlyList <IReadOnlyList <float> > input)
{
using (var v = _lap.CreateMatrix(input.Count, input[0].Count + 1, (i, j) => j == 0 ? 1 : input[i][j - 1]))
using (var r = v.Multiply(_theta))
using (var r2 = r.Row(0)) {
return(r.AsIndexable().Values.ToArray());
}
}
/// <summary>
/// Create a matrix
/// </summary>
/// <param name="lap"></param>
/// <param name="matrix">Matrix to copy</param>
/// <returns></returns>
public static IMatrix CreateMatrix(this ILinearAlgebraProvider lap, FloatMatrix matrix)
{
var ret = lap.CreateMatrix(matrix.RowCount, matrix.ColumnCount, false);
ret.Data = matrix;
return(ret);
//return lap.CreateMatrix(matrix.RowCount, matrix.ColumnCount, (i, j) => matrix.Row[i].Data[j]);
}
public float[] Predict(IReadOnlyList <IReadOnlyList <float> > input)
{
using var feature = _lap.CreateMatrix(input.Count, input[0].Count + 1,
(i, j) => j == 0 ? 1 : input[i][j - 1]);
using var h0 = feature.Multiply(_theta);
using var h1 = h0.Column(0);
using var h = h1.Sigmoid();
using var h2 = h.AsIndexable();
return(h2.ToArray());
}
public IMiniBatch Get(IExecutionContext executionContext, IReadOnlyList <int> rows)
{
var data = rows.Select(i => _data[i]).ToList();
var input = _lap.CreateMatrix(data.Count, InputSize, (x, y) => data[x].Data[y]);
var inputList = new List <IGraphData> {
new MatrixGraphData(input)
};
return(new MiniBatch(rows, this, inputList, null));
}
public RandomProjection(ILinearAlgebraProvider lap, int fixedSize, int reducedSize, int s = 3)
{
_lap = lap;
_fixedSize = fixedSize;
_reducedSize = reducedSize;
var c1 = Math.Sqrt(3);
var distribution = new Categorical(new[] { 1.0 / (2 * s), 1 - (1.0 / s), 1.0 / (2 * s) });
_matrix = _lap.CreateMatrix(fixedSize, reducedSize, (i, j) => Convert.ToSingle((distribution.Sample() - 1) * c1));
}
public LogisticRegressionTrainer(ILinearAlgebraProvider lap, IDataTable table)
{
_lap = lap;
var numRows = table.RowCount;
var classColumnIndex = table.TargetColumnIndex;
int numCols = table.ColumnCount;
var featureColumns = Enumerable.Range(0, numCols).Where(c => c != classColumnIndex).ToList();
var data = table.GetNumericColumns(featureColumns);
_feature = lap.CreateMatrix(numRows, numCols, (i, j) => j == 0 ? 1 : data[j - 1][i]);
_target = lap.CreateVector(table.GetColumn <float>(classColumnIndex));
}
public Convolutional(ILinearAlgebraProvider lap, ConvolutionalNetwork.Layer layer)
{
_lap = lap;
_padding = layer.Padding;
_filterWidth = layer.FilterWidth;
_filterHeight = layer.FilterHeight;
_stride = layer.Stride;
var activation = lap.NN.GetActivation(layer.Data.Activation);
_layer = new StandardFeedForward(lap.CreateMatrix(layer.Data.Weight), lap.CreateVector(layer.Data.Bias), activation);
}
public void TensorCreateFromMatrix()
{
const int DEPTH = 3, ROWS = 4, COLUMNS = 4;
var cpuTensor = _cpu.Create3DTensor(Enumerable.Range(0, DEPTH).Select(i => _cpu.CreateMatrix(ROWS, COLUMNS, (j, k) => (i + 1) * (j + 1) * (k + 1))).ToList());
var cpuMatrix = cpuTensor.ConvertToMatrix();
var cpuTensor2 = cpuMatrix.ConvertTo3DTensor(ROWS, COLUMNS);
FloatingPointHelper.AssertEqual(cpuTensor.AsIndexable(), cpuTensor2.AsIndexable());
using (var gpuMatrix = _cuda.CreateMatrix(cpuMatrix.AsIndexable()))
using (var gpuTensor2 = gpuMatrix.ConvertTo3DTensor(ROWS, COLUMNS)) {
FloatingPointHelper.AssertEqual(cpuTensor.AsIndexable(), gpuTensor2.AsIndexable());
}
}
public void MatrixVectorMultiply()
{
var a = _cpu.CreateMatrix(256, 256, (x, y) => x * y).AsIndexable();
var b = _cpu.CreateVector(256, i => i * 0.5f).AsIndexable();
var c = a.Multiply(b).AsIndexable();
IIndexableMatrix gpuResults;
using (var gpuA = _cuda.CreateMatrix(a))
using (var gpuB = _cuda.CreateVector(b))
using (var gpuC = gpuA.Multiply(gpuB)) {
gpuResults = gpuC.AsIndexable();
}
FloatingPointHelper.AssertEqual(c, gpuResults);
}
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 override void ExecuteForward(IContext context)
{
var rowList = context.BatchSequence.MiniBatch.Rows.Select(i => _data[i]).ToList();
var resultList = new List <Dictionary <int, float> >();
foreach (var row in rowList)
{
var value = _classifier.Classify(row)
.Select(c => (_targetLabel[c.Label], c.Weight))
.ToDictionary(d => d.Item1, d => d.Item2)
;
resultList.Add(value);
}
var output = _lap.CreateMatrix(resultList.Count, _targetLabel.Count, (i, j) => resultList[i].TryGetValue(j, out float temp) ? temp : 0f);
_AddNextGraphAction(context, new MatrixGraphData(output), null);
}
public IMiniBatch Get(IExecutionContext executionContext, IReadOnlyList <int> rows)
{
var data = rows.Select(i => _data[i]).ToList();
var input = _lap.CreateMatrix(InputSize, data.Count, (i, j) => {
var tensor = _data[j];
var rem = i % _matrixSize;
var z = i / _matrixSize;
var x = rem % _rows;
var y = rem / _rows;
return(tensor.Matrix[z].Row[x].Data[y]);
});
var inputList = new List <IGraphData> {
new Tensor4DGraphData(input, _rows, _columns, _depth)
};
return(new MiniBatch(rows, this, inputList, null));
}
public IMiniBatch Get(IExecutionContext executionContext, IReadOnlyList <int> rows)
{
var data = rows.Select(i => _data[i]).ToList();
var inputData = new Dictionary <int, List <FloatVector> >();
foreach (var item in data)
{
var input = item;
for (int i = 0, len = input.RowCount; i < len; i++)
{
if (!inputData.TryGetValue(i, out List <FloatVector> temp))
{
inputData.Add(i, temp = new List <FloatVector>());
}
temp.Add(input.Row[i]);
}
}
var miniBatch = new MiniBatch(rows, this);
foreach (var item in inputData.OrderBy(kv => kv.Key))
{
var input = _lap.CreateMatrix(item.Value);
var type = (item.Key == 0)
? MiniBatchSequenceType.SequenceStart
: item.Key == (inputData.Count - 1)
? MiniBatchSequenceType.SequenceEnd
: MiniBatchSequenceType.Standard
;
var inputList = new List <IGraphData> {
new MatrixGraphData(input)
};
miniBatch.Add(type, inputList, null);
}
return(miniBatch);
}
public IMatrix CreateWeight(int rows, int columns)
{
return(_lap.CreateMatrix(rows, columns, _weightValue));
}
public IReadOnlyList <IReadOnlyList <IVector> > Cluster(IReadOnlyList <IVector> data, int numIterations, float errorThreshold = 0.001f)
{
if (data.Count == 0)
{
return(new List <IVector[]>());
}
// create the main matrix
var data2 = new List <IIndexableVector>();
foreach (var item in data)
{
data2.Add(item.AsIndexable());
}
using (var v = _lap.CreateMatrix(data.Count, data.First().Count, (x, y) => data2[x][y])) {
data2.ForEach(d => d.Dispose());
// create the weights and features
var rand = new Random();
var weights = _lap.CreateMatrix(v.RowCount, _numClusters, (x, y) => Convert.ToSingle(rand.NextDouble()));
var features = _lap.CreateMatrix(_numClusters, v.ColumnCount, (x, y) => Convert.ToSingle(rand.NextDouble()));
// iterate
//float lastCost = 0;
for (int i = 0; i < numIterations; i++)
{
using (var wh = weights.Multiply(features)) {
var cost = _DifferenceCost(v, wh);
//if (i % (numIterations / 10) == 0)
// Console.WriteLine("NNMF cost: " + cost);
if (cost <= errorThreshold)
{
break;
}
//lastCost = cost;
using (var wT = weights.Transpose())
using (var hn = wT.Multiply(v))
using (var wTw = wT.Multiply(weights))
using (var hd = wTw.Multiply(features))
using (var fhn = features.PointwiseMultiply(hn)) {
features.Dispose();
features = fhn.PointwiseDivide(hd);
}
using (var fT = features.Transpose())
using (var wn = v.Multiply(fT))
using (var wf = weights.Multiply(features))
using (var wd = wf.Multiply(fT))
using (var wwn = weights.PointwiseMultiply(wn)) {
weights.Dispose();
weights = wwn.PointwiseDivide(wd);
}
}
}
// weights gives cluster membership
var documentClusters = weights.AsIndexable().Rows.Select((c, i) => Tuple.Create(i, c.MaximumIndex())).ToList();
weights.Dispose();
features.Dispose();
return(documentClusters.GroupBy(d => d.Item2).Select(g => g.Select(d => data[d.Item1]).ToArray()).ToList());
}
}
public IMatrix CreateWeight(int rows, int columns)
{
return(_lap.CreateMatrix(rows, columns, (x, y) => _GetWeight(rows, columns, x, y)));
}
/// <summary>
/// Create a diagonal matrix
/// </summary>
/// <param name="lap"></param>
/// <param name="values">List of diagonal values</param>
/// <returns></returns>
public static IMatrix CreateDiagonalMatrix(this ILinearAlgebraProvider lap, IReadOnlyList <float> values)
{
return(lap.CreateMatrix(values.Count, values.Count, (x, y) => x == y ? values[x] : 0f));
}
/// <summary>
/// Create a matrix
/// </summary>
/// <param name="lap"></param>
/// <param name="matrix">Indexable matrix to copy</param>
/// <returns></returns>
public static IMatrix CreateMatrix(this ILinearAlgebraProvider lap, IIndexableMatrix matrix)
{
return(lap.CreateMatrix(matrix.RowCount, matrix.ColumnCount, (i, j) => matrix[i, j]));
}
/// <summary>
/// Create an identity matrix
/// </summary>
/// <param name="lap"></param>
/// <param name="size">Width and height of the new matrix</param>
/// <returns></returns>
public static IMatrix CreateIdentityMatrix(this ILinearAlgebraProvider lap, int size)
{
return(lap.CreateMatrix(size, size, (x, y) => x == y ? 1f : 0f));
}
public IMatrix CreateMatrix(IReadOnlyList <FloatArray> data)
{
return(Create((IIndexableMatrix)_numerics.CreateMatrix(data)));
}
void _MatrixMultiplication(int rowsA, int columnsArowsB, int columnsB)
{
var rand = new Random(1);
var a = _cpu.CreateMatrix(rowsA, columnsArowsB, (j, k) => Convert.ToSingle(rand.NextDouble())).AsIndexable();
var b = _cpu.CreateMatrix(columnsArowsB, columnsB, (j, k) => Convert.ToSingle(rand.NextDouble())).AsIndexable();
var cpuResults = a.Multiply(b);
IIndexableMatrix gpuResults;
using (var gpuA = _cuda.CreateMatrix(a))
using (var gpuB = _cuda.CreateMatrix(b))
using (var gpuC = gpuA.Multiply(gpuB))
gpuResults = gpuC.AsIndexable();
FloatingPointHelper.AssertEqual(gpuResults, cpuResults.AsIndexable());
}
public void TensorConvertToVector()
{
using (var cpuTensor = _cpu.Create3DTensor(Enumerable.Range(0, 3).Select(i => _cpu.CreateMatrix(4, 4, (j, k) => (i + 1) * (j + 1) * (k + 1))).ToList()))
using (var gpuTensor = _cuda.Create3DTensor(cpuTensor.AsIndexable()))
using (var cpuVector = cpuTensor.ConvertToVector())
using (var gpuVector = gpuTensor.ConvertToVector())
FloatingPointHelper.AssertEqual(cpuVector.AsIndexable(), gpuVector.AsIndexable());
}
public void TestInputSquared()
{
var forwardInput = _cpu.CreateMatrix(SIZE, SIZE, _DefaultInit).AsIndexable();
var expectedOutput =
_cpu.CreateMatrix(SIZE, SIZE, (i, j) => (float)Math.Pow(forwardInput[i, j], 2));
var backwardInput = _cpu.CreateMatrix(SIZE, SIZE, _DefaultInit).AsIndexable();
var expectedBpOutput = _cpu.CreateMatrix(SIZE, SIZE,
(i, j) => backwardInput[i, j] * 2f * forwardInput[i, j]);
_TestNode(_factory.GraphOperation.InputSquared(), forwardInput, expectedOutput, backwardInput,
expectedBpOutput);
}
public IMatrix CreateWeight(int rows, int columns)
{
return(_lap.CreateMatrix(rows, columns, (x, y) => x == y ? _value : 0f));
}
/// <summary> /// Creates a matrix with every value initialised to zero /// </summary> /// <param name="lap"></param> /// <param name="rows">Number of rows</param> /// <param name="columns">Numer of columns</param> public static IMatrix CreateZeroMatrix(this ILinearAlgebraProvider lap, int rows, int columns) => lap.CreateMatrix(rows, columns, true);
