Python - K Matrix Initialization

Matrix is a popular data representation technique in mathematics, machine modeling, etc. They are designed to deal with linear functions. Matrix initialization is a process to fill up the elements (rows and columns) of the matrix with either random or some predetermined values. After initialization there should be no undefined entries in the matrix.

Initializing the matrix is one of the essential tasks in several fields, like competitive programming, machine and deep learning algorithms. In this article, we will learn how to initialize the matrix using various methods like loops, NumPy arrays, etc.

Using Custom Logic with Lists

Matrix initialization with any value k can be done with several looping statements like while loop, for loop, etc. We need to define our matrix and the value of k. Next, we need to iterate over the rows and columns and set the value at that position to k.

Example

In the following code, we have first created the custom function named initialize_matrix, which takes the number of rows, columns, and k as the parameters ?

def initialize_matrix(rows, columns, k=0):
    matrix = []
    for _ in range(rows):
        row = [k] * columns
        matrix.append(row)
    return matrix

rows = 5
columns = 5
k = -1
matrix = initialize_matrix(rows, columns, k)
print(f"The initialized matrix with {rows} rows and {columns} columns with initial values as {k} is:")
for row in matrix:
    print(row)

The initialized matrix with 5 rows and 5 columns with initial values as -1 is:
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]

Zero Initialization with NumPy

Initializing the matrix with zero as the elements is one of the most common tasks in several programming techniques. This provides a starting point for computation and serves as a baseline for the operations. Setting all the elements to zero also removes bias for any rows or columns.

Example

We used the NumPy array in the following code to initialize the matrix. We used the zeros() function, which takes the number of rows and columns as the parameters and fills them with 0 ?

import numpy as np

def initialize_zero_matrix(rows, columns):
    matrix = np.zeros((rows, columns))
    return matrix

rows = 3
columns = 3
matrix = initialize_zero_matrix(rows, columns)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Initialization with Ones using NumPy

Another popular initialization is to initialize the matrix with one. This is useful when we want to set the base to be a whole number. NumPy provides the ones() function, which takes the dimension of the array and returns the array with all the elements filled with one.

Example

In the following example, we have first imported the library named NumPy. The initialize_matrix function takes the rows and columns as the parameters ?

import numpy as np

def initialize_ones_matrix(rows, columns):
    matrix = np.ones((rows, columns))
    return matrix

rows = 5
columns = 4
matrix = initialize_ones_matrix(rows, columns)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

Random Initialization with NumPy

Random initialization is one of the most widely used techniques in deep learning. Random initialization means the initialization of the elements of the matrix with random numbers. In practice, they prove to give better results compared to the initialization with ones or zeros.

Example

In the following example, we used the randint() method of NumPy to initialize the matrix with random numbers. The k and n parameters signify the range from which we need to pick up the random numbers ?

import numpy as np

def initialize_random_matrix(rows, columns, k, n):
    matrix = np.random.randint(k, n, size=(rows, columns))
    return matrix

rows = 5
columns = 4
k = 19
n = 25
matrix = initialize_random_matrix(rows, columns, k, n)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[22 21 23 21]
 [22 22 21 23]
 [20 20 19 24]
 [22 21 21 24]
 [21 21 23 20]]

Constraint Initialization with Specific Values

Constraint initialization is used to initialize matrices with specific constraints or properties. It involves setting the matrix's initial values to satisfy certain predefined conditions. For example, while dealing with optimization problems, we can utilize constraint initialization to ensure that the matrix satisfies certain linear or non?linear constraints.

Example

In the following code, we used the full() method of the NumPy library to fill the matrix with specific values ?

import numpy as np

def initialize_constraint_matrix(rows, columns, value):
    matrix = np.full((rows, columns), value)
    return matrix

rows = 2
columns = 2
value = 5
matrix = initialize_constraint_matrix(rows, columns, value)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[5 5]
 [5 5]]

Identity Matrix Initialization

Identity initialization is a technique used to initialize matrices with the identity matrix. The identity matrix is a square matrix where all diagonal elements are set to 1, and all off?diagonal elements are set to 0. When multiplied with another matrix, the identity matrix will give the same matrix.

Example

In the following code, we have used the eye() method of the NumPy library to initialize the matrix. Note that since the identity matrix is always square, the number of rows equals the number of columns ?

import numpy as np

def initialize_identity_matrix(size):
    matrix = np.eye(size)
    return matrix

size = 3
matrix = initialize_identity_matrix(size)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Diagonal Matrix Initialization

Diagonal initialization is used to initialize matrices where only the diagonal elements have non?zero values. In this approach, the off?diagonal elements are set to zero, while the diagonal elements can have different values depending on the specific requirements. This is very useful in electrical engineering, algebra, signal processing, etc.

Example

In the following code, we used the diag() method to create a diagonal matrix ?

import numpy as np

def initialize_diagonal_matrix(diagonal_values):
    matrix = np.diag(diagonal_values)
    return matrix

diagonal_values = [1, 2, 3]
matrix = initialize_diagonal_matrix(diagonal_values)
print(f"Our Initialized matrix is:\n{matrix}")

Our Initialized matrix is:
[[1 0 0]
 [0 2 0]
 [0 0 3]]

Comparison of Methods

Conclusion

In this article, we understood how to initialize a matrix using different methods in Python. We can write our custom logic using loops, or we can use the built?in functions available in NumPy. Each initialization method serves specific purposes depending on the computational requirements and domain applications.