nodes_value_containers.hpp 14.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
/** @file feature_creation/node/value_storage/node_value_containers.hpp
 *  @brief Centeral storage area for all descriptor matrix data
 *
 *  This file contains definitions where all descriptor/feature data is stored permanently or in temporary storage arrays
 *  All Nodes's (except ModelNodes) value_ptr/test_value_ptrs point to data here.
 *
 *  @author Thomas A. R. Purcell (tpurcell)
 *  @bug No known bugs.
 */
10
11
#ifndef NODE_VALUE_ARR
#define NODE_VALUE_ARR
Thomas Purcell's avatar
Thomas Purcell committed
12

Thomas Purcell's avatar
Thomas Purcell committed
13
#include <algorithm>
14
#include <cmath>
Thomas Purcell's avatar
Thomas Purcell committed
15
#include <memory>
Thomas Purcell's avatar
Thomas Purcell committed
16
#include <numeric>
Thomas Purcell's avatar
Thomas Purcell committed
17
#include <vector>
18
#include <iostream>
Thomas Purcell's avatar
Thomas Purcell committed
19

20
21
#include <omp.h>

Thomas Purcell's avatar
Thomas Purcell committed
22
#include"utils/enum.hpp"
Thomas Purcell's avatar
Thomas Purcell committed
23
24
25

namespace node_value_arrs
{
26
27
28
29
    extern std::vector<double> TEMP_STORAGE_ARR; //!< Array to temporarily store feature training data
    extern std::vector<double> VALUES_ARR; //!< Training data of the stored features
    extern std::vector<double> TEMP_STORAGE_TEST_ARR; //!< Array to temporarily store feature test data
    extern std::vector<double> TEST_VALUES_ARR; //!< Value of the stored features test data
Thomas Purcell's avatar
Thomas Purcell committed
30
    extern std::vector<double> D_MATRIX; //!< The descriptor matrix
31
32
33
    extern std::vector<double> PARAM_STORAGE_ARR; //!< Array to store parameterized feature values
    extern std::vector<double> PARAM_STORAGE_TEST_ARR; //!< Array to store parameterized feature values for the test set

34
35
    extern std::vector<int> TEMP_STORAGE_REG; //!< Register to see which feature is stored in each slot for the training data
    extern std::vector<int> TEMP_STORAGE_TEST_REG; //!< Register to see which feature is stored in each slot for the test data
Thomas Purcell's avatar
Thomas Purcell committed
36
37
38
    extern std::vector<int> TASK_SZ_TRAIN; //!< Number of training samples per task
    extern std::vector<int> TASK_SZ_TEST; //!< Number of test sample per task

39
    extern int N_SELECTED; //!< Number of features selected
40
41
    extern int N_SAMPLES; //!< Number of training samples for each feature
    extern int N_SAMPLES_TEST; //!< Number of test samples for each feature
Thomas Purcell's avatar
Thomas Purcell committed
42
    extern int N_PRIMARY_FEATURES; //!< Number of primary features with stored values
Thomas Purcell's avatar
Thomas Purcell committed
43
44
    extern int N_STORE_FEATURES; //!< Number of features with stored values
    extern int N_RUNGS_STORED; //!< Number of rungs with values stored
45
    extern int MAX_N_THREADS; //!< Get the maximum number of threads possible
46
    extern int N_OP_SLOTS; //!< The number of possible operator slots
47
    extern int N_PARAM_OP_SLOTS; //!< The maximum number of possible operator slots
48
    extern int MAX_RUNG; //!< The maximum rung for all features
Thomas Purcell's avatar
Thomas Purcell committed
49

Thomas Purcell's avatar
Thomas Purcell committed
50
    /**
51
52
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
Thomas Purcell's avatar
Thomas Purcell committed
53
     *
54
55
56
     * @param n_samples Number of training samples for each feature
     * @param n_samples_test Number of test samples for each feature
     * @param n_primary_feat Number of primary features
57
     * @param max_rung Largest rung of a feature
Thomas Purcell's avatar
Thomas Purcell committed
58
     * @param set_test_task_sz If True reset the task_sz vectors
59
     * @param use_params If True set up parameter storage
Thomas Purcell's avatar
Thomas Purcell committed
60
     */
61
62
63
64
65
66
67
68
    void initialize_values_arr(
        const int n_samples,
        const int n_samples_test,
        const int n_primary_feat,
        const int max_rung,
        const bool set_task_sz,
        const bool use_params
    );
Thomas Purcell's avatar
Thomas Purcell committed
69
70
71
72
73
74
75
76

    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @param n_samples Number of training samples for each feature
     * @param n_samples_test Number of test samples for each feature
     * @param n_primary_feat Number of primary features
77
     * @param max_rung Largest rung of a feature
78
     * @param use_params If True set up parameter storage
Thomas Purcell's avatar
Thomas Purcell committed
79
     */
80
81
82
83
84
85
    inline void initialize_values_arr(
        const int n_samples,
        const int n_samples_test,
        const int n_primary_feat,
        const int max_rung
    )
Thomas Purcell's avatar
Thomas Purcell committed
86
    {
87
        initialize_values_arr(n_samples, n_samples_test, n_primary_feat, max_rung, true, false);
Thomas Purcell's avatar
Thomas Purcell committed
88
89
90
91
92
93
94
95
96
    }

    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @param task_sz_train Number of training samples per task
     * @param task_sz_test Number of test sample per task
     * @param n_primary_feat Number of primary features
97
     * @param max_rung Largest rung of a feature
98
     * @param use_params If True set up parameter storage
Thomas Purcell's avatar
Thomas Purcell committed
99
     */
100
101
102
103
104
105
106
    void initialize_values_arr(
        const std::vector<int> task_sz_train,
        const std::vector<int> task_sz_test,
        const int n_primary_feat,
        const int max_rung,
        const bool use_params
    );
Thomas Purcell's avatar
Thomas Purcell committed
107
108

