1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (c) 2020
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_mathunary.h"
#include "libavutil/avassert.h"
#define EPS 0.00001
static float get_expected(float f, DNNMathUnaryOperation op)
{
switch (op)
{
case DMUO_ABS:
return (f >= 0) ? f : -f;
case DMUO_SIN:
return sin(f);
case DMUO_COS:
return cos(f);
case DMUO_TAN:
return tan(f);
case DMUO_ASIN:
return asin(f);
case DMUO_ACOS:
return acos(f);
case DMUO_ATAN:
return atan(f);
case DMUO_SINH:
return sinh(f);
case DMUO_COSH:
return cosh(f);
case DMUO_TANH:
return tanh(f);
case DMUO_ASINH:
return asinh(f);
case DMUO_ACOSH:
return acosh(f);
case DMUO_ATANH:
return atanh(f);
case DMUO_CEIL:
return ceil(f);
case DMUO_FLOOR:
return floor(f);
case DMUO_ROUND:
return round(f);
case DMUO_EXP:
return exp(f);
default:
av_assert0(!"not supported yet");
return 0.f;
}
}
static int test(DNNMathUnaryOperation op)
{
DnnLayerMathUnaryParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*1*3*3] = {
0.1, 0.5, 0.75, -3, 2.5, 2, -2.1, 7.8, 100};
float *output;
params.un_op = op;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 3;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
ff_dnn_execute_layer_math_unary(operands, input_indexes, 1, ¶ms, NULL);
output = operands[1].data;
for (int i = 0; i < sizeof(input) / sizeof(float); ++i) {
float expected_output = get_expected(input[i], op);
int output_nan = isnan(output[i]);
int expected_nan = isnan(expected_output);
if ((!output_nan && !expected_nan && fabs(output[i] - expected_output) > EPS) ||
(output_nan && !expected_nan) || (!output_nan && expected_nan)) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int agrc, char **argv)
{
if (test(DMUO_ABS))
return 1;
if (test(DMUO_SIN))
return 1;
if (test(DMUO_COS))
return 1;
if (test(DMUO_TAN))
return 1;
if (test(DMUO_ASIN))
return 1;
if (test(DMUO_ACOS))
return 1;
if (test(DMUO_ATAN))
return 1;
if (test(DMUO_SINH))
return 1;
if (test(DMUO_COSH))
return 1;
if (test(DMUO_TANH))
return 1;
if (test(DMUO_ASINH))
return 1;
if (test(DMUO_ACOSH))
return 1;
if (test(DMUO_ATANH))
return 1;
if (test(DMUO_CEIL))
return 1;
if (test(DMUO_FLOOR))
return 1;
if (test(DMUO_ROUND))
return 1;
if (test(DMUO_EXP))
return 1;
return 0;
}
|
