input: Write a python function to initialize and perform a forward pass with the `ObjectDetectionNetwork` class.
  ```python
  import torch 
  import torch.nn as nn 
  
  class ObjectDetectionNetwork(nn.Module): 
  
      def __init__(self): 
          super(ObjectDetectionNetwork, self).__init__() 
  
          # Layer 1 
          self.layer1 = nn.Conv2d(3, 32, 3, padding=1) 
          self.bn1 = nn.BatchNorm2d(32) 
          self.relu1 = nn.ReLU()
  
          # Layer 2 
          self.layer2 = nn.Conv2d(32, 64, 3, padding=1) 
          self.bn2 = nn.BatchNorm2d(64) 
          self.relu2 = nn.ReLU()
  
          # Layer 3 
          self.layer3 = nn.Conv2d(64, 128, 3, padding=1) 
          self.bn3 = nn.BatchNorm2d(128) 
          self.relu3 = nn.ReLU()
  
          # Layer 4 
          self.layer4 = nn.Conv2d(128, 256, 3, padding=1) 
          self.bn4 = nn.BatchNorm2d(256) 
          self.relu4 = nn.ReLU()
  
          # Layer 5 
          self.layer5 = nn.Conv2d(256, 512, 3, padding=1) 
          self.bn5 = nn.BatchNorm2d(512) 
          self.relu5 = nn.ReLU()
  
          # Max pooling layer 
          self.maxpool = nn.MaxPool2d(2, 2) 
  
          # Fully connected layer 
          self.fc1 = nn.Linear(512, 4) 
  
  
      # Forward pass 
      def forward(self, x): 
          # Layer 1 
          x = self.layer1(x) 
          x = self.bn1(x) 
          x = self.relu1(x) 
  
          # Layer 2 
          x = self.layer2(x) 
          x = self.bn2(x) 
          x = self.relu2(x) 
  
          # Layer 3 
          x = self.layer3(x) 
          x = self.bn3(x) 
          x = self.relu3(x) 
  
          # Layer 4 
          x = self.layer4(x) 
          x = self.bn4(x) 
          x = self.relu4(x) 
  
          # Layer 5 
          x = self.layer5(x) 
          x = self.bn5(x) 
          x = self.relu5(x) 
  
          # Max pooling 
          x = self.maxpool(x) 
  
          # Reshape 
          x = x.view(-1, 512) 
  
          # Fully connected layer 
          x = self.fc1(x) 
  
          return x
  
  def test_network_forward_pass():
      # Initialize the network
      net = ObjectDetectionNetwork()
      # Create a random tensor with the shape [1, 3, 32, 32]
      input_tensor = torch.randn(1, 3, 32, 32)
      # Perform a forward pass
      output = net(input_tensor)
      # Assert the output shape is correct
      assert output.shape == (1, 4), f"Expected shape (1, 4), but got {output.shape}"
  
  test_network_forward_pass()
output: def test_network_forward_pass():
      # Initialize the network
      net = ObjectDetectionNetwork()
      # Create a random tensor with the shape [1, 3, 32, 32]
      input_tensor = torch.randn(1, 3, 32, 32)
      # Perform a forward pass
      output = net(input_tensor)
      # Assert the output shape is correct
      assert output.shape == (1, 4), f"Expected shape (1, 4), but got {output.shape}"
  
  test_network_forward_pass()