Merge branch 'params' of github.com:SheffieldML/GPy into params

GPy/plotting/matplot_dep/base_plots.py

@@ -6,27 +6,48 @@ import Tango
 import pylab as pb
 import numpy as np
 
-def gpplot(x,mu,lower,upper,edgecol=Tango.colorsHex['darkBlue'],fillcol=Tango.colorsHex['lightBlue'],axes=None,**kwargs):
-    if axes is None:
-        axes = pb.gca()
+def ax_default(fignum, ax):
+    if ax is None:
+        fig = pb.figure(fignum)
+        ax = fig.add_subplot(111)
+    else:
+        fig = ax.figure
+    return fig, ax
+
+def meanplot(x, mu, color=Tango.colorsHex['darkBlue'], ax=None, fignum=None, linewidth=2,**kw):
+    _, axes = ax_default(fignum, ax)
+    #here's the mean
+    return axes.plot(x,mu,color=color,linewidth=linewidth,**kw)
+    
+def gpplot(x,mu,lower,upper,edgecol=Tango.colorsHex['darkBlue'],fillcol=Tango.colorsHex['lightBlue'],ax=None,fignum=None,xlabel='x',ylabel='y',**kwargs):
+    _, axes = ax_default(ax, fignum)
+        
     mu = mu.flatten()
     x = x.flatten()
     lower = lower.flatten()
     upper = upper.flatten()
 
+    plots = []
+    
     #here's the mean
-    axes.plot(x,mu,color=edgecol,linewidth=2)
+    plots.append(meanplot(x, mu, edgecol, axes))
 
     #here's the box
     kwargs['linewidth']=0.5
     if not 'alpha' in kwargs.keys():
         kwargs['alpha'] = 0.3
-    axes.fill(np.hstack((x,x[::-1])),np.hstack((upper,lower[::-1])),color=fillcol,**kwargs)
+    plots.append(axes.fill(np.hstack((x,x[::-1])),np.hstack((upper,lower[::-1])),color=fillcol,**kwargs))
 
     #this is the edge:
-    axes.plot(x,upper,color=edgecol,linewidth=0.2)
-    axes.plot(x,lower,color=edgecol,linewidth=0.2)
-
+    plots.append(meanplot(x, upper,color=edgecol,linewidth=0.2,axes=axes))
+    plots.append(meanplot(x, lower,color=edgecol,linewidth=0.2,axes=axes))
+    
+    axes.set_xlabel(xlabel)
+    axes.set_ylabel(ylabel)
+    
+    return plots
+    
+    
 def removeRightTicks(ax=None):
     ax = ax or pb.gca()
     for i, line in enumerate(ax.get_yticklines()):

GPy/plotting/matplot_dep/dim_reduction_plots.py

@@ -2,6 +2,7 @@ import pylab as pb
 import numpy as np
 from latent_space_visualizations.controllers.imshow_controller import ImshowController,ImAnnotateController
 from ...util.misc import param_to_array
+from ...core.parameterization.variational import VariationalPosterior
 from .base_plots import x_frame2D
 import itertools
 import Tango
@@ -19,7 +20,7 @@ def most_significant_input_dimensions(model, which_indices):
             input_1, input_2 = 0, 1
         else:
             try:
-                input_1, input_2 = np.argsort(model.input_sensitivity())[::-1][:2]
+                input_1, input_2 = np.argsort(model.kern.input_sensitivity())[::-1][:2]
             except:
                 raise ValueError, "cannot automatically determine which dimensions to plot, please pass 'which_indices'"
     else:
@@ -43,26 +44,29 @@ def plot_latent(model, labels=None, which_indices=None,
         labels = np.ones(model.num_data)
 
     input_1, input_2 = most_significant_input_dimensions(model, which_indices)
-    X = param_to_array(model.X)
 
-    # first, plot the output variance as a function of the latent space
-    Xtest, xx, yy, xmin, xmax = x_frame2D(X[:, [input_1, input_2]], resolution=resolution)
-    Xtest_full = np.zeros((Xtest.shape[0], model.X.shape[1]))
+    #fethch the data points X that we'd like to plot
+    X = model.X
+    if isinstance(X, VariationalPosterior):
+        X = param_to_array(X.mean)
+    else:
+        X = param_to_array(X)
 
+
+    # create a function which computes the shading of latent space according to the output variance
     def plot_function(x):
+        Xtest_full = np.zeros((x.shape[0], model.X.shape[1]))
         Xtest_full[:, [input_1, input_2]] = x
         mu, var, low, up = model.predict(Xtest_full)
         var = var[:, :1]
         return np.log(var)
 
+    #Create an IMshow controller that can re-plot the latent space shading at a good resolution
     view = ImshowController(ax, plot_function,
                             tuple(X[:, [input_1, input_2]].min(0)) + tuple(X[:, [input_1, input_2]].max(0)),
                             resolution, aspect=aspect, interpolation='bilinear',
                             cmap=pb.cm.binary)
 
-#     ax.imshow(var.reshape(resolution, resolution).T,
-#               extent=[xmin[0], xmax[0], xmin[1], xmax[1]], cmap=pb.cm.binary, interpolation='bilinear', origin='lower')
-
     # make sure labels are in order of input:
     ulabels = []
     for lab in labels:
@@ -95,8 +99,8 @@ def plot_latent(model, labels=None, which_indices=None,
     if not np.all(labels == 1.) and legend:
         ax.legend(loc=0, numpoints=1)
 
-    ax.set_xlim(xmin[0], xmax[0])
-    ax.set_ylim(xmin[1], xmax[1])
+    #ax.set_xlim(xmin[0], xmax[0])
+    #ax.set_ylim(xmin[1], xmax[1])
     ax.grid(b=False) # remove the grid if present, it doesn't look good
     ax.set_aspect('auto') # set a nice aspect ratio
 

GPy/plotting/matplot_dep/kernel_plots.py

@@ -6,7 +6,7 @@ import pylab as pb
 import Tango
 from matplotlib.textpath import TextPath
 from matplotlib.transforms import offset_copy
-from ...kern import Linear
+from .base_plots import ax_default
 
 
 
@@ -52,11 +52,7 @@ def plot_ARD(kernel, fignum=None, ax=None, title='', legend=False):
         pass '' to not print a title
         pass None for a generic title
     """
-    if ax is None:
-        fig = pb.figure(fignum)
-        ax = fig.add_subplot(111)
-    else:
-        fig = ax.figure
+    fig, ax = ax_default(fignum,ax)
 
     if title is None:
         ax.set_title('ARD parameters, %s kernel' % kernel.name)
@@ -70,13 +66,13 @@ def plot_ARD(kernel, fignum=None, ax=None, title='', legend=False):
     bottom = 0
     x = np.arange(kernel.input_dim)
     
-    for i in range(ard_params.shape[-1]):
+    for i in range(ard_params.shape[0]):
         c = Tango.nextMedium()
-        bars.append(plot_bars(fig, ax, x, ard_params[:,i], c, kernel._parameters_[i].name, bottom=bottom))
-        bottom += ard_params[:,i]
+        bars.append(plot_bars(fig, ax, x, ard_params[i,:], c, kernel._parameters_[i].name, bottom=bottom))
+        bottom += ard_params[i,:]
     
     ax.set_xlim(-.5, kernel.input_dim - .5)
-    add_bar_labels(fig, ax, [bars[-1]], bottom=bottom-ard_params[:,i])
+    add_bar_labels(fig, ax, [bars[-1]], bottom=bottom-ard_params[i,:])
 
     if legend:
         if title is '':