clean up scipy/numpy imports

Author: riscy

multivariate_regressor.py

@@ -8,19 +8,15 @@
 Just simple linear regression with regularization - nothing new here
 """
 
-from scipy import randn
-from scipy import dot
-from scipy import shape
-from scipy import reshape
-from scipy import size
-from scipy.sparse import eye
-from scipy.linalg import pinv
+import numpy as np
+from scipy import sparse
+
 
 def ideal_data(num, dimX, dimY, _rank=None, noise=1):
     """Full rank data"""
-    X = randn(num, dimX)
-    W = randn(dimX, dimY)
-    Y = dot(X, W) + randn(num, dimY) * noise
+    X = np.random.randn(num, dimX)
+    W = np.random.randn(dimX, dimY)
+    Y = np.dot(X, W) + np.random.randn(num, dimY) * noise
     return X, Y
 
 
@@ -32,21 +28,21 @@ class MultivariateRegressor(object):
     - reg is a regularization parameter (optional).
     """
     def __init__(self, X, Y, reg=None):
-        if size(shape(X)) is 1:
-            X = reshape(X, (-1, 1))
-        if size(shape(Y)) is 1:
-            Y = reshape(Y, (-1, 1))
+        if np.size(np.shape(X)) == 1:
+            X = np.reshape(X, (-1, 1))
+        if np.size(np.shape(Y)) == 1:
+            Y = np.reshape(Y, (-1, 1))
         if reg is None:
             reg = 0
 
-        W1 = pinv(dot(X.T, X) + reg * eye(size(X, 1)))
-        W2 = dot(X, W1)
-        self.W = dot(Y.T, W2)
+        W1 = np.linalg.pinv(np.dot(X.T, X) + reg * sparse.eye(np.size(X, 1)))
+        W2 = np.dot(X, W1)
+        self.W = np.dot(Y.T, W2)
 
     def __str__(self):
         return 'Multivariate Linear Regression'
 
     def predict(self, X):
-        if size(shape(X)) == 1:
-            X = reshape(X, (-1, 1))
-        return dot(X, self.W.T)
+        if np.size(np.shape(X)) == 1:
+            X = np.reshape(X, (-1, 1))
+        return np.dot(X, self.W.T)

reduced_rank_regressor.py

@@ -7,21 +7,15 @@
 
 Optimal linear 'bottlenecking' or 'multitask learning'.
 """
+import numpy as np
+from scipy import sparse
 
-from scipy import randn
-from scipy import dot
-from scipy import shape
-from scipy import reshape
-from scipy import size
-from scipy.sparse import eye
-from scipy.linalg import pinv
-from scipy.linalg import svd
 
 def ideal_data(num, dimX, dimY, rrank, noise=1):
     """Low rank data"""
-    X = randn(num, dimX)
-    W = dot(randn(dimX, rrank), randn(rrank, dimY))
-    Y = dot(X, W) + randn(num, dimY) * noise
+    X = np.random.randn(num, dimX)
+    W = np.dot(np.random.randn(dimX, rrank), np.random.randn(rrank, dimY))
+    Y = np.dot(X, W) + np.random.randn(num, dimY) * noise
     return X, Y
 
 
@@ -34,25 +28,25 @@ class ReducedRankRegressor(object):
     - reg is a regularization parameter (optional).
     """
     def __init__(self, X, Y, rank, reg=None):
-        if size(shape(X)) == 1:
-            X = reshape(X, (-1, 1))
-        if size(shape(Y)) == 1:
-            Y = reshape(Y, (-1, 1))
+        if np.size(np.shape(X)) == 1:
+            X = np.reshape(X, (-1, 1))
+        if np.size(np.shape(Y)) == 1:
+            Y = np.reshape(Y, (-1, 1))
         if reg is None:
             reg = 0
         self.rank = rank
 
