-
Notifications
You must be signed in to change notification settings - Fork 1.6k
/
MainActivity.java
211 lines (169 loc) · 7.58 KB
/
MainActivity.java
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
package com.baidu.paddle.lite;
import android.content.Context;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String textOutput = "";
String version = getVersionInfo("lite_naive_model_opt.nb", this);
textOutput += "Version: " + version + "\n";
Tensor output;
output = setInputAndRunNaiveModel("lite_naive_model_opt.nb", this);
textOutput += "\nlite_naive_model output: " + output.getFloatData()[0] + ", "
+ output.getFloatData()[1] + "\n";
textOutput += "expected: 50.2132, -28.8729\n";
Date start = new Date();
output = setInputAndRunImageModel("inception_v4_simple_opt.nb", this);
Date end = new Date();
textOutput += "\ninception_v4_simple test: " + testInceptionV4Simple(output) + "\n";
textOutput += "time: " + (end.getTime() - start.getTime()) + " ms\n";
start = new Date();
output = setInputAndRunImageModel("resnet50_opt.nb", this);
end = new Date();
textOutput += "\nresnet50 test: " + testResnet50(output) + "\n";
textOutput += "time: " + (end.getTime() - start.getTime()) + " ms\n";
start = new Date();
output = setInputAndRunImageModel("mobilenet_v1_opt.nb", this);
end = new Date();
textOutput += "\nmobilenet_v1 test: " + testMobileNetV1(output) + "\n";
textOutput += "time: " + (end.getTime() - start.getTime()) + " ms\n";
start = new Date();
output = setInputAndRunImageModel("mobilenet_v2_relu_opt.nb", this);
end = new Date();
textOutput += "\nmobilenet_v2 test: " + testMobileNetV2Relu(output) + "\n";
textOutput += "time: " + (end.getTime() - start.getTime()) + " ms\n";
TextView textView = findViewById(R.id.text_view);
textView.setText(textOutput);
}
public static String getVersionInfo(String modelName, Context context) {
String modelPath = copyFromAssetsToCache(modelName, context);
MobileConfig config = new MobileConfig();
config.setModelFromFile(modelPath);
PaddlePredictor predictor = PaddlePredictor.createPaddlePredictor(config);
return predictor.getVersion();
}
public static String copyFromAssetsToCache(String modelPath, Context context) {
String newPath = context.getCacheDir() + "/" + modelPath;
File desDir = new File(newPath);
try {
InputStream stream = context.getAssets().open(modelPath);
OutputStream output = new BufferedOutputStream(new FileOutputStream(newPath));
byte data[] = new byte[1024];
int count;
while ((count = stream.read(data)) != -1) {
output.write(data, 0, count);
}
output.flush();
output.close();
stream.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
return desDir.getPath();
}
public static Tensor runModel(String modelName, long[] dims, float[] inputBuffer, Context context) {
String modelPath = copyFromAssetsToCache(modelName, context);
MobileConfig config = new MobileConfig();
config.setModelFromFile(modelPath);
config.setPowerMode(PowerMode.LITE_POWER_HIGH);
config.setThreads(1);
PaddlePredictor predictor = PaddlePredictor.createPaddlePredictor(config);
Tensor input = predictor.getInput(0);
input.resize(dims);
input.setData(inputBuffer);
predictor.run();
Tensor output = predictor.getOutput(0);
return output;
}
public static Tensor setInputAndRunNaiveModel(String modelName, Context context) {
long[] dims = {100, 100};
float[] inputBuffer = new float[10000];
for (int i = 0; i < 10000; ++i) {
inputBuffer[i] = i;
}
return runModel(modelName, dims, inputBuffer, context);
}
/**
* Input size is 3 * 224 * 224
*
* @param modelName
* @return
*/
public static Tensor setInputAndRunImageModel(String modelName, Context context) {
long[] dims = {1, 3, 224, 224};
int item_size = 3 * 224 * 224;
float[] inputBuffer = new float[item_size];
for (int i = 0; i < item_size; ++i) {
inputBuffer[i] = 1;
}
return runModel(modelName, dims, inputBuffer, context);
}
public boolean equalsNear(float a, float b, float delta) {
return a >= b - delta && a <= b + delta;
}
public boolean expectedResult(float[] expected, Tensor result) {
if (expected.length != 20) {
return false;
}
long[] shape = result.shape();
if (shape.length != 2) {
return false;
}
if (shape[0] != 1 || shape[1] != 1000) {
return false;
}
float[] output = result.getFloatData();
if (output.length != 1000) {
return false;
}
int step = 50;
for (int i = 0; i < expected.length; ++i) {
if (!equalsNear(output[i * step], expected[i], 1e-6f)) {
return false;
}
}
return true;
}
public boolean testInceptionV4Simple(Tensor output) {
float[] expected = {0.0011684548f, 0.0010390386f, 0.0011301535f, 0.0010133048f,
0.0010259597f, 0.0010982729f, 0.00093195855f, 0.0009141837f,
0.00096620916f, 0.00089982944f, 0.0010064574f, 0.0010474789f,
0.0009782845f, 0.0009230255f, 0.0010548076f, 0.0010974824f,
0.0010612885f, 0.00089107914f, 0.0010112736f, 0.00097655767f};
return expectedResult(expected, output);
}
public boolean testResnet50(Tensor output) {
float[] expected = {0.00024139918f, 0.00020566184f, 0.00022418296f, 0.00041731037f,
0.0005366107f, 0.00016948722f, 0.00028638865f, 0.0009257241f,
0.00072681636f, 8.531815e-05f, 0.0002129998f, 0.0021168243f,
0.006387163f, 0.0037145028f, 0.0012812682f, 0.00045948103f,
0.00013535398f, 0.0002483765f, 0.00076759676f, 0.0002773295f};
return expectedResult(expected, output);
}
public boolean testMobileNetV1(Tensor output) {
float[] expected = {0.00019130898f, 9.467885e-05f, 0.00015971427f, 0.0003650665f,
0.00026431272f, 0.00060884043f, 0.0002107942f, 0.0015819625f,
0.0010323516f, 0.00010079765f, 0.00011006987f, 0.0017364529f,
0.0048292773f, 0.0013995157f, 0.0018453331f, 0.0002428986f,
0.00020211363f, 0.00013668182f, 0.0005855956f, 0.00025901722f};
return expectedResult(expected, output);
}
public boolean testMobileNetV2Relu(Tensor output) {
float[] expected = {0.00017082224f, 5.699624e-05f, 0.000260885f, 0.00016412718f,
0.00034818667f, 0.00015230637f, 0.00032959113f, 0.0014772735f,
0.0009059976f, 9.5378724e-05f, 5.386537e-05f, 0.0006427285f,
0.0070957416f, 0.0016094646f, 0.0018807327f, 0.00010506048f,
6.823785e-05f, 0.00012269315f, 0.0007806194f, 0.00022354358f};
return expectedResult(expected, output);
}
}