Mathematics for Machine Learning – Day 7

import numpy as np

def compare_two_matrices(matrixA:np.ndarray, matrixB:np.ndarray)->np.ndarray:
    # Ensuring matrix A and B is the same
    if matrixA.shape != matrixB.shape:
        return "Matrix A and B should have the same shape"

    # Comparing each index of the matrices and returning a list
    result = [i for j in matrixA==matrixB for i in j]

    #Return text if all inside the list is true
    if all(result):
        return "Both matrices are exactly the same"

    #Return text if not all inside the list is true
    return "Matrices are not the same"

m = 5
n = 3

Amn = np.random.randint(low=0,high=100,size=(m,n))
Bmn = np.random.randint(low=0,high=100,size=(m,n))
Cmn = Amn+Bmn
Dmn = Amn-Bmn

print(Amn.shape,Bmn.shape, Cmn.shape, Dmn.shape)
# (5, 3) (5, 3) (5, 3) (5, 3)

m = 5
n = 3
k = 9

Amn = np.random.randint(low=0,high=100,size=(m,n))
Bnk = np.random.randint(low=0,high=100,size=(n,k))
Cmk = np.dot(Amn,Bnk)

print(Amn.shape,Bnk.shape, Cmk.shape)
# (5, 3) (3, 9) (5, 9)

m = 9
n = 3
k = 5
l = 7

Amn = np.random.randint(low=0,high=100,size=(m,n))
Bnk = np.random.randint(low=0,high=100,size=(n,k))
Ckl = np.random.randint(low=0,high=100,size=(k,l))

Left_section = np.dot(np.dot(Amn,Bnk), Ckl)
Right_section = np.dot(Amn, np.dot(Bnk,Ckl))

compare_two_matrices(Left_section, Right_section)

# 'Both matrices are exactly the same'

m = 9
n = 3
k = 5

Amn = np.random.randint(low=0,high=100,size=(m,n))
Bmn = np.random.randint(low=0,high=100,size=(m,n))
Cnk = np.random.randint(low=0,high=100,size=(n,k))

Left_section = np.dot((Amn+Bmn),Cnk)
Right_section = np.dot(Amn, Cnk) + np.dot(Bmn, Cnk)

compare_two_matrices(Left_section, Right_section)

# 'Both matrices are exactly the same'

m = 9
n = 3
k = 5

Amn = np.random.randint(low=0,high=100,size=(m,n))
Bnk = np.random.randint(low=0,high=100,size=(n,k))
Cnk = np.random.randint(low=0,high=100,size=(n,k))

Left_section =  np.dot(Amn, (Bnk + Cnk))
Right_section = np.dot(Amn, Bnk) + np.dot(Amn, Cnk)

compare_two_matrices(Left_section, Right_section)

# 'Both matrices are exactly the same'

identity_matrix = np.identity(2)
wrong_matrix = np.array([[4,8],[1,2]])
right_matrix = np.array([[4,8],[0.5,2]])

def create_inverse(matrix:np.ndarray)->np.ndarray:
    # Confirming square matrix
    if matrix.shape[0] != matrix.shape[1]:
        return "Matrix needs to be square to be inversed."

    # Confirming shape
    if matrix.shape != (2,2):
        return "I'm not smart enough to code more complex matrices and don't ask for an inverse of 1x1."

    # Creating the adjoint matrix
    adj_matrix = [[matrix[-1][-1],-matrix[0][-1]],\
            [-matrix[-1][0],matrix[0][0]]]

    # Creating the determinant of the matrix
    det_matrix = np.dot(matrix[0][0],matrix[-1][-1])-np.dot(matrix[0][-1],matrix[-1][0])

    #Calculating the inverse of the matrix
    inverse_matrix = adj_matrix/det_matrix

    return inverse_matrix


create_inverse(wrong_matrix)

# RuntimeWarning: divide by zero encountered in divide (inverse_matrix = adj_matrix/det_matrix)

create_inverse(right_matrix)

"""
array([[ 0.5  , -2.   ],
       [-0.125,  1.   ]])
"""

multiply_with_inverse = np.dot(create_inverse(right_matrix), right_matrix)

compare_two_matrices(multiply_with_inverse, identity_matrix)

# 'Both matrices are exactly the same'

def MSE_function(predicted:np.ndarray, expected:np.ndarray)->np.ndarray: # Mean squared error
    if len(predicted) != len(expected):
        return "Predicted output and expected output should be the same"

    #The amount of values in prediction and expected values
    n = len(predicted)

    # Calculating the difference squared of the expected and predicted value
    total_square = np.array([(predicted[i]-expected[i]) for i in range(n)])

    # The mean squared of the difference
    mse_value = total_square/n

    return mse_value

def finding_gradient(input_matrix:np.ndarray, mse_error:np.ndarray)->np.ndarray:

    #Multiplying matrix A (transposed) by the MSE vector
    At_E = np.dot(input_matrix.T, mse_error)

    # Dividing it by m and multiplying it by 2
    gradient = (2/len(mse_error))*At_E

    return gradient

def update_x(current_x:np.ndarray, gradient:np.ndarray, descent:int = 0.1)->np.ndarray:
"""
I'm using assert because I'd rather have an error on this section rather than outputing a string that'll be an error
somewhere else down the line :D
"""
    assert len(current_x)==len(gradient)

    # The amount of value
    n = len(current_x)

    # Multiplying the gradient by the learning rate
    gradient = gradient*descent

    # Iterating against x and subtracting it by alpha*gradient
    update_values = [(current_x[i]-gradient[i]) for i in range(n)]

    return update_values

A = np.array([[1, 0, 8, 0, -4], [0, 1, 2, 0, -12], [0, 0, 4, 1, 7]])
B = np.array([42, 8, 12])
x = np.array([0, 0, 0, 0, 0])
descent_value = 0.041

for i in range(10000):
    prediction = np.dot(A,x)

    mse_value = MSE_function(prediction, B)

    gradient = finding_gradient(A, mse_value)

    x = update_x(x, gradient, descent_value)

    # Generating final report
    if np.abs(sum(mse_value))<0.0001:
        print("Generation finish after {} iteration".format(i))
        print("A total mean square error value of {} or an average of {}\n".format(round(sum(mse_value),5),np.mean(mse_value)))
        print("With x:",x)
        print("With Ax:",np.dot(A,x))
        break
"""
Generation finish after 1077 iteration
A total mean square error value of 0.0001 or an average of 3.303279802955059e-05

With x: [4.024892733606064, -4.136195147684619, 4.626743232157506, -4.825002085330449, -0.24024375952185326]
With Ax: [41.99981363  8.00021643 12.00026453]
"""