private NeuralVectors CreateNeuralVectors(int index)
{
var fs = featureStreams[index];
var fa = fs.CreateFeatureArray(SampleSize);
if (SubSampleSize == SampleSize)
{
var nv = new NeuralVectors(index, new VectorFlowEntry<double>(CreateInputVector(fa), CreateOutputVector(fs), NumberOfComputationIterations));
return nv;
}
else
{
var entries = new LinkedList<VectorFlowEntry<double>>();
int size = SampleSize / SubSampleSize;
for (int lookupIndex = 0; lookupIndex < lookupArray.Length; lookupIndex++)
{
Point lookupPoint = lookupArray[lookupIndex];
double?[] inputVector = new double?[SubSampleSize * SubSampleSize];
int inputIndex = 0;
for (int y = lookupPoint.Y; y < lookupPoint.Y + SubSampleSize; y++)
{
for (int x = lookupPoint.X; x < lookupPoint.X + SubSampleSize; x++)
{
inputVector[inputIndex++] = fa[y, x];
}
}
//for (int y = 0; y < SampleSize; y += size)
//{
// for (int x = 0; x < SampleSize; x += size)
// {
// int xp = x + lookupPoint.X;
// int yp = y + lookupPoint.Y;
// inputVector[inputIndex++] = fa[yp, xp];
// }
//}
if (lookupIndex != lookupArray.Length - 1)
{
entries.AddLast(new VectorFlowEntry<double>(inputVector, NullOutput));
}
else
{
entries.AddLast(new VectorFlowEntry<double>(inputVector, CreateOutputVector(fs), NumberOfComputationIterations));
}
}
return new NeuralVectors(index, entries);
}
}
private void OnGetNextVectorsCompleted(NativeActivityContext context, ActivityInstance instance, NeuralVectors vectors)
{
var list = vectorList.Get(context);
if (vectors != null) list.Add(vectors);
if (vectors == null || list.Count == GetBatchSize(context))
{
GetNextVectorsDone(context, list.ToArray(), TrainingResetSchedule.None);
}
else if (vectors.IsEndOfStream)
{
GetNextVectorsDone(context, list.ToArray(), TrainingResetSchedule.AfterExecution);
}
else
{
ScheduleGetNextVectors(context);
}
list.Clear();
}
private void ProcessNextVectors(NativeActivityContext context, NeuralVectors[] result)
{
bool reinitialize = false;
IList<NeuralVectors> finalResult = result;
if (IsCached(context))
{
var vars = ComputationContext.GetVariables(context, this);
var cache = vars.Get<SerializableCache>(CacheVarName).Cache;
// Cache results:
if (result != null)
{
foreach (var vectors in result)
{
string key = vectors.ProviderIndex.ToString();
cache[key] = vectors;
}
}
// Combine cached vectors with result:
var vectorsFromCache = cachedVectors.Get(context);
cachedVectors.Set(context, null);
if (result != null)
{
if (vectorsFromCache.Count != 0)
{
finalResult = result.Concat(vectorsFromCache).ToList();
}
}
else
{
finalResult = vectorsFromCache.ToList();
}
}
if (ReinitializationFrequency != null && ReinitializeVectorProvider != null)
{
var freq = ReinitializationFrequency.Get(context);
if (freq > 0)
{
var vars = ComputationContext.GetVariables(context, this);
int iterations = vars.Get<int>(IterationsVarName);
if ((++iterations % freq) == 0)
{
context.ScheduleAction(ReinitializeVectorProvider, OnReinitializeVectorProviderCompleted);
reinitialize = true;
}
vars.Set(IterationsVarName, iterations);
}
}
GetNextVectorsDone(context, finalResult, reinitialize ? TrainingResetSchedule.AfterExecution : TrainingResetSchedule.None);
}
private void OnGetNextVectorsCompleted(NativeActivityContext context, ActivityInstance instance, NeuralVectors[] result)
{
ProcessNextVectors(context, result);
}
private void OnGetNextVectorsCompleted(NativeActivityContext context, ActivityInstance instance, NeuralVectors[] result)
{
if (ReinitializationFrequency != null && ReinitializeVectorProvider != null)
{
var freq = ReinitializationFrequency.Get(context);
if (freq > 0)
{
var vars = ComputationContext.GetVariables(context, this);
int iterations = vars.Get<int>(IterationsVarName);
if ((++iterations % freq) == 0)
{
context.ScheduleAction(ReinitializeVectorProvider, OnReinitializeVectorProviderCompleted);
}
vars.Set(IterationsVarName, iterations);
}
}
GetNextVectorsDone(context, result, TrainingResetSchedule.None);
}
