input: 
  import numpy as np
  class LinearRegressionModel:
      def __init__(self, input_dim, output_dim):
          ''' Initialises the weights and bias of the linear regression model
          Arguments:
              input_dim {int} -- Number of input features
              output_dim {int} -- Number of outputs
          '''
          self.weights = np.zeros((input_dim, output_dim))
          self.bias = np.zeros((1, output_dim))
  
      def forward(self, x):
          ''' Calculates the forward pass of the linear regression model
          Arguments:
              x {numpy array} -- Input data of size (N, input_dim)
          Returns:
              out {numpy array} -- Output of the linear regression model of size (N, output_dim)
          '''
          out = np.dot(x, self.weights) + self.bias
          return out
  # Testing the LinearRegressionModel class
  model = LinearRegressionModel(2, 1)
  input_data = np.array([[1, 2], [3, 4]])
  output_data = model.forward(input_data)
  print(output_data)  # Expected output: [[0.], [0.]]
  
output:     def backward(self, x, grad_output):
          ''' Calculates the backward pass of the linear regression model
          Arguments:
              x {numpy array} -- Input data of size (N, input_dim)
              grad_output {numpy array} -- Gradient of the loss with respect to the output of size (N, output_dim)
          Returns:
              grad_input {numpy array} -- Gradient of the loss with respect to the input of size (N, input_dim)
          '''
          grad_input = np.dot(grad_output, self.weights.T)
          self.weights_grad = np.dot(x.T, grad_output)
          self.bias_grad = np.sum(grad_output, axis=0, keepdims=True)
          return grad_input
  
      def update_parameters(self, learning_rate):
          ''' Updates the weights and bias using the gradients calculated in the backward pass
          Arguments:
              learning_rate {float} -- Learning rate for the update
          '''
          self.weights -= learning_rate * self.weights_grad
          self.bias -= learning_rate * self.bias_grad
  
  # Testing the backward pass and parameter update
  grad_output = np.array([[1], [1]])
  grad_input = model.backward(input_data, grad_output)
  print(grad_input)  # Expected output: [[1. 1.], [1. 1.]]
  model.update_parameters(0.1)
  print(model.weights)  # Expected output: [[-0.1 -0.1], [-0.3 -0.3]]
  print(model.bias)  # Expected output: [[-0.2]]