chumpy-fixed 0.71__py3-none-any.whl

chumpy/ch_random.py

@@ -0,0 +1,32 @@
+"""
+Author(s): Matthew Loper
+
+See LICENCE.txt for licensing and contact information.
+"""
+
+import numpy.random
+from .ch import Ch
+
+api_not_implemented = ['choice','bytes','shuffle','permutation']
+
+api_wrapped_simple = [
+    # simple random data
+    'rand','randn','randint','random_integers','random_sample','random','ranf','sample',
+    
+    # distributions
+    'beta','binomial','chisquare','dirichlet','exponential','f','gamma','geometric','gumbel','hypergeometric',
+    'laplace','logistic','lognormal','logseries','multinomial','multivariate_normal','negative_binomial',
+    'noncentral_chisquare','noncentral_f','normal','pareto','poisson','power','rayleigh','standard_cauchy',
+    'standard_exponential','standard_gamma','standard_normal','standard_t','triangular','uniform','vonmises',
+    'wald','weibull','zipf']
+    
+api_wrapped_direct = ['seed', 'get_state', 'set_state']
+
+for rtn in api_wrapped_simple:
+    exec('def %s(*args, **kwargs) : return Ch(numpy.random.%s(*args, **kwargs))' % (rtn, rtn))
+
+for rtn in api_wrapped_direct:
+    exec('%s = numpy.random.%s' % (rtn, rtn))
+    
+__all__ = api_wrapped_simple + api_wrapped_direct
+

chumpy/extras.py

@@ -0,0 +1,72 @@
+__author__ = 'matt'
+
+from . import ch
+import numpy as np
+from .utils import row, col
+import scipy.sparse as sp
+import scipy.special
+
+class Interp3D(ch.Ch):
+    dterms = 'locations'
+    terms = 'image'
+
+    def on_changed(self, which):
+        if 'image' in which:
+            self.gx, self.gy, self.gz = np.gradient(self.image)
+
+    def compute_r(self):
+        locations = self.locations.r.copy()
+        for i in range(3):
+            locations[:,i] = np.clip(locations[:,i], 0, self.image.shape[i]-1)
+        locs = np.floor(locations).astype(np.uint32)
+        result = self.image[locs[:,0], locs[:,1], locs[:,2]]
+        offset = (locations - locs)
+        dr = self.dr_wrt(self.locations).dot(offset.ravel())
+        return result + dr
+
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.locations:
+            locations = self.locations.r.copy()
+            for i in range(3):
+                locations[:,i] = np.clip(locations[:,i], 0, self.image.shape[i]-1)
+            locations = locations.astype(np.uint32)
+
+            xc = col(self.gx[locations[:,0], locations[:,1], locations[:,2]])
+            yc = col(self.gy[locations[:,0], locations[:,1], locations[:,2]])
+            zc = col(self.gz[locations[:,0], locations[:,1], locations[:,2]])
+
+            data = np.vstack([xc.ravel(), yc.ravel(), zc.ravel()]).T.copy()
+            JS = np.arange(locations.size)
+            IS = JS // 3
+
+            return sp.csc_matrix((data.ravel(), (IS, JS)))
+
+
+class gamma(ch.Ch):
+    dterms = 'x',
+
+    def compute_r(self):
+        return scipy.special.gamma(self.x.r)
+
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.x:
+            d = scipy.special.polygamma(0, self.x.r)*self.r
+            return sp.diags([d.ravel()], [0])
+
+# This function is based directly on the "moment" function
+# in scipy, specifically in mstats_basic.py.
+def moment(a, moment=1, axis=0):
+    if moment == 1:
+        # By definition the first moment about the mean is 0.
+        shape = list(a.shape)
+        del shape[axis]
+        if shape:
+            # return an actual array of the appropriate shape
+            return ch.zeros(shape, dtype=float)
+        else:
+            # the input was 1D, so return a scalar instead of a rank-0 array
+            return np.float64(0.0)
+    else:
+        mn = ch.expand_dims(a.mean(axis=axis), axis)
+        s = ch.power((a-mn), moment)
+        return s.mean(axis=axis)

chumpy/linalg.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+"""
+Author(s): Matthew Loper
+
+See LICENCE.txt for licensing and contact information.
+"""
+
+
+__all__ = ['inv', 'svd', 'det', 'slogdet', 'pinv', 'lstsq', 'norm']
+
+import numpy as np
+import scipy.sparse as sp
+from .ch import Ch, depends_on
+from .ch_ops import NanDivide
+from .ch_ops import asarray as ch_asarray
+from .ch_ops import sqrt as ch_sqrt
+from .ch_ops import sum as ch_sum
+from .reordering import concatenate as ch_concatenate
+from .ch_random import randn as ch_random_randn
+from .utils import row, col
+
+
+try:
+    asarray = ch_asarray
+    import inspect
+    exec(''.join(inspect.getsourcelines(np.linalg.tensorinv)[0]))
+    __all__.append('tensorinv')
+except: pass
+
+def norm(x, ord=None, axis=None):
+    if ord is not None or axis is not None:
+        raise NotImplementedError("'ord' and 'axis' should be None for now.")
+
+    return ch_sqrt(ch_sum(x**2))
+
+# This version works but derivatives are too slow b/c of nested loop in Svd implementation.
+# def lstsq(a, b):
+#     u, s, v = Svd(a)
+#     x = (v.T / s).dot(u.T.dot(b))
+#     residuals = NotImplementedError # ch_sum((a.dot(x) - b)**2, axis=0)
+#     rank = NotImplementedError
+#     s = NotImplementedError
+#     return x, residuals, rank, s
+
+def lstsq(a, b, rcond=-1):
+    if rcond != -1:
+        raise Exception('non-default rcond not yet implemented')
+        
+    x = Ch(lambda a, b : pinv(a).dot(b))
+    x.a = a
+    x.b = b
+    residuals = ch_sum(  (x.a.dot(x) - x.b) **2 , axis=0)
+    rank = NotImplementedError
+    s = NotImplementedError
+    
+    return x, residuals, rank, s
+
+def Svd(x, full_matrices=0, compute_uv=1):
+    
+    if full_matrices != 0:
+        raise Exception('full_matrices must be 0')
+    if compute_uv != 1:
+        raise Exception('compute_uv must be 1')
+        
+    need_transpose = x.shape[0] < x.shape[1]
+    
+    if need_transpose:
+        x = x.T
+        
+    svd_d = SvdD(x=x)
+    svd_v = SvdV(x=x, svd_d=svd_d)
+    svd_u = SvdU(x=x, svd_d=svd_d, svd_v=svd_v)
+
+    if need_transpose:
+        return svd_v, svd_d, svd_u.T
+    else:
+        return svd_u, svd_d, svd_v.T
+
+    
+class Pinv(Ch):
+    dterms = 'mtx'
+    
+    def on_changed(self, which):
+        mtx = self.mtx
+        if mtx.shape[1] > mtx.shape[0]:
+            result = mtx.T.dot(Inv(mtx.dot(mtx.T)))
+        else:
+            result = Inv(mtx.T.dot(mtx)).dot(mtx.T)
+        self._result = result
+        
+    def compute_r(self):
+        return self._result.r
+        
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.mtx:
+            return self._result.dr_wrt(self.mtx)
+        
+# Couldn't make the SVD version of pinv work yet...
+#
+# class Pinv(Ch):
+#     dterms = 'mtx'
+#     
+#     def on_changed(self, which):
+#         u, s, v = Svd(self.mtx)
+#         result = (v.T * (NanDivide(1.,row(s)))).dot(u.T)
+#         self.add_dterm('_result', result)
+# 
+#     def compute_r(self):
+#         return self._result.r
+#         
+#     def compute_dr_wrt(self, wrt):
+#         if wrt is self._result:
+#             return 1
+
+
+
+class LogAbsDet(Ch):
+    dterms = 'x'
+    
+    def on_changed(self, which):
+        self.sign, self.slogdet = np.linalg.slogdet(self.x.r)
+    
+    def compute_r(self):
+        return self.slogdet
+        
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.x:         
+            return row(np.linalg.inv(self.x.r).T)
+
+class SignLogAbsDet(Ch):
+    dterms = 'logabsdet',
+    
+    def compute_r(self):
+        _ = self.logabsdet.r
+        return self.logabsdet.sign
+        
+    def compute_dr_wrt(self, wrt):
+        return None
+
+
+class Det(Ch):
+    dterms = 'x'
+
+    def compute_r(self):
+        return np.linalg.det(self.x.r)
+
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.x:
+            return row(self.r * np.linalg.inv(self.x.r).T)
+
+
+class Inv(Ch):
+    dterms = 'a'
+    
+    def compute_r(self):
+        return np.linalg.inv(self.a.r)
+    
+    def compute_dr_wrt(self, wrt):
+        if wrt is not self.a:
+            return None
+    
+        Ainv = self.r
+
+        if Ainv.ndim <= 2:
+            return -np.kron(Ainv, Ainv.T)
+        else:
+            Ainv = np.reshape(Ainv,  (-1, Ainv.shape[-2], Ainv.shape[-1]))
+            AinvT = np.rollaxis(Ainv, -1, -2)
+            AinvT = np.reshape(AinvT, (-1, AinvT.shape[-2], AinvT.shape[-1]))
+            result = np.dstack([-np.kron(Ainv[i], AinvT[i]).T for i in range(Ainv.shape[0])]).T
+            result = sp.block_diag(result)
+
+        return result
+
+
+class SvdD(Ch):
+    dterms = 'x'
+
+    @depends_on('x')
+    def UDV(self):
+        result = np.linalg.svd(self.x.r, full_matrices=False)
+        result = [result[0], result[1], result[2].T]
+        result[1][np.abs(result[1]) < np.spacing(1)] = 0.
+        return result
+    
+    def compute_r(self):
+        return self.UDV[1]
+    
+    def compute_dr_wrt(self, wrt):
+        if wrt is not self.x:
+            return
+        
+        u, d, v = self.UDV
+        shp = self.x.r.shape
+        u = u[:shp[0], :shp[1]]
+        v = v[:shp[1], :d.size]
+        
+        result = np.einsum('ik,jk->kij', u, v)
+        result = result.reshape((result.shape[0], -1))
+        return result
+    
+    
+class SvdV(Ch):
+    terms = 'svd_d'
+    dterms = 'x'
+    
+    def compute_r(self):
+        return self.svd_d.UDV[2]
+
+    def compute_dr_wrt(self, wrt):
+        if wrt is not self.x:
+            return
+        
+        U,_D,V = self.svd_d.UDV
+        
+        shp = self.svd_d.x.r.shape
+        mxsz = max(shp[0], shp[1])
+        #mnsz = min(shp[0], shp[1])
+        D = np.zeros(mxsz)
+        D[:_D.size] = _D
+
+        omega = np.zeros((shp[0], shp[1], shp[1], shp[1]))
+
+        M = shp[0]
+        N = shp[1]
+        
+        assert(M >= N)
+        
+        for i in range(shp[0]):
+            for j in range(shp[1]):
+                for k in range(N):
+                    for l in range(k+1, N):
+                        mtx = np.array([
+                            [D[l],D[k]],
+                            [D[k],D[l]]])
+                    
+                        rhs = np.array([U[i,k]*V[j,l], -U[i,l]*V[j,k]])
+                        result = np.linalg.solve(mtx, rhs)
+                        
+                        omega[i,j,k,l] =  result[1]
+                        omega[i,j,l,k] = -result[1]
+                   
+        #print 'v size is %s' % (str(V.shape),)
+        #print 'v omega size is %s' % (str(omega.shape),)
+        assert(V.shape[1] == omega.shape[2])
+        return np.einsum('ak,ijkl->alij', -V, omega).reshape((self.r.size, wrt.r.size))
+        
+        
+class SvdU(Ch):
+    dterms = 'x'
+    terms = 'svd_d', 'svd_v'
+
+    def compute_r(self):
+        return self.svd_d.UDV[0]
+    
+    def compute_dr_wrt(self, wrt):
+        if wrt is self.x:
+            # return (
+            #     self.svd_d.x.dot(self.svd_v)
+            #     /
+            #     self.svd_d.reshape((1,-1))
+            #     ).dr_wrt(self.svd_d.x)
+            return (
+                NanDivide(
+                    self.svd_d.x.dot(self.svd_v),
+                    self.svd_d.reshape((1,-1)))
+                ).dr_wrt(self.svd_d.x)
+    
+
+inv = Inv
+svd = Svd
+det = Det
+pinv = Pinv
+
+def slogdet(*args):
+    n = len(args)
+    if n == 1:
+        r2 = LogAbsDet(x=args[0])
+        r1 = SignLogAbsDet(r2)
+        return r1, r2
+    else:
+        r2 = [LogAbsDet(x=arg) for arg in args]
+        r1 = [SignLogAbsDet(r) for r in r2]
+        r2 = ch_concatenate(r2)
+        return r1, r2
+
+def main():
+    
+    tmp = ch_random_randn(100).reshape((10,10))
+    print('chumpy version: ' + str(slogdet(tmp)[1].r))
+    print('old version:' + str(np.linalg.slogdet(tmp.r)[1]))
+
+    eps = 1e-10
+    diff = np.random.rand(100) * eps
+    diff_reshaped = diff.reshape((10,10))
+    print(np.linalg.slogdet(tmp.r+diff_reshaped)[1] - np.linalg.slogdet(tmp.r)[1])
+    print(slogdet(tmp)[1].dr_wrt(tmp).dot(diff))
+    
+    print(np.linalg.slogdet(tmp.r)[0])
+    print(slogdet(tmp)[0])
+
+if __name__ == '__main__':
+    main()
+

