def testOnes_inv(self): A1 = [np.array([[1., 1.], [1., 1.]]), np.array([[1., 1.], [1., 1.]])] x1 = np.array([1., 1., 1., 1.]) y1 = np.array([4, 4, 4, 4]) kp = KronProd(invert(A1)) x = kp.dot(y1) np.testing.assert_almost_equal(x, x1, decimal=7, verbose=True)
def testOnes(self): A1 = [np.array([[1., 1.], [1., 1.]]), np.array([[1., 1.], [1., 1.]])] x1 = np.array([1., 1., 1., 1.]) y1 = np.array([4., 4., 4., 4.]) kp = KronProd(A1) y = kp.dot(x1) self.assertSequenceEqual(list(y), list(y1))
def inverseTest(A, x): foo = time.time() big_A = reduce(np.kron, A) big_A = np.linalg.inv(big_A) big_y1 = np.matmul(big_A, x) time_full = time.time() - foo foo = time.time() newA = [] for i in range(len(A)): newA.append(np.linalg.inv(A[i])) big_A = reduce(np.kron, newA) big_y2 = np.matmul(big_A, x) time_kron = time.time() - foo foo = time.time() newA = [] for i in range(len(A)): newA.append(np.linalg.inv(A[i])) kp1 = KronProd(newA) Y1 = kp1.dot(x) time_kron_dyn = time.time() - foo if (verifyCorrectness(big_y1, big_y2, Y1)): print("Inverse Test Passed") else: print("Inverse Test Failed!") return time_full, time_kron, time_kron_dyn
def testBig_inv(self): n = 2 # number of factors p = 100 # dimension of factor r_As = [ortho_group.rvs(dim=p) for i in range(n)] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row y = np.random.rand(p**n) kp = KronProd(invert(As)) x = kp.dot(y) print("efficient calc: ", x)
def testBig(self): n = 2 # number of factors p = 100 # dimension of factor r_As = [np.random.rand(p, p) for i in range(n)] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row x = np.random.rand(p**n) kp = KronProd(As) Y = kp.dot(x) print("efficient calc: ", Y)
def testBig_pInv(self): n = 2 # number of factors p = 100 # dimension of factor r_As = [np.random.rand(p, p) for i in range(n)] #Make first and second row the same so that way it becomes a non-invertible matrix for A in r_As: A[1, :] = A[0, :] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row x = np.random.rand(p**n) kp = KronProd(invert(As)) Y = kp.dot(x) print("efficient calc: ", Y)
def _evalPolicyMatrix(self): # Evaluate the value function of the policy using linear equations. # # Arguments # --------- # Let S = number of states, A = number of actions # P(SxSxA) = transition matrix # P could be an array with 3 dimensions or a cell array (1xA), # each cell containing a matrix (SxS) possibly sparse # R(SxSxA) or (SxA) = reward matrix # R could be an array with 3 dimensions (SxSxA) or # a cell array (1xA), each cell containing a sparse matrix (SxS) # or a 2D array(SxA) possibly sparse # discount = discount rate in ]0; 1[ # policy(S) = a policy # # Evaluation # ---------- # Vpolicy(S) = value function of the policy # #Ppolicy, Rpolicy = self._computePpolicyPRpolicy() # V = PR + gPV => (I-gP)V = PR => V = inv(I-gP)* PR #self.V = _np.linalg.solve( # (_sp.eye(self.S, self.S) - self.discount * Ppolicy), Rpolicy) #Get appropiately size identity matrices i_as = [] for i in self.P[0].n: i_as.append(_np.eye(i)) kpI = KronProd(list(reversed(i_as))) #Get max value vector vectors = [] for aa in range(self.A): #apply discount to a gP gP = self.P[aa] rP = self.R[aa] Y1 = kpI.dot(rP) Y2 = gP.dot(rP) vectors.append(Y1-Y2) newV = [] for i in range(len(vectors[0])): local_max = float("-inf") for j in range(len(vectors)): if vectors[j][i] > local_max: local_max = vectors[j][i] newV.append(local_max) self.V = _np.asarray(newV)
def testInts(self): A1 = [ np.array([[1.0, 0.0], [0.0, 0.0]]), np.array([[1., 1.], [0., 0.]]) ] x1 = np.array([1., 2., 3., 4.]) big_A = reduce(np.kron, A1) print(big_A) print(x1) big_y = np.matmul(big_A, x1) print("full calc: ", big_y) kp = KronProd(A1) Y = kp.dot(x1) print("efficient calc: ", Y) self.assertSequenceEqual(list(Y), list(big_y))
def testRandom_inv(self): n = 5 # number of factors p = 5 # dimension of factor r_As = [ortho_group.rvs(dim=p) for i in range(n)] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row y = np.random.rand(p**n) big_A = reduce(np.kron, As) big_x = np.linalg.solve(big_A, y) print("full calc: ", big_x) kp = KronProd(invert(As)) x = kp.dot(y) print("efficient calc: ", x) np.testing.assert_almost_equal(x, big_x, decimal=7, verbose=True)
def testRandom(self): n = 5 # number of factors p = 5 # dimension of factor r_As = [np.random.rand(p, p) for i in range(n)] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row x = np.random.rand(p**n) big_A = reduce(np.kron, As) big_y = np.matmul(big_A, x) print("full calc: ", big_y) kp = KronProd(As) Y = kp.dot(x) print("efficient calc: ", Y) np.testing.assert_almost_equal(big_y, Y, decimal=7, verbose=True)
def testInts_pInv(self): A1 = [ np.array([[1.0, 0.0], [0.0,0.0]]), np.array([[1.,1.], [0.,0.]])] y1 = np.array([1.,2.,3.,4.]) A1_inv = [] for a in A1: A1_inv.append(np.linalg.pinv(a)) big_A = reduce(np.kron, A1_inv) big_x = big_A.dot(y1) print("FOO") print("full calc: ",big_x) kp = KronProd(invert(A1)) x = kp.dot(y1) print("efficient calc: ", x) print("BAR") self.assertSequenceEqual(list(x), list(big_x))
def testFail(self): #For some reason this breaks the property of kron product - (A_1 kron A_2)^+ = A_1^+ kron A_2^+ #The equivalent test for this is testRandom_pInv, but the reduce is performed after pinv. If it isn't then we get this error. #This error didn't seem to happen for n=p=3 or 2 but does occur sometimes when n=p=4 and somewhat frequently when n=p=5. n = 4 p = 4 As = As_fail y = Y_fail big_A = reduce(np.kron, As) big_A_inv = np.linalg.pinv(big_A) big_x = big_A_inv.dot(y) kp = KronProd(invert(As)) x = kp.dot(y) if (np.allclose(x, big_x) == False): return else: self.fail("No equivalent!")
def dotTest(A, x): foo = time.time() big_A = reduce(np.kron, A) big_y1 = np.matmul(big_A, x) time_full = time.time() - foo foo = time.time() kp1 = KronProd(A) Y1 = kp1.dot(x) time_kron_dyn = time.time() - foo if (verifyCorrectness(big_y1, big_y1, Y1)): print("Dot Test Passed") else: print("Dot Test Failed!") return time_full, time_kron_dyn
def testRandom_pInv(self): n = 5 # number of factors p = 5 # dimension of factor r_As = [ortho_group.rvs(dim=p) for i in range(n)] #Make first and second row the same so that way it becomes a non-invertible matrix for A in r_As: A[1, :] = A[0, :] As = [m / m.sum(axis=1)[:, None] for m in r_As] # normalize each row y = np.random.rand(p**n) As_inv = [] for a in As: As_inv.append(np.linalg.pinv(a)) big_A = reduce(np.kron, As_inv) big_x = big_A.dot(y) print("[test_kron_inv - testRandom_pInv] full calc: ", big_x) kp = KronProd(invert(As)) x = kp.dot(y) print("[test_kron_inv - testRandom_pInv] efficient calc: ", x) np.testing.assert_almost_equal(big_x, x, decimal=7, verbose=True)
def _computeTransition(self, transition): if self.sparse: return tuple(KronProdSparse(transition[a]) for a in range(self.A)) else: return tuple(KronProd(transition[a]) for a in range(self.A))