    /**
109
110
     * @brief Resize the node value arrays
     * @details Using the updated number of features increase the size of the storage arrays
Thomas Purcell's avatar
Thomas Purcell committed
111
112
113
114
115
     *
     * @param n_dims Number of dimensions to store
     * @param n_feat number of features to store
     * @param use_temp If true keep the temporary_storage
     */
Thomas Purcell's avatar
Thomas Purcell committed
116
    void resize_values_arr(const int n_dims, const int n_feat);
Thomas Purcell's avatar
Thomas Purcell committed
117

118
119
120
121
122
    /**
     * @brief Initialize the parameter storage array
     */
    void initialize_param_storage();

123
    /**
124
125
     * @brief Initialize the descriptor matrix
     * @details Initialize an empty descriptor matrix
126
127
128
129
130
     *
     */
    void initialize_d_matrix_arr();

    /**
131
132
     * @brief Resize the descriptor matrix
     * @details Using the number of newly selected features increase the size of the descriptor matrix
133
134
135
     *
     * @param n_select Number of features to select
     */
136
    void resize_d_matrix_arr(const int n_select);
137

Thomas Purcell's avatar
Thomas Purcell committed
138
139
140
141
142
    /**
     * @brief Reset the global TASK_SZ_TRAIN vector
     *
     * @param task_sz_train the new task_sz train
     */
143
    void set_task_sz_train(const std::vector<int> task_sz_train);
Thomas Purcell's avatar
Thomas Purcell committed
144
145
146
147
148
149

    /**
     * @brief Reset the global TASK_SZ_TEST vector
     *
     * @param task_sz_train the new test_sz train
     */
150
    void set_task_sz_test(const std::vector<int> task_sz_test);
Thomas Purcell's avatar
Thomas Purcell committed
151

152
153
154
155
156
    /**
     * @brief Get the operator slot associated with a given rung/offset
     *
     * @param rung Rung of the feature
     * @param offset Offset used to prevent overwrites
157
     * @param for_comp If true get a slot dedicated to comparing features
158
159
160
     *
     * @return The operator slot to use
     */
161
    inline int get_op_slot(const int rung, const int offset, const bool for_comp)
162
163
164
    {
        return std::abs(N_OP_SLOTS / (1 + !for_comp) - static_cast<int>(std::pow(2, MAX_RUNG - rung)) - offset);
    }
165

166
167
168
169
170
171
172
173
174
175
176
177
178
179
    /**
     * @brief Get the parameter operator slot associated with a given rung/offset
     *
     * @param rung Rung of the feature
     * @param offset Offset used to prevent overwrites
     * @param for_comp If true get a slot dedicated to comparing features
     *
     * @return The operator slot to use
     */
    inline int get_param_op_slot(const int rung, const int offset, const bool for_comp)
    {
        return std::abs(N_PARAM_OP_SLOTS / (1 + !for_comp) - static_cast<int>(std::pow(2, MAX_RUNG - rung)) - offset);
    }

Thomas Purcell's avatar
Thomas Purcell committed
180
    /**
181
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
182
     *
183
     * @param ind The Node's arr_ind
184
185
186
187
     * @param op_slot(int) Offset integer for TEMP_STORE_ARRAY
     *
     * @return The register element for a given feature index and op_slot
     */
188
    inline int& temp_storage_reg(const unsigned long int ind, const int op_slot=0)
189
190
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
191
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
192
193
        ];
    }
