1 #ifndef TIMLUTIL_H_\r
2 #define TIMLUTIL_H_\r
3 \r
4 \r
5 /******************************************************************************/\r
6 /*!\r
7 * \file timlUtil.h\r
8 * \defgroup util util\r
9 * \brief utility module\r
10 */\r
11 /* Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/\r
12 *\r
13 * Redistribution and use in source and binary forms, with or without\r
14 * modification, are permitted provided that the following conditions\r
15 * are met:\r
16 *\r
17 * Redistributions of source code must retain the above copyright\r
18 * notice, this list of conditions and the following disclaimer.\r
19 *\r
20 * Redistributions in binary form must reproduce the above copyright\r
21 * notice, this list of conditions and the following disclaimer in the\r
22 * documentation and/or other materials provided with the\r
23 * distribution.\r
24 *\r
25 * Neither the name of Texas Instruments Incorporated nor the names of\r
26 * its contributors may be used to endorse or promote products derived\r
27 * from this software without specific prior written permission.\r
28 *\r
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
40 *\r
41 ******************************************************************************/\r
42 \r
43 \r
44 /*******************************************************************************\r
45 *\r
46 * INCLUDES\r
47 *\r
48 ******************************************************************************/\r
49 \r
50 #include <stdlib.h>\r
51 #include <stdio.h>\r
52 #include <stdint.h>\r
53 #include <stdbool.h>\r
54 #include <float.h>\r
55 #include <string.h>\r
56 #include <math.h>\r
57 #include <time.h>\r
58 #include <dirent.h>\r
59 #include <omp.h>\r
60 #include <unistd.h>\r
61 #include <libgen.h>\r
62 #include "jpeglib.h"\r
63 #include "cblas.h"\r
64 \r
65 /*******************************************************************************\r
66 *\r
67 * DEFINES\r
68 *\r
69 ******************************************************************************/\r
70 \r
71 //! \ingroup util\r
72 //@{\r
73 #define TIML_UTIL_MAX_STR 100\r
74 #define TIML_UTIL_PI 3.14159265358979323846\r
75 #define ERROR_UTIL_OFFSET 3000\r
76 \r
77 \r
78 /*******************************************************************************\r
79 *\r
80 * ENUM DEFINITIONS\r
81 *\r
82 ******************************************************************************/\r
83 \r
84 typedef enum {\r
85 ERROR_UTIL_NULL_PTR = ERROR_UTIL_OFFSET,\r
86 ERROR_UTIL_MNIST_TRAINING_DATA_READING,\r
87 ERROR_UTIL_MNIST_TRAINING_DATA_ALLOCATION,\r
88 ERROR_UTIL_MNIST_TRAINING_LABEL_READING,\r
89 ERROR_UTIL_MNIST_TRAINING_LABEL_ALLOCATION,\r
90 ERROR_UTIL_MNIST_TESTING_DATA_READING,\r
91 ERROR_UTIL_MNIST_TESTING_DATA_ALLOCATION,\r
92 ERROR_UTIL_MNIST_TESTING_LABEL_READING,\r
93 ERROR_UTIL_MNIST_TESTING_LABEL_ALLOCATION,\r
94 ERROR_UTIL_CIFAR10_TRAINING_READING,\r
95 ERROR_UTIL_CIFAR10_TRAINING_ALLOCATION,\r
96 ERROR_UTIL_CIFAR10_TESTING_READING,\r
97 ERROR_UTIL_CIFAR10_TESTING_ALLOCATION,\r
98 ERROR_UTIL_CIFAR100_TRAINING_READING,\r
99 ERROR_UTIL_CIFAR100_TRAINING_ALLOCATION,\r
100 ERROR_UTIL_CIFAR100_TESTING_READING,\r
101 ERROR_UTIL_CIFAR100_TESTING_ALLOCATION,\r
102 ERROR_UTIL_READ_FLOAT_MATRIX,\r
103 ERROR_UTIL_READ_INT_MATRIX,\r
104 ERROR_UTIL_READ_FLOAT_VECTOR,\r
105 ERROR_UTIL_READ_INT_VECTOR,\r
106 ERROR_UTIL_WRITE_FLOAT_MATRIX,\r
107 ERROR_UTIL_WRITE_INT_MATRIX,\r
108 ERROR_UTIL_WRITE_FLOAT_VECTOR,\r
109 ERROR_UTIL_WRITE_INT_VECTOR,\r
110 ERROR_UTIL_MALLOC,\r
111 ERROR_UTIL_JPEG_READING\r
112 } timlUtilError;\r
113 \r
114 typedef enum {\r
115 Util_Sigmoid,\r
116 Util_Softmax,\r
117 Util_Softplus,\r
118 Util_Relu,\r
119 Util_Nrelu,\r
120 Util_Tanh,\r
121 Util_Linear\r
122 } timlUtilActivationType;\r
123 \r
124 typedef enum {\r
125 Util_CrossEntropy, Util_MSE\r
126 } timlUtilCostFunctionType;\r
127 \r
128 typedef enum {\r
129 Util_Conv2D, Util_Corr2D\r
130 } timlUtilConvType;\r
131 \r
132 typedef enum {\r
133 Util_ParamsLevel1, /**< structure text file only */\r
134 Util_ParamsLevel2, /**< structure text + parameter binary */\r
135 Util_ParamsLevel3 /**< structure text + parameter binary + state binary */\r
136 } timlUtilParamsLevel;\r
137 \r
138 typedef enum {\r
139 Util_AllocatorLevel1, /**< training mode */\r
140 Util_AllocatorLevel2, /**< testing mode */\r
141 Util_AllocatorLevel3 /**< testing mode with memory pool */\r
142 } timlUtilAllocatorLevel;\r
143 \r
144 typedef enum {\r
145 Util_CenterCrop, /**< crop the picture at the center */\r
146 Util_RandomCrop /**< randomly crop the picture */\r
147 } timlUtilCropType;\r
148 \r
149 typedef enum {\r
150 Util_Mirror, /**< mirror the picture */\r
151 Util_NoMirror, /**< do not mirror the picture */\r
152 Util_RandomMirror /**< randomly mirror the picture according to Bernoulli(0,1)*/\r
153 } timlUtilMirrorType;\r
154 \r
155 typedef enum {\r
156 Util_Constant, Util_Gaussian, Util_Uniform, Util_Xavier\r
157 } timlUtilInitializerType;\r
158 \r
159 typedef enum {\r
160 Util_Train, Util_Test, Util_Debug\r
161 } timlUtilPhase;\r
162 \r
163 \r
164 /*******************************************************************************\r
165 *\r
166 * STRUCTURE DEFINITIONS\r
167 *\r
168 ******************************************************************************/\r
169 \r
170 typedef struct {\r
171 float *data;\r
172 int row;\r
173 int col;\r
174 int channel;\r
175 } timlUtilImage;\r
176 \r
177 typedef struct {\r
178 timlUtilInitializerType type;\r
179 float val; /**< constant initializer */\r
180 float min; /**< uniform initializer */\r
181 float max; /**< uniform initializer */\r
182 float mean; /**< Gaussian initializer */\r
183 float std; /**< Gaussian initializer */\r
184 } timlUtilInitializer;\r
185 \r
186 typedef struct {\r
187 float *data;\r
188 int *label;\r
189 int row;\r
190 int col;\r
191 int channel;\r
192 int num; /**< number of images */\r
193 float *mean; /**< mean of all the images */\r
194 } timlUtilImageSet;\r
195 \r
196 \r
197 /*******************************************************************************\r
198 *\r
199 * DATABASE READ FUNCTIONS\r
200 *\r
201 ******************************************************************************/\r
202 \r
203 int timlUtilReadMNIST(const char *path, timlUtilImageSet *training, timlUtilImageSet *testing);\r
204 \r
205 int timlUtilReadCIFAR10(const char *path, timlUtilImageSet *training, timlUtilImageSet *testing);\r
206 \r
207 \r
208 /*******************************************************************************\r
209 *\r
210 * TIMING FUNCTIONS\r
211 *\r
212 ******************************************************************************/\r
213 \r
214 long timlUtilDiffTime(struct timespec start, struct timespec end);\r
215 \r
216 \r
217 /*******************************************************************************\r
218 *\r
219 * RANDOM FUNCTIONS\r
220 *\r
221 ******************************************************************************/\r
222 \r
223 int timlUtilRandDiscreteUniformRNG(int a, int b);\r
224 \r
225 int timlUtilRandContinuousUniformRNG(float *x, int dim, float a, float b);\r
226 \r
227 int timlUtilRandNormalRNG(float *x, int dim, float mean, float std);\r
228 \r
229 int timlUtilRandPerm(int *array, int n);\r
230 \r
231 \r
232 /*******************************************************************************\r
233 *\r
234 * IO FUNCTIONS\r
235 *\r
236 ******************************************************************************/\r
237 \r
238 int timlUtilFread(void* ptr, size_t size, size_t nmemb, FILE *fp);\r
239 \r
240 int timlUtilFwrite(const void *ptr, size_t size, size_t nmemb, FILE *fp);\r
241 \r
242 \r
243 /*******************************************************************************\r
244 *\r
245 * CONV FUNCTIONS\r
246 *\r
247 ******************************************************************************/\r
248 \r
249 int timlUtilConv2Valid(float *a, float *b, float *c, int aRow, int aCol, int bRow, int bCol);\r
250 \r
251 int timlUtilConv2Full(float *a, float *b, float *c, int aRow, int aCol, int bRow, int bCol);\r
252 \r
253 int timlUtilCorr2Full(float *a, float *b, float *c, int aRow, int aCol, int bRow, int bCol);\r
254 \r
255 int timlUtilConv2ImageReshapeBack(float* x, float* xReshape, int *index, int prevChannel, int xDim, int indexDim, int deviceId, int threadId);\r
256 \r
257 int timlUtilConv2ImageReshapeIndex(int *index, int aRow, int aCol, int bRow, int bCol, int padUp, int padDown, int padLeft, int padRight, int strideX, int strideY, timlUtilConvType type);\r
258 \r
259 int timlUtilConv2ImageReshape(float* xReshape, float* x, int *index, int prevChannel, int xDim, int indexDim, int deviceId, int threadId);\r
260 \r
261 \r
262 /*******************************************************************************\r
263 *\r
264 * IMAGE READ FUNCTIONS\r
265 *\r
266 ******************************************************************************/\r
267 \r
268 timlUtilImage timlUtilReadJPEG(const char *name);\r
269 \r
270 int timlUtilReadFixedSizeJPEG(const char *name, float *data, int row, int col, int channel);\r
271 \r
272 char** timlUtilScanJPEG(const char *dirName, int *imageNum);\r
273 \r
274 \r
275 /*******************************************************************************\r
276 *\r
277 * BLAS FUNCTIONS\r
278 *\r
279 ******************************************************************************/\r
280 \r
281 void timlUtilBLASdgemm(const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const double alpha, const double* A, const double* B, const double beta, double* C, int deviceId, int threadId);\r
282 \r
283 void timlUtilBLASsgemm(const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const float alpha, const float* A, const float* B, const float beta, float* C, int deviceId, int threadId);\r
284 \r
285 void timlUtilBLASdgemv(const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const double alpha, const double* A, const double* x, const double beta, double* y, int deviceId, int threadId);\r
286 \r
287 void timlUtilBLASsgemv(const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const float alpha, const float* A, const float* x, const float beta, float* y, int deviceId, int threadId);\r
288 \r
289 void timlUtilBLASsaxpy(const int N, const float alpha, const float* X, float* Y, int deviceId, int threadId);\r
290 \r
291 void timlUtilBLASdaxpy(const int N, const double alpha, const double* X, double* Y, int deviceId, int threadId);\r
292 \r
293 void timlUtilBLASscopy(const int N, const float* X, float* Y, int deviceId, int threadId);\r
294 \r
295 void timlUtilBLASdcopy(const int N, const double* X, double* Y, int deviceId, int threadId);\r
296 \r
297 void timlUtilBLASsger(const int M, const int N, const float alpha, float *x, float *y, float *A, int deviceId, int threadId);\r
298 \r
299 void timlUtilBLASdger(const int M, const int N, const double alpha, double *x, double *y, double *A, int deviceId, int threadId);\r
300 \r
301 void timlUtilBLASdscal(const int N, const double alpha, double *X, int deviceId, int threadId);\r
302 \r
303 void timlUtilBLASsscal(const int N, const float alpha, float *X, int deviceId, int threadId);\r
304 \r
305 \r
306 /*******************************************************************************\r
307 *\r
308 * BLAS AUX FUNCTIONS\r
309 *\r
310 ******************************************************************************/\r
311 \r
312 int timlUtilVectorResetFloat(float *a, int m, float val, int deviceId, int threadId);\r
313 \r
314 int timlUtilVectorResetInt(int *a, int m, int val, int deviceId, int threadId);\r
315 \r
316 float timlUtilVectorSumFloat(float *a, int m);\r
317 \r
318 int timlUtilVectorSortFloat(float *a, int n);\r
319 \r
320 int timlUtilVectorSortIndexFloat(float *a, int *index, int n);\r
321 \r
322 float timlUtilVectorMaxFloat(float *x, int n, int inc);\r
323 \r
324 int timlUtilVectorMaxIndexFloat(float *x, int n, int inc);\r
325 \r
326 int timlUtilElementWiseMultiply(float *a, const float *b, const float *c, int dim, int deviceId, int threadId);\r
327 \r
328 int timlUtilSubtract(float *x, float y, int deviceId, int threadId);\r
329 \r
330 \r
331 /*******************************************************************************\r
332 *\r
333 * CNN AUX FUNCTIONS\r
334 *\r
335 ******************************************************************************/\r
336 \r
337 int timlUtilSigmoid(float *x, float *y, int n, int deviceId, int threadId);\r
338 \r
339 int timlUtilSigmoidDerivative(float *x, float *y, int n, int deviceId, int threadId);\r
340 \r
341 int timlUtilRelu(float *x, float *y, int n, int deviceId, int threadId);\r
342 \r
343 int timlUtilReluDerivative(float *x, float *y, int n, int deviceId, int threadId);\r
344 \r
345 //int timlUtilSoftmaxDerivative(float *x, float *y, int n);\r
346 \r
347 int timlUtilTanhDerivative(float *x, float *y, int n, int deviceId, int threadId);\r
348 \r
349 float timlUtilMultinomialCrossEntropy(float *x, int label, int n);\r
350 \r
351 float timlUtilMeanSqaureError(float *x, int label, int n);\r
352 \r
353 int timlUtilSoftmax(float *x, float *y, int row, int col, int channel, int deviceId, int threadId);\r
354 \r
355 int timlUtilClassifyAccuracy(int *label, int topN, int num, int *trueLabel);\r
356 \r
357 void timlUtilTransform(float *dataOut, float *dataIn, float *dataHost, int channel, int row, int col, int rowOffset, int colOffset, int rowIn, int colIn, float scale, float *mean, timlUtilMirrorType mirrorType, int deviceId, int threadId);\r
358 \r
359 int timlUtilMaxPooling(float *outputMap, int *maxIndex, float *inputMap, int row, int col, int channel, int prevRow, int prevCol, int scaleRow, int scaleCol, int padUp, int padLeft, int strideX, int strideY, timlUtilPhase phase, int deviceId, int threadId);\r
360 \r
361 int timlUtilUndoMaxPooling(float *prevDelta, int * maxIndex, float *delta, int dim, int deviceId, int threadId);\r
362 \r
363 int timlUtilMeanPooling(float *outputMap, float *inputMap, int row, int col, int channel, int prevRow, int prevCol, int scaleRow, int scaleCol, int padUp, int padLeft, int strideX, int strideY, int deviceId, int threadId);\r
364 \r
365 int timlUtilUndoMeanPooling(float *prevDelta, float *delta, int row, int col, int channel, int prevRow, int prevCol, int scaleRow, int scaleCol, int padUp, int padLeft, int strideX, int strideY, int deviceId, int threadId);\r
366 \r
367 int timlUtilLocalContrastNormalize(float *inputMap, float *outputMap, float *denom, int row, int col, int channel, int N, float alpha, float beta, int deviceId, int threadId);\r
368 \r
369 int timlUtilLocalContrastUnnormalize(float *prevDelta, float *prevFeatureMap, float *delta, float *featureMap, float *denom, int row, int col, int channel, int N, float alpha, float beta, int deviceId, int threadId);\r
370 \r
371 int timlUtilMasking(float *inputMap, float *outputMap, int *mask, unsigned int *randomVector, int dim, float prob, int deviceId, int threadId);\r
372 \r
373 int timlUtilUnmasking(float *inputDelta, float *outputDelta, int *mask, int dim, float prob, int deviceId, int threadId);\r
374 \r
375 int timlUtilTanh(float *x, float *y, int n, int deviceId, int threadId);\r
376 \r
377 \r
378 /*******************************************************************************\r
379 *\r
380 * MISC FUNCTIONS\r
381 *\r
382 ******************************************************************************/\r
383 \r
384 int timlUtilMalloc(void** devPtr, size_t size);\r
385 \r
386 void timlUtilFree(void* ptr);\r
387 \r
388 uint32_t timlUtilReverseEndian32(register uint32_t i);\r
389 \r
390 int timlUtilElementWiseFunction(float *x, float *y, int n, float (*fun)(float));\r
391 \r
392 //@}\r
393 #endif /* TIMLUTIL_H_ */\r