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
15namespace 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}