public double GetNegativeFeedbackPercentage(IPartialSnapshotCompression partialSnapshotCompression)
{
double negativeCount = NegativeDictPartialSnapshotCompressions.ContainsKey(partialSnapshotCompression) ? NegativeDictPartialSnapshotCompressions[partialSnapshotCompression].NegativeCount : 0;
double positivCount = PositveDictPartialSnapshotCompressions.ContainsKey(partialSnapshotCompression) ? PositveDictPartialSnapshotCompressions[partialSnapshotCompression].PositiveCount : 0;
double sum = Math.Max(MINIMUM_FEEDBACK_COUNT_FOR_UNIT, positivCount + negativeCount);
if (sum > 0)
{
return(negativeCount / sum);
}
return(-1.0);
}
public void CleanPositiveFeedbackUnits(int count)
{
var removeKeys = new List <IPartialSnapshotCompression>();
foreach (KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> entry in PositveDictPartialSnapshotCompressions.Where(e => e.Value.PositiveCount <= 0))
{
removeKeys.Add(entry.Key);
}
foreach (var key in removeKeys)
{
PositveDictPartialSnapshotCompressions.Remove(key);
}
}
public IPartialSnapshotCompression GetMaxPositivePartialSnapshotCompression(ISensationSnapshot snapshot)
{
IPartialSnapshotCompression result = null;
double maxPercentage = 0.0;
foreach (KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> entry in PositveDictPartialSnapshotCompressions.Where(p => p.Value.PositiveCount > 0))
{
// ToDo: Check in given snapshot if partialSnapshotCompression included.
}
return(result);
}
public void RememberFeedback(int feedbackValue, ISensationSnapshot snapshot)
{
FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForFeedback().Last();
List <IPartialSnapshotCompression> partialSnapshotCompressions = PartialSnapshotCompression.NewInstances(snapshot, fieldOfVision, Action.Direction, GetMaximumCompression());
if (feedbackValue < 0)
{
NegativeFeedbackCount++;
// ########### PartialSnapshotCompression #############
foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions)
{
if (PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
PositveDictPartialSnapshotCompressions.Remove(pscEntry);
}
bool containingEntryExists = false;
foreach (IPartialSnapshotCompression negativePsc in NegativeDictPartialSnapshotCompressions.Keys)
{
if (GetNegativeFeedbackPercentage(negativePsc) >= 0.99 && pscEntry.Contains(negativePsc))
{
containingEntryExists = true;
break;
}
}
if (containingEntryExists)
{
continue;
}
if (!NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
NegativeDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount));
}
else if (GetNegativeFeedbackPercentage(pscEntry) >= 0.99)
{
var entriesToRemove = new List <IPartialSnapshotCompression>();
foreach (IPartialSnapshotCompression existingPsc in NegativeDictPartialSnapshotCompressions.Keys.Where(p => p.CompressionType != pscEntry.CompressionType))
{
if (existingPsc.Contains(pscEntry))
{
entriesToRemove.Add(existingPsc);
}
}
if (entriesToRemove.Any())
{
foreach (IPartialSnapshotCompression existingPsc in entriesToRemove)
{
NegativeDictPartialSnapshotCompressions.Remove(existingPsc);
}
}
}
else
{
NegativeDictPartialSnapshotCompressions[pscEntry].NegativeLifeCycleStamp = NegativeFeedbackCount;
NegativeDictPartialSnapshotCompressions[pscEntry].NegativeCount++;
}
}
}
else if (feedbackValue > 0)
{
PositiveFeedbackCount++;
// ########### PartialSnapshotCompression #############
foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions)
{
if (NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
NegativeDictPartialSnapshotCompressions.Remove(pscEntry);
}
if (OverallNegativePartialSnapshotCompressions.Contains(pscEntry))
{
if (!PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
PositveDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount));
}
else
{
PositveDictPartialSnapshotCompressions[pscEntry].PositiveLifeCycleStamp = PositiveFeedbackCount;
PositveDictPartialSnapshotCompressions[pscEntry].PositiveCount++;
}
}
}
}
if (feedbackValue != 0)
{
List <IPartialSnapshotCompression> sortedKeys = NegativeDictPartialSnapshotCompressions.Keys.ToList();
sortedKeys.Sort();
var keysToRemove = new List <IPartialSnapshotCompression>();
for (int i = 0; i < sortedKeys.Count - 1; i++)
{
for (int j = i + 1; j < sortedKeys.Count; j++)
{
var a = sortedKeys[i];
var b = sortedKeys[j];
if (a.Contains(b) && NegativeDictPartialSnapshotCompressions[a].NegativeCount < NegativeDictPartialSnapshotCompressions[b].NegativeCount)
{
keysToRemove.Add(a);
}
else if (b.Contains(a) && NegativeDictPartialSnapshotCompressions[b].NegativeCount < NegativeDictPartialSnapshotCompressions[a].NegativeCount)
{
keysToRemove.Add(b);
}
}
}
foreach (var key in keysToRemove)
{
NegativeDictPartialSnapshotCompressions.Remove(key);
}
}
}
