code: def drop_block_2d(
      x,
      drop_prob: float = 0.1,
      block_size: int = 7,
      gamma_scale: float = 1.0,
      with_noise: bool = False,
      inplace: bool = False,
      batchwise: bool = False,
  ):
      """DropBlock. See https://arxiv.org/pdf/1810.12890.pdf
      DropBlock with an experimental gaussian noise option. This layer has been tested on
      a few training runs with success, but needs further validation and possibly
      optimization for lower runtime impact.
      """
      B, C, H, W = x.shape
      total_size = W * H
      clipped_block_size = min(block_size, min(W, H))
      # seed_drop_rate, the gamma parameter
      gamma = (
          gamma_scale
          * drop_prob
          * total_size
          / clipped_block_size**2
          / ((W - block_size + 1) * (H - block_size + 1))
      )
  
      # Forces the block to be inside the feature map.
      w_i, h_i = torch.meshgrid(
          torch.arange(W).to(x.device), torch.arange(H).to(x.device)
      )
      valid_block = (
          (w_i >= clipped_block_size // 2)
          & (w_i < W - (clipped_block_size - 1) // 2)
      ) & (
          (h_i >= clipped_block_size // 2)
          & (h_i < H - (clipped_block_size - 1) // 2)
      )
      valid_block = torch.reshape(valid_block, (1, 1, H, W)).to(
          dtype=x.dtype
      )
  
      if batchwise:
          # one mask for whole batch, quite a bit faster
          uniform_noise = torch.rand(
              (1, C, H, W), dtype=x.dtype, device=x.device
          )
      else:
          uniform_noise = torch.rand_like(x)
      block_mask = ((2 - gamma - valid_block + uniform_noise) >= 1).to(
          dtype=x.dtype
      )
      block_mask = -F.max_pool2d(
          -block_mask,
          kernel_size=clipped_block_size,  # block_size,
          stride=1,
          padding=clipped_block_size // 2,
      )
  
      if with_noise:
          normal_noise = (
              torch.randn((1, C, H, W), dtype=x.dtype, device=x.device)
              if batchwise
              else torch.randn_like(x)
          )
          if inplace:
              x.mul_(block_mask).add_(normal_noise * (1 - block_mask))
          else:
              x = x * block_mask + normal_noise * (1 - block_mask)
      else:
          normalize_scale = (
              block_mask.numel()
              / block_mask.to(dtype=torch.float32).sum().add(1e-7)
          ).to(x.dtype)
          if inplace:
              x.mul_(block_mask * normalize_scale)
          else:
              x = x * block_mask * normalize_scale
      return x
  
imports: import collections.abc
  import math
  import warnings
  from dataclasses import dataclass
  from functools import partial
  from itertools import repeat
  import omegaconf
  import torch
  import torch.nn
  import torch.nn.functional
  from mmf.common.registry import registry
  from mmf.modules.encoders import Encoder
label_desc: Use image node_id 2 for calling a global function with example usage: drop_block_2d(x, drop_prob, block_size, gamma_scale, with_noise, inplace, batchwise) and returns: x