code: def _evaluate(self, Gs, Gs_kwargs, num_gpus):
      minibatch_size = num_gpus * self.minibatch_per_gpu
      inception = misc.load_pkl(
          "https://drive.google.com/uc?id=1MzTY44rLToO5APn8TZmfR7_ENSe5aZUn"
      )  # inception_v3_features.pkl
      activations = np.empty(
          [self.num_images, inception.output_shape[1]], dtype=np.float32
      )
  
      # Calculate statistics for reals.
      cache_file = self._get_cache_file_for_reals(
          num_images=self.num_images
      )
      os.makedirs(os.path.dirname(cache_file), exist_ok=True)
      if os.path.isfile(cache_file):
          mu_real, sigma_real = misc.load_pkl(cache_file)
      else:
          for idx, images in enumerate(
              self._iterate_reals(minibatch_size=minibatch_size)
          ):
              begin = idx * minibatch_size
              end = min(begin + minibatch_size, self.num_images)
              activations[begin:end] = inception.run(
                  images[: end - begin],
                  num_gpus=num_gpus,
                  assume_frozen=True,
              )
              if end == self.num_images:
                  break
          mu_real = np.mean(activations, axis=0)
          sigma_real = np.cov(activations, rowvar=False)
          misc.save_pkl((mu_real, sigma_real), cache_file)
  
      # Construct TensorFlow graph.
      result_expr = []
      for gpu_idx in range(num_gpus):
          with tf.device("/gpu:%d" % gpu_idx):
              Gs_clone = Gs.clone()
              inception_clone = inception.clone()
              latents = tf.random_normal(
                  [self.minibatch_per_gpu] + Gs_clone.input_shape[1:]
              )
              labels = self._get_random_labels_tf(
                  self.minibatch_per_gpu
              )
              images = Gs_clone.get_output_for(
                  latents, labels, **Gs_kwargs
              )
              images = tflib.convert_images_to_uint8(images)
              result_expr.append(inception_clone.get_output_for(images))
  
      # Calculate statistics for fakes.
      for begin in range(0, self.num_images, minibatch_size):
          self._report_progress(begin, self.num_images)
          end = min(begin + minibatch_size, self.num_images)
          activations[begin:end] = np.concatenate(
              tflib.run(result_expr), axis=0
          )[: end - begin]
      mu_fake = np.mean(activations, axis=0)
      sigma_fake = np.cov(activations, rowvar=False)
  
      # Calculate FID.
      m = np.square(mu_fake - mu_real).sum()
      s, _ = scipy.linalg.sqrtm(
          np.dot(sigma_fake, sigma_real), disp=False
      )  # pylint: disable=no-member
      dist = m + np.trace(sigma_fake + sigma_real - 2 * s)
      self._report_result(np.real(dist))
  
file_path: insightface/reconstruction/ostec/external/stylegan2/metrics/frechet_inception_distance.py
imports: import os
  import numpy
  import scipy
  import tensorflow
  import dnnlib.tflib
  from metrics import metric_base
  from training import misc
label_desc: Use image node_id 2 for calling the FID obj's underlying member method code with example usage: obj._evaluate(Gs, Gs_kwargs, num_gpus) without return types