      {figure*}[htb!]
                [width=1.0          ]{figures/workflow.png}
        {In the first step, the user is presented with a gallery and
  scores the shown materials according to their taste. Then, a
  regression is performed to obtain a preference function via Gaussian
  Process Regression, which can be efficiently sampled for arbitrarily
  many new material recommendations. These recommendations can be
  visualized in real time using our neural network in a way that
  closely resembles the images rendered with global illumination. In
  the final step, the recommended materials can be conveniently
  assigned to an existing scene.}
      {fig:workflow}
    {figure*}

        {Overview}
      {sec:realoverview}

The overall workflow of our system consists of two stages (see also
Fig.~    {fig:workflow}). In the      {first stage}, the user is
presented with a gallery and asked to assign scores to the shown
materials. After choosing a threshold value to control the variability
of the output, a set of recommendations are computed (Section
    {sec:gpr}) and visualized via neural rendering (Section
    {sec:cnn}).          {The recommendations depend entirely on the
  user scores and may span multiple material classes. If the user
  wishes to fine-tune a subset of the recommended materials,} a latent
space is inferred for low-dimensional exploration (Section
    {sec:gplvm}). The user then evaluates the result:
        {-5mm}
      {enumerate}
          If the recommendations are acceptable -- proceed to the
          next stage,
          If the recommendations need refinement -- assign scores
          to the      {newly proposed gallery} or      {adjust past
          rankings} and compute a new round of recommendations.
          If the recommendations are not acceptable - re-assign
           the      {scores} and compute a new round of
           recommendations.
    {enumerate}
        {-5mm}
In the      {second stage}, the user can choose from two ways to
assign the recommended materials to a scene:
        {-5mm}
      {enumerate}
          Automatic workflow -- randomly assign the materials to
          the selected objects in the scene (Figures     {fig:teaser}
          (right) and     {fig:wrecking}). This is ideal for
          mass-scale material synthesis, when hundreds of materials
          are sought,
          Assisted workflow -- assign the materials to the scene
          manually and perform fine-tuning via      {variant
          generation} (Section     {sec:realtimevariant}), with color
          coding (Section     {sec:colors}). This is ideal when up to
          a few tens of materials are sought and strict control is
          required over the output (Figures     {fig:teaser} (left)
          and     {fig:variant-gen}).
    {enumerate}
        {-5mm}
         {The final scene with the newly assigned material models is
  then to be rendered offline.} In Section     {sec:overview} we first
present the three learning algorithms, which can be used for the
automatic workflow by themselves, while in Section     {sec:comb} we
show how to combine them to provide an interactive system.
 Table     {tab:notation} summarizes the notation used throughout the paper.

        {Learning Algorithms for Material Synthesis}
      {sec:overview}
 
       {enumerate}
       Assign scores, obtain recommendations and visualize them via neural rendering.
          {enumerate}
              If the recommendations are adequate - accept and proceed,
              If the recommendations point to the right direction, but need refinement - back to step 1., and assign scores to the proposed gallery,
              If the recommendations are not acceptable - back to step 1., and re-assign the scores.
        {enumerate}
       Choose workflow.
          {enumerate}
              Manual workflow - assign the materials to the scene manually and fine-tune a chosen subset of them via      {variant generation}. This ideal when up to a few tens of materials are sought and strict control is required over the outputs (Fig.     {fig:variant-gen}).
              Automatic workflow - randomly assign the materials to the scene (Figures     {fig:teaser} (right) and     {fig:wrecking}). Ideal for mass-scale material synthesis when hundreds of material models are sought. 
        {enumerate}
     {enumerate}

In this section, we outline the three main pillars of our system:
       {Gaussian Process Regression} to perform material learning and
recommendation, a        {Convolutional Neural Network} variant for
real-time image prediction, and the        {Gaussian Process Latent
  Variable Model} to embed our high-dimensional shader inputs into a
