Matrix Algebra for Machine Learning
# Matrix multiplication
# Perform Dot product between each row in the first matrix and each column in the second matrix.
# the columns in the first matrix need to match the number of rows in the second matrix.
# Note that the order of multiplication also matters.
matrix_a = np.asarray([
[0.7, 3],
[1.7, 2],
[0.7, 9]
], dtype=np.float32)
matrix_b = np.asarray([
[113, 3, 10],
[1, 0, 1],
], dtype=np.float32)
product_ab = np.dot(matrix_a, matrix_b)
product_ba = np.dot(matrix_b, matrix_a)
print("product_ab:\n", product_ab)
print("product_ba:\n", product_ba)
product_ab:
[[ 82.1 2.1 10. ]
[194.1 5.1000004 19. ]
[ 88.1 2.1 16. ]]
product_ba:
[[ 91.2 435. ]
[ 1.4 12. ]]
# Matrix operations using NumPy
import numpy as np
# Matrix Vector multiplication -
# To multiply a matrix by a vector, the number of columns in the matrix needs to match the number of rows in the vector.
# Assign the matrix to a numpy array named matrix_a
matrix_a = np.asarray([
[0.7,3,9],
[1.7,2,9],
[0.7,9,2]
], dtype=np.float32)
# Assign the vector to a NumPy array named vector_b
vector_b = np.asarray([
[1],
[2],
[1]
], dtype=np.float32)
# To multiply a matrix with a vector in NumPy, we need to use the numpy.dot() function
ab_product = np.dot(matrix_a, vector_b)
print(ab_product)
[[15.7]
[14.7]
[20.7]]
# Matrix Transpose
# To compute the transpose of a NumPy ndarray, we need to use the numpy.transpose() function
matrix_a = np.asarray([
[0.7, 3],
[1.7, 2],
[0.7, 9]
], dtype=np.float32)
matrix_b = np.asarray([
[113, 3, 10],
[1, 0, 1],
], dtype=np.float32)
transpose_a = np.transpose(matrix_a)
print("transpose_a:\n", transpose_a)
transpose_of_transpose_a = np.transpose(transpose_a)
print("transpose_of_transpose_a:\n", transpose_of_transpose_a)
transpose_b = np.transpose(matrix_b)
print("transpose_b:\n", transpose_b)
trans_ba = np.dot(transpose_b, transpose_a)
print("trans_ba:\n", trans_ba)
trans_ab = np.dot(transpose_a, transpose_b)
print("trans_ab:\n", trans_ab)
product_ab = np.dot(matrix_a, matrix_b)
print("product_ab:\n", product_ab)
trans_product_ab = np.transpose(product_ab)
print("trans_product_ab:\n", trans_product_ab) # Notice that transpose of product_ab is the same as trans_ba
transpose_a:
[[0.7 1.7 0.7]
[3. 2. 9. ]]
transpose_of_transpose_a:
[[0.7 3. ]
[1.7 2. ]
[0.7 9. ]]
transpose_b:
[[113. 1.]
[ 3. 0.]
[ 10. 1.]]
trans_ba:
[[ 82.1 194.1 88.1 ]
[ 2.1 5.1000004 2.1 ]
[ 10. 19. 16. ]]
trans_ab:
[[ 91.2 1.4]
[435. 12. ]]
product_ab:
[[ 82.1 2.1 10. ]
[194.1 5.1000004 19. ]
[ 88.1 2.1 16. ]]
trans_product_ab:
[[ 82.1 194.1 88.1 ]
[ 2.1 5.1000004 2.1 ]
[ 10. 19. 16. ]]
# Identity matrix
i_2 = np.identity(2)
i_3 = np.identity(3)
matrix_33 = np.asarray([
[1,2,3],
[4,5,6],
[7,8,9]
])
matrix_23 = np.asarray([
[0.7,3,1],
[1.7,2,10]
], dtype=np.float32)
identity_33 = np.dot(i_3, matrix_33)
identity_23 = np.dot(i_2, matrix_23)
print("identity_33:\n", identity_33)
print("identity_23:\n", identity_23)
# We should expect identity_33 to match matrix_33 and identity_23 to match matrix_23
# This is because each element in the vector is multiplied exactly once by the diagonal 1 value in the identity matrix
identity_33:
[[1. 2. 3.]
[4. 5. 6.]
[7. 8. 9.]]
identity_23:
[[ 0.69999999 3. 1. ]
[ 1.70000005 2. 10. ]]
# Matrix Inverse
# How to cancel the coefficient matrix A. In other words, we want to transform A into the identity matrix I
# Multiply the inverse of a matrix by the matrix
import numpy as np
matrix_a = np.asarray([
[1.5, 3],
[1, 4]
])
# Implement the matrix inverse in Python
def matrix_inverse_two(mat):
"""
Function accepts a 2x2 matrix, as a NumPy ndarray,
returns the matrix inverse.
Function first calculates the determinant of the matrix.
"""
determinant = (mat[0,0]*mat[1,1] - mat[0,1]*mat[1,0])
if determinant == 0:
raise ValueError("The matrix is not invertible")
right_matrix = np.asarray([
[mat[1,1], -mat[0,1]],
[-mat[1,0], mat[0,0]]
])
inverse_matrix = np.dot(1/determinant, right_matrix)
return inverse_matrix
inverse_a = matrix_inverse_two(matrix_a)
print(inverse_a)
i_2 = np.dot(inverse_a, matrix_a)
print(i_2)
[[ 1.33333333 -1. ]
[-0.33333333 0.5 ]]
[[1. 0.]
[0. 1.]]
# Solving the matrix equation
# Create a NumPy ndarray representing A and assign to matrix_a
matrix_a = np.asarray([
[30, -1],
[50, -1]
])
# Create a vector representing b the constants, and assign to vector_b
vector_b = np.asarray([
[-1000],
[-100]
])
# Use the numpy.linalg.inv() function to compute the inverse of a NumPy ndarray
matrix_a_inverse = np.linalg.inv(matrix_a)
# Multiply the inverse of matrix_a with vector_b using numpy.dot()
solution_x = np.dot(matrix_a_inverse, vector_b)
print(solution_x)
[[ 45.]
[2350.]]
# Determinant For Higher Dimensions
# we can only compute the determinant and matrix inverse for square matrices
# we can only compute the matrix inverse of a square matrix when the determinant is not equal to 0
# The determinant of a higher-dimensional system involves breaking down the full matrix into minor matrices
# To compute the determinant in NumPy, we use the numpy.linalg.det() function
# Thankfully, the numpy.linalg.inv() function can work with any n-dimensional square matrix
matrix_22 = np.asarray([
[8, 4],
[4, 2]
])
matrix_33 = np.asarray([
[1, 1, 1],
[1, 1, 6],
[7, 8, 9]
])
det_22 = np.linalg.det(matrix_22)
det_33 = np.linalg.det(matrix_33)
print(det_22)
print(det_33)
0.0
-4.999999999999997
# Matrix Inverse For Higher Dimensions
a = np.array([[1,2],[3,4]])
b = np.array([[1,1,1],[0,2,5],[2,5,-1]])
a_inv = np.linalg.inv(a)
b_inv = np.linalg.inv(b)
print(a_inv)
print(b_inv)
[[-2. 1. ]
[ 1.5 -0.5]]
[[ 1.28571429 -0.28571429 -0.14285714]
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
mat_22 = np.asarray([[8, 4],[4, 2]])
mat_22_inv = np.linalg.inv(mat_22)
print(mat_22_inv)
Execution error
LinAlgError: Singular matrix
mat_33 = np.asarray([[1, 1, 1],[1, 1, 6],[7, 8, 9]])
mat_33_inv = np.linalg.inv(mat_33)
print(mat_33_inv)
[[ 7.8 0.2 -1. ]
[-6.6 -0.4 1. ]
[-0.2 0.2 -0. ]]