File size: 3,033 Bytes
095b0c2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
"""
Author(s): Matthew Loper
See LICENCE.txt for licensing and contact information.
"""
import scipy.sparse as sp
import numpy as np
def row(A):
return A.reshape((1, -1))
def col(A):
return A.reshape((-1, 1))
class timer(object):
def time(self):
import time
return time.time()
def __init__(self):
self._elapsed = 0
self._start = self.time()
def __call__(self):
if self._start is not None:
return self._elapsed + self.time() - self._start
else:
return self._elapsed
def pause(self):
assert self._start is not None
self._elapsed += self.time() - self._start
self._start = None
def resume(self):
assert self._start is None
self._start = self.time()
def dfs_do_func_on_graph(node, func, *args, **kwargs):
'''
invoke func on each node of the dr graph
'''
for _node in node.tree_iterator():
func(_node, *args, **kwargs)
def sparse_is_desireable(lhs, rhs):
'''
Examines a pair of matrices and determines if the result of their multiplication should be sparse or not.
'''
return False
if len(lhs.shape) == 1:
return False
else:
lhs_rows, lhs_cols = lhs.shape
if len(rhs.shape) == 1:
rhs_rows = 1
rhs_cols = rhs.size
else:
rhs_rows, rhs_cols = rhs.shape
result_size = lhs_rows * rhs_cols
if sp.issparse(lhs) and sp.issparse(rhs):
return True
elif sp.issparse(lhs):
lhs_zero_rows = lhs_rows - np.unique(lhs.nonzero()[0]).size
rhs_zero_cols = np.all(rhs==0, axis=0).sum()
elif sp.issparse(rhs):
lhs_zero_rows = np.all(lhs==0, axis=1).sum()
rhs_zero_cols = rhs_cols- np.unique(rhs.nonzero()[1]).size
else:
lhs_zero_rows = np.all(lhs==0, axis=1).sum()
rhs_zero_cols = np.all(rhs==0, axis=0).sum()
num_zeros = lhs_zero_rows * rhs_cols + rhs_zero_cols * lhs_rows - lhs_zero_rows * rhs_zero_cols
# A sparse matrix uses roughly 16 bytes per nonzero element (8 + 2 4-byte inds), while a dense matrix uses 8 bytes per element. So the break even point for sparsity is 50% nonzero. But in practice, it seems to be that the compression in a csc or csr matrix gets us break even at ~65% nonzero, which lets us say 50% is a conservative, worst cases cutoff.
return (float(num_zeros) / float(size)) >= 0.5
def convert_inputs_to_sparse_if_necessary(lhs, rhs):
'''
This function checks to see if a sparse output is desireable given the inputs and if so, casts the inputs to sparse in order to make it so.
'''
if not sp.issparse(lhs) or not sp.issparse(rhs):
if sparse_is_desireable(lhs, rhs):
if not sp.issparse(lhs):
lhs = sp.csc_matrix(lhs)
#print "converting lhs into sparse matrix"
if not sp.issparse(rhs):
rhs = sp.csc_matrix(rhs)
#print "converting rhs into sparse matrix"
return lhs, rhs
|