Comparison Between TreeValue and Tianshou Batch

In this section, we will take a look at the feature and performance of the Tianshou Batch library, which is developed by Tsinghua Machine Learning Group.

Before starting the comparison, let us define some thing.

[1]:
import torch

_TREE_DATA_1 = {'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}}
_TREE_DATA_2 = {
    'a': torch.randn(2, 3),
    'x': {
        'c': torch.randn(3, 4)
    },
}
_TREE_DATA_3 = {
    'obs': torch.randn(4, 84, 84),
    'action': torch.randint(0, 6, size=(1,)),
    'reward': torch.rand(1),
}

Read and Write Operation

Reading and writing are the two most common operations in the tree data structure based on the data model (TreeValue and Tianshou Batch both belong to this type), so this section will compare the reading and writing performance of these two libraries.

TreeValue’s Get and Set

[2]:
from treevalue import FastTreeValue

t = FastTreeValue(_TREE_DATA_2)
[3]:
t
[3]:
../_images/comparison_tianshou_batch.result_8_0.svg
[4]:
t.a
[4]:
tensor([[-0.1242, -0.1211, -0.1289],
        [ 0.8732,  0.4625,  0.5919]])
[5]:
%timeit t.a
88.7 ns ± 0.705 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)
[6]:
new_value = torch.randn(2, 3)
t.a = new_value

t
[6]:
../_images/comparison_tianshou_batch.result_11_0.svg
[7]:
%timeit t.a = new_value
94.4 ns ± 0.529 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

Tianshou Batch’s Get and Set

[8]:
from tianshou.data import Batch

b = Batch(**_TREE_DATA_2)
[9]:
b
[9]:
Batch(
    a: tensor([[-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919]]),
    x: Batch(
           c: tensor([[ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316]]),
       ),
)
[10]:
b.a
[10]:
tensor([[-0.1242, -0.1211, -0.1289],
        [ 0.8732,  0.4625,  0.5919]])
[11]:
%timeit b.a
78.9 ns ± 0.448 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)
[12]:
new_value = torch.randn(2, 3)
b.a = new_value

b
[12]:
Batch(
    a: tensor([[ 0.8001, -1.6944, -1.4613],
               [-0.0234,  0.0072, -0.9134]]),
    x: Batch(
           c: tensor([[ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316]]),
       ),
)
[13]:
%timeit b.a = new_value
652 ns ± 4.11 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

Initialization

TreeValue’s Initialization

[14]:
%timeit FastTreeValue(_TREE_DATA_1)
1.04 µs ± 10.2 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

Tianshou Batch’s Initialization

[15]:
%timeit Batch(**_TREE_DATA_1)
13.2 µs ± 553 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

Deep Copy Operation

[16]:
import copy

Deep Copy of TreeValue

[17]:
t3 = FastTreeValue(_TREE_DATA_3)
%timeit copy.deepcopy(t3)
175 µs ± 1.39 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Deep Copy of Tianshou Batch

[18]:
b3 = Batch(**_TREE_DATA_3)
%timeit copy.deepcopy(b3)
173 µs ± 1.3 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Stack, Concat and Split Operation

Performance of TreeValue

[19]:
trees = [FastTreeValue(_TREE_DATA_2) for _ in range(8)]
[20]:
t_stack = FastTreeValue.func(subside=True)(torch.stack)

t_stack(trees)
[20]:
../_images/comparison_tianshou_batch.result_34_0.svg
[21]:
%timeit t_stack(trees)
40.4 µs ± 114 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
[22]:
t_cat = FastTreeValue.func(subside=True)(torch.cat)

t_cat(trees)
[22]:
../_images/comparison_tianshou_batch.result_36_0.svg
[23]:
%timeit t_cat(trees)
37 µs ± 549 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
[24]:
t_split = FastTreeValue.func(rise=True)(torch.split)
tree = FastTreeValue({
    'obs': torch.randn(8, 4, 84, 84),
    'action': torch.randint(0, 6, size=(8, 1,)),
    'reward': torch.rand(8, 1),
})

%timeit t_split(tree, 1)
75 µs ± 602 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Performance of Tianshou Batch

[25]:
batches = [Batch(**_TREE_DATA_2) for _ in range(8)]

Batch.stack(batches)
[25]:
Batch(
    a: tensor([[[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]],

               [[-0.1242, -0.1211, -0.1289],
                [ 0.8732,  0.4625,  0.5919]]]),
    x: Batch(
           c: tensor([[[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]],

                      [[ 0.4009, -0.7072,  0.3285,  0.6767],
                       [ 0.6301,  0.0497, -1.4183,  0.3445],
                       [ 0.4579, -0.2186,  1.5807,  0.9316]]]),
       ),
)
[26]:
%timeit Batch.stack(batches)
97.2 µs ± 703 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
[27]:
Batch.cat(batches)
[27]:
Batch(
    a: tensor([[-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919],
               [-0.1242, -0.1211, -0.1289],
               [ 0.8732,  0.4625,  0.5919]]),
    x: Batch(
           c: tensor([[ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316],
                      [ 0.4009, -0.7072,  0.3285,  0.6767],
                      [ 0.6301,  0.0497, -1.4183,  0.3445],
                      [ 0.4579, -0.2186,  1.5807,  0.9316]]),
       ),
)
[28]:
%timeit Batch.cat(batches)
178 µs ± 1.63 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
[29]:
batch = Batch({
    'obs': torch.randn(8, 4, 84, 84),
    'action': torch.randint(0, 6, size=(8, 1,)),
    'reward': torch.rand(8, 1)}
)

%timeit list(Batch.split(batch, 1, shuffle=False, merge_last=True))
452 µs ± 6.71 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
[ ]: