Blosc2 Btune

Btune是Blosc2的一个动态插件，可以帮助找到最佳的压缩参数组合。它通过在您的最具代表性的数据集上训练神经网络来实现。

默认情况下，该软件使用遗传算法测试满足您对数据集中每个数据块压缩比和速度要求的不同压缩参数组合。它为每个组合分配一个分数，经过多次迭代后，软件停止并使用找到的最佳分数（最小值）来处理剩余的数据集。更多信息及图形可视化，请访问https://btune.blosc.org。

由于压缩参数组合（编解码器、压缩级别、过滤器、分割模式、线程数等）数量庞大，Blosc2中寻找最佳压缩参数的过程可能很慢。这可能需要大量的尝试和错误才能找到最佳组合。然而，通过在您的数据集上训练神经网络，您可以显著加速此过程。

要开始训练过程，请将您的数据集提供给Blosc开发团队。然后我们将进行训练，并提供针对您需求的定制神经网络模型，以及Blosc2的一般调优建议。作为交换，我们请求对项目的财务贡献。

此外，我们还添加了一种支持整数数据类型图像数据集的损失压缩模式。这结合了神经网络和启发式结果。

如果您感兴趣，请联系我们contact@blosc.org。

安装Btune轮子

Btune使用Python轮子进行安装，但可以从任何使用C-Blosc2的应用程序中使用它，无论是C、Python还是任何其他语言。目前，仅支持Linux和Mac安装程序。

pip install blosc2-btune

接下来，我们将运行Python和C的示例。要做到这一点，请将当前目录更改为该存储库中的examples目录。

cd examples

使用Python中的Btune

要在Python中使用Blosc2的Btune，您可以通过环境变量或程序化方式来实现。

通过环境变量

• 将环境变量BTUNE_TRADEOFF设置为介于0（仅优化速度）和1（仅优化压缩率）之间的浮点数。
• 此外，您可以使用BTUNE_PERF_MODE来优化压缩、解压缩或通过将其设置为COMP、DECOMP或BALANCED来平衡两者。

BTUNE_TRADEOFF=0.5 BTUNE_PERF_MODE=COMP python create_ndarray.py
WARNING: Empty metadata, no inference performed
NDArray succesfully created!

这将在磁盘上创建一个包含一些数据的NDArray。警告消息空元数据，没有进行推断可以忽略，因为我们还没有使用训练过的模型。

程序化

在创建数组时设置cparams={"tuner": blosc2.Tuner.BTUNE}，就像在btune_config.py脚本中一样。我们将在本节稍后访问这个示例。

启用跟踪

您可以将BTUNE_TRACE=1设置为查看Btune正在做什么。

