--- title: Data Core keywords: fastai sidebar: home_sidebar summary: "Main Numpy and Times Series functions used throughout the library." description: "Main Numpy and Times Series functions used throughout the library." nb_path: "nbs/013_data.core.ipynb" ---
{% raw %}
{% endraw %} {% raw %}
{% endraw %} {% raw %}
{% endraw %} {% raw %}
dsid = 'OliveOil'
X_train, y_train, X_valid, y_valid = get_UCR_data(dsid, on_disk=True, force_download=True)
X_on_disk, y_on_disk, splits = get_UCR_data(dsid, on_disk=True, return_split=False, force_download=True)
X_in_memory, y_in_memory, splits = get_UCR_data(dsid, on_disk=False, return_split=False, force_download=True)
y_tensor = cat2int(y_on_disk)
y_array = y_tensor.numpy()
{% endraw %} {% raw %}

class NumpyTensor[source]

NumpyTensor(o, **kwargs) :: TensorBase

Returns a tensor with subclass NumpyTensor that has a show method

{% endraw %} {% raw %}

class ToNumpyTensor[source]

ToNumpyTensor(enc=None, dec=None, split_idx=None, order=None) :: Transform

Transforms an object into NumpyTensor

{% endraw %} {% raw %}
{% endraw %} {% raw %}

class TSTensor[source]

TSTensor(o, **kwargs) :: NumpyTensor

Returns a tensor with subclass TSTensor that has a show method

{% endraw %} {% raw %}

class ToTSTensor[source]

ToTSTensor(enc=None, dec=None, split_idx=None, order=None) :: Transform

Transforms an object into TSTensor

{% endraw %} {% raw %}

show_tuple[source]

show_tuple(tup, nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None)

Display a timeseries plot from a decoded tuple

{% endraw %} {% raw %}
{% endraw %} {% raw %}
a = np.random.randn(2, 3, 4)
test_eq(TSTensor(a.tolist()).shape, a.shape)
{% endraw %} {% raw %}
t = TSTensor(torch.randn(2, 3, 4))
p = torch.tensor(3., requires_grad=True)
test = torch.add(t, p)
test_eq(test.requires_grad, True)
test_eq(type(t.data), torch.Tensor)
test_eq(type(t), TSTensor)
{% endraw %} {% raw %}
l = L([0,1,2,3], [4,5,6,7], [8, 9, 10, 11])
TSTensor(l), TSTensor(l).data
(TSTensor(vars:3, len:4, device=cpu),
 tensor([[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]]))
{% endraw %} {% raw %}
t = TSTensor(X_train)
for i in range(4):
    print(t, t.ndim, torch.is_tensor(t))
    if i < 3: t = t[0]
TSTensor(samples:30, vars:1, len:570, device=cpu) 3 True
TSTensor(vars:1, len:570, device=cpu) 2 True
TSTensor(len:570, device=cpu) 1 True
TSTensor([-0.6113752722740173], device=cpu) 0 True
{% endraw %} {% raw %}
TSTensor(X_on_disk)
TSTensor(samples:60, vars:1, len:570, device=cpu)
{% endraw %} {% raw %}
ToTSTensor()(X_on_disk)
TSTensor(samples:60, vars:1, len:570, device=cpu)
{% endraw %} {% raw %}
TSTensor(X_train).show();
{% endraw %} {% raw %}
TSTensor(X_train).show(title='1');
{% endraw %} {% raw %}
show_tuple((TSTensor(X_train), ['1', '2']))
{% endraw %} {% raw %}
show_tuple((TSTensor(np.arange(10).reshape(2,5)), 1))
{% endraw %} {% raw %}
show_tuple((TSTensor(np.arange(10).reshape(2,5)), '1'))
{% endraw %} {% raw %}
show_tuple((TSTensor(np.arange(10).reshape(2,5)), [1,2]))
{% endraw %} {% raw %}
show_tuple((TSTensor(np.arange(10).reshape(2,5)), ['1', '2']))
{% endraw %} {% raw %}

class TSLabelTensor[source]

TSLabelTensor(o, **kwargs) :: NumpyTensor

Returns a tensor with subclass NumpyTensor that has a show method

{% endraw %} {% raw %}

class TSMaskTensor[source]

TSMaskTensor(o, **kwargs) :: NumpyTensor

Returns a tensor with subclass NumpyTensor that has a show method

{% endraw %} {% raw %}
{% endraw %} {% raw %}
t = TSLabelTensor(torch.randint(0,10,(1, 2, 3)))
t, t[0], t[0][0], t[0][0][0]
(TSLabelTensor(shape:(1, 2, 3)),
 TSLabelTensor(shape:(2, 3)),
 TSLabelTensor(shape:(3,)),
 3)
{% endraw %} {% raw %}
t = TSMaskTensor(torch.randint(0,10,(1, 2, 3)))
t, t[0], t[0][0], t[0][0][0]
(TSMaskTensor(shape:(1, 2, 3)),
 TSMaskTensor(shape:(2, 3)),
 TSMaskTensor(shape:(3,)),
 6)
{% endraw %} {% raw %}

