code: 
  '''simple docstring'''
  
  from functools import partial
  from typing import Any, Callable, Dict, List, Type, TypeVar, Union, overload
  
  import torch
  import torch.nn as nn
  import torch.types
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       Optional[int]  ,      _lowerCamelCase						:       List[Any]		)    ->						torch.Tensor:
    # The first operation in a checkpoint can't be in-place, but it's
    # nice to have in-place addition during inference. Thus...
    if not inplace:
      _lowerCAmelCase       :  Any   				=					ma + ma
    else:
      ma += ma
  
    return ma
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Any  ,      _lowerCamelCase						:       List[Any]		)    ->						torch.Tensor:
    _lowerCAmelCase       :  str   				=					-1 * len(lowercase_		)
    _lowerCAmelCase       :  Any   				=					list(range(len(tensor.shape[:zero_index]		)		)		)
    return tensor.permute(first_inds + [zero_index + i for i in inds]		)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Dict  ,      _lowerCamelCase						:       Any		)    ->						torch.Tensor:
    return t.reshape(t.shape[:-no_dims] + (-1,)		)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[int]  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       Tuple  ,      _lowerCamelCase						:       Optional[Any] = 1e-4		)    ->						torch.Tensor:
    _lowerCAmelCase       :  Any   				=					mask.expand(*value.shape		)
    return torch.sum(mask * value  ,      dim=lowercase_		) / (eps + torch.sum(lowercase_  ,      dim=lowercase_		))
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       List[str]  ,      _lowerCamelCase						:       Union[str, Any] = 2.3125  ,      _lowerCamelCase						:       Optional[int] = 21.6875  ,      _lowerCamelCase						:       Tuple = 64		)    ->						torch.Tensor:
    _lowerCAmelCase       :  int   				=					torch.linspace(lowercase_  ,      lowercase_  ,      no_bins - 1  ,      device=pts.device		)
    _lowerCAmelCase       :  Optional[Any]   				=					torch.sqrt(torch.sum((pts.unsqueeze(-2		) - pts.unsqueeze(-3		)) ** 2  ,      dim=-1		)		)
    return torch.bucketize(lowercase_  ,      lowercase_		)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       str  ,      _lowerCamelCase						:       int		)    ->						dict:
    _lowerCAmelCase       :  Dict   				=					dicts[0]
    _lowerCAmelCase       :  str   				=					{}
    for k, v in first.items():
      _lowerCAmelCase       :  List[Any]   				=					[d[k] for d in dicts]
      if isinstance(lowercase_  ,      lowercase_		):
        _lowerCAmelCase       :  Any   				=					dict_multimap(lowercase_  ,      lowercase_		)
      else:
        _lowerCAmelCase       :  Dict   				=					fn(lowercase_		)
  
    return new_dict
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Union[str, Any]  ,      _lowerCamelCase						:       List[str]		)    ->						torch.Tensor:
    _lowerCAmelCase       :  str   				=					v_bins.view(((1,) * len(x.shape		)) + (len(lowercase_		),)		)
    _lowerCAmelCase       :  Union[str, Any]   				=					x[..., None] - reshaped_bins
    _lowerCAmelCase       :  Optional[Any]   				=					torch.argmin(torch.abs(lowercase_		)  ,      dim=-1		)
    return nn.functional.one_hot(lowercase_  ,      num_classes=len(lowercase_		)		).float()
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Tuple  ,      _lowerCamelCase						:       Dict  ,      _lowerCamelCase						:       Dict = 0  ,      _lowerCamelCase						:       Optional[int] = 0		)    ->						torch.Tensor:
    _lowerCAmelCase       :  List[Union[slice, torch.Tensor]]   				=					[]
    for i, s in enumerate(data.shape[:no_batch_dims]		):
      _lowerCAmelCase       :  Optional[Any]   				=					torch.arange(lowercase_		)
      _lowerCAmelCase       :  Union[str, Any]   				=					r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape		) - i - 1)))		)
      ranges.append(lowercase_		)
  
    _lowerCAmelCase       :  List[Union[slice, torch.Tensor]]   				=					[slice(lowercase_		) for _ in range(len(data.shape		) - no_batch_dims		)]
    _lowerCAmelCase       :  Union[str, Any]   				=					inds
    ranges.extend(lowercase_		)
    # Matt note: Editing this to get around the behaviour of using a list as an array index changing
    # in recent Numpy versions
    return data[tuple(lowercase_		)]
  
  
  UpperCamelCase_     			=       TypeVar("""T""")
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Any  ,      _lowerCamelCase						:       str  ,      _lowerCamelCase						:       Optional[int]		)    ->						Dict[Any, Union[dict, list, tuple, Any]]:
    _lowerCAmelCase       :  Dict[Any, Union[dict, list, tuple, Any]]   				=					{}
    for k, v in dic.items():
      if isinstance(lowercase_  ,      lowercase_		):
        _lowerCAmelCase       :  Dict   				=					dict_map(lowercase_  ,      lowercase_  ,      lowercase_		)
      else:
        _lowerCAmelCase       :  List[Any]   				=					tree_map(lowercase_  ,      lowercase_  ,      lowercase_		)
  
    return new_dict
  
  
  @overload
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[int]  ,      _lowerCamelCase						:       Union[str, Any]  ,      _lowerCamelCase						:       Optional[Any]		)    ->						Any:
    ...
  
  
  @overload
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       List[Any]  ,      _lowerCamelCase						:       List[Any]  ,      _lowerCamelCase						:       Dict		)    ->						dict:
    ...
  
  
  @overload
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       List[str]  ,      _lowerCamelCase						:       List[Any]  ,      _lowerCamelCase						:       Union[str, Any]		)    ->						list:
    ...
  
  
  @overload
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[int]  ,      _lowerCamelCase						:       Union[str, Any]  ,      _lowerCamelCase						:       List[str]		)    ->						tuple:
    ...
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       List[Any]  ,      _lowerCamelCase						:       Optional[int]  ,      _lowerCamelCase						:       Any		)    ->						Any:
    if isinstance(lowercase_  ,      lowercase_		):
      return dict_map(lowercase_  ,      lowercase_  ,      lowercase_		)
    elif isinstance(lowercase_  ,      lowercase_		):
      return [tree_map(lowercase_  ,      lowercase_  ,      lowercase_		) for x in tree]
    elif isinstance(lowercase_  ,      lowercase_		):
      return tuple(tree_map(lowercase_  ,      lowercase_  ,      lowercase_		) for x in tree		)
    elif isinstance(lowercase_  ,      lowercase_		):
      return fn(lowercase_		)
    else:
      print(type(lowercase_		)		)
      raise ValueError("""Not supported"""		)
  
  
  
  UpperCamelCase_     			=       partial(tree_map, leaf_type=torch.Tensor)
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int		)    ->						float:
    if common_ratio == 1:
      # Formula for sum if common ratio is 1
      return num_of_terms * first_term
  
    # Formula for finding sum of n terms of a GeometricProgression
    return (first_term / (1 - common_ratio)) * (1 - common_ratio**num_of_terms)
  
  
  