code: def make_animation(
      self,
      source_image,
      driving_video,
      generator,
      kp_detector,
      relative=True,
      adapt_movement_scale=True,
  ):
      with paddle.no_grad():
          predictions = []
          source = paddle.to_tensor(
              source_image[np.newaxis].astype(np.float32)
          ).transpose([0, 3, 1, 2])
  
          driving = paddle.to_tensor(
              np.array(driving_video).astype(np.float32)
          ).transpose([0, 3, 1, 2])
          kp_source = kp_detector(source)
          kp_driving_initial = kp_detector(driving[0:1])
          kp_source_batch = {}
          kp_source_batch["value"] = paddle.tile(
              kp_source["value"], repeat_times=[self.batch_size, 1, 1]
          )
          kp_source_batch["jacobian"] = paddle.tile(
              kp_source["jacobian"],
              repeat_times=[self.batch_size, 1, 1, 1],
          )
          source = paddle.tile(
              source, repeat_times=[self.batch_size, 1, 1, 1]
          )
          begin_idx = 0
          for frame_idx in tqdm(
              range(
                  int(
                      np.ceil(float(driving.shape[0]) / self.batch_size)
                  )
              )
          ):
              frame_num = min(
                  self.batch_size, driving.shape[0] - begin_idx
              )
              driving_frame = driving[begin_idx : begin_idx + frame_num]
              kp_driving = kp_detector(driving_frame)
              kp_source_img = {}
              kp_source_img["value"] = kp_source_batch["value"][
                  0:frame_num
              ]
              kp_source_img["jacobian"] = kp_source_batch["jacobian"][
                  0:frame_num
              ]
  
              kp_norm = normalize_kp(
                  kp_source=kp_source,
                  kp_driving=kp_driving,
                  kp_driving_initial=kp_driving_initial,
                  use_relative_movement=relative,
                  use_relative_jacobian=relative,
                  adapt_movement_scale=adapt_movement_scale,
              )
  
              out = generator(
                  source[0:frame_num],
                  kp_source=kp_source_img,
                  kp_driving=kp_norm,
              )
              img = (
                  np.transpose(out["prediction"].numpy(), [0, 2, 3, 1])
                  * 255.0
              )
  
              if self.face_enhancement:
                  img = self.faceenhancer.enhance_from_batch(img)
  
              predictions.append(img)
              begin_idx += frame_num
      return np.concatenate(predictions)
  
imports: import os
  import sys
  import math
  import pickle
  import yaml
  import imageio
  import numpy
  from tqdm import tqdm
  from scipy.spatial import ConvexHull
  import cv2
  import paddle
  from ppgan.utils.download import get_path_from_url
  from ppgan.utils.animate import normalize_kp
  from ppgan.modules.keypoint_detector import KPDetector
  from ppgan.models.generators.occlusion_aware import OcclusionAwareGenerator
  from ppgan.faceutils import face_detection
label_desc: Use image node_id 5 for calling the FirstOrderPredictor obj's underlying member method code with example usage: obj.make_animation(source_image, driving_video, generator, kp_detector, relative, adapt_movement_scale) and returns: np