class_docstr: Implementation of a multiscale attention block. Compare to a conventional attention
  block, a multiscale attention block optionally supports pooling (either
  before or after qkv projection). If pooling is not used, a multiscale attention
  block is equivalent to a conventional attention block.
  
  ::
                                 Input
                                   |
                  |----------------|-----------------|
                  ↓                ↓                 ↓
                Linear           Linear            Linear
                  &                &                 &
               Pool (Q)         Pool (K)          Pool (V)
                  → -------------- ←                 |
                           ↓                         |
                     MatMul & Scale                  |
                           ↓                         |
                        Softmax                      |
                           → ----------------------- ←
                                       ↓
                                 MatMul & Scale
                                       ↓
                                    DropOut
code: def _reshape_qkv_to_seq(
      self,
      q: torch.Tensor,
      k: torch.Tensor,
      v: torch.Tensor,
      q_N: int,
      v_N: int,
      k_N: int,
      B: int,
      C: int,
  ) -> Tuple[int]:
      q = q.permute(0, 2, 1, 3).reshape(B, q_N, C)
      v = v.permute(0, 2, 1, 3).reshape(B, v_N, C)
      k = k.permute(0, 2, 1, 3).reshape(B, k_N, C)
      return q, k, v
  
imports: from typing import List, Optional, Tuple
  import numpy
  import torch
  import torch.fx
  import torch.nn
  from torch.nn.common_types import _size_3_t
  from .drop_path import DropPath
label_desc: Use image node_id 5 for calling the MultiScaleAttention obj's underlying member method code with example usage: obj._reshape_qkv_to_seq(q, k, v, q_N, v_N, k_N, B, C) and returns: q,  k,  v