BTUNE_TRACE=1 BTUNE_TRADEOFF=0.5 BTUNE_PERF_MODE=COMP python create_ndarray.py
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Btune version: 1.1.2
Performance Mode: COMP, Compression tradeoff: 0.500000, Bandwidth: 20 GB/s
Behaviour: Waits - 0, Softs - 5, Hards - 10, Repeat Mode - STOP
TRACE: Environment variable BTUNE_MODELS_DIR is not defined
WARNING: Empty metadata, no inference performed
|    Codec   | Filter | Split | C.Level | C.Threads | D.Threads |  S.Score  |  C.Ratio   |   Btune State   | Readapt | Winner
|        lz4 |      0 |     1 |       8 |        16 |        16 |     0.144 |      1.97x |    CODEC_FILTER |    HARD | W
|        lz4 |      0 |     0 |       8 |        16 |        16 |     0.933 |      2.07x |    CODEC_FILTER |    HARD | W
|        lz4 |      1 |     1 |       8 |        16 |        16 |      3.23 |      3.97x |    CODEC_FILTER |    HARD | W
|        lz4 |      1 |     0 |       8 |        16 |        16 |      7.66 |      3.91x |    CODEC_FILTER |    HARD | -
|        lz4 |      2 |     1 |       8 |        16 |        16 |      1.55 |      4.52x |    CODEC_FILTER |    HARD | -
|        lz4 |      2 |     0 |       8 |        16 |        16 |      2.84 |      4.46x |    CODEC_FILTER |    HARD | -
|    blosclz |      0 |     1 |       8 |        16 |        16 |     0.386 |      1.98x |    CODEC_FILTER |    HARD | -
|    blosclz |      0 |     0 |       8 |        16 |        16 |     0.492 |      2.09x |    CODEC_FILTER |    HARD | -
|    blosclz |      1 |     1 |       8 |        16 |        16 |      1.33 |      3.97x |    CODEC_FILTER |    HARD | -
|    blosclz |      1 |     0 |       8 |        16 |        16 |      1.72 |      3.82x |    CODEC_FILTER |    HARD | -
|    blosclz |      2 |     1 |       8 |        16 |        16 |      1.83 |      4.47x |    CODEC_FILTER |    HARD | -
|    blosclz |      2 |     0 |       8 |        16 |        16 |      1.65 |      4.35x |    CODEC_FILTER |    HARD | -
|        lz4 |      1 |     1 |       8 |        14 |        16 |     0.151 |      3.97x |    THREADS_COMP |    HARD | -
|        lz4 |      1 |     1 |       8 |        18 |        16 |     0.111 |      3.97x |    THREADS_COMP |    HARD | -
|        lz4 |      1 |     1 |       7 |        16 |        16 |     0.108 |      3.97x |          CLEVEL |    HARD | -
|        lz4 |      1 |     1 |       9 |        16 |        16 |      9.92 |      3.97x |          CLEVEL |    HARD | W
|        lz4 |      1 |     1 |       8 |        16 |        16 |      9.96 |      3.97x |          CLEVEL |    SOFT | W
|        lz4 |      1 |     1 |       7 |        16 |        16 |      9.74 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |      1 |     1 |       6 |        16 |        16 |      9.78 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |      1 |     1 |       7 |        16 |        16 |      10.1 |      3.97x |          CLEVEL |    SOFT | W
NDArray succesfully created!

您可以在Winner列中看到组合是否是赢家（W），它不改进以前的赢家（-）。当Btune找到一个特殊的值块（即块由重复的值组成，这些值以特殊方式编码）时，它输出S，这意味着Btune无法确定这是否是赢家（它不是按常规方式压缩的）。

Btune模型

Blosc开发团队提供了一种名为Btune模型的服务，其中我们提供专门针对您的数据进行训练的神经网络模型，以确定最佳的编解码器和过滤器组合。要使用这些模型，请设置BTUNE_MODELS_DIR为包含模型文件的目录，在Blosc开发团队完成训练后。然后Btune将自动使用训练过的模型；请继续阅读以了解它是如何工作的。

要确定进行推断的块数，请使用BTUNE_USE_INFERENCE。如果设置为-1，则在所有块上执行推断。如果设置为大于0的数字，则在该数量的块上执行推断，然后调整其余块的参数。如果设置为0，则完全不执行推断。默认值为-1。

BTUNE_TRADEOFF=0.5 BTUNE_PERF_MODE=COMP BTUNE_TRACE=1  BTUNE_MODELS_DIR=./models/ BTUNE_USE_INFERENCE=3 python create_ndarray.py
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Btune version: 1.1.2
Performance Mode: COMP, Compression tradeoff: 0.500000, Bandwidth: 20 GB/s
Behaviour: Waits - 0, Softs - 5, Hards - 10, Repeat Mode - STOP
INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
TRACE: time load model: 0.000558
TRACE: Inference category=39 codec=1 filter=35 clevel=5 splitmode=1 time entropy=0.000501 inference=0.000015
|    Codec   | Filter | Split | C.Level | C.Threads | D.Threads |  S.Score  |  C.Ratio   |   Btune State   | Readapt | Winner
|        lz4 |     35 |     1 |       5 |        16 |        16 |     0.162 |      3.97x |    CODEC_FILTER |    HARD | W
TRACE: Inference category=39 codec=1 filter=35 clevel=5 splitmode=1 time entropy=0.000201 inference=0.000002
|        lz4 |     35 |     1 |       5 |        16 |        16 |      4.14 |      3.97x |    CODEC_FILTER |    HARD | W
TRACE: Inference category=39 codec=1 filter=35 clevel=5 splitmode=1 time entropy=0.000175 inference=0.000003
|        lz4 |     35 |     1 |       5 |        16 |        16 |      2.85 |      3.97x |    CODEC_FILTER |    HARD | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.79 |      3.97x |    CODEC_FILTER |    HARD | -
|        lz4 |     35 |     1 |       5 |        14 |        16 |    0.0765 |      3.97x |    THREADS_COMP |    HARD | -
|        lz4 |     35 |     1 |       5 |        18 |        16 |    0.0996 |      3.97x |    THREADS_COMP |    HARD | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |       0.1 |      3.97x |          CLEVEL |    HARD | -
|        lz4 |     35 |     1 |       6 |        16 |        16 |      3.87 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |       3.7 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       4 |        16 |        16 |      3.96 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.94 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       6 |        16 |        16 |      3.96 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.94 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       4 |        16 |        16 |      3.97 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.97 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       6 |        16 |        16 |      3.94 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.96 |      3.97x |          CLEVEL |    SOFT | -
|        lz4 |     35 |     1 |       5 |        16 |        16 |      3.98 |      3.97x |    CODEC_FILTER |    HARD | -
|        lz4 |     35 |     1 |       5 |        14 |        16 |     0.116 |      3.97x |    THREADS_COMP |    HARD | -
|        lz4 |     35 |     1 |       5 |        18 |        16 |    0.0959 |      3.97x |    THREADS_COMP |    HARD | -
NDArray succesfully created!

