code: def fuse_copy_between_cpu_and_gpu(predict_net: caffe2_pb2.NetDef):
      """
      In-place fuse extra copy ops between cpu/gpu for the following case:
          a -CopyAToB-> b -CopyBToA> c1 -NextOp1-> d1
                          -CopyBToA> c2 -NextOp2-> d2
      The fused network will look like:
          a -NextOp1-> d1
            -NextOp2-> d2
      """
  
      _COPY_OPS = ["CopyCPUToGPU", "CopyGPUToCPU"]
  
      def _fuse_once(predict_net):
          ssa, blob_versions = core.get_ssa(predict_net)
          consumer_map = get_consumer_map(ssa)
          versioned_external_output = [
              (name, blob_versions[name])
              for name in predict_net.external_output
          ]
  
          for op_id, op in enumerate(predict_net.op):
              if op.type in _COPY_OPS:
                  fw_copy_versioned_output = ssa[op_id][1][0]
                  consumer_ids = [
                      x[0]
                      for x in consumer_map[fw_copy_versioned_output]
                  ]
                  reverse_op_type = _COPY_OPS[
                      1 - _COPY_OPS.index(op.type)
                  ]
  
                  is_fusable = (
                      len(consumer_ids) > 0
                      and fw_copy_versioned_output
                      not in versioned_external_output
                      and all(
                          predict_net.op[_op_id].type == reverse_op_type
                          and ssa[_op_id][1][0]
                          not in versioned_external_output
                          for _op_id in consumer_ids
                      )
                  )
  
                  if is_fusable:
                      for rv_copy_op_id in consumer_ids:
                          # making each NextOp uses "a" directly and removing Copy ops
                          rs_copy_versioned_output = ssa[rv_copy_op_id][
                              1
                          ][0]
                          next_op_id, inp_id = consumer_map[
                              rs_copy_versioned_output
                          ][0]
                          predict_net.op[next_op_id].input[
                              inp_id
                          ] = op.input[0]
                      # remove CopyOps
                      new_ops = [
                          op
                          for i, op in enumerate(predict_net.op)
                          if i != op_id and i not in consumer_ids
                      ]
                      del predict_net.op[:]
                      predict_net.op.extend(new_ops)
                      return True
  
          return False
  
      # _fuse_once returns False is nothing can be fused
      while _fuse_once(predict_net):
          pass
  
imports: import collections
  import copy
  import functools
  import logging
  import numpy
  import os
  from typing import Any, Callable, Dict, List, Optional, Tuple, Union
  from unittest import mock
  import caffe2.python.utils
  import torch
  import torch.nn.functional
  from caffe2.proto import caffe2_pb2
  from caffe2.python import core, net_drawer, workspace
  from torch.nn.functional import interpolate
label_desc: Use image node_id 38 for calling a global function with example usage: fuse_copy_between_cpu_and_gpu(predict_net) and returns: False, True