Getting started


You can install the most recent stable version of George using PyPI or the development version from GitHub.


Whichever method you choose, you’ll need to make sure that you first have Eigen installed. On Linux:

sudo apt-get install libeigen3-dev

On Mac:

brew install eigen


Chances are high that George won’t work on Windows right now because it hasn’t been tested at all but feel free to try it out at your own risk!

You’ll also need a working scientific Python installation (including NumPy and SciPy). I recommend the Anaconda distribution if you don’t already have your own opinions.

Stable Version

The simplest way to install the most recent stable version of George is using pip:

pip install george

If you installed Eigen in a strange place, specify that location by running (sorry to say that it’s pretty freaking ugly):

pip install george \
    --global-option=build_ext \

Development Version

To get the source for the development version, clone the git repository and checkout the required HODLR submodule:

git clone
cd george
git submodule init
git submodule update

Then, install the package by running the following command:

python install

If installed Eigen in a non-standard location, you can specify the correct path using the install command:

python build_ext -I/path/to/eigen3 install


To run the unit tests, install nose and then execute:

nosetests -v george.testing

All of the tests should (of course) pass. If any of the tests don’t pass and if you can’t sort out why, open an issue on GitHub.

A Simple Example

The following code generates some fake data (from a sinusoidal model) with error bars:

import numpy as np

# Generate some fake noisy data.
x = 10 * np.sort(np.random.rand(10))
yerr = 0.2 * np.ones_like(x)
y = np.sin(x) + yerr * np.random.randn(len(x))

Then, we’ll choose a simple kernel function (see Kernels for some other choices) and compute the log-likelihood of the fake data under a Gaussian process model with this kernel:

import george
from george.kernels import ExpSquaredKernel

# Set up the Gaussian process.
kernel = ExpSquaredKernel(1.0)
gp = george.GP(kernel)

# Pre-compute the factorization of the matrix.
gp.compute(x, yerr)

# Compute the log likelihood.

Finally, we can compute the predicted values of the function at a fine grid of points conditioned on the observed data. This prediction will be an \(N_\mathrm{test} \times N_\mathrm{test}\) multivariate Gaussian (where \(N_\mathrm{test}\) is the number of points in the grid) with mean mu and covariance cov:

t = np.linspace(0, 10, 500)
mu, cov = gp.predict(y, t)
std = np.sqrt(np.diag(cov))

This should result in a constraint that looks something like:


where the points with error bars are the simulated data and the filled gray patch is the mean and standard deviation of the prediction.