/// <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); }