# dgpsi 2.6.0
- Prediction speed with `predict()` enhanced for small testing data sets by reducing overhead caused by the multi-threading implementation.
- The Python environment now installs packages exclusively from conda-forge whenever possible. Packages from other channels will only be used if they are unavailable on conda-forge.
- A bug in `vigf()`, affecting a bundle of emulators that includes GP emulators, has now been fixed.
- The column names from the training input and output provided to `gp()` and `dgp()` are retained in the relevant slots of the returned objects, as well as in any updated objects produced by the downstream functions that operate on them.
- The column names from the testing input and output supplied to `validate()` and `design()` are retained in the relevant slots of the returned objects.
- Improved numerical stability and achieved ~30x faster speed for DGP emulators using heteroskedastic likelihoods with replicates, with or without the Vecchia approximation.
- Enhanced initialization of DGP emulators with heteroskedastic and categorical likelihoods for improved performance.
- Removed the `mode` argument from `predict()` for DGP emulators with categorical likelihoods. Predictions of class probabilities can now be obtained using either the `"mean_var"` or `"sampling"` method.
- Set the default `method` for `predict()`, `validate()`, and `plot()` to `"mean_var"`.
- Redesigned the output of `validate()` for `dgp` objects with `likelihood = "Categorical"`. See `validate()` documentation for details.
- Added support for the `nugget_est` argument in `dgp()` to control whether nuggets of GP nodes feeding into the likelihood node are estimated when `likelihood` is not `NULL`.
- Updated initial nugget values when `nugget_est = TRUE` in `dgp()`. If `likelihood = NULL`, all initial GP nuggets default to `1e-6`; otherwise, GP nodes feeding into the likelihood node default to `1e-4` and all others to `1e-6`.
- Added the `accuracy` metric to the figures produced by `plot()` for DGP emulators with categorical likelihoods.
- Fixed the confusion matrix visualization (`style = 2` in `plot()`) so that the diagonal is drawn from top-left to bottom-right.
- Updated `init_py()` to handle errors related to TOS acceptance when installing Miniconda, and to automate TOS acceptance for required channels.
- Enabled use of the `newaccelerate` BLAS library on Apple Silicon machines running macOS > 13.3.
- Added the `decouple` argument to `dgp()` to allow likelihood parameters to be modeled using separate deep Gaussian process hierarchies when `depth > 2`.
- Added the `link` argument to `dgp()` to support binary classification using either logit or probit link function when `likelihood = "Categorical"`.
- Inference for (D)GPs with homogeneous noise and replicates in the training data has been significantly enhanced, achieving over 10× speed-up.