使用Btune模型通常会导致性能分数显著提高，如上表所示。此外，使用训练模型找到最佳组合的过程要快得多。有关更多信息，请参阅https://btune.blosc.org。

从Python程序化配置Btune

如果您想在同一脚本中使用不同的配置来配置不同的Blosc2数据容器，您可以通过从Python配置Btune而不是使用环境变量来实现。为此，您需要通过将所需配置作为关键字参数传递给set_params_defaults函数来设置所需的配置。

kwargs = {"tradeoff": 0.3, "perf_mode": blosc2_btune.PerformanceMode.DECOMP}
blosc2_btune.set_params_defaults(**kwargs)

然后，通过cparams={"tuner": blosc2.Tuner.BTUNE}告诉Blosc2您想使用Btune。

ba = blosc2.asarray(a, urlpath=urlpath, mode="w", chunks=(1e6,), cparams={"tuner": blosc2.Tuner.BTUNE})

查看激活BTUNE_TRACE环境变量时的输出示例

BTUNE_TRACE=1 python btune_config.py
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Btune version: 1.1.2
Performance Mode: DECOMP, Compression tradeoff: 0.300000, Bandwidth: 20 GB/s
Behaviour: Waits - 0, Softs - 5, Hards - 10, Repeat Mode - STOP
INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
TRACE: time load model: 0.000503
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000292 inference=0.000009
|    Codec   | Filter | Split | C.Level | C.Threads | D.Threads |  S.Score  |  C.Ratio   |   Btune State   | Readapt | Winner
|        lz4 |      0 |     1 |       5 |        16 |        16 |      0.17 |      1.97x |    CODEC_FILTER |    HARD | W
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000137 inference=0.000002
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.285 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000040 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.282 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000035 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.272 |      1.97x |    CODEC_FILTER |    HARD | W
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000164 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.291 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000081 inference=0.000004
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.149 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000118 inference=0.000002
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.153 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000099 inference=0.000002
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.155 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000062 inference=0.000002
|        lz4 |      0 |     1 |       5 |        16 |        16 |      0.15 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000039 inference=0.000003
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.229 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000032 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.277 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000033 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.282 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000032 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.286 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000034 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.295 |      1.97x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000036 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.277 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=0 codec=0 filter=0 clevel=5 splitmode=2 time entropy=0.000035 inference=0.000001
|    blosclz |      0 |     0 |       5 |        16 |        16 |     0.263 |      2.08x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=0 codec=0 filter=0 clevel=5 splitmode=2 time entropy=0.000035 inference=0.000001
|    blosclz |      0 |     0 |       5 |        16 |        16 |      0.26 |      2.08x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=36 codec=1 filter=0 clevel=5 splitmode=1 time entropy=0.000032 inference=0.000001
|        lz4 |      0 |     1 |       5 |        16 |        16 |     0.294 |      1.96x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=0 codec=0 filter=0 clevel=5 splitmode=2 time entropy=0.000035 inference=0.000001
|    blosclz |      0 |     0 |       5 |        16 |        16 |     0.268 |      2.08x |    CODEC_FILTER |    HARD | -
TRACE: Inference category=0 codec=0 filter=0 clevel=5 splitmode=2 time entropy=0.000035 inference=0.000001
|    blosclz |      0 |     0 |       5 |        16 |        16 |     0.266 |      2.08x |    CODEC_FILTER |    HARD | -
NDArray succesfully created in btune_config.b2nd

