code: def expected_soft_attention(
      alpha: Tensor,
      soft_energy: Tensor,
      padding_mask: Optional[Tensor] = None,
      chunk_size: Optional[int] = None,
      eps: float = 1e-10,
  ):
      """
      Function to compute expected soft attention for
      monotonic infinite lookback attention from
      expected alignment and soft energy.
  
      Reference:
      Monotonic Chunkwise Attention
      https://arxiv.org/abs/1712.05382
  
      Monotonic Infinite Lookback Attention for Simultaneous Machine Translation
      https://arxiv.org/abs/1906.05218
  
      alpha: bsz, tgt_len, src_len
      soft_energy: bsz, tgt_len, src_len
      padding_mask: bsz, src_len
      left_padding: bool
      """
      if padding_mask is not None:
          alpha = alpha.masked_fill(padding_mask.unsqueeze(1), 0.0)
          soft_energy = soft_energy.masked_fill(
              padding_mask.unsqueeze(1), -float("inf")
          )
  
      prob_check(alpha)
  
      dtype = alpha.dtype
  
      alpha = alpha.float()
      soft_energy = soft_energy.float()
  
      soft_energy = (
          soft_energy - soft_energy.max(dim=2, keepdim=True)[0]
      )
      exp_soft_energy = torch.exp(soft_energy) + eps
  
      if chunk_size is not None:
          # Chunkwise
          beta = exp_soft_energy * moving_sum(
              alpha
              / (eps + moving_sum(exp_soft_energy, chunk_size, 1)),
              1,
              chunk_size,
          )
      else:
          # Infinite lookback
          # Notice that infinite lookback is a special case of chunkwise
          # where chunksize = inf
          inner_items = alpha / (
              eps + torch.cumsum(exp_soft_energy, dim=2)
          )
  
          beta = exp_soft_energy * torch.cumsum(
              inner_items.flip(dims=[2]), dim=2
          ).flip(dims=[2])
  
      if padding_mask is not None:
          beta = beta.masked_fill(
              padding_mask.unsqueeze(1).to(torch.bool), 0.0
          )
  
      # Mix precision to prevent overflow for fp16
      beta = beta.type(dtype)
  
      beta = beta.clamp(0, 1)
  
      prob_check(beta)
  
      return beta
  
imports: from typing import Optional
  import torch
  from torch import Tensor
  from examples.simultaneous_translation.utils.functions import exclusive_cumprod, prob_check, moving_sum
label_desc: Use image node_id 2 for calling a global function with example usage: expected_soft_attention(alpha, soft_energy, padding_mask, chunk_size, eps) and returns: beta