public List <GameMoveResult> MakeMoves(object owner, IContextLookup globalVars, int movesNumber) { var objGame = Game.EvaluateTyped(owner, globalVars); var objState = State.Evaluate(owner, globalVars); var objStrategy = Strategy.GetValue(owner, globalVars); return(objStrategy.MakeMoves(objGame, objState, movesNumber)); }
internal DefaultPropertyBuildContext(ILookup innerLookup, IContextLookup contextLookup, IPropertyMap map, TSubject subject) { this.innerLookup = innerLookup; this.contextLookup = contextLookup; this.map = map; this.getInstance = delegate() { return(subject); }; this.setInstance = delegate { }; }
public bool Ask(object owner, IContextLookup globalVars) { var kb = KnowledgeBase.EvaluateTyped(owner, globalVars); var predicate = Predicate.GetValue(owner, globalVars); var objInferProc = Procedure.EvaluateTyped(owner, globalVars); return(objInferProc.Ask(kb, predicate)); }
public CategoricalDistribution AskBayesianModel(object owner, IContextLookup globalVars) { var randomVariables = BayesianNetwork.GetRandomVariables(owner, globalVars); var network = BayesianNetwork.GetNetwork(randomVariables); var inference = InferenceType.GetInference(); var model = new FiniteBayesModel(network, inference); return(Ask.AskBayesianModel(owner, globalVars, randomVariables, model)); }
protected DefaultPropertyBuildContext(ILookup innerLookup, IContextLookup contextLookup, string prefix, IPropertyMap map, GetInstanceDelegate <TSubject> getInstance, SetInstanceDelegate <TSubject> setInstance, AssignmentPolicy policy) { this.innerLookup = innerLookup; this.map = map; this.prefix = prefix; this.getInstance = getInstance; this.setInstance = setInstance; this.policy = policy; this.contextLookup = contextLookup; }
public GameMoveResult MakeMove(object owner, IContextLookup globalVars) { var moves = MakeMoves(owner, globalVars, 1); if (moves.Count > 0) { return(moves[0]); } return(null); }
public BackPropagation GetLearningMethod(object owner, IContextLookup globalVars, BasicNetwork theNetwork, IList <BasicData> data) { double theLearningRate = LearningRate.GetValue(owner, globalVars); double theMomentum = Momentum.GetValue(owner, globalVars); var theL1 = L1.GetValue(owner, globalVars); var theL2 = L2.GetValue(owner, globalVars); var toReturn = new BackPropagation(theNetwork, data, theLearningRate, theMomentum); toReturn.L1 = theL1; toReturn.L2 = theL2; return(toReturn); }
public Assignment SolveCSP(object owner, IContextLookup globalVars) { var objStrategy = Strategy.EvaluateTyped(owner, globalVars); var objListeners = StateListeners.EvaluateGeneric(owner, globalVars); foreach (KeyValuePair <string, CSPStateListener> keyValuePairListener in objListeners) { objStrategy.addCSPStateListener(keyValuePairListener.Value); globalVars.Items[keyValuePairListener.Key] = keyValuePairListener.Value; } var objCSP = CSP.EvaluateTyped(owner, globalVars); return(objStrategy.solve(objCSP)); }
public object Train(object owner, IContextLookup globalVars) { object theNetwork = Network.EvaluateTyped(owner, globalVars); IEnumerable theData = Data.EvaluateTyped(owner, globalVars); ILearningMethodInfo theLearningMethodInfo = LearningMethod.EvaluateTyped(owner, globalVars); ILearningMethod learningMethod = theLearningMethodInfo.GetLearningMethod(owner, globalVars, theNetwork, theData); IEnumerable theValidationData = ValidationData.EvaluateTyped(owner, globalVars); ITrainingInfo theTrainMode = TrainMode.EvaluateTyped(owner, globalVars); theTrainMode.PerformTraining(learningMethod, theNetwork, theValidationData); return(theNetwork); }
public HiddenMarkovModel GetModel(object owner, IContextLookup globalVars) { var randomVar = StateVariable.GetRandomVariable(owner, globalVars); var transition = TransitionModel.GetMatrix(); var sensor = new HashMap(); foreach (SensorMapRowInfo row in SensorModel) { var value = row.Value.Evaluate(owner, globalVars); var distribution = row.SensorModel.GetMatrix(); sensor.put(value, distribution); } var objPrior = Prior.GetMatrix(); return(new HMM(randomVar, transition, sensor, objPrior)); }
public IDictionary <string, RandomVariable> GetRandomVariables(object owner, IContextLookup globalVars, IDictionary <string, RandomVariable> existingVars) { IDictionary <string, RandomVariable> randomVars = existingVars; if (randomVars == null) { randomVars = new Dictionary <string, RandomVariable>(RandomVariables.Count); } foreach (RandomVariableInfo randomVariableInfo in RandomVariables) { if (!randomVars.ContainsKey(randomVariableInfo.Name)) { randomVars[randomVariableInfo.Name] = randomVariableInfo.GetRandomVariable(owner, globalVars); } } return(randomVars); }
public Problem GetProblem(Object owner, IContextLookup globalVars, Object initialState) { Problem toReturn; var objActionsFunction = ActionsFunction.EvaluateTyped(owner, globalVars); var objResultFunction = ResultFunction.EvaluateTyped(owner, globalVars); var objGoalTest = GoalTest.EvaluateTyped(owner, globalVars); if (StepCostFunction.Enabled) { var objStepCostFunction = StepCostFunction.Entity.EvaluateTyped(owner, globalVars); toReturn = new Problem(initialState, objActionsFunction, objResultFunction, objGoalTest, objStepCostFunction); } else { toReturn = new Problem(initialState, objActionsFunction, objResultFunction, objGoalTest); } return(toReturn); }
public SearchAgentResult PerformSearch(object owner, IContextLookup globalVars) { var objInitialState = InitialState.Evaluate(owner, globalVars); var objProblemInfo = Problem.GetValue(owner, globalVars); var objSearchInfo = Search.GetValue(owner, globalVars); Problem objProblem = objProblemInfo.GetProblem(owner, globalVars, objInitialState); var objHeuristicFunction = HeuristicFunction.Entity.EvaluateTyped(owner, globalVars); if (objHeuristicFunction == null) { objHeuristicFunction = DefaultHeuristics; } var objSearch = objSearchInfo.GetSearch(owner, globalVars, objHeuristicFunction); return(new SearchAgentResult() { Problem = objProblem, SearchAgent = new SearchAgent(objProblem, objSearch) }); }
public CategoricalDistribution AskBayesianModel(object owner, IContextLookup globalVars, IDictionary <string, RandomVariable> randomVariables, FiniteProbabilityModel model) { var priorProps = Prior.Select(objProp => objProp.GetProposition(owner, globalVars, randomVariables)); switch (QueryType) { case BayesianQueryType.Prior: return(model.priorDistribution(priorProps.ToArray())); case BayesianQueryType.Posterior: var posteriorProps = Posteriors.Select(objProp => objProp.GetProposition(owner, globalVars, randomVariables)); return(model.posteriorDistribution(priorProps.ToArray()[0], posteriorProps.ToArray())); case BayesianQueryType.Joint: return(model.jointDistribution((priorProps.ToArray()))); default: throw new ArgumentOutOfRangeException(); } }
public List <AssignmentProposition[][]> AskParticleFiltering(object owner, IContextLookup globalVars) { var randomVars = DynamicBayesianNetwork.GetRandomVariables(owner, globalVars); var model = DynamicBayesianNetwork.GetNetwork(randomVars); Randomizer objRandomizer; switch (RandomizerType) { case RandomizerType.Random: objRandomizer = new JavaRandomizer(); break; case RandomizerType.Mock: objRandomizer = new MockRandomizer(RandomizerValues.ToArray()); break; default: throw new ArgumentOutOfRangeException(); } var objAlgorithm = new ParticleFiltering(SampleNb, (DynamicBayesianNetwork)model, objRandomizer); var objEvidences = new java.util.ArrayList(Evidences.Count); var toReturn = new List <AssignmentProposition[][]>(); foreach (List <PropositionInfo> propositions in Evidences) { var stepEvidences = new List <AssignmentProposition>(propositions.Count); foreach (PropositionInfo proposition in propositions) { stepEvidences.Add((AssignmentProposition)proposition.GetProposition(owner, globalVars, randomVars)); } toReturn.Add(objAlgorithm.particleFiltering(stepEvidences.Cast <AssignmentProposition>().ToArray())); } return(toReturn); }
public IDictionary <string, RandomVariable> GetRandomVariables(object owner, IContextLookup globalVars) { return(GetRandomVariables(owner, globalVars, null)); }
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars) { return(DoForwardBackward(owner, globalVars)); }
public aima.core.search.framework.Search GetSearch(Object owner, IContextLookup globalVars, HeuristicFunction objHeuristicFunction) { aima.core.search.framework.Search toReturn; QueueSearch objQueueSearch; switch (QueueSearchType) { case QueueSearchType.TreeSearch: objQueueSearch = new TreeSearch(); break; default: objQueueSearch = new GraphSearch(); break; } switch (AlgorithmType) { case SearchAlgorithmType.KnownInformed: switch (KnownInformedAlgorithm) { case KnownInformedSearch.GreedyBestFirst: toReturn = new GreedyBestFirstSearch(objQueueSearch, objHeuristicFunction); break; case KnownInformedSearch.RecursiveGreedyBestFirst: toReturn = new RecursiveBestFirstSearch(new GreedyBestFirstEvaluationFunction(objHeuristicFunction)); break; case KnownInformedSearch.RecursiveAStar: toReturn = new RecursiveBestFirstSearch(new AStarEvaluationFunction(objHeuristicFunction)); break; case KnownInformedSearch.HillClimbing: toReturn = new HillClimbingSearch(objHeuristicFunction); break; case KnownInformedSearch.SimulatedAnnealing: toReturn = new SimulatedAnnealingSearch(objHeuristicFunction); break; default: toReturn = new AStarSearch(objQueueSearch, objHeuristicFunction); break; } break; case SearchAlgorithmType.KnownUninformed: switch (KnownUninformedAlgorithm) { case KnownUninformedSearch.DepthFirst: toReturn = new DepthFirstSearch(objQueueSearch); break; case KnownUninformedSearch.DepthLimited: toReturn = new DepthLimitedSearch(DepthLimit); break; case KnownUninformedSearch.IterativeDeepening: toReturn = new IterativeDeepeningSearch(); break; case KnownUninformedSearch.UniformCost: toReturn = new UniformCostSearch(objQueueSearch); break; case KnownUninformedSearch.Bidirectional: toReturn = new BidirectionalSearch(); break; default: toReturn = new BreadthFirstSearch(objQueueSearch); break; } break; default: toReturn = CustomSearchAlgorithm.EvaluateTyped(owner, globalVars); break; } return(toReturn); }
public void Query(object owner, IContextLookup globalVars) { object theNetwork = Network.EvaluateTyped(owner, globalVars); IEnumerable theData = Data.EvaluateTyped(owner, globalVars); }
private void Init(object owner, IContextLookup globalVars, DynamicCSP objCSP) { var objVariables = Variables.EvaluateTyped(owner, globalVars); var dicoVariables = (from object objVariable in objVariables select ReflectionHelper.GetFriendlyName(objVariable)).ToDictionary(varName => varName, varName => new Variable(varName)); foreach (var objVariable in dicoVariables.Values) { objCSP.AddNewVariable(objVariable); } var objDomains = Domains.EvaluateGeneric(owner, globalVars); var dicoDomains = new Dictionary <string, Domain>(); foreach (KeyValuePair <string, IEnumerable> keyValuePair in objDomains) { var domainArray = new ArrayList(); foreach (object domainItem in keyValuePair.Value) { domainArray.Add(domainItem); } Domain domain = new Domain(domainArray.ToArray()); dicoDomains.Add(keyValuePair.Key, domain); } if (dicoDomains.Count == 0) { throw new ApplicationException("No Domain defined for CSP problem"); } if (dicoDomains.Count == 1) { var domain = dicoDomains.Values.First(); Iterator terator = objCSP.getVariables().iterator(); while (terator.hasNext()) { objCSP.setDomain((Variable)terator.next(), domain); } } else { var varDomains = VariableDomains.GetValue(owner, globalVars); foreach (KeyValuePair <string, Variable> varPair in dicoVariables) { string targetDomain; Domain objDomain; if (varDomains.TryGetValue(varPair.Key, out targetDomain) && dicoDomains.TryGetValue(targetDomain, out objDomain)) { objCSP.setDomain(varPair.Value, objDomain); } else { throw new ApplicationException("Incomplete Variables Domain affectation"); } } } var objConstraints = Constraints.EvaluateTyped(owner, globalVars); foreach (Constraint objConstraint in objConstraints) { objCSP.addConstraint(objConstraint); } }
public ILearningMethod GetLearningMethod(object owner, IContextLookup globalVars, object theNetwork, IEnumerable data) { return(GetLearningMethod(owner, globalVars, (BasicNetwork)theNetwork, (IList <BasicData>)data)); }
public void SetNext(IContextLookup next) { this.next = next; }
/// <summary> /// Populates this instance from scratch using a provided selection provider. /// </summary> /// <remarks>This instance will be cleared, and all constraints on it will be reset. /// The builder inspects the first <see cref="IPropertyItemDescriptor{T}"/> from /// <paramref name="selectionProvider"/> and creates an <see cref="IOptionBuilder"/> instance /// that will <see cref="IOptionBuilder.AddItems"/> to this instance via the builder. /// </remarks> /// <param name="selectionProvider"></param> /// <param name="contextLookup">The lookup tunnel through to the created /// <see cref="IOptionBuilderContext"/> that will be used to query the <see cref="IOptionBuilder"/> /// instances for recursive sets of properties.</param> public virtual void BuildFromSelection <T>(ISelectionProvider <T> selectionProvider, IContextLookup contextLookup) { StartContentChange(); try { Clear(); DefaultOptionBuilderContext <T> context; context = new DefaultOptionBuilderContext <T>(selectionProvider, this); context.ContextLookup = contextLookup; ConstraintManager constraintManager = this.Lookup <ConstraintManager>(); if (constraintManager == null) { constraintManager = new ConstraintManager(this); this.SetLookup(typeof(ConstraintManager), constraintManager); } constraintManager.Clear(); IEnumerator <IPropertyItemDescriptor <T> > enumerator = selectionProvider.Selection.GetEnumerator(); if (enumerator.MoveNext()) { IPropertyItemDescriptor <T> descriptor = enumerator.Current; T item; item = descriptor.Item; IOptionBuilder builder = context.GetOptionBuilder(item); if (builder != null) { builder.AddItems(context, item.GetType(), item); } } } finally { EndContentChange(); } }
public abstract List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars);
internal DecoratedBuildContext(ILookup lookup, IContextLookup innerLookup, string prefix, IPropertyMap map, GetInstanceDelegate <TInnerSubject> getHandler, SetInstanceDelegate <TInnerSubject> setHandler, AssignmentPolicy policy) : base(lookup, innerLookup, prefix, map, getHandler, setHandler, policy) { }
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars) { throw new NotImplementedException(); }
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars) { return(AskFixedLagSmoothing(owner, globalVars)); }