class ToFloat[source]

ToFloat(enc=None, dec=None, split_idx=None, order=None) :: Transform

Transforms an object dtype to float (vectorized)

{% endraw %} {% raw %}

class ToInt[source]

ToInt(enc=None, dec=None, split_idx=None, order=None) :: Transform

Transforms an object dtype to int

{% endraw %} {% raw %}

class TSClassification[source]

TSClassification(vocab=None, sort=True, add_na=False) :: DisplayedTransform

Vectorized, reversible transform of category string to vocab id

{% endraw %} {% raw %}
{% endraw %} {% raw %}
a = np.random.randint(0, 2, 10)
b = np.array(['1', '2', '3'])
c = np.array(['1.0', '2.0', '3.0'])
t = torch.randint(0, 2, (10, ))
test_eq(ToFloat()(a).dtype, 'float32')
test_eq(ToFloat()(b).dtype, 'float32')
test_eq(ToFloat()(c).dtype, 'float32')
test_eq(ToFloat()(t).dtype, torch.float32)
{% endraw %} {% raw %}
a = np.random.rand(10)*10
b = np.array(['1.0', '2.0', '3.0'])
t = torch.rand(10)*10
test_eq(ToInt()(a).dtype, 'int64')
test_eq(ToInt()(b).dtype, 'int64')
test_eq(ToInt()(t).dtype, torch.long)
{% endraw %} {% raw %}
t = TSClassification()
t.setup(y_on_disk[splits[0]])
y_encoded = t(y_on_disk)
print(y_encoded)
test_eq(t.decodes(y_encoded), y_on_disk)
TensorCategory([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
        3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3])
{% endraw %} {% raw %}
y_multi= np.random.randint(0,3,20)
y_multi = np.asarray(alphabet[y_multi]).reshape(4,5)
tfm = TSClassification()
tfm.setup(y_multi)
enc_y_multi = tfm(y_multi)
test_eq(y_multi, tfm.decode(enc_y_multi))
enc_y_multi
TensorCategory([[2, 0, 1, 1, 0],
        [2, 2, 2, 0, 2],
        [0, 2, 0, 1, 2],
        [1, 1, 0, 2, 2]])
{% endraw %} {% raw %}

class TSMultiLabelClassification[source]

TSMultiLabelClassification(c=None, vocab=None, add_na=False) :: Categorize

Reversible combined transform of multi-category strings to one-hot encoded vocab id

{% endraw %} {% raw %}
{% endraw %} {% raw %}

class NumpyTensorBlock[source]

NumpyTensorBlock(type_tfms=None, item_tfms=None, batch_tfms=None, dl_type=None, dls_kwargs=None)

{% endraw %} {% raw %}

class TSTensorBlock[source]

TSTensorBlock(type_tfms=None, item_tfms=None, batch_tfms=None, dl_type=None, dls_kwargs=None)

{% endraw %} {% raw %}
{% endraw %} {% raw %}
test_eq(NumpyTensorBlock().item_tfms[0].__name__, 'ToNumpyTensor')
test_eq(TSTensorBlock().item_tfms[0].__name__, 'ToTSTensor')
{% endraw %} {% raw %}

class TorchDataset[source]

TorchDataset(X, y=None)

{% endraw %} {% raw %}

class NumpyDataset[source]

NumpyDataset(X, y=None, types=None)

{% endraw %} {% raw %}

class TSDataset[source]

TSDataset(X, y=None, types=None, sel_vars=None, sel_steps=None)

{% endraw %} {% raw %}
{% endraw %} {% raw %}
a = np.random.rand(5,6,7)
b = np.random.rand(5)
ds = NumpyDataset(a,b)
xb, yb = ds[[0,4]]
test_eq(xb.shape, (2,6,7))
test_eq(yb.shape, (2,))
{% endraw %} {% raw %}

class NoTfmLists[source]

NoTfmLists(items=None, *rest, use_list=False, match=None) :: TfmdLists

A Pipeline of tfms applied to a collection of items

{% endraw %} {% raw %}

class TSTfmdLists[source]

TSTfmdLists(items=None, *rest, use_list=False, match=None) :: TfmdLists

A Pipeline of tfms applied to a collection of items

