code: 
  from typing import SupportsIndex
  
  import numpy as np
  from scipy.ndimage import convolve
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			np.stack((horizontal_flow, vertical_flow)		,						2	)
  
  				# Create a grid of all pixel coordinates and subtract the flow to get the
  				# target pixels coordinates
  				lowercase						    =			np.stack(
  				    np.meshgrid(np.arange(0		,						image.shape[1]	)		,						np.arange(0		,						image.shape[0]	)	)		,						2	)
  				lowercase						    =			np.round(grid - flow	).astype(np.intaa	)
  
  				# Find the locations outside of the original image
  				lowercase						    =			(grid < 0) | (grid >= np.array([image.shape[1], image.shape[0]]	))
  				lowercase						    =			0
  
  				lowercase						    =			image[grid[:, :, 1], grid[:, :, 0]]
  
  				# Set pixels at invalid locations to 0
  				lowercase						    =			0
  
  				return warped
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__ = None		,						):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if alpha is None:
  								lowercase						    =			0.1
  
  				# Initialize flow
  				lowercase						    =			np.zeros_like(__magic_name__	)
  				lowercase						    =			np.zeros_like(__magic_name__	)
  
  				# Prepare kernels for the calculation of the derivatives and the average velocity
  				lowercase						    =			np.array([[-1, 1], [-1, 1]]	) * 0.2_5
  				lowercase						    =			np.array([[-1, -1], [1, 1]]	) * 0.2_5
  				lowercase						    =			np.array([[1, 1], [1, 1]]	) * 0.2_5
  				lowercase						    =			np.array(
  				    [[1 / 12, 1 / 6, 1 / 12], [1 / 6, 0, 1 / 6], [1 / 12, 1 / 6, 1 / 12]]	)
  
  				# Iteratively refine the flow
  				for _ in range(__magic_name__	):
  								lowercase						    =			warp(__magic_name__		,						__magic_name__		,						__magic_name__	)
  								lowercase						    =			convolve(__magic_name__		,						__magic_name__	) + convolve(__magic_name__		,						__magic_name__	)
  								lowercase						    =			convolve(__magic_name__		,						__magic_name__	) + convolve(__magic_name__		,						__magic_name__	)
  								lowercase						    =			convolve(__magic_name__		,						__magic_name__	) + convolve(__magic_name__		,						-kernel_t	)
  
  								lowercase						    =			convolve(__magic_name__		,						__magic_name__	)
  								lowercase						    =			convolve(__magic_name__		,						__magic_name__	)
  
  								# This updates the flow as proposed in the paper (Step 12)
  								lowercase						    =			(
  								    derivative_x * avg_horizontal_velocity
  								    + derivative_y * avg_vertical_velocity
  								    + derivative_t
  								)
  								lowercase						    =			update / (alpha**2 + derivative_x**2 + derivative_y**2)
  
  								lowercase						    =			avg_horizontal_velocity - derivative_x * update
  								lowercase						    =			avg_vertical_velocity - derivative_y * update
  
  				return horizontal_flow, vertical_flow
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
style_context: 
  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    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if not inplace:
  								lowercase						    =			ma + ma
  				else:
  								ma += ma
  
  				return ma
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			-1 * len(__magic_name__	)
  				lowercase						    =			list(range(len(tensor.shape[:zero_index]	)	)	)
  				return tensor.permute(first_inds + [zero_index + i for i in inds]	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				return t.reshape(t.shape[:-no_dims] + (-1,)	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__ = 1e-4	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			mask.expand(*value.shape	)
  				return torch.sum(mask * value		,						dim=__magic_name__	) / (eps + torch.sum(__magic_name__		,						dim=__magic_name__	))
  
  def    __snake_case       (  __magic_name__		,						__magic_name__ = 2.3_1_2_5		,						__magic_name__ = 2_1.6_8_7_5		,						__magic_name__ = 64	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			torch.linspace(__magic_name__		,						__magic_name__		,						no_bins - 1		,						device=pts.device	)
  				lowercase						    =			torch.sqrt(torch.sum((pts.unsqueeze(-2	) - pts.unsqueeze(-3	)) ** 2		,						dim=-1	)	)
  				return torch.bucketize(__magic_name__		,						__magic_name__	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			dicts[0]
  				lowercase						    =			{}
  				for k, v in first.items():
  								lowercase						    =			[d[k] for d in dicts]
  								if isinstance(__magic_name__		,						__magic_name__	):
  												lowercase						    =			dict_multimap(__magic_name__		,						__magic_name__	)
  								else:
  												lowercase						    =			fn(__magic_name__	)
  
  				return new_dict
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			v_bins.view(((1,) * len(x.shape	)) + (len(__magic_name__	),)	)
  				lowercase						    =			x[..., None] - reshaped_bins
  				lowercase						    =			torch.argmin(torch.abs(__magic_name__	)		,						dim=-1	)
  				return nn.functional.one_hot(__magic_name__		,						num_classes=len(__magic_name__	)	).float()
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__ = 0		,						__magic_name__ = 0	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			[]
  				for i, s in enumerate(data.shape[:no_batch_dims]	):
  								lowercase						    =			torch.arange(__magic_name__	)
  								lowercase						    =			r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape	) - i - 1)))	)
  								ranges.append(__magic_name__	)
  
  				lowercase						    =			[slice(__magic_name__	) for _ in range(len(data.shape	) - no_batch_dims	)]
  				lowercase						    =			inds
  				ranges.extend(__magic_name__	)
  				# 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(__magic_name__	)]
  
  
  _snake_case			:       List[Any]      =						TypeVar("T")
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			{}
  				for k, v in dic.items():
  								if isinstance(__magic_name__		,						__magic_name__	):
  												lowercase						    =			dict_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  								else:
  												lowercase						    =			tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  
  				return new_dict
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if isinstance(__magic_name__		,						__magic_name__	):
  								return dict_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return [tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	) for x in tree]
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return tuple(tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	) for x in tree	)
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return fn(__magic_name__	)
  				else:
  								print(type(__magic_name__	)	)
  								raise ValueError("Not supported"	)
  
  
  
  
  _snake_case			:       Union[str, Any]      =						partial(tree_map, leaf_type=torch.Tensor)
  