chumpy/logic.py

@@ -0,0 +1,39 @@
+"""
+Author(s): Matthew Loper
+
+See LICENCE.txt for licensing and contact information.
+"""
+
+__author__ = 'matt'
+
+
+__all__ = [] # added to incrementally below
+
+from . import ch
+from .ch import Ch
+import numpy as np
+
+class LogicFunc(Ch):
+    dterms = 'a' # we keep this here so that changes to children of "a" will trigger cache changes
+    terms = 'args', 'kwargs', 'funcname'
+
+    def compute_r(self):
+        arr = self.a
+        fn = getattr(np, self.funcname)
+        return fn(arr, *self.args, **self.kwargs)
+
+    def compute_dr_wrt(self, wrt):
+        pass
+
+
+unaries = 'all', 'any', 'isfinite', 'isinf', 'isnan', 'isneginf', 'isposinf', 'logical_not'
+for unary in unaries:
+    exec("def %s(a, *args, **kwargs): return LogicFunc(a=a, args=args, kwargs=kwargs, funcname='%s')" % (unary, unary))
+__all__ += unaries
+
+
+
+if __name__ == '__main__':
+    from . import ch
+    print(all(np.array([1,2,3])))
+    print(isinf(np.array([0,2,3])))

chumpy/monitor.py

