public static MatrixD randomLines(this MatrixD m, int countLines)
{
var l = MatrixD.Build.repeat(countLines, m.ColumnCount, 0);
var rLines = GlobalRandom.NextIntArr(countLines, 0, m.RowCount - 1);
for (int i = 0; i < l.RowCount; i++)
{
for (int j = 0; j < l.ColumnCount; j++)
{
l[i, j] = m[rLines[i], j];
}
}
return(l);
}
public void NextIntArr()
{
int minVal = -2, maxVal = 2, count = 100;
var nums = new List <int>(GlobalRandom.NextIntArr(count, minVal, maxVal));
Assert.IsTrue(nums.Count == count);
foreach (var num in nums)
{
Assert.IsTrue(num >= -2 && num <= 2);
}
Assert.IsTrue(nums.Contains(-2));
Assert.IsTrue(nums.Contains(-1));
Assert.IsTrue(nums.Contains(0));
Assert.IsTrue(nums.Contains(1));
Assert.IsTrue(nums.Contains(2));
}
public void next(double learnRate, int countEntries)
{
preCost = postCost = null;
var randomEntriesIdx = GlobalRandom.NextIntArr(countEntries, 0, annInputs.RowCount - 1);
this.currentInput = annInputs.lines(randomEntriesIdx);
this.currentExpectedOutput = annExpectedOutputs.lines(randomEntriesIdx);
var costLayer = new CostLayer(currentExpectedOutput);
forward(currentInput, costLayer);
backwardTrain(costLayer, learnRate / countEntries);
/* * /
* var mO = annOutput.ToRowArrays();
* var mEO = currentExpectedOutput.ToRowArrays();
*
* var mOidx = annOutput.maxIdxEachRow();
* var mEOidx = currentExpectedOutput.maxIdxEachRow();
* //*/
}
public void setup()
{
this.depth = GlobalRandom.NextInt(2, 5);
this.countEntries = GlobalRandom.NextInt(2, 5);
this.inDims = GlobalRandom.NextIntArr(countEntries, 2, 5);
this.entrySize = inDims.product();
this.kernels = ArrayBuilder.repeat(
new Kernel(inDims.map(x => GlobalRandom.NextInt(2, x))), depth);
this.layer = new ConvolutionLayer(this.kernels, this.inDims);
MultiMatrix[] entries = ArrayBuilder.repeat(() => MultiMatrix.Build.random(inDims), countEntries);
MultiMatrix[][] expectedOutputs = new MultiMatrix[countEntries][];
MultiMatrix[][] nextGradients = new MultiMatrix[countEntries][];
MultiMatrix[] expectedInGradients = new MultiMatrix[countEntries];
Kernel[] kerns = kernels.map(k => new Kernel(k));
for (int i = 0; i < countEntries; i++)
{
expectedInGradients[i] = MultiMatrix.Build.repeat(inDims, 0);
expectedOutputs[i] = new MultiMatrix[depth];
}
for (int i = 0; i < countEntries; i++)
{
nextGradients[i] = new MultiMatrix[depth];
for (var j = 0; j < kerns.Length; j++)
{
expectedOutputs[i][j] = kernels[j].slideOver(entries[i]);
nextGradients[i][j] = MultiMatrix.Build.random(kernels[0].getOutputDims(inDims));
expectedInGradients[i] += kernels[j].getGradientInput(entries[i], nextGradients[i][j]);
kerns[j].backwardLearn(entries[i], nextGradients[i][j], learnRate);
}
}
this.entries = entries.toMatrixD();
this.expectedOutputs = expectedOutputs.map(o => new MultiMatrix(o)).toMatrixD();
this.nextGradients = nextGradients.map(g => new MultiMatrix(g)).toMatrixD();
this.expectedGradients = expectedInGradients.toMatrixD();
this.expectedLearnedWeights = kerns.map(k => k.Weights);
}
public void setup()
{
this.countEntries = GlobalRandom.NextInt(2, 5);
this.inDims = GlobalRandom.NextIntArr(countEntries, 2, 5);
this.entrySize = inDims.product();
this.pooler = new Pooler(inDims.map(x => GlobalRandom.NextInt(2, x)));
this.layer = new PoolingLayer(this.pooler, this.inDims);
MultiMatrix[] entries = ArrayBuilder.repeat(() => MultiMatrix.Build.random(inDims), countEntries);
MultiMatrix[] expectedOutputs = new MultiMatrix[countEntries];
MultiMatrix[] nextGradients = new MultiMatrix[countEntries];
MultiMatrix[] expectedGradients = new MultiMatrix[countEntries];
for (int i = 0; i < countEntries; i++)
{
expectedOutputs[i] = pooler.slideOver(entries[i]);
nextGradients[i] = MultiMatrix.Build.random(pooler.getOutputDims(inDims));
expectedGradients[i] = pooler.getGradientInput(entries[i], nextGradients[i]);
}
this.inputs = entries.toMatrixD();
this.expectedOutputs = expectedOutputs.toMatrixD();
this.nextGradients = nextGradients.toMatrixD();
this.expectedGradients = expectedGradients.toMatrixD();
}
