treevalue: OpenDILab树形结构数据容器

原作者: [db:作者] 来自: 网络收藏邀请

开源软件名称：

treevalue

开源软件地址：

https://gitee.com/opendilab/treevalue

开源软件介绍：

treevalue

PyPI - Python Version Loc Comments

GitHub commit activity

TreeValue is a generalized tree-based data structure mainly developed by OpenDILab Contributors.

Almost all the operation can be supported in form of trees in a convenient way to simplify the structure processing when the calculation is tree-based.

Installation

You can simply install it with pip command line from the official PyPI site.

pip install treevalue

For more information about installation, you can refer to the installation guide.

Documentation

The detailed documentation are hosted on https://opendilab.github.io/treevalue.

Only english version is provided now, the chinese documentation is still under development.

Quick Start

You can easily create a tree value object based on FastTreeValue.

from treevalue import FastTreeValueif __name__ == '__main__':    t = FastTreeValue({        'a': 1,        'b': 2.3,        'x': {            'c': 'str',            'd': [1, 2, None],            'e': b'bytes',        }    })    print(t)

The result should be

<FastTreeValue 0x7f6c7df00160 keys: ['a', 'b', 'x']>├── 'a' --> 1├── 'b' --> 2.3└── 'x' --> <FastTreeValue 0x7f6c81150860 keys: ['c', 'd', 'e']>    ├── 'c' --> 'str'    ├── 'd' --> [1, 2, None]    └── 'e' --> b'bytes'

And t is structure should be like this

Not only a visible tree structure, but abundant operation supports is provided.You can just put objects (such as torch.Tensor, or any other types) here and justcall their methods, like this

import torchfrom treevalue import FastTreeValuet = FastTreeValue({    'a': torch.rand(2, 5),    'x': {        'c': torch.rand(3, 4),    }})print(t)# <FastTreeValue 0x7f8c069346a0># ├── a --> tensor([[0.3606, 0.2583, 0.3843, 0.8611, 0.5130],# │                 [0.0717, 0.1370, 0.1724, 0.7627, 0.7871]])# └── x --> <FastTreeValue 0x7f8ba6130f40>#     └── c --> tensor([[0.2320, 0.6050, 0.6844, 0.3609],#                       [0.0084, 0.0816, 0.8740, 0.3773],#                       [0.6523, 0.4417, 0.6413, 0.8965]])print(t.shape)  # property access# <FastTreeValue 0x7f8c06934ac0># ├── a --> torch.Size([2, 5])# └── x --> <FastTreeValue 0x7f8c069346d0>#     └── c --> torch.Size([3, 4])print(t.sin())  # method call# <FastTreeValue 0x7f8c06934b80># ├── a --> tensor([[0.3528, 0.2555, 0.3749, 0.7586, 0.4908],# │                 [0.0716, 0.1365, 0.1715, 0.6909, 0.7083]])# └── x --> <FastTreeValue 0x7f8c06934b20>#     └── c --> tensor([[0.2300, 0.5688, 0.6322, 0.3531],#                       [0.0084, 0.0816, 0.7669, 0.3684],#                       [0.6070, 0.4275, 0.5982, 0.7812]])print(t.reshape((2, -1)))  # method with arguments# <FastTreeValue 0x7f8c06934b80># ├── a --> tensor([[0.3606, 0.2583, 0.3843, 0.8611, 0.5130],# │                 [0.0717, 0.1370, 0.1724, 0.7627, 0.7871]])# └── x --> <FastTreeValue 0x7f8c06934b20>#     └── c --> tensor([[0.2320, 0.6050, 0.6844, 0.3609, 0.0084, 0.0816],#                       [0.8740, 0.3773, 0.6523, 0.4417, 0.6413, 0.8965]])print(t[:, 1:-1])  # index operator# <FastTreeValue 0x7f8ba5c8eca0># ├── a --> tensor([[0.2583, 0.3843, 0.8611],# │                 [0.1370, 0.1724, 0.7627]])# └── x --> <FastTreeValue 0x7f8ba5c8ebe0>#     └── c --> tensor([[0.6050, 0.6844],#                       [0.0816, 0.8740],#                       [0.4417, 0.6413]])print(1 + (t - 0.8) ** 2 * 1.5)  # math operators# <FastTreeValue 0x7fdfa5836b80># ├── a --> tensor([[1.6076, 1.0048, 1.0541, 1.3524, 1.0015],# │                 [1.0413, 1.8352, 1.2328, 1.7904, 1.0088]])# └── x --> <FastTreeValue 0x7fdfa5836880>#     └── c --> tensor([[1.1550, 1.0963, 1.3555, 1.2030],#                       [1.0575, 1.4045, 1.0041, 1.0638],#                       [1.0782, 1.0037, 1.5075, 1.0658]])