@@ -0,0 +1,149 @@
+'''
+Logging service for tracking dr tree changes from root objective 
+and record every step that incrementally changes the dr tree
+
+'''
+import os, sys, time
+import json
+import psutil
+
+import scipy.sparse as sp
+import numpy as np
+from . import reordering
+
+_TWO_20 = float(2 **20)
+
+'''
+memory utils
+
+'''
+def pdb_mem():
+    from .monitor import get_current_memory
+    mem = get_current_memory()
+    if mem > 7000:
+        import pdb;pdb.set_trace()
+
+def get_peak_mem():
+    '''
+    this returns peak memory use since process starts till the moment its called
+    '''
+    import resource
+    rusage_denom = 1024.
+    if sys.platform == 'darwin':
+        # ... it seems that in OSX the output is different units ...
+        rusage_denom = rusage_denom * rusage_denom
+    mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / rusage_denom
+    return mem
+
+def get_current_memory():
+    p = psutil.Process(os.getpid())
+    mem = p.memory_info()[0]/_TWO_20
+
+    return mem
+
+'''
+Helper for Profiler
+'''
+
+def build_cache_info(k, v, info_dict):
+    if v is not None:
+        issparse = sp.issparse(v)
+        size = v.size
+        if issparse:
+            nonzero = len(v.data)
+        else:
+            nonzero = np.count_nonzero(v)
+        info_dict[k.short_name] = {
+            'sparse': issparse,
+            'size' : str(size),
+            'nonzero' : nonzero,
+        }
+
+
+def cache_info(ch_node):
+    result = {}
+    if isinstance(ch_node, reordering.Concatenate) and hasattr(ch_node, 'dr_cached') and len(ch_node.dr_cached) > 0:
+        for k, v in ch_node.dr_cached.items():
+            build_cache_info(k, v, result)
+    elif len(ch_node._cache['drs']) > 0:
+        for k, v in ch_node._cache['drs'].items():
+            build_cache_info(k, v, result)
+
+    return result
+
+class DrWrtProfiler(object):
+    base_path = os.path.abspath('profiles')
+    
+    def __init__(self, root, base_path=None):
+        self.root = root.obj
+        self.history = []
+
+        ts = time.time()
+        if base_path:
+            self.base_path = base_path
+                       
+        self.path = os.path.join(self.base_path, 'profile_%s.json' % str(ts))
+        self.root_path = os.path.join(self.base_path, 'root_%s.json' % str(ts))
+
+        
+        with open(self.root_path, 'w') as f:
+            json.dump(self.dump_tree(self.root), f, indent=4)
+
+    def dump_tree(self, node):
+        if not hasattr(node, 'dterms'):
+            return []
+
+        node_dict = self.serialize_node(node, verbose=False)
+        if hasattr(node, 'visited') and node.visited:
+            node_dict.update({'indirect':True})
+            return node_dict
+
+        node.visited = True
+        children_list = []
+        for dterm in node.dterms:
+            if hasattr(node, dterm):
+                child = getattr(node, dterm)
+                if hasattr(child, 'dterms') or hasattr(child, 'terms'):
+                    children_list.append(self.dump_tree(child))
+        node_dict.update({'children':children_list})
+        return node_dict
+
+    def serialize_node(self, ch_node, verbose=True):
+        node_id = id(ch_node)
+        name = ch_node.short_name
+        ts = time.time()
+        status = ch_node._status
+        mem = get_current_memory()
+        node_cache_info = cache_info(ch_node)
+
+        rec = {
+            'id': str(node_id),
+            'indirect' : False,
+        }
+        if verbose:
+            rec.update({
+                'name':name,
+                'ts' : ts,
+                'status':status,
+                'mem': mem,
+                'cache': node_cache_info,
+            })
+        return rec
+
+    def show_tree(self, label):
+        '''
+        show tree from the root node
+        '''
+        self.root.show_tree_cache(label)
+
+    def record(self, ch_node):
+        '''
+        Incremental changes
+        '''
+        rec = self.serialize_node(ch_node)
+        self.history.append(rec)
+
+    def harvest(self):
+        print('collecting and dump to file %s' % self.path)
+        with open(self.path, 'w') as f:
+            json.dump(self.history, f, indent=4)