Skip to content

Features Storage

Different classes to optimize RAM usage with repeated features over time.

ArrayStorage

Bases: Storage

Function to store features with ids as NumPy Array.

Source code in choice_learn/data/storage.py 
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
class ArrayStorage(Storage):
    """Function to store features with ids as NumPy Array."""

    def __init__(self, values=None, values_names=None, name=None):
        """Build the store.

        Parameters
        ----------
        values : array_like
            list of values of features to store
        values_names : array_like
            Iterable of str indicating the name of the features. Must be same length as values.
        name: string, optional
            name of the features store
        """
        if isinstance(values, list):
            storage = np.array(values)
        elif not isinstance(values, np.ndarray):
            raise ValueError("ArrayStorage Values must be a list or a numpy array")

        # self.storage = storage
        self.values_names = values_names
        self.name = name

        self.shape = storage.shape
        self.indexer = storage

    def get_element_from_index(self, index):
        """Getter method over self.sequence.

        Returns the features stored at index index. Compared to __getitem__, it does take
        the index-th element of sequence but the index-th element of the store.

        Parameters
        ----------
        index : (int, list, slice)
            index argument of the feature

        Returns
        -------
        array_like
            features corresponding to the index index in self.store
        """
        return self.batch[index]

    def __len__(self):
        """Return the length of the sequence of apparition of the features."""
        return self.shape[0]

    def __getitem__(self, id_keys):
        """Subset FeaturesStorage, keeping only features which id is in keys.

        Parameters
        ----------
        id_keys : Iterable
            List of ids to keep.

        Returns
        -------
        FeaturesStorage
            Subset of the FeaturesStorage, with only the features whose id is in id_keys
        """
        if not isinstance(id_keys, list):
            id_keys = [id_keys]
        return ArrayStorage(
            values=self.batch[id_keys], values_names=self.values_names, name=self.name
        )

    def get_storage_type(self):
        """Functions to access stored elements dtypes.

        Returns
        -------
        tuple
            tuple of dtypes of the stored elements, as returned by np.dtype
        """
        element = self.get_element_from_index(0)
        return element.dtype

    @property
    def batch(self):
        """Indexing attribute."""
        return self.indexer

batch property

Indexing attribute.

__getitem__(id_keys)

Subset FeaturesStorage, keeping only features which id is in keys.

Parameters:

Name Type Description Default
id_keys Iterable

List of ids to keep.

 required

Returns:

Type Description
FeaturesStorage

Subset of the FeaturesStorage, with only the features whose id is in id_keys
Source code in choice_learn/data/storage.py 
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
def __getitem__(self, id_keys):
    """Subset FeaturesStorage, keeping only features which id is in keys.

    Parameters
    ----------
    id_keys : Iterable
        List of ids to keep.

    Returns
    -------
    FeaturesStorage
        Subset of the FeaturesStorage, with only the features whose id is in id_keys
    """
    if not isinstance(id_keys, list):
        id_keys = [id_keys]
    return ArrayStorage(
        values=self.batch[id_keys], values_names=self.values_names, name=self.name
    )

__init__(values=None, values_names=None, name=None)

Build the store.

Parameters:

Name Type Description Default
values array_like

list of values of features to store

 None
values_names array_like

Iterable of str indicating the name of the features. Must be same length as values.

 None
name

name of the features store

 None
Source code in choice_learn/data/storage.py 
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
def __init__(self, values=None, values_names=None, name=None):
    """Build the store.

    Parameters
    ----------
    values : array_like
        list of values of features to store
    values_names : array_like
        Iterable of str indicating the name of the features. Must be same length as values.
    name: string, optional
        name of the features store
    """
    if isinstance(values, list):
        storage = np.array(values)
    elif not isinstance(values, np.ndarray):
        raise ValueError("ArrayStorage Values must be a list or a numpy array")

    # self.storage = storage
    self.values_names = values_names
    self.name = name

    self.shape = storage.shape
    self.indexer = storage

__len__()

Return the length of the sequence of apparition of the features.

