static public List <IPartialSnapshotCompression> NewInstancesOfUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry2 in unitCountDictonary2)
{
if (unitCountEntry2.Key.Equals(unitCountEntry.Key) && unitCountEntry2.Value <= 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.UnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int i = 0; i < unitCountEntry2.Value; i++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitCountEntry2.Key));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstances(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction, CompressionTypes maximumCompression)
{
var result = new List <IPartialSnapshotCompression>();
ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction);
// Single units for fieldOfVision.Single and fieldOfVision.ThreeByThree allows to find 0 and 9
var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot);
result.AddRange(NewInstancesOfUnitCompression(unitCountDictonary, fieldOfVision));
if (maximumCompression >= CompressionTypes.UnitSimpleTree)
{
// Find 1 and 8 if a field around is marked as Filled or Empty (two pattern with single unit) --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfUnitSimpleTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
if (maximumCompression >= CompressionTypes.UnitCountTree)
{
// ToDo: Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
if (maximumCompression >= CompressionTypes.MultiUnitCountTree)
{
// ToDo: Find 1-5 fields at the boarder with combination of Empty and Outside --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
return(result);
}
public double CheckForNegativeFeedback(ISensationSnapshot snapshot)
{
double result = 0.0;
IEnumerable <FieldOfVisionTypes> fieldOfVisions = NegativeDictPartialSnapshotCompressions.Keys.Select(e => e.FieldOfVision).Distinct();
var dictDirectionToSnapshot = new Dictionary <Tuple <FieldOfVisionTypes, DirectionTypes>, ISensationSnapshot>();
var baseDirection = Action.Direction;
foreach (FieldOfVisionTypes fieldOfVision in fieldOfVisions)
{
var basePartialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, baseDirection);
dictDirectionToSnapshot.Add(new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, baseDirection), basePartialSnapshot);
foreach (var childDirection in basePartialSnapshot.SensoryPatterns.Select(p => p.DirectionType))
{
if (childDirection != baseDirection)
{
var childPartialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, childDirection);
dictDirectionToSnapshot.Add(new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, childDirection), childPartialSnapshot);
}
}
}
foreach (IPartialSnapshotCompression partialSnapshotCompression in NegativeDictPartialSnapshotCompressions.Keys)
{
if (PartialSnapshotCompression.Contains(dictDirectionToSnapshot, partialSnapshotCompression))
{
result = Math.Max(result, GetNegativeFeedbackPercentage(partialSnapshotCompression));
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction);
var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot);
result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
return(result);
}
public void TryToLearn()
{
ActionFeedback = 0;
// Zuerst mal die Lage erkunden
RaiseExperienceWanted();
ISensationSnapshot sensationSnapshotBeforeAction = _lastSensationSnapshot;
if (CheckForConflicts(sensationSnapshotBeforeAction))
{
return;
}
// Nun wird entschieden welche Aktion ausgeführt werden soll
IPuzzleAction action = GetDecisionByMemory(sensationSnapshotBeforeAction);
if (action == null)
{
}
// Nun eine Aktion ausführen und Reaktion erkennen
RaiseActionWanted(action);
int actionFeedback = ActionFeedback;
// Wieder die Lage ermitteln und mit dem Zustand zuvor vergleichen
RaiseExperienceWanted();
ISensationSnapshot sensationSnapshotAfterAction = _lastSensationSnapshot;
var difference = SensationSnapshot.GetDifferencePatterns(sensationSnapshotBeforeAction, sensationSnapshotAfterAction);
IActionMemory actionMemory = ActionMemoryDictonary[action];
bool isDifferent = difference.SensoryPatterns.Any();
actionMemory.RememberDifference(isDifferent, sensationSnapshotBeforeAction);
if (isDifferent)
{
if (actionFeedback != 0)
{
if (actionFeedback < 0)
{
Console.WriteLine("Error occurred!");
}
actionMemory.RememberFeedback(actionFeedback, sensationSnapshotBeforeAction);
actionMemory.RefreshOverallNegativePscList(ActionMemoryDictonary.Values.ToList());
}
_actionFeedbackHistory.Add(actionFeedback);
while (_actionFeedbackHistory.Count > MAX_ACTION_FEEDBACK_HISTORY_COUNT)
{
_actionFeedbackHistory.RemoveAt(0);
}
}
}
static public ISensationSnapshot GetDifferencePatterns(ISensationSnapshot a, ISensationSnapshot b)
{
var result = new SensationSnapshot(a.Direction, a.FieldOfVision, a.SensoryPatterns, false);
foreach (ISensoryPattern sensoryPattern in b.SensoryPatterns)
{
if (a.SensoryPatterns.Contains(sensoryPattern))
{
result.SensoryPatterns.Remove(sensoryPattern);
}
}
result.SensoryPatterns.Sort();
return(result);
}
public double CheckForDifferencePattern(ISensationSnapshot snapshot)
{
List <FieldOfVisionTypes> fieldOfVisions = GetFieldOfVisionsForDifferences();
double result = 1.0;
foreach (var fieldOfVision in fieldOfVisions)
{
var partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, Action.Direction);
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
if (GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
double posibilityForDifference = 1.0 - (double)GetNoDifferencePattern(fieldOfVision)[pattern] / MINIMUM_PATTERN_NO_DIFFERENT_COUNT;
result = Math.Min(result, posibilityForDifference);
}
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
List <ISensoryUnit> sortedUnits = new List <ISensoryUnit>();
sortedUnits.AddRange(unitCountDictonary2.Keys.ToList());
sortedUnits.Sort();
for (int i = 0; i < sortedUnits.Count - 1; i++)
{
var unitKey1 = sortedUnits[i];
int unitValue1 = unitCountDictonary2[unitKey1];
if (unitKey1.Equals(unitCountEntry.Key))
{
unitValue1--;
if (unitValue1 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
for (int j = i + 1; j < sortedUnits.Count; j++)
{
var unitKey2 = sortedUnits[j];
var unitValue2 = unitCountDictonary2[unitKey2];
if (unitKey2.Equals(unitCountEntry.Key))
{
unitValue2--;
if (unitValue2 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.MultiUnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int q = 0; q < unitValue1; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey1));
}
for (int q = 0; q < unitValue2; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey2));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
}
return(result);
}
public void RememberDifference(bool isDifferent, ISensationSnapshot snapshot)
{
FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForDifferences().Last();
var partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, Action.Direction);
// Handles counter and single units
if (isDifferent)
{
DifferenceCount++;
var singleUnits = SplitUnits(partialSnapshot);
foreach (var unit in singleUnits)
{
if (!DifferentUnits.ContainsKey(unit) && NoDifferentUnits.ContainsKey(unit))
{
DifferentUnits.Add(unit, 0);
}
if (DifferentUnits.ContainsKey(unit))
{
DifferentUnits[unit]++;
}
}
List <ISensoryUnit> unitsToRemove = new List <ISensoryUnit>();
foreach (var entry in DifferentUnits)
{
if (!NoDifferentUnits.ContainsKey(entry.Key))
{
unitsToRemove.Add(entry.Key);
}
}
foreach (var unit in unitsToRemove)
{
DifferentUnits.Remove(unit);
}
}
else
{
NoDifferenceCount++;
var singleUnits = SplitUnits(partialSnapshot);
foreach (var unit in singleUnits)
{
if (!NoDifferentUnits.ContainsKey(unit))
{
NoDifferentUnits.Add(unit, 0);
}
NoDifferentUnits[unit]++;
}
}
if (NoDifferenceCount > MINIMUM_CALL_COUNT_FOR_DIFFERENT_PATTERN && DifferenceCount > 0)
{
if (isDifferent)
{
// Look for pattern in No-Difference-Dictionary, which have brought about a change
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
if (GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
GetNoDifferencePattern(fieldOfVision).Remove(pattern);
}
}
}
else
{
// Looking for pattern that probably show, that there is no effect by handling this action
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
bool patternFound = true;
foreach (var unit in pattern.SensoryUnits)
{
if (!NoDifferentUnits.ContainsKey(unit))
{
patternFound = false;
break;
}
}
if (patternFound)
{
if (!GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
GetNoDifferencePattern(fieldOfVision).Add(pattern, 0);
}
GetNoDifferencePattern(fieldOfVision)[pattern]++;
}
}
}
}
}