194
195
196
197
198
199
200
201
202

    /**
     * @brief Get a reference slot/feature register of the test data
     *
     * @param ind The Node's arr_ind
     * @param op_slot(int) Offset integer for TEMP_STORE_TEST_ARRAY
     *
     * @return The register element for a given feature index and op_slot
     */
203
    inline int& temp_storage_test_reg(const unsigned long int ind, const int op_slot=0)
204
205
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
206
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
207
208
        ];
    }
209

Thomas Purcell's avatar
Thomas Purcell committed
210
    /**
211
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
212
     *
213
     * @param ind The Node's arr_ind
214
215
     * @param rung Rung of the feature
     * @param offset Offset used to prevent overwrites
216
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
217
218
219
     *
     * @return The register element for a given feature index and offset
     */
220
    inline int& temp_storage_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
221
222
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
223
224
225
            (ind % N_PRIMARY_FEATURES) +
            (get_op_slot(rung, offset, for_comp) % N_OP_SLOTS) * N_PRIMARY_FEATURES +
            omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
226
227
        ];
    }
Thomas Purcell's avatar
Thomas Purcell committed
228

229
    /**
230
     * @brief Get a reference slot/feature register of the test data
231
     *
232
     * @param ind The Node's arr_ind
233
234
     * @param rung Rung of the feature
     * @param offset Offset used to prevent overwrites
235
     * @param for_comp If true get a slot dedicated to comparing features
236
237
238
     *
     * @return The register element for a given feature index and offset
     */
239
    inline int& temp_storage_test_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
240
241
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
242
            (ind % N_PRIMARY_FEATURES) +
Thomas Purcell's avatar
Thomas Purcell committed
243
244
            (get_op_slot(rung, offset, for_comp) % N_OP_SLOTS) * N_PRIMARY_FEATURES +
            omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
245
246
        ];
    }
247

Thomas Purcell's avatar
Thomas Purcell committed
248
    /**
249
     * @brief Access element of the permanent training data storage array
Thomas Purcell's avatar
Thomas Purcell committed
250
     *
251
     * @param feature_ind The _arr_ind of Node to get the training data of
Thomas Purcell's avatar
Thomas Purcell committed
252
     *
253
     * @return pointer to the Node's training data
Thomas Purcell's avatar
Thomas Purcell committed
254
     */
255
    inline double* access_value_arr(const unsigned long int feature_ind){return &VALUES_ARR[feature_ind*N_SAMPLES];}
256

257
    /**
258
     * @brief Access element of the permanent test data storage array
259
     *
260
     * @param feature_ind The _arr_ind of Node to get the test data of
261
     *
262
     * @return pointer to the Node's test data
263
     */
264
    inline double* access_test_value_arr(const unsigned long int feature_ind){return &TEST_VALUES_ARR[feature_ind*N_SAMPLES_TEST];}
265

Thomas Purcell's avatar
Thomas Purcell committed
266
    /**
267
     * @brief Access element of temporary storage array for the training data
Thomas Purcell's avatar
Thomas Purcell committed
268
     *
269
     * @param slot The slot of the temporary storage array
Thomas Purcell's avatar
Thomas Purcell committed
270
     *
271
     * @return pointer to the data stored in the specified slot
Thomas Purcell's avatar
Thomas Purcell committed
272
     */