-        CXX = dot(X.T, X) + reg * eye(size(X, 1))
-        CXY = dot(X.T, Y)
-        _U, _S, V = svd(dot(CXY.T, dot(pinv(CXX), CXY)))
+        CXX = np.dot(X.T, X) + reg * sparse.eye(np.size(X, 1))
+        CXY = np.dot(X.T, Y)
+        _U, _S, V = np.linalg.svd(np.dot(CXY.T, np.dot(np.linalg.pinv(CXX), CXY)))
         self.W = V[0:rank, :].T
-        self.A = dot(pinv(CXX), dot(CXY, self.W)).T
+        self.A = np.dot(np.linalg.pinv(CXX), np.dot(CXY, self.W)).T
 
     def __str__(self):
         return 'Reduced Rank Regressor (rank = {})'.format(self.rank)
 
     def predict(self, X):
         """Predict Y from X."""
-        if size(shape(X)) == 1:
-            X = reshape(X, (-1, 1))
-        return dot(X, dot(self.A.T, self.W.T))
+        if np.size(np.shape(X)) == 1:
+            X = np.reshape(X, (-1, 1))
+        return np.dot(X, np.dot(self.A.T, self.W.T))

system_identifier.py

@@ -14,57 +14,49 @@
    x_(i+1) = dot(A, x_i) + dot(B, u_i)
 This is a linear dynamical system.
 """
+import numpy as np
+import scipy as sp
+from scipy import sparse
+from scipy.sparse import linalg as sparse_linalg
 
-from numpy.lib import diag
-from scipy import randn
-from scipy import dot
-from scipy import shape
-from scipy import reshape
-from scipy import size
-from scipy import zeros
-from scipy import array
-from scipy.sparse import bmat
-from scipy import ravel
-from scipy import concatenate
-from scipy.sparse import eye
-from scipy.linalg import pinv
-from scipy.sparse.linalg import eigs
-from scipy.linalg import svd
 
 def ideal_data(num, dimU, dimY, dimX, noise=1):
     """Linear system data"""
     # generate randomized linear system matrices
-    A = randn(dimX, dimX)
-    B = randn(dimX, dimU)
-    C = randn(dimY, dimX)
-    D = randn(dimY, dimU)
+    A = np.random.randn(dimX, dimX)
+    B = np.random.randn(dimX, dimU)
+    C = np.random.randn(dimY, dimX)
+    D = np.random.randn(dimY, dimU)
 
     # make sure state evolution is stable
-    U, S, V = svd(A)
-    A = dot(U, dot(diag(S / max(S)), V))
-    U, S, V = svd(B)
-    S2 = zeros((size(U,1), size(V,0)))
-    S2[:,:size(U,1)] = diag(S / max(S))
-    B = dot(U, dot(S2, V))
+    U, S, V = np.linalg.svd(A)
+    A = np.dot(U, np.dot(np.lib.diag(S / max(S)), V))
+    U, S, V = np.linalg.svd(B)
+    S2 = np.zeros((np.size(U, 1), np.size(V, 0)))
+    S2[:, :np.size(U, 1)] = np.lib.diag(S / max(S))
+    B = np.dot(U, np.dot(S2, V))
 
     # random input
-    U = randn(num, dimU)
+    U = np.random.randn(num, dimU)
 
     # initial state
-    X = reshape(randn(dimX), (1,-1))
+    X = np.reshape(np.random.randn(dimX), (1, -1))
 
     # initial output
-    Y = reshape(dot(C, X[-1]) + dot(D, U[0]), (1,-1))
+    Y = np.reshape(np.dot(C, X[-1]) + np.dot(D, U[0]), (1, -1))
 
     # generate next state
-    X = concatenate((X, reshape(dot(A, X[-1]) + dot(B, U[0]), (1,-1))))
+    X = np.concatenate(
+        (X, np.reshape(np.dot(A, X[-1]) + np.dot(B, U[0]), (1, -1))))
 
     # and so forth
     for u in U[1:]:
-        Y = concatenate((Y, reshape(dot(C, X[-1]) + dot(D, u), (1,-1))))
-        X = concatenate((X, reshape(dot(A, X[-1]) + dot(B, u), (1,-1))))
+        Y = np.concatenate(
+            (Y, np.reshape(np.dot(C, X[-1]) + np.dot(D, u), (1, -1))))
+        X = np.concatenate(
+            (X, np.reshape(np.dot(A, X[-1]) + np.dot(B, u), (1, -1))))
 
-    return U, Y + randn(num, dimY) * noise
+    return U, Y + np.random.randn(num, dimY) * noise
 
 
 class SystemIdentifier(object):
@@ -76,87 +68,89 @@ class SystemIdentifier(object):
     - reg is a regularization parameter (optional).
     """
     def __init__(self, U, Y, statedim, reg=None):
