def np_ortho(shape, random_state, scale=1.): """ Builds a numpy variable filled with orthonormal random values Parameters ---------- shape, tuple of ints or tuple of tuples shape of values to initialize tuple of ints should be single shape tuple of tuples is primarily for convnets and should be of form ((n_in_kernels, kernel_width, kernel_height), (n_out_kernels, kernel_width, kernel_height)) random_state, numpy.random.RandomState() object scale, float (default 1.) default of 1. results in orthonormal random values sacled by 1. Returns ------- initialized_ortho, array-like Array-like of random values the same size as shape parameter References ---------- Exact solutions to the nonlinear dynamics of learning in deep linear neural networks A. Saxe, J. McClelland, S. Ganguli """ if type(shape[0]) is tuple: shp = (shape[1][0], shape[0][0]) + shape[1][1:] flat_shp = (shp[0], np.prd(shp[1:])) else: shp = shape flat_shp = shape g = random_state.randn(*flat_shp) U, S, VT = linalg.svd(g, full_matrices=False) res = U if U.shape == flat_shp else VT # pick one with the correct shape res = res.reshape(shp) return (scale * res).astype("float32")
def np_ortho(shp, random_state, scale=1.): """Builds a numpy variable filled with orthonormal random values. Args: shp: tuple of ints or tuple of tuples shape of values to initialize tuple of ints should be single shape tuple of tuples is primarily for convnets and should be of form ((n_in_kernels, kernel_width, kernel_height), (n_out_kernels, kernel_width, kernel_height)) random_state: numpy.random.RandomState() object scale: float (default 1.) default of 1. results in orthonormal random values sacled by 1. Returns: initialized_ortho, array-like Array-like of random values the same size as shape parameter References ---------- Exact solutions to the nonlinear dynamics of learning in deep linear neural networks A. Saxe, J. McClelland, S. Ganguli """ if isinstance(shp[0], tuple): shp = (shp[1][0], shp[0][0]) + shp[1][1:] flat_shp = (shp[0], np.prd(shp[1:])) else: flat_shp = shp g = random_state.randn(*flat_shp) u, _, vt = linalg.svd(g, full_matrices=False) res = u if u.shape == flat_shp else vt # pick one with the correct shape res = res.reshape(shp) return (scale * res).astype('float32')
def np_ortho(shape, random_state, scale=1.): if type(shape[0]) is tuple: shp = (shape[1][0], shape[0][0]) + shape[1][1:] flat_shp = (shp[0], np.prd(shp[1:])) else: shp = shape flat_shp = shape g = random_state.randn(*flat_shp) U, S, VT = linalg.svd(g, full_matrices=False) res = U if U.shape == flat_shp else VT # pick one with the correct shape res = res.reshape(shp) return (scale * res).astype(theano.config.floatX)
def Wishart_eval(n, V, W, dV=None, dW=None, piV=None): """ Evaluation of the probability of W under Wishart(n,V) Parameters ---------- n: float, the number of degrees of freedom (dofs) V: array of shape (n,n) the scale matrix of the Wishart density W: array of shape (n,n) the sample to be evaluated dV: float, optional, determinant of V dW: float, optional, determinant of W piV: array of shape (n,n), optional psuedo-inverse of V Returns ------- (float) the density """ # check that shape(V)==shape(W) p = V.shape[0] if dV == None: dV = np.prd(eigvalsh(V)) if dW == None: dW = np.prod(eigvalsh(W)) if piV==None: piV = inv(V) ldW = np.log(dW)*(n-p-1)/2 ltr = - np.trace(np.dot(piV, W))/2 la = ( n*p*np.log(2) + np.log(dV)*n )/2 lg = np.log(np.pi)*p*(p-1)/4 #for j in range(p): # lg += gammaln((n-j)/2) lg += gammaln(np.arange(n-p+1, n+1).astype(np.float)/2).sum() lt = ldW + ltr -la -lg return np.exp(lt)