diff --git a/GPy/core/gp.py b/GPy/core/gp.py index 5b356744..744ac008 100644 --- a/GPy/core/gp.py +++ b/GPy/core/gp.py @@ -2,10 +2,9 @@ # Licensed under the BSD 3-clause license (see LICENSE.txt) import numpy as np -import pylab as pb +import sys import warnings from .. import kern -from ..util.plot import gpplot, Tango, x_frame1D, x_frame2D from ..util.linalg import dtrtrs from model import Model from parameterization import ObservableArray @@ -122,9 +121,9 @@ class GP(Model): :param X: The points at which to take the samples. :type X: np.ndarray, Nnew x self.input_dim. - :param size: the number of a posteriori samples to plot. + :param size: the number of a posteriori samples. :type size: int. - :param which_parts: which of the kernel functions to plot (additively). + :param which_parts: which of the kernel functions to use (additively). :type which_parts: 'all', or list of bools. :param full_cov: whether to return the full covariance matrix, or just the diagonal. :type full_cov: bool. @@ -145,9 +144,9 @@ class GP(Model): :param X: the points at which to take the samples. :type X: np.ndarray, Nnew x self.input_dim. - :param size: the number of a posteriori samples to plot. + :param size: the number of a posteriori samples. :type size: int. - :param which_parts: which of the kernel functions to plot (additively). + :param which_parts: which of the kernel functions to use (additively). :type which_parts: 'all', or list of bools. :param full_cov: whether to return the full covariance matrix, or just the diagonal. :type full_cov: bool. @@ -172,20 +171,13 @@ class GP(Model): """ Plot the GP's view of the world, where the data is normalized and before applying a likelihood. - This is a convenience function: we simply call self.plot with the - argument use_raw_predict set True. All args and kwargs are passed on to - plot. - - see also: gp.plot + This is a convenience function: arguments are passed to GPy.plotting.matplot_dep.models_plots.plot_f_fit """ - kwargs['plot_raw'] = True - self.plot(*args, **kwargs) + assert "matplotlib" in sys.modules, "matplotlib package has not been imported." + from ..plotting.matplot_dep import models_plots + models_plots.plot_fit_f(self,*args,**kwargs) - def plot(self, plot_limits=None, which_data_rows='all', - which_data_ycols='all', which_parts='all', fixed_inputs=[], - levels=20, samples=0, fignum=None, ax=None, resolution=None, - plot_raw=False, - linecol=Tango.colorsHex['darkBlue'],fillcol=Tango.colorsHex['lightBlue']): + def plot(self, *args): """ Plot the posterior of the GP. - In one dimension, the function is plotted with a shaded region identifying two standard deviations. @@ -193,121 +185,13 @@ class GP(Model): - In higher dimensions, use fixed_inputs to plot the GP with some of the inputs fixed. Can plot only part of the data and part of the posterior functions - using which_data_rowsm which_data_ycols and which_parts + using which_data_rows which_data_ycols and which_parts - :param plot_limits: The limits of the plot. If 1D [xmin,xmax], if 2D [[xmin,ymin],[xmax,ymax]]. Defaluts to data limits - :type plot_limits: np.array - :param which_data_rows: which of the training data to plot (default all) - :type which_data_rows: 'all' or a slice object to slice self.X, self.Y - :param which_data_ycols: when the data has several columns (independant outputs), only plot these - :type which_data_rows: 'all' or a list of integers - :param which_parts: which of the kernel functions to plot (additively) - :type which_parts: 'all', or list of bools - :param fixed_inputs: a list of tuple [(i,v), (i,v)...], specifying that input index i should be set to value v. - :type fixed_inputs: a list of tuples - :param resolution: the number of intervals to sample the GP on. Defaults to 200 in 1D and 50 (a 50x50 grid) in 2D - :type resolution: int - :param levels: number of levels to plot in a contour plot. - :type levels: int - :param samples: the number of a posteriori samples to plot - :type samples: int - :param fignum: figure to plot on. - :type fignum: figure number - :param ax: axes to plot on. - :type ax: axes handle - :type output: integer (first output is 0) - :param linecol: color of line to plot. - :type linecol: - :param fillcol: color of fill - :param levels: for 2D plotting, the number of contour levels to use is ax is None, create a new figure + This is a convenience function: arguments are passed to GPy.plotting.matplot_dep.models_plots.plot_fit """ - #deal with optional arguments - if which_data_rows == 'all': - which_data_rows = slice(None) - if which_data_ycols == 'all': - which_data_ycols = np.arange(self.output_dim) - if len(which_data_ycols)==0: - raise ValueError('No data selected for plotting') - if ax is None: - fig = pb.figure(num=fignum) - ax = fig.add_subplot(111) - - #work out what the inputs are for plotting (1D or 2D) - fixed_dims = np.array([i for i,v in fixed_inputs]) - free_dims = np.setdiff1d(np.arange(self.input_dim),fixed_dims) - - #one dimensional plotting - if len(free_dims) == 1: - - #define the frame on which to plot - resolution = resolution or 200 - Xnew, xmin, xmax = x_frame1D(self.X[:,free_dims], plot_limits=plot_limits) - Xgrid = np.empty((Xnew.shape[0],self.input_dim)) - Xgrid[:,free_dims] = Xnew - for i,v in fixed_inputs: - Xgrid[:,i] = v - - #make a prediction on the frame and plot it - if plot_raw: - m, v = self._raw_predict(Xgrid, which_parts=which_parts) - lower = m - 2*np.sqrt(v) - upper = m + 2*np.sqrt(v) - Y = self.Y - else: - m, v, lower, upper = self.predict(Xgrid, which_parts=which_parts) - Y = self.Y - for d in which_data_ycols: - gpplot(Xnew, m[:, d], lower[:, d], upper[:, d], axes=ax, edgecol=linecol, fillcol=fillcol) - ax.plot(self.X[which_data_rows,free_dims], Y[which_data_rows, d], 'kx', mew=1.5) - - #optionally plot some samples - if samples: #NOTE not tested with fixed_inputs - Ysim = self.posterior_samples(Xgrid, samples, which_parts=which_parts) - for yi in Ysim.T: - ax.plot(Xnew, yi[:,None], Tango.colorsHex['darkBlue'], linewidth=0.25) - #ax.plot(Xnew, yi[:,None], marker='x', linestyle='--',color=Tango.colorsHex['darkBlue']) #TODO apply this line for discrete outputs. - - #set the limits of the plot to some sensible values - ymin, ymax = min(np.append(Y[which_data_rows, which_data_ycols].flatten(), lower)), max(np.append(Y[which_data_rows, which_data_ycols].flatten(), upper)) - ymin, ymax = ymin - 0.1 * (ymax - ymin), ymax + 0.1 * (ymax - ymin) - ax.set_xlim(xmin, xmax) - ax.set_ylim(ymin, ymax) - - #2D plotting - elif len(free_dims) == 2: - - #define the frame for plotting on - resolution = resolution or 50 - Xnew, _, _, xmin, xmax = x_frame2D(self.X[:,free_dims], plot_limits, resolution) - Xgrid = np.empty((Xnew.shape[0],self.input_dim)) - Xgrid[:,free_dims] = Xnew - for i,v in fixed_inputs: - Xgrid[:,i] = v - x, y = np.linspace(xmin[0], xmax[0], resolution), np.linspace(xmin[1], xmax[1], resolution) - - #predict on the frame and plot - if plot_raw: - m, _ = self._raw_predict(Xgrid, which_parts=which_parts) - Y = self.likelihood.Y - else: - m, _, _, _ = self.predict(Xgrid, which_parts=which_parts,sampling=False) - Y = self.likelihood.data - for d in which_data_ycols: - m_d = m[:,d].reshape(resolution, resolution).T - ax.contour(x, y, m_d, levels, vmin=m.min(), vmax=m.max(), cmap=pb.cm.jet) - ax.scatter(self.X[which_data_rows, free_dims[0]], self.X[which_data_rows, free_dims[1]], 40, Y[which_data_rows, d], cmap=pb.cm.jet, vmin=m.min(), vmax=m.max(), linewidth=0.) - - #set the limits of the plot to some sensible values - ax.set_xlim(xmin[0], xmax[0]) - ax.set_ylim(xmin[1], xmax[1]) - - if samples: - warnings.warn("Samples are rather difficult to plot for 2D inputs...") - - else: - raise NotImplementedError, "Cannot define a frame with more than two input dimensions" - - + assert "matplotlib" in sys.modules, "matplotlib package has not been imported." + from ..plotting.matplot_dep import models_plots + models_plots.plot_fit(self,*args) def _getstate(self): """ @@ -333,5 +217,3 @@ class GP(Model): self.num_data = state.pop() self.X = state.pop() Model._setstate(self, state) - -