{% endraw %} {% raw %}
{% endraw %} {% raw %}
items = X_on_disk
tl = TfmdLists(items, tfms=None, splits=splits)
test_eq(len(tl), len(X_on_disk))
test_eq(len(tl.train), len(splits[0]))
test_eq(len(tl.valid), len(splits[1]))
test_eq(tl[[0,4,7]], X_on_disk[[0,4,7]])
test_eq(tl.train[[0,4,7]], X_on_disk[splits[0][0,4,7]])
test_eq(tl.valid[[0,4,7]], X_on_disk[splits[1][0,4,7]])
test_eq(tl[0], items[0])
test_eq(tl[[0,1]], items[[0,1]])
test_eq(tl.decode(tl[0]), tl[0])
test_eq((tl.split_idx, tl.train.split_idx, tl.valid.split_idx), (None, 0, 1))
{% endraw %} {% raw %}
items = X_on_disk
tl = TSTfmdLists(items, tfms=None, splits=splits)
test_eq(len(tl), len(X_on_disk))
test_eq(len(tl.train), len(splits[0]))
test_eq(len(tl.valid), len(splits[1]))
test_eq(tl[[0,4,7]], X_on_disk[[0,4,7]])
test_eq(tl.train[[0,4,7]], X_on_disk[splits[0][0,4,7]])
test_eq(tl.valid[[0,4,7]], X_on_disk[splits[1][0,4,7]])
test_eq(tl[0], items[0])
test_eq(tl[[0,1]], items[[0,1]])
test_eq(tl.decode(tl[0]), tl[0])
test_eq((tl.split_idx, tl.train.split_idx, tl.valid.split_idx), (None, 0, 1))
{% endraw %} {% raw %}
items = X_on_disk
ntl = NoTfmLists(items, splits=splits)
test_eq(len(ntl), len(X_on_disk))
test_eq(len(ntl.train), len(splits[0]))
test_eq(len(ntl.valid), len(splits[1]))
test_eq(ntl._splits, np.arange(len(X_on_disk)))
test_eq(ntl.train._splits, np.arange(len(splits[0])))
test_eq(ntl.valid._splits, np.arange(len(splits[0]), len(X_on_disk)))
print(ntl)
print(ntl.train)
print(ntl.valid)
test_eq(ntl[[0,4,7]], X_on_disk[[0,4,7]])
test_eq(ntl.train[[0,4,7]], X_on_disk[splits[0][0,4,7]])
test_eq(ntl.valid[[0,4,7]], X_on_disk[splits[1][0,4,7]])
test_eq(ntl[0], items[0])
test_eq(ntl[[0,1]], items[[0,1]])
test_eq(ntl[:], X_on_disk)
ntl[0].shape, stack(ntl[[0,1]]).shape
test_eq(ntl.decode(ntl[0]), ntl[0])
assert id(items) == id(ntl.items) == id(ntl.train.items) == id(ntl.valid.items)
test_eq((ntl.split_idx, ntl.train.split_idx, ntl.valid.split_idx), (None, 0, 1))
NoTfmLists: memmap(60, 1, 570)
NoTfmLists: memmap(30, 1, 570)
NoTfmLists: memmap(30, 1, 570)
{% endraw %} {% raw %}
subitems = X_on_disk
new_ntl = ntl._new(X_on_disk)
test_eq(new_ntl[:], X_on_disk)
{% endraw %} {% raw %}
idxs = np.random.choice(len(X_on_disk), 10, False)
new_ntl = ntl._new(X_on_disk[idxs])
test_eq(new_ntl[:], X_on_disk[idxs])
{% endraw %} {% raw %}
idxs = np.random.choice(len(X_on_disk), 10, False)
new_ntl = ntl.valid._new(X_on_disk[idxs])
test_eq(new_ntl[:], X_on_disk[idxs])
{% endraw %} {% raw %}

class NumpyDatasets[source]

NumpyDatasets(items=None, tfms=None, tls=None, n_inp=None, dl_type=None, use_list=None, do_setup=True, split_idx=None, train_setup=True, splits=None, types=None, verbose=False) :: Datasets

A dataset that creates tuples from X (and y) and applies tfms of type item_tfms

{% endraw %} {% raw %}

tscoll_repr[source]

tscoll_repr(c, max_n=10)

String repr of up to max_n items of (possibly lazy) collection c

{% endraw %} {% raw %}
{% endraw %} {% raw %}

class TSDatasets[source]

TSDatasets(items=None, tfms=None, tls=None, n_inp=None, dl_type=None, use_list=None, do_setup=True, split_idx=None, train_setup=True, splits=None, types=None, verbose=False) :: NumpyDatasets

A dataset that creates tuples from X (and optionally y) and applies item_tfms

