Benchmarks

Speed and memory comparisons.

import resource
import time
from concurrent import futures
from functools import partial
import numpy as np
from spector import indices, matrix, vector

def memory(unit=1e6):
    """Return memory usage in megabytes."""
    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / unit

def diff(metric, func, *args):
    """Return metric difference before and after function call."""
    start = metric()
    _ = func(*args)  # noqa
    return metric() - start

executor = futures.ProcessPoolExecutor()
def sized(func, *args):
    """Measure memory in a separate process."""
    return executor.submit(diff, memory, func, *args).result()

timed = partial(diff, time.time)

def dok(size):
    return {(i, j): 1.0 for i in range(size) for j in range(size)}

def vecs(size):
    arr = np.array(range(size))
    return matrix((i, vector(arr)) for i in range(size))

keys = np.array(range(2 ** 18))
values = np.ones(len(keys))

indices vs. set

# memory
sized(indices, keys) / sized(set, keys)

0.6575404973762264

# from array
timed(indices, keys) / timed(set, keys)

0.9379571787068183

# to array
timed(np.array, indices(keys)) / timed(np.fromiter, keys, keys.dtype, len(keys))

0.09806606195447544

# set op
timed(indices(keys).__sub__, indices(keys)) / timed(set(keys).__sub__, set(keys))

0.7381768552021837

vector vs. dict

# memory
sized(vector, keys, values) / sized(dict, zip(keys, values))

0.44884702825592737

# from arrays
timed(vector, keys, values) / timed(dict, zip(keys, values))

0.44178317671327066

vec, d = vector(keys, values), dict(zip(keys, values))
# keys
timed(vec.keys) / timed(np.fromiter, d.keys(), keys.dtype, len(d))

0.3060828060828061

# values
timed(vec.values) / timed(np.fromiter, d.values(), values.dtype, len(d))

0.27414184975814443

# sum
timed(np.sum, vec) / timed(sum, d.values())

0.02977646562631801

# dot
timed(vec.dot, vec) / timed(sum, (d[k] * d[k] for k in d))

0.03351056327493578

matrix vs. dict

size = int(len(keys) ** 0.5)
# memory
sized(vecs, size) / sized(dok, size)

0.0

groupby

Matrices rely on an optimized groupby implementation which is much faster than pandas, especially for integer keys.

import collections
import math
import random
import pandas as pd
from spector import groupby

def measure(size, base=10):
    buckets = [base ** exp for exp in range(round(math.log(size, base)) + 1)]
    data = np.array([random.randint(0, size) for _ in range(size)])
    rows = []
    values = np.arange(len(data))
    for num in buckets:
        keys = data % num
        df = pd.DataFrame({'keys': keys, 'values': values})
        rows.append({
            'hashed': timed(collections.deque, groupby(keys, values), 0),
            'sorted': timed(collections.deque, groupby(keys.astype('u8'), values), 0),
            'pandas': timed(collections.deque, df.groupby('keys', sort=False)['values'], 0),
        })
    return pd.DataFrame(rows, index=buckets)

df = measure(10 ** 5, 10)[['hashed', 'sorted', 'pandas']]
df.index.name = 'buckets'
df

	hashed	sorted	pandas
buckets
1	0.002075	0.002632	0.003111
10	0.002581	0.005743	0.003611
100	0.002686	0.006646	0.012685
1000	0.003882	0.010128	0.089451
10000	0.020858	0.030449	0.936619
100000	0.112520	0.125473	5.786675

for i in df.index:
    df.loc[i] = df.loc[i] / df.loc[i].min()
df

	hashed	sorted	pandas
buckets
1	1.0	1.268298	1.499138
10	1.0	2.225219	1.399261
100	1.0	2.474567	4.722947
1000	1.0	2.609016	23.042992
10000	1.0	1.459861	44.905456
100000	1.0	1.115111	51.427764