For more quick start explanation and further usage, take a look at:

Speed Performance

Here is the speed performance of all the operations in FastTreeValue, the following table is the performance comparison result with dm-tree.

	flatten	flatten(with path)	mapping	mapping(with path)
treevalue	---	511 ns ± 6.92 ns	3.16 µs ± 42.8 ns	1.58 µs ± 30 ns
	flatten	flatten_with_path	map_structure	map_structure_with_path
dm-tree	830 ns ± 8.53 ns	11.9 µs ± 358 ns	13.3 µs ± 87.2 ns	62.9 µs ± 2.26 µs

The following 2 tables are the performance comparison result with jax pytree.

	mapping	mapping(with path)	flatten	unflatten	flatten_values	flatten_keys
treevalue	2.21 µs ± 32.2 ns	2.16 µs ± 123 ns	515 ns ± 7.53 ns	601 ns ± 5.99 ns	301 ns ± 12.9 ns	451 ns ± 17.3 ns
	tree_map	(Not Implemented)	tree_flatten	tree_unflatten	tree_leaves	tree_structure
jax pytree	4.67 µs ± 184 ns	---	1.29 µs ± 27.2 ns	742 ns ± 5.82 ns	1.29 µs ± 22 ns	1.27 µs ± 16.5 ns

	flatten + all	flatten + reduce	flatten + reduce(with init)	rise(given structure)	rise(automatic structure)
treevalue	425 ns ± 9.33 ns	702 ns ± 5.93 ns	793 ns ± 13.4 ns	9.14 µs ± 129 ns	11.5 µs ± 182 ns
	tree_all	tree_reduce	tree_reduce(with init)	tree_transpose	(Not Implemented)
jax pytree	1.47 µs ± 37 ns	1.88 µs ± 27.2 ns	1.91 µs ± 47.4 ns	10 µs ± 117 ns	---

This is the comparison between dm-tree, jax-libtree and us, with flatten and mapping operations (lower value means less time cost and runs faster)

Time cost of flatten operation

Time cost of mapping operation

The following table is the performance comparison result with tianshou Batch.

	get	set	init	deepcopy	stack	cat	split
treevalue	51.6 ns ± 0.609 ns	64.4 ns ± 0.564 ns	750 ns ± 14.2 ns	88.9 µs ± 887 ns	50.2 µs ± 771 ns	40.3 µs ± 1.08 µs	62 µs ± 1.2 µs
tianshou Batch	43.2 ns ± 0.698 ns	396 ns ± 8.99 ns	11.1 µs ± 277 ns	89 µs ± 1.42 µs	119 µs ± 1.1 µs	194 µs ± 1.81 µs	653 µs ± 17.8 µs

And this is the comparison between tianshou Batch and us, with cat , stack and split operations (lower value means less time cost and runs faster)

Time cost of cat operation

Time cost of stack operation

Time cost of split operation

Test benchmark code can be found here:

Extension

If you need to translate treevalue object to runnable source code, you may use the potc-treevalue plugin with the installation command below

pip install potc-treevalue

Or just install it with treevalue itself

pip install treevalue[potc]

In potc, you can translate the objects to runnable python source code, which can be loaded to objects afterwards by the python interpreter, like the following graph

potc system