{% endraw %} {% raw %}
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, splits=splits, tfms=[None, TSClassification()], inplace=True)
i = np.random.choice(len(splits[0]), 10, False).tolist()
test_eq(dsets.subset(i), dsets.train.subset(i))
dsets.valid.subset(i)
dsets.valid.subset(i)[[0,6,8]]
test_eq(dsets.subset(i)[[0,6,8]], dsets.train.subset(i)[[0,6,8]])
dsets.subset([0,7,3])
dsets.subset(i), dsets.train.subset(i), dsets.valid.subset(i)
((#10) [(TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(2)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0))] ...],
 (#10) [(TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(2)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0))] ...],
 (#10) [(TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(3)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0))] ...])
{% endraw %} {% raw %}

add_ds[source]

add_ds(dsets, X, y=None, inplace=True)

Create test datasets from X (and y) using validation transforms of dsets

{% endraw %} {% raw %}

NumpyDatasets.add_dataset[source]

NumpyDatasets.add_dataset(X, y=None, inplace=True)

{% endraw %} {% raw %}

NumpyDatasets.add_test[source]

NumpyDatasets.add_test(X, y=None, inplace=True)

{% endraw %} {% raw %}

NumpyDatasets.add_unlabeled[source]

NumpyDatasets.add_unlabeled(X, inplace=True)

{% endraw %} {% raw %}
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, splits=splits, tfms=[None, TSClassification()], inplace=True)
print(dsets.train[0][0].shape, dsets.train[[0,1]][0].shape)
print(dsets.split_idx, dsets.train.split_idx, dsets.valid.split_idx)
print(dsets.new_empty())
dsets
torch.Size([1, 570]) torch.Size([2, 1, 570])
None 0 1
(#0) []
(#60) [(TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(0)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1)), (TSTensor(vars:1, len:570, device=cpu), TensorCategory(1))] ...]
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, splits=splits, tfms=[None, TSClassification()], inplace=False)
print(dsets.train[0][0].shape, dsets.train[[0,1]][0].shape)
print(dsets.split_idx, dsets.train.split_idx, dsets.valid.split_idx)
print(dsets.new_empty())
dsets
torch.Size([1, 570]) torch.Size([2, 1, 570])
None 0 1
(#0) []
(#60) [(TSTensor(vars:1, len:570, device=cpu), TensorCategory([0])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([0])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([0])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([0])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([0])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([1])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([1])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([1])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([1])), (TSTensor(vars:1, len:570, device=cpu), TensorCategory([1]))] ...]
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, tfms=[None, TSClassification()], splits=splits, inplace=True)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])

idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])
test_eq(dsets.train[idxs][1].numpy(), y_array[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
test_eq(dsets.valid[idxs][1].numpy(), y_array[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, tfms=[None, TSClassification()], splits=splits, inplace=False)
assert id(X_on_disk) == id(dsets.tls[0].items) == id(dsets.ptls[0].items)
assert id(X_on_disk) == id(dsets.train.tls[0].items) == id(dsets.train.ptls[0].items)
assert id(X_on_disk) == id(dsets.valid.tls[0].items) == id(dsets.valid.ptls[0].items)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])


idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])
test_eq(dsets.train[idxs][1].numpy(), y_array[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
test_eq(dsets.valid[idxs][1].numpy(), y_array[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, splits=splits, inplace=True)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])

idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, splits=splits, inplace=False)
assert id(X_on_disk) == id(dsets.tls[0].items) == id(dsets.ptls[0].items)
assert id(X_on_disk) == id(dsets.train.tls[0].items) == id(dsets.train.ptls[0].items)
assert id(X_on_disk) == id(dsets.valid.tls[0].items) == id(dsets.valid.ptls[0].items)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])

idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits, inplace=True)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])

idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])
test_eq(dsets.train[idxs][1].numpy(), y_array[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
test_eq(dsets.valid[idxs][1].numpy(), y_array[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits, inplace=False)
assert id(X_on_disk) == id(dsets.tls[0].items) == id(dsets.ptls[0].items)
assert id(X_on_disk) == id(dsets.train.tls[0].items) == id(dsets.train.ptls[0].items)
assert id(X_on_disk) == id(dsets.valid.tls[0].items) == id(dsets.valid.ptls[0].items)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])

idxs = np.random.choice(len(dsets.train), 10, False)
test_eq(dsets.train[idxs][0].numpy(), X_on_disk[splits[0][idxs]])
test_eq(dsets.train[idxs][1].numpy(), y_array[splits[0][idxs]])

idxs = np.random.choice(len(dsets.valid), 10, False)
test_eq(dsets.valid[idxs][0].numpy(), X_on_disk[splits[1][idxs]])
test_eq(dsets.valid[idxs][1].numpy(), y_array[splits[1][idxs]])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, tfms=[None, TSClassification()], splits=None, inplace=True)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, tfms=[None, TSClassification()], splits=None, inplace=False)
assert id(X_on_disk) == id(dsets.tls[0].items) == id(dsets.ptls[0].items)
assert id(X_on_disk) == id(dsets.train.tls[0].items) == id(dsets.train.ptls[0].items)
assert id(X_on_disk) == id(dsets.valid.tls[0].items) == id(dsets.valid.ptls[0].items)

