source: branches/HeuristicLab.Problems.GrammaticalOptimization/HeuristicLab.Algorithms.Bandits/GrammarPolicies/GrammarPolicy.cs @ 11770

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HeuristicLab.Common;
using HeuristicLab.Problems.GrammaticalOptimization;

namespace HeuristicLab.Algorithms.Bandits.GrammarPolicies {
  // stores: tries, avg reward and max reward for each state
  public abstract class GrammarPolicy : IGrammarPolicy {
    protected Dictionary<string, double> avgReward;
    protected Dictionary<string, int> tries;
    protected Dictionary<string, double> maxReward;
    private readonly bool useCanonicalState;
    private readonly IProblem problem;

    public GrammarPolicy(IProblem problem, bool useCanonicalState = false) {
      this.useCanonicalState = useCanonicalState;
      this.problem = problem;
      this.tries = new Dictionary<string, int>();
      this.avgReward = new Dictionary<string, double>();
      this.maxReward = new Dictionary<string, double>();
    }

    public abstract bool TrySelect(Random random, ReadonlySequence curState, IEnumerable<ReadonlySequence> afterStates, out ReadonlySequence selectedState);

    public virtual void UpdateReward(IEnumerable<ReadonlySequence> stateTrajectory, double reward) {
      foreach (var state in stateTrajectory) {
        var s = CanonicalState(state.ToString());

        if (!tries.ContainsKey(s)) tries.Add(s, 0);
        if (!avgReward.ContainsKey(s)) avgReward.Add(s, 0);
        if (!maxReward.ContainsKey(s)) maxReward.Add(s, 0);

        tries[s]++;
        double alpha = 1.0 / tries[s];
        avgReward[s] += alpha * (reward - avgReward[s]);
        maxReward[s] = Math.Max(maxReward[s], reward);
      }
    }

    public virtual void Reset() {
      avgReward.Clear();
      maxReward.Clear();
      tries.Clear();
    }

    public double AvgReward(ReadonlySequence state) {
      var s = CanonicalState(state.ToString());
      if (avgReward.ContainsKey(s)) return avgReward[s];
      else return 0.0;
    }

    public double MaxReward(ReadonlySequence state) {
      var s = CanonicalState(state.ToString());
      if (maxReward.ContainsKey(s)) return maxReward[s];
      else return 0.0;
    }

    public virtual int GetTries(ReadonlySequence state) {
      var s = CanonicalState(state.ToString());
      if (tries.ContainsKey(s)) return tries[s];
      else return 0;
    }

    public virtual double GetValue(ReadonlySequence state) {
      return AvgReward(state);
    }

    protected string CanonicalState(string state) {
      if (useCanonicalState) return problem.CanonicalRepresentation(state);
      else return state;
    }
  }
}