restructuring and merge with devel

.travis.yml

@@ -12,6 +12,7 @@ before_install:
   - sudo apt-get install -qq python-matplotlib
 
 install:
+  - pip install --upgrade numpy==1.7.1 
   - pip install sphinx 
   - pip install nose
   - pip install . --use-mirrors

GPy/core/model.py

@@ -2,17 +2,19 @@
 # Licensed under the BSD 3-clause license (see LICENSE.txt)
 
 
-import numpy as np
-from scipy import optimize
-import sys, pdb
-import multiprocessing as mp
-from GPy.util.misc import opt_wrapper
-#import numdifftools as ndt
-from parameterised import parameterised, truncate_pad
-import priors
-from ..util.linalg import jitchol
-from ..inference import optimization
 from .. import likelihoods
+from ..inference import optimization
+from ..util.linalg import jitchol
+from GPy.util.misc import opt_wrapper
+from parameterised import parameterised, truncate_pad
+from scipy import optimize
+import multiprocessing as mp
+import numpy as np
+import priors
+import re
+import sys
+import pdb
+# import numdifftools as ndt
 
 class model(parameterised):
     def __init__(self):
@@ -214,9 +216,9 @@ class model(parameterised):
         for s in positive_strings:
             for i in self.grep_param_names(s):
                 if not (i in currently_constrained):
-                    to_make_positive.append(param_names[i])
+                    to_make_positive.append(re.escape(param_names[i]))
                     if warn:
-                        print "Warning! constraining %s postive"%name
+                        print "Warning! constraining %s positive" % s
         if len(to_make_positive):
             self.constrain_positive('(' + '|'.join(to_make_positive) + ')')
 
@@ -253,7 +255,7 @@ class model(parameterised):
 
         :max_f_eval: maximum number of function evaluations
         :messages: whether to display during optimisation
-        :param optimzer: whice optimizer to use (defaults to self.preferred optimizer)
+        :param optimzer: which optimizer to use (defaults to self.preferred optimizer)
         :type optimzer: string TODO: valid strings?
         """
         if optimizer is None:

GPy/core/parameterised.py

@@ -171,10 +171,18 @@ class parameterised(object):
             return expr
 
     def Nparam_transformed(self):
+        """
+        Compute the number of parameters after ties and fixing have been performed
+        """
         ties = 0
-            for ar in self.tied_indices:
+        for ti in self.tied_indices:
-                ties += ar.size - 1
+            ties += ti.size - 1
-            return self.Nparam - len(self.constrained_fixed_indices) - ties
+
+        fixes = 0
+        for fi in self.constrained_fixed_indices:
+            fixes += len(fi)
+
+        return self.Nparam - fixes - ties
 
     def constrain_positive(self, which):
         """

GPy/examples/dimensionality_reduction.py

@@ -81,11 +81,19 @@ def BGPLVM_oil(optimize=True, N=100, Q=10, M=15, max_f_eval=300):
     else:
         m.ensure_default_constraints()
 
-    # plot
+    y = m.likelihood.Y[0, :]
-    print(m)
+    fig,(latent_axes,hist_axes) = plt.subplots(1,2)
-    m.plot_latent(labels=m.data_labels)
+    plt.sca(latent_axes)
-    pb.figure()
+    m.plot_latent()
-    pb.bar(np.arange(m.kern.D), 1. / m.input_sensitivity())
+    data_show = GPy.util.visualize.vector_show(y)
+    lvm_visualizer = GPy.util.visualize.lvm_dimselect(m.X[0, :], m, data_show, latent_axes=latent_axes, hist_axes=hist_axes)
+    raw_input('Press enter to finish')
+    plt.close('all')
+    # # plot
+    # print(m)
+    # m.plot_latent(labels=m.data_labels)
+    # pb.figure()
+    # pb.bar(np.arange(m.kern.D), 1. / m.input_sensitivity())
     return m
 
 def oil_100():
@@ -348,7 +356,7 @@ def brendan_faces():
     ax = m.plot_latent()
     y = m.likelihood.Y[0, :]
     data_show = GPy.util.visualize.image_show(y[None, :], dimensions=(20, 28), transpose=True, invert=False, scale=False)
-    lvm_visualizer = GPy.util.visualize.lvm(m, data_show, ax)
+    lvm_visualizer = GPy.util.visualize.lvm(m.X[0, :], m, data_show, ax)
     raw_input('Press enter to finish')
     plt.close('all')
 
