code: def create_instant_clone_node(
      self,
      parent_vm_name,
      target_vm_name,
      node_config,
      tags,
      gpu_cards_map,
  ):
      resources = node_config["resources"]
      to_be_plugged_gpu = []
      requested_gpu_num = resources.get("GPU", 0)
      if requested_gpu_num > 0:
          # If the Ray node requires GPU, we will select the frozen VM to do instant
          # clone based on GPU availability
          if not gpu_cards_map:
              raise ValueError(
                  f"No available GPU card to assigned to node {target_vm_name}"
              )
  
          for vm_name in gpu_cards_map:
              # the gpu_cards_map has helped you to stored which GPUs should bind and
              # which frozen VM should be cloned. There is only one k,v pair in this
              # map
              parent_vm_name = vm_name
              to_be_plugged_gpu = gpu_cards_map[vm_name]
              break
  
      tags[
          Constants.VSPHERE_NODE_STATUS
      ] = Constants.VsphereNodeStatus.CREATING.value
      threading.Thread(
          target=self.get_vsphere_sdk_provider().tag_new_vm_instantly,
          args=(target_vm_name, tags),
      ).start()
      self.get_pyvmomi_sdk_provider().instance_clone_vm(
          parent_vm_name,
          target_vm_name,
          node_config.get("resource_pool"),
          node_config.get("datastore"),
      )
  
      target_vm_id = self.get_pyvmomi_sdk_provider().name_to_id(
          [vim.VirtualMachine], target_vm_name
      )
  
      if "CPU" in resources:
          # Update number of CPUs
          self.get_vsphere_sdk_provider().update_vm_cpu(
              target_vm_id, resources["CPU"]
          )
  
      if "Memory" in resources:
          # Update Memory
          self.get_vsphere_sdk_provider().update_vm_memory(
              target_vm_id, resources["Memory"]
          )
  
      if to_be_plugged_gpu:
          is_dynamic = is_dynamic_passthrough(node_config)
          plug_gpu_cards_to_vm(
              self.get_pyvmomi_sdk_provider(),
              target_vm_name,
              to_be_plugged_gpu,
              is_dynamic,
          )
  
      return self.get_vsphere_sdk_provider().get_vsphere_sdk_vm_obj(
          target_vm_id
      )
  
imports: import copy
  import logging
  import threading
  import uuid
  from concurrent.futures import ThreadPoolExecutor
  from typing import Any, Dict
  from pyVmomi import vim
  from ray.autoscaler._private.vsphere.config import bootstrap_vsphere, is_dynamic_passthrough
  from ray.autoscaler._private.vsphere.gpu_utils import get_gpu_cards_from_vm, get_vm_2_gpu_cards_map, plug_gpu_cards_to_vm, set_gpu_placeholder, split_vm_2_gpu_cards_map
  from ray.autoscaler._private.vsphere.pyvmomi_sdk_provider import PyvmomiSdkProvider
  from ray.autoscaler._private.vsphere.scheduler import SchedulerFactory
  from ray.autoscaler._private.vsphere.utils import Constants, now_ts
  from ray.autoscaler._private.vsphere.vsphere_sdk_provider import VsphereSdkProvider
  from ray.autoscaler.node_provider import NodeProvider
  from ray.autoscaler.tags import TAG_RAY_CLUSTER_NAME, TAG_RAY_NODE_NAME
label_desc: Use image node_id 14 for calling the VsphereNodeProvider obj's underlying member method code with example usage: obj.create_instant_clone_node(parent_vm_name, target_vm_name, node_config, tags, gpu_cards_map) and returns: self