All modules for which code is available
39 |- bayesquad.acquisition_functions 40 |
- bayesquad.batch_selection 41 |
- bayesquad.gps 42 |
- bayesquad.plotting 43 |
- bayesquad.priors 44 |
- bayesquad.quadrature 45 |
34 |
63 |
95 |
96 |
97 |
109 |
113 |
114 |
--------------------------------------------------------------------------------
/bayesquad/_maths_helpers.py:
--------------------------------------------------------------------------------
1 | """A home for mathematical operations which are used multiple times in this package."""
2 |
3 | from numpy import ndarray, newaxis
4 |
5 |
6 | def jacobian_of_f_squared_times_g(*,
7 | f: ndarray, f_jacobian: ndarray,
8 | g: ndarray, g_jacobian: ndarray) -> ndarray:
9 | """Given two functions f and g, along with their Jacobians, returns the Jacobian of the function f^2 * g.
10 |
11 | Parameters
12 | ----------
13 | f
14 | A 1D array whose :math:`i`-th element is the value of the function :math:`f` at point :math:`x_i`.
15 | f_jacobian
16 | A 2D array whose :math:`(i,j)`-th element is the :math:`j`-th component of the Jacobian of :math:`f` at point
17 | :math:`x_i`.
18 | g
19 | A 1D array whose :math:`i`-th element is the value of the function :math:`g` at point :math:`x_i`.
20 | g_jacobian
21 | A 2D array whose :math:`(i,j)`-th element is the :math:`j`-th component of the Jacobian of :math:`g` at point
22 | :math:`x_i`.
23 |
24 | Returns
25 | -------
26 | jacobian : ndarray
27 | A 2D array of shape (num_points, num_dimensions). The :math:`(i, j)`-th element is the :math:`j`-th component of
28 | the Jacobian of :math:`f^2 g` at point :math:`x_i`.
29 |
30 | Notes
31 | -----
32 | The required derivative is as follows:
33 |
34 | .. math::
35 |
36 | \\frac{\\partial f^2 g}{\\partial x_j} = 2 f g \\frac{\\partial f}{\\partial x_j}
37 | + f^2 \\frac{\\partial g}{\\partial x_j}
38 | """
39 | assert f.ndim == g.ndim == 1, "Function data must be a 1-dimensional array"
40 | assert f_jacobian.ndim == g_jacobian.ndim == 2, "Function Jacobian data must be a 2-dimensional array"
41 |
42 | # The Jacobian has dimensions (num_points, num_dimensions). For NumPy to broadcast the calculations
43 | # appropriately, we need to augment our 1D variables with a new axis.
44 | f, g = f[:, newaxis], g[:, newaxis]
45 |
46 | jacobian = 2 * f * g * f_jacobian + g_jacobian * f ** 2
47 |
48 | return jacobian
49 |
50 |
51 | def hessian_of_f_squared_times_g(*,
52 | f: ndarray, f_jacobian: ndarray, f_hessian: ndarray,
53 | g: ndarray, g_jacobian: ndarray, g_hessian: ndarray) -> ndarray:
54 | """Given two functions f and g, along with their Jacobian and Hessian, returns the Hessian of the function f^2 * g.
55 |
56 | Parameters
57 | ----------
58 | f
59 | A 1D array whose :math:`i`-th element is the value of the function :math:`f` at point :math:`x_i`.
60 | f_jacobian
61 | A 2D array whose :math:`(i,j)`-th element is the :math:`j`-th component of the Jacobian of :math:`f` at point
62 | :math:`x_i`.
63 | f_hessian
64 | A 3D array whose :math:`(i,j,k)`-th element is the :math:`(j,k)`-th mixed partial derivative of :math:`f` at
65 | point :math:`x_i`.
66 | g
67 | A 1D array whose :math:`i`-th element is the value of the function :math:`g` at point :math:`x_i`.
68 | g_jacobian
69 | A 2D array whose :math:`(i,j)`-th element is the :math:`j`-th component of the Jacobian of :math:`g` at point
70 | :math:`x_i`.
71 | g_hessian
72 | A 3D array whose :math:`(i,j,k)`-th element is the :math:`(j,k)`-th mixed partial derivative of :math:`g` at
73 | point :math:`x_i`.
74 |
75 | Returns
76 | -------
77 | hessian : ndarray
78 | A 3D array of shape (num_points, num_dimensions, num_dimensions). The :math:`(i, j, k)`-th element is the
79 | :math:`(j, k)`-th mixed partial derivative of :math:`f^2 g` at point :math:`x_i`.
80 |
81 | Notes
82 | -----
83 | The required derivatives are as follows:
84 |
85 | .. math::
86 |
87 | \\frac{\\partial f^2 g}{\\partial x_j} & = & 2 f g \\frac{\\partial f}{\\partial x_j}
88 | + f^2 \\frac{\\partial g}{\\partial x_j} \\\\
89 | \\frac{\\partial^2 f^2 g}{\\partial x_j \\partial x_k} & = &
90 | 2 f \\left( g \\frac{\\partial^2 f}{\\partial x_j \\partial x_k}
91 | + \\frac{\\partial g}{\\partial x_j} \\frac{\\partial f}{\\partial x_k}
92 | + \\frac{\\partial f}{\\partial x_j} \\frac{\\partial g}{\\partial x_k} \\right) \\\\
93 | & & + 2 g \\frac{\\partial f}{\\partial x_j} \\frac{\\partial f}{\\partial x_k}
94 | + f^2 \\frac{\\partial^2 f}{\\partial x_j \\partial x_k}
95 | """
96 | assert f.ndim == g.ndim == 1, "Function data must be a 1-dimensional array"
97 | assert f_jacobian.ndim == g_jacobian.ndim == 2, "Function Jacobian data must be a 2-dimensional array"
98 | assert f_hessian.ndim == g_hessian.ndim == 3, "Function Hessian data must be a 3-dimensional array"
99 |
100 | # The Hessian has dimensions (num_points, num_dimensions, num_dimensions). For NumPy to broadcast the calculations
101 | # appropriately, we need to augment our 1D variables with new axes.
102 | f, g = f[:, newaxis, newaxis], g[:, newaxis, newaxis]
103 |
104 | # The (i,j,k)-th element of these arrays is the j-th component of the Jacobian at x_i (the k axis has size 1).
105 | f_jacobian_dxj, g_jacobian_dxj = f_jacobian[:, :, newaxis], g_jacobian[:, :, newaxis]
106 |
107 | # The (i,j,k)-th element of these arrays is the k-th component of the Jacobian at x_i (the j axis has size 1).
108 | f_jacobian_dxk, g_jacobian_dxk = f_jacobian[:, newaxis, :], g_jacobian[:, newaxis, :]
109 |
110 | hessian = \
111 | 2 * f * (
112 | f_hessian * g +
113 | g_jacobian_dxj * f_jacobian_dxk +
114 | f_jacobian_dxj * g_jacobian_dxk
115 | ) + 2 * g * f_jacobian_dxj * f_jacobian_dxk \
116 | + g_hessian * f ** 2
117 |
118 | return hessian
119 |
--------------------------------------------------------------------------------
/docs/build/html/py-modindex.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 |
37 |
112 |
124 |
128 |
129 |
--------------------------------------------------------------------------------
/docs/source/conf.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | #
3 | # Configuration file for the Sphinx documentation builder.
4 | #
5 | # This file does only contain a selection of the most common options. For a
6 | # full list see the documentation:
7 | # http://www.sphinx-doc.org/en/master/config
8 |
9 | # -- Path setup --------------------------------------------------------------
10 |
11 | # If extensions (or modules to document with autodoc) are in another directory,
12 | # add these directories to sys.path here. If the directory is relative to the
13 | # documentation root, use os.path.abspath to make it absolute, like shown here.
14 |
15 | import os
16 | import sys
17 | sys.path.insert(0, os.path.abspath('../../'))
18 |
19 |
20 | # -- Project information -----------------------------------------------------
21 |
22 | project = 'Batch Bayesian quadrature'
23 | copyright = '2018, Ed Wagstaff'
24 | author = 'Ed Wagstaff'
25 |
26 | # The short X.Y version
27 | version = ''
28 | # The full version, including alpha/beta/rc tags
29 | release = ''
30 |
31 |
32 | # -- General configuration ---------------------------------------------------
33 |
34 | # If your documentation needs a minimal Sphinx version, state it here.
35 | #
36 | # needs_sphinx = '1.0'
37 |
38 | # Add any Sphinx extension module names here, as strings. They can be
39 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
40 | # ones.
41 | extensions = [
42 | 'sphinx.ext.autodoc',
43 | 'sphinx.ext.doctest',
44 | 'sphinx.ext.coverage',
45 | 'sphinx.ext.mathjax',
46 | 'sphinx.ext.viewcode',
47 | 'sphinx.ext.napoleon',
48 | ]
49 |
50 | # Add any paths that contain templates here, relative to this directory.
51 | templates_path = ['_templates']
52 |
53 | # The suffix(es) of source filenames.
54 | # You can specify multiple suffix as a list of string:
55 | #
56 | # source_suffix = ['.rst', '.md']
57 | source_suffix = '.rst'
58 |
59 | # The master toctree document.
60 | master_doc = 'index'
61 |
62 | # The language for content autogenerated by Sphinx. Refer to documentation
63 | # for a list of supported languages.
64 | #
65 | # This is also used if you do content translation via gettext catalogs.
66 | # Usually you set "language" from the command line for these cases.
67 | language = None
68 |
69 | # List of patterns, relative to source directory, that match files and
70 | # directories to ignore when looking for source files.
71 | # This pattern also affects html_static_path and html_extra_path .
72 | exclude_patterns = []
73 |
74 | # The name of the Pygments (syntax highlighting) style to use.
75 | pygments_style = 'sphinx'
76 |
77 |
78 | # -- Options for HTML output -------------------------------------------------
79 |
80 | # The theme to use for HTML and HTML Help pages. See the documentation for
81 | # a list of builtin themes.
82 | #
83 | html_theme = 'classic'
84 |
85 | # Theme options are theme-specific and customize the look and feel of a theme
86 | # further. For a list of options available for each theme, see the
87 | # documentation.
88 | #
89 | # html_theme_options = {}
90 |
91 | # Add any paths that contain custom static files (such as style sheets) here,
92 | # relative to this directory. They are copied after the builtin static files,
93 | # so a file named "default.css" will overwrite the builtin "default.css".
94 | html_static_path = ['_static']
95 |
96 | # Custom sidebar templates, must be a dictionary that maps document names
97 | # to template names.
98 | #
99 | # The default sidebars (for documents that don't match any pattern) are
100 | # defined by theme itself. Builtin themes are using these templates by
101 | # default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
102 | # 'searchbox.html']``.
103 | #
104 | # html_sidebars = {}
105 |
106 |
107 | # -- Options for HTMLHelp output ---------------------------------------------
108 |
109 | # Output file base name for HTML help builder.
110 | htmlhelp_basename = 'BatchBayesianquadraturedoc'
111 |
112 |
113 | # -- Options for LaTeX output ------------------------------------------------
114 |
115 | latex_elements = {
116 | # The paper size ('letterpaper' or 'a4paper').
117 | #
118 | # 'papersize': 'letterpaper',
119 |
120 | # The font size ('10pt', '11pt' or '12pt').
121 | #
122 | # 'pointsize': '10pt',
123 |
124 | # Additional stuff for the LaTeX preamble.
125 | #
126 | # 'preamble': '',
127 |
128 | # Latex figure (float) alignment
129 | #
130 | # 'figure_align': 'htbp',
131 | }
132 |
133 | # Grouping the document tree into LaTeX files. List of tuples
134 | # (source start file, target name, title,
135 | # author, documentclass [howto, manual, or own class]).
136 | latex_documents = [
137 | (master_doc, 'BatchBayesianquadrature.tex', 'Batch Bayesian quadrature Documentation',
138 | 'Ed Wagstaff', 'manual'),
139 | ]
140 |
141 |
142 | # -- Options for manual page output ------------------------------------------
143 |
144 | # One entry per manual page. List of tuples
145 | # (source start file, name, description, authors, manual section).
146 | man_pages = [
147 | (master_doc, 'batchbayesianquadrature', 'Batch Bayesian quadrature Documentation',
148 | [author], 1)
149 | ]
150 |
151 |
152 | # -- Options for Texinfo output ----------------------------------------------
153 |
154 | # Grouping the document tree into Texinfo files. List of tuples
155 | # (source start file, target name, title, author,
156 | # dir menu entry, description, category)
157 | texinfo_documents = [
158 | (master_doc, 'BatchBayesianquadrature', 'Batch Bayesian quadrature Documentation',
159 | author, 'BatchBayesianquadrature', 'One line description of project.',
160 | 'Miscellaneous'),
161 | ]
162 |
163 |
164 | # -- Extension configuration -------------------------------------------------
165 |
--------------------------------------------------------------------------------
/docs/build/html/searchindex.js:
--------------------------------------------------------------------------------
1 | Search.setIndex({docnames:["bayesquad","bayesquad.acquisition_functions","bayesquad.batch_selection","bayesquad.gps","bayesquad.plotting","bayesquad.priors","bayesquad.quadrature","index","modules"],envversion:53,filenames:["bayesquad.rst","bayesquad.acquisition_functions.rst","bayesquad.batch_selection.rst","bayesquad.gps.rst","bayesquad.plotting.rst","bayesquad.priors.rst","bayesquad.quadrature.rst","index.rst","modules.rst"],objects:{"":{bayesquad:[0,0,0,"-"]},"bayesquad.acquisition_functions":{model_variance:[1,1,1,""],model_variance_norm_of_gradient_squared:[1,1,1,""]},"bayesquad.batch_selection":{select_batch:[2,1,1,""]},"bayesquad.gps":{GP:[3,2,1,""],WarpedGP:[3,2,1,""],WsabiLGP:[3,2,1,""]},"bayesquad.gps.GP":{posterior_hessians:[3,3,1,""],posterior_jacobians:[3,3,1,""],posterior_mean_and_variance:[3,3,1,""],update:[3,3,1,""]},"bayesquad.gps.WarpedGP":{kernel:[3,4,1,""],posterior_mean_and_variance:[3,3,1,""],posterior_variance_hessian:[3,3,1,""],posterior_variance_jacobian:[3,3,1,""],remove:[3,3,1,""],update:[3,3,1,""]},"bayesquad.gps.WsabiLGP":{posterior_mean_and_variance:[3,3,1,""],posterior_variance_hessian:[3,3,1,""],posterior_variance_jacobian:[3,3,1,""],remove:[3,3,1,""],update:[3,3,1,""]},"bayesquad.plotting":{add_callback:[4,1,1,""],plottable:[4,1,1,""]},"bayesquad.priors":{Gaussian:[5,2,1,""],Prior:[5,2,1,""]},"bayesquad.priors.Gaussian":{covariance:[5,4,1,""],gradient:[5,3,1,""],logpdf:[5,3,1,""],mean:[5,4,1,""],precision:[5,4,1,""],sample:[5,3,1,""]},"bayesquad.priors.Prior":{gradient:[5,3,1,""],logpdf:[5,3,1,""],sample:[5,3,1,""]},"bayesquad.quadrature":{IntegrandModel:[6,2,1,""],_compute_mean:[6,4,1,""]},"bayesquad.quadrature.IntegrandModel":{integral_mean:[6,3,1,""],posterior_mean_and_variance:[6,3,1,""],posterior_variance_hessian:[6,3,1,""],posterior_variance_jacobian:[6,3,1,""],remove:[6,3,1,""],update:[6,3,1,""]},bayesquad:{acquisition_functions:[1,0,0,"-"],batch_selection:[2,0,0,"-"],gps:[3,0,0,"-"],plotting:[4,0,0,"-"],priors:[5,0,0,"-"],quadrature:[6,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","method","Python method"],"4":["py","attribute","Python attribute"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:method","4":"py:attribute"},terms:{"class":[3,5,6],"default":6,"float":[3,6],"function":[1,3,4,6],"int":[2,5],"new":[2,3,6],"return":[2,3,5,6],The:[2,3,5,6],These:3,With:3,_clear_cach:3,_compute_mean:6,abc:[3,5],access:3,acquisit:1,acquisition_funct:[0,8],add:[3,6],add_callback:4,addit:3,advanc:3,again:3,against:5,all:3,allow:4,alpha:3,also:[3,6],ani:3,appli:3,approxim:3,arg:3,argument:[3,6],around:3,arrai:[2,3,5,6],base:[3,5,6],batch:[0,2],batch_method:2,batch_select:[0,8],batch_siz:2,bayesian:[0,2,3,6],been:3,believ:2,between:3,cach:3,calcul:3,call:3,callabl:4,callback:4,capabl:6,clear:3,code:[3,4],complic:3,compon:[3,6],comput:[2,3,5,6],consist:3,contain:5,content:8,conveni:3,core:3,correctli:3,covari:5,current:2,data:[3,6],data_dependent_hessian:3,deal:3,decoupl:4,default_plotting_paramet:4,defin:6,deleg:6,depend:3,deriv:[3,5,6],detail:3,diagon:3,diagonal_hessian:3,differ:3,dimens:3,dimension:3,directli:3,disabl:3,distribut:5,document:3,doe:[3,6],dub:3,duplic:3,each:[2,3,5],element:[3,5,6],equal:[3,6],error:6,evalu:[0,2,3,5,6],exactli:3,fast:3,follow:3,found:6,from:[3,4,5,6],further:3,gaussian:[3,5,6],get:[3,6],given:[3,5,6],gps:[0,6,8],gpy:3,gpy_gp:3,gradient:[3,5],gunter:3,has:3,have:3,hessian:[3,5,6],hit:3,identifi:4,immedi:3,implement:[3,6],includ:3,independ:[3,5],index:7,infer:3,inform:3,input:[3,6],instanc:3,integr:[5,6],integral_mean:6,integrand:[2,6],integrand_model:[1,2],integrandmodel:[1,2,6],intend:5,interest:6,introduc:3,invers:[3,5],its:[3,5],jacobian:[3,5,6],k_d_inv:3,k_star:3,kern:3,kernel:[3,6],kernel_hessian:3,kernel_jacobian:3,keyword:3,krige:2,kwarg:3,length:3,likelihood:5,line:3,linearis:3,list:[2,3,6],local:2,locat:3,log:5,logpdf:5,mai:[3,6],make:3,manual:3,mappingproxi:4,matrix:[3,5],mean:[3,5,6],mean_hessian:3,mean_jacobian:3,mechan:3,method:[2,3,5,6],mix:[3,5,6],model:[0,2,3,6],model_vari:1,model_variance_norm_of_gradient_squar:1,modifi:3,modul:[7,8],more:3,most:3,multivari:5,must:[3,6],name:6,ndarrai:[2,3,5,6],necessari:3,need:3,neural:3,none:[3,6],notat:3,note:[3,6],num_dimens:[3,5,6],num_point:[3,5,6],number:[2,3,6],numpi:[2,3,5,6],object:[3,6],observ:3,occur:3,one:3,onli:3,optimis:3,optimist:2,other:6,our:3,output:3,overrid:3,own:3,packag:8,page:7,pain:3,paramet:[2,3,5,6],part:3,partial:[3,5,6],pass:3,pdf:5,penalis:2,perform:[0,2,3,6],pleas:3,plot:[0,8],plottabl:4,point:[0,2,3,5,6],pointwis:5,posit:3,possibl:3,posterior:[3,6],posterior_hessian:3,posterior_jacobian:3,posterior_mean_and_vari:[3,6],posterior_variance_hessian:[3,6],posterior_variance_jacobian:[3,6],precis:5,predict:3,predictive_gradi:3,prevent:3,prior:[0,6,8],probabilist:3,probabl:5,process:[3,6],produc:3,product:6,properti:3,provid:[3,5,6],quadratur:[0,1,2,3,8],rais:[3,6],reason:3,recent:3,refer:3,relat:1,remain:3,remov:[3,6],repres:[3,5,6],respect:3,rest:4,result:3,root:3,same:[3,6],sampl:[3,5],search:7,see:[3,5],select:[0,2],select_batch:2,self:3,separ:3,set:[3,5,6],shape:[3,5,6],share:3,should:3,sinc:3,slightli:3,some:3,sourc:[1,2,3,4,5,6],space:3,squar:3,str:[2,4],straightforward:3,submodul:8,support:[0,2],system:3,tensor:3,term:3,thi:[3,6],through:3,tom:3,transform:3,tupl:[3,5,6],type:[2,3,5,6],typic:6,under:6,underli:3,union:[3,6],updat:[3,6],update_model:3,use:3,using:3,valu:[3,5],valueerror:[3,6],varianc:[3,6],variance_hessian:3,variance_jacobian:3,vector:3,versa:[3,6],vice:[3,6],warp:[0,3,6],warped_gp:6,warpedgp:[3,6],whenev:3,where:3,which:[2,3,5,6],whose:5,wish:2,work:3,would:3,wrap:3,wrapper:3,write:[3,6],wsabi:3,wsabilgp:3,x_d:3,y_d:3},titles:["bayesquad package","bayesquad.acquisition_functions module","bayesquad.batch_selection module","bayesquad.gps module","bayesquad.plotting module","bayesquad.priors module","bayesquad.quadrature module","Welcome to Batch Bayesian quadrature\u2019s documentation!","bayesquad"],titleterms:{acquisition_funct:1,batch:7,batch_select:2,bayesian:7,bayesquad:[0,1,2,3,4,5,6,8],content:0,document:7,gps:3,indic:7,modul:[0,1,2,3,4,5,6],packag:0,plot:4,prior:5,quadratur:[6,7],submodul:0,tabl:7,welcom:7}})
--------------------------------------------------------------------------------
/docs/build/html/bayesquad.batch_selection.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 |
38 |
94 |
110 |
111 |
39 |
93 |
40 |
41 |
42 |
49 |
89 |
90 |
91 |
92 | Python Module Index
43 | 44 |
45 | b
46 |
47 |
48 | | 51 | b | ||
| 55 | |
56 | bayesquad | 57 | |
| 60 | |
61 | bayesquad.acquisition_functions | 62 | |
| 65 | |
66 | bayesquad.batch_selection | 67 | |
| 70 | |
71 | bayesquad.gps | 72 | |
| 75 | |
76 | bayesquad.plotting | 77 | |
| 80 | |
81 | bayesquad.priors | 82 | |
| 85 | |
86 | bayesquad.quadrature | 87 | |
34 |
106 |
118 |
122 |
123 |
--------------------------------------------------------------------------------
/bayesquad/_kernel_gradients.py:
--------------------------------------------------------------------------------
1 | """Functions for computing the gradients of Gaussian Process kernels."""
2 |
3 | import numpy as np
4 |
5 | from GPy.kern.src.kern import Kern
6 | from GPy.kern.src.rbf import RBF
7 | from GPy.kern.src.stationary import Stationary
8 | from numpy import ndarray, newaxis
9 |
10 |
11 | def jacobian(kernel: Kern, variable_points: ndarray, fixed_points: ndarray) -> ndarray:
12 | """Return the Jacobian of a kernel evaluated at all pairs from two sets of points.
13 |
14 | Given a kernel and two sets :math:`X, D` of points (`variable_points` and `fixed_points` respectively), this
15 | function will evaluate the Jacobian of the kernel at each pair of points :math:`(x, d)` with :math:`x \in X` and
16 | :math:`d \in D`. The derivative is taken with respect to the first argument, i.e. :math:`d` is regarded as a
17 | fixed quantity. Typically, :math:`D` will be the set of :math:`x` values in the data set of a Gaussian Process, and
18 | :math:`X` will be the set of :math:`x` values at which we wish to find the gradient of the posterior GP.
19 |
20 | Parameters
21 | ----------
22 | kernel
23 | The kernel to be differentiated. Currently supported kernels are:
24 | - :class:`GPy.kern.src.rbf.RBF`
25 | variable_points
26 | A 2D array of points, with shape (num_variable_points, num_dimensions).
27 | fixed_points
28 | A 2D array of points, with shape (num_fixed_points, num_dimensions).
29 |
30 | Returns
31 | -------
32 | ndarray
33 | A 3D array of shape (num_variable_points, num_fixed_points, num_dimensions), whose (i, j, k)-th element is the
34 | k-th component of the Jacobian of the kernel evaluated at the i-th point of :math:`X` and the j-th point of
35 | :math:`D`.
36 |
37 | Raises
38 | ------
39 | NotImplementedError
40 | If the provided kernel type is not supported. See the parameters list for a list of supported kernels.
41 | """
42 | if isinstance(kernel, RBF):
43 | lengthscale = kernel.lengthscale.values[0]
44 | k = kernel.K(variable_points, fixed_points)
45 |
46 | # The (i, j, k)-th element of this is the k-th component of X_i - D_j.
47 | differences = variable_points[:, newaxis, :] - fixed_points[newaxis, :, :]
48 |
49 | return -k[:, :, newaxis] * differences / (lengthscale ** 2)
50 | else:
51 | raise NotImplementedError
52 |
53 |
54 | def hessian(kernel: Kern, variable_points: ndarray, fixed_points: ndarray) -> ndarray:
55 | """Return the Hessian of a kernel evaluated at all pairs from two sets of points.
56 |
57 | Given a kernel and two sets :math:`X, D` of points (`variable_points` and `fixed_points` respectively), this
58 | function will evaluate the Hessian of the kernel at each pair of points :math:`(x, d)` with :math:`x \in X` and
59 | :math:`d \in D`. The derivatives are taken with respect to the first argument, i.e. :math:`d` is regarded as a
60 | fixed quantity. Typically, :math:`D` will be the set of :math:`x` values in the data set of a Gaussian Process, and
61 | :math:`X` will be the set of :math:`x` values at which we wish to find the gradient of the posterior GP.
62 |
63 | Parameters
64 | ----------
65 | kernel
66 | The kernel to be differentiated. Currently supported kernels are:
67 | - :class:`GPy.kern.src.rbf.RBF`
68 | fixed_points
69 | A 2D array of points, with shape (num_variable_points, num_dimensions).
70 | variable_points
71 | A 2D array of points, with shape (num_fixed_points, num_dimensions).
72 |
73 | Returns
74 | -------
75 | ndarray
76 | A 4D array of shape (num_variable_points, num_fixed_points, num_dimensions, num_dimensions), whose
77 | (i, j, k, l)-th element is the (k, l)-th mixed partial derivative of the kernel evaluated at the i-th point of
78 | :math:`X` and the j-th point of :math:`D`.
79 |
80 | Raises
81 | ------
82 | NotImplementedError
83 | If the provided kernel type is not supported. See the parameters list for a list of supported kernels.
84 | """
85 | if isinstance(kernel, RBF):
86 | lengthscale = kernel.lengthscale.values[0]
87 | k = kernel.K(variable_points, fixed_points)
88 |
89 | _, num_dimensions = variable_points.shape
90 |
91 | # The (i, j, k)-th element of this is the k-th component of X_i - D_j (i.e. (X_i - D_j)_k).
92 | differences = variable_points[:, newaxis, :] - fixed_points[newaxis, :, :]
93 |
94 | # The (i, j, k, l)-th element of this is (X_i - D_j)_k * (X_i - D_j)_l. This can be viewed as a matrix of
95 | # matrices, whose (i, j)-th matrix is the outer product of (X_i - D_j) with itself.
96 | outer_products_of_differences = np.einsum('ijk,ijl->ijkl', differences, differences, optimize=True)
97 |
98 | transformed_outer_products = (outer_products_of_differences / lengthscale ** 2) - np.eye(num_dimensions)
99 |
100 | # Now multiply the (i, j)-th transformed outer product by K(X_i, D_j).
101 | product = np.einsum('ij,ijkl->ijkl', k, transformed_outer_products, optimize=True)
102 |
103 | return product / (lengthscale ** 2)
104 | else:
105 | raise NotImplementedError
106 |
107 |
108 | def diagonal_hessian(kernel: Kern, x: ndarray) -> ndarray:
109 | """Return the Hessian of a kernel considered as a function of one variable by constraining both inputs to be equal.
110 |
111 | Given a kernel :math:`K` and a set of points :math:`X`, this function will evaluate the Hessian of :math:`K(x, x)`
112 | at each point :math:`x` of :math:`X`.
113 |
114 | Parameters
115 | ----------
116 | kernel
117 | The kernel to be differentiated. Currently supported kernels are:
118 | - All subclasses of :class:`GPy.kern.src.rbf.Stationary`
119 | x
120 | A 2D array of points, with shape (num_points, num_dimensions).
121 |
122 | Returns
123 | -------
124 | ndarray
125 | A 3D array of shape (num_points, num_dimensions, num_dimensions).
126 | """
127 | if isinstance(kernel, Stationary):
128 | num_points, num_dimensions = x.shape
129 |
130 | return np.zeros((num_points, num_dimensions, num_dimensions))
131 | else:
132 | raise NotImplementedError
133 |
--------------------------------------------------------------------------------
/bayesquad/quadrature.py:
--------------------------------------------------------------------------------
1 | """Provides a model of the integrand, with the capability to perform Bayesian quadrature."""
2 |
3 | from typing import Tuple, Union, List
4 |
5 | import numpy as np
6 | from GPy.kern import Kern, RBF
7 | from multimethod import multimethod
8 | from numpy import ndarray, newaxis
9 |
10 | from ._decorators import flexible_array_dimensions
11 | from .gps import WarpedGP, WsabiLGP
12 | from ._maths_helpers import jacobian_of_f_squared_times_g, hessian_of_f_squared_times_g
13 | from .priors import Gaussian, Prior
14 |
15 |
16 | class IntegrandModel:
17 | """Represents the product of a warped Gaussian Process and a prior.
18 |
19 | Typically, this product is the function that we're interested in integrating."""
20 |
21 | def __init__(self, warped_gp: WarpedGP, prior: Prior):
22 | self.warped_gp = warped_gp
23 | self.prior = prior
24 | self.dimensions = warped_gp.dimensions
25 |
26 | @flexible_array_dimensions
27 | def posterior_mean_and_variance(self, x: ndarray) -> Tuple[ndarray, ndarray]:
28 | """Get the posterior mean and variance of the product of warped GP and prior at a point, or a set of points.
29 |
30 | Parameters
31 | ----------
32 | x
33 | The point(s) at which to evaluate the posterior mean and variance. A 2D array of shape
34 | (num_points, num_dimensions), or a 1D array of shape (num_dimensions).
35 |
36 | Returns
37 | -------
38 | mean : ndarray
39 | A 1D array of shape (num_points) if the input was 2D, or a 0D array if the input was 1D. The :math:`i`-th
40 | element is the posterior mean at the :math:`i`-th point of `x`.
41 | variance : ndarray
42 | A 1D array of shape (num_points) if the input was 2D, or a 0D array if the input was 1D. The :math:`i`-th
43 | element is the posterior variance at the :math:`i`-th point of `x`.
44 | """
45 | warped_gp_mean, warped_gp_variance = self.warped_gp.posterior_mean_and_variance(x)
46 | prior = self.prior(x)
47 |
48 | mean = warped_gp_mean * prior
49 | variance = warped_gp_variance * prior ** 2
50 |
51 | return mean, variance
52 |
53 | @flexible_array_dimensions
54 | def posterior_variance_jacobian(self, x: ndarray) -> ndarray:
55 | """Get the Jacobian of the posterior variance of the product of warped GP and prior at a point or set of points.
56 |
57 | Parameters
58 | ----------
59 | x
60 | The point(s) at which to evaluate the Jacobian. A 2D array of shape (num_points, num_dimensions), or a 1D
61 | array of shape (num_dimensions).
62 |
63 | Returns
64 | -------
65 | jacobian : ndarray
66 | A 2D array of shape (num_points, num_dimensions) if the input was 2D, or a 1D array of shape
67 | (num_dimensions) if the input was 1D. The :math:`(i, j)`-th element is the :math:`j`-th component of the
68 | Jacobian of the posterior variance at the :math:`i`-th point of `x`.
69 |
70 | Notes
71 | -----
72 | Writing :math:`\\pi(x)` for the prior, and :math:`V(x)` for the posterior variance, the posterior variance of
73 | the product is :math:`\\pi(x)^2 V(x)`.
74 | """
75 | _, gp_variance = self.warped_gp.posterior_mean_and_variance(x)
76 | gp_variance_jacobian = self.warped_gp.posterior_variance_jacobian(x)
77 |
78 | prior = self.prior(x)
79 | prior_jacobian, _ = self.prior.gradient(x)
80 |
81 | return jacobian_of_f_squared_times_g(
82 | f=prior, f_jacobian=prior_jacobian,
83 | g=gp_variance, g_jacobian=gp_variance_jacobian)
84 |
85 | @flexible_array_dimensions
86 | def posterior_variance_hessian(self, x: ndarray) -> ndarray:
87 | """Get the Hessian of the posterior variance of the product of warped GP and prior at a point, or set of points.
88 |
89 | Parameters
90 | ----------
91 | x
92 | The point(s) at which to evaluate the Hessian. A 2D array of shape (num_points, num_dimensions), or a 1D
93 | array of shape (num_dimensions).
94 |
95 | Returns
96 | -------
97 | hessian : ndarray
98 | A 3D array of shape (num_points, num_dimensions, num_dimensions) if the input was 2D, or a 2D array of shape
99 | (num_dimensions, num_dimensions) if the input was 1D. The :math:`(i, j, k)`-th element is the
100 | :math:`(j, k)`-th mixed partial derivative of the posterior variance at the :math:`i`-th point of `x`.
101 |
102 | Notes
103 | -----
104 | Writing :math:`\\pi(x)` for the prior, and :math:`V(x)` for the posterior variance, the posterior variance of
105 | the product is :math:`\\pi(x)^2 V(x)`.
106 | """
107 | _, gp_variance = self.warped_gp.posterior_mean_and_variance(x)
108 | gp_variance_jacobian = self.warped_gp.posterior_variance_jacobian(x)
109 | gp_variance_hessian = self.warped_gp.posterior_variance_hessian(x)
110 |
111 | prior = self.prior(x)
112 | prior_jacobian, prior_hessian = self.prior.gradient(x)
113 |
114 | return hessian_of_f_squared_times_g(
115 | f=prior, f_jacobian=prior_jacobian, f_hessian=prior_hessian,
116 | g=gp_variance, g_jacobian=gp_variance_jacobian, g_hessian=gp_variance_hessian)
117 |
118 | def update(self, x: ndarray, y: ndarray) -> None:
119 | """Add new data to the model.
120 |
121 | Parameters
122 | ----------
123 | x
124 | A 2D array of shape (num_points, num_dimensions), or a 1D array of shape (num_dimensions).
125 | y
126 | A 1D array of shape (num_points). If X is 1D, this may also be a 0D array or float.
127 |
128 | Raises
129 | ------
130 | ValueError
131 | If the number of points in `x` does not equal the number of points in `y`.
132 | """
133 | self.warped_gp.update(x, y)
134 |
135 | def remove(self, x: Union[ndarray, List[ndarray]], y: Union[ndarray, List[ndarray]]) -> None:
136 | """Remove data from the model.
137 |
138 | Parameters
139 | ----------
140 | x
141 | A 2D array of shape (num_points, num_dimensions), or a 1D array of shape (num_dimensions), or a list of such
142 | arrays.
143 | y
144 | A 1D array of shape (num_points), or a list of such arrays. If `x` is 1D, this may also be a 0D array or
145 | float. Must be of the same type as `x`.
146 |
147 | Raises
148 | ------
149 | ValueError
150 | If the number of points in `x` does not equal the number of points in `y`.
151 | If `x` is an array and `y` is a list, or vice versa.
152 | """
153 | self.warped_gp.remove(x, y)
154 |
155 | def integral_mean(self) -> float:
156 | """Compute the mean of the integral of the function under this model."""
157 | return _compute_mean(self.prior, self.warped_gp, self.warped_gp.kernel)
158 |
159 |
160 | @multimethod
161 | def _compute_mean(prior: Prior, gp: WarpedGP, kernel: Kern) -> float:
162 | """Compute the mean of the integral for the given prior, warped GP, and kernel.
163 |
164 | This method will delegate to other methods of the same name defined in this module, based on the type of the
165 | arguments. If no implementation is found for the provided types, this default implementation will raise an error."""
166 | raise NotImplementedError("Integration is not supported for this combination of prior, warping and kernel.\n\n"
167 | "Prior was of type {}.\n"
168 | "Warped GP was of type {}.\n"
169 | "Kernel was of type {}."
170 | .format(type(prior), type(gp), type(kernel)))
171 |
172 |
173 | @multimethod
174 | def _compute_mean(prior: Gaussian, gp: WsabiLGP, kernel: RBF) -> float:
175 | """Compute the mean of the integral for a WSABI-L GP with a squared exponential kernel against a Gaussian prior."""
176 | underlying_gp = gp.underlying_gp
177 |
178 | dimensions = gp.dimensions
179 |
180 | alpha = gp.alpha
181 | kernel_lengthscale = kernel.lengthscale.values[0]
182 | kernel_variance = kernel.variance.values[0]
183 |
184 | X_D = underlying_gp.X
185 |
186 | mu = prior.mean
187 | sigma = prior.covariance
188 | sigma_inv = prior.precision
189 |
190 | nu = (X_D[:, newaxis, :] + X_D[newaxis, :, :]) / 2
191 | A = underlying_gp.K_inv_Y
192 |
193 | L = np.exp(-(np.linalg.norm(X_D[:, newaxis, :] - X_D[newaxis, :, :], axis=2) ** 2)/(4 * kernel_lengthscale**2))
194 | L = kernel_variance ** 2 * L
195 | L = np.linalg.det(2 * np.pi * sigma) ** (-1/2) * L
196 |
197 | C = sigma_inv + 2 * np.eye(dimensions) / kernel_lengthscale ** 2
198 |
199 | C_inv = np.linalg.inv(C)
200 | gamma_part = 2 * nu / kernel_lengthscale ** 2 + (sigma_inv @ mu)[newaxis, newaxis, :]
201 |
202 | gamma = np.einsum('kl,ijl->ijk', C_inv, gamma_part)
203 |
204 | k_1 = 2 * np.einsum('ijk,ijk->ij', nu, nu) / kernel_lengthscale ** 2
205 | k_2 = mu.T @ sigma_inv @ mu
206 | k_3 = np.einsum('ijk,kl,ijl->ij', gamma, C, gamma)
207 |
208 | k = k_1 + k_2 - k_3
209 |
210 | K = np.exp(-k/2)
211 |
212 | integral_mean = alpha + (np.linalg.det(2 * np.pi * np.linalg.inv(C)) ** 0.5)/2 * (A.T @ (K * L) @ A)
213 |
214 | return integral_mean.item()
215 |
--------------------------------------------------------------------------------
/docs/build/html/_modules/bayesquad/plotting.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 |
35 |
81 |
104 |
105 |
36 |
80 |
37 |
38 |
79 |
39 |
76 |
77 |
78 | bayesquad.batch_selection module¶
40 |Methods for selecting a batch of points to evaluate for Bayesian quadrature.
41 |-
42 |
-
43 |
bayesquad.batch_selection.select_batch(integrand_model: bayesquad.quadrature.IntegrandModel, batch_size: int, batch_method: str = 'Local Penalisation') → List[numpy.ndarray][source]¶
44 | Select a batch of points at which to evaluate the integrand.
45 |46 |
73 |47 | 48 | 49 | Parameters: -
50 |
- integrand_model – The model with which we wish to perform Bayesian quadrature. 51 |
- batch_size – The number of points to return in the new batch. 52 |
- batch_method –
-
53 |
- The method by which to compute the new batch. Currently supported methods are: 54 |
-
55 |
- ”Local Penalisation” 56 |
- ”Kriging Believer” 57 |
- ”Kriging Optimist” 58 |
60 |
62 |
Returns: A list of arrays. Each array is a point of the new batch.
66 |Return type: list[ndarray]
69 |
35 |
115 |
128 |
132 |
133 |
--------------------------------------------------------------------------------
/docs/build/html/_static/doctools.js:
--------------------------------------------------------------------------------
1 | /*
2 | * doctools.js
3 | * ~~~~~~~~~~~
4 | *
5 | * Sphinx JavaScript utilities for all documentation.
6 | *
7 | * :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
8 | * :license: BSD, see LICENSE for details.
9 | *
10 | */
11 |
12 | /**
13 | * select a different prefix for underscore
14 | */
15 | $u = _.noConflict();
16 |
17 | /**
18 | * make the code below compatible with browsers without
19 | * an installed firebug like debugger
20 | if (!window.console || !console.firebug) {
21 | var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
22 | "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
23 | "profile", "profileEnd"];
24 | window.console = {};
25 | for (var i = 0; i < names.length; ++i)
26 | window.console[names[i]] = function() {};
27 | }
28 | */
29 |
30 | /**
31 | * small helper function to urldecode strings
32 | */
33 | jQuery.urldecode = function(x) {
34 | return decodeURIComponent(x).replace(/\+/g, ' ');
35 | };
36 |
37 | /**
38 | * small helper function to urlencode strings
39 | */
40 | jQuery.urlencode = encodeURIComponent;
41 |
42 | /**
43 | * This function returns the parsed url parameters of the
44 | * current request. Multiple values per key are supported,
45 | * it will always return arrays of strings for the value parts.
46 | */
47 | jQuery.getQueryParameters = function(s) {
48 | if (typeof s === 'undefined')
49 | s = document.location.search;
50 | var parts = s.substr(s.indexOf('?') + 1).split('&');
51 | var result = {};
52 | for (var i = 0; i < parts.length; i++) {
53 | var tmp = parts[i].split('=', 2);
54 | var key = jQuery.urldecode(tmp[0]);
55 | var value = jQuery.urldecode(tmp[1]);
56 | if (key in result)
57 | result[key].push(value);
58 | else
59 | result[key] = [value];
60 | }
61 | return result;
62 | };
63 |
64 | /**
65 | * highlight a given string on a jquery object by wrapping it in
66 | * span elements with the given class name.
67 | */
68 | jQuery.fn.highlightText = function(text, className) {
69 | function highlight(node, addItems) {
70 | if (node.nodeType === 3) {
71 | var val = node.nodeValue;
72 | var pos = val.toLowerCase().indexOf(text);
73 | if (pos >= 0 &&
74 | !jQuery(node.parentNode).hasClass(className) &&
75 | !jQuery(node.parentNode).hasClass("nohighlight")) {
76 | var span;
77 | var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
78 | if (isInSVG) {
79 | span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
80 | } else {
81 | span = document.createElement("span");
82 | span.className = className;
83 | }
84 | span.appendChild(document.createTextNode(val.substr(pos, text.length)));
85 | node.parentNode.insertBefore(span, node.parentNode.insertBefore(
86 | document.createTextNode(val.substr(pos + text.length)),
87 | node.nextSibling));
88 | node.nodeValue = val.substr(0, pos);
89 | if (isInSVG) {
90 | var bbox = span.getBBox();
91 | var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
92 | rect.x.baseVal.value = bbox.x;
93 | rect.y.baseVal.value = bbox.y;
94 | rect.width.baseVal.value = bbox.width;
95 | rect.height.baseVal.value = bbox.height;
96 | rect.setAttribute('class', className);
97 | var parentOfText = node.parentNode.parentNode;
98 | addItems.push({
99 | "parent": node.parentNode,
100 | "target": rect});
101 | }
102 | }
103 | }
104 | else if (!jQuery(node).is("button, select, textarea")) {
105 | jQuery.each(node.childNodes, function() {
106 | highlight(this, addItems);
107 | });
108 | }
109 | }
110 | var addItems = [];
111 | var result = this.each(function() {
112 | highlight(this, addItems);
113 | });
114 | for (var i = 0; i < addItems.length; ++i) {
115 | jQuery(addItems[i].parent).before(addItems[i].target);
116 | }
117 | return result;
118 | };
119 |
120 | /*
121 | * backward compatibility for jQuery.browser
122 | * This will be supported until firefox bug is fixed.
123 | */
124 | if (!jQuery.browser) {
125 | jQuery.uaMatch = function(ua) {
126 | ua = ua.toLowerCase();
127 |
128 | var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
129 | /(webkit)[ \/]([\w.]+)/.exec(ua) ||
130 | /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
131 | /(msie) ([\w.]+)/.exec(ua) ||
132 | ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
133 | [];
134 |
135 | return {
136 | browser: match[ 1 ] || "",
137 | version: match[ 2 ] || "0"
138 | };
139 | };
140 | jQuery.browser = {};
141 | jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
142 | }
143 |
144 | /**
145 | * Small JavaScript module for the documentation.
146 | */
147 | var Documentation = {
148 |
149 | init : function() {
150 | this.fixFirefoxAnchorBug();
151 | this.highlightSearchWords();
152 | this.initIndexTable();
153 |
154 | },
155 |
156 | /**
157 | * i18n support
158 | */
159 | TRANSLATIONS : {},
160 | PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
161 | LOCALE : 'unknown',
162 |
163 | // gettext and ngettext don't access this so that the functions
164 | // can safely bound to a different name (_ = Documentation.gettext)
165 | gettext : function(string) {
166 | var translated = Documentation.TRANSLATIONS[string];
167 | if (typeof translated === 'undefined')
168 | return string;
169 | return (typeof translated === 'string') ? translated : translated[0];
170 | },
171 |
172 | ngettext : function(singular, plural, n) {
173 | var translated = Documentation.TRANSLATIONS[singular];
174 | if (typeof translated === 'undefined')
175 | return (n == 1) ? singular : plural;
176 | return translated[Documentation.PLURALEXPR(n)];
177 | },
178 |
179 | addTranslations : function(catalog) {
180 | for (var key in catalog.messages)
181 | this.TRANSLATIONS[key] = catalog.messages[key];
182 | this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
183 | this.LOCALE = catalog.locale;
184 | },
185 |
186 | /**
187 | * add context elements like header anchor links
188 | */
189 | addContextElements : function() {
190 | $('div[id] > :header:first').each(function() {
191 | $('\u00B6').
192 | attr('href', '#' + this.id).
193 | attr('title', _('Permalink to this headline')).
194 | appendTo(this);
195 | });
196 | $('dt[id]').each(function() {
197 | $('\u00B6').
198 | attr('href', '#' + this.id).
199 | attr('title', _('Permalink to this definition')).
200 | appendTo(this);
201 | });
202 | },
203 |
204 | /**
205 | * workaround a firefox stupidity
206 | * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
207 | */
208 | fixFirefoxAnchorBug : function() {
209 | if (document.location.hash && $.browser.mozilla)
210 | window.setTimeout(function() {
211 | document.location.href += '';
212 | }, 10);
213 | },
214 |
215 | /**
216 | * highlight the search words provided in the url in the text
217 | */
218 | highlightSearchWords : function() {
219 | var params = $.getQueryParameters();
220 | var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
221 | if (terms.length) {
222 | var body = $('div.body');
223 | if (!body.length) {
224 | body = $('body');
225 | }
226 | window.setTimeout(function() {
227 | $.each(terms, function() {
228 | body.highlightText(this.toLowerCase(), 'highlighted');
229 | });
230 | }, 10);
231 | $('
36 |
97 |
113 |
114 |
37 |
96 |
38 |
39 |
93 |
94 |
95 | Source code for bayesquad.plotting
40 | """Functions to allow plotting code to be decoupled from the rest of the code."""
41 |
42 | from functools import wraps
43 | from types import MappingProxyType
44 | from typing import Callable
45 |
46 |
47 | class _Registry:
48 | def __init__(self):
49 | self._callback_registry = {}
50 |
51 | def trigger_callbacks(self, identifier: str, func: Callable):
52 | if identifier not in self._callback_registry:
53 | return
54 |
55 | for callback in self._callback_registry[identifier]:
56 | callback(func)
57 |
58 | def add_callback(self, identifier: str, callback: Callable):
59 | if identifier not in self._callback_registry:
60 | self._callback_registry[identifier] = []
61 |
62 | self._callback_registry[identifier].append(callback)
63 |
64 |
65 | _function_registry = _Registry()
66 |
67 | # Using a mutable object (e.g. an empty dict) as a default parameter can lead to undesirable behaviour, so we use this
68 | # read-only proxy.
69 | #
70 | # See:
71 | # The problem: https://stackoverflow.com/q/1132941
72 | # A solution: https://stackoverflow.com/a/30638022
73 | _EMPTY = MappingProxyType({})
74 |
75 |
76 | [docs]def plottable(identifier: str, *, default_plotting_parameters=_EMPTY):
77 | def decorator(func: Callable):
78 | @wraps(func)
79 | def func_for_plotting(*args, **kwargs):
80 | # Merge default_plotting_parameters into kwargs
81 | kwargs = {**default_plotting_parameters, **kwargs}
82 | return func(*args, **kwargs)
83 |
84 | _function_registry.trigger_callbacks(identifier, func_for_plotting)
85 |
86 | return func
87 | return decorator
88 |
89 |
90 | [docs]def add_callback(identifier: str, callback: Callable):
91 | _function_registry.add_callback(identifier, callback)
92 | ' + _('Hide Search Matches') + '
') 233 | .appendTo($('#searchbox')); 234 | } 235 | }, 236 | 237 | /** 238 | * init the domain index toggle buttons 239 | */ 240 | initIndexTable : function() { 241 | var togglers = $('img.toggler').click(function() { 242 | var src = $(this).attr('src'); 243 | var idnum = $(this).attr('id').substr(7); 244 | $('tr.cg-' + idnum).toggle(); 245 | if (src.substr(-9) === 'minus.png') 246 | $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); 247 | else 248 | $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); 249 | }).css('display', ''); 250 | if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { 251 | togglers.click(); 252 | } 253 | }, 254 | 255 | /** 256 | * helper function to hide the search marks again 257 | */ 258 | hideSearchWords : function() { 259 | $('#searchbox .highlight-link').fadeOut(300); 260 | $('span.highlighted').removeClass('highlighted'); 261 | }, 262 | 263 | /** 264 | * make the url absolute 265 | */ 266 | makeURL : function(relativeURL) { 267 | return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; 268 | }, 269 | 270 | /** 271 | * get the current relative url 272 | */ 273 | getCurrentURL : function() { 274 | var path = document.location.pathname; 275 | var parts = path.split(/\//); 276 | $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { 277 | if (this === '..') 278 | parts.pop(); 279 | }); 280 | var url = parts.join('/'); 281 | return path.substring(url.lastIndexOf('/') + 1, path.length - 1); 282 | }, 283 | 284 | initOnKeyListeners: function() { 285 | $(document).keyup(function(event) { 286 | var activeElementType = document.activeElement.tagName; 287 | // don't navigate when in search box or textarea 288 | if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { 289 | switch (event.keyCode) { 290 | case 37: // left 291 | var prevHref = $('link[rel="prev"]').prop('href'); 292 | if (prevHref) { 293 | window.location.href = prevHref; 294 | return false; 295 | } 296 | case 39: // right 297 | var nextHref = $('link[rel="next"]').prop('href'); 298 | if (nextHref) { 299 | window.location.href = nextHref; 300 | return false; 301 | } 302 | } 303 | } 304 | }); 305 | } 306 | }; 307 | 308 | // quick alias for translations 309 | _ = Documentation.gettext; 310 | 311 | $(document).ready(function() { 312 | Documentation.init(); 313 | }); -------------------------------------------------------------------------------- /docs/build/html/_static/underscore.js: -------------------------------------------------------------------------------- 1 | // Underscore.js 1.3.1 2 | // (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc. 3 | // Underscore is freely distributable under the MIT license. 4 | // Portions of Underscore are inspired or borrowed from Prototype, 5 | // Oliver Steele's Functional, and John Resig's Micro-Templating. 6 | // For all details and documentation: 7 | // http://documentcloud.github.com/underscore 8 | (function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source== 9 | c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c, 10 | h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each= 11 | b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e
35 |
133 |
146 |
150 |
151 |
--------------------------------------------------------------------------------
/docs/build/html/bayesquad.priors.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 |
36 |
115 |
131 |
132 |
37 |
114 |
38 |
39 |
111 |
112 |
113 | Source code for bayesquad.acquisition_functions
40 | """Acquisition functions and related functions."""
41 | import numpy as np
42 |
43 | from .plotting import plottable
44 | from .quadrature import IntegrandModel
45 |
46 |
47 | [docs]def model_variance(integrand_model: IntegrandModel):
48 |
49 | @plottable("Model variance", default_plotting_parameters={'calculate_jacobian': False})
50 | def f(x, *, calculate_jacobian=True):
51 | """Evaluate the variance, and the Jacobian of the variance, for the given `IntegrandModel` at a point, or a set
52 | of points.
53 |
54 | Given an array of shape (num_points, num_dimensions), returns an array of shape (num_points) containing the
55 | function values and an array of shape (num_points, num_dimensions) containing the function Jacobians.
56 |
57 | Given an array of shape (num_dimensions), returns a 0D array containing the function value and an array of shape
58 | (num_dimensions) containing the function Jacobian.
59 |
60 | If the Jacobian is not required (e.g. for plotting), the relevant calculations can be disabled by setting
61 | `calculate_jacobian=False`.
62 | """
63 | _, variance = integrand_model.posterior_mean_and_variance(x)
64 |
65 | if calculate_jacobian:
66 | variance_jacobian = integrand_model.posterior_variance_jacobian(x)
67 | else:
68 | variance_jacobian = None
69 |
70 | return variance, variance_jacobian
71 |
72 | return f
73 |
74 |
75 | [docs]def model_variance_norm_of_gradient_squared(integrand_model: IntegrandModel):
76 |
77 | @plottable("Gradient squared", default_plotting_parameters={'calculate_jacobian': False})
78 | def f(x, *, calculate_jacobian=True):
79 | """Evaluate the squared norm of the gradient of the variance, and the Jacobian of this quantity, for the given
80 | `IntegrandModel` at a point, or a set of points.
81 |
82 | Given an array of shape (num_points, num_dimensions), returns an array of shape (num_points) containing the
83 | function values and an array of shape (num_points, num_dimensions) containing the function Jacobians.
84 |
85 | Given an array of shape (num_dimensions), returns a 0D array containing the function value and an array of shape
86 | (num_dimensions) containing the function Jacobian.
87 |
88 | If the Jacobian is not required (e.g. for plotting), the relevant calculations can be disabled by setting
89 | `calculate_jacobian=False`.
90 | """
91 | variance_jacobian = integrand_model.posterior_variance_jacobian(x)
92 |
93 | # Inner product of the Jacobian with itself, for each point.
94 | gradient_squared = np.einsum('...i,...i->...', variance_jacobian, variance_jacobian, optimize=True)
95 |
96 | if calculate_jacobian:
97 | variance_hessian = integrand_model.posterior_variance_hessian(x)
98 |
99 | # Matrix product of Hessian and Jacobian, for each point.
100 | gradient_squared_jacobian = 2 * np.einsum('...ij,...j->...i',
101 | variance_hessian,
102 | variance_jacobian,
103 | optimize=True)
104 | else:
105 | gradient_squared_jacobian = None
106 |
107 | return gradient_squared, gradient_squared_jacobian
108 |
109 | return f
110 |
34 |
189 |
201 |
205 |
206 |
--------------------------------------------------------------------------------
/bayesquad/batch_selection.py:
--------------------------------------------------------------------------------
1 | """Methods for selecting a batch of points to evaluate for Bayesian quadrature."""
2 | from abc import ABC, abstractmethod
3 | from math import sqrt
4 | from typing import List, Callable
5 |
6 | import numpy as np
7 | import numpy.ma as ma
8 | from numpy import ndarray
9 |
10 | from .acquisition_functions import model_variance, model_variance_norm_of_gradient_squared
11 | from ._optimisation import multi_start_maximise
12 | from ._transformations import log_of_function
13 | from .plotting import plottable
14 | from .quadrature import IntegrandModel
15 |
16 | LOCAL_PENALISATION = "Local Penalisation"
17 | KRIGING_BELIEVER = "Kriging Believer"
18 | KRIGING_OPTIMIST = "Kriging Optimist"
19 |
20 |
21 | def select_batch(integrand_model: IntegrandModel,
22 | batch_size: int,
23 | batch_method: str = LOCAL_PENALISATION) -> List[ndarray]:
24 | """Select a batch of points at which to evaluate the integrand.
25 |
26 | Parameters
27 | ----------
28 | integrand_model
29 | The model with which we wish to perform Bayesian quadrature.
30 | batch_size
31 | The number of points to return in the new batch.
32 | batch_method
33 | The method by which to compute the new batch. Currently supported methods are:
34 | - "Local Penalisation"
35 | - "Kriging Believer"
36 | - "Kriging Optimist"
37 |
38 | Returns
39 | -------
40 | list[ndarray]
41 | A list of arrays. Each array is a point of the new batch.
42 | """
43 | if batch_method == LOCAL_PENALISATION:
44 | method = _LocalPenalisation(integrand_model)
45 | elif batch_method == KRIGING_BELIEVER:
46 | method = _KrigingBeliever(integrand_model)
47 | elif batch_method == KRIGING_OPTIMIST:
48 | method = _KrigingOptimist(integrand_model)
49 | else:
50 | raise NotImplementedError("{} is not a supported batch method.".format(batch_method))
51 |
52 | return method.select_batch(batch_size)
53 |
54 |
55 | class _BatchSelectionMethod(ABC):
56 | """A method for selecting a batch of points at which to evaluate an integrand, based on a model of the integrand.
57 |
58 | This selection will always be done on the basis of an acquisition function, which can be chosen or modified by
59 | this class. In general, we sequentially select batch points by maximising the acquisition function (currently, this
60 | is fixed to be the posterior variance of the integrand). In order to avoid repeatedly selecting the same point (or
61 | very nearby points) repeatedly, we update the acquisition function after selecting each point. Different methods
62 | will perform this update in different ways."""
63 |
64 | def __init__(self, integrand_model: IntegrandModel):
65 | self._integrand_model = integrand_model
66 | self._batch: List[ndarray] = []
67 |
68 | def select_batch(self, batch_size: int) -> List[ndarray]:
69 | """Select a batch containing the given number of points."""
70 | while len(self._batch) < batch_size:
71 | acquisition_function = self._get_acquisition_function()
72 | initial_points = self._select_initial_points()
73 | batch_point, _ = multi_start_maximise(acquisition_function, initial_points)
74 |
75 | self._batch.append(batch_point)
76 |
77 | self._cleanup()
78 |
79 | return self._batch
80 |
81 | @abstractmethod
82 | def _get_acquisition_function(self) -> Callable:
83 | """Based on the current state (including at least the current state of the `IntegrandModel` and the batch points
84 | selected so far), return the acquisition function to be maximised to select the next batch point."""
85 |
86 | def _cleanup(self):
87 | """After the full batch has been chosen, perform any necessary cleanup/finalisation. By default, this method
88 | takes no action."""
89 | return
90 |
91 | def _select_initial_points(self):
92 | """Select the initial points for multi-start maximisation of the acquisition function."""
93 | num_initial_points = 10 * self._integrand_model.dimensions
94 |
95 | return self._integrand_model.prior.sample(num_initial_points)
96 |
97 |
98 | class _KrigingBeliever(_BatchSelectionMethod):
99 | """After each batch point is selected, this method updates the model with fictitious data generated by taking the
100 | posterior mean of the model at the batch point."""
101 |
102 | def __init__(self, *args, **kwargs):
103 | self._fantasised_evaluations: List[ndarray] = []
104 | super().__init__(*args, **kwargs)
105 |
106 | def _get_acquisition_function(self) -> Callable:
107 | if self._batch:
108 | batch_point = self._batch[-1]
109 |
110 | mean_y, _ = self._integrand_model.posterior_mean_and_variance(batch_point)
111 | self._fantasised_evaluations.append(mean_y)
112 |
113 | self._integrand_model.update(batch_point, mean_y)
114 |
115 | acquisition_function = model_variance(self._integrand_model)
116 | return log_of_function(acquisition_function)
117 |
118 | def _cleanup(self):
119 | points_with_fantasised_evaluations = self._batch[:-1]
120 | self._integrand_model.remove(points_with_fantasised_evaluations, self._fantasised_evaluations)
121 |
122 |
123 | class _KrigingOptimist(_BatchSelectionMethod):
124 | """After each batch point is selected, this method updates the model with fictitious data generated by taking the
125 | posterior mean of the model at the batch point, plus two posterior standard deviations."""
126 |
127 | def __init__(self, *args, **kwargs):
128 | self._fantasised_evaluations: List[ndarray] = []
129 | super().__init__(*args, **kwargs)
130 |
131 | def _get_acquisition_function(self) -> Callable:
132 | if self._batch:
133 | batch_point = self._batch[-1]
134 |
135 | mean_y, var_y = self._integrand_model.posterior_mean_and_variance(batch_point)
136 | optimistic_y = mean_y + 2 * np.sqrt(var_y)
137 | self._fantasised_evaluations.append(optimistic_y)
138 |
139 | self._integrand_model.update(batch_point, optimistic_y)
140 |
141 | acquisition_function = model_variance(self._integrand_model)
142 | return log_of_function(acquisition_function)
143 |
144 | def _cleanup(self):
145 | points_with_fantasised_evaluations = self._batch[:-1]
146 | self._integrand_model.remove(points_with_fantasised_evaluations, self._fantasised_evaluations)
147 |
148 |
149 | class _LocalPenalisation(_BatchSelectionMethod):
150 | """After each batch point is selected, this method directly penalises the acquisition function around the point.
151 |
152 | Notes
153 | -----
154 | In this method, after choosing a batch point we maximise the norm of the gradient of the acquisition function in the
155 | neighbourhood of this point. We then take the penalised function to be the minimum of the original function and a
156 | cone with half of this maximal gradient around the selected point. We choose half the gradient since the true
157 | function must have zero gradient at the selected point and at the nearest maximum, so the average gradient here will
158 | not be as large as the maximum.
159 |
160 | Since this minimum of multiple functions will not be smooth, we use an approximation to the minimum (a "soft
161 | minimum"). This is done by taking the p-norm of all function values for a negative value of p.
162 | """
163 |
164 | def __init__(self, *args, **kwargs):
165 | self._penaliser_gradients: List[float] = []
166 | super().__init__(*args, **kwargs)
167 |
168 | def _get_acquisition_function(self) -> Callable:
169 | if self._batch:
170 | max_gradient = self._find_max_gradient_near_latest_batch_point()
171 |
172 | self._penaliser_gradients.append(max_gradient / 2)
173 |
174 | acquisition_function = model_variance(self._integrand_model)
175 |
176 | softmin_penalised_log_acquisition_function = \
177 | self._get_soft_penalised_log_acquisition_function(acquisition_function)
178 |
179 | return softmin_penalised_log_acquisition_function
180 |
181 | def _find_max_gradient_near_latest_batch_point(self) -> float:
182 | batch_point = self._batch[-1]
183 |
184 | num_local_initial_points = self._integrand_model.dimensions * 10
185 | local_initial_points = self._get_local_initial_points(batch_point, num_local_initial_points)
186 |
187 | _log_variance_gradient_squared_and_jacobian = \
188 | log_of_function(model_variance_norm_of_gradient_squared(self._integrand_model))
189 |
190 | _, log_max_gradient_squared = multi_start_maximise(_log_variance_gradient_squared_and_jacobian,
191 | local_initial_points)
192 |
193 | max_gradient_squared = np.exp(log_max_gradient_squared)
194 | return sqrt(max_gradient_squared)
195 |
196 | def _get_soft_penalised_log_acquisition_function(self, acquisition_function: Callable) -> Callable:
197 | """Create a function which will return the log of a soft minimum of the given acquisition function and the given
198 | penalisers at any point, or set of points.
199 |
200 | The soft minimisation is performed by taking the p-norm of all function values for a negative value of p. This
201 | gives a differentiable function which is approximately equal to the min of the given functions.
202 |
203 | If the Jacobian is not required (e.g. for plotting), the relevant calculations can be disabled by passing
204 | `calculate_jacobian=False` as a parameter to the returned function.
205 | """
206 | penaliser_centres = self._batch
207 | penaliser_gradients = self._penaliser_gradients
208 |
209 | penalisers = [self._cone(centre, gradient) for centre, gradient in zip(penaliser_centres, penaliser_gradients)]
210 | p = 6
211 |
212 | @plottable("Soft penalised log acquisition function", default_plotting_parameters={'calculate_jacobian': False})
213 | def penalised_acquisition_function(x, *, calculate_jacobian=True):
214 | function_evaluations = \
215 | [acquisition_function(x, calculate_jacobian=calculate_jacobian)] + [f(x) for f in penalisers]
216 | function_values, function_jacobians = [np.array(ret) for ret in zip(*function_evaluations)]
217 |
218 | # This is necessary to ensure that function_values has the same dimensions as function_jacobians, so that we
219 | # can index into both arrays in a consistent manner.
220 | function_values = np.expand_dims(function_values, -1)
221 |
222 | # We want to avoid dividing by zero and taking the log of zero, so we mask out all zeroes.
223 | function_values = ma.masked_equal(function_values, 0)
224 |
225 | min_function_values = np.min(function_values, axis=0)
226 | min_function_values = ma.masked_array(min_function_values, mask=np.any(function_values.mask, axis=0))
227 |
228 | # Any values more than roughly an order of magnitude from the minimum value will be irrelevant to the final
229 | # result, but might cause overflows, so we clip them here.
230 | scaled_function_values = (function_values / min_function_values).clip(max=1e2)
231 |
232 | scaled_inverse_power_sum = (1 / (scaled_function_values ** p)).sum(axis=0)
233 | values = -ma.log(scaled_inverse_power_sum) / p + ma.log(min_function_values)
234 | values = ma.filled(values, -1e9)
235 |
236 | if calculate_jacobian:
237 | scaled_function_jacobians = (function_jacobians / min_function_values).clip(max=1e2, min=-1e2)
238 | jacobian_numerator = (1 / (scaled_function_values ** (p + 1)) * scaled_function_jacobians).sum(axis=0)
239 | jacobians = jacobian_numerator / scaled_inverse_power_sum
240 | jacobians = ma.filled(jacobians, np.random.randn())
241 | else:
242 | jacobians = None
243 |
244 | return values.squeeze(), jacobians
245 |
246 | return penalised_acquisition_function
247 |
248 | @staticmethod
249 | def _get_local_initial_points(central_point: ndarray, num_points: int):
250 | """Get a set of points close to a given point."""
251 | perturbations = 0.01 * np.random.randn(num_points, *central_point.shape)
252 | return central_point + perturbations
253 |
254 | @staticmethod
255 | def _cone(centre: ndarray, gradient: float):
256 | def f(x):
257 | """Evaluate a cone around the given centre with the given gradient, i.e. a function whose value increases
258 | linearly with distance from the centre.
259 |
260 | Given an array of shape (num_points, num_dimensions), returns an array of shape (num_points) containing the
261 | function values and an array of shape (num_points, num_dimensions) containing the function Jacobians.
262 |
263 | Given an array of shape (num_dimensions), returns a 0D array containing the function value and an array of
264 | shape (num_dimensions) containing the function Jacobian.
265 | """
266 | distance = np.linalg.norm(x - centre, axis=-1)
267 |
268 | value = distance * gradient
269 |
270 | distance = np.expand_dims(distance, -1)
271 | distance = ma.masked_equal(distance, 0) # Avoid division by zero at the centre.
272 |
273 | jacobian = (x - centre) * gradient / distance
274 |
275 | # The Jacobian isn't defined at the centre of the cone but we must return a value.
276 | jacobian = ma.filled(jacobian, x)
277 |
278 | return value, jacobian
279 |
280 | return f
281 |
--------------------------------------------------------------------------------
35 |
164 |
187 |
188 |
36 |
163 |
37 |
38 |
162 |
39 |
159 |
160 |
161 | bayesquad.priors module¶
40 |Classes representing probability distributions, intended to be integrated against a likelihood.
41 |-
42 |
-
43 | class
bayesquad.priors.Gaussian(mean: numpy.ndarray, covariance: numpy.ndarray)[source]¶
44 | Bases:
45 |bayesquad.priors.PriorA multivariate Gaussian prior.
46 |47 |
58 |48 | 49 | 50 | Parameters: -
51 |
- mean – A 1D array of shape (num_dimensions). 52 |
- covariance – A 2D array of shape (num_dimensions, num_dimensions). 53 |
-
59 |
-
60 |
mean¶
61 | ndarray – A 1D array of shape (num_dimensions).
62 |
-
65 |
-
66 |
covariance¶
67 | ndarray – A 2D array of shape (num_dimensions, num_dimensions).
68 |
-
71 |
-
72 |
precision¶
73 | ndarray – The inverse of the covariance matrix.
74 |
-
77 |
-
78 |
gradient(x: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray][source]¶
79 | See
80 |gradient()
-
97 |
-
98 | class
bayesquad.priors.Prior[source]¶
99 | Bases:
100 |abc.ABCA prior, providing methods for sampling, and for pointwise evaluation of the pdf and its derivatives.
101 |-
102 |
-
103 |
gradient(x: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray][source]¶
104 | Compute the Jacobian and Hessian of the prior’s pdf at the given set of points.
105 |106 |
120 |107 | 108 | 109 | Parameters: x – A 2D array of the points at which to evaluate the derivatives, with shape (num_points, num_dimensions). 110 |Returns: -
112 |
- jacobian – A 2D array of shape (num_points, num_dimensions), containing the value of the Jacobian at each point. 113 |
- hessian – A 3D array of shape (num_points, num_dimensions, num_dimensions), whose (i, j, k)-th element is the 114 | (j, k)-th mixed partial derivative of the pdf at the i-th point of x. 115 |
-
123 |
-
124 |
logpdf(x: numpy.ndarray) → numpy.ndarray[source]¶
125 | Evaluate the prior’s log pdf at the given set of points.
126 |127 |
138 |128 | 129 | 130 | Parameters: x – An array of shape (num_points, num_dimensions). 131 |Returns: A 1D array of shape (num_points). 133 |Return type: ndarray 135 |
-
141 |
-
142 |
sample(num_points: int = 1) → numpy.ndarray[source]¶
143 | Sample num_points points independently from the prior.
144 |145 |
154 |146 | 147 | 148 | Returns: num_points samples from the prior, as a 2D array of shape (num_points, num_dimensions). 149 |Return type: ndarray 151 |
-
103 |