code: def drop_block_fast_2d(
      x: torch.Tensor,
      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. Simplied from above without
      concern for valid block mask at edges.
      """
      B, C, H, W = x.shape
      total_size = W * H
      clipped_block_size = min(block_size, min(W, H))
      gamma = (
          gamma_scale
          * drop_prob
          * total_size
          / clipped_block_size**2
          / ((W - block_size + 1) * (H - block_size + 1))
      )
  
      if batchwise:
          # one mask for whole batch, quite a bit faster
          block_mask = (
              torch.rand((1, C, H, W), dtype=x.dtype, device=x.device)
              < gamma
          )
      else:
          # mask per batch element
          block_mask = torch.rand_like(x) < gamma
      block_mask = F.max_pool2d(
          block_mask.to(x.dtype),
          kernel_size=clipped_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_(1.0 - block_mask).add_(normal_noise * block_mask)
          else:
              x = x * (1.0 - block_mask) + normal_noise * block_mask
      else:
          block_mask = 1 - block_mask
          normalize_scale = (
              block_mask.numel()
              / block_mask.to(dtype=torch.float32).sum().add(1e-7)
          ).to(dtype=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 3 for calling a global function with example usage: drop_block_fast_2d(x, drop_prob, block_size, gamma_scale, with_noise, inplace, batchwise) and returns: x