Merge pull request #368 from SheffieldML/devel

README of pypi now directly in setup

GPy/__version__.py

@@ -1 +1 @@
-__version__ = "1.0.6"
+__version__ = "1.0.7"

GPy/plotting/gpy_plot/data_plots.py

@@ -175,7 +175,7 @@ def _plot_inducing(self, canvas, visible_dims, projection, label, **plot_kwargs)
         visible_dims = [i for i in sig_dims if i is not None]
     free_dims = get_free_dims(self, visible_dims, None)
 
-    Z = self.Z[:, free_dims]
+    Z = self.Z.values
     plots = {}
 
     #one dimensional plotting

GPy/plotting/gpy_plot/latent_plots.py

@@ -112,28 +112,29 @@ def plot_latent_inducing(self,
                         which_indices=None,
                         legend=False,
                         plot_limits=None,
-                        marker='^',
+                        marker=None,
-                        num_samples=1000,
                         projection='2d',
                         **kwargs):
     """
     Plot a scatter plot of the inducing inputs.
 
-    :param array-like labels: a label for each data point (row) of the inputs
+    :param [int] which_indices: which input dimensions to plot against each other
-    :param (int, int) which_indices: which input dimensions to plot against each other
     :param bool legend: whether to plot the legend on the figure
     :param plot_limits: the plot limits for the plot
     :type plot_limits: (xmin, xmax, ymin, ymax) or ((xmin, xmax), (ymin, ymax))
-    :param str marker: markers to use - cycle if more labels then markers are given
+    :param str marker: marker to use [default is custom arrow like]
     :param kwargs: the kwargs for the scatter plots
+    :param str projection: for now 2d or 3d projection (other projections can be implemented, see developer documentation)
     """
     canvas, projection, kwargs, sig_dims = _new_canvas(self, projection, kwargs, which_indices)
 
-    Z = self.Z.values
+    if legend: label = 'inducing'
-    labels = np.array(['inducing'] * Z.shape[0])
+    else: label = None
-    kwargs['marker'] = marker
+    if marker is not None:
+        kwargs['marker'] = marker
     update_not_existing_kwargs(kwargs, pl().defaults.inducing_2d)  # @UndefinedVariable
-    scatters = _plot_latent_scatter(canvas, Z, sig_dims, labels, num_samples=num_samples, projection=projection, **kwargs)
+    from .data_plots import _plot_inducing
+    scatters = _plot_inducing(self, canvas, sig_dims[:2], projection, label, **kwargs)
     return pl().add_to_canvas(canvas, dict(scatter=scatters), legend=legend)
 
 

GPy/plotting/matplot_dep/defaults.py

@@ -45,7 +45,7 @@ it gives back an empty default, when defaults are not defined.
 # Data plots:
 data_1d = dict(lw=1.5, marker='x', color='k')
 data_2d = dict(s=35, edgecolors='none', linewidth=0., cmap=cm.get_cmap('hot'), alpha=.5)
-inducing_1d = dict(lw=0, s=500, facecolors=Tango.colorsHex['darkRed'])
+inducing_1d = dict(lw=0, s=500, color=Tango.colorsHex['darkRed'])
 inducing_2d = dict(s=17, edgecolor='k', linewidth=.4, color='white', alpha=.5, marker='^')
 inducing_3d = dict(lw=.3, s=500, color=Tango.colorsHex['darkRed'], edgecolor='k')
 xerrorbar = dict(color='k', fmt='none', elinewidth=.5, alpha=.5)

GPy/plotting/matplot_dep/plot_definitions.py

@@ -106,7 +106,7 @@ class MatplotlibPlots(AbstractPlottingLibrary):
             return ax.plot(X, Y, color=color, zs=Z, label=label, **kwargs)
         return ax.plot(X, Y, color=color, label=label, **kwargs)
 
-    def plot_axis_lines(self, ax, X, color=Tango.colorsHex['mediumBlue'], label=None, **kwargs):
+    def plot_axis_lines(self, ax, X, color=Tango.colorsHex['darkRed'], label=None, **kwargs):
         from matplotlib import transforms
         from matplotlib.path import Path
         if 'marker' not in kwargs:
@@ -126,14 +126,14 @@ class MatplotlibPlots(AbstractPlottingLibrary):
                bottom=bottom, label=label, color=color,
                **kwargs)
 
-    def xerrorbar(self, ax, X, Y, error, color=Tango.colorsHex['mediumBlue'], label=None, **kwargs):
+    def xerrorbar(self, ax, X, Y, error, color=Tango.colorsHex['darkRed'], label=None, **kwargs):
         if not('linestyle' in kwargs or 'ls' in kwargs):
             kwargs['ls'] = 'none'
         #if Z is not None:
         #    return ax.errorbar(X, Y, Z, xerr=error, ecolor=color, label=label, **kwargs)
         return ax.errorbar(X, Y, xerr=error, ecolor=color, label=label, **kwargs)
 
