code: def convert_key(model_name, bifpn_repeats, weights):
      p6_w1 = [
          torch.tensor([-1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p5_w1 = [
          torch.tensor([-1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p4_w1 = [
          torch.tensor([-1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p3_w1 = [
          torch.tensor([-1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p4_w2 = [
          torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p5_w2 = [
          torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p6_w2 = [
          torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      p7_w2 = [
          torch.tensor([-1e4, -1e4], dtype=torch.float64)
          for _ in range(bifpn_repeats)
      ]
      idx2key = {
          0: "1.0",
          1: "2.0",
          2: "2.1",
          3: "3.0",
          4: "3.1",
          5: "4.0",
          6: "4.1",
          7: "4.2",
          8: "4.3",
          9: "4.4",
          10: "4.5",
          11: "5.0",
          12: "5.1",
          13: "5.2",
          14: "5.3",
          15: "5.4",
      }
      m = dict()
      for k, v in weights.items():
          if "Exponential" in k or "global_step" in k:
              continue
  
          seg = k.split("/")
          if len(seg) == 1:
              continue
          if seg[2] == "depthwise_conv2d":
              v = v.transpose(1, 0)
  
          if seg[0] == model_name:
              if seg[1] == "stem":
                  prefix = "backbone.layers.0"
                  mapping = {
                      "conv2d/kernel": "conv.weight",
                      "tpu_batch_normalization/beta": "bn.bias",
                      "tpu_batch_normalization/gamma": "bn.weight",
                      "tpu_batch_normalization/moving_mean": "bn.running_mean",
                      "tpu_batch_normalization/moving_variance": "bn.running_var",
                  }
                  suffix = mapping["/".join(seg[2:])]
                  m[prefix + "." + suffix] = v
  
              elif seg[1].startswith("blocks_"):
                  idx = int(seg[1][7:])
                  prefix = ".".join(
                      ["backbone", "layers", idx2key[idx]]
                  )
                  base_mapping = {
                      "depthwise_conv2d/depthwise_kernel": "depthwise_conv.conv.weight",
                      "se/conv2d/kernel": "se.conv1.conv.weight",
                      "se/conv2d/bias": "se.conv1.conv.bias",
                      "se/conv2d_1/kernel": "se.conv2.conv.weight",
                      "se/conv2d_1/bias": "se.conv2.conv.bias",
                  }
                  if idx == 0:
                      mapping = {
                          "conv2d/kernel": "linear_conv.conv.weight",
                          "tpu_batch_normalization/beta": "depthwise_conv.bn.bias",
                          "tpu_batch_normalization/gamma": "depthwise_conv.bn.weight",
                          "tpu_batch_normalization/moving_mean": "depthwise_conv.bn.running_mean",
                          "tpu_batch_normalization/moving_variance": "depthwise_conv.bn.running_var",
                          "tpu_batch_normalization_1/beta": "linear_conv.bn.bias",
                          "tpu_batch_normalization_1/gamma": "linear_conv.bn.weight",
                          "tpu_batch_normalization_1/moving_mean": "linear_conv.bn.running_mean",
                          "tpu_batch_normalization_1/moving_variance": "linear_conv.bn.running_var",
                      }
                  else:
                      mapping = {
                          "depthwise_conv2d/depthwise_kernel": "depthwise_conv.conv.weight",
                          "conv2d/kernel": "expand_conv.conv.weight",
                          "conv2d_1/kernel": "linear_conv.conv.weight",
                          "tpu_batch_normalization/beta": "expand_conv.bn.bias",
                          "tpu_batch_normalization/gamma": "expand_conv.bn.weight",
                          "tpu_batch_normalization/moving_mean": "expand_conv.bn.running_mean",
                          "tpu_batch_normalization/moving_variance": "expand_conv.bn.running_var",
                          "tpu_batch_normalization_1/beta": "depthwise_conv.bn.bias",
                          "tpu_batch_normalization_1/gamma": "depthwise_conv.bn.weight",
                          "tpu_batch_normalization_1/moving_mean": "depthwise_conv.bn.running_mean",
                          "tpu_batch_normalization_1/moving_variance": "depthwise_conv.bn.running_var",
                          "tpu_batch_normalization_2/beta": "linear_conv.bn.bias",
                          "tpu_batch_normalization_2/gamma": "linear_conv.bn.weight",
                          "tpu_batch_normalization_2/moving_mean": "linear_conv.bn.running_mean",
                          "tpu_batch_normalization_2/moving_variance": "linear_conv.bn.running_var",
                      }
                  mapping.update(base_mapping)
                  suffix = mapping["/".join(seg[2:])]
                  m[prefix + "." + suffix] = v
          elif seg[0] == "resample_p6":
              prefix = "neck.bifpn.0.p5_to_p6.0"
              mapping = {
                  "conv2d/kernel": "down_conv.weight",
                  "conv2d/bias": "down_conv.bias",
                  "bn/beta": "bn.bias",
                  "bn/gamma": "bn.weight",
                  "bn/moving_mean": "bn.running_mean",
                  "bn/moving_variance": "bn.running_var",
              }
              suffix = mapping["/".join(seg[1:])]
              m[prefix + "." + suffix] = v
          elif seg[0] == "fpn_cells":
              fpn_idx = int(seg[1][5:])
              prefix = ".".join(["neck", "bifpn", str(fpn_idx)])
              fnode_id = int(seg[2][5])
              if fnode_id == 0:
                  mapping = {
                      "op_after_combine5/conv/depthwise_kernel": "conv6_up.depthwise_conv.weight",
                      "op_after_combine5/conv/pointwise_kernel": "conv6_up.pointwise_conv.weight",
                      "op_after_combine5/conv/bias": "conv6_up.pointwise_conv.bias",
                      "op_after_combine5/bn/beta": "conv6_up.bn.bias",
                      "op_after_combine5/bn/gamma": "conv6_up.bn.weight",
                      "op_after_combine5/bn/moving_mean": "conv6_up.bn.running_mean",
                      "op_after_combine5/bn/moving_variance": "conv6_up.bn.running_var",
                  }
                  if seg[3] != "WSM" and seg[3] != "WSM_1":
                      suffix = mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p6_w1[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p6_w1[fpn_idx][1] = v
                  if torch.min(p6_w1[fpn_idx]) > -1e4:
                      m[prefix + ".p6_w1"] = p6_w1[fpn_idx]
              elif fnode_id == 1:
                  base_mapping = {
                      "op_after_combine6/conv/depthwise_kernel": "conv5_up.depthwise_conv.weight",
                      "op_after_combine6/conv/pointwise_kernel": "conv5_up.pointwise_conv.weight",
                      "op_after_combine6/conv/bias": "conv5_up.pointwise_conv.bias",
                      "op_after_combine6/bn/beta": "conv5_up.bn.bias",
                      "op_after_combine6/bn/gamma": "conv5_up.bn.weight",
                      "op_after_combine6/bn/moving_mean": "conv5_up.bn.running_mean",
                      "op_after_combine6/bn/moving_variance": "conv5_up.bn.running_var",
                  }
                  if fpn_idx == 0:
                      mapping = {
                          "resample_0_2_6/conv2d/kernel": "p5_down_channel.down_conv.weight",
                          "resample_0_2_6/conv2d/bias": "p5_down_channel.down_conv.bias",
                          "resample_0_2_6/bn/beta": "p5_down_channel.bn.bias",
                          "resample_0_2_6/bn/gamma": "p5_down_channel.bn.weight",
                          "resample_0_2_6/bn/moving_mean": "p5_down_channel.bn.running_mean",
                          "resample_0_2_6/bn/moving_variance": "p5_down_channel.bn.running_var",
                      }
                      base_mapping.update(mapping)
                  if seg[3] != "WSM" and seg[3] != "WSM_1":
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p5_w1[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p5_w1[fpn_idx][1] = v
                  if torch.min(p5_w1[fpn_idx]) > -1e4:
                      m[prefix + ".p5_w1"] = p5_w1[fpn_idx]
              elif fnode_id == 2:
                  base_mapping = {
                      "op_after_combine7/conv/depthwise_kernel": "conv4_up.depthwise_conv.weight",
                      "op_after_combine7/conv/pointwise_kernel": "conv4_up.pointwise_conv.weight",
                      "op_after_combine7/conv/bias": "conv4_up.pointwise_conv.bias",
                      "op_after_combine7/bn/beta": "conv4_up.bn.bias",
                      "op_after_combine7/bn/gamma": "conv4_up.bn.weight",
                      "op_after_combine7/bn/moving_mean": "conv4_up.bn.running_mean",
                      "op_after_combine7/bn/moving_variance": "conv4_up.bn.running_var",
                  }
                  if fpn_idx == 0:
                      mapping = {
                          "resample_0_1_7/conv2d/kernel": "p4_down_channel.down_conv.weight",
                          "resample_0_1_7/conv2d/bias": "p4_down_channel.down_conv.bias",
                          "resample_0_1_7/bn/beta": "p4_down_channel.bn.bias",
                          "resample_0_1_7/bn/gamma": "p4_down_channel.bn.weight",
                          "resample_0_1_7/bn/moving_mean": "p4_down_channel.bn.running_mean",
                          "resample_0_1_7/bn/moving_variance": "p4_down_channel.bn.running_var",
                      }
                      base_mapping.update(mapping)
                  if seg[3] != "WSM" and seg[3] != "WSM_1":
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p4_w1[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p4_w1[fpn_idx][1] = v
                  if torch.min(p4_w1[fpn_idx]) > -1e4:
                      m[prefix + ".p4_w1"] = p4_w1[fpn_idx]
              elif fnode_id == 3:
                  base_mapping = {
                      "op_after_combine8/conv/depthwise_kernel": "conv3_up.depthwise_conv.weight",
                      "op_after_combine8/conv/pointwise_kernel": "conv3_up.pointwise_conv.weight",
                      "op_after_combine8/conv/bias": "conv3_up.pointwise_conv.bias",
                      "op_after_combine8/bn/beta": "conv3_up.bn.bias",
                      "op_after_combine8/bn/gamma": "conv3_up.bn.weight",
                      "op_after_combine8/bn/moving_mean": "conv3_up.bn.running_mean",
                      "op_after_combine8/bn/moving_variance": "conv3_up.bn.running_var",
                  }
                  if fpn_idx == 0:
                      mapping = {
                          "resample_0_0_8/conv2d/kernel": "p3_down_channel.down_conv.weight",
                          "resample_0_0_8/conv2d/bias": "p3_down_channel.down_conv.bias",
                          "resample_0_0_8/bn/beta": "p3_down_channel.bn.bias",
                          "resample_0_0_8/bn/gamma": "p3_down_channel.bn.weight",
                          "resample_0_0_8/bn/moving_mean": "p3_down_channel.bn.running_mean",
                          "resample_0_0_8/bn/moving_variance": "p3_down_channel.bn.running_var",
                      }
                      base_mapping.update(mapping)
                  if seg[3] != "WSM" and seg[3] != "WSM_1":
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p3_w1[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p3_w1[fpn_idx][1] = v
                  if torch.min(p3_w1[fpn_idx]) > -1e4:
                      m[prefix + ".p3_w1"] = p3_w1[fpn_idx]
              elif fnode_id == 4:
                  base_mapping = {
                      "op_after_combine9/conv/depthwise_kernel": "conv4_down.depthwise_conv.weight",
                      "op_after_combine9/conv/pointwise_kernel": "conv4_down.pointwise_conv.weight",
                      "op_after_combine9/conv/bias": "conv4_down.pointwise_conv.bias",
                      "op_after_combine9/bn/beta": "conv4_down.bn.bias",
                      "op_after_combine9/bn/gamma": "conv4_down.bn.weight",
                      "op_after_combine9/bn/moving_mean": "conv4_down.bn.running_mean",
                      "op_after_combine9/bn/moving_variance": "conv4_down.bn.running_var",
                  }
                  if fpn_idx == 0:
                      mapping = {
                          "resample_0_1_9/conv2d/kernel": "p4_level_connection.down_conv.weight",
                          "resample_0_1_9/conv2d/bias": "p4_level_connection.down_conv.bias",
                          "resample_0_1_9/bn/beta": "p4_level_connection.bn.bias",
                          "resample_0_1_9/bn/gamma": "p4_level_connection.bn.weight",
                          "resample_0_1_9/bn/moving_mean": "p4_level_connection.bn.running_mean",
                          "resample_0_1_9/bn/moving_variance": "p4_level_connection.bn.running_var",
                      }
                      base_mapping.update(mapping)
                  if (
                      seg[3] != "WSM"
                      and seg[3] != "WSM_1"
                      and seg[3] != "WSM_2"
                  ):
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p4_w2[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p4_w2[fpn_idx][1] = v
                  elif seg[3] == "WSM_2":
                      p4_w2[fpn_idx][2] = v
                  if torch.min(p4_w2[fpn_idx]) > -1e4:
                      m[prefix + ".p4_w2"] = p4_w2[fpn_idx]
              elif fnode_id == 5:
                  base_mapping = {
                      "op_after_combine10/conv/depthwise_kernel": "conv5_down.depthwise_conv.weight",
                      "op_after_combine10/conv/pointwise_kernel": "conv5_down.pointwise_conv.weight",
                      "op_after_combine10/conv/bias": "conv5_down.pointwise_conv.bias",
                      "op_after_combine10/bn/beta": "conv5_down.bn.bias",
                      "op_after_combine10/bn/gamma": "conv5_down.bn.weight",
                      "op_after_combine10/bn/moving_mean": "conv5_down.bn.running_mean",
                      "op_after_combine10/bn/moving_variance": "conv5_down.bn.running_var",
                  }
                  if fpn_idx == 0:
                      mapping = {
                          "resample_0_2_10/conv2d/kernel": "p5_level_connection.down_conv.weight",
                          "resample_0_2_10/conv2d/bias": "p5_level_connection.down_conv.bias",
                          "resample_0_2_10/bn/beta": "p5_level_connection.bn.bias",
                          "resample_0_2_10/bn/gamma": "p5_level_connection.bn.weight",
                          "resample_0_2_10/bn/moving_mean": "p5_level_connection.bn.running_mean",
                          "resample_0_2_10/bn/moving_variance": "p5_level_connection.bn.running_var",
                      }
                      base_mapping.update(mapping)
                  if (
                      seg[3] != "WSM"
                      and seg[3] != "WSM_1"
                      and seg[3] != "WSM_2"
                  ):
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p5_w2[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p5_w2[fpn_idx][1] = v
                  elif seg[3] == "WSM_2":
                      p5_w2[fpn_idx][2] = v
                  if torch.min(p5_w2[fpn_idx]) > -1e4:
                      m[prefix + ".p5_w2"] = p5_w2[fpn_idx]
              elif fnode_id == 6:
                  base_mapping = {
                      "op_after_combine11/conv/depthwise_kernel": "conv6_down.depthwise_conv.weight",
                      "op_after_combine11/conv/pointwise_kernel": "conv6_down.pointwise_conv.weight",
                      "op_after_combine11/conv/bias": "conv6_down.pointwise_conv.bias",
                      "op_after_combine11/bn/beta": "conv6_down.bn.bias",
                      "op_after_combine11/bn/gamma": "conv6_down.bn.weight",
                      "op_after_combine11/bn/moving_mean": "conv6_down.bn.running_mean",
                      "op_after_combine11/bn/moving_variance": "conv6_down.bn.running_var",
                  }
                  if (
                      seg[3] != "WSM"
                      and seg[3] != "WSM_1"
                      and seg[3] != "WSM_2"
                  ):
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p6_w2[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p6_w2[fpn_idx][1] = v
                  elif seg[3] == "WSM_2":
                      p6_w2[fpn_idx][2] = v
                  if torch.min(p6_w2[fpn_idx]) > -1e4:
                      m[prefix + ".p6_w2"] = p6_w2[fpn_idx]
              elif fnode_id == 7:
                  base_mapping = {
                      "op_after_combine12/conv/depthwise_kernel": "conv7_down.depthwise_conv.weight",
                      "op_after_combine12/conv/pointwise_kernel": "conv7_down.pointwise_conv.weight",
                      "op_after_combine12/conv/bias": "conv7_down.pointwise_conv.bias",
                      "op_after_combine12/bn/beta": "conv7_down.bn.bias",
                      "op_after_combine12/bn/gamma": "conv7_down.bn.weight",
                      "op_after_combine12/bn/moving_mean": "conv7_down.bn.running_mean",
                      "op_after_combine12/bn/moving_variance": "conv7_down.bn.running_var",
                  }
                  if (
                      seg[3] != "WSM"
                      and seg[3] != "WSM_1"
                      and seg[3] != "WSM_2"
                  ):
                      suffix = base_mapping["/".join(seg[3:])]
                      if "depthwise_conv" in suffix:
                          v = v.transpose(1, 0)
                      m[prefix + "." + suffix] = v
                  elif seg[3] == "WSM":
                      p7_w2[fpn_idx][0] = v
                  elif seg[3] == "WSM_1":
                      p7_w2[fpn_idx][1] = v
                  if torch.min(p7_w2[fpn_idx]) > -1e4:
                      m[prefix + ".p7_w2"] = p7_w2[fpn_idx]
          elif seg[0] == "box_net":
              if "box-predict" in seg[1]:
                  prefix = ".".join(["bbox_head", "reg_header"])
                  base_mapping = {
                      "depthwise_kernel": "depthwise_conv.weight",
                      "pointwise_kernel": "pointwise_conv.weight",
                      "bias": "pointwise_conv.bias",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  if "depthwise_conv" in suffix:
                      v = v.transpose(1, 0)
                  m[prefix + "." + suffix] = v
              elif "bn" in seg[1]:
                  bbox_conv_idx = int(seg[1][4])
                  bbox_bn_idx = int(seg[1][9]) - 3
                  prefix = ".".join(
                      [
                          "bbox_head",
                          "reg_bn_list",
                          str(bbox_conv_idx),
                          str(bbox_bn_idx),
                      ]
                  )
                  base_mapping = {
                      "beta": "bias",
                      "gamma": "weight",
                      "moving_mean": "running_mean",
                      "moving_variance": "running_var",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  m[prefix + "." + suffix] = v
              else:
                  bbox_conv_idx = int(seg[1][4])
                  prefix = ".".join(
                      ["bbox_head", "reg_conv_list", str(bbox_conv_idx)]
                  )
                  base_mapping = {
                      "depthwise_kernel": "depthwise_conv.weight",
                      "pointwise_kernel": "pointwise_conv.weight",
                      "bias": "pointwise_conv.bias",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  if "depthwise_conv" in suffix:
                      v = v.transpose(1, 0)
                  m[prefix + "." + suffix] = v
          elif seg[0] == "class_net":
              if "class-predict" in seg[1]:
                  prefix = ".".join(["bbox_head", "cls_header"])
                  base_mapping = {
                      "depthwise_kernel": "depthwise_conv.weight",
                      "pointwise_kernel": "pointwise_conv.weight",
                      "bias": "pointwise_conv.bias",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  if "depthwise_conv" in suffix:
                      v = v.transpose(1, 0)
                  m[prefix + "." + suffix] = v
              elif "bn" in seg[1]:
                  cls_conv_idx = int(seg[1][6])
                  cls_bn_idx = int(seg[1][11]) - 3
                  prefix = ".".join(
                      [
                          "bbox_head",
                          "cls_bn_list",
                          str(cls_conv_idx),
                          str(cls_bn_idx),
                      ]
                  )
                  base_mapping = {
                      "beta": "bias",
                      "gamma": "weight",
                      "moving_mean": "running_mean",
                      "moving_variance": "running_var",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  m[prefix + "." + suffix] = v
              else:
                  cls_conv_idx = int(seg[1][6])
                  prefix = ".".join(
                      ["bbox_head", "cls_conv_list", str(cls_conv_idx)]
                  )
                  base_mapping = {
                      "depthwise_kernel": "depthwise_conv.weight",
                      "pointwise_kernel": "pointwise_conv.weight",
                      "bias": "pointwise_conv.bias",
                  }
                  suffix = base_mapping["/".join(seg[2:])]
                  if "depthwise_conv" in suffix:
                      v = v.transpose(1, 0)
                  m[prefix + "." + suffix] = v
      return m
  
file_path: mmdetection/projects/EfficientDet/convert_tf_to_pt.py
imports: import argparse
  import numpy
  import torch
  from tensorflow.python.training import py_checkpoint_reader
label_desc: Use image node_id 2 for calling a global function with example usage: convert_key(model_name, bifpn_repeats, weights) and returns: m