idxs = np.random.choice(len(dsets), 10, False)
test_eq(dsets[idxs][0].numpy(), X_on_disk[idxs])
test_eq(dsets[idxs][1].numpy(), y_array[idxs])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits)
test_eq(dsets.train[0:10], dsets.add_dataset(X_on_disk[0:10], y_array[0:10])[:])
test_eq(dsets.train[0:10][0], dsets.add_dataset(X_on_disk[0:10])[:][0])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits)
torch.save(dsets, 'export/dsets.pth')
del dsets
dsets = torch.load('export/dsets.pth')
dsets
(#60) [(TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1))] ...]
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits)
torch.save(dsets.train, 'export/dsets.pth')
del dsets
dsets = torch.load('export/dsets.pth')
dsets
(#30) [(TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(0)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1)), (TSTensor(vars:1, len:570, device=cpu), tensor(1))] ...]
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits)
test_eq(len(dsets.train), len(X_train))
dsets = TSDatasets(X_on_disk, y_array, tfms=None, splits=splits)
test_eq(len(dsets.train), len(X_train))
dsets = TSDatasets(X_on_disk, y_array, tfms=[add(1), Categorize()], splits=splits)
test_eq(len(dsets.train), len(X_train))
# test_eq(dsets.train[0][0].data, tensor(X_train[0] + 1))
test_eq(dsets.train[0][1].item(), y_tensor[0])
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_on_disk, tfms=[None, Categorize()], splits=splits)
test_eq(len(dsets.add_test(X_train, y_train)), len(X_train))
test_eq(len(dsets.add_unlabeled(X_train)), len(X_train))
{% endraw %} {% raw %}
{% endraw %} {% raw %}

class NumpyDataLoader[source]

NumpyDataLoader(dataset, bs=64, shuffle=True, drop_last=True, num_workers=None, verbose=False, do_setup=True, batch_tfms=None, weights=None, partial_n=None, pin_memory=False, timeout=0, batch_size=None, indexed=None, n=None, device=None, persistent_workers=False, wif=None, before_iter=None, after_item=None, before_batch=None, after_batch=None, after_iter=None, create_batches=None, create_item=None, create_batch=None, retain=None, get_idxs=None, sample=None, shuffle_fn=None, do_batch=None) :: TfmdDL

Transformed DataLoader

{% endraw %} {% raw %}

class TSDataLoader[source]

TSDataLoader(dataset, bs=64, shuffle=True, drop_last=True, num_workers=None, verbose=False, do_setup=True, batch_tfms=None, weights=None, partial_n=None, pin_memory=False, timeout=0, batch_size=None, indexed=None, n=None, device=None, persistent_workers=False, wif=None, before_iter=None, after_item=None, before_batch=None, after_batch=None, after_iter=None, create_batches=None, create_item=None, create_batch=None, retain=None, get_idxs=None, sample=None, shuffle_fn=None, do_batch=None) :: NumpyDataLoader

Transformed DataLoader

{% endraw %} {% raw %}
{% endraw %} {% raw %}

class NumpyDataLoaders[source]

NumpyDataLoaders(*loaders, path='.', device=None) :: DataLoaders

Basic wrapper around several DataLoaders.

{% endraw %} {% raw %}

class TSDataLoaders[source]

TSDataLoaders(*loaders, path='.', device=None) :: NumpyDataLoaders

Basic wrapper around several DataLoaders.

{% endraw %} {% raw %}
{% endraw %} {% raw %}

get_best_dl_params[source]

get_best_dl_params(dl, n_iters=10, num_workers=[0, 1, 2, 4, 8], pin_memory=False, prefetch_factor=[2, 4, 8], return_best=True, verbose=True)

{% endraw %} {% raw %}

get_best_dls_params[source]

get_best_dls_params(dls, n_iters=10, num_workers=[0, 1, 2, 4, 8], pin_memory=False, prefetch_factor=[2, 4, 8], return_best=True, verbose=True)

{% endraw %} {% raw %}
{% endraw %} {% raw %}

get_ts_dls[source]

get_ts_dls(X, y=None, splits=None, sel_vars=None, sel_steps=None, tfms=None, inplace=True, path='.', bs=64, batch_tfms=None, num_workers=0, device=None, shuffle_train=True, drop_last=True, weights=None, partial_n=None, **kwargs)

{% endraw %} {% raw %}

get_ts_dl[source]

get_ts_dl(X, y=None, sel_vars=None, sel_steps=None, tfms=None, inplace=True, path='.', bs=64, batch_tfms=None, num_workers=0, device=None, shuffle_train=True, drop_last=True, weights=None, partial_n=None, **kwargs)

{% endraw %} {% raw %}

get_subset_dl[source]

get_subset_dl(dl, idxs)

{% endraw %} {% raw %}
{% endraw %} {% raw %}
X, y, splits = get_UCR_data(dsid, on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=8)
dls = get_best_dls_params(dls, prefetch_factor=[2, 4, 8, 16])
Dataloader 0

   num_workers:  0  pin_memory: False  prefetch_factor:  2  -  time:    1.284 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor:  4  -  time:    0.654 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor:  8  -  time:    0.578 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor: 16  -  time:    0.521 ms/iter

   best dl params:
       best num_workers    : 0
       best pin_memory     : False
       best prefetch_factor: 16
       return_best         : True



Dataloader 1

   num_workers:  0  pin_memory: False  prefetch_factor:  2  -  time:    1.299 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor:  4  -  time:    0.422 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor:  8  -  time:    0.444 ms/iter
   num_workers:  0  pin_memory: False  prefetch_factor: 16  -  time:    0.400 ms/iter

   best dl params:
       best num_workers    : 0
       best pin_memory     : False
       best prefetch_factor: 16
       return_best         : True


{% endraw %} {% raw %}
X, y, splits = get_UCR_data(dsid, on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=8)
b=first(dls.train)
dls.decode(b)
test_eq(X.shape[1], dls.vars)
test_eq(X.shape[-1], dls.len)
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=64, inplace=True)

idxs = np.random.choice(len(dls.valid_ds), 10, False)
new_dl = get_subset_dl(dls.train, idxs)

idxs = np.random.choice(len(dls.valid_ds), 10, False)
new_dl = get_subset_dl(dls.valid, idxs)
test_eq(new_dl.one_batch()[0].cpu().numpy(), X[splits[1][idxs]])
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
weights = np.random.rand(len(X))
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=64, inplace=True, weights=weights)
weights2 = weights[splits[0]] / weights[splits[0]].sum()
test_eq(dls.train.weights, weights2)
test_eq(dls.valid.weights, None)
{% endraw %} {% raw %}
partial_n = 12
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, splits=splits, tfms=[None, TSClassification()], bs=64, inplace=True, partial_n=partial_n)
test_eq(len(dls.train.one_batch()[0]), partial_n)

partial_n = .1
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], bs=64, inplace=True, partial_n=partial_n)
test_eq(len(dls.train.one_batch()[0]), int(round(len(dls.train.dataset) * partial_n)))
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=64, inplace=False)

idxs = np.random.choice(len(dls.valid_ds), 10, False)
new_dl = get_subset_dl(dls.train, idxs)

idxs = np.random.choice(len(dls.valid_ds), 10, False)
new_dl = get_subset_dl(dls.valid, idxs)
test_eq(new_dl.one_batch()[0].cpu().numpy(), X[splits[1][idxs]])
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, TSClassification()], splits=splits, bs=8)
b = dls.one_batch()
input_idxs = dls.input_idxs
test_eq(b[0].cpu().numpy(), X[input_idxs])
b = dls.train.one_batch()
input_idxs = dls.train.input_idxs
test_eq(b[0].cpu().numpy(), X[input_idxs])
assert max(input_idxs) < len(splits[0])
b = dls.valid.one_batch()
input_idxs = dls.valid.input_idxs
test_eq(b[0].cpu().numpy(), X[input_idxs])
assert min(input_idxs) >= len(splits[0])
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, Categorize()], splits=splits, bs=8)
b=first(dls.train)
dls.decode(b)
test_eq(X.shape[1], dls.vars)
test_eq(X.shape[-1], dls.len)
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, Categorize()], splits=splits, bs=8, weights=np.random.randint(0, 3, len(y)))
b=first(dls.train)
dls.decode(b)
test_eq(X.shape[1], dls.vars)
test_eq(X.shape[-1], dls.len)
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dsets = TSDatasets(X, y, tfms=[None, Categorize()], splits=splits)
ts_dls = TSDataLoaders.from_dsets(dsets.train, dsets.valid, device=default_device(), bs=4)
torch.save(ts_dls, 'export/ts_dls.pth')
del ts_dls
ts_dls = torch.load('export/ts_dls.pth')
for xb,yb in ts_dls.train: 
    test_eq(tensor(X[ts_dls.train.idxs]), xb.cpu())
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('OliveOil', on_disk=False, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, Categorize()], splits=splits, bs=4)
for xb,yb in dls.train:
    test_eq(xb.cpu().numpy(), X[dls.train.input_idxs])