@@ -365,7 +373,29 @@ def stick():
     ax = m.plot_latent()
     y = m.likelihood.Y[0, :]
     data_show = GPy.util.visualize.stick_show(y[None, :], connect=data['connect'])
-    lvm_visualizer = GPy.util.visualize.lvm(m, data_show, ax)
+    lvm_visualizer = GPy.util.visualize.lvm(m.X[0, :], m, data_show, ax)
+    raw_input('Press enter to finish')
+    plt.close('all')
+
+    return m
+
+def cmu_mocap(subject='35', motion=['01'], in_place=True):
+
+    data = GPy.util.datasets.cmu_mocap(subject, motion)
+    Y = data['Y']
+    if in_place:
+        # Make figure move in place.
+        data['Y'][:, 0:3]=0.0
+    m = GPy.models.GPLVM(data['Y'], 2, normalize_Y=True)
+
+    # optimize
+    m.ensure_default_constraints()
+    m.optimize(messages=1, max_f_eval=10000)
+
+    ax = m.plot_latent()
+    y = m.likelihood.Y[0, :]
+    data_show = GPy.util.visualize.skeleton_show(y[None, :], data['skel'])
+    lvm_visualizer = GPy.util.visualize.lvm(m.X[0, :], m, data_show, ax)
     raw_input('Press enter to finish')
     plt.close('all')
 

GPy/models/GPLVM.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
+### Copyright (c) 2012, GPy authors (see AUTHORS.txt).
 # Licensed under the BSD 3-clause license (see LICENSE.txt)
 
 
@@ -91,8 +91,8 @@ class GPLVM(GP):
         Xtest_full[:, :2] = Xtest
         mu, var, low, up = self.predict(Xtest_full)
         var = var[:, :1]
-        ax.imshow(var.reshape(resolution, resolution).T[::-1, :],
+        ax.imshow(var.reshape(resolution, resolution).T,
-                  extent=[xmin[0], xmax[0], xmin[1], xmax[1]], cmap=pb.cm.binary,interpolation='bilinear')
+                  extent=[xmin[0], xmax[0], xmin[1], xmax[1]], cmap=pb.cm.binary,interpolation='bilinear',origin='lower')
 
         for i,ul in enumerate(np.unique(labels)):
             if type(ul) is np.string_:

GPy/util/mocap.py

@@ -532,7 +532,6 @@ class acclaim_skeleton(skeleton):
                 self.vertices[0].meta['orientation'] =  [float(parts[1]),
                                              float(parts[2]),
                                              float(parts[3])]
-                print self.vertices[0].meta['orientation']
             lin = self.read_line(fid)
         return lin
     

GPy/util/visualize.py

@@ -3,121 +3,7 @@ from mpl_toolkits.mplot3d import Axes3D
 import GPy
 import numpy as np
 import matplotlib as mpl
