class_docstr: The BlazeFace face detection model from MediaPipe.
  
  The version from MediaPipe is simpler than the one in the paper;
  it does not use the "double" BlazeBlocks.
  
  Because we won't be training this model, it doesn't need to have
  batchnorm layers. These have already been "folded" into the conv
  weights by TFLite.
  
  The conversion to PyTorch is fairly straightforward, but there are
  some small differences between TFLite and PyTorch in how they handle
  padding on conv layers with stride 2.
  
  This version works on batches, while the MediaPipe version can only
  handle a single image at a time.
  
  Based on code from https://github.com/tkat0/PyTorch_BlazeFace/ and
  https://github.com/google/mediapipe/
code: def forward(self, x):
      # TFLite uses slightly different padding on the first conv layer
      # than PyTorch, so do it manually.
      x = F.pad(x, (1, 2, 1, 2), "constant", 0)
  
      b = x.shape[0]  # batch size, needed for reshaping later
  
      if self.back_model:
          x = self.backbone(x)  # (b, 16, 16, 96)
          h = self.final(x)  # (b, 8, 8, 96)
      else:
          x = self.backbone1(x)  # (b, 88, 16, 16)
          h = self.backbone2(x)  # (b, 96, 8, 8)
  
      # Note: Because PyTorch is NCHW but TFLite is NHWC, we need to
      # permute the output from the conv layers before reshaping it.
  
      c1 = self.classifier_8(x)  # (b, 2, 16, 16)
      c1 = c1.permute(0, 2, 3, 1)  # (b, 16, 16, 2)
      c1 = c1.reshape(b, -1, 1)  # (b, 512, 1)
  
      c2 = self.classifier_16(h)  # (b, 6, 8, 8)
      c2 = c2.permute(0, 2, 3, 1)  # (b, 8, 8, 6)
      c2 = c2.reshape(b, -1, 1)  # (b, 384, 1)
  
      c = torch.cat((c1, c2), dim=1)  # (b, 896, 1)
  
      r1 = self.regressor_8(x)  # (b, 32, 16, 16)
      r1 = r1.permute(0, 2, 3, 1)  # (b, 16, 16, 32)
      r1 = r1.reshape(b, -1, 16)  # (b, 512, 16)
  
      r2 = self.regressor_16(h)  # (b, 96, 8, 8)
      r2 = r2.permute(0, 2, 3, 1)  # (b, 8, 8, 96)
      r2 = r2.reshape(b, -1, 16)  # (b, 384, 16)
  
      r = torch.cat((r1, r2), dim=1)  # (b, 896, 16)
      return [r, c]
  
imports: import numpy
  import torch
  import torch.nn
  import torch.nn.functional
label_desc: Use image node_id 5 for calling the BlazeFace obj's underlying member method code with example usage: obj.forward(x) and returns: list