# dgpsi 2.5.0
- Training times for DGP emulators are now approximately 30%-40% faster.
- The computation of (D)GP predictions and Leave-One-Out (LOO) evaluations is now 6-7 times faster.
- The `nb_parallel` argument has been removed from relevant functions, as multi-threading is now integrated by default.
- A Vecchia approximation, implemented under the SI framework, is now available across all functions to support large-scale emulations.
- Two new functions, `get_thread_num()` and `set_thread_num()`, allow users to inspect and adjust the number of threads used for multi-threaded computations.
- A new function, `set_vecchia()`, enables users to easily add or remove the Vecchia approximation for GP, DGP, or linked (D)GP emulators.
- Documentation now includes lifecycle status badges to highlight deprecated and newly introduced functions and arguments.
- The default value of the `nugget` parameter in DGP emulators with likelihood layers has been adjusted from `1e-6` to `1e-4`.
- A `Categorical` likelihood option has been added to the `dgp()` function’s `likelihood` argument, enabling DGP-based classification.
- An issue related to the `LD_LIBRARY` environment variable on Linux systems has been resolved via the `init_py()` function.
- The `lgp()` function has been enhanced to accept connection information among emulators in the form of a data frame, streamlining linked emulation setup.
- A new function, `set_id()`, allows users to assign unique IDs to emulators.
- The `predict()` function has been updated to accommodate predictions from DGP classifiers.  
- The `plot()` function has been updated to generate validation plots for DGP classifiers (i.e., DGP emulators with categorical likelihoods) and linked emulators created by `lgp()` using the new data frame form for `struc`.  
- The `summary()` function has been redesigned to provide both summary tables and visualizations of structure and model specifications for (D)GP and linked (D)GP emulators.  
- A `sample_size` argument has been added to the `validate()` and `plot()` functions, allowing users to adjust the number of samples used for validation when the validation method is set to `sampling`.
- `combine()` and `set_linked_idx()` are deprecated as of this version and will be removed in the next release. These two functions are no longer maintained. Please refer to the updated package documentation for alternative workflows.
- The basic node functions `kernel()`, `Hetero()`, `Poisson()`, and `NegBin()`, along with the `struc` argument in the `gp()` and `dgp()` functions, have been removed as of this version. Customization of (D)GP specifications can be achieved by modifying the other arguments in `gp()` and `dgp()`.
- The `draw()` function has been updated for instances of the `bundle` class to allow drawing of design and evaluation plots of all emulators in a single figure.  
- The `plot()` function has been updated for linked emulators generated by `lgp()` using the new data frame form for `struc`.  
- The `design()` function has been redesigned to allow new specifications of the user-supplied `method` function.  
- The `batch_size` argument has been added to `design()` to enable locating multiple design points in a single iteration of the sequential design. This argument is compatible with all built-in `method` functions: `alm()`, `mice()`, and `vigf()`.
- The `alm()` and `vigf()` functions have been redesigned to support continuous search for the next design point or search from a discrete candidate set passed through the `x_cand` argument.
- The `alm()`, `mice()`, and `vigf()` functions have been updated to output the locations of identified design points when a discrete candidate set is not supplied.  
- The `pei()` function has been removed from the package for re-engineering and will be added back in a future version.  
- The default of the `refit` argument in the `update()` function has been changed from `FALSE` to `TRUE`.  
- The `write()` function now allows `light = TRUE` for both GP emulators and bundles of GP emulators.  
- Two new functions, `serialize()` and `deserialize()`, have been added to allow users to export emulators to multi-session workers for parallel processing.
- Additional vignettes are available, showcasing large-scale DGP emulation, DGP classification, and Bayesian optimization using (D)GP emulators.
- Enhanced clarity and consistency across the documentation.
- Improved examples and explanations in vignettes for better user guidance.

# dgpsi 2.4.0
- One can now use `design()` to implement sequential designs using `f` and a fixed candidate set passed to `x_cand` with `y_cand = NULL`.
- The sizes of `.pkl` files written by `write()` are significantly reduced.
- One can now set different kernel functions to nodes in different layers in a DGP emulator by passing a vector of kernel function names to `name` argument of `dgp()`.
- The default number of imputations `B` in `dgp()` and `lgp()` is changed to `10` for faster validations and predictions.
- The default method for sequential designs in `design()` is changed to `vigf()`.
- A new argument `new_wave` is added to `design()` to allow users to resume sequential designs with or without a separate wave. 
- A bug in `vigf()` is fixed when `object` is an instance of the `bundle` class and `batch_size` is greater than one.
- Static and dynamic pruning of DGP structures are implemented in `prune()` and `design()` (via the new arguments `pruning` and `control`) respectively.
- Some redundant codes are removed from `update()` which makes `design()` slightly faster.
- `limits` argument in `design()` is now required when `x_cand` is not supplied to avoid under-sampling using the limits inferred from the training data.
- `design()` now supports `f` that produce `NA` as outputs. This is useful to prevent the sequential design from stopping due to errors or `NA` outputs from a simulator at some input locations identified by the sequential design process.
- A bug is fixed in `design()` when `x_cand` is supplied and the input dimension is one.
- `alm()`, `mice()`, `pei()`, and `vigf()` now accept separate candidate sets (even with different number of candidate points) via `x_cand` for bundle emulators.
- A slot called `id` is added to instances of `gp`, `dgp`, `lgp`, and `bundle` classes to uniquely identify the emulators. `id` can also be passed to instances of `gp`, `dgp`,`lgp`, and `bundle` classes by the new `id` argument in `gp()`, `dgp()`, `lgp()`, and `pack()`.
- `pack()` can now accept a list of (D)GP emulators as the input.
- The `check_point` argument is removed from `design()` and replaced by `autosave`.
- Automatic saving of emulators during the sequential design is added to `design()` through the new argument `autosave`.
- When a customized evaluation function is provided to `design()` via `eval`, the design information in previous waves will be retained as long as the previous waves of the sequential design also use customized evaluation functions. If different customized evaluation functions are supplied to `design()` in different waves, the trace plot of RMSEs produced by `draw()` will show RMSEs from different evaluation functions in different waves.
- One can now link the same emulator multiple times in a chain via `lgp()` by setting different linking information for the emulator via `set_linked_idx()`.
- Updates of documentations and vignettes.