Source code in choice_learn/data/storage.py 
275
276
277
def __len__(self):
    """Return the length of the sequence of apparition of the features."""
    return self.shape[0]

get_element_from_index(index)

Getter method over self.sequence.

Returns the features stored at index index. Compared to getitem, it does take the index-th element of sequence but the index-th element of the store.

Parameters:

Name Type Description Default
index (int, list, slice)

index argument of the feature

 required

Returns:

Type Description
array_like

features corresponding to the index index in self.store
Source code in choice_learn/data/storage.py 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
def get_element_from_index(self, index):
    """Getter method over self.sequence.

    Returns the features stored at index index. Compared to __getitem__, it does take
    the index-th element of sequence but the index-th element of the store.

    Parameters
    ----------
    index : (int, list, slice)
        index argument of the feature

    Returns
    -------
    array_like
        features corresponding to the index index in self.store
    """
    return self.batch[index]

get_storage_type()

Functions to access stored elements dtypes.

Returns:

Type Description
tuple

tuple of dtypes of the stored elements, as returned by np.dtype
Source code in choice_learn/data/storage.py 
298
299
300
301
302
303
304
305
306
307
def get_storage_type(self):
    """Functions to access stored elements dtypes.

    Returns
    -------
    tuple
        tuple of dtypes of the stored elements, as returned by np.dtype
    """
    element = self.get_element_from_index(0)
    return element.dtype

DictStorage

Bases: Storage

Function to store features with ids.

Source code in choice_learn/data/storage.py 
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
class DictStorage(Storage):
    """Function to store features with ids."""

    def __init__(
        self,
        ids=None,
        values=None,
        values_names=None,
        name=None,
        indexer=StorageIndexer,
    ):
        """Build the store.

        Parameters
        ----------
        ids : array_like or None
            list of ids of features to store. If None is given, ids are created from
            apparition order of values
        values : array_like
            list of values of features to store
        values_names : array_like
            Iterable of str indicating the name of the features. Must be same length as values.
        name: string, optional
            name of the features store
        """
        print("DictStorage")
        if isinstance(values, dict):
            storage = values
            lengths = []
            for k, v in storage.items():
                if not isinstance(v, np.ndarray) | isinstance(v, list):
                    raise ValueError("values must be a dict of np.ndarray or list")
                if not len(np.array(v).shape) == 1:
                    raise ValueError(
                        "values (features) must be a dict of np.ndarray or list of 1D arrays"
                    )
                lengths.append(len(v))
                if isinstance(v, list):
                    storage[k] = np.array(v)
            if not len(set(lengths)) == 1:
                raise ValueError("values (dict values) must all have same length")
            if ids is not None:
                print("Warning: ids is ignored when values is a dict")

        elif isinstance(values, pd.DataFrame):
            if values_names is not None:
                print("Warning: values_names is ignored when values is a DataFrame")
            if "id" in values.columns:
                values = values.set_index("id")
            values_names = values.columns
            storage = {k: v.to_numpy() for (k, v) in values.iterrows()}
        elif isinstance(values, list) or isinstance(values, np.ndarray):
            if ids is None:
                ids = list(range(len(values)))
            storage = {k: np.array(v) for (k, v) in zip(ids, values)}
        else:
            raise ValueError("values must be a dict, a DataFrame, a list or a numpy array")

        self.storage = storage
        self.values_names = values_names
        self.name = name

        self.shape = (len(self), len(next(iter(self.storage.values()))))
        self.indexer = indexer(self)

    def get_element_from_index(self, index):
        """Getter method over self.sequence.

        Returns the features stored at index index. Compared to __getitem__, it does take
        the index-th element of sequence but the index-th element of the store.

        Parameters
        ----------
        index : (int, list, slice)
            index argument of the feature

        Returns
        -------
        array_like
            features corresponding to the index index in self.store
        """
        if isinstance(index, int):
            index = [index]
        keys = [list(self.storage.keys())[i] for i in index]
        return self.batch[keys]

    def __len__(self):
        """Return the length of the sequence of apparition of the features."""
        return len(self.storage)

    def __getitem__(self, id_keys):
        """Subset FeaturesStorage, keeping only features which id is in keys.

        Parameters
        ----------
        id_keys : Iterable
            List of ids to keep.

        Returns
        -------
        FeaturesStorage
            Subset of the FeaturesStorage, with only the features whose id is in id_keys
        """
        if not isinstance(id_keys, list):
            id_keys = [id_keys]
        sub_storage = {k: self.storage[k] for k in id_keys}
        return FeaturesStorage(values=sub_storage, values_names=self.values_names, name=self.name)

    def get_storage_type(self):
        """Functions to access stored elements dtypes.

        Returns
        -------
        tuple
            tuple of dtypes of the stored elements, as returned by np.dtype
        """
        element = self.get_element_from_index(0)
        return element.dtype

    @property
    def batch(self):
        """Indexing attribute."""
        return self.indexer

