NeuralEngine
A Game Engine with embeded Machine Learning algorithms based on Gaussian Processes.
FgVFESparseGPLayer.h
1
11
#pragma once
12
13
#include <MachineLearning/FgSparseGPBaseLayer.h>
14
15
namespace
NeuralEngine
16
{
17
namespace
MachineLearning
18
{
19
namespace
GPModels
20
{
21
namespace
VFE
22
{
36
class
NE_IMPEXP
SGPLayer
// : public SparseGPBaseLayer
37
{
38
public
:
39
// ////////////////////////////////////////////////////////////////////////////////////////////////////
40
// /// <summary> Constructor. </summary>
41
// ///
42
// /// <remarks> , 15.05.2018. </remarks>
43
// ///
44
// /// <param name="numPoints"> Number of points. </param>
45
// /// <param name="numPseudos"> Number of pseudo inputs. </param>
46
// /// <param name="outputDim"> The output dimension. </param>
47
// /// <param name="inputDim"> The input dimension. </param>
48
// ////////////////////////////////////////////////////////////////////////////////////////////////////
49
// SGPLayer(int numPoints, int numPseudos, int outputDim, int inputDim);
50
51
// ////////////////////////////////////////////////////////////////////////////////////////////////////
52
// /// <summary> Destructor. </summary>
53
// ///
54
// /// <remarks> , 15.05.2018. </remarks>
55
// ////////////////////////////////////////////////////////////////////////////////////////////////////
56
// virtual ~SGPLayer();
57
58
// ////////////////////////////////////////////////////////////////////////////////////////////////////
59
// /// <summary> Forward prediction through cavity. </summary>
60
// ///
61
// /// <remarks>
62
// /// Computes new mean m^{\n}_{f} and covariance V^{\n}_{ff} function. From cavity
63
// /// distribution.
64
// ///
65
// /// , 16.05.2018.
66
// /// </remarks>
67
// ///
68
// /// <param name="mout"> [in,out] The m^{\n}_{f}. </param>
69
// /// <param name="vout"> [in,out] The V^{\n}_{ff}. </param>
70
// /// <param name="n"> [in,out] indexes of points to be removed from distribution. </param>
71
// /// <param name="mx"> [in,out] The inputs mx. </param>
72
// /// <param name="vx"> [in,out] (Optional) If non-null, the variances vx. </param>
73
// /// <param name="alpha"> (Optional) the alpha, weighning for alpha-divergence. </param>
74
// ////////////////////////////////////////////////////////////////////////////////////////////////////
75
// void ForwardPredictionCavity(af::array& outMout, af::array& outVout, af::array& mx, af::array* vx = nullptr, double alpha = 1.0);
76
77
// ////////////////////////////////////////////////////////////////////////////////////////////////////
78
// /// <summary> Prediction of posterior function values. </summary>
79
// ///
80
// /// <remarks> , 12.06.2018. </remarks>
81
// ///
82
// /// <param name="testX"> [in,out] The test inputs. </param>
83
// /// <param name="mf"> [in,out] mean function values. </param>
84
// /// <param name="vf"> [in,out] covariance function values. </param>
85
// ////////////////////////////////////////////////////////////////////////////////////////////////////
86
// virtual void ForwardPredictionPost(af::array& mout, af::array& vout, af::array* mx, af::array* vx = nullptr) override;
87
88
// void BackpropGradientsReg(af::array& m, af::array& v, af::array& dlogZ_dm, af::array& dlogZ_dv, af::array& x, std::map<std::string,
89
// af::array>& outGrad_hyper, std::map<std::string, af::array> outGrad_cav, double alpha = 1.0);
90
91
// ////////////////////////////////////////////////////////////////////////////////////////////////////
92
// /// <summary> Computes the weighted sum of the log-partitions of prior, post and cav. </summary>
93
// ///
94
// /// <remarks> , 25.06.2018. </remarks>
95
// ///
96
// /// <param name="alpha"> The alpha. </param>
97
// ///
98
// /// <returns> The calculated phi. </returns>
99
// ////////////////////////////////////////////////////////////////////////////////////////////////////
100
// double ComputePhi(double alpha);
101
102
// ////////////////////////////////////////////////////////////////////////////////////////////////////
103
// /// <summary> Update step of PowerEP. </summary>
104
// ///
105
// /// <remarks>
106
// ///
107
// /// Hmetal T, 08/06/2018.
108
// /// </remarks>
109
// ///
110
// /// <param name="n"> [in,out] The indexes to compute. </param>
111
// /// <param name="grad_cav"> [in,out] The gradient of the cavity functions m_f^{\n} and V_{ff}^{\m}. </param>
112
// /// <param name="alpha"> The alpha. </param>
113
// /// <param name="decay"> (Optional) the decay. </param>
114
// ////////////////////////////////////////////////////////////////////////////////////////////////////
115
// void UpdateFactor(af::array& n, std::map<std::string, af::array> grad_cav, double alpha, double decay = 0);
116
117
// virtual void InitParameters(af::array* X = nullptr) override;
118
119
// ////////////////////////////////////////////////////////////////////////////////////////////////////
120
// /// <summary> Gets number of parameters to be optimized. </summary>
121
// ///
122
// /// <remarks> , 26.06.2018. </remarks>
123
// ///
124
// /// <returns> The number parameters. </returns>
125
// ////////////////////////////////////////////////////////////////////////////////////////////////////
126
// virtual int GetNumParameters() override;
127
128
// ////////////////////////////////////////////////////////////////////////////////////////////////////
129
// /// <summary> Sets the parameters for each optimization iteration. </summary>
130
// ///
131
// /// <remarks> , 26.06.2018. </remarks>
132
// ///
133
// /// <param name="param"> The parameter. </param>
134
// ////////////////////////////////////////////////////////////////////////////////////////////////////
135
// virtual void SetParameters(const af::array& param) override;
136
137
// ////////////////////////////////////////////////////////////////////////////////////////////////////
138
// /// <summary> Gets the parameters for each optimization iteration. </summary>
139
// ///
140
// /// <remarks> , 26.06.2018. </remarks>
141
// ///
142
// /// <returns> The parameters. </returns>
143
// ////////////////////////////////////////////////////////////////////////////////////////////////////
144
// virtual af::array GetParameters() override;
145
146
//protected:
147
// ////////////////////////////////////////////////////////////////////////////////////////////////////
148
// /// <summary> Default constructor. </summary>
149
// ///
150
// /// <remarks> Hmetal T, 02/07/2018. </remarks>
151
// ////////////////////////////////////////////////////////////////////////////////////////////////////
152
// SGPLayer() { }
153
154
// ////////////////////////////////////////////////////////////////////////////////////////////////////
155
// /// <summary> Updates the parameters. </summary>
156
// ///
157
// /// <remarks> , 26.06.2018. </remarks>
158
// ////////////////////////////////////////////////////////////////////////////////////////////////////
159
// virtual void UpdateParameters() override;
160
161
// void ForwardPredictionDeterministicPost(af::array& mx, af::array* mout, af::array* vout);
162
163
// ////////////////////////////////////////////////////////////////////////////////////////////////////
164
// /// <summary> Forward prediction through deterministic cavity. </summary>
165
// ///
166
// /// <remarks>
167
// /// Projection step. Computation of cavity posterior mean and covariance function,
168
// ///
169
// /// m^{\n}_{f} = K_{fu}K_{uu}^{−1}T^{\n, −1}_{2, u}T^{\n}_{1, u},
170
// ///
171
// /// V{\n}_{ff} = K_{ff} − Q_{ff} + K_{fu}K^{−1}_{uu}T^{\n, −1}_{2, u}K^{−1}_{uu}K_{uf}.
172
// ///
173
// /// , 16.05.2018.
174
// /// </remarks>
175
// ///
176
// /// <param name="mout"> [in,out] The m^{\n}_{f}. </param>
177
// /// <param name="vout"> [in,out] The V^{\n}_{ff}. </param>
178
// /// <param name="idx"> [in,out] indexes of points to be removed from distribution. </param>
179
// /// <param name="mx"> [in,out] The inputs mx. </param>
180
// /// <param name="alpha"> (Optional) the alpha, weighning for alpha-divergence. </param>
181
// ////////////////////////////////////////////////////////////////////////////////////////////////////
182
// void ForwardPredictionDeterministicCavity(af::array& outMout, af::array& outVout, af::array& mx, double alpha = 1.0);
183
184
// ////////////////////////////////////////////////////////////////////////////////////////////////////
185
// /// <summary> Forward prediction through random cavity. </summary>
186
// ///
187
// /// <remarks> , 16.05.2018. </remarks>
188
// ///
189
// /// <param name="mout"> [in,out] The m^{\n}_{f}. </param>
190
// /// <param name="vout"> [in,out] The V^{\n}_{ff}. </param>
191
// /// <param name="idx"> [in,out] indexes of points to be removed from distribution. </param>
192
// /// <param name="mx"> [in,out] The inputs mx. </param>
193
// /// <param name="vx"> [in,out] (Optional) If non-null, the variances vx. </param>
194
// /// <param name="alpha"> (Optional) the alpha, weighning for alpha-divergence. </param>
195
// ////////////////////////////////////////////////////////////////////////////////////////////////////
196
// void ForwardPredictionRandomCavity(af::array& mout, af::array& vout, af::array& mx, af::array& vx, double alpha = 1.0);
197
198
// ////////////////////////////////////////////////////////////////////////////////////////////////////
199
// /// <summary> Calculates the cavity. </summary>
200
// ///
201
// /// <remarks>
202
// /// Deletion step: The cavity for data point n, q^{\n}(f) ∝ q^∗(f)/t^α_n(u), has a similar
203
// /// form to the posterior, but the natural parameters are modified by the deletion,
204
// ///
205
// /// T^\n_{1, u} = T_{1, u} − αT_{1, n}
206
// ///
207
// /// and
208
// ///
209
// /// T^\n_{2, u} = T_{2, u} − αT_{2, n},
210
// ///
211
// /// for yielding new mean muhat and covariance function Suhat.
212
// ///
213
// /// , 16.05.2018.
214
// /// </remarks>
215
// ///
216
// /// <param name="T2uHat"> [in,out] The cavity natural parameter T^\n_{2, u}. </param>
217
// ///
218
// /// <param name="outMuhat"> [in,out] indexes of points to be removed from distribution. </param>
219
// /// <param name="outSuhat"> [in,out] The muhat. </param>
220
// /// <param name="outT1uHat"> [in,out] The Suhat. </param>
221
// /// <param name="outT2uHat"> [in,out] The cavity natural parameter T^\n_{1, u}. </param>
222
// /// <param name="alpha"> (Optional) the alpha, weighning for alpha-divergence. </param>
223
// ////////////////////////////////////////////////////////////////////////////////////////////////////
224
// void ComputeCavity(af::array& outMuhat, af::array& outSuhat, af::array& outT1uHat, af::array& outT2uHat, double alpha = 1.0f);
225
226
// ////////////////////////////////////////////////////////////////////////////////////////////////////
227
// /// <summary> Calculates gradient contributions of cavity distribution. </summary>
228
// ///
229
// /// <remarks> , 22.06.2018. </remarks>
230
// ///
231
// /// <param name="dMucav"> [in,out] The gradient mucav. </param>
232
// /// <param name="dSucav"> [in,out] The gradient sucav. </param>
233
// /// <param name="out_dT1"> [in,out] The gradient of natural parameter 1. </param>
234
// /// <param name="out_dT2"> [in,out] The gradient of natural parameter 2. </param>
235
// /// <param name="out_dInvKuu"> [in,out] The gradient of inverse Kuu. </param>
236
// /// <param name="alpha"> (Optional) the alpha. </param>
237
// ////////////////////////////////////////////////////////////////////////////////////////////////////
238
// void ComputeCavityGradientU(af::array& dMucav, af::array& dSucav, af::array& out_dT1, af::array& out_dT2, af::array& out_dInvKuu, double alpha = 1.0f);
239
240
// ////////////////////////////////////////////////////////////////////////////////////////////////////
241
// /// <summary> Calculates the gradient contributions of posterior. </summary>
242
// ///
243
// /// <remarks> , 25.06.2018. </remarks>
244
// ///
245
// /// <param name="dMu"> [in,out] The gradient mu. </param>
246
// /// <param name="dSu"> [in,out] The gradient su. </param>
247
// /// <param name="out_dT1"> [in,out] The gradient of natural parameter 1. </param>
248
// /// <param name="out_dT2"> [in,out] The gradient of natural parameter 2. </param>
249
// ////////////////////////////////////////////////////////////////////////////////////////////////////
250
// void ComputePosteriorGradientU(af::array& dMu, af::array& dSu, af::array& out_dT1, af::array& out_dT2, af::array& out_dInvKuu);
251
252
// ////////////////////////////////////////////////////////////////////////////////////////////////////
253
// /// <summary> Calculates energy contribution phi prior. </summary>
254
// ///
255
// /// <remarks> , 26.06.2018. </remarks>
256
// ///
257
// /// <returns> The calculated phi prior. </returns>
258
// ////////////////////////////////////////////////////////////////////////////////////////////////////
259
// double ComputePhiPrior();
260
261
// ////////////////////////////////////////////////////////////////////////////////////////////////////
262
// /// <summary> Calculates energy contribution phi posterior. </summary>
263
// ///
264
// /// <remarks> , 26.06.2018. </remarks>
265
// ///
266
// /// <returns> The calculated phi posterior. </returns>
267
// ////////////////////////////////////////////////////////////////////////////////////////////////////
268
// double ComputePhiPosterior();
269
270
// ////////////////////////////////////////////////////////////////////////////////////////////////////
271
// /// <summary> Calculates energy contribution phi cavity. </summary>
272
// ///
273
// /// <remarks> , 26.06.2018. </remarks>
274
// ///
275
// /// <returns> The calculated phi cavity. </returns>
276
// ////////////////////////////////////////////////////////////////////////////////////////////////////
277
// double ComputePhiCavity();
278
279
// // PEP variables
280
// af::array afGamma;
281
// af::array afBeta;
282
// af::array afGammaHat;
283
// af::array afBetaHat;
284
285
// // natural parameters
286
// af::array T1;
287
// af::array T2;
288
289
// // Cavity temp variables
290
// af::array afMuHat; // mean^{\n} of q(u)
291
// af::array afSuHat; // covariance^{\n} of q(u)
292
// af::array afInvSuHat; // T_{2,u}
293
// af::array afInvSuMuHat; // T_{1,u}
294
295
private
:
296
//friend class boost::serialization::access;
297
298
//template<class Archive>
299
//void serialize(Archive& ar, unsigned int version)
300
//{
301
// //ar & boost::serialization::base_object<SparseGPBaseLayer>(*this);
302
// /*ar & afGamma & afBeta & afGammaHat & afBetaHat & afMuHat & afSuHat &
303
// afInvSuHat & afInvSuMuHat & T1 & T2;*/
304
//}
305
};
306
}
307
}
308
}
309
}
NeuralEngine::MachineLearning::GPModels::VFE::SGPLayer
Sparse GP layer.
Definition:
FgVFESparseGPLayer.h:37
NeuralEngine
Definition:
NeArray2.h:18
include
MachineLearning
FgVFESparseGPLayer.h
Generated by
1.9.4