diff --git a/zarrtraj/benchmarking.ipynb b/zarrtraj/benchmarking.ipynb index e69de29..144d59a 100644 --- a/zarrtraj/benchmarking.ipynb +++ b/zarrtraj/benchmarking.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [], + "source": [ + "# Method to create trajectory data\n", + "# based on MDAnalaysisTests/data/coordinates/create_data.py\n", + "\n", + "import numpy as np\n", + "\n", + "def generate_traj(n_atoms, frames):\n", + " pos = np.arange(3 * n_atoms).reshape(n_atoms, 3)\n", + " orig_box = np.array([81.1, 82.2, 83.3, 75, 80, 85], dtype=np.float32)\n", + "\n", + " positions = np.empty((frames, n_atoms, 3), dtype=np.float32)\n", + " velocities = np.empty((frames, n_atoms, 3), dtype=np.float32)\n", + " forces = np.empty((frames, n_atoms, 3), dtype=np.float32)\n", + " time = np.empty((frames), dtype=np.float32)\n", + " frame = np.empty((frames), dtype=np.int32)\n", + "\n", + " dimensions = np.empty((frames, 6))\n", + "\n", + " for i in range(frames):\n", + " positions[i] = 2** i * pos\n", + " velocities[i] = positions[i] / 10\n", + " forces[i] = positions[i] / 100\n", + " time[i] = i\n", + " frame[i] = i\n", + "\n", + " dimensions[i][:3] = orig_box[:3] + i\n", + " dimensions[i][3:] = orig_box[3:] + i * 0.1\n", + "\n", + " return [frames, dimensions, positions, velocities, forces, time]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "# Method to load trajectory data into a zarr trajectory \n", + "# Also includes a method to load data into an hdf5 traj using the same \n", + "# test format to make a fair comparison\n", + "\n", + "import zarr\n", + "import h5py\n", + "\n", + "def create_zarr_traj(n_atoms, frames, compressor):\n", + " # create zarr group layout\n", + " root = zarr.open(f'zarrfiles/zarr_{n_atoms}_{frames}.zarr', mode='a')\n", + " particles = root.create_group('particles')\n", + " group1 = particles.create_group('group1')\n", + " box = group1.create_group('box')\n", + " edges = box.create_group('edges')\n", + " position = group1.create_group('position')\n", + " velocity = group1.create_group('velocity')\n", + " force = group1.create_group('force')\n", + "\n", + " traj = generate_traj(n_atoms, frames)\n", + "\n", + " edges.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " edges.create_dataset('value', data=traj[1], dtype=np.float32)\n", + " position.create_dataset('value', data=traj[2], compressor=compressor, \n", + " chunks=(1, n_atoms, 3), dtype=np.float32)\n", + " position.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " position.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + " velocity.create_dataset('value', data=traj[3], compressor=compressor, \n", + " chunks=(1, n_atoms, 3), dtype=np.float32)\n", + " velocity.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " velocity.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + " force.create_dataset('value', data=traj[4], compressor=compressor, \n", + " chunks=(1, n_atoms, 3), dtype=np.float32)\n", + " force.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " force.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + "\n", + " # Return filename to make it easy to open file\n", + " return f'zarrfiles/zarr_{n_atoms}_{frames}.zarr'\n", + "\n", + "\n", + "def create_hdf5_traj(n_atoms, frames, compression, compression_opts):\n", + " with h5py.File(f'h5files/h5_{n_atoms}_{frames}.h5', 'w') as root:\n", + " particles = root.create_group('particles')\n", + " group1 = particles.create_group('group1')\n", + " box = group1.create_group('box')\n", + " edges = box.create_group('edges')\n", + " position = group1.create_group('position')\n", + " velocity = group1.create_group('velocity')\n", + " force = group1.create_group('force')\n", + "\n", + " traj = generate_traj(n_atoms, frames)\n", + "\n", + " edges.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " edges.create_dataset('value', data=traj[1], dtype=np.float32)\n", + " position.create_dataset('value', data=traj[2], compression=compression, \n", + " compression_opts=compression_opts, chunks=(1, n_atoms, 3),\n", + " dtype=np.float32)\n", + " position.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " position.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + " velocity.create_dataset('value', data=traj[3], compression=compression, \n", + " compression_opts=compression_opts, chunks=(1, n_atoms, 3),\n", + " dtype=np.float32)\n", + " velocity.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " velocity.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + " force.create_dataset('value', data=traj[4], compression=compression, \n", + " compression_opts=compression_opts, chunks=(1, n_atoms, 3),\n", + " dtype=np.float32)\n", + " force.create_dataset('step', data=traj[0], dtype=np.int32)\n", + " force.create_dataset('time', data=traj[-1], dtype=np.float32)\n", + "\n", + " # Return filename to make it easy to open file\n", + " return f'h5files/h5_{n_atoms}_{frames}.h5'\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import subprocess\n", + "\n", + "\n", + "def zarr_filesize(filename):\n", + " return int(subprocess.check_output(['du','-s', filename]).split()[0].decode('utf-8'))\n", + "def h5_filesize(filename):\n", + " return int(subprocess.check_output(['du','-s', filename]).split()[0].decode('utf-8'))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "import zarr\n", + "import h5py\n", + "import time\n", + "\n", + "# Each method opens, iterates through each frame, and closes the file\n", + "\n", + "def zarr_iterate_frames(filename):\n", + " start_time = time.time()\n", + " root = zarr.open(filename, mode='a')\n", + " pos_vals = root['particles/group1/position/value']\n", + " num = 0\n", + " for i in range(len(pos_vals)):\n", + " # arbitrary task that requires accessing third dimension\n", + " num += pos_vals[i][0][0]\n", + " end_time = time.time()\n", + " return end_time - start_time\n", + "\n", + "def h5_iterate_frames(filename):\n", + " start_time = time.time()\n", + " with h5py.File(filename, 'r') as root:\n", + " pos_vals = root['particles/group1/position/value']\n", + " num = 0\n", + " for i in range(len(pos_vals)):\n", + " # arbitrary task that requires accessing third dimension\n", + " num += pos_vals[i][0][0]\n", + " end_time = time.time()\n", + " return end_time - start_time\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "import zarr\n", + "\n", + "# Create files of different sizes\n", + "\n", + "\n", + "n = []\n", + "z_filesize = []\n", + "h_filesize =[]\n", + "\n", + "for i in range(1000, 50001, 500):\n", + " compressor = zarr.Blosc(cname='zstd', clevel=9, shuffle=zarr.Blosc.SHUFFLE)\n", + " zarr_fname = create_zarr_traj(i, 5, compressor)\n", + " h5_fname = create_hdf5_traj(i, 5, compression='gzip', compression_opts=9)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Graph filesize vs num atoms for hdf5 and zarr\n", + "\n", + "n = [np.arange(1000, 50001, 500)]\n", + "z_filesize = []\n", + "h_filesize =[]\n", + "\n", + "for i in range(1000, 50001, 500):\n", + " z_filesize.append(zarr_filesize(f'zarrfiles/zarr_{i}_5.zarr'))\n", + " h_filesize.append(h5_filesize(f'h5files/h5_{i}_5.h5'))\n", + "\n", + "# Graph zarrtraj size vs h5 size\n", + "plt.xlabel('Number of atoms')\n", + "plt.ylabel('Trajectory filesize')\n", + "\n", + "plt.scatter(n, z_filesize, c='blue', s=10)\n", + "plt.scatter(n, h_filesize, c='red', s=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Graph iteration time vs number atoms for hdf5 and zarr\n", + "\n", + "n = [np.arange(1000, 50001, 2000)]\n", + "z_iteration_time = []\n", + "h_iteration_time = []\n", + "\n", + "for i in range(1000, 50001, 2000):\n", + " z_iteration_time.append(zarr_iterate_frames(f'zarrfiles/zarr_{i}_5.zarr'))\n", + " h_iteration_time.append(h5_iterate_frames(f'h5files/h5_{i}_5.h5'))\n", + "\n", + "\n", + "\n", + "\n", + "# Graph zarrtraj size vs h5 size\n", + "plt.xlabel('Number of atoms')\n", + "plt.ylabel('Trajectory filesize')\n", + "\n", + "plt.scatter(n, z_iteration_time, c='blue')\n", + "plt.scatter(n, h_iteration_time, c='red')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "zarrtraj", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}