Loading...
Searching...
No Matches
DerivativeRbfModel.h
Go to the documentation of this file.
1/*
2** This file is part of eOn.
3** SPDX-License-Identifier: BSD-3-Clause
4** Copyright (c) 2010--present, eOn Development Team
5*/
6#pragma once
7#include <Eigen/Dense>
8#include <cmath>
9#include <nlohmann/json.hpp>
10#include <stdexcept>
11#include <vector>
12
13namespace eonc::tunneling {
14
16 Eigen::VectorXd value;
17 Eigen::MatrixXd jacobian;
18 std::vector<Eigen::MatrixXd> hessians;
19};
20
24public:
25 static DerivativeRbfModel fromJson(const nlohmann::json &data) {
26 if (data.at("kind").get<std::string>() != "derivative_rbf")
27 throw std::invalid_argument("unsupported reduced interpolant kind");
29 model.scales_ = vector(data.at("length_scales"));
30 model.constant_ = vector(data.at("constant"));
31 const Eigen::Index d = model.scales_.size(),
32 outputs = model.constant_.size();
33 if (d < 1 || outputs < 1 || !(model.scales_.array() > 0).all())
34 throw std::invalid_argument(
35 "interpolant dimensions and scales must be positive");
36 model.sites_ = matrix(data.at("sites"), d);
37 model.weights_ = matrix(data.at("weights"), outputs);
38 model.linear_ = data.contains("linear") ? matrix(data.at("linear"), d)
39 : Eigen::MatrixXd::Zero(outputs, d);
40 if (model.weights_.rows() != model.sites_.rows() ||
41 model.linear_.rows() != outputs)
42 throw std::invalid_argument("interpolant coefficient dimensions differ");
43 const auto &orders = data.at("derivative_orders");
44 if (orders.size() != static_cast<size_t>(model.sites_.rows()))
45 throw std::invalid_argument("interpolant derivative count differs");
46 for (const auto &row : orders) {
47 if (row.size() != static_cast<size_t>(d))
48 throw std::invalid_argument("interpolant derivative dimension differs");
49 std::vector<int> values;
50 int total = 0;
51 for (const auto &entry : row) {
52 const int order = entry.get<int>();
53 if (order < 0 || order > 2)
54 throw std::invalid_argument(
55 "interpolant site derivative order must be 0, 1 or 2");
56 values.push_back(order);
57 total += order;
58 }
59 if (total > 2)
60 throw std::invalid_argument(
61 "interpolant site derivative total exceeds two");
62 model.orders_.push_back(std::move(values));
63 }
64 model.quadratic_.assign(static_cast<size_t>(outputs),
65 Eigen::MatrixXd::Zero(d, d));
66 if (data.contains("quadratic")) {
67 if (data.at("quadratic").size() != static_cast<size_t>(outputs))
68 throw std::invalid_argument(
69 "interpolant quadratic output dimension differs");
70 for (Eigen::Index i = 0; i < outputs; ++i) {
71 auto h = matrix(data.at("quadratic").at(i), d);
72 if (h.rows() != d || !h.isApprox(h.transpose(), 1e-12))
73 throw std::invalid_argument(
74 "interpolant quadratic baseline must be symmetric");
75 model.quadratic_[static_cast<size_t>(i)] = std::move(h);
76 }
77 }
78 return model;
79 }
80
81 Eigen::Index dimension() const { return scales_.size(); }
82 Eigen::Index outputs() const { return constant_.size(); }
83
84 RbfEvaluation evaluate(const Eigen::VectorXd &q,
85 double scalarValueShift = 0.0) const {
86 if (q.size() != dimension() || !q.allFinite())
87 throw std::invalid_argument(
88 "interpolant coordinate dimension or finiteness differs");
89 if (!std::isfinite(scalarValueShift) ||
90 (outputs() != 1 && scalarValueShift != 0.0))
91 throw std::invalid_argument(
92 "interpolant energy shift requires a scalar output and finite value");
93 if (outputs() == 1)
94 return evaluateScalar(q, scalarValueShift);
96 for (Eigen::Index k = 0; k < outputs(); ++k) {
97 result.value[k] += .5 * q.dot(quadratic_[static_cast<size_t>(k)] * q);
98 result.jacobian.row(k) +=
99 (quadratic_[static_cast<size_t>(k)] * q).transpose();
100 }
101 std::vector<int> derivative(static_cast<size_t>(dimension()), 0);
102 for (Eigen::Index site = 0; site < sites_.rows(); ++site) {
103 result.value.noalias() +=
104 kernel(q, site, derivative) * weights_.row(site).transpose();
105 for (Eigen::Index i = 0; i < dimension(); ++i) {
106 derivative[static_cast<size_t>(i)]++;
107 result.jacobian.col(i).noalias() +=
108 kernel(q, site, derivative) * weights_.row(site).transpose();
109 for (Eigen::Index j = 0; j < dimension(); ++j) {
110 derivative[static_cast<size_t>(j)]++;
111 const double value = kernel(q, site, derivative);
112 for (Eigen::Index output = 0; output < outputs(); ++output)
113 result.hessians[static_cast<size_t>(output)](i, j) +=
114 value * weights_(site, output);
115 derivative[static_cast<size_t>(j)]--;
116 }
117 derivative[static_cast<size_t>(i)]--;
118 }
119 }
120 return result;
121 }
122
123private:
125 struct Sum {
126 long double value = 0, correction = 0;
127 void add(long double term) {
128 const long double next = value + term;
129 correction += std::abs(value) >= std::abs(term) ? (value - next) + term
130 : (term - next) + value;
131 value = next;
132 }
133 long double total() const { return value + correction; }
134 };
135
136 RbfEvaluation evaluateScalar(const Eigen::VectorXd &q, double shift) const {
137 const Eigen::Index d = dimension();
138 std::vector<Sum> jet(static_cast<size_t>(1 + d + d * d));
139 // Shift the constant before accumulating kernels, preserving relative
140 // energies.
141 jet[0].add(static_cast<long double>(constant_[0]) -
142 static_cast<long double>(shift));
143 for (Eigen::Index i = 0; i < d; ++i) {
144 jet[0].add(static_cast<long double>(linear_(0, i)) * q[i]);
145 jet[static_cast<size_t>(1 + i)].add(linear_(0, i));
146 for (Eigen::Index j = 0; j < d; ++j) {
147 const long double h = quadratic_[0](i, j);
148 jet[0].add(0.5L * q[i] * h * q[j]);
149 jet[static_cast<size_t>(1 + i)].add(h * q[j]);
150 jet[static_cast<size_t>(1 + d + i * d + j)].add(h);
151 }
152 }
153 std::vector<int> derivative(static_cast<size_t>(d), 0);
154 for (Eigen::Index site = 0; site < sites_.rows(); ++site) {
155 const long double weight = weights_(site, 0);
156 jet[0].add(weight * scalarKernel(q, site, derivative));
157 for (Eigen::Index i = 0; i < d; ++i) {
158 derivative[static_cast<size_t>(i)]++;
159 jet[static_cast<size_t>(1 + i)].add(weight *
160 scalarKernel(q, site, derivative));
161 for (Eigen::Index j = 0; j < d; ++j) {
162 derivative[static_cast<size_t>(j)]++;
163 jet[static_cast<size_t>(1 + d + i * d + j)].add(
164 weight * scalarKernel(q, site, derivative));
165 derivative[static_cast<size_t>(j)]--;
166 }
167 derivative[static_cast<size_t>(i)]--;
168 }
169 }
170 RbfEvaluation result{
171 Eigen::VectorXd(1), Eigen::MatrixXd(1, d), {Eigen::MatrixXd(d, d)}};
172 result.value[0] = static_cast<double>(jet[0].total());
173 for (Eigen::Index i = 0; i < d; ++i) {
174 result.jacobian(0, i) =
175 static_cast<double>(jet[static_cast<size_t>(1 + i)].total());
176 for (Eigen::Index j = 0; j < d; ++j)
177 result.hessians[0](i, j) = static_cast<double>(
178 jet[static_cast<size_t>(1 + d + i * d + j)].total());
179 }
180 return result;
181 }
182
183 long double scalarKernel(const Eigen::VectorXd &q, Eigen::Index site,
184 const std::vector<int> &inputOrder) const {
185 std::vector<long double> z(static_cast<size_t>(dimension()));
186 long double squared = 0;
187 for (Eigen::Index j = 0; j < dimension(); ++j) {
188 z[static_cast<size_t>(j)] =
189 (static_cast<long double>(q[j]) - sites_(site, j)) / scales_[j];
190 squared += z[static_cast<size_t>(j)] * z[static_cast<size_t>(j)];
191 }
192 long double value = std::exp(-0.5L * squared);
193 for (Eigen::Index j = 0; j < dimension(); ++j) {
194 const int input = inputOrder[static_cast<size_t>(j)];
195 const int total =
196 input + orders_[static_cast<size_t>(site)][static_cast<size_t>(j)];
197 value *= hermite(total, z[static_cast<size_t>(j)]) /
198 std::pow(static_cast<long double>(scales_[j]), total);
199 if (input % 2)
200 value = -value;
201 }
202 return value;
203 }
204
205 static Eigen::VectorXd vector(const nlohmann::json &data) {
206 if (!data.is_array())
207 throw std::invalid_argument("interpolant vector must be an array");
208 Eigen::VectorXd out(data.size());
209 for (Eigen::Index i = 0; i < out.size(); ++i)
210 out[i] = data.at(i).get<double>();
211 if (!out.allFinite())
212 throw std::invalid_argument("non-finite interpolant vector");
213 return out;
214 }
215 static Eigen::MatrixXd matrix(const nlohmann::json &data,
216 Eigen::Index columns) {
217 if (!data.is_array())
218 throw std::invalid_argument("interpolant matrix must be an array");
219 Eigen::MatrixXd out(data.size(), columns);
220 for (Eigen::Index i = 0; i < out.rows(); ++i) {
221 if (data.at(i).size() != static_cast<size_t>(columns))
222 throw std::invalid_argument("interpolant matrix column count differs");
223 for (Eigen::Index j = 0; j < columns; ++j)
224 out(i, j) = data.at(i).at(j).get<double>();
225 }
226 if (!out.allFinite())
227 throw std::invalid_argument("non-finite interpolant matrix");
228 return out;
229 }
230 template <class Scalar> static Scalar hermite(int n, Scalar z) {
231 if (n == 0)
232 return 1.;
233 if (n == 1)
234 return z;
235 Scalar previous = 1., current = z;
236 for (int k = 1; k < n; ++k) {
237 const Scalar next = z * current - k * previous;
238 previous = current;
239 current = next;
240 }
241 return current;
242 }
243 double kernel(const Eigen::VectorXd &q, Eigen::Index site,
244 const std::vector<int> &inputOrder) const {
245 const Eigen::VectorXd z =
246 (q - sites_.row(site).transpose()).array() / scales_.array();
247 double value = std::exp(-.5 * z.squaredNorm());
248 for (Eigen::Index j = 0; j < dimension(); ++j) {
249 const int input = inputOrder[static_cast<size_t>(j)];
250 const int total =
251 input + orders_[static_cast<size_t>(site)][static_cast<size_t>(j)];
252 value *= hermite(total, z[j]) / std::pow(scales_[j], total);
253 if (input % 2)
254 value = -value;
255 }
256 return value;
257 }
258 Eigen::VectorXd scales_, constant_;
259 Eigen::MatrixXd sites_, weights_, linear_;
260 std::vector<std::vector<int>> orders_;
261 std::vector<Eigen::MatrixXd> quadratic_;
262};
263} // namespace eonc::tunneling
Gaussian derivative interpolant with an explicit quadratic baseline.
RbfEvaluation evaluateScalar(const Eigen::VectorXd &q, double shift) const
static Scalar hermite(int n, Scalar z)
static Eigen::VectorXd vector(const nlohmann::json &data)
std::vector< std::vector< int > > orders_
double kernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
static DerivativeRbfModel fromJson(const nlohmann::json &data)
long double scalarKernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
RbfEvaluation evaluate(const Eigen::VectorXd &q, double scalarValueShift=0.0) const
static Eigen::MatrixXd matrix(const nlohmann::json &data, Eigen::Index columns)
std::vector< Eigen::MatrixXd > quadratic_
Compensated accumulation retains small terms beside cancelling weights.
std::vector< Eigen::MatrixXd > hessians