-
+import time
-class lvm:
-    def __init__(self, model, data_visualize, latent_axes, latent_index=[0,1]):
-        if isinstance(latent_axes,mpl.axes.Axes):
-            self.cid = latent_axes.figure.canvas.mpl_connect('button_press_event', self.on_click)
-            self.cid = latent_axes.figure.canvas.mpl_connect('motion_notify_event', self.on_move)
-            self.cid = latent_axes.figure.canvas.mpl_connect('axes_leave_event', self.on_leave)
-            self.cid = latent_axes.figure.canvas.mpl_connect('axes_enter_event', self.on_enter)
-        else:
-            self.cid = latent_axes[0].figure.canvas.mpl_connect('button_press_event', self.on_click)
-            self.cid = latent_axes[0].figure.canvas.mpl_connect('motion_notify_event', self.on_move)
-            self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_leave_event', self.on_leave)
-            self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_enter_event', self.on_enter)
-        self.data_visualize = data_visualize
-        self.model = model
-        self.latent_axes = latent_axes
-
-        self.called = False
-        self.move_on = False
-        self.latent_index = latent_index
-        self.latent_dim = model.Q
-
-    def on_enter(self,event):
-        pass
-    def on_leave(self,event):
-        pass
-
-    def on_click(self, event):
-        #print 'click', event.xdata, event.ydata
-        if event.inaxes!=self.latent_axes: return
-        self.move_on = not self.move_on
-        # if self.called:
-        #     self.xs.append(event.xdata)
-        #     self.ys.append(event.ydata)
-        #     self.line.set_data(self.xs, self.ys)
-        #     self.line.figure.canvas.draw()
-        # else:
-        #     self.xs = [event.xdata]
-        #     self.ys = [event.ydata]
-        #     self.line, = self.latent_axes.plot(event.xdata, event.ydata)
-        self.called = True
-    def on_move(self, event):
-        if event.inaxes!=self.latent_axes: return
-        if self.called and self.move_on:
-            # Call modify code on move
-            #print 'move', event.xdata, event.ydata
-            latent_values = np.zeros((1,self.latent_dim))
-            latent_values[0,self.latent_index] = np.array([event.xdata, event.ydata])
-            y = self.model.predict(latent_values)[0]
-            self.data_visualize.modify(y)
-            #print 'y', y
-
-class lvm_subplots(lvm):
-    """
-    latent_axes is a np array of dimension np.ceil(Q/2) + 1,
-    one for each pair of the axes, and the last one for the sensitiity histogram
-    """
-    def __init__(self, model, data_visualize, latent_axes=None, latent_index=[0,1]):
-        self.nplots = int(np.ceil(model.Q/2.))+1
-        lvm.__init__(self,model,data_visualize,latent_axes,latent_index)
-        self.latent_values = np.zeros(2*np.ceil(self.model.Q/2.)) # possibly an extra dimension on this
-        assert latent_axes.size == self.nplots
-
-
-class lvm_dimselect(lvm):
-    """
-    A visualizer for latent variable models
-    with selection by clicking on the histogram
-    """
-    def __init__(self, model, data_visualize):
-        self.fig,(latent_axes,self.hist_axes) = plt.subplots(1,2)
-
-        lvm.__init__(self,model,data_visualize,latent_axes,[0,1])
-        self.latent_values_clicked = np.zeros(model.Q)
-        self.clicked_handle = self.latent_axes.plot([0],[0],'rx',mew=2)[0]
-        print "use left and right mouse butons to select dimensions"
-
-    def on_click(self, event):
-        #print "click"
-        if event.inaxes==self.hist_axes:
-            self.hist_axes.cla()
-            self.hist_axes.bar(np.arange(self.model.Q),1./self.model.input_sensitivity(),color='b')
-            new_index = max(0,min(int(np.round(event.xdata-0.5)),self.model.Q-1))
-            self.latent_index[(0 if event.button==1 else 1)] = new_index
-            self.hist_axes.bar(np.array(self.latent_index),1./self.model.input_sensitivity()[self.latent_index],color='r')
-            self.latent_axes.cla()
-            self.model.plot_latent(which_indices = self.latent_index,ax=self.latent_axes)
-            self.clicked_handle = self.latent_axes.plot([self.latent_values_clicked[self.latent_index[0]]],self.latent_values_clicked[self.latent_index[1]],'rx',mew=2)[0]
-        if event.inaxes==self.latent_axes:
-            self.clicked_handle.set_visible(False)
-            self.latent_values_clicked[self.latent_index] = np.array([event.xdata,event.ydata])
-            self.clicked_handle = self.latent_axes.plot([self.latent_values_clicked[self.latent_index[0]]],self.latent_values_clicked[self.latent_index[1]],'rx',mew=2)[0]
-        self.fig.canvas.draw()
-        self.move_on=True
-        self.called = True
-
-
-    def on_move(self, event):
-        #print "move"
-        if event.inaxes!=self.latent_axes: return
-        if self.called and self.move_on:
-            latent_values = self.latent_values_clicked.copy()
-            latent_values[self.latent_index] = np.array([event.xdata, event.ydata])
-            y = self.model.predict(latent_values[None,:])[0]
-            self.data_visualize.modify(y)
-
-    def on_leave(self,event):
-        latent_values = self.latent_values_clicked.copy()
-        y = self.model.predict(latent_values[None,:])[0]
-        self.data_visualize.modify(y)
-
-
-
-
-
 
 class data_show:
     """
@@ -155,6 +41,160 @@ class vector_show(data_show):
         self.handle.set_data(xdata, self.vals)
         self.axes.figure.canvas.draw()
 
+
+class lvm(data_show):
+    def __init__(self, vals, model, data_visualize, latent_axes=None, latent_index=[0,1]):
+        """Visualize a latent variable model
+
+        :param model: the latent variable model to visualize.
+        :param data_visualize: the object used to visualize the data which has been modelled.
+        :type data_visualize: visualize.data_show  type.
+        :param latent_axes: the axes where the latent visualization should be plotted.
+        """
+        if vals == None:
+            vals = model.X[0]
+
+        data_show.__init__(self, vals, axes=latent_axes)
+
+        if isinstance(latent_axes,mpl.axes.Axes):
+            self.cid = latent_axes.figure.canvas.mpl_connect('button_press_event', self.on_click)
+            self.cid = latent_axes.figure.canvas.mpl_connect('motion_notify_event', self.on_move)
+            self.cid = latent_axes.figure.canvas.mpl_connect('axes_leave_event', self.on_leave)
+            self.cid = latent_axes.figure.canvas.mpl_connect('axes_enter_event', self.on_enter)
+        else:
+            self.cid = latent_axes[0].figure.canvas.mpl_connect('button_press_event', self.on_click)
+            self.cid = latent_axes[0].figure.canvas.mpl_connect('motion_notify_event', self.on_move)
+            self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_leave_event', self.on_leave)
+            self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_enter_event', self.on_enter)
+
+        self.data_visualize = data_visualize
+        self.model = model
+        self.latent_axes = latent_axes
+
+        self.called = False
+        self.move_on = False
+        self.latent_index = latent_index
+        self.latent_dim = model.Q
+
+        # The red cross which shows current latent point.        
+        self.latent_values = vals
+        self.latent_handle = self.latent_axes.plot([0],[0],'rx',mew=2)[0]
+        self.modify(vals)
+
+    def modify(self, vals):
+        """When latent values are modified update the latent representation and ulso update the output visualization."""
+        
+        y = self.model.predict(vals)[0]
+        self.data_visualize.modify(y)
+        self.latent_handle.set_data(vals[self.latent_index[0]], vals[self.latent_index[1]])
+        self.axes.figure.canvas.draw()
+
+
+    def on_enter(self,event):
+        pass
+    def on_leave(self,event):
+        pass
+
+    def on_click(self, event):
+        if event.inaxes!=self.latent_axes: return
+        self.move_on = not self.move_on
+        self.called = True
+    def on_move(self, event):
+        if event.inaxes!=self.latent_axes: return
+        if self.called and self.move_on:
+            # Call modify code on move
+            self.latent_values[self.latent_index[0]]=event.xdata
+            self.latent_values[self.latent_index[1]]=event.ydata            
+            self.modify(self.latent_values)
+
+class lvm_subplots(lvm):
+    """
+    latent_axes is a np array of dimension np.ceil(Q/2) + 1,
+    one for each pair of the axes, and the last one for the sensitiity bar chart
+    """
+    def __init__(self, vals, model, data_visualize, latent_axes=None, latent_index=[0,1]):
+        lvm.__init__(self, vals, model,data_visualize,latent_axes,[0,1])
+        self.nplots = int(np.ceil(model.Q/2.))+1
+        lvm.__init__(self,model,data_visualize,latent_axes,latent_index)
+        self.latent_values = np.zeros(2*np.ceil(self.model.Q/2.)) # possibly an extra dimension on this
+        assert latent_axes.size == self.nplots
+
+
+class lvm_dimselect(lvm):
+    """
+    A visualizer for latent variable models which allows selection of the latent dimensions to use by clicking on a bar chart of their length scales.
+    """
+    def __init__(self, vals, model, data_visualize, latent_axes=None, sense_axes=None, latent_index=[0, 1]):
+        if latent_axes==None and sense_axes==None:
+            self.fig,(latent_axes,self.sense_axes) = plt.subplots(1,2)
+        elif sense_axes==None:
+            fig=plt.figure()
+            self.sense_axes = fig.add_subplot(111)
+        else:
+            self.sense_axes = sense_axes
+        
+        lvm.__init__(self,vals,model,data_visualize,latent_axes,latent_index)
+        self.show_sensitivities()
+        print "use left and right mouse butons to select dimensions"
+
+    def show_sensitivities(self):
+        # A click in the bar chart axis for selection a dimension.
+        self.sense_axes.cla()
+        self.sense_axes.bar(np.arange(self.model.Q),1./self.model.input_sensitivity(),color='b')
+
+        if self.latent_index[1] == self.latent_index[0]:
+            self.sense_axes.bar(np.array(self.latent_index[0]),1./self.model.input_sensitivity()[self.latent_index[0]],color='y')
+            self.sense_axes.bar(np.array(self.latent_index[1]),1./self.model.input_sensitivity()[self.latent_index[1]],color='y')
+            
+        else:
+            self.sense_axes.bar(np.array(self.latent_index[0]),1./self.model.input_sensitivity()[self.latent_index[0]],color='g')
+            self.sense_axes.bar(np.array(self.latent_index[1]),1./self.model.input_sensitivity()[self.latent_index[1]],color='r')
+
+        self.sense_axes.figure.canvas.draw()
+
+    def on_click(self, event):
+
+        if event.inaxes==self.sense_axes:
+            new_index = max(0,min(int(np.round(event.xdata-0.5)),self.model.Q-1))
+            if event.button == 1:
+                # Make it red if and y-axis (red=port=left) if it is a left button click
+                self.latent_index[1] = new_index                
+            else:
+                # Make it green and x-axis (green=starboard=right) if it is a right button click
+                self.latent_index[0] = new_index
+                
+            self.show_sensitivities()
+
+            self.latent_axes.cla()
+            self.model.plot_latent(which_indices=self.latent_index,
+                                   ax=self.latent_axes)
+            self.latent_handle = self.latent_axes.plot([0],[0],'rx',mew=2)[0]
+            self.modify(self.latent_values)
+
+        elif event.inaxes==self.latent_axes:
+            self.move_on = not self.move_on
+
+        self.called = True
+
+
+    def on_move(self, event):
+        if event.inaxes!=self.latent_axes: return
+        if self.called and self.move_on:
+            self.latent_values[self.latent_index[0]]=event.xdata
+            self.latent_values[self.latent_index[1]]=event.ydata            
+            self.modify(self.latent_values)
+
+    def on_leave(self,event):
+        latent_values = self.latent_values.copy()
+        y = self.model.predict(latent_values[None,:])[0]
+        self.data_visualize.modify(y)
+
+
+
+
+
+
+
 class image_show(data_show):
     """Show a data vector as an image."""
     def __init__(self, vals, axes=None, dimensions=(16,16), transpose=False, invert=False, scale=False):
@@ -269,12 +309,24 @@ class stick_show(mocap_data_show):
 class skeleton_show(mocap_data_show):
     """data_show class for visualizing motion capture data encoded as a skeleton with angles."""
     def __init__(self, vals, skel, padding=0, axes=None):
+        """data_show class for visualizing motion capture data encoded as a skeleton with angles.
+        :param vals: set of modeled angles to use for printing in the axis when it's first created.
+        :type vals: np.array
+        :param skel: skeleton object that has the parameters of the motion capture skeleton associated with it.
+        :type skel: mocap.skeleton object 
+        :param padding:
+        :type int
+        """
         self.skel = skel
         self.padding = padding
         connect = skel.connection_matrix()
         mocap_data_show.__init__(self, vals, axes, connect)
 
     def process_values(self, vals):
+        """Takes a set of angles and converts them to the x,y,z coordinates in the internal prepresentation of the class, ready for plotting.
+
+        :param vals: the values that are being modelled."""
+        
         if self.padding>0:
             channels = np.zeros((vals.shape[0], vals.shape[1]+self.padding))
             channels[:, 0:vals.shape[0]] = vals
@@ -296,3 +348,27 @@ class skeleton_show(mocap_data_show):
                 if nVals[i] != nVals[j]:
                     connect[i, j] = False
         return vals, connect
+
+
+def data_play(Y, visualizer, frame_rate=30):
+    """Play a data set using the data_show object given.
+
+    :Y: the data set to be visualized.
+    :param visualizer: the data show objectwhether to display during optimisation
+    :type visualizer: data_show
+
+    Example usage:
+
+    This example loads in the CMU mocap database (http://mocap.cs.cmu.edu) subject number 35 motion number 01. It then plays it using the mocap_show visualize object.
+    
+    data = GPy.util.datasets.cmu_mocap(subject='35', train_motions=['01'])
+    Y = data['Y']
+    Y[:, 0:3] = 0.   # Make figure walk in place
+    visualize = GPy.util.visualize.skeleton_show(Y[0, :], data['skel'])
+    GPy.util.visualize.data_play(Y, visualize)
+    """
+    
+
+    for y in Y:
+        visualizer.modify(y)
+        time.sleep(1./float(frame_rate))