# dgpsi 2.3.0
- A bug from the underlying Python implementations is fixed when `name = 'matern2.5'` in `gp()` and `dgp()`.
- Thanks to @yyimingucl, a bug from the underlying Python implementations for the MICE sequential design criterion `mice()` is fixed.
- An argument `reset` is added to `update()` and `design()` to reset hyperparameters of a (D)GP emulator to their initial values (that were specified when the emulator is initialized) after the input and output of the emulator are updated and before the emulator is refitted. This argument can be useful for sequential designs in cases where the hyperparameters of a (D)GP emulator get caught in suboptimal estimates. In such circumstances, one can set `reset = TRUE` to reinitialize the (D)GP emulator in some steps of the sequential designs as a strategy to escape the poor estimates.
- The refitting of an emulator in the final step of a sequential design is no longer forced in `design()`. 
- An argument `type` is added to `plot()` to allow users to draw OOS validation plots with testing data shown as a line instead of individual points when the emulator's input is one-dimensional and `style = 1`.
- Thanks to @tjmckinley, an issue relating to `libstdc++.so.6` on Linux machines when R is restarting after the installation of the package is fixed.
- `alm()` and `mice()` can locate new design points for stochastic simulators with (D)GP or bundle emulators that can deal with stochastic outputs.
- `design()` can be used to construct (D)GP or bundle emulators adaptively by utilizing multiple realizations from a stochastic simulator at the same design positions through the new argument `reps` when `method = alm` or `method = mice`.
- A new slot called `specs` is added to the objects returned by `gp()` and `dgp()` that contains the key information of the kernel functions used in the constructions of GP and DGP emulators.
- Due to a bug in the latest version of an underlying Python package, the emulators saved by `write()` in version `2.1.6` and `2.2.0` may not work properly with `update()` and `design()` when they are loaded back by `read()` in this version. This bug has been addressed in this version so emulators saved in this version would not have the compatibility issue in future version.
- A new sequential design criterion, called the Variance of Improvement for Global Fit (VIGF), is added to the package with the function `vigf()`.
- The sampling from an existing candidate set `x_cand` in `design()` is changed from a random sampling to a conditioned Latin Hypercube sampling in `clhs` package.
- The python environment is now automatically installed or invoked when a function from the package is executed. One does not need to run `init_py()` to activate the required python environment but `init_py()` is still useful to re-install and uninstall the underlying python environment. A `verb` argument is added to `init_py()` to switch on/off the trace information.

# dgpsi 2.2.0

