Switch to PyTorch

.travis.yml

@@ -4,8 +4,7 @@ python:
   - "3.5"
   - "3.6"
 install:
-  - pip install pipenv yapf
-  - pipenv install
-  - pipenv run python setup.py install
+  - pip install yapf==0.22.0
+  - python setup.py install
 script:
   - yapf --diff --recursive .

Pipfile

@@ -1,21 +1,14 @@
 [[source]]
-
 url = "https://pypi.python.org/simple"
 verify_ssl = true
 name = "pypi"
 
-
 [packages]
-
 numpy = "==1.14.2"
-scipy = "==1.0.0"
 six = "==1.11.0"
-theano = "==1.0.1"
-
+torch = "==0.4.0"
 
 [dev-packages]
+yapf = "==0.22.0"
 
-
-
-[requires]
-
+[requires]

README.rst

@@ -6,7 +6,7 @@ Gaussian Process
 
 This is a *differentiable* `Gaussian Process
 <https://en.wikipedia.org/wiki/Gaussian_process>`_ implementation for
-`Theano <http://deeplearning.net/software/theano/>`_.
+`PyTorch <https://pytorch.org>`_.
 
 The code is based off of the
 `Gaussian Processes for Machine Learning <http://www.gaussianprocess.org/gpml/>`_
@@ -35,42 +35,24 @@ After installation, :code:`import` and use as follows:
 .. code-block:: python
 
   from gp import GaussianProcess
+  from gp.kernels import RBFKernel, WhiteNoiseKernel
 
-  gp = GaussianProcess()
-  gp.fit(X, Y)
+  k = RBFKernel() + WhiteNoiseKernel()
+  gp = GaussianProcess(k, X, Y)
+  gp.fit()
 
 where :code:`X` and :code:`Y` are your training data's inputs and outputs as
-:code:`theano.SharedVariable`.
+:code:`torch.Tensor`.
 
 You can then use the Gaussian Process's estimates as a tensor in your own
 graphs:
 
 .. code-block:: python
 
-  mu = gp.mean
-  sigma = gp.standard_deviation
-  sigma_squared = gp.variance
-  log_likelihood = gp.log_likelihood
-
-You can also differentiate any of these tensors with respect to any other
-tensor variables:
-
-.. code-block:: python
-
-  import theano.tensor as T
-
-  loss = -gp.log_likelihood
-  loss_wrt_hyperparameters = T.grad(loss, gp.hyperparameters)
-
-Alternatively, you can use it standalone and compile its tensors into
-functions:
-
-.. code-block:: python
-
-  gp.compile()
-  mu = gp.compute_mean(x)
-  sigma = gp.compute_standard_deviation(x)
-  sigma_squared = gp.compute_variance(x)
+  mean = gp(x)
+  mean, std = gp(x, return_std=True)
+  mean, covar = gp(x, return_covar=True)
+  mean, covar, std = gp(x, return_covar=True, return_std=True)
 
 The following is an example of what this Gaussian Process was able to estimate
 with a few randomly sampled points (in blue) of a noisy :code:`sin` function.
@@ -85,12 +67,11 @@ You can see the `examples <examples/>`_ directory for some
 `Jupyter <https://jupyter.org>`_ notebooks with more detailed examples. You can
 also play with the *secret* functions that the Gaussian Process is attempting
 to learn and see how well it performs. Depending on the complexity and nature
-of the function, you might need to sample more data or lower the noise applied
-to the system.
+of the function, you might need to sample more data.
 
-Finally, you can also use a custom kernel function instead of the default
+Finally, you can also use a custom kernel function instead of the included
 Radial-Basis Function (RBF) kernel by implementing your own :code:`Kernel`
-class as in `kernel.py <gp/kernel.py>`_.
+class as in `kernels.py <gp/kernels.py>`_.
 
 Contributing
 ------------

gp/__init__.py

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
-"""Gaussian Process implementation for Theano."""
+"""Gaussian Process implementation."""
 
 __version__ = "0.1.0"
 
-from .kernel import Kernel, RBFKernel
-from .gaussian_process import GaussianProcess, MultiGaussianProcess
+import kernels
+from .models import GaussianProcess, MultiGaussianProcess
 
-__all__ = ["GaussianProcess", "Kernel", "MultiGaussianProcess", "RBFKernel"]
+__all__ = ["GaussianProcess", "MultiGaussianProcess", "kernels"]