many compression algorithm benchmark: applied to binary voxel map

[HiroIshida]

とりあえず zstd の level = 15を使うのがよさそう

import numpy as np
import matplotlib.pyplot as plt
import tqdm
import time
import zstandard
import lz4
import lzma
import zlib
import zstd
import brotli

from rpbench.articulated.world.jail import ConwayJailWorld

def zlib_compress(data, level):
    return zlib.compress(data, level)

def lzma_compress(data, level):
    return lzma.compress(data, preset=level)

def zstd_compress(data, level):
    return zstd.compress(data, level)

def brotli_compress(data, level):
    return brotli.compress(data, quality=level)

def bench(datas, algorithm, max_level):
    results = []
    for level in tqdm.tqdm(range(1, max_level + 1)):
        size_sum = 0.0
        elapsed_sum = 0.0
        n_data = len(datas)
        for data in datas:
            ts = time.time()
            b = algorithm(data, level)
            elapsed = time.time() - ts
            size_sum += len(b)
            elapsed_sum += elapsed
        results.append((size_sum / n_data, 1000 * elapsed_sum / n_data))
    return results

n = 100
worlds = [ConwayJailWorld.sample() for _ in range(n)]
datas = [world.voxels.to_3darray() for world in worlds]
print("data prepared")

fig, ax = plt.subplots()

results = bench(datas, brotli_compress, 11)
sizes, times = zip(*results)
ax.plot(np.array(sizes), np.array(times), '^', label='brotli')

results = bench(datas, zstd_compress, 22)
sizes, times = zip(*results)
ax.plot(np.array(sizes), np.array(times), 's', label='zstd')

results = bench(datas, zlib_compress, 9)
sizes, times = zip(*results)
ax.plot(np.array(sizes), np.array(times), 'o', label='zlib')

results = bench(datas, lzma_compress, 9)
sizes, times = zip(*results)
ax.plot(np.array(sizes), np.array(times), 'x', label='lzma')

ax.set_xlim(left=0)
plt.legend(prop={'size': 20})
ax.set_xlabel("compressed size (bytes)", fontsize=20)
ax.set_ylabel("time (ms)", fontsize=20)
ax.tick_params(axis='both', which='major', labelsize=14)
plt.grid()
plt.show()