- The efficiency and speed of imputations involved in the training and predictions of DGP emulators are significantly improved (achieving roughly 3x faster training and imputations) by utilizing blocked Gibbs sampling that imputes latent variables layer-wise rather than node-wise. The blocked Gibbs sampling is now the default method for DGP emulator inference and can be changed back to the old node-wise approach by setting `blocked_gibbs = FALSE` in `dgp()`.
- One can now optimize GP components that are contained in the same layer of a DGP emulator in parallel during the DGP emulator training, using multiple cores by setting the new argument `cores` in `dgp()`. This option is useful and can accelerate the training speed when the input dimension is moderately large (in which case there is a large number of GP components to be optimized) and the optimization of GP components is computationally expensive, e.g., when `share = FALSE` in which case input dimensions to individual GP components have different lengthscales.
- Thanks to @tjmckinley, a bug in `update()` when the `object` is an instance of the `dgp` class (that has been trimmed by `window()`) is fixed.
- Thanks to @tjmckinley, some R memory issues due to the underlying Python implementations are rectified.
- `set_seed()` function is added to ensure reproducible results from the package.
- A bug is fixed when candidate sets `x_cand` and `y_cand` are provided to `design()`.
- One can choose different color palettes using the new argument `color` in `plot()` when `style = 2`.
- `set_linked_idx()` allows constructions of different (D)GP emulators (in terms of different connections to the feeding layers) from a same (D)GP emulator. 

# dgpsi 2.1.6

- A bug is found in multi-core predictions in `predict()` when `object` is an instance of `lgp` class and `x` is a list. This bug has been fixed in this version.  
- Thanks to @tjmckinley, an issue (`/usr/lib/x86_64-linux-gnu/libstdc++.so.6: version 'GLIBCXX_3.4.30' not found`) encountered in Linux machines is fixed automatically during the execution of `init_py()`.
- `gp()` and `dgp()` allow users to specify the value of scale parameters and whether to estimate the parameters.
- `gp()` and `dgp()` allow users to specify the bounds of lengthscales.
- The jointly robust prior (Gu, 2019) is implemented as the default inference approach for GP emulators in `gp()`.
- The default value of `lengthscale` in `gp()` is changed from `0.2` to `0.1`, and the default value for `nugget` in `gp()` is changed from `1e-6` to `1e-8` if `nugget_est = FALSE`.
- One can now specify the number of GP nodes in each layer (except for the final layer) of a DGP emulator via the `node` argument in `dgp()`.
- Training data are now contained in the S3 classes `gp` and `dgp`.
- The RMSEs (without the min-max normalization) of emulators are now contained in the S3 classes `gp`, `dgp`, and `lgp` after the execution of `validate()`.
- `window()` function is added to trim the traces and obtain new point estimates of DGP model parameters for predictions.
- The min-max normalization can now be switched off in `plot()` by setting the value of `min_max`.
- The default number of imputations `B` for `dgp()` is changed from `50` to `30` to better balance the uncertainty and the speed of DGP emulator predictions. A new function `set_imp()` is made available to change the number of imputations of a trained DGP emulator so one can either achieve faster predictions by further reducing the number of imputations, or account for more imputation uncertainties by increasing the number of imputations, without re-training the emulator.
- The default number of imputations `B` for `continue()` is set to `NULL`, in which case the same number of imputations used in `object` will be applied.
- `nugget` argument of `dgp()` now specifies the nugget values for GP nodes in different layers rather than GP nodes in the final layer.
- The speed of predictions from DGP emulators with squared exponential kernels is significantly improved and is roughly 3x faster than the implementations in version `2.1.5`. 
- The implementation of sequential designs (with two vignettes) of (D)GP emulators using different criterion is made available.
- Thanks to @tjmckinley, an internal reordering issue in `plot()` is fixed.
- `init_py()` now allows users to reinstall and uninstall the underlying Python environment.
- A bug that occurs when a linked DGP emulator involves a DGP emulator with external inputs is fixed.
- `Intel SVML` will now be installed with the Python environment automatically for Intel users for faster implementations.

# dgpsi 2.1.5

- Initial release of the R interface to the Python package `dgpsi v2.1.5`.