batch property

Indexing attribute.

__getitem__(id_keys)

Subset FeaturesStorage, keeping only features which id is in keys.

Parameters:

Name Type Description Default
id_keys Iterable

List of ids to keep.

 required

Returns:

Type Description
FeaturesStorage

Subset of the FeaturesStorage, with only the features whose id is in id_keys
Source code in choice_learn/data/storage.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
def __getitem__(self, id_keys):
    """Subset FeaturesStorage, keeping only features which id is in keys.

    Parameters
    ----------
    id_keys : Iterable
        List of ids to keep.

    Returns
    -------
    FeaturesStorage
        Subset of the FeaturesStorage, with only the features whose id is in id_keys
    """
    if not isinstance(id_keys, list):
        id_keys = [id_keys]
    sub_storage = {k: self.storage[k] for k in id_keys}
    return FeaturesStorage(values=sub_storage, values_names=self.values_names, name=self.name)

__init__(ids=None, values=None, values_names=None, name=None, indexer=StorageIndexer)

Build the store.

Parameters:

Name Type Description Default
ids array_like or None

list of ids of features to store. If None is given, ids are created from apparition order of values

 None
values array_like

list of values of features to store

 None
values_names array_like

Iterable of str indicating the name of the features. Must be same length as values.

 None
name

name of the features store

 None
Source code in choice_learn/data/storage.py 
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
157
158
159
160
161
162
163
164
165
166
167
168
def __init__(
    self,
    ids=None,
    values=None,
    values_names=None,
    name=None,
    indexer=StorageIndexer,
):
    """Build the store.

    Parameters
    ----------
    ids : array_like or None
        list of ids of features to store. If None is given, ids are created from
        apparition order of values
    values : array_like
        list of values of features to store
    values_names : array_like
        Iterable of str indicating the name of the features. Must be same length as values.
    name: string, optional
        name of the features store
    """
    print("DictStorage")
    if isinstance(values, dict):
        storage = values
        lengths = []
        for k, v in storage.items():
            if not isinstance(v, np.ndarray) | isinstance(v, list):
                raise ValueError("values must be a dict of np.ndarray or list")
            if not len(np.array(v).shape) == 1:
                raise ValueError(
                    "values (features) must be a dict of np.ndarray or list of 1D arrays"
                )
            lengths.append(len(v))
            if isinstance(v, list):
                storage[k] = np.array(v)
        if not len(set(lengths)) == 1:
            raise ValueError("values (dict values) must all have same length")
        if ids is not None:
            print("Warning: ids is ignored when values is a dict")

    elif isinstance(values, pd.DataFrame):
        if values_names is not None:
            print("Warning: values_names is ignored when values is a DataFrame")
        if "id" in values.columns:
            values = values.set_index("id")
        values_names = values.columns
        storage = {k: v.to_numpy() for (k, v) in values.iterrows()}
    elif isinstance(values, list) or isinstance(values, np.ndarray):
        if ids is None:
            ids = list(range(len(values)))
        storage = {k: np.array(v) for (k, v) in zip(ids, values)}
    else:
        raise ValueError("values must be a dict, a DataFrame, a list or a numpy array")

    self.storage = storage
    self.values_names = values_names
    self.name = name

    self.shape = (len(self), len(next(iter(self.storage.values()))))
    self.indexer = indexer(self)

