class_docstr: Pipeline for text-to-image generation using a latent consistency model.
  
  This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
  implemented for all pipelines (downloading, saving, running on a particular device, etc.).
  
  The pipeline also inherits the following loading methods:
      - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
      - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
      - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
      - [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files
  
  Args:
      vae ([`AutoencoderKL`]):
          Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
      text_encoder ([`~transformers.CLIPTextModel`]):
          Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
      tokenizer ([`~transformers.CLIPTokenizer`]):
          A `CLIPTokenizer` to tokenize text.
      unet ([`UNet2DConditionModel`]):
          A `UNet2DConditionModel` to denoise the encoded image latents.
      scheduler ([`SchedulerMixin`]):
          A scheduler to be used in combination with `unet` to denoise the encoded image latents. Currently only
          supports [`LCMScheduler`].
      safety_checker ([`StableDiffusionSafetyChecker`]):
          Classification module that estimates whether generated images could be considered offensive or harmful.
          Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
          about a model's potential harms.
      feature_extractor ([`~transformers.CLIPImageProcessor`]):
          A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
      requires_safety_checker (`bool`, *optional*, defaults to `True`):
          Whether the pipeline requires a safety checker component.
code: def interpolate_latent(
      self,
      start_latent: torch.FloatTensor,
      end_latent: torch.FloatTensor,
      num_interpolation_steps: Union[int, List[int]],
      interpolation_type: str,
  ) -> torch.FloatTensor:
      if interpolation_type == "lerp":
          interpolation_fn = lerp
      elif interpolation_type == "slerp":
          interpolation_fn = slerp
  
      latent = torch.cat([start_latent, end_latent])
      steps = (
          torch.linspace(
              0, 1, num_interpolation_steps, dtype=latent.dtype
          )
          .cpu()
          .numpy()
      )
      steps = np.expand_dims(steps, axis=tuple(range(1, latent.ndim)))
      interpolations = []
  
      # Interpolate between latents
      # TODO: Think of a better way of doing this
      # See if it can be done parallelly instead
      for i in range(latent.shape[0] - 1):
          interpolations.append(
              interpolation_fn(latent[i], latent[i + 1], steps).squeeze(
                  dim=1
              )
          )
  
      return torch.cat(interpolations)
  
imports: import inspect
  from typing import Any, Callable, Dict, List, Optional, Union
  import numpy
  import torch
  from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
  from diffusers.image_processor import VaeImageProcessor
  from diffusers.loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin
  from diffusers.models import AutoencoderKL, UNet2DConditionModel
  from diffusers.models.lora import adjust_lora_scale_text_encoder
  from diffusers.pipelines.pipeline_utils import DiffusionPipeline
  from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput, StableDiffusionSafetyChecker
  from diffusers.schedulers import LCMScheduler
  from diffusers.utils import USE_PEFT_BACKEND, deprecate, logging, replace_example_docstring, scale_lora_layers, unscale_lora_layers
  from diffusers.utils.torch_utils import randn_tensor
label_desc: Use image node_id 15 for calling the LatentConsistencyModelWalkPipeline obj's underlying member method code with example usage: obj.interpolate_latent(start_latent, end_latent, num_interpolation_steps, interpolation_type) and returns: torch