protected void ManageMemoryBuffer(List <IState>[] plans)
{
List <TrainingInstance> trainingInstances = new List <TrainingInstance>();
foreach (var plan in plans)
{
for (int i = 0; i < plan.Count; i++)
{
double pathCost = Global.CostOfPath(plan.GetRange(i, plan.Count - i).ToArray());
TrainingInstance trainingInstance = new TrainingInstance(plan[i], pathCost);
trainingInstances.Add(trainingInstance);
}
}
for (int i = 0; i < trainingInstances.Count; i++)
{
TrainingInstance trainingInstance = trainingInstances[i];
if (!memoryBuffer.Any(x => x.Equals(trainingInstance)))
{
memoryBuffer.Add(trainingInstance);
}
}
if (memoryBuffer.Count > memoryBufferMaxRecords)
{
int numIter = memoryBuffer.Count - memoryBufferMaxRecords;
memoryBuffer.RemoveRange(0, numIter);
}
}
/** Given a training instance it returns the result of sign(weights'instanceFeatures). */
int Classify(TrainingInstance ti)
{
RealVector features = ti.GetFeatures();
double result = features.DotProduct(weights);
if (result >= 0) {
return 1;
}
return -1;
}
private TrainingInstance[] SelectSubset(int k)
{
var result = new TrainingInstance[k];
var visited = new HashSet<int>();
for (int i = 0; i < k; i++) {
while (true)
{
int nextIdx = rand.Next(0, k);
if (visited.Add(nextIdx)) {
result[i] = trainingSet[nextIdx];
break;
}
}
}
return result;
}
private TrainingInstance[] CreateBatch(TrainingInstance[] subset, RealVector weights)
{
TrainingInstance[] misclassified = Misclassified(subset, weights);
var ret = new TrainingInstance[subset.Length + 3* misclassified.Length];
for (int i = 0; i < ret.Length; i++) {
if (i < subset.Length) {
ret[i] = subset[i];
} else {
ret[i] = misclassified[(i - subset.Length) % misclassified.Length];
}
}
return ret;
}
private int classify(TrainingInstance ti, RealVector w)
{
RealVector features = ti.GetFeatures();
double result = features.DotProduct(w);
if (result >= 0) {
return 1;
}
return -1;
}
/** Calculates the logloss for every object in batch. */
private static double[] LogisticLoss(TrainingInstance[] batch, RealVector weights)
{
double[] result = new double[batch.Length];
double[] raw = new double[batch.Length];
for (int i = 0; i < batch.Length; i++) {
RealVector cur = batch[i].GetFeatures();
raw[i] = cur.DotProduct(weights);
}
for (int i = 0; i < result.Length; i++) {
double exp = Math.Exp(raw[i]);
result[i] = exp / (1 + exp);
}
return (result);
}
private static RealVector BatchGradient(double[] logloss, TrainingInstance[] batch)
{
int dimensions = batch[0].GetFeatureCount();
int batchSize = batch.Length;
RealVector toReplicate = new RealVector(logloss);
RealVector labels = new RealVector(batchSize);
for (int i = 0 ; i < batchSize; i++)
{
labels.GetFeatures()[i] = batch[i].GetLabel();
}
labels.Add(1).ScaleThis(0.5);
toReplicate.Subtract(labels);
RealVector[] repmat = new RealVector[dimensions];
for (int i = 0; i < dimensions; i++) {
repmat[i] = new RealVector(toReplicate);
}
for (int i = 0; i < dimensions; i++) {
for(int j = 0; j < batchSize; j++) {
repmat[i].w[j] *= batch[j].GetFeatures().w[i];
}
}
RealVector result = new RealVector(dimensions);
for (int i = 0; i < dimensions;i++) {
result.w[i] = repmat[i].Average();
}
return result;
}