__len__()

Return the length of the sequence of apparition of the features.

Source code in choice_learn/data/storage.py 
191
192
193
def __len__(self):
    """Return the length of the sequence of apparition of the features."""
    return len(self.storage)

get_element_from_index(index)

Getter method over self.sequence.

Returns the features stored at index index. Compared to getitem, it does take the index-th element of sequence but the index-th element of the store.

Parameters:

Name Type Description Default
index (int, list, slice)

index argument of the feature

 required

Returns:

Type Description
array_like

features corresponding to the index index in self.store
Source code in choice_learn/data/storage.py 
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
def get_element_from_index(self, index):
    """Getter method over self.sequence.

    Returns the features stored at index index. Compared to __getitem__, it does take
    the index-th element of sequence but the index-th element of the store.

    Parameters
    ----------
    index : (int, list, slice)
        index argument of the feature

    Returns
    -------
    array_like
        features corresponding to the index index in self.store
    """
    if isinstance(index, int):
        index = [index]
    keys = [list(self.storage.keys())[i] for i in index]
    return self.batch[keys]

get_storage_type()

Functions to access stored elements dtypes.

Returns:

Type Description
tuple

tuple of dtypes of the stored elements, as returned by np.dtype
Source code in choice_learn/data/storage.py 
213
214
215
216
217
218
219
220
221
222
def get_storage_type(self):
    """Functions to access stored elements dtypes.

    Returns
    -------
    tuple
        tuple of dtypes of the stored elements, as returned by np.dtype
    """
    element = self.get_element_from_index(0)
    return element.dtype

FeaturesStorage

Bases: object

Base FeaturesStorage class that redirects toward the right one.

Source code in choice_learn/data/storage.py 
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 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
class FeaturesStorage(object):
    """Base FeaturesStorage class that redirects toward the right one."""

    def __new__(
        cls,
        ids=None,
        values=None,
        values_names=None,
        name=None,
        as_one_hot=False,
    ):
        """Redirects toward the right object.

        Parameters
        ----------
        ids : Iterable, optional
            IDs to references features with, by default None
        values : Iterable, optional
            Features to be stored, by default None
        values_names : list, optional
            List of names for the features to be stored, by default None
        name : str, optional
            Name of the FeaturesStorage, to be matched in ChoiceDataset, by default None
        as_one_hot: bool
            Whether features are OneHot representations or not.

        Returns
        -------
        FeaturesStorage
            One of ArrayStorage, DictStorage or OneHotStorage
        """
        if as_one_hot:
            return OneHotStorage(ids=ids, values=values, name=name)

        if ids is None and (isinstance(values, np.ndarray) or isinstance(values, list)):
            return ArrayStorage(values=values, values_names=values_names, name=name)

        if ids is not None:
            check_ids = np.unique(ids) == np.arange(len(ids))
            if isinstance(check_ids, np.ndarray):
                check_ids = check_ids.all()
            if check_ids:
                values = [values[np.where(np.array(ids) == i)[0][0]] for i in np.arange(len(ids))]
                return ArrayStorage(values=values, values_names=values_names, name=name)

        return DictStorage(
            ids=ids, values=values, values_names=values_names, name=name, indexer=StorageIndexer
        )

__new__(ids=None, values=None, values_names=None, name=None, as_one_hot=False)

Redirects toward the right object.

Parameters:

Name Type Description Default
ids Iterable

IDs to references features with, by default None

 None
values Iterable

Features to be stored, by default None

 None
values_names list

List of names for the features to be stored, by default None

 None
name str

Name of the FeaturesStorage, to be matched in ChoiceDataset, by default None

 None
as_one_hot

Whether features are OneHot representations or not.

 False

Returns:

Type Description
FeaturesStorage

