public Model( IModelParameters parameters, 
               IModelDependencies dependencies )
 {
     this.InitializePrivateProperties( parameters, dependencies );
     this.InitializePublicProperties();
     this.RegisterToPropertyChangedEvents();
 }
Example #2
0
 /// <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);
 }
Example #3
0
        /// <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);
        }
Example #4
0
        /// <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();
        }
Example #9
0
        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);
        }
Example #11
0
        /// <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));
        }
Example #13
0
        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 );
        }
Example #14
0
 /// <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);
 }
Example #17
0
 /// <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;
 }
Example #18
0
        /// <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);
        }