public Model( IModelParameters parameters, IModelDependencies dependencies ) { this.InitializePrivateProperties( parameters, dependencies ); this.InitializePublicProperties(); this.RegisterToPropertyChangedEvents(); }
/// <summary> /// Initializes a new instance of the <see cref="RandomModel" /> class. /// </summary> /// <param name="parameters">The parameters.</param> public RandomModel(IModelParameters parameters) { this.Parameters = (RandomModelParameters)parameters; this.OutcomeDistribution = new Discrete( 1 - this.Parameters.EmpiricalDrawProportion, this.Parameters.EmpiricalDrawProportion, 1 - this.Parameters.EmpiricalDrawProportion); }
/// <summary> /// Initializes a new instance of the <see cref="MultiPlayer" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> /// <param name="trainingModel">if set to <c>true</c> [training model].</param> public MultiPlayer(IModelParameters parameters, bool showFactorGraph = false, bool trainingModel = true) : base(parameters) { //The factor graph of this model slightly differs from the one from the book //because this model is generic and uses arrays to support any number of players. this.numberOfPlayers = Variable.New <int>().Named("numberOfPlayers").Attrib(new DoNotInfer()); var dynamicsVariance = Variable.Observed(this.Parameters.DynamicsVariance).Named("dynamicsVariance"); var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); Range player = new Range(this.numberOfPlayers).Named("player"); this.playersPerGame = Variable.New <int>().Named("playersPerGame").Attrib(new DoNotInfer()); Range gamePlayer = new Range(this.playersPerGame).Named("gamePlayer"); this.skillPriors = Variable.Array <Gaussian>(player).Named("skillPriors").Attrib(new DoNotInfer()); this.skills = Variable.Array <double>(player).Named("skills"); this.skills[player] = Variable.GaussianFromMeanAndVariance(Variable <double> .Random(this.skillPriors[player]), dynamicsVariance); this.drawMargin = Variable.New <double>().Named("drawMargin"); this.drawMarginPrior = Variable.New <Gaussian>().Named("drawMarginPrior"); this.drawMargin.SetTo(Variable <double> .Random(this.drawMarginPrior)); Variable.ConstrainTrue(this.drawMargin > 0); this.playerIndices = Variable.Array <int>(gamePlayer).Named("playerIndices").Attrib(new DoNotInfer()); this.performances = Variable.Array <double>(gamePlayer).Named("performances"); var gameSkills = Variable.Subarray(this.skills, this.playerIndices).Named("gameSkills"); if (trainingModel) { this.scores = Variable.Array <int>(gamePlayer).Named("scores").Attrib(new DoNotInfer()); } using (ForEachBlock gp = Variable.ForEach(gamePlayer)) { this.performances[gamePlayer] = Variable.GaussianFromMeanAndVariance(gameSkills[gamePlayer], performanceVariance); if (trainingModel) { using (Variable.If(gp.Index > 0)) { var diff = (this.performances[gp.Index - 1] - this.performances[gp.Index]).Named("diff"); using (Variable.If(this.scores[gp.Index - 1] == this.scores[gp.Index])) { Variable.ConstrainBetween(diff, -this.drawMargin, this.drawMargin); } using (Variable.IfNot(this.scores[gp.Index - 1] == this.scores[gp.Index])) { Variable.ConstrainTrue(diff > this.drawMargin); } } } } this.engine = Utils.GetDefaultEngine(showFactorGraph); }
/// <summary> /// Construct a field updated for the given surface. /// </summary> /// <param name="surface"></param> /// <param name="options"></param> public PrognosticFieldsUpdater(IPolyhedron surface, IModelParameters options) { _options = options; _coriolisField = SimulationUtilities.CoriolisField(surface, _options.RotationFrequency); _faceNormalsField = SimulationUtilities.FaceNormalsField(surface); _vertexNormalsField = SimulationUtilities.VertexNormalsField(surface); _operators = new VectorFieldOperators(surface); _gravity = options.Gravity; }
public IProbabilityFunction Build(IModelParameters parameters) { if (parameters.GetType() == typeof (ThreeParamModelParameters)) { return new ThreeParamProbabilityFunction((ThreeParamModelParameters)parameters); } if (parameters.GetType() == typeof(TwoParamModelParameters)) { return new TwoParamProbabilityFunction((TwoParamModelParameters)parameters); } throw new NotImplementedException(); }
public IItemInformationFunction Build(IModelParameters modelParameters) { if (modelParameters.GetType() == typeof (TwoParamModelParameters)) { return new TwoParamItemInformationFunction((TwoParamModelParameters) modelParameters); } if (modelParameters.GetType() == typeof(ThreeParamModelParameters)) { return new ThreeParamItemInformationFunction((ThreeParamModelParameters) modelParameters); } throw new NotImplementedException(); }
/// <summary> /// Initializes a new instance of the <see cref="TwoPlayerWithDraws" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> public TwoPlayerWithDraws(IModelParameters parameters, bool showFactorGraph = false) : base(parameters) { var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); this.drawMargin = Variable.New <double>().Named("drawMargin"); this.drawMarginPrior = Variable.New <Gaussian>().Named("drawMarginPrior"); this.drawMargin.SetTo(Variable <double> .Random(this.drawMarginPrior)); Variable.ConstrainTrue(this.drawMargin > 0); this.skill1Prior = Variable.New <Gaussian>().Named("JSkillPrior").Attrib(new DoNotInfer()); this.skill2Prior = Variable.New <Gaussian>().Named("FSkillPrior").Attrib(new DoNotInfer()); this.player1skill = Variable.New <double>().Named("JSkill"); this.player2skill = Variable.New <double>().Named("FSkill"); player1skill.SetTo(Variable.Random <double, Gaussian>(skill1Prior)); player2skill.SetTo(Variable.Random <double, Gaussian>(skill2Prior)); var player1Performance = Variable.GaussianFromMeanAndVariance(player1skill, performanceVariance).Named("JPerf"); var player2Performance = Variable.GaussianFromMeanAndVariance(player2skill, performanceVariance).Named("FPerf"); var diff = (player1Performance - player2Performance).Named("diff"); this.outcome = Variable.DiscreteUniform(3).Named("outcome"); // The WinLoseDraw factor implemented using a constraint that's why it looks different in the factor graph viewer comparing to the book. using (Variable.Case(this.outcome, 0)) { // player 1 wins Variable.ConstrainTrue(diff > this.drawMargin); } using (Variable.Case(this.outcome, 1)) { // draw Variable.ConstrainBetween(diff, -this.drawMargin, this.drawMargin); } using (Variable.Case(this.outcome, 2)) { // player 2 wins Variable.ConstrainTrue(diff < -this.drawMargin); } this.engine = Utils.GetDefaultEngine(showFactorGraph); }
public IItemInformationFunction Build(IModelParameters modelParameters) { if (modelParameters.GetType() == typeof(TwoParamModelParameters)) { return(new TwoParamItemInformationFunction((TwoParamModelParameters)modelParameters)); } if (modelParameters.GetType() == typeof(ThreeParamModelParameters)) { return(new ThreeParamItemInformationFunction((ThreeParamModelParameters)modelParameters)); } if (modelParameters.GetType() == typeof(FourParamModelParameters)) { return(new FourParamItemInformationFunction((FourParamModelParameters)modelParameters)); } throw new NotImplementedException(); }
public IProbabilityFunction Build(IModelParameters parameters) { if (parameters.GetType() == typeof(FourParamModelParameters)) { return(new FourParamProbabilityFunction((FourParamModelParameters)parameters)); } if (parameters.GetType() == typeof(ThreeParamModelParameters)) { return(new ThreeParamProbabilityFunction((ThreeParamModelParameters)parameters)); } if (parameters.GetType() == typeof(TwoParamModelParameters)) { return(new TwoParamProbabilityFunction((TwoParamModelParameters)parameters)); } throw new NotImplementedException(); }
/// <summary> /// Initializes a new instance of the <see cref="TwoPlayerVaryingSkills" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> public TwoPlayerVaryingSkills(IModelParameters parameters, bool showFactorGraph = false) : base(parameters) { var dynamicsVariance = Variable.Observed(this.Parameters.DynamicsVariance).Named("dynamicsVariance"); var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); this.skill1Prior = Variable.New <Gaussian>().Named("skill1Prior").Attrib(new DoNotInfer()); this.skill2Prior = Variable.New <Gaussian>().Named("skill2Prior").Attrib(new DoNotInfer()); this.player1skill = Variable.GaussianFromMeanAndVariance(Variable <double> .Random(skill1Prior), dynamicsVariance).Named("player1skill"); this.player2skill = Variable.GaussianFromMeanAndVariance(Variable <double> .Random(skill2Prior), dynamicsVariance).Named("player2skill"); var player1Performance = Variable.GaussianFromMeanAndVariance(player1skill, performanceVariance).Named("player1Performance"); var player2Performance = Variable.GaussianFromMeanAndVariance(player2skill, performanceVariance).Named("player2Performance"); this.outcome = (player1Performance > player2Performance).Named("player1wins"); this.engine = Utils.GetDefaultEngine(showFactorGraph); }
/// <summary> /// Initializes a new instance of the <see cref="TwoPlayer" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> public TwoPlayer(IModelParameters parameters, bool showFactorGraph = false) : base(parameters) { var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); this.skill1Prior = Variable.New <Gaussian>().Named("JSkillPrior").Attrib(new DoNotInfer()); this.skill2Prior = Variable.New <Gaussian>().Named("FSkillPrior").Attrib(new DoNotInfer()); this.player1skill = Variable.New <double>().Named("JSkill"); this.player2skill = Variable.New <double>().Named("FSkill"); player1skill.SetTo(Variable.Random <double, Gaussian>(skill1Prior)); player2skill.SetTo(Variable.Random <double, Gaussian>(skill2Prior)); var player1Performance = Variable.GaussianFromMeanAndVariance(player1skill, performanceVariance).Named("JPerf"); var player2Performance = Variable.GaussianFromMeanAndVariance(player2skill, performanceVariance).Named("FPerf"); this.outcome = (player1Performance > player2Performance).Named("JWins"); this.engine = Utils.GetDefaultEngine(showFactorGraph); }
// The standard error of estimate (SEE) for the location parameter theta. The general formula is given by (2.11) on page 28. public double Calculate(List <QuestionInfo> questionHistory, double theta) { List <IModelParameters> modelParametersList = questionHistory.Select(x => x.Question.ModelParameters).ToList(); List <int> responseVector = questionHistory.Select(x => (int)x.Score).ToList(); double sum = 0; for (int i = 0; i < responseVector.Count; i++) { IModelParameters modelParameters = modelParametersList[i]; IProbabilityFunction probabilityFunction = _probabilityFunctionFactory.Build(modelParameters); double p = probabilityFunction.ProbabilityOfCorrectResponse(theta); double pPrime = probabilityFunction.FirstThetaDerivative(theta); sum += pPrime * pPrime / (p * (1 - p)); } return(1 / Math.Sqrt(sum)); }
private void InitializePrivateProperties( IModelParameters parameters, IModelDependencies dependencies ) { this._isInstalled = parameters.IsInstalled; this._osConfigModelFactory = dependencies.OsConfigurationModelFactory; this._programInfoVM = parameters.ProgramInfoVM; var definitionParams = new Win32.Model.DefinitionParametersDTO { ApplicationInfo = this._programInfoVM.ApplicationInfo, OsConfigurationInfos = this._programInfoVM.OsConfigs }; this._definition = dependencies.DefinitionFactory.Get( definitionParams ); }
/// <summary> /// Creates a simulation on the given surface using the given initial fields & options. /// </summary> /// <param name="surface"></param> /// <param name="initialFields"></param> /// <param name="options"></param> public SimulationRunner(IPolyhedron surface, PrognosticFields initialFields, IModelParameters options) { _fieldUpdater = new PrognosticFieldsUpdater(surface, options); _initialFields = initialFields; CurrentFields = initialFields; }
/// <summary> /// Initializes a new instance of the <see cref="OnlineExperiment"/> class. /// </summary> /// <param name="modelFunc">The model function.</param> /// <param name="modelParameters">The model parameters.</param> public OnlineExperiment(Func <IModelParameters, bool, bool, IModel> modelFunc, IModelParameters modelParameters) { this.TrainModel = modelFunc(modelParameters, false, true); this.PredictModel = modelFunc(modelParameters, false, false); }
/// <summary> /// Initializes a new instance of the <see cref="OnlineExperiment"/> class. /// </summary> /// <param name="modelFunc">The model function.</param> /// <param name="modelParameters">The model parameters.</param> public OnlineExperiment(Func <IModelParameters, IModel> modelFunc, IModelParameters modelParameters) { this.TrainModel = modelFunc(modelParameters); this.PredictModel = modelFunc(modelParameters); }
/// <summary> /// Initializes a new instance of the <see cref="ModelBase"/> class. /// </summary> /// <param name="parameters">The parameters.</param> protected ModelBase(IModelParameters parameters) { this.Parameters = (TrueSkillParameters)parameters; }
/// <summary> /// Initializes a new instance of the <see cref="TwoTeam" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> public TwoTeam(IModelParameters parameters, bool showFactorGraph = false) : base(parameters) { this.numberOfPlayers = Variable.New<int>().Named("numberOfPlayers").Attrib(new DoNotInfer()); var dynamicsVariance = Variable.Observed(this.Parameters.DynamicsVariance).Named("dynamicsVariance"); var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); Range player = new Range(this.numberOfPlayers).Named("player"); this.team1Count = Variable.New<int>().Named("team1Count").Attrib(new DoNotInfer()); Range team1Player = new Range(this.team1Count).Named("team1Player"); this.team2Count = Variable.New<int>().Named("team2Count").Attrib(new DoNotInfer()); Range team2Player = new Range(this.team2Count).Named("team2Player"); this.skillPriors = Variable.Array<Gaussian>(player).Named("skillPriors").Attrib(new DoNotInfer()); this.skills = Variable.Array<double>(player).Named("skills"); this.skills[player] = Variable.GaussianFromMeanAndVariance(Variable<double>.Random(this.skillPriors[player]), dynamicsVariance); this.drawMargin = Variable.New<double>().Named("drawMargin"); this.drawMarginPrior = Variable.New<Gaussian>().Named("drawMarginPrior"); this.drawMargin.SetTo(Variable<double>.Random(this.drawMarginPrior)); Variable.ConstrainTrue(this.drawMargin > 0); this.team1Players = Variable.Array<int>(team1Player).Named("team1Players").Attrib(new DoNotInfer()); this.team2Players = Variable.Array<int>(team2Player).Named("team2Players").Attrib(new DoNotInfer()); var team1Skills = Variable.Subarray(this.skills, this.team1Players).Named("team1Skills"); var team2Skills = Variable.Subarray(this.skills, this.team2Players).Named("team2Skills"); var team1Performances = Variable.Array<double>(team1Player).Named("team1Performances"); team1Performances[team1Player] = Variable.GaussianFromMeanAndVariance(team1Skills[team1Player], performanceVariance); var team1Performance = Variable.Sum(team1Performances).Named("team1Performance"); var team2Performances = Variable.Array<double>(team2Player).Named("team2Performances"); team2Performances[team2Player] = Variable.GaussianFromMeanAndVariance(team2Skills[team2Player], performanceVariance); var team2Performance = Variable.Sum(team2Performances).Named("team2Performance"); this.outcome = Variable.DiscreteUniform(3).Named("outcome"); var diff = (team1Performance - team2Performance).Named("diff"); using (Variable.Case(this.outcome, 0)) { // player 1 wins Variable.ConstrainTrue(diff > this.drawMargin); } using (Variable.Case(this.outcome, 1)) { // draw Variable.ConstrainBetween(diff, -this.drawMargin, this.drawMargin); } using (Variable.Case(this.outcome, 2)) { // player 2 wins Variable.ConstrainTrue(diff < -this.drawMargin); } this.engine = Utils.GetDefaultEngine(showFactorGraph); }