•INVERSE
```
A.I #inverse

linalg.inv(A) #inverse
```
•TRANSPOSE and CONJUGATE
```
A.T #transpose matrix

A.H #conjugate
```
•TRACE
```
np.trace(A) #trace
```
•NORM
```
linalg.norm(A) #Frobenius norm

linalg.norm(A,1) #L1 Norm (max column sum)

linalg.norm(A,np.inf) #L inf Norm (max row sum)
```
•RANK
```
np.linalg.matrix_rank(C) #matrix rank
```
•DETERMINANT 
```
linalg.det(A) #determinant
```
•SOLVING LINEAR EQUATIONS
```
linalg.solve(A,b) #solver for dense matrices

E = np.mat(a).T #solver for dense matrices

linalg.lstsq(F,E) #least-squares solution to linear matrix equation
```

•GENERALIZED INVERSE
```
linalg.pinv(C) #Compute the pseudo-inverse of a matrix (least-squares solver)

linalg.pinv2(C) #Compute the pseudo-inverse of a matrix
(SVD)
```

Michigan State University

You’ll use the linalg and sparse modules. Note that scipy.linalg contains and expands on numpy.linalg. 
```
from scipy import linalg, sparse
```

Linear Algebra

```
A = np.matrix(np.random.random((2,2)))

B = np.asmatrix(b)

C = np.mat(np.random.random((10,5)))

D = np.mat([[3,4], [5,6]])
```

Creating Matrix

Basic Matrix Routines

 F = np.eye(3, k=1) #Create a 2X2 identity matrix

G = np.mat(np.identity(2)) #Create a 2x2 identity matrix

C[[C > 0.5]] = 0

H = sparse.csr_matrix(C) #Compressed Sparse Row matrix

I = sparse.csc_matrix(D) #Compressed Sparse Column matrix

J = sparse.dok_matrix(A) #Dictionary Of Keys matrix

E.todense() #Sparse matrix to full matrix

sparse.isspmatrix_csc(A) #Identify sparse matrix

Creating Sparse Matrices

•INVERSE
```
sparse.linalg.inv(I) #inverse
```
•NORM
```
sparse.linalg.norm(I) #norm
```
•SOLVING LINEAR EQUATIONS
```
sparse.linalg.spsolve(H,I) #solver for sparse matrices
```

Sparse Matrix Routines

```
sparse.linalg.expm(I) #Sparse matrix exponential
```

Sparse Matrix Functions

•EIGENVALUES AND EIGENVECTORS
```
la, v = linalg.eig(A) #Solve ordinary or generalized eigenvalue problem for square matrix

l1, l2 = la #Unpack eigenvalues

v[:,0] #First eigenvector

v[:,1] #Second eigenvector

linalg.eigvals(A) #Unpack eigenvalues 
```
•SINGULAR VALUE DECOMPOSITION
```
U,s,Vh = linalg.svd(B) #Singular Value Decomposition (SVD)

M,N = B.shape

Sig = linalg.diagsvd(s,M,N) #Construct sigma matrix in SVD
```
•LU DECOMPOSITION
```
P,L,U = linalg.lu(C) #LU Decomposition
```

Decompositions

```
la, v = sparse.linalg.eigs(F,1) #Eigenvalues and eigenvectors

sparse.linalg.svds(H, 2) #SVD```

Sparse Matrix Decomposition

The numpy (np) and scipy.linalg modules provide a variety of functions for matrix operations:

- Addition & Subtraction: np.add(A, D), np.subtract(A, D)
- Division: np.divide(A, D)
- Multiplication: A @ D (matrix multiplication operator), np.multiply(D, A) (element-wise), np.dot(A, D) (dot product), np.vdot(A, D) (vector dot product), np.inner(A, D) (inner product), np.outer(A, D) (outer product), np.tensordot(A, D) (tensor dot product), np.kron(A, D) (Kronecker product)
- Exponential: linalg.expm(A) (matrix exponential), linalg.expm2(A) (Taylor series), linalg.expm3(D) (eigenvalue decomposition)
- Logarithmic: linalg.logm(A)
- Trigonometric: linalg.sinm(D), linalg.cosm(D), linalg.tanm(A)
- Hyperbolic: linalg.sinhm(D), linalg.coshm(D), linalg.tanhm(A)
- Sign: np.signm(A)
- Square Root: linalg.sqrtm(A)
- Arbitrary: linalg.funm(A, lambda x: x*x)

NumPy and SciPy Matrix Functions

Vectorization is a computational technique used to replace explicit, element-by-element loops (such as Python for-loops) with optimized operations on entire data structures simultaneously. In machine learning, vectorization leverages highly optimized linear algebra libraries to perform mathematical operations—like calculating the elementwise sum of vectors or processing whole minibatches of examples—at once. This approach dramatically reduces execution time by yielding order-of-magnitude speedups, simplifies code, reduces the potential for bugs, and increases portability by offloading mathematics to underlying libraries.

Learn Before

Related