/// <summary>
/// Converts the state vector into an MDP state.
/// </summary>
/// <param name="state">State vector.</param>
/// <param name="summary">Feature properties from the original set.</param>
/// <param name="discretizer">Discretization function for generating unique state identifiers.</param>
/// <returns>MDPState.</returns>
public static MDPState GetState(Vector state, Summary summary, IDiscretizer discretizer)
{
return(new MDPState((int)discretizer.Discretize(state, summary))
{
Features = state
});
}
/// <summary>
/// Returns a graph of MDP States from the States matrices and Action label vector.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="actions">Action label vector.</param>
/// <param name="statesP">Transition states matrix.</param>
/// <param name="reward">Reward value vector.</param>
/// <param name="properties">Feature properties from the original set.</param>
/// <param name="discretizer">Discretization function for generating unique state identifiers.</param>
/// <returns>IEnumerable<IMDPState></returns>
public static IEnumerable<MDPState> GetStates(Matrix states, Vector actions, Matrix statesP, Vector reward,
Math.Summary properties, IDiscretizer discretizer)
{
Math.Summary summary = (properties != null ? properties : Math.Summary.Summarize(states));
discretizer.Initialize(states, summary);
var sdist = new Dictionary<double, MDPState>();
var adist = new Dictionary<string, double>();
var results = new Dictionary<double, MDPState>();
for (int i = 0; i < states.Rows; i++)
{
double sid = discretizer.Discretize(states[i], summary);
if (!sdist.ContainsKey(sid))
{
sdist.Add(sid, MDPConverter.GetState(states[i], summary, discretizer));
results.Add(sid, sdist[sid]);
}
double tsid = discretizer.Discretize(statesP[i], summary);
MDPState tstate = (sdist.ContainsKey(tsid) ? sdist[tsid] : MDPConverter.GetState(statesP[i], summary, discretizer));
if (!sdist.ContainsKey(tsid))
sdist.Add(tsid, tstate);
string key = GetActionKey((int)sid, (int)tsid);
if (!adist.ContainsKey(key))
adist.Add(key, 1);
else
{
adist[key]++;
}
sdist[sid].Successors.Add(new MDPSuccessorState(MDPConverter.GetAction(actions[i], (int) sid, (int) tsid), 0, tstate, reward[i]));
if (results.ContainsKey(tsid))
results.Remove(tsid);
}
foreach (var state in sdist.Values)
{
double sum = state.Successors.Sum(s => adist[GetActionKey(state.Id, s.State.Id)]);
foreach (var successor in state.Successors)
{
var key = GetActionKey(state.Id, successor.State.Id);
((AI.Action) successor.Action).Probability = adist[key] / sum;
}
}
// return starting states
return results.Values;
}
/// <summary>
/// Returns a flat collection of states/actions and their transition states.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="actions">Action label vector.</param>
/// <param name="statesP">Transition states matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static Tuple <IEnumerable <IState>, IEnumerable <IAction>, IEnumerable <IState> > GetStates(
Matrix states,
Vector actions,
Matrix statesP,
Summary properties,
IDiscretizer discretizer)
{
var summary = properties ?? Summary.Summarize(states);
var slist = new IState[states.Rows];
var alist = new IAction[actions.Length];
var splist = new IState[statesP.Rows];
for (var i = 0; i < states.Rows; i++)
{
slist[i] = GetState(states[i], summary, discretizer);
splist[i] = GetState(statesP[i], summary, discretizer);
alist[i] = GetAction(actions[i], slist[i].Id, splist[i].Id);
}
return(new Tuple <IEnumerable <IState>, IEnumerable <IAction>, IEnumerable <IState> >(slist, alist, splist));
}
protected StandardODESolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
if (discretizer == null)
{
throw new ArgumentNullException("discretizer", "Null discretizer passed");
}
this.discretizer = discretizer;
if (function == null)
{
throw new ArgumentNullException("function", "Null function passed");
}
this.function = function;
if (maxIterations <= 0)
{
throw new ArgumentOutOfRangeException("maxIterations", "The number of maximum iterations must be positive");
}
this.maxIterations = maxIterations;
if (!initialCondition.IsFinite())
{
throw new ArgumentOutOfRangeException("initialCondition", "Non-finite initial condition");
}
this.initialCondition = initialCondition;
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, discretizer, options, maxIterations).Solve);
}
/// <summary>
/// Converts the state vector into an MDP state.
/// </summary>
/// <param name="state">State vector.</param>
/// <param name="summary">Feature properties from the original set.</param>
/// <param name="discretizer">Discretization function for generating unique state identifiers.</param>
/// <returns>MDPState.</returns>
public static MDPState GetState(Vector state, Summary summary, IDiscretizer discretizer)
{
return new MDPState((int)discretizer.Discretize(state, summary)) { Features = state };
}
private void ChangeDiscretizationModule()
{
int outputSize = (int)nOutputSize.Value;
discretizer = new DiscretizationModule(outputSize);
}
/// <summary>
/// Returns a flat collection of states/actions and their transition states.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="actions">Action label vector.</param>
/// <param name="statesP">Transition states matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static Tuple<IEnumerable<IState>, IEnumerable<IAction>, IEnumerable<IState>> GetStates(Matrix states,
Vector actions, Matrix statesP, Math.Summary properties, IDiscretizer discretizer)
{
Math.Summary summary = (properties != null ? properties : Math.Summary.Summarize(states));
var slist = new IState[states.Rows];
var alist = new IAction[actions.Length];
var splist = new IState[statesP.Rows];
for (int i = 0; i < states.Rows; i++)
{
slist[i] = MDPConverter.GetState(states[i], summary, discretizer);
splist[i] = MDPConverter.GetState(statesP[i], summary, discretizer);
alist[i] = MDPConverter.GetAction(actions[i], slist[i].Id, splist[i].Id);
}
return new Tuple<IEnumerable<IState>, IEnumerable<IAction>, IEnumerable<IState>>(slist, alist, splist);
}
/// <summary>
/// Converts a Matrix of states into an array of State objects.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static IEnumerable<IMDPState> GetStates(Matrix states, Math.Summary properties, IDiscretizer discretizer)
{
Math.Summary summary = (properties != null ? properties : Math.Summary.Summarize(states));
var slist = new IMDPState[states.Rows];
for (int i = 0; i < states.Rows; i++)
{
slist[i] = MDPConverter.GetState(states[i], summary, discretizer);
}
return slist;
}
//Euler solver extension
public static ArraySolver EulerArraySolver(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(EulerSolver.MakeArraySolver(argument, initialCondition, discretizer, maxIterations));
}
public static Function RungeKuttaSolve(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(RungeKuttaSolver.MakeSolution(argument, initialCondition, discretizer, maxIterations));
}
protected StandardODESolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS) :
this(function, initialCondition, discretizer, maxIterations)
{
nodeSelector = GenerateSelector(options);
}
public static Function HeunSolve(this ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = StandardODESolver.DEFAULT_MAX_ITERATIONS)
{
return(HeunSolver.MakeSolution(argument, initialCondition, discretizer, options, maxIterations));
}
/// <summary>
/// Returns a graph of MDP States from the States matrices and Action label vector.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="actions">Action label vector.</param>
/// <param name="statesP">Transition states matrix.</param>
/// <param name="reward">Reward value vector.</param>
/// <param name="properties">Feature properties from the original set.</param>
/// <param name="discretizer">Discretization function for generating unique state identifiers.</param>
/// <returns>IEnumerable<IMDPState></returns>
public static IEnumerable <MDPState> GetStates(
Matrix states,
Vector actions,
Matrix statesP,
Vector reward,
Summary properties,
IDiscretizer discretizer)
{
var summary = properties ?? Summary.Summarize(states);
discretizer.Initialize(states, summary);
var sdist = new Dictionary <double, MDPState>();
var adist = new Dictionary <string, double>();
var results = new Dictionary <double, MDPState>();
for (var i = 0; i < states.Rows; i++)
{
var sid = discretizer.Discretize(states[i], summary);
if (!sdist.ContainsKey(sid))
{
sdist.Add(sid, GetState(states[i], summary, discretizer));
results.Add(sid, sdist[sid]);
}
var tsid = discretizer.Discretize(statesP[i], summary);
var tstate = sdist.ContainsKey(tsid) ? sdist[tsid] : GetState(statesP[i], summary, discretizer);
if (!sdist.ContainsKey(tsid))
{
sdist.Add(tsid, tstate);
}
var key = GetActionKey((int)sid, (int)tsid);
if (!adist.ContainsKey(key))
{
adist.Add(key, 1);
}
else
{
adist[key]++;
}
sdist[sid].Successors.Add(
new MDPSuccessorState(GetAction(actions[i], (int)sid, (int)tsid), 0, tstate, reward[i]));
if (results.ContainsKey(tsid))
{
results.Remove(tsid);
}
}
foreach (var state in sdist.Values)
{
var sum = state.Successors.Sum(s => adist[GetActionKey(state.Id, s.State.Id)]);
foreach (var successor in state.Successors)
{
var key = GetActionKey(state.Id, successor.State.Id);
((Action)successor.Action).Probability = adist[key] / sum;
}
}
// return starting states
return(results.Values);
}
private HeunSolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS) :
base(function, initialCondition, discretizer, maxIterations)
{
}
public static Function MakeSolution(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new RungeKuttaSolver(argument, initialCondition, discretizer, DEFAULT_MAX_ITERATIONS).Solve);
}
/// <summary>
/// Converts a Matrix of states into an array of State objects.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static IEnumerable <IMDPState> GetStates(Matrix states, Math.Summary properties, IDiscretizer discretizer)
{
Math.Summary summary = (properties != null ? properties : Math.Summary.Summarize(states));
var slist = new IMDPState[states.Rows];
for (int i = 0; i < states.Rows; i++)
{
slist[i] = MDPConverter.GetState(states[i], summary, discretizer);
}
return(slist);
}
/// <summary>
/// Returns a flat collection of states/actions and their transition states.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="actions">Action label vector.</param>
/// <param name="statesP">Transition states matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static Tuple <IEnumerable <IState>, IEnumerable <IAction>, IEnumerable <IState> > GetStates(Matrix states,
Vector actions, Matrix statesP, Math.Summary properties, IDiscretizer discretizer)
{
Math.Summary summary = (properties != null ? properties : Math.Summary.Summarize(states));
var slist = new IState[states.Rows];
var alist = new IAction[actions.Length];
var splist = new IState[statesP.Rows];
for (int i = 0; i < states.Rows; i++)
{
slist[i] = MDPConverter.GetState(states[i], summary, discretizer);
splist[i] = MDPConverter.GetState(statesP[i], summary, discretizer);
alist[i] = MDPConverter.GetAction(actions[i], slist[i].Id, splist[i].Id);
}
return(new Tuple <IEnumerable <IState>, IEnumerable <IAction>, IEnumerable <IState> >(slist, alist, splist));
}
public RecognitionPath(IDiscretizer discretizer, IPictogramClassifier classifier, IClassMapper mapper)
{
this.discretizer = discretizer;
this.classifier = classifier;
this.mapper = mapper;
}
private RungeKuttaSolver(ODEFunction function, Vector2D initialCondition, IDiscretizer discretizer, OptimizationOptions options, int maxIterations = DEFAULT_MAX_ITERATIONS) :
base(function, initialCondition, discretizer, options, maxIterations)
{
}
public static ArraySolver MakeArraySolver(ODEFunction argument, Vector2D initialCondition, IDiscretizer discretizer, int maxIterations = DEFAULT_MAX_ITERATIONS)
{
return(new HeunSolver(argument, initialCondition, discretizer, maxIterations).Solve);
}
/// <summary>
/// Converts a Matrix of states into an array of State objects.
/// </summary>
/// <param name="states">State matrix.</param>
/// <param name="properties">(Optional) Feature summary.</param>
/// <param name="discretizer">Disretization function to apply for reducing states.</param>
/// <returns></returns>
public static IEnumerable <IMDPState> GetStates(Matrix states, Summary properties, IDiscretizer discretizer)
{
var summary = properties ?? Summary.Summarize(states);
var slist = new IMDPState[states.Rows];
for (var i = 0; i < states.Rows; i++)
{
slist[i] = GetState(states[i], summary, discretizer);
}
return(slist);
}