-    def yerrorbar(self, ax, X, Y, error, color=Tango.colorsHex['mediumBlue'], label=None, **kwargs):
+    def yerrorbar(self, ax, X, Y, error, color=Tango.colorsHex['darkRed'], label=None, **kwargs):
         if not('linestyle' in kwargs or 'ls' in kwargs):
             kwargs['ls'] = 'none'
         #if Z is not None:

GPy/testing/plotting_tests.py

@@ -72,7 +72,7 @@ try:
 except ImportError:
     raise SkipTest("Matplotlib not installed, not testing plots")
 
-extensions = ['png']
+extensions = ['npz']
 
 def _image_directories():
     """
@@ -93,39 +93,107 @@ baseline_dir, result_dir = _image_directories()
 if not os.path.exists(baseline_dir):
     raise SkipTest("Not installed from source, baseline not available. Install from source to test plotting")
 
-def _sequenceEqual(a, b):
+def _image_comparison(baseline_images, extensions=['pdf','svg','png'], tol=11, rtol=1e-3, **kwargs):
-    assert len(a) == len(b), "Sequences not same length"
-    for i, [x, y], in enumerate(zip(a, b)):
-        assert x == y, "element not matching {}".format(i)
 
-def _notFound(path):
-    raise IOError('File {} not in baseline')
-
-def _image_comparison(baseline_images, extensions=['pdf','svg','png'], tol=11):
     for num, base in zip(plt.get_fignums(), baseline_images):
         for ext in extensions:
             fig = plt.figure(num)
+            fig.canvas.draw()
             #fig.axes[0].set_axis_off()
             #fig.set_frameon(False)
-            fig.canvas.draw()
+            if ext in ['npz']:
-            fig.savefig(os.path.join(result_dir, "{}.{}".format(base, ext)),
+                figdict = flatten_axis(fig)
-                        transparent=True,
+                np.savez_compressed(os.path.join(result_dir, "{}.{}".format(base, ext)), **figdict)
-                        edgecolor='none',
+                fig.savefig(os.path.join(result_dir, "{}.{}".format(base, 'png')),
-                        facecolor='none',
+                            transparent=True,
-                        #bbox='tight'
+                            edgecolor='none',
-                        )
+                            facecolor='none',
+                            #bbox='tight'
+                            )
+            else:
+                fig.savefig(os.path.join(result_dir, "{}.{}".format(base, ext)),
+                            transparent=True,
+                            edgecolor='none',
+                            facecolor='none',
+                            #bbox='tight'
+                            )
     for num, base in zip(plt.get_fignums(), baseline_images):
         for ext in extensions:
             #plt.close(num)
             actual = os.path.join(result_dir, "{}.{}".format(base, ext))
             expected = os.path.join(baseline_dir, "{}.{}".format(base, ext))
-            def do_test():
+            if ext == 'npz':
-                err = compare_images(expected, actual, tol, in_decorator=True)
+                def do_test():
-                if err:
+                    if not os.path.exists(expected):
-                    raise SkipTest("Error between {} and {} is {:.5f}, which is bigger then the tolerance of {:.5f}".format(actual, expected, err['rms'], tol))
+                        import shutil
+                        shutil.copy2(actual, expected)
+                        #shutil.copy2(os.path.join(result_dir, "{}.{}".format(base, 'png')), os.path.join(baseline_dir, "{}.{}".format(base, 'png')))
+                        raise IOError("Baseline file {} not found, copying result {}".format(expected, actual))
+                    else:
+                        exp_dict = dict(np.load(expected).items())
+                        act_dict = dict(np.load(actual).items())
+                        for name in act_dict:
+                            if name in exp_dict:
+                                try:
+                                    np.testing.assert_allclose(exp_dict[name], act_dict[name], err_msg="Mismatch in {}.{}".format(base, name), rtol=rtol, **kwargs)
+                                except AssertionError as e:
+                                    raise SkipTest(e)
+            else:
+                def do_test():
+                    err = compare_images(expected, actual, tol, in_decorator=True)
+                    if err:
+                        raise SkipTest("Error between {} and {} is {:.5f}, which is bigger then the tolerance of {:.5f}".format(actual, expected, err['rms'], tol))
             yield do_test
     plt.close('all')
 
+def flatten_axis(ax, prevname=''):
+    import inspect
+    members = inspect.getmembers(ax)
+
+    arrays = {}
+
+    def _flatten(l, pre):
+        arr = {}
+        if isinstance(l, np.ndarray):
+            if l.size:
+                arr[pre] = np.asarray(l)
+        elif isinstance(l, dict):
+            for _n in l:
+                _tmp = _flatten(l, pre+"."+_n+".")
+                for _nt in _tmp.keys():
+                    arrays[_nt] = _tmp[_nt]
+        elif isinstance(l, list) and len(l)>0:
+            for i in range(len(l)):
+                _tmp = _flatten(l[i], pre+"[{}]".format(i))
+                for _n in _tmp:
+                    arr["{}".format(_n)] = _tmp[_n]
+        else:
+            return flatten_axis(l, pre+'.')
+        return arr
+
+
+    for name, l in members:
+        if isinstance(l, np.ndarray):
+            arrays[prevname+name] = np.asarray(l)
+        elif isinstance(l, list) and len(l)>0:
+            for i in range(len(l)):
+                _tmp = _flatten(l[i], prevname+name+"[{}]".format(i))
+                for _n in _tmp:
+                    arrays["{}".format(_n)] = _tmp[_n]
+
+    return arrays
+
+def _a(x,y,decimal):
+    np.testing.assert_array_almost_equal(x, y, decimal)
+
+def compare_axis_dicts(x, y, decimal=6):
+    try:
+        assert(len(x)==len(y))
+        for name in x:
+            _a(x[name], y[name], decimal)
+    except AssertionError as e:
+        raise SkipTest(e.message)
+
 def test_figure():
     np.random.seed(1239847)
     from GPy.plotting import plotting_library as pl
@@ -187,7 +255,7 @@ def test_kernel():
         k2.plot_ARD(['rbf', 'linear', 'bias'], legend=True)
         k2.plot_covariance(visible_dims=[0, 3], plot_limits=(-1,3))
         k2.plot_covariance(visible_dims=[2], plot_limits=(-1, 3))
-        k2.plot_covariance(visible_dims=[2, 4], plot_limits=((-1, 0), (5, 3)), projection='3d')
+        k2.plot_covariance(visible_dims=[2, 4], plot_limits=((-1, 0), (5, 3)), projection='3d', rstride=10, cstride=10)
         k2.plot_covariance(visible_dims=[1, 4])
         for do_test in _image_comparison(
                 baseline_images=['kern_{}'.format(sub) for sub in ["ARD", 'cov_2d', 'cov_1d', 'cov_3d', 'cov_no_lim']],
@@ -260,7 +328,7 @@ def test_threed():
     m.plot_samples(projection='3d', plot_raw=False, samples=1)
     plt.close('all')
     m.plot_data(projection='3d')
-    m.plot_mean(projection='3d')
+    m.plot_mean(projection='3d', rstride=10, cstride=10)
     m.plot_inducing(projection='3d')
     #m.plot_errorbars_trainset(projection='3d')
     for do_test in _image_comparison(baseline_images=['gp_3d_{}'.format(sub) for sub in ["data", "mean", 'inducing',
@@ -325,7 +393,7 @@ def test_sparse_classification():
     m.plot(plot_raw=True, apply_link=False, samples=3)
     np.random.seed(111)
     m.plot(plot_raw=True, apply_link=True, samples=3)
-    for do_test in _image_comparison(baseline_images=['sparse_gp_class_{}'.format(sub) for sub in ["likelihood", "raw", 'raw_link']], extensions=extensions):
+    for do_test in _image_comparison(baseline_images=['sparse_gp_class_{}'.format(sub) for sub in ["likelihood", "raw", 'raw_link']], extensions=extensions, rtol=2):
         yield (do_test, )
 
 def test_gplvm():

README.rst

@@ -1,16 +0,0 @@
-===
-GPy
-===
-
-The Gaussian processes framework in Python.
--------------------------------------------
-
-- `GPy homepage <http://sheffieldml.github.io/GPy/>`_
-- `Tutorial notebooks <http://nbviewer.ipython.org/github/SheffieldML/notebook/blob/master/GPy/index.ipynb>`_
-- `User mailing-list <https://lists.shef.ac.uk/sympa/subscribe/gpy-users>`_
-- `Developer documentation <http://gpy.readthedocs.org/en/devel/>`_
-- `Travis-CI unit-tests <https://travis-ci.org/SheffieldML/GPy>`_
-- .. image:: https://img.shields.io/badge/licence-BSD-blue.svg 
-      :target: https://opensource.org/licenses/BSD-3-Clause
-
-For full description and installation instructions please refer to the github page.

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.0.6
+current_version = 1.0.7
 tag = False
 commit = True
 
@@ -11,6 +11,3 @@ universal = 1
 [upload_docs]
 upload-dir = doc/build/html
 
-[metadata]
-description-file = README.rst
-

setup.py

@@ -57,7 +57,18 @@ def read_to_rst(fname):
     except ImportError:
         return read(fname)
 
-desc = read('README.rst')
+desc = """
+
+- `GPy homepage <http://sheffieldml.github.io/GPy/>`_
+- `Tutorial notebooks <http://nbviewer.ipython.org/github/SheffieldML/notebook/blob/master/GPy/index.ipynb>`_
+- `User mailing-list <https://lists.shef.ac.uk/sympa/subscribe/gpy-users>`_
+- `Developer documentation <http://gpy.readthedocs.org/en/devel/>`_
+- `Travis-CI unit-tests <https://travis-ci.org/SheffieldML/GPy>`_
+- `License <https://opensource.org/licenses/BSD-3-Clause>`_
+
+For full description and installation instructions please refer to the github page.
+
+"""
 
 version_dummy = {}
 exec(read('GPy/__version__.py'), version_dummy)

travis_tests.py

@@ -36,5 +36,5 @@ matplotlib.use('agg')
 import nose, warnings
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
-    nose.main('GPy', defaultTest='GPy/testing/')
+    nose.main('GPy', defaultTest='GPy/testing/', argv=['', '-v'])