Skip to content

Some baseline models

Models to be used as baselines for choice modeling. Nothing smart here.

DistribMimickingModel

Bases: ChoiceModel

Dumb class model that mimicks the probabilities.

It stores the encountered in the train datasets and always returns them

Source code in choice_learn/models/baseline_models.py 
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
class DistribMimickingModel(ChoiceModel):
    """Dumb class model that mimicks the probabilities.

    It stores the encountered in the train datasets and always returns them
    """

    def __init__(self, **kwargs):
        """Initialize of the model."""
        super().__init__(**kwargs)
        self._trainable_weights = []
        self.is_fitted = False

    @property
    def trainable_weights(self):
        """Trainable weights of the model."""
        return [self._trainable_weights]

    def fit(self, choice_dataset, *args, **kwargs):
        """Compute the choice frequency of each product and defines it as choice probabilities.

        Parameters
        ----------
        choice_dataset : ChoiceDataset
            Dataset to be used for fitting
        """
        _ = kwargs
        _ = args
        choices = choice_dataset.choices
        for i in range(choice_dataset.get_n_items()):
            self._trainable_weights.append(tf.reduce_sum(tf.cast(choices == i, tf.float32)))
        self._trainable_weights = tf.stack(self._trainable_weights) / len(choices)
        self.is_fitted = True

    def _fit_with_lbfgs(self, choice_dataset, *args, **kwargs):
        """Compute the choice frequency of each product and defines it as choice probabilities.

        Parameters
        ----------
        choice_dataset : ChoiceDataset
            Dataset to be used for fitting
        """
        _ = kwargs
        _ = args
        choices = choice_dataset.choices
        for i in range(choice_dataset.get_n_items()):
            self._trainable_weights.append(tf.reduce_sum(tf.cast(choices == i, tf.float32)))
        self._trainable_weights = tf.stack(self._trainable_weights) / len(choices)
        self.is_fitted = True

    def compute_batch_utility(
        self,
        shared_features_by_choice,
        items_features_by_choice,
        available_items_by_choice,
        choices,
    ):
        """Return utility that is fixed. U = log(P).

        Parameters
        ----------
        shared_features_by_choice : tuple of np.ndarray (choices_features)
            a batch of shared features
            Shape must be (n_choices, n_shared_features)
        items_features_by_choice : tuple of np.ndarray (choices_items_features)
            a batch of items features
            Shape must be (n_choices, n_items_features)
        available_items_by_choice : np.ndarray
            A batch of items availabilities
            Shape must be (n_choices, n_items)
        choices_batch : np.ndarray
            Choices
            Shape must be (n_choices, )

        Returns
        -------
        np.ndarray (n_choices, n_items)
            Utilities

        Raises
        ------
        ValueError
            If the model has not been fitted cannot evaluate the utility
        """
        # In order to avoid unused arguments warnings
        _ = items_features_by_choice, shared_features_by_choice, available_items_by_choice
        if not self.is_fitted:
            raise ValueError("Model not fitted")
        return tf.stack([tf.math.log(self.trainable_weights[0])] * len(choices), axis=0)

trainable_weights property

Trainable weights of the model.

__init__(**kwargs)

Initialize of the model.

Source code in choice_learn/models/baseline_models.py 
75
76
77
78
79
def __init__(self, **kwargs):
    """Initialize of the model."""
    super().__init__(**kwargs)
    self._trainable_weights = []
    self.is_fitted = False

compute_batch_utility(shared_features_by_choice, items_features_by_choice, available_items_by_choice, choices)

Return utility that is fixed. U = log(P).

Parameters:

Name Type Description Default
shared_features_by_choice tuple of np.ndarray (choices_features)

a batch of shared features Shape must be (n_choices, n_shared_features)

 required
items_features_by_choice tuple of np.ndarray (choices_items_features)

a batch of items features Shape must be (n_choices, n_items_features)

 required
available_items_by_choice ndarray

A batch of items availabilities Shape must be (n_choices, n_items)

 required
choices_batch ndarray

Choices Shape must be (n_choices, )

 required

Returns:

Type Description
ndarray(n_choices, n_items)

Utilities

Raises:

Type Description
ValueError

If the model has not been fitted cannot evaluate the utility
Source code in choice_learn/models/baseline_models.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
def compute_batch_utility(
    self,
    shared_features_by_choice,
    items_features_by_choice,
    available_items_by_choice,
    choices,
):
    """Return utility that is fixed. U = log(P).

    Parameters
    ----------
    shared_features_by_choice : tuple of np.ndarray (choices_features)
        a batch of shared features
        Shape must be (n_choices, n_shared_features)
    items_features_by_choice : tuple of np.ndarray (choices_items_features)
        a batch of items features
        Shape must be (n_choices, n_items_features)
    available_items_by_choice : np.ndarray
        A batch of items availabilities
        Shape must be (n_choices, n_items)
    choices_batch : np.ndarray
        Choices
        Shape must be (n_choices, )

    Returns
    -------
    np.ndarray (n_choices, n_items)
        Utilities

    Raises
    ------
    ValueError
        If the model has not been fitted cannot evaluate the utility
    """
    # In order to avoid unused arguments warnings
    _ = items_features_by_choice, shared_features_by_choice, available_items_by_choice
    if not self.is_fitted:
        raise ValueError("Model not fitted")
    return tf.stack([tf.math.log(self.trainable_weights[0])] * len(choices), axis=0)