One of ArrayStorage, DictStorage or OneHotStorage
Source code in choice_learn/data/storage.py 
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 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
def __new__(
    cls,
    ids=None,
    values=None,
    values_names=None,
    name=None,
    as_one_hot=False,
):
    """Redirects toward the right object.

    Parameters
    ----------
    ids : Iterable, optional
        IDs to references features with, by default None
    values : Iterable, optional
        Features to be stored, by default None
    values_names : list, optional
        List of names for the features to be stored, by default None
    name : str, optional
        Name of the FeaturesStorage, to be matched in ChoiceDataset, by default None
    as_one_hot: bool
        Whether features are OneHot representations or not.

    Returns
    -------
    FeaturesStorage
        One of ArrayStorage, DictStorage or OneHotStorage
    """
    if as_one_hot:
        return OneHotStorage(ids=ids, values=values, name=name)

    if ids is None and (isinstance(values, np.ndarray) or isinstance(values, list)):
        return ArrayStorage(values=values, values_names=values_names, name=name)

    if ids is not None:
        check_ids = np.unique(ids) == np.arange(len(ids))
        if isinstance(check_ids, np.ndarray):
            check_ids = check_ids.all()
        if check_ids:
            values = [values[np.where(np.array(ids) == i)[0][0]] for i in np.arange(len(ids))]
            return ArrayStorage(values=values, values_names=values_names, name=name)

    return DictStorage(
        ids=ids, values=values, values_names=values_names, name=name, indexer=StorageIndexer
    )

OneHotStorage

Bases: Storage

Specific Storage for one hot features storage.

Inherits from Storage. For example can be used to store a OneHot representation of the days of week.

Has the same attributes as FeaturesStoage, only differs whit some One-Hot optimized methods. It only stores the indexes of the features, and creates the OneHot matrix when needed, using .batch[].

Source code in choice_learn/data/storage.py 
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
class OneHotStorage(Storage):
    """Specific Storage for one hot features storage.

    Inherits from Storage.
    For example can be used to store a OneHot representation of the days of week.

    Has the same attributes as FeaturesStoage, only differs whit some One-Hot optimized methods.
    It only stores the indexes of the features, and creates the OneHot matrix
    when needed, using .batch[].
    """

    def __init__(
        self, ids=None, values=None, name=None, dtype=np.uint8, indexer=OneHotStorageIndexer
    ):
        """Build the store.

        Parameters
        ----------
        ids : array_like or None
            list of ids of features to store. If None is given, ids are created from
            apparition order of values
        values : array_like
            list of values of features to store
        dtype: type
            type for One Hot representation, usually int or float, default is np.uint8
        name: string, optional
            name of the features store
        """
        if isinstance(values, dict):
            storage = values
            for k, v in storage.items():
                if not isinstance(v, int):
                    raise ValueError(
                        """values of values dict must be int as
                        they are indexes of the one hot vector ones."""
                    )
            length = np.max(list(storage.values())) + 1
            if ids is not None:
                print("Warning: ids is ignored when values is a dict")

        elif isinstance(values, list) or isinstance(values, np.ndarray):
            if ids is None:
                ids = list(range(len(values)))
            storage = {k: int(v) for (k, v) in zip(ids, values)}
            length = np.max(values) + 1

        elif values is None:
            if ids is None:
                raise ValueError("ids or values must be given, both are None")
            value = 0
            storage = {}
            for id in ids:
                storage[id] = value
                value += 1
            length = value
        else:
            raise ValueError("values must be a dict, a DataFrame, a list or a numpy array")

        self.storage = storage
        self.name = name

        self.shape = (len(self), length)
        self.dtype = dtype
        self.indexer = indexer(self)

    def __len__(self):
        """Return the length of the sequence of apparition of the features."""
        return len(self.storage)

    def __getitem__(self, id_keys):
        """Subset FeaturesStorage, keeping only features which id is in keys.

        Parameters
        ----------
        id_keys : Iterable
            List of ids to keep.

        Returns
        -------
        OneHotStorage
            Subset of the OneHotStorage, with only the features whose id is in id_keys
        """
        if isinstance(id_keys, int):
            id_keys = [id_keys]
        sub_storage = {k: self.storage[k] for k in id_keys}

        return OneHotStorage(values=sub_storage, name=self.name, dtype=self.dtype)

    def astype(self, dtype):
        """Change (mainly int or float) type of returned OneHot features vectors.

        Parameters
        ----------
        dtype : type
            Type to set the features as
        """
        self.dtype = dtype

    def get_element_from_index(self, index):
        """Getter method over self.sequence.

        Returns the features stored at index index. Compared to __getitem__, it does take
        the index-th element of sequence but the index-th element of the store.

        Parameters
        ----------
        index : (int, list, slice)
            index argument of the feature

        Returns
        -------
        array_like
            features corresponding to the index index in self.store
        """
        keys = list(self.storage.keys())[index]
        return self.storage[keys]

    def get_storage_type(self):
        """Functions to access stored elements dtypes.

        Returns
        -------
        type
            tuple of dtypes of the stored elements, as returned by np.dtype
        """
        return self.dtype

    @property
    def batch(self):
        """Indexing attribute."""
        return self.indexer