273
    inline double* access_temp_storage(const unsigned long int slot){return &TEMP_STORAGE_ARR[slot*N_SAMPLES];}
274

275
    /**
276
     * @brief Access element of temporary storage array for the test data
277
     *
278
     * @param slot The slot of the temporary storage array
279
     *
280
     * @return pointer to the data stored in the specified slot
281
     */
282
    inline double* access_temp_storage_test(const unsigned long int slot){return &TEMP_STORAGE_TEST_ARR[slot*N_SAMPLES_TEST];}
283

284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    /**
     * @brief Access the param storage array
     *
     * @param rung Rung of the feature
     * @param offset(int) the offset for temporary storage access
     * @param for_comp If true get a slot dedicated to comparing features
     * @return pointer to the correct element of the PARAM_STORAGE_ARR
     */
    inline double* access_param_storage(const int rung=0, const int offset=0, const bool for_comp=false)
    {
        return &PARAM_STORAGE_ARR[
            N_SAMPLES *
            (
                (get_param_op_slot(rung, offset, for_comp) % N_PARAM_OP_SLOTS) +
                omp_get_thread_num() * (N_PARAM_OP_SLOTS + 1)
            )
        ];
    }

    /**
     * @brief Access the param storage array for the test set
     *
     * @param rung Rung of the feature
     * @param offset(int) the offset for temporary storage access
     * @param for_comp If true get a slot dedicated to comparing features
     * @return pointer to the correct element of the PARAM_STORAGE_ARR
     */
    inline double* access_param_storage_test(const int rung=0, const int offset=0, const bool for_comp=false)
    {
        return &PARAM_STORAGE_TEST_ARR[
            N_SAMPLES_TEST *
            (
                (get_param_op_slot(rung, offset, for_comp) % N_PARAM_OP_SLOTS) +
                omp_get_thread_num() * (N_PARAM_OP_SLOTS + 1)
            )
        ];
    }

Thomas Purcell's avatar
Thomas Purcell committed
322
    /**
323
     * @brief Get a Node's value_ptr
Thomas Purcell's avatar
Thomas Purcell committed
324
     *
325
326
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
327
     * @param rung Rung of the feature
328
     * @param offset(int) the offset for temporary storage access
329
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
330
331
332
     *
     * @return The value pointer
     */
333
334
335
336
337
    double* get_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
338
        const bool for_comp=false
339
    );
Thomas Purcell's avatar
Thomas Purcell committed
340

341
    /**
342
     * @brief Get a Node's test_value_ptr
343
     *
344
345
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
346
     * @param rung Rung of the feature
347
     * @param offset(int) the offset for temporary storage access
348
     * @param for_comp If true get a slot dedicated to comparing features
349
350
351
     *
     * @return The value pointer
     */
352
353
354
355
356
    double* get_test_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
357
        const bool for_comp=false
358
    );
359

360
    /**
361
     * @brief Get the pointer to a particular selected Node from sis
362
     *
363
     * @param ind Index of the data in the descriptor matrix
364
     * @return The pointer to the descriptor matrix's data
365
     */
366
    inline double* get_d_matrix_ptr(const int ind){return &D_MATRIX[ind * N_SAMPLES];}
Thomas Purcell's avatar
Bug Fix    
Thomas Purcell committed
367

368
369
370
371
    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
372
    inline void clear_temp_reg(){std::fill_n(TEMP_STORAGE_REG.begin(), TEMP_STORAGE_REG.size(), -1);}
373

374
375
376
377
    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
378
379
    inline void clear_temp_reg_thread()
    {
Thomas Purcell's avatar
Thomas Purcell committed
380
        std::fill_n(TEMP_STORAGE_REG.begin() + (N_PRIMARY_FEATURES * N_OP_SLOTS + 1) * omp_get_thread_num(), N_PRIMARY_FEATURES * N_OP_SLOTS + 1, -1);
381
    }
382

383
384
385
386
    /**
     * @brief Flush the temporary storage register (test data)
     * @details Reset all slots in the register to -1
     */
387
    inline void clear_temp_test_reg(){std::fill_n(TEMP_STORAGE_TEST_REG.begin(), TEMP_STORAGE_TEST_REG.size(), -1);}
388

Thomas Purcell's avatar
Thomas Purcell committed
389
390
}

391
#endif