for xb,yb in dls.valid:
    test_eq(xb.cpu().numpy(), X[dls.valid.input_idxs])
{% endraw %} {% raw %}
test_eq((ts_dls.train.shuffle, ts_dls.valid.shuffle, ts_dls.train.drop_last, ts_dls.valid.drop_last), (True, False, True, False))
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, Categorize()], splits=splits, bs=8, num_workers=0)
xb, yb = first(dls.train)
test_eq(tensor(X[dls.train.idxs]), xb.cpu())
{% endraw %} {% raw %}
test_eq((dls.train.shuffle, dls.valid.shuffle, dls.train.drop_last, dls.valid.drop_last), (True, False, True, False))
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, on_disk=True, split_data=False)
dls = get_ts_dls(X, y, tfms=[None, Categorize()], splits=splits, inplace=True)
dls.show_dist()
dls.train.show_dist()
xb,yb = first(dls.train)
test_eq((dls.cat, dls.c), (True, 4))
test_ne(dls.cws.cpu().numpy(), None)
dls.decoder((xb, ))
dls.decoder((xb[0], ))
dls.decoder((xb, yb))
dls.decoder((xb[0], yb[0]))
dls.decoder(yb)
dls.decoder(yb[0])
'1'
{% endraw %} {% raw %}
new_dl = dls.new_dl(X)
first(new_dl)
(TSTensor(samples:30, vars:1, len:570, device=cpu),)
{% endraw %} {% raw %}
new_dl = dls.new_dl(X, y=y)
first(new_dl)
(TSTensor(samples:30, vars:1, len:570, device=cpu),
 TensorCategory([0, 0, 0, 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 1, 1, 1, 1, 1,
         2, 3, 3, 3, 3, 3]))
{% endraw %} {% raw %}
dls.train.dataset.split_idxs, dls.train.dataset.splits, dls.valid.split_idxs
((#30) [0,1,2,3,4,5,6,7,8,9...],
 (#2) [[0, 1, 2, 3, 4, 5, 6, 7, 8, 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]],
 (#30) [30,31,32,33,34,35,36,37,38,39...])
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, on_disk=True, split_data=False)
dls = get_ts_dls(X, np.random.rand(60, ), tfms=[None, ToNumpyTensor], splits=splits)
dls.show_dist()
dls.train.show_dist()
xb,yb = first(dls.train)
dls.decoder((xb, ))
dls.decoder((xb[0], ))
dls.decoder((xb, yb))
dls.decoder((xb[0], yb[0]))
dls.decoder(yb)
dls.decoder(yb[0])
test_eq((dls.cat, dls.c), (False, 1))
test_eq(dls.cws, None)
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, on_disk=True, split_data=False)
dls = get_ts_dls(X, np.random.rand(60, 3) * 5, tfms=[None, ToNumpyTensor], splits=splits)
dls.show_dist()
dls.train.show_dist()
xb,yb = first(dls.train)
dls.decoder((xb, ))
dls.decoder((xb[0], ))
dls.decoder((xb, yb))
dls.decoder((xb[0], yb[0]))
dls.decoder(yb)
dls.decoder(yb[0])
test_eq((dls.cat, dls.c, dls.d),(False, 1, 3)) 
test_eq(dls.cws, None)
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, on_disk=True, split_data=False)
cm = {
    '1':'A',        
    '2':['B', 'C'],
    '3':['B', 'D'] , 
    '4':'E', 
    }
keys = cm.keys()
new_cm = {k:v for k,v in zip(keys, [listify(v) for v in cm.values()])}
y_multi = np.array([new_cm[yi] if yi in keys else listify(yi) for yi in y], dtype=object)
dls = get_ts_dls(X, y_multi, tfms=[None, TSMultiLabelClassification()], splits=splits)
dls.show_dist()
dls.train.show_dist()
xb,yb = first(dls.train)
dls.decoder((xb, ))
dls.decoder((xb[0], ))
dls.decoder((xb, yb))
dls.decoder((xb[0], yb[0]))
dls.decoder(yb)
dls.decoder(yb[0])
test_eq((dls.cat, dls.c), (True, 5))
test_ne(dls.cws.cpu().numpy(), None)
{% endraw %} {% raw %}
dsid = 'OliveOil'
X, y, splits = get_UCR_data(dsid, on_disk=True, split_data=False)
cm = {
    '1':'A',        
    '2':['B', 'C'],
    '3':['B', 'D'] , 
    '4':'E', 
    }
keys = cm.keys()
new_cm = {k:v for k,v in zip(keys, [listify(v) for v in cm.values()])}
y_multi = np.array([new_cm[yi] if yi in keys else listify(yi) for yi in y], dtype=object)
dls = get_ts_dls(X, y_multi, tfms=[None, TSMultiLabelClassification()], splits=splits)
test_eq(dls.new(X[0]).one_batch().shape, (1, 570))
test_eq(dls.new(X[:15]).one_batch().shape, (15, 1, 570))
test_eq(dls.train.new(X[0]).one_batch().shape, (1, 570))
test_eq(dls.valid.new(X[:15]).one_batch().shape, (15, 1, 570))
{% endraw %} {% raw %}
bs = 25
dsets = TSDatasets(X, y, tfms=[None, Categorize()], splits=splits)
dls   = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=[bs, bs*2], batch_tfms=add(1), num_workers=0)
xb,yb = dls.train.one_batch()
test_eq(xb.cpu().data, tensor(X_on_disk[splits[0]][dls.train.idxs]) + 1)
{% endraw %} {% raw %}
dsets = TSDatasets(X, y, tfms=[None, Categorize()], splits=splits)
dls   = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=[bs, bs*2])
xb,yb = dls.train.one_batch()
test_eq(xb.shape, (min(bs, len(splits[0])), X.shape[1], X.shape[-1]))
it = iter(dls.valid)
for xb,yb in it: 
    test_close(xb.cpu(), TSTensor(X[splits[1]][dls.valid.idxs]))
{% endraw %} {% raw %}
bs = 64
dsets = TSDatasets(X, y, tfms=[add(1), Categorize()], splits=RandomSplitter(valid_pct=.3)(y_array))
dls = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=[bs, bs*2])
xb,yb = dls.train.one_batch()
test_eq(xb.shape, (min(bs, len(dsets.train)), X_on_disk.shape[1], X_on_disk.shape[-1]))
xb,yb = dls.valid.one_batch()
test_eq(xb.shape, (min(bs*2, len(dsets.valid)), X_on_disk.shape[1], X_on_disk.shape[-1]))
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=[None, Categorize()], splits=splits)
dls   = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=[32, 64])
for i in range(10):
    dl = dls.train if random.random() < .5 else dls.valid
    xb,yb = dl.one_batch()
    torch.equal(xb.cpu(), TSTensor(X_on_disk[dl.input_idxs]))
    