batch property

Indexing attribute.

__getitem__(id_keys)

Subset FeaturesStorage, keeping only features which id is in keys.

Parameters:

Name Type Description Default
id_keys Iterable

List of ids to keep.

 required

Returns:

Type Description
OneHotStorage

Subset of the OneHotStorage, with only the features whose id is in id_keys
Source code in choice_learn/data/storage.py 
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
def __getitem__(self, id_keys):
    """Subset FeaturesStorage, keeping only features which id is in keys.

    Parameters
    ----------
    id_keys : Iterable
        List of ids to keep.

    Returns
    -------
    OneHotStorage
        Subset of the OneHotStorage, with only the features whose id is in id_keys
    """
    if isinstance(id_keys, int):
        id_keys = [id_keys]
    sub_storage = {k: self.storage[k] for k in id_keys}

    return OneHotStorage(values=sub_storage, name=self.name, dtype=self.dtype)

__init__(ids=None, values=None, name=None, dtype=np.uint8, indexer=OneHotStorageIndexer)

Build the store.

Parameters:

Name Type Description Default
ids array_like or None

list of ids of features to store. If None is given, ids are created from apparition order of values

 None
values array_like

list of values of features to store

 None
dtype

type for One Hot representation, usually int or float, default is np.uint8

 uint8
name

name of the features store

 None
Source code in choice_learn/data/storage.py 
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
def __init__(
    self, ids=None, values=None, name=None, dtype=np.uint8, indexer=OneHotStorageIndexer
):
    """Build the store.

    Parameters
    ----------
    ids : array_like or None
        list of ids of features to store. If None is given, ids are created from
        apparition order of values
    values : array_like
        list of values of features to store
    dtype: type
        type for One Hot representation, usually int or float, default is np.uint8
    name: string, optional
        name of the features store
    """
    if isinstance(values, dict):
        storage = values
        for k, v in storage.items():
            if not isinstance(v, int):
                raise ValueError(
                    """values of values dict must be int as
                    they are indexes of the one hot vector ones."""
                )
        length = np.max(list(storage.values())) + 1
        if ids is not None:
            print("Warning: ids is ignored when values is a dict")

    elif isinstance(values, list) or isinstance(values, np.ndarray):
        if ids is None:
            ids = list(range(len(values)))
        storage = {k: int(v) for (k, v) in zip(ids, values)}
        length = np.max(values) + 1

    elif values is None:
        if ids is None:
            raise ValueError("ids or values must be given, both are None")
        value = 0
        storage = {}
        for id in ids:
            storage[id] = value
            value += 1
        length = value
    else:
        raise ValueError("values must be a dict, a DataFrame, a list or a numpy array")

    self.storage = storage
    self.name = name

    self.shape = (len(self), length)
    self.dtype = dtype
    self.indexer = indexer(self)

__len__()

Return the length of the sequence of apparition of the features.

Source code in choice_learn/data/storage.py 
380
381
382
def __len__(self):
    """Return the length of the sequence of apparition of the features."""
    return len(self.storage)

astype(dtype)

Change (mainly int or float) type of returned OneHot features vectors.