这里我们将权衡设置为0.3，性能模式设置为DECOMP。

Btune质量模式

现在Btune不仅可以考虑压缩比和速度，还可以考虑质量。这是用于由整数数据类型组成的图像数据集的。另一个要求是系统必须安装blosc2_grok插件。

要使用它，您必须将BTUNE_TRADEOFF设置为3个值的元组(cratio, speed, quality)。这些必须加起来为1。值越大，它就越重要。

在 examples 目录下有一个 Python 示例 lossy.py，它创建了一个由 10 个块组成的 NDArray（每个块对应一个图像）。您可以使用以下命令运行它：

BTUNE_TRACE=1 python lossy.py lossy_example.tif
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Btune version: 1.1.2
Performance Mode: COMP, Compression tradeoff: (0.500000, 0.300000, 0.200000), Bandwidth: 20 GB/s
Behaviour: Waits - 0, Softs - 5, Hards - 10, Repeat Mode - STOP
INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
TRACE: time load model: 0.000487
|    Codec   | Filter | Split | C.Level | C.Threads | D.Threads |  S.Score  |  C.Ratio   |   Btune State   | Readapt | Winner
|       grok |      0 |     0 |       5 |        16 |        16 |  0.000468 |      8.15x |    CODEC_FILTER |    HARD | W
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0236 |      8.15x |    CODEC_FILTER |    HARD | W
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0297 |      8.15x |    CODEC_FILTER |    HARD | W
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0362 |      8.15x |    CODEC_FILTER |    HARD | W
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0328 |      8.15x |    CODEC_FILTER |    HARD | -
|       grok |      0 |     0 |       5 |        16 |        16 |     0.036 |      8.15x |    CODEC_FILTER |    HARD | -
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0399 |      8.15x |    CODEC_FILTER |    HARD | W
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0371 |      8.15x |    CODEC_FILTER |    HARD | -
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0318 |      8.15x |    CODEC_FILTER |    HARD | -
|       grok |      0 |     0 |       5 |        16 |        16 |    0.0252 |      8.15x |    CODEC_FILTER |    HARD | -

所使用的权衡策略告诉 Btune 您非常关注压缩率，但不是特别关注速度或质量损失。据此，Btune 预测使用 blosc2_grok 编解码器，并设法在牺牲一些质量的情况下实现了 8 倍的压缩比。

类似于传统的 Btune，您可以使用 BTUNE_TRADEOFF 环境变量来更改权衡策略

BTUNE_TRADEOFF="(0.3, 0.1, 0.6)" BTUNE_PERF_MODE=DECOMP BTUNE_TRACE=1 python lossy.py lossy_example.tif

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Btune version: 1.1.2
Performance Mode: DECOMP, Compression tradeoff: (0.300000, 0.100000, 0.600000), Bandwidth: 20 GB/s
Behaviour: Waits - 0, Softs - 5, Hards - 10, Repeat Mode - STOP
INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
TRACE: time load model: 0.000755
|    Codec   | Filter | Split | C.Level | C.Threads | D.Threads |  S.Score  |  C.Ratio   |   Btune State   | Readapt | Winner
|       zstd |     36 |     1 |       3 |        16 |        16 |     0.102 |      2.18x |    CODEC_FILTER |    HARD | W
|       zstd |     36 |     1 |       3 |        16 |        16 |     0.125 |      2.18x |    CODEC_FILTER |    HARD | W
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0815 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0805 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0801 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0828 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0834 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |    0.0826 |      2.18x |    CODEC_FILTER |    HARD | -
|       zstd |     36 |     1 |       3 |        16 |        16 |     0.129 |      2.18x |    CODEC_FILTER |    HARD | W
|       zstd |     36 |     1 |       3 |        16 |        16 |     0.144 |      2.18x |    CODEC_FILTER |    HARD | W