dsets = TSDatasets(X_on_disk, y_array, tfms=[None, Categorize()])
dls   = TSDataLoaders.from_dsets(dsets, bs=32)
for i in range(10):
    xb,yb = dls.one_batch()
    torch.equal(xb.cpu(), TSTensor(X_on_disk[dl.input_idxs]))
    
dsets = TSDatasets(X_on_disk, tfms=None)
dls   = TSDataLoaders.from_dsets(dsets, bs=32)
for i in range(10):
    xb = dls.one_batch()
    torch.equal(xb[0].cpu(), TSTensor(X_on_disk[dl.input_idxs]))
{% endraw %} {% raw %}
dsets = TSDatasets(X_on_disk, y_array, tfms=[None, Categorize()])
dls   = TSDataLoaders.from_dsets(dsets, bs=32)
test_eq_type(dls.split_idxs, L(np.arange(len(X_on_disk)).tolist()))
{% endraw %} {% raw %}
X, y, splits = get_UCR_data('NATOPS', return_split=False)
tfms  = [None, [Categorize()]]
dls = get_ts_dls(X, y, tfms=tfms, splits=splits, bs=[64, 128])
dls.show_batch()
dls.show_dist()
{% endraw %} {% raw %}
dsid = 'NATOPS'
bs = 64
X2, y2, splits2 = get_UCR_data(dsid, return_split=False)
vocab = sorted(set(y))
tfms = [None, [Categorize(vocab=vocab)]]
dsets = TSDatasets(X2, y2, tfms=tfms, splits=splits2)
dls = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=[bs, bs*2])
dls.train.one_batch()
(TSTensor(samples:64, vars:24, len:51, device=cpu),
 TensorCategory([2, 0, 0, 3, 5, 4, 5, 4, 3, 3, 1, 0, 2, 2, 0, 1, 4, 0, 5, 1, 2, 3, 3, 2,
         1, 2, 1, 1, 0, 4, 4, 3, 1, 0, 1, 1, 3, 2, 3, 0, 2, 4, 4, 2, 1, 0, 5, 0,
         1, 5, 1, 0, 5, 2, 1, 5, 5, 0, 4, 3, 0, 3, 3, 4]))
{% endraw %} {% raw %}
bs = 64
n_epochs = 100
tfms = [None, [MultiCategorize()]]
dsets = TSDatasets(X2, y2, tfms=tfms, splits=splits2)
dls = TSDataLoaders.from_dsets(dsets.train, dsets.valid, bs=bs)
dls.train.one_batch()
(TSTensor(samples:64, vars:24, len:51, device=cpu),
 TensorMultiCategory([[5, 0, 1],
         [6, 0, 1],
         [3, 0, 1],
         [2, 0, 1],
         [3, 0, 1],
         [3, 0, 1],
         [4, 0, 1],
         [6, 0, 1],
         [6, 0, 1],
         [6, 0, 1],
         [4, 0, 1],
         [5, 0, 1],
         [6, 0, 1],
         [2, 0, 1],
         [7, 0, 1],
         [2, 0, 1],
         [2, 0, 1],
         [5, 0, 1],
         [2, 0, 1],
         [5, 0, 1],
         [6, 0, 1],
         [7, 0, 1],
         [4, 0, 1],
         [3, 0, 1],
         [2, 0, 1],
         [5, 0, 1],
         [7, 0, 1],
         [3, 0, 1],
         [5, 0, 1],
         [7, 0, 1],
         [3, 0, 1],
         [4, 0, 1],
         [6, 0, 1],
         [7, 0, 1],
         [3, 0, 1],
         [3, 0, 1],
         [6, 0, 1],
         [2, 0, 1],
         [6, 0, 1],
         [6, 0, 1],
         [5, 0, 1],
         [4, 0, 1],
         [7, 0, 1],
         [7, 0, 1],
         [5, 0, 1],
         [2, 0, 1],
         [6, 0, 1],
         [7, 0, 1],
         [2, 0, 1],
         [3, 0, 1],
         [7, 0, 1],
         [6, 0, 1],
         [6, 0, 1],
         [6, 0, 1],
         [4, 0, 1],
         [4, 0, 1],
         [3, 0, 1],
         [6, 0, 1],
         [7, 0, 1],
         [3, 0, 1],
         [5, 0, 1],
         [2, 0, 1],
         [5, 0, 1],
         [5, 0, 1]]))
{% endraw %}