Repository: cornellius-gp/gpytorch
Pull request #458 (2019-01-09 13:03:10)

log_det -> logdet (with appropriate deprecation warnings
- log_det -> logdet
- inv_quad_log_det -> inv_quad_logdet
- Add some new deprecation helpers


Patch:
diff --git a/docs/source/functions.rst b/docs/source/functions.rst
index 037851d1..9e3c9f9b 100644
--- a/docs/source/functions.rst
+++ b/docs/source/functions.rst
@@ -22,11 +22,11 @@ Functions
 
 .. autofunction:: inv_quad
 
-.. autofunction:: inv_quad_log_det
+.. autofunction:: inv_quad_logdet
 
 .. autofunction:: matmul
 
-.. autofunction:: log_det
+.. autofunction:: logdet
 
 .. autofunction:: log_normal_cdf
 
diff --git a/gpytorch/__init__.py b/gpytorch/__init__.py
index d7cc4b23..2020f1c2 100644
--- a/gpytorch/__init__.py
+++ b/gpytorch/__init__.py
@@ -21,13 +21,16 @@ from .functions import (
     dsmm,
     inv_matmul,
     inv_quad,
-    inv_quad_log_det,
-    log_det,
+    inv_quad_logdet,
+    logdet,
     log_normal_cdf,
     matmul,
     normal_cdf,
     root_decomposition,
     root_inv_decomposition,
+    # Deprecated
+    inv_quad_log_det,
+    log_det,
 )
 from .mlls import ExactMarginalLogLikelihood, VariationalMarginalLogLikelihood
 from .lazy import lazify, delazify
@@ -60,9 +63,9 @@ __all__ = [
     "dsmm",
     "inv_matmul",
     "inv_quad",
-    "inv_quad_log_det",
+    "inv_quad_logdet",
     "lazify",
-    "log_det",
+    "logdet",
     "log_normal_cdf",
     "matmul",
     "normal_cdf",
@@ -70,6 +73,9 @@ __all__ = [
     "root_inv_decomposition",
     # Context managers
     "beta_features",
-    "fast_pred_var",
     "settings",
+    # Deprecated
+    "fast_pred_var",
+    "inv_quad_log_det",
+    "log_det",
 ]
diff --git a/gpytorch/distributions/multivariate_normal.py b/gpytorch/distributions/multivariate_normal.py
index 8d0bdf62..9a16c196 100644
--- a/gpytorch/distributions/multivariate_normal.py
+++ b/gpytorch/distributions/multivariate_normal.py
@@ -123,9 +123,9 @@ class _MultivariateNormalBase(TMultivariateNormal, Distribution):
             )
 
         # Get log determininat and first part of quadratic form
-        inv_quad, log_det = covar.inv_quad_log_det(inv_quad_rhs=diff.unsqueeze(-1), log_det=True)
+        inv_quad, logdet = covar.inv_quad_logdet(inv_quad_rhs=diff.unsqueeze(-1), logdet=True)
 
-        res = -0.5 * sum([inv_quad, log_det, diff.size(-1) * math.log(2 * math.pi)])
+        res = -0.5 * sum([inv_quad, logdet, diff.size(-1) * math.log(2 * math.pi)])
         return res
 
     def rsample(self, sample_shape=torch.Size(), base_samples=None):
@@ -240,9 +240,9 @@ def kl_mvn_mvn(p_dist, q_dist):
         # but we may want to be smarter about this in the future
         root_p_covar = root_p_covar.evaluate()
     inv_quad_rhs = torch.cat([mean_diffs.unsqueeze(-1), root_p_covar], -1)
-    log_det_p_covar = p_covar.log_det()
-    trace_plus_inv_quad_form, log_det_q_covar = q_covar.inv_quad_log_det(inv_quad_rhs=inv_quad_rhs, log_det=True)
+    logdet_p_covar = p_covar.logdet()
+    trace_plus_inv_quad_form, logdet_q_covar = q_covar.inv_quad_logdet(inv_quad_rhs=inv_quad_rhs, logdet=True)
 
     # Compute the KL Divergence.
-    res = 0.5 * sum([log_det_q_covar, log_det_p_covar.mul(-1), trace_plus_inv_quad_form, -float(mean_diffs.size(-1))])
+    res = 0.5 * sum([logdet_q_covar, logdet_p_covar.mul(-1), trace_plus_inv_quad_form, -float(mean_diffs.size(-1))])
     return res
diff --git a/gpytorch/functions/__init__.py b/gpytorch/functions/__init__.py
index 9d8c0ae8..01023140 100644
--- a/gpytorch/functions/__init__.py
+++ b/gpytorch/functions/__init__.py
@@ -5,6 +5,7 @@ import torch
 from ._dsmm import DSMM
 from ._normal_cdf import NormalCDF
 from ._log_normal_cdf import LogNormalCDF
+from ..utils.deprecation import _deprecated_function_for
 
 
 def add_diag(input, diag):
@@ -131,11 +132,11 @@ def inv_quad(mat, tensor):
     Returns:
         - tensor - tr( tensor^T (mat)^{-1} tensor )
     """
-    res, _ = inv_quad_log_det(mat, inv_quad_rhs=tensor, log_det=False)
+    res, _ = inv_quad_logdet(mat, inv_quad_rhs=tensor, logdet=False)
     return res
 
 
-def inv_quad_log_det(mat, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+def inv_quad_logdet(mat, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
     """
     Computes an inverse quadratic form (w.r.t mat) with several right hand sides.
     I.e. computes tr( tensor^T mat^{-1} tensor )
@@ -149,17 +150,17 @@ def inv_quad_log_det(mat, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True
         - scalar - log determinant
     """
     from ..lazy import lazify
-    return lazify(mat).inv_quad_log_det(inv_quad_rhs, log_det, reduce_inv_quad=reduce_inv_quad)
+    return lazify(mat).inv_quad_logdet(inv_quad_rhs, logdet, reduce_inv_quad=reduce_inv_quad)
 
 
-def log_det(mat):
+def logdet(mat):
     """
     Computes an (approximate) log determinant of the matrix
 
     Returns:
         - scalar - log determinant
     """
-    _, res = inv_quad_log_det(mat, inv_quad_rhs=None, log_det=True)
+    _, res = inv_quad_logdet(mat, inv_quad_rhs=None, logdet=True)
     return res
 
 
@@ -190,16 +191,23 @@ def root_inv_decomposition(mat, initial_vectors=None, test_vectors=None):
     return lazify(mat).root_inv_decomposition(initial_vectors, test_vectors)
 
 
+log_det = _deprecated_function_for("log_det", logdet)
+inv_quad_log_det = _deprecated_function_for("inv_quad_log_det", inv_quad_logdet)
+
+
 __all__ = [
     "add_diag",
     "dsmm",
     "inv_matmul",
     "inv_quad",
-    "inv_quad_log_det",
-    "log_det",
+    "inv_quad_logdet",
+    "logdet",
     "log_normal_cdf",
     "matmul",
     "normal_cdf",
     "root_decomposition",
     "root_inv_decomposition",
+    # Deprecated
+    "log_det"
+    "inv_quad_log_det"
 ]
diff --git a/gpytorch/functions/_inv_matmul.py b/gpytorch/functions/_inv_matmul.py
index 76fd2d58..527729c5 100644
--- a/gpytorch/functions/_inv_matmul.py
+++ b/gpytorch/functions/_inv_matmul.py
@@ -27,7 +27,7 @@ class InvMatmul(Function):
             right_tensor = right_tensor.unsqueeze(-1)
             self.is_vector = True
 
-        # Perform solves (for inv_quad) and tridiagonalization (for estimating log_det)
+        # Perform solves (for inv_quad) and tridiagonalization (for estimating logdet)
         if self.has_left:
             rhs = torch.cat([left_tensor.transpose(-1, -2), right_tensor], -1)
             solves = lazy_tsr._solve(rhs, self.preconditioner)
diff --git a/gpytorch/functions/_inv_quad_log_det.py b/gpytorch/functions/_inv_quad_log_det.py
index 47742948..14e5cf54 100644
--- a/gpytorch/functions/_inv_quad_log_det.py
+++ b/gpytorch/functions/_inv_quad_log_det.py
@@ -23,14 +23,14 @@ class InvQuadLogDet(Function):
         matrix_shape,
         batch_shape=torch.Size(),
         inv_quad=False,
-        log_det=False,
+        logdet=False,
         preconditioner=None,
-        log_det_correction=None,
+        logdet_correction=None,
         probe_vectors=None,
         probe_vector_norms=None,
     ):
-        if not (inv_quad or log_det):
-            raise RuntimeError("Either inv_quad or log_det must be true (or both)")
+        if not (inv_quad or logdet):
+            raise RuntimeError("Either inv_quad or logdet must be true (or both)")
 
         self.representation_tree = representation_tree
         self.dtype = dtype
@@ -38,11 +38,11 @@ class InvQuadLogDet(Function):
         self.matrix_shape = matrix_shape
         self.batch_shape = batch_shape
         self.inv_quad = inv_quad
-        self.log_det = log_det
+        self.logdet = logdet
         self.preconditioner = preconditioner
-        self.log_det_correction = log_det_correction
+        self.logdet_correction = logdet_correction
 
-        if (probe_vectors is None or probe_vector_norms is None) and log_det:
+        if (probe_vectors is None or probe_vector_norms is None) and logdet:
             num_random_probes = settings.num_trace_samples.value()
             probe_vectors = torch.empty(matrix_shape[-1], num_random_probes, dtype=dtype, device=device)
             probe_vectors.bernoulli_().mul_(2).add_(-1)
@@ -63,7 +63,7 @@ class InvQuadLogDet(Function):
 
         Returns:
         - (Scalar) The inverse quadratic form (or None, if self.inv_quad is False)
-        - (Scalar) The log determinant (or None, self.if log_det is False)
+        - (Scalar) The log determinant (or None, self.if logdet is False)
         """
         matrix_args = None
         inv_quad_rhs = None
@@ -82,8 +82,8 @@ class InvQuadLogDet(Function):
         num_random_probes = 0
         num_inv_quad_solves = 0
 
-        # RHS for log_det
-        if self.log_det:
+        # RHS for logdet
+        if self.logdet:
             rhs_list.append(self.probe_vectors)
             num_random_probes = self.probe_vectors.size(-1)
 
@@ -96,33 +96,33 @@ class InvQuadLogDet(Function):
             rhs_list.append(inv_quad_rhs)
             num_inv_quad_solves = inv_quad_rhs.size(-1)
 
-        # Perform solves (for inv_quad) and tridiagonalization (for estimating log_det)
+        # Perform solves (for inv_quad) and tridiagonalization (for estimating logdet)
         rhs = torch.cat(rhs_list, -1)
         t_mat = None
-        if self.log_det and settings.skip_logdet_forward.off():
+        if self.logdet and settings.skip_logdet_forward.off():
             solves, t_mat = lazy_tsr._solve(rhs, self.preconditioner, num_tridiag=num_random_probes)
 
         else:
             solves = lazy_tsr._solve(rhs, self.preconditioner, num_tridiag=0)
 
         # Final values to return
-        log_det_term = torch.zeros(lazy_tsr.batch_shape, dtype=self.dtype, device=self.device)
+        logdet_term = torch.zeros(lazy_tsr.batch_shape, dtype=self.dtype, device=self.device)
         inv_quad_term = torch.zeros(lazy_tsr.batch_shape, dtype=self.dtype, device=self.device)
 
-        # Compute log_det from tridiagonalization
-        if self.log_det and settings.skip_logdet_forward.off():
+        # Compute logdet from tridiagonalization
+        if self.logdet and settings.skip_logdet_forward.off():
             if torch.any(torch.isnan(t_mat)).item():
-                log_det_term = torch.tensor(float("nan"), dtype=self.dtype, device=self.device)
+                logdet_term = torch.tensor(float("nan"), dtype=self.dtype, device=self.device)
             else:
                 if self.batch_shape is None:
                     t_mat = t_mat.unsqueeze(1)
                 eigenvalues, eigenvectors = lanczos_tridiag_to_diag(t_mat)
                 slq = StochasticLQ()
-                log_det_term, = slq.evaluate(self.matrix_shape, eigenvalues, eigenvectors, [lambda x: x.log()])
+                logdet_term, = slq.evaluate(self.matrix_shape, eigenvalues, eigenvectors, [lambda x: x.log()])
 
                 # Add correction
-                if self.log_det_correction is not None:
-                    log_det_term = log_det_term + self.log_det_correction
+                if self.logdet_correction is not None:
+                    logdet_term = logdet_term + self.logdet_correction
 
         # Extract inv_quad solves from all the solves
         if self.inv_quad:
@@ -138,15 +138,15 @@ class InvQuadLogDet(Function):
         if settings.memory_efficient.off():
             self._lazy_tsr = lazy_tsr
 
-        return inv_quad_term, log_det_term
+        return inv_quad_term, logdet_term
 
-    def backward(self, inv_quad_grad_output, log_det_grad_output):
+    def backward(self, inv_quad_grad_output, logdet_grad_output):
         matrix_arg_grads = None
         inv_quad_rhs_grad = None
 
         # Which backward passes should we compute?
         compute_inv_quad_grad = inv_quad_grad_output.abs().sum() and self.inv_quad
-        compute_log_det_grad = log_det_grad_output.abs().sum() and self.log_det
+        compute_logdet_grad = logdet_grad_output.abs().sum() and self.logdet
 
         # Get input arguments, and get gradients in the proper form
         matrix_args = self.saved_tensors[:-1]
@@ -160,18 +160,18 @@ class InvQuadLogDet(Function):
         # Fix grad_output sizes
         if self.inv_quad:
             inv_quad_grad_output = inv_quad_grad_output.unsqueeze(-2)
-        if compute_log_det_grad:
-            log_det_grad_output = log_det_grad_output.unsqueeze(-1)
-            log_det_grad_output.unsqueeze_(-1)
+        if compute_logdet_grad:
+            logdet_grad_output = logdet_grad_output.unsqueeze(-1)
+            logdet_grad_output.unsqueeze_(-1)
 
         # Divide up the solves
         probe_vector_solves = None
         inv_quad_solves = None
         neg_inv_quad_solves_times_grad_out = None
-        if compute_log_det_grad:
+        if compute_logdet_grad:
             coef = 1.0 / self.probe_vectors.size(-1)
             probe_vector_solves = solves.narrow(-1, 0, self.num_random_probes).mul(coef)
-            probe_vector_solves.mul_(self.probe_vector_norms).mul_(log_det_grad_output)
+            probe_vector_solves.mul_(self.probe_vector_norms).mul_(logdet_grad_output)
             probe_vectors = self.probe_vectors.mul(self.probe_vector_norms)
         if self.inv_quad:
             inv_quad_solves = solves.narrow(-1, self.num_random_probes, self.num_inv_quad_solves)
@@ -183,7 +183,7 @@ class InvQuadLogDet(Function):
             left_factors_list = []
             right_factors_list = []
 
-            if compute_log_det_grad:
+            if compute_logdet_grad:
                 left_factors_list.append(probe_vector_solves)
                 right_factors_list.append(probe_vectors)
 
diff --git a/gpytorch/lazy/added_diag_lazy_tensor.py b/gpytorch/lazy/added_diag_lazy_tensor.py
index 2225fc82..bc1b3d93 100644
--- a/gpytorch/lazy/added_diag_lazy_tensor.py
+++ b/gpytorch/lazy/added_diag_lazy_tensor.py
@@ -66,8 +66,8 @@ class AddedDiagLazyTensor(SumLazyTensor):
                 tensor, self._piv_chol_self, self._woodbury_cache, self._diag_tensor.diag()
             )
 
-        # log_det correction
-        if not hasattr(self, "_precond_log_det_cache"):
+        # logdet correction
+        if not hasattr(self, "_precond_logdet_cache"):
             lr_flipped = self._piv_chol_self.matmul(
                 self._piv_chol_self.transpose(-2, -1).div(self._diag_tensor.diag().unsqueeze(-1))
             )
@@ -78,6 +78,6 @@ class AddedDiagLazyTensor(SumLazyTensor):
             else:
                 ld_one = lr_flipped.cholesky(upper=True).diag().log().sum() * 2
                 ld_two = self._diag_tensor.diag().log().sum().item()
-            self._precond_log_det_cache = ld_one + ld_two
+            self._precond_logdet_cache = ld_one + ld_two
 
-        return precondition_closure, self._precond_log_det_cache
+        return precondition_closure, self._precond_logdet_cache
diff --git a/gpytorch/lazy/batch_repeat_lazy_tensor.py b/gpytorch/lazy/batch_repeat_lazy_tensor.py
index cd24780a..b3f28a55 100644
--- a/gpytorch/lazy/batch_repeat_lazy_tensor.py
+++ b/gpytorch/lazy/batch_repeat_lazy_tensor.py
@@ -122,10 +122,10 @@ class BatchRepeatLazyTensor(LazyTensor):
     def add_jitter(self, jitter_val=1e-3):
         return self.__class__(self.base_lazy_tensor.add_jitter(jitter_val=jitter_val), batch_repeat=self.batch_repeat)
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
         if not self.is_square:
             raise RuntimeError(
-                "inv_quad_log_det only operates on (batches of) square (positive semi-definite) LazyTensors. "
+                "inv_quad_logdet only operates on (batches of) square (positive semi-definite) LazyTensors. "
                 "Got a {} of size {}.".format(self.__class__.__name__, self.size())
             )
 
@@ -145,8 +145,8 @@ class BatchRepeatLazyTensor(LazyTensor):
         if inv_quad_rhs is not None:
             inv_quad_rhs = self._move_repeat_batches_to_columns(inv_quad_rhs)
 
-        inv_quad_term, log_det_term = self.base_lazy_tensor.inv_quad_log_det(
-            inv_quad_rhs, log_det, reduce_inv_quad=False
+        inv_quad_term, logdet_term = self.base_lazy_tensor.inv_quad_logdet(
+            inv_quad_rhs, logdet, reduce_inv_quad=False
         )
 
         if inv_quad_term is not None and inv_quad_term.numel():
@@ -155,10 +155,10 @@ class BatchRepeatLazyTensor(LazyTensor):
             if reduce_inv_quad:
                 inv_quad_term = inv_quad_term.sum(-1)
 
-        if log_det_term is not None and log_det_term.numel():
-            log_det_term = log_det_term.repeat(*self.batch_repeat)
+        if logdet_term is not None and logdet_term.numel():
+            logdet_term = logdet_term.repeat(*self.batch_repeat)
 
-        return inv_quad_term, log_det_term
+        return inv_quad_term, logdet_term
 
     def repeat(self, *sizes):
         if len(sizes) < 3 or tuple(sizes[-2:]) != (1, 1):
diff --git a/gpytorch/lazy/block_diag_lazy_tensor.py b/gpytorch/lazy/block_diag_lazy_tensor.py
index e10985b9..072aa105 100644
--- a/gpytorch/lazy/block_diag_lazy_tensor.py
+++ b/gpytorch/lazy/block_diag_lazy_tensor.py
@@ -103,20 +103,20 @@ class BlockDiagLazyTensor(BlockLazyTensor):
             res = res.view(-1)
         return res
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
         if inv_quad_rhs is not None:
             inv_quad_rhs = inv_quad_rhs.view(-1, self.base_lazy_tensor.size(-1), inv_quad_rhs.size(-1))
-        inv_quad_res, log_det_res = self.base_lazy_tensor.inv_quad_log_det(
-            inv_quad_rhs, log_det, reduce_inv_quad=reduce_inv_quad
+        inv_quad_res, logdet_res = self.base_lazy_tensor.inv_quad_logdet(
+            inv_quad_rhs, logdet, reduce_inv_quad=reduce_inv_quad
         )
         if inv_quad_res is not None and inv_quad_res.numel():
             if reduce_inv_quad:
                 inv_quad_res = inv_quad_res.view(*self.batch_shape, -1).sum(-1)
             else:
                 inv_quad_res = inv_quad_res.view(*self.batch_shape, -1, inv_quad_res.size(-1)).sum(-2)
-        if log_det_res is not None and log_det_res.numel():
-            log_det_res = log_det_res.view(*self.batch_shape, -1).sum(-1)
-        return inv_quad_res, log_det_res
+        if logdet_res is not None and logdet_res.numel():
+            logdet_res = logdet_res.view(*self.batch_shape, -1).sum(-1)
+        return inv_quad_res, logdet_res
 
     def zero_mean_mvn_samples(self, num_samples):
         res = self.base_lazy_tensor.zero_mean_mvn_samples(num_samples)
diff --git a/gpytorch/lazy/cat_lazy_tensor.py b/gpytorch/lazy/cat_lazy_tensor.py
index 968f361a..0114948f 100644
--- a/gpytorch/lazy/cat_lazy_tensor.py
+++ b/gpytorch/lazy/cat_lazy_tensor.py
@@ -326,8 +326,8 @@ class CatLazyTensor(LazyTensor):
     def inv_quad(self, tensor):
         return super().inv_quad(tensor).to(self.device)
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
-        res = super().inv_quad_log_det(inv_quad_rhs, log_det, reduce_inv_quad)
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
+        res = super().inv_quad_logdet(inv_quad_rhs, logdet, reduce_inv_quad)
         return tuple(r.to(self.device) for r in res)
 
     def matmul(self, other):
diff --git a/gpytorch/lazy/chol_lazy_tensor.py b/gpytorch/lazy/chol_lazy_tensor.py
index d57e831f..b0387e8f 100644
--- a/gpytorch/lazy/chol_lazy_tensor.py
+++ b/gpytorch/lazy/chol_lazy_tensor.py
@@ -43,16 +43,16 @@ class CholLazyTensor(RootLazyTensor):
                 self._chol_diag_memo = self._chol.diag()
         return self._chol_diag_memo
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
         inv_quad_term = None
-        log_det_term = None
+        logdet_term = None
 
         if inv_quad_rhs is not None:
-            inv_quad_term, _ = super(CholLazyTensor, self).inv_quad_log_det(
-                inv_quad_rhs, log_det=False, reduce_inv_quad=reduce_inv_quad
+            inv_quad_term, _ = super(CholLazyTensor, self).inv_quad_logdet(
+                inv_quad_rhs, logdet=False, reduce_inv_quad=reduce_inv_quad
             )
 
-        if log_det:
-            log_det_term = self._chol_diag.log().sum(-1).mul(2)
+        if logdet:
+            logdet_term = self._chol_diag.log().sum(-1).mul(2)
 
-        return inv_quad_term, log_det_term
+        return inv_quad_term, logdet_term
diff --git a/gpytorch/lazy/diag_lazy_tensor.py b/gpytorch/lazy/diag_lazy_tensor.py
index e3cb92dc..2117f910 100644
--- a/gpytorch/lazy/diag_lazy_tensor.py
+++ b/gpytorch/lazy/diag_lazy_tensor.py
@@ -126,7 +126,7 @@ class DiagLazyTensor(LazyTensor):
             res = left_tensor @ res
         return res
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
 
         # TODO: Use proper batching for inv_quad_rhs (prepand to shape rathern than append)
         if inv_quad_rhs is None:
@@ -144,12 +144,12 @@ class DiagLazyTensor(LazyTensor):
             if reduce_inv_quad:
                 inv_quad_term = inv_quad_term.sum(-1)
 
-        if not log_det:
-            log_det_term = torch.empty(0, dtype=self.dtype, device=self.device)
+        if not logdet:
+            logdet_term = torch.empty(0, dtype=self.dtype, device=self.device)
         else:
-            log_det_term = self._diag.log().sum(-1)
+            logdet_term = self._diag.log().sum(-1)
 
-        return inv_quad_term, log_det_term
+        return inv_quad_term, logdet_term
 
     def log(self):
         return DiagLazyTensor(self._diag.log())
diff --git a/gpytorch/lazy/lazy_tensor.py b/gpytorch/lazy/lazy_tensor.py
index fa964306..08228ba1 100644
--- a/gpytorch/lazy/lazy_tensor.py
+++ b/gpytorch/lazy/lazy_tensor.py
@@ -12,6 +12,7 @@ from ..functions._matmul import Matmul
 from ..functions._root_decomposition import RootDecomposition
 from ..utils import linear_cg
 from ..utils.broadcasting import _matmul_broadcast_shape
+from ..utils.deprecation import _deprecate_renamed_methods
 from ..utils.memoize import cached
 from ..utils.qr import batch_qr
 from ..utils.svd import batch_svd
@@ -366,7 +367,7 @@ class LazyTensor(object):
 
         ..note::
             This method is intended to be used only internally by various Functions that support backpropagation.
-            For example, this method is used internally by :func:`~gpytorch.lazy.LazyTensor.inv_quad_log_det`. It is
+            For example, this method is used internally by :func:`~gpytorch.lazy.LazyTensor.inv_quad_logdet`. It is
             not likely that users will need to call this method directly.
 
         Returns:
@@ -691,7 +692,7 @@ class LazyTensor(object):
         I.e. computes tr( tensor^T self^{-1} tensor )
 
         NOTE: Don't overwrite this function!
-        Instead, overwrite inv_quad_log_det
+        Instead, overwrite inv_quad_logdet
 
         Args:
             - tensor (tensor nxk) - Vector (or matrix) for inverse quad
@@ -699,10 +700,10 @@ class LazyTensor(object):
         Returns:
             - tensor - tr( tensor^T (self)^{-1} tensor )
         """
-        res, _ = self.inv_quad_log_det(inv_quad_rhs=tensor, log_det=False, reduce_inv_quad=reduce_inv_quad)
+        res, _ = self.inv_quad_logdet(inv_quad_rhs=tensor, logdet=False, reduce_inv_quad=reduce_inv_quad)
         return res
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
         """
         Computes an inverse quadratic form (w.r.t self) with several right hand sides.
         I.e. computes tr( tensor^T self^{-1} tensor )
@@ -717,7 +718,7 @@ class LazyTensor(object):
         """
         if not self.is_square:
             raise RuntimeError(
-                "inv_quad_log_det only operates on (batches of) square (positive semi-definite) LazyTensors. "
+                "inv_quad_logdet only operates on (batches of) square (positive semi-definite) LazyTensors. "
                 "Got a {} of size {}.".format(self.__class__.__name__, self.size())
             )
 
@@ -746,39 +747,39 @@ class LazyTensor(object):
             args = [inv_quad_rhs] + list(args)
 
         probe_vectors, probe_vector_norms = self._probe_vectors_and_norms()
-        inv_quad_term, log_det_term = InvQuadLogDet(
+        inv_quad_term, logdet_term = InvQuadLogDet(
             representation_tree=self.representation_tree(),
             matrix_shape=self.matrix_shape,
             batch_shape=self.batch_shape,
             dtype=self.dtype,
             device=self.device,
             inv_quad=(inv_quad_rhs is not None),
-            log_det=log_det,
+            logdet=logdet,
             preconditioner=self._preconditioner()[0],
-            log_det_correction=self._preconditioner()[1],
+            logdet_correction=self._preconditioner()[1],
             probe_vectors=probe_vectors,
             probe_vector_norms=probe_vector_norms,
         )(*args)
 
         if inv_quad_term.numel() and reduce_inv_quad:
             inv_quad_term = inv_quad_term.sum(-1)
-        return inv_quad_term, log_det_term
+        return inv_quad_term, logdet_term
 
     @property
     def is_square(self):
         return self.matrix_shape[0] == self.matrix_shape[1]
 
-    def log_det(self):
+    def logdet(self):
         """
         Computes an (approximate) log determinant of the matrix
 
         NOTE: Don't overwrite this function!
-        Instead, overwrite inv_quad_log_det
+        Instead, overwrite inv_quad_logdet
 
         Returns:
             - scalar: log determinant
         """
-        _, res = self.inv_quad_log_det(inv_quad_rhs=None, log_det=True)
+        _, res = self.inv_quad_logdet(inv_quad_rhs=None, logdet=True)
         return res
 
     def matmul(self, other):
@@ -1403,6 +1404,12 @@ def delazify(obj):
         raise TypeError("object of class {} cannot be made into a Tensor".format(obj.__class__.__name__))
 
 
+_deprecate_renamed_methods(
+    LazyTensor,
+    inv_quad_log_det="inv_quad_logdet",
+    log_det="logdet",
+)
+
 __all__ = [
     "LazyTensor",
     "delazify",
diff --git a/gpytorch/lazy/zero_lazy_tensor.py b/gpytorch/lazy/zero_lazy_tensor.py
index 984eba06..1216ab9b 100644
--- a/gpytorch/lazy/zero_lazy_tensor.py
+++ b/gpytorch/lazy/zero_lazy_tensor.py
@@ -125,10 +125,10 @@ class ZeroLazyTensor(LazyTensor):
     def inv_quad(self, tensor):
         raise RuntimeError("ZeroLazyTensors are not invertible!")
 
-    def inv_quad_log_det(self, inv_quad_rhs=None, log_det=False, reduce_inv_quad=True):
+    def inv_quad_logdet(self, inv_quad_rhs=None, logdet=False, reduce_inv_quad=True):
         raise RuntimeError("ZeroLazyTensors are not invertible!")
 
-    def log_det(self):
+    def logdet(self):
         return torch.log(torch.tensor(0.0))
 
     def matmul(self, tensor):
diff --git a/gpytorch/utils/deprecation.py b/gpytorch/utils/deprecation.py
index 1440654d..faf3c3dd 100644
--- a/gpytorch/utils/deprecation.py
+++ b/gpytorch/utils/deprecation.py
@@ -1,12 +1,25 @@
 #!/usr/bin/env python3
 
 import warnings
+import functools
 
 
 class DeprecationError(Exception):
     pass
 
 
+def _deprecated_function_for(old_function_name, function):
+    @functools.wraps(function)
+    def _deprecated_function(*args, **kwargs):
+        warnings.warn(
+            "The `{}` function is deprecated. Use `{}` instead".format(old_function_name, function.__name__),
+            DeprecationWarning
+        )
+        return function(*args, **kwargs)
+
+    return _deprecated_function
+
+
 def _deprecate_kwarg(kwargs, old_kw, new_kw, new_kw_value):
     old_kwarg = kwargs.get(old_kw)
     if old_kwarg is not None:
@@ -15,3 +28,22 @@ def _deprecate_kwarg(kwargs, old_kw, new_kw, new_kw_value):
             raise ValueError("Cannot set both `{}` and `{}`".format(old_kw, new_kw))
         return old_kwarg
     return new_kw_value
+
+
+def _deprecated_renamed_method(cls, old_method_name, new_method_name):
+    def _deprecated_method(self, *args, **kwargs):
+        warnings.warn(
+            "The `{}` method is deprecated. Use `{}` instead".format(old_method_name, new_method_name),
+            DeprecationWarning
+        )
+        return getattr(self, new_method_name)(*args, **kwargs)
+
+    _deprecated_method.__name__ = old_method_name
+    setattr(cls, old_method_name, _deprecated_method)
+    return cls
+
+
+def _deprecate_renamed_methods(cls, **renamed_methods):
+    for old_method_name, new_method_name in renamed_methods.items():
+        _deprecated_renamed_method(cls, old_method_name, new_method_name)
+    return cls


Test patch:
diff --git a/test/functions/test_inv_quad_log_det.py b/test/functions/test_inv_quad_log_det.py
index 085b111b..e308adea 100644
--- a/test/functions/test_inv_quad_log_det.py
+++ b/test/functions/test_inv_quad_log_det.py
@@ -34,22 +34,22 @@ class TestInvQuadLogDetNonBatch(unittest.TestCase):
         self.vecs = vecs.detach().clone().requires_grad_(True)
         self.vecs_clone = vecs.detach().clone().requires_grad_(True)
 
-    def test_inv_quad_log_det_vector(self):
+    def test_inv_quad_logdet_vector(self):
         # Forward pass
         actual_inv_quad = self.mat_clone.inverse().matmul(self.vec_clone).mul(self.vec_clone).sum()
-        actual_log_det = self.mat_clone.logdet()
+        actual_logdet = self.mat_clone.logdet()
         with gpytorch.settings.num_trace_samples(1000):
             non_lazy_tsr = NonLazyTensor(self.mat)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vec, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vec, logdet=True)
 
         self.assertAlmostEqual(res_inv_quad.item(), actual_inv_quad.item(), places=1)
-        self.assertAlmostEqual(res_log_det.item(), actual_log_det.item(), places=1)
+        self.assertAlmostEqual(res_logdet.item(), actual_logdet.item(), places=1)
 
         # Backward
         actual_inv_quad.backward()
-        actual_log_det.backward()
+        actual_logdet.backward()
         res_inv_quad.backward(retain_graph=True)
-        res_log_det.backward()
+        res_logdet.backward()
 
         self.assertLess(torch.max((self.mat_clone.grad - self.mat.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vec_clone.grad - self.vec.grad).abs()).item(), 1e-1)
@@ -67,40 +67,40 @@ class TestInvQuadLogDetNonBatch(unittest.TestCase):
         self.assertLess(torch.max((self.mat_clone.grad - self.mat.grad).abs()).item(), 1e-3)
         self.assertLess(torch.max((self.vec_clone.grad - self.vec.grad).abs()).item(), 1e-3)
 
-    def test_inv_quad_log_det_many_vectors(self):
+    def test_inv_quad_logdet_many_vectors(self):
         # Forward pass
         actual_inv_quad = self.mat_clone.inverse().matmul(self.vecs_clone).mul(self.vecs_clone).sum()
-        actual_log_det = self.mat_clone.logdet()
+        actual_logdet = self.mat_clone.logdet()
         with gpytorch.settings.num_trace_samples(1000):
             non_lazy_tsr = NonLazyTensor(self.mat)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vecs, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vecs, logdet=True)
         self.assertAlmostEqual(res_inv_quad.item(), actual_inv_quad.item(), places=1)
-        self.assertAlmostEqual(res_log_det.item(), actual_log_det.item(), places=1)
+        self.assertAlmostEqual(res_logdet.item(), actual_logdet.item(), places=1)
 
         # Backward
         actual_inv_quad.backward()
-        actual_log_det.backward()
+        actual_logdet.backward()
         res_inv_quad.backward(retain_graph=True)
-        res_log_det.backward()
+        res_logdet.backward()
 
         self.assertLess(torch.max((self.mat_clone.grad - self.mat.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-1)
 
-    def test_inv_quad_log_det_many_vectors_improper(self):
+    def test_inv_quad_logdet_many_vectors_improper(self):
         # Forward pass
         actual_inv_quad = self.mat_clone.inverse().matmul(self.vecs_clone).mul(self.vecs_clone).sum()
-        actual_log_det = self.mat_clone.logdet()
+        actual_logdet = self.mat_clone.logdet()
         with gpytorch.settings.num_trace_samples(1000), gpytorch.settings.skip_logdet_forward(True):
             non_lazy_tsr = NonLazyTensor(self.mat)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vecs, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vecs, logdet=True)
         self.assertAlmostEqual(res_inv_quad.item(), actual_inv_quad.item(), places=1)
-        self.assertAlmostEqual(res_log_det.item(), torch.zeros(non_lazy_tsr.batch_shape), places=1)
+        self.assertAlmostEqual(res_logdet.item(), torch.zeros(non_lazy_tsr.batch_shape), places=1)
 
         # Backward
         actual_inv_quad.backward()
-        actual_log_det.backward()
+        actual_logdet.backward()
         res_inv_quad.backward(retain_graph=True)
-        res_log_det.backward()
+        res_logdet.backward()
 
         self.assertLess(torch.max((self.mat_clone.grad - self.mat.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-1)
@@ -118,10 +118,10 @@ class TestInvQuadLogDetNonBatch(unittest.TestCase):
         self.assertLess(torch.max((self.mat_clone.grad - self.mat.grad).abs()).item(), 1e-3)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-3)
 
-    def test_log_det_only(self):
+    def test_logdet_only(self):
         # Forward pass
         with gpytorch.settings.num_trace_samples(1000):
-            res = NonLazyTensor(self.mat).log_det()
+            res = NonLazyTensor(self.mat).logdet()
         actual = self.mat_clone.logdet()
         self.assertAlmostEqual(res.item(), actual.item(), places=1)
 
@@ -153,7 +153,7 @@ class TestInvQuadLogDetBatch(unittest.TestCase):
         self.vecs = vecs.detach().clone().requires_grad_(True)
         self.vecs_clone = vecs.detach().clone().requires_grad_(True)
 
-    def test_inv_quad_log_det_many_vectors(self):
+    def test_inv_quad_logdet_many_vectors(self):
         # Forward pass
         actual_inv_quad = (
             torch.cat([mat.inverse().unsqueeze(0) for mat in self.mats_clone])
@@ -162,28 +162,28 @@ class TestInvQuadLogDetBatch(unittest.TestCase):
             .sum(2)
             .sum(1)
         )
-        actual_log_det = torch.cat([mat.logdet().unsqueeze(0) for mat in self.mats_clone])
+        actual_logdet = torch.cat([mat.logdet().unsqueeze(0) for mat in self.mats_clone])
         with gpytorch.settings.num_trace_samples(2000):
             non_lazy_tsr = NonLazyTensor(self.mats)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vecs, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vecs, logdet=True)
 
         self.assertEqual(res_inv_quad.shape, actual_inv_quad.shape)
-        self.assertEqual(res_log_det.shape, actual_log_det.shape)
+        self.assertEqual(res_logdet.shape, actual_logdet.shape)
         self.assertLess(torch.max((res_inv_quad - actual_inv_quad).abs()).item(), 1e-1)
-        self.assertLess(torch.max((res_log_det - actual_log_det).abs()).item(), 1e-1)
+        self.assertLess(torch.max((res_logdet - actual_logdet).abs()).item(), 1e-1)
 
         # Backward
         inv_quad_grad_output = torch.randn(5, dtype=torch.float)
-        log_det_grad_output = torch.randn(5, dtype=torch.float)
+        logdet_grad_output = torch.randn(5, dtype=torch.float)
         actual_inv_quad.backward(gradient=inv_quad_grad_output)
-        actual_log_det.backward(gradient=log_det_grad_output)
+        actual_logdet.backward(gradient=logdet_grad_output)
         res_inv_quad.backward(gradient=inv_quad_grad_output, retain_graph=True)
-        res_log_det.backward(gradient=log_det_grad_output)
+        res_logdet.backward(gradient=logdet_grad_output)
 
         self.assertLess(torch.max((self.mats_clone.grad - self.mats.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-1)
 
-    def test_inv_quad_log_det_many_vectors_improper(self):
+    def test_inv_quad_logdet_many_vectors_improper(self):
         # Forward pass
         actual_inv_quad = (
             torch.cat([mat.inverse().unsqueeze(0) for mat in self.mats_clone])
@@ -192,23 +192,23 @@ class TestInvQuadLogDetBatch(unittest.TestCase):
             .sum(2)
             .sum(1)
         )
-        actual_log_det = torch.cat([mat.logdet().unsqueeze(0) for mat in self.mats_clone])
+        actual_logdet = torch.cat([mat.logdet().unsqueeze(0) for mat in self.mats_clone])
         with gpytorch.settings.num_trace_samples(2000), gpytorch.settings.skip_logdet_forward(True):
             non_lazy_tsr = NonLazyTensor(self.mats)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vecs, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vecs, logdet=True)
 
         self.assertEqual(res_inv_quad.shape, actual_inv_quad.shape)
-        self.assertEqual(res_log_det.shape, actual_log_det.shape)
+        self.assertEqual(res_logdet.shape, actual_logdet.shape)
         self.assertLess(torch.max((res_inv_quad - actual_inv_quad).abs()).item(), 1e-1)
-        self.assertLess(torch.max(res_log_det.abs()).item(), 1e-1)
+        self.assertLess(torch.max(res_logdet.abs()).item(), 1e-1)
 
         # Backward
         inv_quad_grad_output = torch.randn(5, dtype=torch.float)
-        log_det_grad_output = torch.randn(5, dtype=torch.float)
+        logdet_grad_output = torch.randn(5, dtype=torch.float)
         actual_inv_quad.backward(gradient=inv_quad_grad_output)
-        actual_log_det.backward(gradient=log_det_grad_output)
+        actual_logdet.backward(gradient=logdet_grad_output)
         res_inv_quad.backward(gradient=inv_quad_grad_output, retain_graph=True)
-        res_log_det.backward(gradient=log_det_grad_output)
+        res_logdet.backward(gradient=logdet_grad_output)
 
         self.assertLess(torch.max((self.mats_clone.grad - self.mats.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-1)
@@ -233,10 +233,10 @@ class TestInvQuadLogDetBatch(unittest.TestCase):
         self.assertLess(torch.max((self.mats_clone.grad - self.mats.grad).abs()).item(), 1e-3)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-3)
 
-    def test_log_det_only(self):
+    def test_logdet_only(self):
         # Forward pass
         with gpytorch.settings.num_trace_samples(2000):
-            res = NonLazyTensor(self.mats).log_det()
+            res = NonLazyTensor(self.mats).logdet()
         actual = torch.cat([mat.logdet().unsqueeze(0) for mat in self.mats_clone])
         self.assertEqual(res.shape, actual.shape)
         self.assertLess(torch.max((res - actual).abs()).item(), 1e-1)
@@ -270,7 +270,7 @@ class TestInvQuadLogDetMultiBatch(unittest.TestCase):
         self.vecs = vecs.detach().clone().requires_grad_(True)
         self.vecs_clone = vecs.detach().clone().requires_grad_(True)
 
-    def test_inv_quad_log_det_many_vectors(self):
+    def test_inv_quad_logdet_many_vectors(self):
         # Forward pass
         flattened_mats = self.mats_clone.view(-1, *self.mats_clone.shape[-2:])
         actual_inv_quad = (
@@ -281,25 +281,25 @@ class TestInvQuadLogDetMultiBatch(unittest.TestCase):
             .sum(-2)
             .sum(-1)
         )
-        actual_log_det = torch.cat([mat.logdet().unsqueeze(0) for mat in flattened_mats])
-        actual_log_det = actual_log_det.view(self.mats_clone.shape[:-2])
+        actual_logdet = torch.cat([mat.logdet().unsqueeze(0) for mat in flattened_mats])
+        actual_logdet = actual_logdet.view(self.mats_clone.shape[:-2])
 
         with gpytorch.settings.num_trace_samples(2000):
             non_lazy_tsr = NonLazyTensor(self.mats)
-            res_inv_quad, res_log_det = non_lazy_tsr.inv_quad_log_det(inv_quad_rhs=self.vecs, log_det=True)
+            res_inv_quad, res_logdet = non_lazy_tsr.inv_quad_logdet(inv_quad_rhs=self.vecs, logdet=True)
 
         self.assertEqual(res_inv_quad.shape, actual_inv_quad.shape)
-        self.assertEqual(res_log_det.shape, actual_log_det.shape)
+        self.assertEqual(res_logdet.shape, actual_logdet.shape)
         self.assertLess(torch.max((res_inv_quad - actual_inv_quad).abs()).item(), 1e-1)
-        self.assertLess(torch.max((res_log_det - actual_log_det).abs()).item(), 1e-1)
+        self.assertLess(torch.max((res_logdet - actual_logdet).abs()).item(), 1e-1)
 
         # Backward
         inv_quad_grad_output = torch.randn(2, 3, dtype=torch.float)
-        log_det_grad_output = torch.randn(2, 3, dtype=torch.float)
+        logdet_grad_output = torch.randn(2, 3, dtype=torch.float)
         actual_inv_quad.backward(gradient=inv_quad_grad_output)
-        actual_log_det.backward(gradient=log_det_grad_output)
+        actual_logdet.backward(gradient=logdet_grad_output)
         res_inv_quad.backward(gradient=inv_quad_grad_output, retain_graph=True)
-        res_log_det.backward(gradient=log_det_grad_output)
+        res_logdet.backward(gradient=logdet_grad_output)
 
         self.assertLess(torch.max((self.mats_clone.grad - self.mats.grad).abs()).item(), 1e-1)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-1)
@@ -326,10 +326,10 @@ class TestInvQuadLogDetMultiBatch(unittest.TestCase):
         self.assertLess(torch.max((self.mats_clone.grad - self.mats.grad).abs()).item(), 1e-3)
         self.assertLess(torch.max((self.vecs_clone.grad - self.vecs.grad).abs()).item(), 1e-3)
 
-    def test_log_det_only(self):
+    def test_logdet_only(self):
         # Forward pass
         with gpytorch.settings.num_trace_samples(2000):
-            res = NonLazyTensor(self.mats).log_det()
+            res = NonLazyTensor(self.mats).logdet()
         flattened_mats = self.mats_clone.view(-1, *self.mats_clone.shape[-2:])
         actual = torch.cat([mat.logdet().unsqueeze(0) for mat in flattened_mats])
         actual = actual.view(self.mats_clone.shape[:-2])
diff --git a/test/lazy/_lazy_tensor_test_case.py b/test/lazy/_lazy_tensor_test_case.py
index a72c93a0..a10ffeed 100644
--- a/test/lazy/_lazy_tensor_test_case.py
+++ b/test/lazy/_lazy_tensor_test_case.py
@@ -430,7 +430,7 @@ class LazyTensorTestCase(RectangularLazyTensorTestCase):
         self.assertEqual(res.size(), lazy_tensor.size()[:-1])
         self.assertLess(((res - actual).abs() / actual.abs().clamp(1, 1e5)).max().item(), 3e-1)
 
-    def test_inv_quad_log_det(self):
+    def test_inv_quad_logdet(self):
         # Forward
         lazy_tensor = self.create_lazy_tensor()
         evaluated = self.evaluate_lazy_tensor(lazy_tensor)
@@ -440,19 +440,19 @@ class LazyTensorTestCase(RectangularLazyTensorTestCase):
         vecs_copy = vecs.clone().detach_().requires_grad_(True)
 
         with gpytorch.settings.num_trace_samples(128):
-            res_inv_quad, res_log_det = lazy_tensor.inv_quad_log_det(inv_quad_rhs=vecs, log_det=True)
-        res = res_inv_quad + res_log_det
+            res_inv_quad, res_logdet = lazy_tensor.inv_quad_logdet(inv_quad_rhs=vecs, logdet=True)
+        res = res_inv_quad + res_logdet
 
         actual_inv_quad = evaluated.inverse().matmul(vecs_copy).mul(vecs_copy).sum(-2).sum(-1)
-        actual_log_det = torch.cat(
+        actual_logdet = torch.cat(
             [torch.logdet(flattened_evaluated[i]).unsqueeze(0) for i in range(lazy_tensor.batch_shape.numel())]
         ).view(lazy_tensor.batch_shape)
-        actual = actual_inv_quad + actual_log_det
+        actual = actual_inv_quad + actual_logdet
 
         diff = (res - actual).abs() / actual.abs().clamp(1, math.inf)
         self.assertLess(diff.max().item(), 15e-2)
 
-    def test_inv_quad_log_det_no_reduce(self):
+    def test_inv_quad_logdet_no_reduce(self):
         # Forward
         lazy_tensor = self.create_lazy_tensor()
         evaluated = self.evaluate_lazy_tensor(lazy_tensor)
@@ -462,16 +462,16 @@ class LazyTensorTestCase(RectangularLazyTensorTestCase):
         vecs_copy = vecs.clone().detach_().requires_grad_(True)
 
         with gpytorch.settings.num_trace_samples(128):
-            res_inv_quad, res_log_det = lazy_tensor.inv_quad_log_det(
-                inv_quad_rhs=vecs, log_det=True, reduce_inv_quad=False
+            res_inv_quad, res_logdet = lazy_tensor.inv_quad_log_det(
+                inv_quad_rhs=vecs, logdet=True, reduce_inv_quad=False
             )
-        res = res_inv_quad.sum(-1) + res_log_det
+        res = res_inv_quad.sum(-1) + res_logdet
 
         actual_inv_quad = evaluated.inverse().matmul(vecs_copy).mul(vecs_copy).sum(-2).sum(-1)
-        actual_log_det = torch.cat(
+        actual_logdet = torch.cat(
             [torch.logdet(flattened_evaluated[i]).unsqueeze(0) for i in range(lazy_tensor.batch_shape.numel())]
         ).view(lazy_tensor.batch_shape)
-        actual = actual_inv_quad + actual_log_det
+        actual = actual_inv_quad + actual_logdet
 
         diff = (res - actual).abs() / actual.abs().clamp(1, math.inf)
         self.assertLess(diff.max().item(), 15e-2)
diff --git a/test/lazy/test_cached_cg_lazy_tensor.py b/test/lazy/test_cached_cg_lazy_tensor.py
index 55d4cdee..714d1df8 100644
--- a/test/lazy/test_cached_cg_lazy_tensor.py
+++ b/test/lazy/test_cached_cg_lazy_tensor.py
@@ -19,7 +19,7 @@ class TestCachedCGLazyTensorNoLogdet(LazyTensorTestCase, unittest.TestCase):
 
         lazy_tensor = NonLazyTensor(mat)
         eager_rhs = torch.randn(5, 10).detach()
-        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_log_det tests
+        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_logdet tests
             solve, probe_vecs, probe_vec_norms, probe_vec_solves, tmats = CachedCGLazyTensor.precompute_terms(
                 lazy_tensor, eager_rhs.detach(), logdet_terms=False
             )
@@ -159,10 +159,10 @@ class TestCachedCGLazyTensorNoLogdet(LazyTensorTestCase, unittest.TestCase):
             ((test_vector.grad - test_vector_copy.grad).abs() / test_vector.grad.abs().clamp(1, 1e5)).max().item(), 3e-1
         )
 
-    def test_inv_quad_log_det(self):
+    def test_inv_quad_logdet(self):
         pass
 
-    def test_inv_quad_log_det_no_reduce(self):
+    def test_inv_quad_logdet_no_reduce(self):
         pass
 
     def test_root_inv_decomposition(self):
@@ -186,7 +186,7 @@ class TestCachedCGLazyTensor(TestCachedCGLazyTensorNoLogdet):
 
         lazy_tensor = NonLazyTensor(mat)
         eager_rhs = torch.randn(5, 10).detach()
-        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_log_det tests
+        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_logdet tests
             solve, probe_vecs, probe_vec_norms, probe_vec_solves, tmats = CachedCGLazyTensor.precompute_terms(
                 lazy_tensor, eager_rhs.detach()
             )
@@ -200,7 +200,7 @@ class TestCachedCGLazyTensor(TestCachedCGLazyTensorNoLogdet):
     def evaluate_lazy_tensor(self, lazy_tensor):
         return lazy_tensor.base_lazy_tensor.tensor
 
-    def test_inv_quad_log_det(self):
+    def test_inv_quad_logdet(self):
         # Forward
         lazy_tensor = self.create_lazy_tensor()
         evaluated = self.evaluate_lazy_tensor(lazy_tensor)
@@ -210,20 +210,20 @@ class TestCachedCGLazyTensor(TestCachedCGLazyTensorNoLogdet):
         vecs_copy = lazy_tensor.eager_rhss[0].clone().detach().requires_grad_(True)
 
         with gpytorch.settings.num_trace_samples(128), warnings.catch_warnings(record=True) as w:
-            res_inv_quad, res_log_det = lazy_tensor.inv_quad_log_det(inv_quad_rhs=vecs, log_det=True)
+            res_inv_quad, res_logdet = lazy_tensor.inv_quad_logdet(inv_quad_rhs=vecs, logdet=True)
             self.assertEqual(len(w), 0)
-        res = res_inv_quad + res_log_det
+        res = res_inv_quad + res_logdet
 
         actual_inv_quad = evaluated.inverse().matmul(vecs_copy).mul(vecs_copy).sum(-2).sum(-1)
-        actual_log_det = torch.cat(
+        actual_logdet = torch.cat(
             [torch.logdet(flattened_evaluated[i]).unsqueeze(0) for i in range(lazy_tensor.batch_shape.numel())]
         ).view(lazy_tensor.batch_shape)
-        actual = actual_inv_quad + actual_log_det
+        actual = actual_inv_quad + actual_logdet
 
         diff = (res - actual).abs() / actual.abs().clamp(1, math.inf)
         self.assertLess(diff.max().item(), 15e-2)
 
-    def test_inv_quad_log_det_no_reduce(self):
+    def test_inv_quad_logdet_no_reduce(self):
         # Forward
         lazy_tensor = self.create_lazy_tensor()
         evaluated = self.evaluate_lazy_tensor(lazy_tensor)
@@ -233,17 +233,17 @@ class TestCachedCGLazyTensor(TestCachedCGLazyTensorNoLogdet):
         vecs_copy = lazy_tensor.eager_rhss[0].clone().detach().requires_grad_(True)
 
         with gpytorch.settings.num_trace_samples(128), warnings.catch_warnings(record=True) as w:
-            res_inv_quad, res_log_det = lazy_tensor.inv_quad_log_det(
-                inv_quad_rhs=vecs, log_det=True, reduce_inv_quad=False
+            res_inv_quad, res_logdet = lazy_tensor.inv_quad_logdet(
+                inv_quad_rhs=vecs, logdet=True, reduce_inv_quad=False
             )
             self.assertEqual(len(w), 0)
-        res = res_inv_quad.sum(-1) + res_log_det
+        res = res_inv_quad.sum(-1) + res_logdet
 
         actual_inv_quad = evaluated.inverse().matmul(vecs_copy).mul(vecs_copy).sum(-2).sum(-1)
-        actual_log_det = torch.cat(
+        actual_logdet = torch.cat(
             [torch.logdet(flattened_evaluated[i]).unsqueeze(0) for i in range(lazy_tensor.batch_shape.numel())]
         ).view(lazy_tensor.batch_shape)
-        actual = actual_inv_quad + actual_log_det
+        actual = actual_inv_quad + actual_logdet
 
         diff = (res - actual).abs() / actual.abs().clamp(1, math.inf)
         self.assertLess(diff.max().item(), 15e-2)
@@ -257,7 +257,7 @@ class TestCachedCGLazyTensorNoLogdetBatch(TestCachedCGLazyTensorNoLogdet):
         mat = mat.matmul(mat.transpose(-1, -2))
         mat.requires_grad_(True)
 
-        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_log_det tests
+        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_logdet tests
             lazy_tensor = NonLazyTensor(mat)
             eager_rhs = torch.randn(3, 5, 10).detach()
             solve, probe_vecs, probe_vec_norms, probe_vec_solves, tmats = CachedCGLazyTensor.precompute_terms(
@@ -286,7 +286,7 @@ class TestCachedCGLazyTensorBatch(TestCachedCGLazyTensor):
         mat = mat.matmul(mat.transpose(-1, -2))
         mat.requires_grad_(True)
 
-        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_log_det tests
+        with gpytorch.settings.num_trace_samples(1000):  # For inv_quad_logdet tests
             lazy_tensor = NonLazyTensor(mat)
             eager_rhs = torch.randn(3, 5, 10).detach()
             solve, probe_vecs, probe_vec_norms, probe_vec_solves, tmats = CachedCGLazyTensor.precompute_terms(