apunkt/GPy
1
0
Fork 0
mirror of https://github.com/SheffieldML/GPy.git synced 2026-05-04 01:02:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

[plotly] starting plotly

Browse source
This commit is contained in:
mzwiessele 2015-10-07 11:35:23 +01:00
parent cbb06f3efc
commit e0d48a0558
18 changed files with 120 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

2
GPy/plotting/gpy_plot/__init__.py
View file

@ -1,3 +1,3 @@
from .. import plotting_library as pl
from . import data_plots, gp_plots, latent_plots, kernel_plots, plot_util
from . import data_plots, gp_plots, latent_plots, kernel_plots, plot_util, inference_plots

8
GPy/plotting/gpy_plot/data_plots.py
View file

@ -54,7 +54,7 @@ def plot_data(self, which_data_rows='all',
:returns list: of plots created.
"""
canvas, plot_kwargs = pl.get_new_canvas(projection=projection, **plot_kwargs)
canvas, plot_kwargs = pl.new_canvas(projection=projection, **plot_kwargs)
plots = _plot_data(self, canvas, which_data_rows, which_data_ycols, visible_dims, projection, label, **plot_kwargs)
return pl.show_canvas(canvas, plots)
@ -117,7 +117,7 @@ def plot_data_error(self, which_data_rows='all',
:returns list: of plots created.
"""
canvas, error_kwargs = pl.get_new_canvas(projection=='3d', **error_kwargs)
canvas, error_kwargs = pl.new_canvas(projection=='3d', **error_kwargs)
plots = _plot_data_error(self, canvas, which_data_rows, which_data_ycols, visible_dims, projection, label, **error_kwargs)
return pl.show_canvas(canvas, plots)
@ -165,7 +165,7 @@ def plot_inducing(self, visible_dims=None, projection='2d', label=None, **plot_k
:param array-like visible_dims: an array specifying the input dimensions to plot (maximum two)
:param kwargs plot_kwargs: keyword arguments for the plotting library
"""
canvas, kwargs = pl.get_new_canvas(projection=projection, **plot_kwargs)
canvas, kwargs = pl.new_canvas(projection=projection, **plot_kwargs)
plots = _plot_inducing(self, canvas, visible_dims, projection, label, **kwargs)
return pl.show_canvas(canvas, plots)
@ -217,7 +217,7 @@ def plot_errorbars_trainset(self, which_data_rows='all',
:param dict predict_kwargs: kwargs for the prediction used to predict the right quantiles.
:param kwargs plot_kwargs: kwargs for the data plot for the plotting library you are using
"""
canvas, kwargs = pl.get_new_canvas(projection=projection, **plot_kwargs)
canvas, kwargs = pl.new_canvas(projection=projection, **plot_kwargs)
plots = _plot_errorbars_trainset(self, canvas, which_data_rows, which_data_ycols,
fixed_inputs, plot_raw, apply_link, label, projection, predict_kw, **kwargs)
return pl.show_canvas(canvas, plots)

12
GPy/plotting/gpy_plot/gp_plots.py
View file

@ -62,7 +62,7 @@ def plot_mean(self, plot_limits=None, fixed_inputs=None,
:param str label: the label for the plot.
:param dict predict_kw: the keyword arguments for the prediction. If you want to plot a specific kernel give dict(kern=<specific kernel>) in here
"""
canvas, kwargs = pl.get_new_canvas(projection=projection, **kwargs)
canvas, kwargs = pl.new_canvas(projection=projection, **kwargs)
plots = _plot_mean(self, canvas, plot_limits, fixed_inputs,
resolution, plot_raw,
apply_link, visible_dims, which_data_ycols,
@ -131,7 +131,7 @@ def plot_confidence(self, lower=2.5, upper=97.5, plot_limits=None, fixed_inputs=
:param array-like which_data_ycols: which columns of the output y (!) to plot (array-like or list of ints)
:param dict predict_kw: the keyword arguments for the prediction. If you want to plot a specific kernel give dict(kern=<specific kernel>) in here
"""
canvas, kwargs = pl.get_new_canvas(**kwargs)
canvas, kwargs = pl.new_canvas(**kwargs)
plots = _plot_confidence(self, canvas, lower, upper, plot_limits,
fixed_inputs, resolution, plot_raw,
apply_link, visible_dims, which_data_ycols,
@ -190,7 +190,7 @@ def plot_samples(self, plot_limits=None, fixed_inputs=None,
:param dict predict_kw: the keyword arguments for the prediction. If you want to plot a specific kernel give dict(kern=<specific kernel>) in here
:param int levels: for 2D plotting, the number of contour levels to use is
"""
canvas, kwargs = pl.get_new_canvas(projection=projection, **kwargs)
canvas, kwargs = pl.new_canvas(projection=projection, **kwargs)
plots = _plot_samples(self, canvas, plot_limits, fixed_inputs,
resolution, plot_raw,
apply_link, visible_dims, which_data_ycols, samples, projection,
@ -253,7 +253,7 @@ def plot_density(self, plot_limits=None, fixed_inputs=None,
:param int levels: the number of levels in the density (number bigger then 1, where 35 is smooth and 1 is the same as plot_confidence). You can go higher then 50 if the result is not smooth enough for you.
:param dict predict_kw: the keyword arguments for the prediction. If you want to plot a specific kernel give dict(kern=<specific kernel>) in here
"""
canvas, kwargs = pl.get_new_canvas(**kwargs)
canvas, kwargs = pl.new_canvas(**kwargs)
plots = _plot_density(self, canvas, plot_limits,
fixed_inputs, resolution, plot_raw,
apply_link, visible_dims, which_data_ycols,
@ -326,7 +326,7 @@ def plot(self, plot_limits=None, fixed_inputs=None,
:param bool plot_density: plot density instead of the confidence interval?
:param dict predict_kw: the keyword arguments for the prediction. If you want to plot a specific kernel give dict(kern=<specific kernel>) in here
"""
canvas, _ = pl.get_new_canvas(projection=projection, **kwargs)
canvas, _ = pl.new_canvas(projection=projection, **kwargs)
plots = _plot(self, canvas, plot_limits, fixed_inputs, resolution, plot_raw,
apply_link, which_data_ycols, which_data_rows, visible_dims,
levels, samples, samples_likelihood, lower, upper, plot_data,
@ -375,7 +375,7 @@ def plot_f(self, plot_limits=None, fixed_inputs=None,
:param dict error_kwargs: kwargs for the error plot for the plotting library you are using
:param kwargs plot_kwargs: kwargs for the data plot for the plotting library you are using
"""
canvas, _ = pl.get_new_canvas(projection=='3d', **kwargs)
canvas, _ = pl.new_canvas(projection=='3d', **kwargs)
plots = _plot(self, canvas, plot_limits, fixed_inputs, resolution,
True, apply_link, which_data_ycols, which_data_rows,
visible_dims, levels, samples, 0, lower, upper,

28
GPy/plotting/gpy_plot/inference_plots.py Normal file
View file

@ -0,0 +1,28 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
#import numpy as np
#import Tango
#from base_plots import gpplot, x_frame1D, x_frame2D
from . import pl
def plot_optimizer(optimizer, **kwargs):
if optimizer.trace == None:
print("No trace present so I can't plot it. Please check that the optimizer actually supplies a trace.")
else:
canvas, kwargs = pl.new_canvas(**kwargs)
plots = dict(trace=pl.plot(range(len(optimizer.trace)), optimizer.trace))
return pl.show_canvas(canvas, plots, xlabel='Iteration', ylabel='f(x)')
def plot_sgd_traces(optimizer):
figure = pl.figure(2,1)
canvas, _ = pl.new_canvas(figure, 1, 1, title="Parameters")
plots = dict(lines=[])
for k in optimizer.param_traces.keys():
plots['lines'].append(pl.plot(canvas, range(len(optimizer.param_traces[k])), optimizer.param_traces[k], label=k))
pl.show_canvas(canvas, legend=True)
canvas, _ = pl.new_canvas(figure, 1, 2, title="Objective function")
pl.plot(canvas, range(len(optimizer.fopt_trace)), optimizer.fopt_trace)
return pl.show_canvas(canvas, plots, legend=True)

2
GPy/plotting/gpy_plot/kernel_plots.py
View file

@ -41,7 +41,7 @@ def plot_ARD(kernel, filtering=None, **kwargs):
will be used for plotting.
:type filtering: list of names to use for ARD plot
"""
canvas, kwargs = pl.get_new_canvas(kwargs)
canvas, kwargs = pl.new_canvas(kwargs)
Tango.reset()

92
GPy/plotting/gpy_plot/latent_plots.py
View file

@ -29,8 +29,8 @@
#===============================================================================
import numpy as np
from . import pl
from .plot_util import get_x_y_var, get_which_data_ycols,\
get_which_data_rows, update_not_existing_kwargs, helper_predict_with_model,\
from .plot_util import get_x_y_var,\
update_not_existing_kwargs, \
helper_for_plot_data, scatter_label_generator, subsample_X,\
find_best_layout_for_subplots
@ -83,7 +83,10 @@ def plot_latent_scatter(self, labels=None,
"""
input_1, input_2, input_3 = sig_dims = self.get_most_significant_input_dimensions(which_indices)
canvas, kwargs = pl.get_new_canvas(projection=projection, **kwargs)
canvas, kwargs = pl.new_canvas(projection=projection,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
zlabel='latent dimension %i' % input_3, **kwargs)
X, _, _ = get_x_y_var(self)
if labels is None:
labels = np.ones(self.num_data)
@ -91,17 +94,7 @@ def plot_latent_scatter(self, labels=None,
else:
legend = find_best_layout_for_subplots(len(np.unique(labels)))[1]
scatters = _plot_latent_scatter(canvas, X, sig_dims, labels, marker, num_samples, projection=projection, **kwargs)
if projection == '3d':
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
zlabel='latent dimension %i' % input_3)
else:
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
#zlabel='latent dimension %i' % input_3
)
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend)
def plot_latent_inducing(self,
which_indices=None,
legend=False,
@ -125,24 +118,17 @@ def plot_latent_inducing(self,
if 'color' not in kwargs:
kwargs['color'] = 'white'
canvas, kwargs = pl.get_new_canvas(projection=projection, **kwargs)
canvas, kwargs = pl.new_canvas(projection=projection,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
zlabel='latent dimension %i' % input_3, **kwargs)
Z = self.Z.values
labels = np.array(['inducing'] * Z.shape[0])
scatters = _plot_latent_scatter(canvas, Z, sig_dims, labels, marker, num_samples, projection=projection, **kwargs)
if projection == '3d':
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
zlabel='latent dimension %i' % input_3)
else:
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend,
xlabel='latent dimension %i' % input_1,
ylabel='latent dimension %i' % input_2,
#zlabel='latent dimension %i' % input_3
)
return pl.show_canvas(canvas, dict(scatter=scatters), legend=legend)
def _plot_magnification(self, canvas, which_indices, Xgrid,
xmin, xmax, resolution,
xmin, xmax, resolution, updates,
mean=True, covariance=True,
kern=None,
**imshow_kwargs):
@ -153,9 +139,11 @@ def _plot_magnification(self, canvas, which_indices, Xgrid,
return mf.reshape(resolution, resolution).T
imshow_kwargs = update_not_existing_kwargs(imshow_kwargs, pl.defaults.magnification)
try:
return pl.imshow_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, **imshow_kwargs)
if updates:
return pl.imshow_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, **imshow_kwargs)
else: raise NotImplementedError
except NotImplementedError:
return pl.imshow(canvas, plot_function(Xgrid), (xmin[0], xmax[0], xmin[1], xmax[1]), **imshow_kwargs)
return pl.imshow(canvas, plot_function(Xgrid[:, which_indices]), (xmin[0], xmax[0], xmin[1], xmax[1]), **imshow_kwargs)
def plot_magnification(self, labels=None, which_indices=None,
resolution=60, marker='<>^vsd', legend=True,
@ -184,19 +172,19 @@ def plot_magnification(self, labels=None, which_indices=None,
:param kwargs: the kwargs for the scatter plots
"""
input_1, input_2 = which_indices = self.get_most_significant_input_dimensions(which_indices)[:2]
canvas, imshow_kwargs = pl.get_new_canvas(**imshow_kwargs)
X, _, _, _, _, Xgrid, _, _, xmin, xmax, resolution = helper_for_plot_data(self, plot_limits, which_indices, None, resolution)
canvas, imshow_kwargs = pl.new_canvas(xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2, **imshow_kwargs)
if (labels is not None):
legend = find_best_layout_for_subplots(len(np.unique(labels)))[1]
else:
labels = np.ones(self.num_data)
legend = False
scatters = _plot_latent_scatter(canvas, X, which_indices, labels, marker, num_samples, projection='2d', **scatter_kwargs or {})
view = _plot_magnification(self, canvas, which_indices[:2], Xgrid, xmin, xmax, resolution, mean, covariance, kern, **imshow_kwargs)
view = _plot_magnification(self, canvas, which_indices[:2], Xgrid, xmin, xmax, resolution, updates, mean, covariance, kern, **imshow_kwargs)
plots = pl.show_canvas(canvas, dict(scatter=scatters, imshow=view),
legend=legend,
xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2)
)
_wait_for_updates(view, updates)
return plots
@ -204,7 +192,7 @@ def plot_magnification(self, labels=None, which_indices=None,
def _plot_latent(self, canvas, which_indices, Xgrid,
xmin, xmax, resolution,
xmin, xmax, resolution, updates,
kern=None,
**imshow_kwargs):
def plot_function(x):
@ -215,9 +203,11 @@ def _plot_latent(self, canvas, which_indices, Xgrid,
imshow_kwargs = update_not_existing_kwargs(imshow_kwargs, pl.defaults.latent)
try:
return pl.imshow_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, **imshow_kwargs)
if updates:
return pl.imshow_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, **imshow_kwargs)
else: raise NotImplementedError
except NotImplementedError:
return pl.imshow(canvas, plot_function(Xgrid), (xmin[0], xmax[0], xmin[1], xmax[1]), **imshow_kwargs)
return pl.imshow(canvas, plot_function(Xgrid[:, which_indices]), (xmin[0], xmax[0], xmin[1], xmax[1]), **imshow_kwargs)
def plot_latent(self, labels=None, which_indices=None,
resolution=60, legend=True,
@ -245,24 +235,22 @@ def plot_latent(self, labels=None, which_indices=None,
:param scatter_kwargs: the kwargs for the scatter plots
"""
input_1, input_2 = which_indices = self.get_most_significant_input_dimensions(which_indices)[:2]
canvas, imshow_kwargs = pl.get_new_canvas(**imshow_kwargs)
X, _, _, _, _, Xgrid, _, _, xmin, xmax, resolution = helper_for_plot_data(self, plot_limits, which_indices, None, resolution)
canvas, imshow_kwargs = pl.new_canvas(xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2, **imshow_kwargs)
if (labels is not None):
legend = find_best_layout_for_subplots(len(np.unique(labels)))[1]
else:
labels = np.ones(self.num_data)
legend = False
scatters = _plot_latent_scatter(canvas, X, which_indices, labels, marker, num_samples, projection='2d', **scatter_kwargs or {})
view = _plot_latent(self, canvas, which_indices, Xgrid, xmin, xmax, resolution, kern, **imshow_kwargs)
plots = pl.show_canvas(canvas, dict(scatter=scatters, imshow=view),
legend=legend,
xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2)
view = _plot_latent(self, canvas, which_indices, Xgrid, xmin, xmax, resolution, updates, kern, **imshow_kwargs)
plots = pl.show_canvas(canvas, dict(scatter=scatters, imshow=view), legend=legend)
_wait_for_updates(view, updates)
return plots
def _plot_steepest_gradient_map(self, canvas, which_indices, Xgrid,
xmin, xmax, resolution, output_labels,
xmin, xmax, resolution, output_labels, updates,
kern=None, annotation_kwargs=None,
**imshow_kwargs):
if output_labels is None:
@ -276,9 +264,12 @@ def _plot_steepest_gradient_map(self, canvas, which_indices, Xgrid,
annotation_kwargs = update_not_existing_kwargs(annotation_kwargs or {}, pl.defaults.annotation)
imshow_kwargs = update_not_existing_kwargs(imshow_kwargs or {}, pl.defaults.gradient)
try:
return dict(annotation=pl.annotation_heatmap_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, imshow_kwargs=imshow_kwargs, **annotation_kwargs))
if updates:
return dict(annotation=pl.annotation_heatmap_interact(canvas, plot_function, (xmin[0], xmax[0], xmin[1], xmax[1]), resolution=resolution, imshow_kwargs=imshow_kwargs, **annotation_kwargs))
else:
raise NotImplementedError
except NotImplementedError:
imshow, annotation = pl.annotation_heatmap(canvas, *plot_function(Xgrid), extent=(xmin[0], xmax[0], xmin[1], xmax[1]), imshow_kwargs=imshow_kwargs, **annotation_kwargs)
imshow, annotation = pl.annotation_heatmap(canvas, *plot_function(Xgrid[:, which_indices]), extent=(xmin[0], xmax[0], xmin[1], xmax[1]), imshow_kwargs=imshow_kwargs, **annotation_kwargs)
return dict(heatmap=imshow, annotation=annotation)
def plot_steepest_gradient_map(self, output_labels=None, data_labels=None, which_indices=None,
@ -309,20 +300,19 @@ def plot_steepest_gradient_map(self, output_labels=None, data_labels=None, which
:param scatter_kwargs: the kwargs for the scatter plots
"""
input_1, input_2 = which_indices = self.get_most_significant_input_dimensions(which_indices)[:2]
canvas, imshow_kwargs = pl.get_new_canvas(**imshow_kwargs)
X, _, _, _, _, Xgrid, _, _, xmin, xmax, resolution = helper_for_plot_data(self, plot_limits, which_indices, None, resolution)
canvas, imshow_kwargs = pl.new_canvas(xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2, **imshow_kwargs)
if (data_labels is not None):
legend = find_best_layout_for_subplots(len(np.unique(data_labels)))[1]
else:
data_labels = np.ones(self.num_data)
legend = False
plots = dict(scatter=_plot_latent_scatter(canvas, X, which_indices, data_labels, marker, num_samples, **scatter_kwargs or {}))
plots.update(_plot_steepest_gradient_map(self, canvas, which_indices, Xgrid, xmin, xmax, resolution, output_labels, kern, annotation_kwargs=annotation_kwargs, **imshow_kwargs))
pl.show_canvas(canvas, plots, legend=legend,
xlim=(xmin[0], xmax[0]), ylim=(xmin[1], xmax[1]),
xlabel='latent dimension %i' % input_1, ylabel='latent dimension %i' % input_2)
plots.update(_plot_steepest_gradient_map(self, canvas, which_indices, Xgrid, xmin, xmax, resolution, output_labels, updates, kern, annotation_kwargs=annotation_kwargs, **imshow_kwargs))
show = pl.show_canvas(canvas, plots, legend=legend)
_wait_for_updates(plots['annotation'], updates)
return plots
return show