IEnumerable <SamplesTargets> generator(float[][] data, int lookback, int delay, int min_index, int max_index, bool shuffle = false, int batch_size = 128, int step = 6, bool reverse = false)
{
if (reverse)
{
throw new NotImplementedException();
}
var random = new Random();
if (max_index < 0)
{
max_index = data.Length - delay - 1;
}
var i = min_index + lookback;
while (true)
{
int[] rows = null;
if (shuffle)
{
rows = new int[batch_size];
var range = max_index - (min_index + lookback);
for (int k = 0; k < batch_size; k++)
{
rows[k] = random.Next(range) + (min_index + lookback);
}
}
else
{
if (i + batch_size >= max_index)
{
i = min_index + lookback;
}
var num_rows = Math.Min(i + batch_size, max_index) - i;
rows = new int[num_rows];
for (int k = 0; k < num_rows; k++)
{
rows[k] = k + i;
}
i += num_rows;
}
var st = new SamplesTargets();
st.num_strides = (int)(lookback / step);
st.samples = new float[rows.Length * st.num_strides * data[0].Length];
st.targets = new float[rows.Length];
var samples_index = 0;
var num_bytes_in_block_row = data[0].Length * sizeof(float);
for (int j = 0; j < rows.Length; j++)
{
for (int s = rows[j] - lookback; s < rows[j]; s += step)
{
Buffer.BlockCopy(data[s], 0, st.samples, samples_index * num_bytes_in_block_row, num_bytes_in_block_row);
samples_index++;
}
st.targets[j] = data[rows[j] + delay][1];
}
yield return(st);
}
/**
*
* if reverse is True:
* yield samples[:, ::-1, :], targets
*/
}
CNTK.Value create_x_minibatch(bool sequence_mode, CNTK.Variable x, GeneratorsInfo gi, SamplesTargets st, CNTK.DeviceDescriptor computeDevice)
{
if (sequence_mode == false)
{
return(CNTK.Value.CreateBatch(x.Shape, st.samples, computeDevice));
}
var sequence_length = gi.lookback / gi.step;
var minibatch_size = st.samples.Length / sequence_length / gi.num_records;
var x_shape = CNTK.NDShape.CreateNDShape(new int[] { gi.num_records, sequence_length, minibatch_size });
var ndArrayView = new CNTK.NDArrayView(x_shape, st.samples, computeDevice, readOnly: true);
return(new CNTK.Value(ndArrayView));
}
