SYMBOL INDEX (362 symbols across 60 files)

FILE: AverageMeter.py
  class AverageMeter (line 3) | class AverageMeter(object):
    method __init__ (line 5) | def __init__(self):
    method reset (line 8) | def reset(self):
    method update (line 14) | def update(self, val, n=1):

FILE: MegaDepth/MegaDepth_model.py
  function HourGlass (line 11) | def HourGlass(pretrained=None):

FILE: MegaDepth/SDR_compute.py
  function test_SDR (line 41) | def test_SDR(model):

FILE: MegaDepth/data/aligned_data_loader.py
  class PairedData (line 12) | class PairedData(object):
    method __init__ (line 13) | def __init__(self, data_loader, flip):
    method __iter__ (line 22) | def __iter__(self):
    method __next__ (line 27) | def __next__(self):
  class AlignedDataLoader (line 35) | class AlignedDataLoader(BaseDataLoader):
    method __init__ (line 36) | def __init__(self,_root, _list_dir, _input_height, _input_width, _is_f...
    method name (line 47) | def name(self):
    method load_data (line 50) | def load_data(self):
    method __len__ (line 53) | def __len__(self):
  class AlignedDataLoader_TEST (line 58) | class AlignedDataLoader_TEST(BaseDataLoader):
    method __init__ (line 59) | def __init__(self,_root, _list_dir, _input_height, _input_width):
    method name (line 69) | def name(self):
    method load_data (line 72) | def load_data(self):
    method __len__ (line 76) | def __len__(self):

FILE: MegaDepth/data/base_data_loader.py
  class BaseDataLoader (line 2) | class BaseDataLoader():
    method __init__ (line 3) | def __init__(self):
    method load_data (line 10) | def load_data():

FILE: MegaDepth/data/data_loader.py
  function CreateDataLoader (line 2) | def CreateDataLoader(_root, _list_dir, _input_height, _input_width, is_f...
  function CreateDataLoader_TEST (line 8) | def CreateDataLoader_TEST(_root, _list_dir, _input_height, _input_width):

FILE: MegaDepth/data/image_folder.py
  function make_dataset (line 20) | def make_dataset(list_dir):
  class ImageFolder (line 34) | class ImageFolder(data.Dataset):
    method __init__ (line 36) | def __init__(self, root, list_dir, input_height, input_width, transfor...
    method load_MD (line 55) | def load_MD(self, img_path, depth_path):
    method __getitem__ (line 95) | def __getitem__(self, index):
    method __len__ (line 119) | def __len__(self):
  class ImageFolder_TEST (line 124) | class ImageFolder_TEST(data.Dataset):
    method __init__ (line 126) | def __init__(self, root, list_dir, _input_height, _input_width):
    method load_SfM_ORD (line 139) | def load_SfM_ORD(self, img_path, targets_path):
    method __getitem__ (line 170) | def __getitem__(self, index):
    method __len__ (line 211) | def __len__(self):

FILE: MegaDepth/models/HG_model.py
  class HGModel (line 10) | class HGModel(BaseModel):
    method name (line 11) | def name(self):
    method __init__ (line 14) | def __init__(self, opt,pretrained=None):
    method batch_classify (line 48) | def batch_classify(self, z_A_arr, z_B_arr, ground_truth ):
    method computeSDR (line 86) | def computeSDR(self, prediction_d, targets):
    method evaluate_SDR (line 123) | def evaluate_SDR(self, input_, targets):
    method rmse_Loss (line 131) | def rmse_Loss(self, log_prediction_d, mask, log_gt):
    method evaluate_RMSE (line 144) | def evaluate_RMSE(self, input_images, prediction_d, targets):
    method evaluate_sc_inv (line 159) | def evaluate_sc_inv(self, input_, targets):
    method switch_to_train (line 167) | def switch_to_train(self):
    method switch_to_eval (line 170) | def switch_to_eval(self):

FILE: MegaDepth/models/base_model.py
  class BaseModel (line 4) | class BaseModel():
    method name (line 5) | def name(self):
    method initialize (line 8) | def initialize(self, opt):
    method set_input (line 15) | def set_input(self, input):
    method forward (line 18) | def forward(self):
    method test (line 22) | def test(self):
    method get_image_paths (line 25) | def get_image_paths(self):
    method optimize_parameters (line 28) | def optimize_parameters(self):
    method get_current_visuals (line 31) | def get_current_visuals(self):
    method get_current_errors (line 34) | def get_current_errors(self):
    method save (line 37) | def save(self, label):
    method save_network (line 41) | def save_network(self, network, network_label, epoch_label, gpu_ids):
    method load_network (line 49) | def load_network(self, network, network_label, epoch_label):
    method update_learning_rate (line 57) | def update_learning_rate():

FILE: MegaDepth/models/models.py
  function create_model (line 2) | def create_model(opt,pretrained=None):

FILE: MegaDepth/options/base_options.py
  class BaseOptions (line 5) | class BaseOptions():
    method __init__ (line 6) | def __init__(self):
    method initialize (line 10) | def initialize(self):
    method parse (line 41) | def parse(self):

FILE: MegaDepth/options/test_options.py
  class TestOptions (line 3) | class TestOptions(BaseOptions):
    method initialize (line 4) | def initialize(self):

FILE: MegaDepth/options/train_options.py
  class TrainOptions (line 3) | class TrainOptions(BaseOptions):
    method initialize (line 4) | def initialize(self):

FILE: MegaDepth/pytorch_DIW_scratch.py
  class LambdaBase (line 7) | class LambdaBase(nn.Sequential):
    method __init__ (line 8) | def __init__(self, fn, *args):
    method forward_prepare (line 12) | def forward_prepare(self, input):
  class Lambda (line 18) | class Lambda(LambdaBase):
    method forward (line 19) | def forward(self, input):
  class LambdaMap (line 22) | class LambdaMap(LambdaBase):
    method forward (line 23) | def forward(self, input):
  class LambdaReduce (line 26) | class LambdaReduce(LambdaBase):
    method forward (line 27) | def forward(self, input):

FILE: MegaDepth/rmse_error_main.py
  function test (line 33) | def test(model):

FILE: MegaDepth/util/html.py
  class HTML (line 6) | class HTML:
    method __init__ (line 7) | def __init__(self, web_dir, title, reflesh=0):
    method get_image_dir (line 22) | def get_image_dir(self):
    method add_header (line 25) | def add_header(self, str):
    method add_table (line 29) | def add_table(self, border=1):
    method add_images (line 33) | def add_images(self, ims, txts, links, width=400):
    method save (line 45) | def save(self):

FILE: MegaDepth/util/image_pool.py
  class ImagePool (line 6) | class ImagePool():
    method __init__ (line 7) | def __init__(self, pool_size):
    method query (line 13) | def query(self, images):

FILE: MegaDepth/util/png.py
  function encode (line 4) | def encode(buf, width, height):

FILE: MegaDepth/util/util.py
  function tensor2im (line 12) | def tensor2im(image_tensor, imtype=np.uint8):
  function diagnose_network (line 18) | def diagnose_network(net, name='network'):
  function save_image (line 31) | def save_image(image_numpy, image_path):
  function info (line 35) | def info(object, spacing=10, collapse=1):
  function varname (line 45) | def varname(p):
  function print_numpy (line 51) | def print_numpy(x, val=True, shp=False):
  function mkdirs (line 61) | def mkdirs(paths):
  function mkdir (line 69) | def mkdir(path):

FILE: MegaDepth/util/visualizer.py
  class Visualizer (line 8) | class Visualizer():
    method __init__ (line 9) | def __init__(self, opt):
    method display_current_results (line 27) | def display_current_results(self, visuals, epoch):
    method plot_current_errors (line 57) | def plot_current_errors(self, epoch, counter_ratio, opt, errors):
    method print_current_errors (line 73) | def print_current_errors(self, epoch, i, errors, t):
    method save_images (line 81) | def save_images(self, webpage, visuals, image_path):

FILE: PWCNet/PWCNet.py
  function conv (line 27) | def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dila...
  function predict_flow (line 33) | def predict_flow(in_planes):
  function deconv (line 36) | def deconv(in_planes, out_planes, kernel_size=4, stride=2, padding=1):
  class PWCDCNet (line 41) | class PWCDCNet(nn.Module):
    method __init__ (line 46) | def __init__(self, md=4):
    method warp (line 159) | def warp(self, x, flo):
    method forward (line 202) | def forward(self,x, output_more = False):
  class PWCDCNet_old (line 322) | class PWCDCNet_old(nn.Module):
    method __init__ (line 327) | def __init__(self, md=4):
    method warp (line 417) | def warp(self, x, flo):
    method forward (line 452) | def forward(self,x):
  function pwc_dc_net (line 542) | def pwc_dc_net(path=None):
  function pwc_dc_net_old (line 556) | def pwc_dc_net_old(path=None):

FILE: PWCNet/correlation_package_pytorch1_0/correlation.py
  class CorrelationFunction (line 6) | class CorrelationFunction(Function):
    method __init__ (line 8) | def __init__(self, pad_size=3, kernel_size=3, max_displacement=20, str...
    method forward (line 18) | def forward(self, input1, input2):
    method backward (line 31) | def backward(self, grad_output):
  class Correlation (line 47) | class Correlation(Module):
    method __init__ (line 48) | def __init__(self, pad_size=0, kernel_size=0, max_displacement=0, stri...
    method forward (line 57) | def forward(self, input1, input2):

FILE: PWCNet/correlation_package_pytorch1_0/correlation_cuda.cc
  function correlation_forward_cuda (line 8) | int correlation_forward_cuda(at::Tensor& input1, at::Tensor& input2, at:...
  function correlation_backward_cuda (line 87) | int correlation_backward_cuda(at::Tensor& input1, at::Tensor& input2, at...
  function PYBIND11_MODULE (line 167) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: PWCNet/models/PWCNet.py
  function conv (line 24) | def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dila...
  function predict_flow (line 30) | def predict_flow(in_planes):
  function deconv (line 33) | def deconv(in_planes, out_planes, kernel_size=4, stride=2, padding=1):
  class PWCDCNet (line 38) | class PWCDCNet(nn.Module):
    method __init__ (line 43) | def __init__(self, md=4):
    method warp (line 140) | def warp(self, x, flo):
    method forward (line 179) | def forward(self,x):
  class PWCDCNet_old (line 276) | class PWCDCNet_old(nn.Module):
    method __init__ (line 281) | def __init__(self, md=4):
    method warp (line 371) | def warp(self, x, flo):
    method forward (line 406) | def forward(self,x):
  function pwc_dc_net (line 496) | def pwc_dc_net(path=None):
  function pwc_dc_net_old (line 510) | def pwc_dc_net_old(path=None):

FILE: Resblock/BasicBlock.py
  function conv3x3 (line 7) | def conv3x3(in_planes, out_planes, dilation = 1, stride=1):
  class BasicBlock (line 11) | class BasicBlock(nn.Module):
    method __init__ (line 14) | def __init__(self, inplanes, planes, dilation = 1, stride=1, downsampl...
    method forward (line 33) | def forward(self, x):
  class MultipleBasicBlock (line 50) | class MultipleBasicBlock(nn.Module):
    method __init__ (line 52) | def __init__(self,input_feature,
    method forward (line 80) | def forward(self, x):
  function MultipleBasicBlock_4 (line 88) | def MultipleBasicBlock_4(input_feature,intermediate_feature = 64):

FILE: S2D_models/S2DF.py
  function conv3x3 (line 20) | def conv3x3(in_planes, out_planes, dilation = 1, stride=1):
  class BasicBlock (line 26) | class BasicBlock(nn.Module):
    method __init__ (line 29) | def __init__(self, inplanes, planes, dilation = 1, stride=1, downsampl...
    method forward (line 39) | def forward(self, x):
  class Bottleneck (line 58) | class Bottleneck(nn.Module):
    method __init__ (line 61) | def __init__(self, inplanes, planes, dilation = 1, stride=1, downsampl...
    method forward (line 74) | def forward(self, x):
  class S2DF (line 97) | class S2DF(nn.Module):
    method __init__ (line 99) | def __init__(self, block, num_blocks,dense = True,dilation=True):
    method forward (line 124) | def forward(self, x):
  class S2DFsim (line 147) | class S2DFsim(nn.Module):
    method __init__ (line 149) | def __init__(self, block, num_blocks,dense = True,dilation=True):
    method forward (line 187) | def forward(self, x):
  function S2DF_3dense_nodilation (line 208) | def S2DF_3dense_nodilation():
  function S2DF_3dense (line 211) | def S2DF_3dense():
  function S2DF_3last (line 214) | def S2DF_3last():
  function S2DF_2dense (line 217) | def S2DF_2dense():

FILE: Stack.py
  class Stack (line 2) | class Stack:
    method __init__ (line 3) | def __init__(self):
    method pop (line 5) | def pop(self):
    method push (line 10) | def push(self,val):
    method peak (line 12) | def peak(self):
    method size (line 17) | def size(self):
    method is_empty (line 19) | def is_empty(self):

FILE: balancedsampler.py
  class RandomBalancedSampler (line 4) | class RandomBalancedSampler(Sampler):
    method __init__ (line 12) | def __init__(self, data_source, epoch_size):
    method __next__ (line 17) | def __next__(self):
    method next (line 24) | def next(self):
    method __iter__ (line 27) | def __iter__(self):
    method __len__ (line 30) | def __len__(self):
  class SequentialBalancedSampler (line 33) | class SequentialBalancedSampler(Sampler):
    method __init__ (line 41) | def __init__(self, data_source, epoch_size):
    method __next__ (line 46) | def __next__(self):
    method next (line 50) | def next(self):
    method __iter__ (line 53) | def __iter__(self):
    method __len__ (line 56) | def __len__(self):

FILE: datasets/Vimeo_90K_interp.py
  function make_dataset (line 8) | def make_dataset(root, list_file):
  function Vimeo_90K_interp (line 18) | def Vimeo_90K_interp(root, split=1.0, single=False, task = 'interp' ):

FILE: datasets/listdatasets.py
  function Vimeo_90K_loader (line 8) | def Vimeo_90K_loader(root, im_path, input_frame_size = (3, 256, 448), ou...
  class ListDataset (line 53) | class ListDataset(data.Dataset):
    method __init__ (line 54) | def __init__(self, root, path_list,  loader=Vimeo_90K_loader):
    method __getitem__ (line 60) | def __getitem__(self, index):
    method __len__ (line 66) | def __len__(self):

FILE: loss_function.py
  function charbonier_loss (line 16) | def charbonier_loss(x,epsilon):
  function negPSNR_loss (line 19) | def negPSNR_loss(x,epsilon):
  function tv_loss (line 23) | def tv_loss(x,epsilon):
  function gra_adap_tv_loss (line 32) | def gra_adap_tv_loss(flow, image, epsilon):
  function smooth_loss (line 39) | def smooth_loss(x,epsilon):
  function motion_sym_loss (line 49) | def motion_sym_loss(offset, epsilon, occlusion = None):
  function part_loss (line 61) | def part_loss(diffs, offsets, occlusions, images, epsilon, use_negPSNR=F...

FILE: lr_scheduler.py
  class _LRScheduler (line 5) | class _LRScheduler(object):
    method __init__ (line 6) | def __init__(self, optimizer, last_epoch=-1):
    method get_lr (line 23) | def get_lr(self):
    method step (line 26) | def step(self, epoch=None):
  class LambdaLR (line 34) | class LambdaLR(_LRScheduler):
    method __init__ (line 55) | def __init__(self, optimizer, lr_lambda, last_epoch=-1):
    method get_lr (line 67) | def get_lr(self):
  class StepLR (line 73) | class StepLR(_LRScheduler):
    method __init__ (line 98) | def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1):
    method get_lr (line 103) | def get_lr(self):
  class MultiStepLR (line 109) | class MultiStepLR(_LRScheduler):
    method __init__ (line 133) | def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1):
    method get_lr (line 141) | def get_lr(self):
  class ExponentialLR (line 147) | class ExponentialLR(_LRScheduler):
    method __init__ (line 157) | def __init__(self, optimizer, gamma, last_epoch=-1):
    method get_lr (line 161) | def get_lr(self):
  class ReduceLROnPlateau (line 167) | class ReduceLROnPlateau(object):
    method __init__ (line 212) | def __init__(self, optimizer, mode='min', factor=0.1, patience=10,
    method _reset (line 250) | def _reset(self):
    method step (line 256) | def step(self, metrics, epoch=None):
    method _reduce_lr (line 277) | def _reduce_lr(self, epoch):
    method in_cooldown (line 288) | def in_cooldown(self):
    method _init_is_better (line 291) | def _init_is_better(self, mode, threshold, threshold_mode):

FILE: my_package/DepthFlowProjection/DepthFlowProjectionLayer.py
  class DepthFlowProjectionLayer (line 7) | class DepthFlowProjectionLayer(Function):
    method __init__ (line 8) | def __init__(self,requires_grad):
    method forward (line 13) | def forward(ctx, input1, input2, requires_grad):
    method backward (line 59) | def backward(ctx, gradoutput):

FILE: my_package/DepthFlowProjection/DepthFlowProjectionModule.py
  class DepthFlowProjectionModule (line 7) | class DepthFlowProjectionModule(Module):
    method __init__ (line 8) | def __init__(self, requires_grad = True):
    method forward (line 13) | def forward(self, input1, input2):

FILE: my_package/DepthFlowProjection/depthflowprojection_cuda.cc
  function DepthFlowProjectionLayer_gpu_forward (line 10) | int DepthFlowProjectionLayer_gpu_forward(
  function DepthFlowProjectionLayer_gpu_backward (line 70) | int DepthFlowProjectionLayer_gpu_backward(
  function PYBIND11_MODULE (line 143) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/FilterInterpolation/FilterInterpolationLayer.py
  class FilterInterpolationLayer (line 10) | class FilterInterpolationLayer(Function):
    method __init__ (line 11) | def __init__(self):
    method forward (line 14) | def forward(ctx, input1,input2,input3):
    method backward (line 44) | def backward(ctx, gradoutput):
  class WeightLayer (line 82) | class WeightLayer(Function):
    method __init__ (line 83) | def __init__(self, lambda_e = 10.0/255.0, lambda_v = 1.0, Nw = 3):
    method forward (line 91) | def forward(self, input1,input2,input3):
    method backward (line 129) | def backward(self, gradoutput):
  class PixelValueLayer (line 172) | class PixelValueLayer(Function):
    method __init__ (line 173) | def __init__(self, sigma_d = 3, tao_r = 0.05, Prowindow = 2 ):
    method forward (line 180) | def forward(self, input1, input3, flow_weights):
    method backward (line 218) | def backward(self, gradoutput):
  class PixelWeightLayer (line 267) | class PixelWeightLayer(Function):
    method __init__ (line 268) | def __init__(self,threshhold, sigma_d =3, tao_r =0.05, Prowindow = 2 ):
    method forward (line 275) | def forward(self, input3, flow_weights):
    method backward (line 313) | def backward(self, gradoutput):
  class ReliableWeightLayer (line 441) | class ReliableWeightLayer(Function):
    method __init__ (line 442) | def __init__(self, threshhold, sigma_d =3, tao_r =0.05, Prowindow = 2 ):
    method forward (line 450) | def forward(self, input3):
    method backward (line 490) | def backward(self, gradoutput):

FILE: my_package/FilterInterpolation/FilterInterpolationModule.py
  class FilterInterpolationModule (line 8) | class FilterInterpolationModule(Module):
    method __init__ (line 9) | def __init__(self):
    method forward (line 13) | def forward(self, input1, input2, input3):
  class AdaptiveWeightInterpolationModule (line 25) | class AdaptiveWeightInterpolationModule(Module):
    method __init__ (line 26) | def __init__(self,  training = False, threshhold = 1e-6,
    method forward (line 63) | def forward(self, input1, input2, input3, input4):

FILE: my_package/FilterInterpolation/filterinterpolation_cuda.cc
  function FilterInterpolationLayer_gpu_forward (line 11) | int FilterInterpolationLayer_gpu_forward(
  function FilterInterpolationLayer_gpu_backward (line 83) | int FilterInterpolationLayer_gpu_backward(
  function PYBIND11_MODULE (line 168) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/FlowProjection/FlowProjectionLayer.py
  class FlowProjectionLayer (line 10) | class FlowProjectionLayer(Function):
    method __init__ (line 11) | def __init__(self,requires_grad):
    method forward (line 16) | def forward(ctx, input1, requires_grad):
    method backward (line 55) | def backward(ctx, gradoutput):
  class FlowFillholelayer (line 87) | class FlowFillholelayer(Function):
    method __init__ (line 88) | def __init__(self):
    method forward (line 91) | def forward(self, input1):

FILE: my_package/FlowProjection/FlowProjectionModule.py
  class FlowProjectionModule (line 5) | class FlowProjectionModule(Module):
    method __init__ (line 6) | def __init__(self, requires_grad = True):
    method forward (line 11) | def forward(self, input1):

FILE: my_package/FlowProjection/flowprojection_cuda.cc
  function FlowProjectionLayer_gpu_forward (line 9) | int FlowProjectionLayer_gpu_forward(
  function FlowProjectionLayer_gpu_backward (line 59) | int FlowProjectionLayer_gpu_backward(
  function PYBIND11_MODULE (line 117) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/Interpolation/InterpolationLayer.py
  class InterpolationLayer (line 10) | class InterpolationLayer(Function):
    method __init__ (line 11) | def __init__(self):
    method forward (line 15) | def forward(ctx, input1,input2):
    method backward (line 42) | def backward(ctx, gradoutput):

FILE: my_package/Interpolation/InterpolationModule.py
  class InterpolationModule (line 5) | class InterpolationModule(Module):
    method __init__ (line 6) | def __init__(self):
    method forward (line 10) | def forward(self, input1, input2):

FILE: my_package/Interpolation/interpolation_cuda.cc
  function InterpolationLayer_gpu_forward (line 10) | int InterpolationLayer_gpu_forward(
  function InterpolationLayer_gpu_backward (line 63) | int InterpolationLayer_gpu_backward(
  function PYBIND11_MODULE (line 125) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/InterpolationCh/InterpolationChLayer.py
  class InterpolationChLayer (line 10) | class InterpolationChLayer(Function):
    method __init__ (line 11) | def __init__(self,ch):
    method forward (line 16) | def forward(ctx, input1,input2):
    method backward (line 43) | def backward(ctx, gradoutput):

FILE: my_package/InterpolationCh/InterpolationChModule.py
  class InterpolationChModule (line 5) | class InterpolationChModule(Module):
    method __init__ (line 6) | def __init__(self,ch):
    method forward (line 11) | def forward(self, input1, input2):

FILE: my_package/InterpolationCh/interpolationch_cuda.cc
  function InterpolationChLayer_gpu_forward (line 10) | int InterpolationChLayer_gpu_forward(
  function InterpolationChLayer_gpu_backward (line 63) | int InterpolationChLayer_gpu_backward(
  function PYBIND11_MODULE (line 125) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/MinDepthFlowProjection/minDepthFlowProjectionLayer.py
  class minDepthFlowProjectionLayer (line 7) | class minDepthFlowProjectionLayer(Function):
    method __init__ (line 8) | def __init__(self,requires_grad):
    method forward (line 13) | def forward(ctx, input1, input2, requires_grad):
    method backward (line 59) | def backward(ctx, gradoutput):

FILE: my_package/MinDepthFlowProjection/minDepthFlowProjectionModule.py
  class minDepthFlowProjectionModule (line 7) | class minDepthFlowProjectionModule(Module):
    method __init__ (line 8) | def __init__(self, requires_grad = True):
    method forward (line 13) | def forward(self, input1, input2):

FILE: my_package/MinDepthFlowProjection/mindepthflowprojection_cuda.cc
  function minDepthFlowProjectionLayer_gpu_forward (line 10) | int minDepthFlowProjectionLayer_gpu_forward(
  function minDepthFlowProjectionLayer_gpu_backward (line 70) | int minDepthFlowProjectionLayer_gpu_backward(
  function PYBIND11_MODULE (line 143) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/SeparableConv/SeparableConvLayer.py
  class SeparableConvLayer (line 10) | class SeparableConvLayer(Function):
    method __init__ (line 11) | def __init__(self,filtersize):
    method forward (line 15) | def forward(self, input1,input2,input3):
    method backward (line 57) | def backward(self, gradoutput):

FILE: my_package/SeparableConv/SeparableConvModule.py
  class SeparableConvModule (line 5) | class SeparableConvModule(Module):
    method __init__ (line 6) | def __init__(self,filtersize):
    method forward (line 10) | def forward(self, input1, input2, input3):

FILE: my_package/SeparableConv/separableconv_cuda.cc
  function SeparableConvLayer_gpu_forward (line 10) | int SeparableConvLayer_gpu_forward(
  function SeparableConvLayer_gpu_backward (line 88) | int SeparableConvLayer_gpu_backward(
  function PYBIND11_MODULE (line 178) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/SeparableConvFlow/SeparableConvFlowLayer.py
  class SeparableConvFlowLayer (line 10) | class SeparableConvFlowLayer(Function):
    method __init__ (line 11) | def __init__(self,filtersize):
    method forward (line 16) | def forward(self, input1,input2,input3):
    method backward (line 60) | def backward(self, gradoutput):

FILE: my_package/SeparableConvFlow/SeparableConvFlowModule.py
  class SeparableConvFlowModule (line 5) | class SeparableConvFlowModule(Module):
    method __init__ (line 6) | def __init__(self,filtersize):
    method forward (line 10) | def forward(self, input1, input2, input3):

FILE: my_package/SeparableConvFlow/separableconvflow_cuda.cc
  function SeparableConvFlowLayer_gpu_forward (line 9) | int SeparableConvFlowLayer_gpu_forward(
  function SeparableConvFlowLayer_gpu_backward (line 103) | int SeparableConvFlowLayer_gpu_backward(
  function PYBIND11_MODULE (line 201) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: my_package/test_module.py
  function test_SeparableConvFlowModule (line 20) | def test_SeparableConvFlowModule(input1, input2, input3,filtersize):
  function test_SeparableConvModule (line 124) | def test_SeparableConvModule(input1, input2, input3,filtersize):
  function test_FilterInterpolation (line 218) | def test_FilterInterpolation(input1,input2,input3):
  function test_InterpolationModule (line 313) | def test_InterpolationModule(input1,input2):
  function test_InterpolationChModule (line 397) | def test_InterpolationChModule(input1,input2):
  function test_FlowProjectionModule (line 481) | def test_FlowProjectionModule(input1):
  function test_DepthFlowProjectionModule (line 576) | def test_DepthFlowProjectionModule(input1,input2):
  function test_WeightedFlowProjectionModule (line 671) | def test_WeightedFlowProjectionModule(input1 , input2, input3):
  function test_AdaptiveWeightInterpolationModule (line 768) | def test_AdaptiveWeightInterpolationModule(input1, input2, input3, input4):

FILE: networks/DAIN.py
  class DAIN (line 16) | class DAIN(torch.nn.Module):
    method __init__ (line 17) | def __init__(self,
    method _initialize_weights (line 57) | def _initialize_weights(self):
    method forward (line 81) | def forward(self, input):
    method forward_flownets (line 197) | def forward_flownets(self, model, input, time_offsets = None):
    method forward_singlePath (line 212) | def forward_singlePath(self, modulelist, input, name):
    method get_MonoNet5 (line 243) | def get_MonoNet5(self, channel_in, channel_out, name):
    method FlowProject (line 294) | def FlowProject(inputs, depth = None):
    method FilterInterpolate_ctx (line 304) | def FilterInterpolate_ctx(ctx0,ctx2,offset,filter):
    method FilterInterpolate (line 317) | def FilterInterpolate(ref0, ref2, offset, filter,filter_size2):
    method conv_relu_conv (line 324) | def conv_relu_conv(input_filter, output_filter, kernel_size,
    method conv_relu (line 342) | def conv_relu(input_filter, output_filter, kernel_size,
    method conv_relu_maxpool (line 353) | def conv_relu_maxpool(input_filter, output_filter, kernel_size,
    method conv_relu_unpool (line 369) | def conv_relu_unpool(input_filter, output_filter, kernel_size,

FILE: networks/DAIN_slowmotion.py
  class DAIN_slowmotion (line 16) | class DAIN_slowmotion(torch.nn.Module):
    method __init__ (line 17) | def __init__(self,
    method _initialize_weights (line 56) | def _initialize_weights(self):
    method forward (line 80) | def forward(self, input):
    method forward_flownets (line 204) | def forward_flownets(self, model, input, time_offsets = None):
    method forward_singlePath (line 219) | def forward_singlePath(self, modulelist, input, name):
    method get_MonoNet5 (line 250) | def get_MonoNet5(self, channel_in, channel_out, name):
    method FlowProject (line 301) | def FlowProject(inputs, depth = None):
    method FilterInterpolate_ctx (line 311) | def FilterInterpolate_ctx(ctx0,ctx2,offset,filter, timeoffset):
    method FilterInterpolate (line 324) | def FilterInterpolate(ref0, ref2, offset, filter,filter_size2, time_of...
    method conv_relu_conv (line 339) | def conv_relu_conv(input_filter, output_filter, kernel_size,
    method conv_relu (line 357) | def conv_relu(input_filter, output_filter, kernel_size,
    method conv_relu_maxpool (line 368) | def conv_relu_maxpool(input_filter, output_filter, kernel_size,
    method conv_relu_unpool (line 384) | def conv_relu_unpool(input_filter, output_filter, kernel_size,

FILE: train.py
  function train (line 20) | def train():