code: def main(args):
      serialization_dir = args.serialization_dir
      pruning_method = args.pruning_method
      threshold = args.threshold
  
      st = torch.load(
          os.path.join(serialization_dir, "pytorch_model.bin"),
          map_location="cpu",
      )
  
      remaining_count = (
          0  # Number of remaining (not pruned) params in the encoder
      )
      encoder_count = 0  # Number of params in the encoder
  
      print(
          "name".ljust(60, " "),
          "Remaining Weights %",
          "Remaining Weight",
      )
      for name, param in st.items():
          if "encoder" not in name:
              continue
  
          if "mask_scores" in name:
              if pruning_method == "topK":
                  mask_ones = (
                      TopKBinarizer.apply(param, threshold).sum().item()
                  )
              elif pruning_method == "sigmoied_threshold":
                  mask_ones = (
                      ThresholdBinarizer.apply(param, threshold, True)
                      .sum()
                      .item()
                  )
              elif pruning_method == "l0":
                  l, r = -0.1, 1.1
                  s = torch.sigmoid(param)
                  s_bar = s * (r - l) + l
                  mask = s_bar.clamp(min=0.0, max=1.0)
                  mask_ones = (mask > 0.0).sum().item()
              else:
                  raise ValueError("Unknown pruning method")
              remaining_count += mask_ones
              print(
                  name.ljust(60, " "),
                  str(round(100 * mask_ones / param.numel(), 3)).ljust(
                      20, " "
                  ),
                  str(mask_ones),
              )
          else:
              encoder_count += param.numel()
              if "bias" in name or "LayerNorm" in name:
                  remaining_count += param.numel()
  
      print("")
      print(
          "Remaining Weights (global) %: ",
          100 * remaining_count / encoder_count,
      )
  
imports: import argparse
  import os
  import torch
  from emmental.modules import ThresholdBinarizer, TopKBinarizer
label_desc: Use image node_id 1 for calling a global function with example usage: main(args) without return types