-        if size(shape(U)) == 1:
-            U = reshape(U, (-1,1))
-        if size(shape(Y)) == 1:
-            Y = reshape(Y, (-1,1))
+        if np.size(np.shape(U)) == 1:
+            U = np.reshape(U, (-1, 1))
+        if np.size(np.shape(Y)) == 1:
+            Y = np.reshape(Y, (-1, 1))
         if reg is None:
             reg = 0
 
-        yDim = size(Y,1)
-        uDim = size(U,1)
+        yDim = np.size(Y, 1)
+        uDim = np.size(U, 1)
 
-        self.output_size = size(Y,1) # placeholder
+        self.output_size = np.size(Y, 1)  # placeholder
 
         # number of samples of past/future we'll mash together into a 'state'
         width = 1
         # total number of past/future pairings we get as a result
-        K = size(U,0) - 2 * width + 1
+        K = np.size(U, 0) - 2 * width + 1
 
         # build hankel matrices containing pasts and futures
-        U_p = array([ravel(U[t : t + width]) for t in range(K)]).T
-        U_f = array([ravel(U[t + width : t + 2 * width]) for t in range(K)]).T
-        Y_p = array([ravel(Y[t : t + width]) for t in range(K)]).T
-        Y_f = array([ravel(Y[t + width : t + 2 * width]) for t in range(K)]).T
+        U_p = np.array([np.ravel(U[t:t + width]) for t in range(K)]).T
+        U_f = np.array([np.ravel(U[t + width:t + 2 * width]) for t in range(K)]).T
+        Y_p = np.array([np.ravel(Y[t:t + width]) for t in range(K)]).T
+        Y_f = np.array([np.ravel(Y[t + width:t + 2 * width]) for t in range(K)]).T
 
         # solve the eigenvalue problem
-        YfUfT = dot(Y_f, U_f.T)
-        YfUpT = dot(Y_f, U_p.T)
-        YfYpT = dot(Y_f, Y_p.T)
-        UfUpT = dot(U_f, U_p.T)
-        UfYpT = dot(U_f, Y_p.T)
-        UpYpT = dot(U_p, Y_p.T)
-        F = bmat([[None, YfUfT, YfUpT, YfYpT],
-                  [YfUfT.T, None, UfUpT, UfYpT],
-                  [YfUpT.T, UfUpT.T, None, UpYpT],
-                  [YfYpT.T, UfYpT.T, UpYpT.T, None]])
-        Ginv = bmat([[pinv(dot(Y_f,Y_f.T)), None, None, None],
-                     [None, pinv(dot(U_f,U_f.T)), None, None],
-                     [None, None, pinv(dot(U_p,U_p.T)), None],
-                     [None, None, None, pinv(dot(Y_p,Y_p.T))]])
-        F = F - eye(size(F, 0)) * reg
+        YfUfT = np.dot(Y_f, U_f.T)
+        YfUpT = np.dot(Y_f, U_p.T)
+        YfYpT = np.dot(Y_f, Y_p.T)
+        UfUpT = np.dot(U_f, U_p.T)
+        UfYpT = np.dot(U_f, Y_p.T)
+        UpYpT = np.dot(U_p, Y_p.T)
+        F = sparse.bmat([
+            [None, YfUfT, YfUpT, YfYpT],
+            [YfUfT.T, None, UfUpT, UfYpT],
+            [YfUpT.T, UfUpT.T, None, UpYpT],
+            [YfYpT.T, UfYpT.T, UpYpT.T, None],
+        ])
+        Ginv = sparse.bmat([
+            [np.linalg.pinv(np.dot(Y_f, Y_f.T)), None, None, None],
+            [None, np.linalg.pinv(np.dot(U_f, U_f.T)), None, None],
+            [None, None, np.linalg.pinv(np.dot(U_p, U_p.T)), None],
+            [None, None, None, np.linalg.pinv(np.dot(Y_p, Y_p.T))],
+        ])
+        F = F - sparse.eye(sp.size(F, 0)) * reg
 
         # Take smallest eigenvalues