2D latent space to enable the fine-tuning of a select set of
recommended materials (Fig.     {fig:architecture}). Table
    {tab:notation} summarizes the notation used throughout the paper.

           {Material Learning and Recommendation}
      {sec:gpr}

       {figure*}[ht!]
                 [width=1.0          ]{figures/gpr-jsd.png}
                 [width=0.35          ]{figures/plots/jsd-time.png}
         {Approximating a simple 1D function with Gaussian Process Regression using 82 na\"ive samples (left). The quality of the reconstruction is greater than most other regression algorithms (e.g., neural networks), however, as the execution time scales unfavorably with the number of samples  (O(N^3)) , it should be used in scenarios where samples are scarce. This makes GPR a suitable choice to learn the material model galleries provided by the user.}
       {fig:gpr}
     {figure*}

 In this section, we describe an application of Gaussian Process
 Regression for learning material spaces and show why classical
 techniques fail to accurately solve this problem, followed by a way
 to easily exert control on the output recommendations.
In this section, we propose a combination of Gaussian Process
Regression, Automatic Relevance Determination and Resilient
Backpropagation to efficiently perform material learning and
recommendation. We also show that these recommendations are easily
controllable.

          {Material learning.} Gaussian Process Regression (GPR) is
a kernel-based Bayesian regression technique that leverages prior
knowledge to perform high-quality regression from a low number of
samples         {Throughout this manuscript, we will use the terms
     {samples} and      {observations} interchangeably.}.
 As it is endowed with additional information in the form of a covariance kernel, the quality of the reconstruction is greater than most regression techniques (e.g., neural networks, random forests or SVRs) at low sample counts. 
 However, as several steps contain computing the inverse of the covariance matrix          (Equations (    {eq:eq_start})-(    {eq:eq_end})) the execution time scales unfavorably with the number of observations, i.e.,  O(n^3) , it should be used in scenarios where samples are scarce. This makes GPR a suitable choice to minimize user interaction and learn the material model galleries provided by the user.
 The goal is to approximate a preference function  \preffungprofparam  with                   from a discrete set of  n  observations
It can be used to approximate a preference function                   from a discrete set of  n  observations
              = 
      {bmatrix}
    u(      {      }_1), u(      {      }_2),      , u(      {      }_n) \\
    {bmatrix}^T
 ,
each of which can be imagined as point samples of a Gaussian where        {      }_i \in        {R}^m  encode the parameters that yield a BSDF model. 
 In our case,  m=19           {refers to our parameter space that
 spans the most commonly used materials, i.e., a combination of
 diffuse, specular, glossy, transparent and translucent
 materials. This description is similar to Disney's ``principled
 shader''      {burley2012physically} to accommodate procedurally
 textured albedos and displacements (see Section     {sec:results} and
 the supplementary materials for this extended version where
  m=38 )}. The goal is to produce  \preffunofparamunknown  for an
 arbitrary unknown test input                 by defining a Gaussian
 Process over              .
         {We created a parameter space similar to Disney's
  ``principled shader''      {burley2012physically} that comes in two
  versions: the  m=19  variant spans the most commonly used materials,
  i.e., a combination of diffuse, specular, glossy, transparent and
  translucent materials where the extended  m=38  version additionally
  supports procedurally textured albedos and displacements (see
  Section     {sec:results} and the supplementary materials).} A
Gaussian Process is given by its mean and covariance
        (      ,      ')  that describes the relation between
individual material samples          and        ' . A squared
exponential covariance function is given as
      {equation}
           (      ,      ') =       _f^2 \,           [ -     {(       -       ')^2}{2l^2}      ] +      ^{-1}      _{xx'},
          {eq:sqexp}
    {equation}
with a given        _f^2  variance and length scale  l  where
      ^{-1}      _{xx'}  is an additional noise term enabled by the
Kronecker delta to yield a positive definite covariance matrix. This
means that a highly correlated pair             \param -       '
      \rVert         0  yields the maximum of the function, i.e.,
        (      ,      ')               _f^2 +      ^{-1}      _{xx'} ,
leading to a smooth function approximation as                  \approx
        (      {      }') .
Conversely, if             \param -       '       \rVert  is large,
the two observations show negligible correlation, therefore for a
rapidly decaying covariance function,         (      ,       ')
        0 .

      {figure}[t]
                [width=0.475          ]{figures/architecture.png}
        {A high-level overview of our pipeline: GPR is used to learn
  the user-specified material preferences and recommend new materials
  which are subsequently visualized using our Convolutional Neural
  Network. Optionally, GPLVM can be used to provide an intuitive 2D
  space for variant generation.}
      {fig:architecture}
    {figure}

The covariance matrix          is given by all possible combinations of the point samples
      {equation}
       =
          {bmatrix}
               (      _1,       _1) &        (      _1,       _2) &        &        (      _1,       _n) \\
               (      _2,       _1) &        (      _2,       _2) &        &        (      _2,       _n) \\
               &        &        &        \\
               (      _n,       _1) &        (      _n,       _2) &        &        (      _n,       _n)
        {bmatrix},
    {equation}
the diagonal of          is therefore always        _f^2 +
     ^{-1}      _{xx'} . The covariances for the unknown sample
                are written as
      {equation}
       = 
      {bmatrix}
           (             , x_1),        (             , x_2),      ,        (             , x_n)
    {bmatrix}^T,
    {equation}
(where  x_i \!\in\!               ) and          =
       (             ,              ) . We define a zero-mean Gaussian
Process over  
      {bmatrix}
            ,         (             )
    {bmatrix}^T
 
with the covariance function         (      ,       ') :

      {equation}
          {bmatrix}
                 \\ 
             (             )
        {bmatrix}
                 {N}      ( 0, 
          {bmatrix}
            &         \\        & \kstars
        {bmatrix}
          ).
    {equation}

      {table}[tb]
        {Notation used throughout this paper, in order of occurrence.}
             {             }{1.075}
\centering
          {tabular}{crr}
          \toprule
          Symbol & Description & Type \\
          \midrule
                 {x}  & BSDF description & Vector \\
           \preffungprofparam  & Preference function (Ground truth) & Scalar \\
                            & Preference function (GPR prediction) & Scalar \\
           n  & Number of GPR samples & Scalar \\
                          & Unknown BSDF test input & Vector  \\
                        & GPR training set & Matrix \\
           m  & Input BSDF dimensionality & Scalar \\
                  (      ,      ')  & Covariance function & Scalar \\
                 _f^2  & Variance & Scalar \\
           l & Length scale & Scalar \\
                ^{-1} & Noise term & Scalar \\
                 _{xx'} & Kronecker delta & Scalar \\
                  & GPR covariance matrix & Matrix \\
                      {      } & Covariance function parameterization & Vector \\
           \bm{      } & Learning rate & Vector \\
               (      {x}^{*}) & CNN image prediction of a BSDF & Matrix \\
                 {X}  & GPLVM training set & Matrix\\
                 {L}  & Low dimensional latent descriptor & Matrix \\
           l  & Latent space dimensionality & Scalar \\
                   {N}( x | \, \mu,       ^2 )  &       {1}{     {2\pi      ^2}}     (-     {(x-\mu)^2}{2      ^2})  & Scalar \\
           z & Number of GPLVM samples & Scalar \\
                 {K}^{'} & GPLVM covariance matrix & Matrix \\
               (      {l}^{*}) & Mapping from latent to observed space & Vector  \\
           m(      )  &       {1}{2}(                + \preffungprofparam)  & Scalar \\
                 & Recommendation threshold & Scalar \\
           r  & Grid resolution & Scalar  \\
           s(      {x}^{*},       {x}')  & Similarity (CNN prediction) & Scalar \\
           u(      {x}') & Preference score (GPR prediction) & Scalar \\
          \bottomrule
        {tabular}
      {tab:notation}
    {table}

We seek  \preffunofparamunknown  leaning on the knowledge that the
conditional probability  P(\preffunofparamunknown \, | \, \preffunvec
)  follows a Gaussian distribution, therefore the closed-form solution
for  \preffunofparamunknown  and its variance is obtained by
      {align*}
    \preffunofparamunknown &=               ^{-1}            , \\
          (\preffunofparamunknown) &=         -              ^{-1}        . \numberthis
          {eq:eq_start}
    {align*}
The quality of the regression depends on the choice and the
parameterization of the covariance function. If             {      } =
\{      _f^2,l\}  in (    {eq:sqexp}) is chosen poorly, the result
will suffer from severe over- or underfitting. To avoid this, a model
selection step is performed to maximize the log-likelihood of the
observed samples by choosing the appropriate hyperparameters, i.e.,
      {equation}
         P    (             |       ,            {      }    ) = -      {1}{2}            ^T       ^{-1}             -      {1}{2}      |      | -      {n}{2}      2\pi.
    {equation}

The derivatives of the log-likelihood with respect to the
hyperparameters and a learning rate  \bm{      }  are given by
      {equation}
     {        }{               _j}      P    (             |       ,            {      }    ) = -      {1}{2} \tr      \{      ( \bm{      } \bm{      }^T       ^{-1}       )      {               }{               _j}      \},
          {eq:eq_end}
    {equation}
which can be used with gradient-based optimization techniques. In some
cases, the user is looking for a class of material models where, for
instance, the surface reflectance properties are of great importance
and the choice of albedos is irrelevant (e.g., carpaint material
variants). In this case, using one fixed length scale for all features
leads to poor predictions. To this end, we have also used Automatic
Relevance Determination      {mackay1996bayesian,neal2012bayesian} and
assigned a             {      }  to each dimension (with appropriate
modifications to (    {eq:sqexp})) to open up the possibility of
discarding potentially irrelevant features. However, this
substantially increases the dimensionality of the optimization
problem, to a point where classical methods such as L-BFGS-B
     {byrd1995limited} and the Scaled Conjugate Gradient method
     {moller1993scaled} prove to be ineffective: lower learning rates
are theoretically able to find the desired minima, but slow down
considerably in shallow regions while larger learning rates introduce
oscillation near the minima.
To this end, instead of using a fixed step size that is proportional
to the local gradient, we adapt the learning rate based on the
topology of the error function by using Resilient Backpropagation
     {riedmiller1992rprop,blum2013optimization}, a technique
originally designed for training neural networks. This significantly
reduces the number of required learning steps and has always succeeded
finding usable minima in our experiments.

          {Material recommendation.}
Given enough learning samples,            will resemble the true user
preferences, therefore high-scoring material recommendations can be
obtained by simply rejection-sampling it against a minimum acceptable
score threshold. The rejection rates depend on the properties of
          : choosing a high threshold will result in high-quality
recommendations at the cost of higher rejection rates and decreased
variety. Conversely, a larger variety of recommendations can be
enforced by lowering the target threshold. Upon encountering a
rejection ratio that is unacceptably high, we extend the rejection
sampler with a low number of stochastic hillclimbing steps. This
offers a considerably improved ratio at the cost of a minimal increase
in sample correlation. Generally, we have found setting the
recommendation threshold between  40 \  and  70 \  of the maximum
possible score to be a good tradeoff between sample quality and
variety (Fig.     {fig:wrecking}, higher quality (left) --  70 \ ,
more variety (right) --  40 \ ).

      {figure}[t]
                [width=0.475          ]{figures/cnn-arch.png}
        {Our decoder network takes the shader description as an input
  and predicts its appearance. Due to the fact that we have an
  atypical problem where the input shader dimensionality is orders of
  magnitude smaller than the output, the input signal is subjected to
  a series of 1D convolution and upsampling steps.}
      {fig:cnn_architecture}
    {figure}

           {Neural Networks and Rendering}
      {sec:cnn}

 Every image in the recommendation gallery has to be rendered before
 being presented to the user. This is done via a global illumination,
 where delaying the artist's work by 40-60 seconds per image for a
 larger workflow is clearly infeasible.
After the learning and recommendation step have taken place, a gallery
is generated with a prescribed amount of recommendations. The GPR and
the recommendation steps take only a few seconds (Table
    {tab:timings}), however, rendering all 300 recommendations (a
typical number throughout our experiments) would take over 4 hours,
which is a prohibitively long time for practical use. To cut down the
time between the two steps, we introduce a neural network-based
solution. Deep neural networks are universal function approximators
that have proven to be remarkably useful for classification and
regression problems. Typically, the dimensionality of the input is
orders of magnitude larger than that of the output (e.g., image
classification). Convolutional Neural Networks
     {lecun1998gradient} (CNNs) excel at solving problems of this
form; their advantages include augmenting neurons with a receptive
field to take advantage of the locality of information in images and
their pooling operations that reduce the number of parameters in each
layer.
In this work, we are concerned with an atypical adjoint problem where
images are to be predicted pixel by pixel from the shader input,
     \!:        {R}^m \!\!             \!        {R}^p , where the
input dimensionality  m  is in the order of tens, which is to be
mapped to an output of  p  dimensions, which represents the largest
possible output that fits into the GPU memory along with its decoder
network, i.e., in our case, a  410^2  image with three color
channels. We will refer to problems of this kind as      {neural
rendering}.

      {figure*}[ht]
                [width=0.495          ]{figures/nn-predictions/best1_captioned.png}
                [width=0.495          ]{figures/nn-predictions/worst1_captioned.png}
                [width=0.495          ]{figures/nn-predictions/best2.png}
                [width=0.495          ]{figures/nn-predictions/worst2.png}
                [width=0.495          ]{figures/nn-predictions/best3.png}
                [width=0.495          ]{figures/nn-predictions/worst3.png}
        {The best (left side) and worst-case (right side) predictions
  by our neural network on a set of 250 images. Mean PSNR: 37.96dB,
  minimum: 26.05dB, maximum: 48.70dB.}
      {fig:nn_predictions}
    {figure*}

Neural rendering remains an unsolved problem in general. However, as
our case is constrained to material modeling, the geometry and
lighting setups can be kept constant, therefore it is possible to
create a sufficiently deep network and training set to predict images
that are nearly indistinguishable from the ones rendered until
convergence with full global illumination. Using deconvolutional
layers      {zeiler2010deconvolutional,noh2015learning} would be a
natural choice for       , however, as few of the most common software
packages support it and unwanted artifacts may appear during image
generation      {odena2016deconvolution}, instead, the input signal is
subjected to a series of 1D convolutions, each followed by an
upsampling layer to inflate the number of parameters as we advance
deeper into the network (Fig.     {fig:cnn_architecture}).

        This architecture is similar to the decoder part of
Convolutional Autoencoders      {masci2011stacked} and can be
described with the shorthand notation of  4 x \{ Conv1D( 64,3,1 ) --
Upsampling( 2 ) \}  -- FC( 1000 ) -- FC( 410^2\!     \!3 ), where the
parameters of the convolutional layer are      {number of filters},
     {spatial kernel size} and      {strides}, respectively. These
layers use exponential linear units      {clevert2015fast} with
Glorot-initialization      {glorot2010understanding} and are trained
via the Adam optimizer      {kingma2014adam} ( lr\!\!=\!\!10^{-3},
     _1\!\!=\!\!0.9,      _2\!\!=\!\!0.999,         \!\!=\!\!10^{-8},
     {decay}\!\!=\!\!0 ). Normally, a network of this size introduces
severe overfitting, even in the presence of
         {L}_1/        {L}_2  regularization
     {nowlan1992simplifying,zou2005regularization} or dropout
     {srivastava2014dropout}, especially if learning takes place on a
given, fixed dataset. However, as we can create our own dataset, i.e.,
a potentially infinite number of shader-image pairs via rendering, we
are able to evade this problem by creating a sufficiently large
training set.
 These images were tone mapped using a Gaussian kernel (       \!=\!1.5 )} 
         {In the interest of efficiency, we have generated  45000  LDR
  shader-image pairs with a spatial resolution of  410^2  and  250 
  samples per pixel over 4 weeks on a consumer system with a NVIDIA
  GeForce GTX TITAN X GPU}, and since no means were required to
prevent overfitting, our training process converged to
         { 10^{-2}  (RMSE)}, a negligible but non-zero          {L}_2 
training and validation loss (where a zero loss would mean containing
all the noise from the training set) in less than 30
hours.          {Our validation set contained  2500  images and the
  measured losses correlated well with real-world performance.} This
pre-trained network can be reused as long as the shader description
remains unchanged and the inference of a new image typically takes  3 
to  4  milliseconds. A further advantage of this architecture is that
similarly to Denoising Autoencoders      {vincent2010stacked}, it also
performs      {denoising} on the training samples.

A key observation is that the more layers the neural network contains,
the more high-frequency details it will be able to represent (a
similar effect has been observed in Fig 4., Saito et
al.           {saito2016photorealistic}). This means that our proposed
neural network contains enough layers to capture the important
features to maximize visual quality, but not enough to learn the
high-frequency noise contained in the dataset.
          {          }{6.5pt}
      {wrapfigure}{hr}{0.2          }
  \centering
          {-2pt}
         {-12pt}   With some placements, this is useful
          {+10pt}   
                  [width=0.2          ]{figures/noise_filter.png}
          {-20pt}   With some placements, this is useful
          {-23.75pt}   
         {-26.5pt}   
          {-28.5pt}  
           {Caption}
    {wrapfigure}
 This is a remarkable scenario where the network's predictions are
 closer to the ground truth images than the training samples used to
 train it.
Normally, this denoising process requires the presence of auxiliary
feature buffers and longer computation times      {sen2012filtering}
or other deep learning approaches using more complex architectures
     {bako2017kernel}. In our case, this step does not require any
additional complexity and is inherent to the structure of our
network. Beyond producing less noisy images in real time, this is also
a significant advantage in easing the computational load of creating
new datasets as the training images do not have to be rendered until
convergence. We took advantage of this by using only  250  samples per
pixel for each training image, which took six times less than the
standard  1500  samples that would be required for perfectly converged
training samples, cutting down the total time to produce the training
set from  24  to  4  weeks.
       {figure}[ht!]
                 [width=0.475          ]{figures/noise_filter.png}
         {Caption.}
       {fig:nn-noise}
     {figure}

           {Latent Space Variant Generation}
      {sec:gplvm}
After being presented with a gallery of material models, the user may
find that some recommendations are close to their preference, but some
require fine-tuning to fit their artistic vision for a
scene. Adjusting the materials by hand requires domain expertise and a
non-trivial amount of trial and error. In our solution, we seek a
dimensionality reduction technique that maps the shader inputs into a
2D latent space where similar materials can be intuitively
explored. Non-linear manifold learning techniques come as a natural
choice for this kind of problem, however, the most well-known methods
     {belkin2003laplacian,maaten2008visualizing,tenenbaum2000global}
could not find coherent structures in 2D. Beyond that, these
techniques are unable to interpolate between the embedded samples,
therefore they would only be useful for visualization in a latent
space, but not for exploration. Dimensionality reduction with
autoencoders      {hinton2006reducing} would require orders of
magnitude more samples to work properly (we have at most a few tens at
our disposal), which is infeasible as it would be too laborious for
the user to provide that many scores through the presented gallery.

The Gaussian Process Latent Variable Model (GPLVM)
     {lawrence2004gaussian} is a non-linear dimensionality reduction
technique which is able to embed a few tens of high-scoring materials
from the gallery         {X} =
      {bmatrix}
              {x}_i        \\
    {bmatrix}^T
 
with        {x}_i \in        {R}^m  into a set of low dimensional latent descriptors
        {L} = 
      {bmatrix}
              {l}_i        \\
    {bmatrix}^T
  with        {l}_i \in        {R}^l .
Typically,  m \! \gg \! l , in our case,  m=19  and  l=2  to make sure
that variant generation can take place conveniently on a 2D plane. The
likelihood of the high-dimensional data using  z  high-scoring
training samples is given as
      {equation}
 P     (       {X} |       {L},            {      }     ) =      _{z=1}^{Z}         {N}     (       {X}_z | \, 0, \;       {K}(      {L},      {L}|           {      }) +       ^2       {I}     ).
P     (       {X} |       {L},            {      }     ) =      _{i=1}^{z}         {N}     (       {X}_i | \,       {0}, \;       {K}^{'} \!\! +      ^{-1}       {I}     ),
    {equation}
where        {K}^{'}  is a covariance matrix similar to         
containing elements akin to (    {eq:sqexp}) with a substitution of
        (      ,      ')             k(      {l},      {l}^{'}) . In
this case, the optimization takes place jointly over the latent values
in        {L}  and             {      } , i.e.,
      {equation}
          {L}^*,            {      }^* =        _{      {L},           {      }} \,          [ P     (       {X} |       {L},            {      }     )     ].
    {equation}
Even though PCA disregards the non-linear behavior of BSDF parameters
     {lafortune1997non}, it serves as a formidable initial guess for
       {L}       {lawrence2004gaussian} and             {      }  is
initialized with a wide prior. Beyond the ability to learn efficiently
from a handful a samples, a further advantage of this method is that a
new mapping can be made between the latent and observed space
       {x}^{*}=    (      {l}^{*}) , i.e.,
      {equation}
          {bmatrix}
           {X} \\ 
           {x}^{*}
        {bmatrix}
                 {N}      ( 0, 
          {bmatrix}
           {K}^{'} &       {k}_{*}^{'T} \\       {k}_{*}^{'} &       {k}_{**}^{'}
        {bmatrix}
          ),
    {equation}
yielding the final closed-form solution
      {align*}
        (      {l}^{*})  &=       {k}_{*}^{'T}       {K}^{'-1}       {X}, \\
          (    (      {l}^{*})) &=       {k}_{**}^{'} -       {k}_{*}^{'}       {K}^{'-1}       {k}_{*}^{'T}. \numberthis
          {eq:eq_gplvm}
    {align*}
By storing and reusing        {K}^{'-1} , this mapping can be done in
negligible time, which allows the user to rapidly generate new
material variants in this 2D latent space.
