code: def apply_rotary_emb(
      xq: torch.Tensor,
      xk: torch.Tensor,
      freqs_cis: torch.Tensor,
  ) -> Tuple[torch.Tensor, torch.Tensor]:
      """
      Apply rotary embeddings to input tensors using the given frequency tensor.
  
      This function applies rotary embeddings to the given query 'xq' and key 'xk' tensors using the provided
      frequency tensor 'freqs_cis'. The input tensors are reshaped as complex numbers, and the frequency tensor
      is reshaped for broadcasting compatibility. The resulting tensors contain rotary embeddings and are
      returned as real tensors.
  
      Args:
          xq (torch.Tensor): Query tensor to apply rotary embeddings.
          xk (torch.Tensor): Key tensor to apply rotary embeddings.
          freqs_cis (torch.Tensor): Precomputed frequency tensor for complex exponentials.
  
      Returns:
          Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor and key tensor with rotary embeddings.
  
  
  
      """
      xq_ = torch.view_as_complex(
          xq.float().reshape(*xq.shape[:-1], -1, 2)
      )
      xk_ = torch.view_as_complex(
          xk.float().reshape(*xk.shape[:-1], -1, 2)
      )
      freqs_cis = reshape_for_broadcast(freqs_cis, xq_)
      xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)
      xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)
      return xq_out.type_as(xq), xk_out.type_as(xk)
  
imports: import torch
  import torch.nn.functional
  from typing import Optional, Tuple
label_desc: Use image node_id 3 for calling a global function with example usage: apply_rotary_emb(xq, xk, freqs_cis) and returns: xq_out,  xk_out