def construct_model(self, X, Y): """ Constructs the nested logit model by applying priors on weight vectors **weights** and **weights_k** as per :meth:`model_configuration`. Then we apply a uniform prior to the :math:`\\lambda s`, i.e. :math:`\\lambda s \\sim Uniform(\\text{alpha}, 1.0)`.The probability of choosing the object :math:`x_i` from the query set :math:`Q = \\{x_1, \\ldots ,x_n\\}` is evaluated in :meth:`get_probabilities`. Parameters ---------- X : numpy array (n_instances, n_objects, n_features) Feature vectors of the objects Y : numpy array (n_instances, n_objects) Preferences in the form of discrete choices for given objects Returns ------- model : pymc3 Model :class:`pm.Model` """ self.trace_ = None self.trace_vi_ = None self.random_state_ = check_random_state(self.random_state) self.loss_function_ = likelihood_dict.get(self.loss_function, None) self.threshold_ = 43e5 if np.prod(X.shape) > self.threshold_: upper_bound = int(self.threshold_ / np.prod(X.shape[1:])) indices = self.random_state_.choice(X.shape[0], upper_bound, replace=False) X = X[indices, :, :] Y = Y[indices, :] logger.info( "Train Set instances {} objects {} features {}".format(*X.shape)) with pm.Model() as self.model: self.Xt_ = theano.shared(X) self.Yt_ = theano.shared(Y) shapes = { "weights": self.n_object_features_fit_, "weights_ik": (self.n_object_features_fit_, self.n_nests), } weights_dict = create_weight_dictionary(self.model_configuration, shapes) alpha_ik = tt.dot(self.Xt_, weights_dict["weights_ik"]) alpha_ik = ttu.softmax(alpha_ik, axis=2) utility = tt.dot(self.Xt_, weights_dict["weights"]) lambda_k = pm.Uniform("lambda_k", self.alpha, 1.0, shape=self.n_nests) self.p_ = self.get_probabilities(utility, lambda_k, alpha_ik) LogLikelihood("yl", loss_func=self.loss_function_, p=self.p_, observed=self.Yt_) logger.info("Model construction completed")
def construct_model(self, X, Y): with pm.Model() as self.model: self.Xt = theano.shared(X) self.Yt = theano.shared(Y) shapes = {'weights': (self.n_object_features, self.n_mixtures)} weights_dict = create_weight_dictionary(self.model_priors, shapes) utility = tt.dot(self.Xt, weights_dict['weights']) self.p = tt.mean(ttu.softmax(utility, axis=1), axis=2) yl = LogLikelihood('yl', loss_func=self.loss_function, p=self.p, observed=self.Yt) self.logger.info("Model construction completed")
def construct_model(self, X, Y): """ Constructs the nested logit model by applying priors on weight vectors **weights** and **weights_k** as per :meth:`model_configuration`. Then we apply a uniform prior to the :math:`\\lambda s`, i.e. :math:`\\lambda s \\sim Uniform(\\text{alpha}, 1.0)`.The probability of choosing the object :math:`x_i` from the query set :math:`Q = \\{x_1, \\ldots ,x_n\\}` is evaluated in :meth:`get_probabilities`. Parameters ---------- X : numpy array (n_instances, n_objects, n_features) Feature vectors of the objects Y : numpy array (n_instances, n_objects) Preferences in the form of discrete choices for given objects Returns ------- model : pymc3 Model :class:`pm.Model` """ if np.prod(X.shape) > self.threshold: l = int(self.threshold / np.prod(X.shape[1:])) indices = self.random_state.choice(X.shape[0], l, replace=False) X = X[indices, :, :] Y = Y[indices, :] self.logger.info( "Train Set instances {} objects {} features {}".format(*X.shape)) with pm.Model() as self.model: self.Xt = theano.shared(X) self.Yt = theano.shared(Y) shapes = { 'weights': self.n_object_features, 'weights_ik': (self.n_object_features, self.n_nests) } weights_dict = create_weight_dictionary(self.model_configuration, shapes) alpha_ik = tt.dot(self.Xt, weights_dict['weights_ik']) alpha_ik = ttu.softmax(alpha_ik, axis=2) utility = tt.dot(self.Xt, weights_dict['weights']) lambda_k = pm.Uniform('lambda_k', self.alpha, 1.0, shape=self.n_nests) self.p = self.get_probabilities(utility, lambda_k, alpha_ik) yl = LogLikelihood('yl', loss_func=self.loss_function, p=self.p, observed=self.Yt) self.logger.info("Model construction completed")
def construct_model(self, X, Y): self.logger.info('Creating model_args config {}'.format( print_dictionary(self.model_priors))) with pm.Model() as self.model: self.Xt = theano.shared(X) self.Yt = theano.shared(Y) shapes = {'weights': self.n_object_features} # shapes = {'weights': (self.n_object_features, 3)} weights_dict = create_weight_dictionary(self.model_args, shapes) intercept = pm.Normal('intercept', mu=0, sd=10) utility = tt.dot(self.Xt, weights_dict['weights']) + intercept self.p = ttu.softmax(utility, axis=1) yl = LogLikelihood('yl', loss_func=self.loss_function, p=self.p, observed=self.Yt) self.logger.info("Model construction completed")
def construct_model(self, X, Y): """ Constructs the multinomial logit model which evaluated the utility score as :math:`U(x) = w \\cdot x`, where :math:`w` is the weight vector. The probability of choosing the object :math:`x_i` from the query set :math:`Q = \\{x_1, \\ldots ,x_n\\}` is: .. math:: P_i = P(x_i \\lvert Q) = \\frac{exp(U(x_i))}{\\sum_{x_j \\in Q} exp(U(x_j))} Parameters ---------- X : numpy array (n_instances, n_objects, n_features) Feature vectors of the objects Y : numpy array (n_instances, n_objects) Preferences in the form of discrete choices for given objects Returns ------- model : pymc3 Model :class:`pm.Model` """ self.trace_ = None self.trace_vi_ = None logger.info("Creating model_args config {}".format( print_dictionary(self.model_configuration))) self.loss_function_ = likelihood_dict.get(self.loss_function, None) with pm.Model() as self.model: self.Xt_ = theano.shared(X) self.Yt_ = theano.shared(Y) shapes = {"weights": self.n_object_features_fit_} # shapes = {'weights': (self.n_object_features_fit_, 3)} weights_dict = create_weight_dictionary(self.model_configuration, shapes) intercept = pm.Normal("intercept", mu=0, sd=10) utility = tt.dot(self.Xt_, weights_dict["weights"]) + intercept self.p_ = ttu.softmax(utility, axis=1) LogLikelihood("yl", loss_func=self.loss_function_, p=self.p_, observed=self.Yt_) logger.info("Model construction completed")
def construct_model(self, X, Y): """ Constructs the mixed logit model by applying priors on weight vectors **weights** as per :meth:`model_configuration`. The probability of choosing the object :math:`x_i` from the query set :math:`Q = \\{x_1, \\ldots ,x_n\\}` assuming we draw :math:`R` samples of the weight vectors is: .. math:: P(x_i \\lvert Q) = \\frac{1}{R} \\sum_{r=1}^R \\frac{exp(U_r(x_i))}{\\sum_{x_j \\in Q} exp(U_r(x_j))} Parameters ---------- X : numpy array (n_instances, n_objects, n_features) Feature vectors of the objects Y : numpy array (n_instances, n_objects) Preferences in the form of discrete choices for given objects Returns ------- model : pymc3 Model :class:`pm.Model` """ self.trace_ = None self.trace_vi = None self.loss_function_ = likelihood_dict.get(self.loss_function, None) with pm.Model() as self.model: self.Xt_ = theano.shared(X) self.Yt_ = theano.shared(Y) shapes = { "weights": (self.n_object_features_fit_, self.n_mixtures) } weights_dict = create_weight_dictionary(self.model_configuration, shapes) utility = tt.dot(self.Xt_, weights_dict["weights"]) self.p_ = tt.mean(ttu.softmax(utility, axis=1), axis=2) LogLikelihood("yl", loss_func=self.loss_function_, p=self.p_, observed=self.Yt_) logger.info("Model construction completed")
def construct_model(self, X, Y): with pm.Model() as self.model: self.Xt = theano.shared(X) self.Yt = theano.shared(Y) shapes = { 'weights': self.n_object_features, 'weights_ik': (self.n_object_features, self.n_nests) } weights_dict = create_weight_dictionary(self.model_priors, shapes) alpha_ik = tt.dot(self.Xt, weights_dict['weights_ik']) alpha_ik = ttu.softmax(alpha_ik, axis=2) utility = tt.dot(self.Xt, weights_dict['weights']) lambda_k = pm.Uniform('lambda_k', self.alpha, 1.0, shape=self.n_nests) self.p = self.get_probabilities(utility, lambda_k, alpha_ik) yl = LogLikelihood('yl', loss_func=self.loss_function, p=self.p, observed=self.Yt) self.logger.info("Model construction completed")