internal ManagedDataArray(float[] array, bool isConst)
{
Debug.Assert(array != null && array.Length > 0);
InternalManagedArray = new ManagedArray(array);
this.isConst = isConst;
}
internal static void UpdateWeightsOffline(
ManagedArray lastUpdates,
ManagedArray weights,
ManagedArray gradientSums,
float count,
float rate,
float momentum,
bool smoothing)
{
Debug.Assert(lastUpdates.Size != 0 && lastUpdates.Size == weights.Size && weights.Size == gradientSums.Size);
fixed (float* pLastUpdates = lastUpdates.InternalArray, pWeights = weights.InternalArray, pGradients = gradientSums.InternalArray)
{
var lastUpdatesPtr = lastUpdates.ToPtr(pLastUpdates);
var weightsPtr = weights.ToPtr(pWeights);
var gradientSumsPtr = gradientSums.ToPtr(pGradients);
if (smoothing)
{
float smoothV = 1.0f - momentum;
for (int idx = 0; idx < weights.Size; idx++)
{
float update = (gradientSumsPtr[idx] / count) * rate;
float lastUpdate = lastUpdatesPtr[idx];
update = (lastUpdate * momentum) + (update * smoothV);
weightsPtr[idx] += update;
lastUpdatesPtr[idx] = update;
}
}
else
{
for (int idx = 0; idx < weights.Size; idx++)
{
float update = (gradientSumsPtr[idx] / count) * rate;
float lastUpdate = lastUpdatesPtr[idx];
update = (lastUpdate * momentum) + update;
weightsPtr[idx] += update;
lastUpdatesPtr[idx] = update;
}
}
}
}
// Copies a 3D [x][y][z] to 4D [index][x][y][z]
public static void Copy3D4D(ManagedArray dst, ManagedArray src, int index)
{
MemCopy(dst, index * src.Length(), src, 0, src.Length());
}
protected bool SetupInputData(string training)
{
var text = training.Trim();
if (string.IsNullOrEmpty(text))
{
return(false);
}
var TrainingBuffer = new TextBuffer(new TextTagTable())
{
Text = text
};
Examples.Value = Convert.ToInt32(TrainingBuffer.LineCount, ci);
var inpx = Convert.ToInt32(InputLayerNodes.Value, ci);
var inpy = Convert.ToInt32(Examples.Value, ci);
ManagedOps.Free(InputData, OutputData, NormalizationData);
InputData = new ManagedArray(inpx, inpy);
NormalizationData = new ManagedArray(inpx, 2);
OutputData = new ManagedArray(1, inpy);
int min = 0;
int max = 1;
for (int x = 0; x < inpx; x++)
{
NormalizationData[x, min] = double.MaxValue;
NormalizationData[x, max] = double.MinValue;
}
var current = DelimiterBox.Active;
var delimiter = current >= 0 && current < Delimiters.Count ? Delimiters[current].Character : '\t';
var inputs = inpx;
using (var reader = new StringReader(TrainingBuffer.Text))
{
for (int y = 0; y < inpy; y++)
{
var line = reader.ReadLine();
if (!string.IsNullOrEmpty(line))
{
var tokens = line.Split(delimiter);
if (inputs > 0 && tokens.Length > inputs)
{
OutputData[0, y] = Convert.ToDouble(tokens[inputs], ci);
for (int x = 0; x < inpx; x++)
{
var data = Convert.ToDouble(tokens[x], ci);
NormalizationData[x, min] = data < NormalizationData[x, min] ? data : NormalizationData[x, min];
NormalizationData[x, max] = data > NormalizationData[x, max] ? data : NormalizationData[x, max];
InputData[x, y] = data;
}
}
}
}
}
NormalizeData(InputData, NormalizationData);
UpdateTextView(Normalization, NormalizationData);
return(true);
}
// Copies a 4D [index][x][y][z] to 3D [x][y][z]
public static void Copy4D3D(ManagedArray dst, ManagedArray src, int index)
{
MemCopy(dst, 0, src, index * dst.Length(), dst.Length());
}
static void Vectorize(ManagedArray x1, ManagedArray x2)
{
// Reshape into column vectors
ManagedMatrix.Vector(x1);
ManagedMatrix.Vector(x2);
}
static int Cols(ManagedArray x)
{
return(x.x);
}
static int Rows(ManagedArray x)
{
return(x.y);
}
public ManagedArray(ManagedArray a, bool initialize = true)
{
Resize(a, initialize);
}
public void Resize(ManagedArray a, bool initialize = true)
{
Resize(a.x, a.y, a.z, a.i, a.j, initialize);
}
