Remove convert_legacy_grid option.

**Note**: This is not a breaking change; "legacy" grids were deprecated
pre v1.0.

Author: gpleiss

gpytorch/kernels/grid_kernel.py

@@ -9,7 +9,7 @@
 from torch import Tensor
 
 from .. import settings
-from ..utils.grid import convert_legacy_grid, create_data_from_grid
+from ..utils.grid import create_data_from_grid
 from .kernel import Kernel
 
 
@@ -58,8 +58,6 @@ def __init__(
             raise RuntimeError("The base_kernel for GridKernel must be stationary.")
 
         super().__init__(active_dims=active_dims)
-        if torch.is_tensor(grid):
-            grid = convert_legacy_grid(grid)
         self.interpolation_mode = interpolation_mode
         self.base_kernel = base_kernel
         self.num_dims = len(grid)
@@ -84,9 +82,6 @@ def update_grid(self, grid):
         """
         Supply a new `grid` if it ever changes.
         """
-        if torch.is_tensor(grid):
-            grid = convert_legacy_grid(grid)
-
         if len(grid) != self.num_dims:
             raise RuntimeError("New grid should have the same number of dimensions as before.")
 

gpytorch/utils/grid.py

@@ -99,19 +99,13 @@ def choose_grid_size(train_inputs, ratio=1.0, kronecker_structure=True):
         return ratio * num_data
 
 
-def convert_legacy_grid(grid: torch.Tensor) -> List[torch.Tensor]:
-    return [grid[:, i] for i in range(grid.size(-1))]
-
-
 def create_data_from_grid(grid: List[torch.Tensor]) -> torch.Tensor:
     """
     :param grid: Each Tensor is a 1D set of increments for the grid in that dimension
     :type grid: List[torch.Tensor]
     :return: The set of points on the grid going by column-major order
     :rtype: torch.Tensor
     """
-    if torch.is_tensor(grid):
-        grid = convert_legacy_grid(grid)
     ndims = len(grid)
     assert all(axis.dim() == 1 for axis in grid)
     projections = torch.meshgrid(*grid, indexing="ij")

gpytorch/utils/interpolation.py

@@ -8,8 +8,6 @@
 import torch
 from linear_operator.utils.interpolation import left_interp as _left_interp, left_t_interp as _left_t_interp
 
-from .grid import convert_legacy_grid
-
 
 class Interpolation(object):
     def _cubic_interpolation_kernel(self, scaled_grid_dist):
@@ -41,8 +39,6 @@ def _cubic_interpolation_kernel(self, scaled_grid_dist):
         return res
 
     def interpolate(self, x_grid: List[torch.Tensor], x_target: torch.Tensor, interp_points=range(-2, 2), eps=1e-10):
-        if torch.is_tensor(x_grid):
-            x_grid = convert_legacy_grid(x_grid)
         num_target_points = x_target.size(0)
         num_dim = x_target.size(-1)
         assert num_dim == len(x_grid)

gpytorch/variational/grid_interpolation_variational_strategy.py

@@ -30,6 +30,11 @@ class GridInterpolationVariationalStrategy(_VariationalStrategy):
     :param list grid_bounds: Bounds of each dimension of the grid (should be a list of (float, float) tuples)
     :param ~gpytorch.variational.VariationalDistribution variational_distribution: A
         VariationalDistribution object that represents the form of the variational distribution :math:`q(\mathbf u)`
+
+    :ivar grid: The grid of points that the inducing points are based on.
+        The grid is stored as a matrix, where each column corresponds to the
+        projection of the grid onto one dimension.
+    :type grid: torch.Tensor (M x D)
     """
 
     def __init__(self, model, grid_size, grid_bounds, variational_distribution):
@@ -51,15 +56,14 @@ def __init__(self, model, grid_size, grid_bounds, variational_distribution):
             model, inducing_points, variational_distribution, learn_inducing_locations=False
         )
         object.__setattr__(self, "model", model)
-
         self.register_buffer("grid", grid)
 
     def _compute_grid(self, inputs):
-        n_data, n_dimensions = inputs.size(-2), inputs.size(-1)
-        batch_shape = inputs.shape[:-2]
+        *batch_shape, n_data, n_dimensions = inputs.shape
+        grid = tuple(self.grid[..., i] for i in range(n_dimensions))
 
         inputs = inputs.reshape(-1, n_dimensions)
-        interp_indices, interp_values = Interpolation().interpolate(self.grid, inputs)
+        interp_indices, interp_values = Interpolation().interpolate(grid, inputs)
         interp_indices = interp_indices.view(*batch_shape, n_data, -1)
         interp_values = interp_values.view(*batch_shape, n_data, -1)
 

test/examples/test_grid_gp_regression.py

@@ -61,12 +61,12 @@ def test_grid_gp_mean_abs_error(self, num_dim=1, cuda=False):
         device = torch.device("cuda") if cuda else torch.device("cpu")
         grid_bounds = [(0, 1)] if num_dim == 1 else [(0, 1), (0, 2)]
         grid_size = 25
-        grid = torch.zeros(grid_size, len(grid_bounds), device=device)
+        grid = []
         for i in range(len(grid_bounds)):
             grid_diff = float(grid_bounds[i][1] - grid_bounds[i][0]) / (grid_size - 2)
-            grid[:, i] = torch.linspace(
+            grid.append(torch.linspace(
                 grid_bounds[i][0] - grid_diff, grid_bounds[i][1] + grid_diff, grid_size, device=device
-            )
+            ))
 
         train_x, train_y, test_x, test_y = make_data(grid, cuda=cuda)
         likelihood = gpytorch.likelihoods.GaussianLikelihood()

test/utils/test_interpolation.py

@@ -12,11 +12,11 @@
 class TestCubicInterpolation(unittest.TestCase):
     def test_interpolation(self):
         x = torch.linspace(0.01, 1, 100).unsqueeze(1)
-        grid = torch.linspace(-0.05, 1.05, 50).unsqueeze(1)
+        grid = [torch.linspace(-0.05, 1.05, 50)]
         indices, values = Interpolation().interpolate(grid, x)
         indices = indices.squeeze_(0)
         values = values.squeeze_(0)
-        test_func_grid = grid.squeeze(1).pow(2)
+        test_func_grid = grid[0].pow(2)
         test_func_x = x.pow(2).squeeze(-1)
 
         interp_func_x = left_interp(indices, values, test_func_grid.unsqueeze(1)).squeeze()
@@ -25,7 +25,7 @@ def test_interpolation(self):
 
     def test_multidim_interpolation(self):
         x = torch.tensor([[0.25, 0.45, 0.65, 0.85], [0.35, 0.375, 0.4, 0.425], [0.45, 0.5, 0.55, 0.6]]).t().contiguous()
-        grid = torch.linspace(0.0, 1.0, 11).unsqueeze(1).repeat(1, 3)
+        grid = [torch.linspace(0.0, 1.0, 11) for _ in range(3)]
 
         indices, values = Interpolation().interpolate(grid, x)