ismarou

Here's a simple implementation of bilinear interpolation on tensors using PyTorch.

I wrote this up since I ended up learning a lot about options for interpolation in both the numpy and PyTorch ecosystems. More generally than just interpolation, too, it's also a nice case study in how PyTorch magically can put very numpy-like code on the GPU (and by the way, do autodiff for you too).

For interpolation in PyTorch, this open issue calls for more interpolation features. There is now a nn.functional.grid_sample() feature but at least at first this didn't look like what I needed (but we'll come back to this later).

In particular I wanted to take an image, W x H x C, and sample it many times at different random locations. Note also that this is different than upsampling which exhaustively samples and also doesn't give us fle

	import numpy as np
	import matplotlib.pyplot as plt
	import pybullet as pb
	import pybullet_data

	def read_parameters(dbg_params):
	'''Reads values from debug parameters

	Parameters
	----------

	#!/usr/bin/env python
	# -- coding:UTF-8 --

	import torch
	import torch.nn as nn
	import torch.nn.init as init


	def weight_init(m):
	'''

	def init_gru(cell, gain=1):
	cell.reset_parameters()

	# orthogonal initialization of recurrent weights
	for _, hh, _, _ in cell.all_weights:
	for i in range(0, hh.size(0), cell.hidden_size):
	I.orthogonal(hh[i:i + cell.hidden_size], gain=gain)


	def init_lstm(cell, gain=1):

	import itertools
	import torch


	def svd(x):
	# https://discuss.pytorch.org/t/multidimensional-svd/4366/2
	batches = x.shape[:-2]
	if batches:
	n, m = x.shape[-2:]
	k = min(n, m)

	#!/usr/bin/env python
	# -- coding: utf-8 --
	"""
	## References
	- [Umeyama's paper](http://edge.cs.drexel.edu/Dmitriy/Matching_and_Metrics/Umeyama/um.pdf)
	- [CarloNicolini's python implementation](https://gist.github.com/CarloNicolini/7118015)
	"""
	from __future__ import print_function
	import numpy as np