Parameters:

Name Type Description Default
dtype type

Type to set the features as

 required
Source code in choice_learn/data/storage.py 
403
404
405
406
407
408
409
410
411
def astype(self, dtype):
    """Change (mainly int or float) type of returned OneHot features vectors.

    Parameters
    ----------
    dtype : type
        Type to set the features as
    """
    self.dtype = dtype

get_element_from_index(index)

Getter method over self.sequence.

Returns the features stored at index index. Compared to getitem, it does take the index-th element of sequence but the index-th element of the store.

Parameters:

Name Type Description Default
index (int, list, slice)

index argument of the feature

 required

Returns:

Type Description
array_like

features corresponding to the index index in self.store
Source code in choice_learn/data/storage.py 
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
def get_element_from_index(self, index):
    """Getter method over self.sequence.

    Returns the features stored at index index. Compared to __getitem__, it does take
    the index-th element of sequence but the index-th element of the store.

    Parameters
    ----------
    index : (int, list, slice)
        index argument of the feature

    Returns
    -------
    array_like
        features corresponding to the index index in self.store
    """
    keys = list(self.storage.keys())[index]
    return self.storage[keys]

get_storage_type()

Functions to access stored elements dtypes.

Returns:

Type Description
type

tuple of dtypes of the stored elements, as returned by np.dtype
Source code in choice_learn/data/storage.py 
432
433
434
435
436
437
438
439
440
def get_storage_type(self):
    """Functions to access stored elements dtypes.

    Returns
    -------
    type
        tuple of dtypes of the stored elements, as returned by np.dtype
    """
    return self.dtype

Storage

Bases: ABC

Parent Class to have OneHotStorage and FeaturesStorage with same parent.

Source code in choice_learn/data/storage.py 
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
class Storage(ABC):
    """Parent Class to have OneHotStorage and FeaturesStorage with same parent."""

    def __init__(self, features_to_store):
        """Instantiate the storage.

        Parameters
        ----------
        features_to_store : object
            Object to store
        """
        self.features_to_store = features_to_store

    @abstractmethod
    def __getitem__(self, keys):
        """Access an element. To be implemented in children classes.

        Parameters
        ----------
        keys : float, int, str or list of
            values among indexes of the stiage
        """
        pass

    @abstractmethod
    def __len__(self):
        """Return the length of the sequence of apparition of the features."""
        pass

    @property
    def batch(self):
        """Indexing method."""
        pass

    def __str__(self):
        """Return string representation method.

        Returns
        -------
        str
            Description of the storage.
        """
        return f"FeatureStorage with name {self.name}"

batch property

Indexing method.

__getitem__(keys) abstractmethod

Access an element. To be implemented in children classes.

Parameters:

Name Type Description Default
keys float, int, str or list of

values among indexes of the stiage

 required
Source code in choice_learn/data/storage.py 
23
24
25
26
27
28
29
30
31
32
@abstractmethod
def __getitem__(self, keys):
    """Access an element. To be implemented in children classes.

    Parameters
    ----------
    keys : float, int, str or list of
        values among indexes of the stiage
    """
    pass

__init__(features_to_store)

Instantiate the storage.

Parameters:

Name Type Description Default
features_to_store object

Object to store

 required
Source code in choice_learn/data/storage.py 
13
14
15
16
17
18
19
20
21
def __init__(self, features_to_store):
    """Instantiate the storage.

    Parameters
    ----------
    features_to_store : object
        Object to store
    """
    self.features_to_store = features_to_store

__len__() abstractmethod

Return the length of the sequence of apparition of the features.

Source code in choice_learn/data/storage.py 
34
35
36
37
@abstractmethod
def __len__(self):
    """Return the length of the sequence of apparition of the features."""
    pass

__str__()

Return string representation method.

Returns:

Type Description
str

Description of the storage.
Source code in choice_learn/data/storage.py 
44
45
46
47
48
49
50
51
52
def __str__(self):
    """Return string representation method.

    Returns
    -------
    str
        Description of the storage.
    """
    return f"FeatureStorage with name {self.name}"