public void NextInt()
{
int minVal = -2, maxVal = 2, count = 100;
var nums = new List <int>(ArrayBuilder.repeat(() => GlobalRandom.NextInt(minVal, maxVal), 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 start()
{
var inputs = new double[countIns][];
var outputs = new double[countIns][];
for (var i = 0; i < countIns; i++)
{
var rand = GlobalRandom.NextInt(0, xorTable.Length - 1);
inputs[i] = xorTable[rand].Take(2).ToArray();
outputs[i] = xorTable[rand].Skip(2).ToArray();
}
var ins = MatrixD.Build.DenseOfRowArrays(inputs);
var outs = MatrixD.Build.DenseOfRowArrays(outputs);
var nn = new XORnetBuilder().build();
nn.train(ins, outs, iterations, iterSize);
}
public GameState RandomPlay()
{
List <int> availablePositions = this.game.GameState.AllowedActions;
if (availablePositions.Count == 0)
{
return(this.game.GameState);
}
for (int i = 0; i <= availablePositions.Count - 1; i++)
{
Game verifyGame = new Game(this.game);
verifyGame.Step(availablePositions[i]);
if (verifyGame.GameState.Done)
{
return(verifyGame.GameState);
}
}
int selectRandom = GlobalRandom.NextInt(availablePositions.Count);
this.game.Step(availablePositions[selectRandom]);
return(this.game.GameState);
}
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();
}