-        _, W = eigs(Ginv.dot(F), k=statedim, which='SR')
+        _, W = sparse_linalg.eigs(Ginv.dot(F), k=statedim, which='SR')
 
         # State sequence is a weighted combination of the past
-        W_U_p = W[ width * (yDim + uDim) : width * (yDim + uDim + uDim), :]
-        W_Y_p = W[ width * (yDim + uDim + uDim):, :]
-        X_hist = dot(W_U_p.T, U_p) + dot(W_Y_p.T, Y_p)
+        W_U_p = W[width * (yDim + uDim):width * (yDim + uDim + uDim), :]
+        W_Y_p = W[width * (yDim + uDim + uDim):, :]
+        X_hist = np.dot(W_U_p.T, U_p) + np.dot(W_Y_p.T, Y_p)
 
         # Regress; trim inputs to match the states we retrieved
-        R = concatenate((X_hist[:, :-1], U[width:-width].T), 0)
-        L = concatenate((X_hist[:, 1: ], Y[width:-width].T), 0)
-        RRi = pinv(dot(R, R.T))
-        RL  = dot(R, L.T)
-        Sys = dot(RRi, RL).T
+        R = np.concatenate((X_hist[:, :-1], U[width:-width].T), 0)
+        L = np.concatenate((X_hist[:, 1:], Y[width:-width].T), 0)
+        RRi = np.linalg.pinv(np.dot(R, R.T))
+        RL = np.dot(R, L.T)
+        Sys = np.dot(RRi, RL).T
         self.A = Sys[:statedim, :statedim]
         self.B = Sys[:statedim, statedim:]
         self.C = Sys[statedim:, :statedim]
         self.D = Sys[statedim:, statedim:]
 
-
-    def __str__ (self):
+    def __str__(self):
         return "Linear Dynamical System"
 
-
     def predict(self, U):
         # If U is a vector, reshape it
-        if size(shape(U)) == 1:
-            U = reshape(U, (-1, 1))
+        if np.size(np.shape(U)) == 1:
+            U = np.reshape(U, (-1, 1))
 
         # assume some random initial state
-        X = reshape(randn(size(self.A, 1)), (1, -1))
+        X = np.reshape(np.random.randn(np.size(self.A, 1)), (1, -1))
 
         # intitial output
-        Y = reshape(dot(self.C, X[-1]) + dot(self.D, U[0]), (1, -1))
+        Y = np.reshape(np.dot(self.C, X[-1]) + np.dot(self.D, U[0]), (1, -1))
 
         # generate next state
-        X = concatenate((X, reshape(dot(self.A, X[-1]) + dot(self.B, U[0]), (1, -1))))
+        X = np.concatenate((X, np.reshape(np.dot(self.A, X[-1]) + np.dot(self.B, U[0]), (1, -1))))
 
         # and so forth
         for u in U[1:]:
-            Y = concatenate((Y, reshape(dot(self.C, X[-1]) + dot(self.D, u), (1, -1))))
-            X = concatenate((X, reshape(dot(self.A, X[-1]) + dot(self.B, u), (1, -1))))
+            Y = np.concatenate((Y, np.reshape(np.dot(self.C, X[-1]) + np.dot(self.D, u), (1, -1))))
+            X = np.concatenate((X, np.reshape(np.dot(self.A, X[-1]) + np.dot(self.B, u), (1, -1))))
 
         return Y