fit(choice_dataset, *args, **kwargs)

Compute the choice frequency of each product and defines it as choice probabilities.

Parameters:

Name Type Description Default
choice_dataset ChoiceDataset

Dataset to be used for fitting

 required
Source code in choice_learn/models/baseline_models.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def fit(self, choice_dataset, *args, **kwargs):
    """Compute the choice frequency of each product and defines it as choice probabilities.

    Parameters
    ----------
    choice_dataset : ChoiceDataset
        Dataset to be used for fitting
    """
    _ = kwargs
    _ = args
    choices = choice_dataset.choices
    for i in range(choice_dataset.get_n_items()):
        self._trainable_weights.append(tf.reduce_sum(tf.cast(choices == i, tf.float32)))
    self._trainable_weights = tf.stack(self._trainable_weights) / len(choices)
    self.is_fitted = True

RandomChoiceModel

Bases: ChoiceModel

Dumb model that randomly attributes utilities to products.

Source code in choice_learn/models/baseline_models.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class RandomChoiceModel(ChoiceModel):
    """Dumb model that randomly attributes utilities to products."""

    def __init__(self, **kwargs):
        """Initialize of the model."""
        super().__init__(**kwargs)

    @property
    def trainable_weights(self):
        """Return an empty list - there is no trainable weight."""
        return []

    def compute_batch_utility(
        self,
        shared_features_by_choice,
        items_features_by_choice,
        available_items_by_choice,
        choices,
    ):
        """Compute the random utility for each product of each choice.

        Parameters
        ----------
        shared_features_by_choice : tuple of np.ndarray (choices_features)
            a batch of shared features
            Shape must be (n_choices, n_shared_features)
        items_features_by_choice : tuple of np.ndarray (choices_items_features)
            a batch of items features
            Shape must be (n_choices, n_items_features)
        available_items_by_choice : np.ndarray
            A batch of items availabilities
            Shape must be (n_choices, n_items)
        choices_batch : np.ndarray
            Choices
            Shape must be (n_choices, )

        Returns
        -------
        tf.Tensor
            (n_choices, n_items) matrix of random utilities
        """
        # In order to avoid unused arguments warnings
        _ = shared_features_by_choice, items_features_by_choice, choices
        return np.squeeze(
            np.random.uniform(size=(available_items_by_choice.shape), low=0.0, high=1.0)
        ).astype(np.float32)

    def fit(self, *args, **kwargs):
        """Make sure that nothing happens during .fit."""
        _ = kwargs
        _ = args
        return {}

    def _fit_with_lbfgs(self, *args, **kwargs):
        """Make sure that nothing happens during .fit."""
        _ = kwargs
        _ = args
        return {}

trainable_weights property

Return an empty list - there is no trainable weight.

__init__(**kwargs)

Initialize of the model.

Source code in choice_learn/models/baseline_models.py 
12
13
14
def __init__(self, **kwargs):
    """Initialize of the model."""
    super().__init__(**kwargs)

compute_batch_utility(shared_features_by_choice, items_features_by_choice, available_items_by_choice, choices)

Compute the random utility for each product of each choice.

Parameters:

Name Type Description Default
shared_features_by_choice tuple of np.ndarray (choices_features)

a batch of shared features Shape must be (n_choices, n_shared_features)

 required
items_features_by_choice tuple of np.ndarray (choices_items_features)

a batch of items features Shape must be (n_choices, n_items_features)

 required
available_items_by_choice ndarray

A batch of items availabilities Shape must be (n_choices, n_items)

 required
choices_batch ndarray

Choices Shape must be (n_choices, )

 required

Returns:

Type Description
Tensor

(n_choices, n_items) matrix of random utilities
Source code in choice_learn/models/baseline_models.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def compute_batch_utility(
    self,
    shared_features_by_choice,
    items_features_by_choice,
    available_items_by_choice,
    choices,
):
    """Compute the random utility for each product of each choice.

    Parameters
    ----------
    shared_features_by_choice : tuple of np.ndarray (choices_features)
        a batch of shared features
        Shape must be (n_choices, n_shared_features)
    items_features_by_choice : tuple of np.ndarray (choices_items_features)
        a batch of items features
        Shape must be (n_choices, n_items_features)
    available_items_by_choice : np.ndarray
        A batch of items availabilities
        Shape must be (n_choices, n_items)
    choices_batch : np.ndarray
        Choices
        Shape must be (n_choices, )

    Returns
    -------
    tf.Tensor
        (n_choices, n_items) matrix of random utilities
    """
    # In order to avoid unused arguments warnings
    _ = shared_features_by_choice, items_features_by_choice, choices
    return np.squeeze(
        np.random.uniform(size=(available_items_by_choice.shape), low=0.0, high=1.0)
    ).astype(np.float32)

fit(*args, **kwargs)

Make sure that nothing happens during .fit.

Source code in choice_learn/models/baseline_models.py 
56
57
58
59
60
def fit(self, *args, **kwargs):
    """Make sure that nothing happens during .fit."""
    _ = kwargs
    _ = args
    return {}