internal override float CalculateErrorByOutputGradient(NNDetailedBackpropagationData detailedBackpropagationData, int fromNeuronIndex)
{
float[] dE_dz = detailedBackpropagationData.dE_dz[this];
var idcs = PreviousLayer.ConvertFromNeuronIndex(fromNeuronIndex);
int x = idcs.x;
int y = idcs.x;
int z = idcs.z;
float dE_do = 0;
for (int zIdx = 0; zIdx < Depth; zIdx++)
{
for (int yIdx = 0; yIdx < Height; yIdx++)
{
for (int xIdx = 0; xIdx < Width; xIdx++)
{
int wx = xIdx - x;
int wy = yIdx - y;
if (wx < 0 || wx >= FilterSize || wy < 0 || wy >= FilterSize)
{
continue;
}
dE_do += this.weights[ToWeightIndex(wx, wy, z, zIdx)] * dE_dz[ConvertToNeuronIndex(xIdx, yIdx, zIdx)];
}
}
}
return(dE_do);
}
private void ComputeFilteredImage()
{
FilteredImage image = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] newChannels = new FilteredImageChannel[image.NumberOfChannels];
int size = image.Size;
for (int i = 0; i < image.NumberOfChannels; i++)
{
double[,] newValues = new double[size, size];
for (int valuesI = 0; valuesI < size; valuesI++)
{
for (int valuesJ = 0; valuesJ < size; valuesJ++)
{
if (GlobalRandom.GetRandomDouble() < Rate)
{
newValues[valuesI, valuesJ] = 0;
}
else
{
newValues[valuesI, valuesJ] = image.Channels[i].Values[valuesI, valuesJ];
}
}
}
newChannels[i] = new FilteredImageChannel(size, newValues);
}
Output = new FilteredImage(image.NumberOfChannels, newChannels);
}
public override void ComputeOutput()
{
FilteredImageChannel[] channels = new FilteredImageChannel[FilterNumber];
FilteredImage img = (FilteredImage)PreviousLayer.GetData();
bool samePadding = (Padding == "same") ? true : false;
Task[] tasks = new Task[FilterNumber];
for (int i = 0; i < FilterNumber; i++)
{
int taski = 0 + i;
tasks[taski] = Task.Run(() =>
{
channels[taski] = Filters[taski].Convolve(img, samePadding);
});
}
Task.WaitAll(tasks);
//for (int i = 0; i < FilterNumber; i++)
//{
// channels[i] = Filters[i].Convolve(img, samePadding);
//}
OutputBeforeActivation = new FilteredImage(FilterNumber, channels);
OutputImage = ActivationFunction.Activate(OutputBeforeActivation);
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
FilteredImage image = (FilteredImage)PreviousLayer.GetData();
int outputIndex = 0;
FilteredImageChannel[] channels = new FilteredImageChannel[image.NumberOfChannels];
for (int channel = 0; channel < image.NumberOfChannels; channel++)
{
double[,] values = new double[image.Size, image.Size];
for (int valuesI = 0; valuesI < image.Size; valuesI++)
{
for (int valuesJ = 0; valuesJ < image.Size; valuesJ++)
{
values[valuesI, valuesJ] = nextOutput[outputIndex].Sum();
outputIndex++;
}
}
channels[channel] = new FilteredImageChannel(image.Size, values);
}
return(new FilteredImage[1] {
new FilteredImage(image.NumberOfChannels, channels)
});
}
public override void ComputeOutput()
{
FilteredImage image = (FilteredImage)PreviousLayer.GetData();
int outputIndex = 0;
//for(int valuesI = 0; valuesI < image.Size; valuesI++)
// {
// for (int valuesJ = 0; valuesJ < image.Size; valuesJ++)
// {
// for (int channel = 0; channel < image.NumberOfChannels; channel++)
// {
// Output.Values[outputIndex] = image.Channels[channel].Values[valuesI, valuesJ];
// outputIndex++;
// }
// }
// }
for (int channel = 0; channel < image.NumberOfChannels; channel++)
{
for (int valuesI = 0; valuesI < image.Size; valuesI++)
{
for (int valuesJ = 0; valuesJ < image.Size; valuesJ++)
{
Output.Values[outputIndex] = image.Channels[channel].Values[valuesI, valuesJ];
outputIndex++;
}
}
}
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
FilteredImage input = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] outputChannels = new FilteredImageChannel[input.NumberOfChannels];
FilteredImage nextErrors = (FilteredImage)nextOutput[0];
int errorSize = nextErrors.Size;
int outputSize = input.Size;
for (int i = 0; i < input.NumberOfChannels; i++)
{
outputChannels[i] = new FilteredImageChannel(outputSize);
}
Task[] tasks = new Task[input.NumberOfChannels];
for (int channel = 0; channel < input.NumberOfChannels; channel++)
{
int taskc = 0 + channel;
tasks[taskc] = Task.Run(() =>
{
for (int channelI = 0; channelI + Pool <= outputSize; channelI += Pool)
{
for (int channelJ = 0; channelJ + Pool <= outputSize; channelJ += Pool)
{
int maxi = 0, maxj = 0;
double maxx = input.Channels[taskc].Values[channelI, channelJ];
for (int poolI = 0; poolI < Pool; poolI++)
{
for (int poolJ = 0; poolJ < Pool; poolJ++)
{
int i = channelI + poolI, j = channelJ + poolJ;
if (input.Channels[taskc].Values[i, j] > maxx)
{
maxx = input.Channels[taskc].Values[i, j];
maxi = i;
maxj = j;
}
}
}
outputChannels[taskc].Values[maxi, maxj] =
nextErrors.Channels[taskc].Values[channelI / Pool, channelJ / Pool];
}
}
});
}
Task.WaitAll(tasks);
return(new FilteredImage[1] {
new FilteredImage(input.NumberOfChannels, outputChannels)
});
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
FilteredImage[] newErrors = new FilteredImage[FilterNumber];
FilteredImage previous = (FilteredImage)PreviousLayer.GetData();
FilteredImage nextErrors = (FilteredImage)nextOutput[0];
FilteredImage activationDerivatives = ActivationFunction.GetDerivative(OutputBeforeActivation);
for (int i = 0; i < nextErrors.NumberOfChannels; i++)
{
for (int j = 0; j < nextErrors.Size; j++)
{
for (int k = 0; k < nextErrors.Size; k++)
{
nextErrors.Channels[i].Values[j, k] *= activationDerivatives.Channels[i].Values[j, k];
}
}
}
bool samePadding = (Padding == "same") ? true : false;
Task[] tasks = new Task[FilterNumber];
for (int i = 0; i < FilterNumber; i++)
{
int taski = 0 + i;
tasks[taski] = Task.Run(() =>
{
newErrors[taski] = Filters[taski].Backpropagate(previous,
nextErrors.Channels[taski], learningRate, samePadding);
});
}
Task.WaitAll(tasks);
//for (int i = 0; i < FilterNumber; i++)
//{
// newErrors[i] = Filters[i].Backpropagate(previous,
// nextErrors.Channels[i], learningRate, samePadding);
//}
//for (int i = 0; i < FilterNumber; i++)
//{
// newErrors[i] = Filters[i].Backpropagate(previous,
// activationDerivatives.Channels[i], learningRate, samePadding);
//}
return(newErrors);
}
private RelevantObjectCollection.RelevantObjectCollection GetAllPreviousLayersCollection()
{
if (PreviousLayer == null)
{
return(null);
}
var collection = PreviousLayer.GetAllPreviousLayersCollection();
return(collection == null ?
PreviousLayer.Objects :
RelevantObjectCollection.RelevantObjectCollection.Merge(collection, PreviousLayer.Objects));
}
public override void ComputeOutput()
{
FilteredImage input = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] outputChannels = new FilteredImageChannel[input.NumberOfChannels];
int inputSize = input.Size;
int outputSize = inputSize / Pool;
Task[] tasks = new Task[input.NumberOfChannels];
for (int channel = 0; channel < input.NumberOfChannels; channel++)
{
int taskc = 0 + channel;
tasks[taskc] = Task.Run(() =>
{
FilteredImageChannel auxInput = input.Channels[taskc];
double[,] outputValues = new double[outputSize, outputSize];
for (int channelI = 0; channelI + Pool <= inputSize; channelI += Pool)
{
for (int channelJ = 0; channelJ + Pool <= inputSize; channelJ += Pool)
{
double maxx = auxInput.Values[channelI, channelJ];
for (int poolI = 0; poolI < Pool; poolI++)
{
for (int poolJ = 0; poolJ < Pool; poolJ++)
{
if (maxx < auxInput.Values[channelI + poolI, channelJ + poolJ])
{
maxx = auxInput.Values[channelI + poolI, channelJ + poolJ];
}
}
}
outputValues[channelI / Pool, channelJ / Pool] = maxx;
}
}
outputChannels[taskc] = new FilteredImageChannel(outputSize, outputValues);
});
}
Task.WaitAll(tasks);
Output = new FilteredImage(input.NumberOfChannels, outputChannels);
}
private void InitializeOutput()
{
if (Output == null)
{
LayerOutput previousData = PreviousLayer.GetData();
if (previousData is FlattenedImage)
{
FlattenedImage previous = (FlattenedImage)previousData;
Output = new FlattenedImage(previous.Size);
}
else
{
FilteredImage previous = (FilteredImage)previousData;
Output = new FilteredImage(previous.NumberOfChannels, previous.Size);
}
}
}
public override void ComputeOutput()
{
FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData();
Task[] tasks = new Task[NumberOfUnits];
for (int i = 0; i < NumberOfUnits; i++)
{
int taski = 0 + i;
tasks[taski] = Task.Run(() =>
{
Output.Values[taski] = Units[taski].ComputeOutput(previous);
});
}
Task.WaitAll(tasks);
Output = ActivationFunction.Activate(Output);
}
private void ComputeFlattenedImage()
{
FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData();
double[] newValues = new double[previous.Size];
for (int i = 0; i < previous.Size; i++)
{
if (GlobalRandom.GetRandomDouble() < Rate)
{
newValues[i] = 0;
}
else
{
newValues[i] = previous.Values[i];
}
}
Output = new FlattenedImage(previous.Size, newValues);
}
internal override NNDetailedFeedData FeedForward(NNFeedData input)
{
float[] output = new float[Neurons];
int[] maxIndices = new int[Neurons];
for (int zIdx = 0; zIdx < PreviousLayer.Depth; zIdx++)
{
for (int yiIdx = 0, yoIdx = 0; yoIdx < Height; yiIdx += this.Stride, yoIdx++)
{
for (int xiIdx = 0, xoIdx = 0; xoIdx < Width; xiIdx += this.Stride, xoIdx++)
{
float max = float.MinValue;
int maxIdx = -1;
for (int fyIdx = 0; fyIdx < this.FilterSize; fyIdx++)
{
for (int fxIdx = 0; fxIdx < this.FilterSize; fxIdx++)
{
int idx = PreviousLayer.ConvertToNeuronIndex(xiIdx + fxIdx, yiIdx + fyIdx, zIdx);
if (input[idx] > max)
{
max = input[idx];
maxIdx = idx;
}
}
}
int i = ConvertToNeuronIndex(xoIdx, yoIdx, zIdx);
output[i] = max;
maxIndices[i] = maxIdx;
}
}
}
NNDetailedFeedData feedData = new NNDetailedFeedData(this, output, output);
feedData.CustomData[nameof(maxIndices)] = maxIndices;
return(feedData);
}
public void PopLayer(bool instant = false)
{
PlayNewFloor();
if (savedLayers.Count == 0)
{
return;
}
if (CurrentLayer != null)
{
PreviousLayer = CurrentLayer;
PreviousLayer.ClearEntities();
}
var poppedLayer = savedLayers.Dequeue();
CurrentLayer = poppedLayer;
Tile cachedTile = null;
var layerOffset = Vector2Int.zero;
var previousLayerPlayerPos = PreviousLayer?.PlayerPosition;
if (previousLayerPlayerPos != null)
{
var nextPlayerPos = CurrentLayer.GetPlayerTilePosition();
if (nextPlayerPos != null)
{
layerOffset.x = previousLayerPlayerPos.Value.x - nextPlayerPos.Value.x;
layerOffset.y = previousLayerPlayerPos.Value.y - nextPlayerPos.Value.y;
cachedTile = PreviousLayer?.GetTileAtPosition(previousLayerPlayerPos.Value);
if (cachedTile != null)
{
cachedTile.transform.SetParent(null);
}
}
}
lastLayerOffset = layerOffset;
var newPosition = lastPosition;
newPosition.x += layerOffset.x;
newPosition.z += layerOffset.y;
lastPosition = newPosition;
var spawnPos = newPosition;
spawnPos.x += 5f;
spawnPos.z += 5f;
previousSpawnPos = spawnPos;
poppedLayer.OnLayerPushed(
spawnPos,
newPosition,
() =>
{
cachedPlayer.transform.SetParent(null);
if (PreviousLayer == null)
{
cachedPlayer.transform.SetParent(((Layer)poppedLayer).transform);
}
PreviousLayer?.OnLayerPopped(() =>
{
cachedPlayer.RevokeEvents();
cachedPlayer.transform.SetParent(((Layer)poppedLayer).transform);
if (cachedTile != null)
{
cachedTile.transform.SetParent(((MonoBehaviour)CurrentLayer).transform);
CurrentLayer.SetTile(cachedTile.CurrentPosition, cachedTile);
CurrentLayer.RefreshPlayerPossibleMoves();
}
}, layerOffset, true);
if (!instant)
{
var mainCamera = CameraController.Instance.MainCamera;
mainCamera.DOShakePosition(.2f, 1f, 2, 160f).OnComplete(() =>
{
mainCamera.transform.SetPosition(null, mainCamera.transform.position.y + poppedLayer.Height / 2f, null);
});
}
}, cachedPlayer, instant);
}
internal override void PropagateBackward(NNDetailedBackpropagationData backpropagationData)
{
float[] lastRawOutput = backpropagationData.FeedForwardData[this].RawOutputData;
float[] dE_dz = new float[Neurons];
float[] newWeights = new float[this.weights.Length];
// For each filter
for (int fIdx = 0; fIdx < FilterCount; fIdx++)
{
float dE_db = 0;
float[] dE_dw = new float[FilterSize * FilterSize * PreviousLayer.Depth];
for (int yIdx = 0; yIdx < Height; yIdx++)
{
for (int xIdx = 0; xIdx < Width; xIdx++)
{
int oIdx = ConvertToNeuronIndex(xIdx, yIdx, fIdx);
float do_dz = Activation.Gradient(lastRawOutput[oIdx], lastRawOutput);
float dE_do;
if (NextLayer == null)
{
float o = backpropagationData.FeedForwardData[this].OutputData[oIdx];
dE_do = backpropagationData.ErrorGradient(o, oIdx);
}
else
{
dE_do = NextLayer.CalculateErrorByOutputGradient(backpropagationData, oIdx);
}
float dE_dz_tmp = dE_do * do_dz;
dE_dz[oIdx] = dE_dz_tmp;
for (int fzIdx = 0; fzIdx < PreviousLayer.Depth; fzIdx++)
{
for (int fyIdx = 0; fyIdx < FilterSize; fyIdx++)
{
for (int fxIdx = 0; fxIdx < FilterSize; fxIdx++)
{
float dz_dw = backpropagationData.FeedForwardData[PreviousLayer].OutputData[PreviousLayer.ConvertToNeuronIndex(xIdx * Stride + fxIdx, yIdx * Stride + fyIdx, fzIdx)];
dE_dw[ToWeightIndex(fxIdx, fyIdx, fzIdx, 0)] += dE_dz_tmp * dz_dw;
}
}
}
dE_db += dE_do * do_dz; // dz_dw = 1 for bias
}
}
for (int fzIdx = 0; fzIdx < PreviousLayer.Depth; fzIdx++)
{
for (int fyIdx = 0; fyIdx < FilterSize; fyIdx++)
{
for (int fxIdx = 0; fxIdx < FilterSize; fxIdx++)
{
int weightIndex = ToWeightIndex(fxIdx, fyIdx, fzIdx, fIdx);
newWeights[weightIndex] = backpropagationData.CalculateNewWeight(this.weights[weightIndex], dE_dw[ToWeightIndex(fxIdx, fyIdx, fzIdx, 0)], this, weightIndex);
}
}
}
this.biases[fIdx] += backpropagationData.CalculateNewWeight(this.biases[fIdx], dE_db, this, fIdx);
}
backpropagationData.dE_dz[this] = dE_dz;
backpropagationData.UpdatedWeights[this] = newWeights;
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
int weightsPerUnit = Units[0].NumberOfWeights;
FlattenedImage[] result = new FlattenedImage[weightsPerUnit];
FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData();
for (int i = 0; i < weightsPerUnit; i++)
{
result[i] = new FlattenedImage(NumberOfUnits);
}
FlattenedImage activationDerivative = ActivationFunction.GetDerivative(Output);
Task[] tasks = new Task[NumberOfUnits];
for (int unit = 0; unit < NumberOfUnits; unit++)
{
int tasku = 0 + unit;
tasks[tasku] = Task.Run(() =>
{
Unit unitAux = Units[tasku];
FlattenedImage nextErrors = (FlattenedImage)nextOutput[tasku];
double unitSum = nextErrors.Values.Sum();
double unitDerivative = unitSum * activationDerivative.Values[tasku];
for (int weight = 0; weight < unitAux.NumberOfWeights; weight++)
{
Monitor.Enter(result);
result[weight].Values[tasku] = unitDerivative * unitAux.Weights[weight];
Monitor.Exit(result);
double deltaW = unitDerivative * previous.Values[weight];
unitAux.Weights[weight] -= learningRate * deltaW;
}
});
}
Task.WaitAll(tasks);
//for (int unit = 0; unit < NumberOfUnits; unit++)
//{
// Unit unitAux = Units[unit];
// FlattenedImage nextErrors = (FlattenedImage)nextOutput[unit];
// double unitSum = nextErrors.Sum();
// double unitDerivative = unitSum * activationDerivative.Values[unit];
// for (int weight = 0; weight < unitAux.NumberOfWeights; weight++)
// {
// Monitor.Enter(result);
// result[weight].Values[unit] = unitDerivative * unitAux.Weights[weight];
// Monitor.Exit(result);
// double deltaW = unitDerivative * previous.Values[weight];
// unitAux.Weights[weight] -= learningRate * deltaW;
// }
//}
return(result);
}