在这种情况下，由于质量比以前更重要，Btune 预测使用具有整数截断过滤器（ID 36）的 zstd 编解码器，其质量优于压缩比为 x8 的 blosc2_grok 编解码器。

从 C 使用 Btune

您还可以从 C 使用 Btune。类似于上面的 Python 示例，您可以通过设置 BTUNE_TRADEOFF 环境变量来激活它。或者，您可以将压缩参数中的 tuner_id（也称为 cparams）设置为 BLOSC_BTUNE 的值。这将使用默认的 Btune 配置。然而，从 C 运行 Btune 的优势在于能够根据您的偏好调整更多参数

    // compression params
    blosc2_cparams cparams = BLOSC2_CPARAMS_DEFAULTS;
    cparams.nthreads = 16; // Btune may lower this
    cparams.typesize = schunk_in->typesize;

    // btune
    btune_config btune_config = BTUNE_CONFIG_DEFAULTS;
    //btune_config.perf_mode = BTUNE_PERF_DECOMP;
    btune_config.tradeoff[0] = .5;
    btune_config.tradeoff_nelems = 1;
    /* For lossy mode it would be
    btune_config.tradeoff[0] = .5;
    btune_config.tradeoff[1] = .2;
    btune_config.tradeoff[2] = .3;
    btune_config.tradeoff_nelems = 3;
    */
    btune_config.behaviour.nhards_before_stop = 10;
    btune_config.behaviour.repeat_mode = BTUNE_REPEAT_ALL;
    btune_config.use_inference = 2;
    char *models_dir = "./models/";
    strcpy(btune_config.models_dir, models_dir);
    cparams.tuner_id = BLOSC_BTUNE;
    cparams.tuner_params = &btune_config;

    // Create super chunk
    blosc2_dparams dparams = BLOSC2_DPARAMS_DEFAULTS;
    dparams.nthreads = 1;
    blosc2_storage storage = {
        .cparams=&cparams,
        .dparams=&dparams,
        .contiguous=true,
        .urlpath=(char*)out_fname
    };
    blosc2_schunk* schunk_out = blosc2_schunk_new(&storage);

请参阅 examples/btune_example.c 中的完整示例。您可以通过以下方式编译和运行此示例：

Linux

gcc -o btune_example btune_example.c -lblosc2 -lm -I $CONDA_PREFIX/include/ -L $CONDA_PREFIX/lib64/
BTUNE_TRACE=1 LD_LIBRARY_PATH=$CONDA_PREFIX/lib64 ./btune_example rand_int.b2nd out.b2nd

MacOS

gcc -o btune_example btune_example.c -lblosc2 -lm -I $CONDA_PREFIX/include/ -I $CONDA_PREFIX/lib/python3.xx/site-packages/include/ -L $CONDA_PREFIX/lib/
BTUNE_TRACE=1 DYLD_LIBRARY_PATH=$CONDA_PREFIX/lib ./btune_example rand_int.b2nd out.b2nd

优化技巧

如果您希望使用相同的模型处理不同的数组，您可以使用 Python 的 ReuseModels 上下文管理器来保存加载时间并重用第一次加载的模型

with blosc2_btune.ReuseModels():
    for nchunk in range(0, nchunks):
        b = blosc2.asarray(a[nchunk * chunk_nitems:(nchunk + 1) * chunk_nitems], chunks=(chunk_nitems,), blocks=(chunk_nitems//10,), cparams=cparams)
        tr += time() - tref

这允许在上下文中重用相同的模型，并在结束时管理所有需要释放的引用和内存。根据您的需要，这可能会使您的程序大约加速 5%。您可以在 reuse_models.py 示例中查看重用模型和每次重新加载模型的比较：

INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
Creating arrays reusing loaded models
Creating arrays reloading models each time
Reusing time: 0.542s (1.476 GB/s)
Reloading time: 0.547s (1.463 GB/s)

平台支持

目前，我们支持在 Intel/ARM64 Linux 和 Intel/ARM64 Mac 以及 Intel Windows 上使用 Btune，并为这些平台提供二进制轮子。