作者：十岁的小男孩
QQ：929994365
能下者，上。
前言
本文是MACE的第三步即MACE环境编译出来的库在Android工程中的使用。在第一篇博文中通过mace官方提供的安卓工程进行调试，本文将其精简，只关心其数据流的逻辑过程。该工程功能是mace的demo物体识别，即传入一张图片，模型识别预测将结果在桌面显示。本人萌新一枚，学习安卓有一月多了，工程漏洞百出，望相互学习。下一篇博文会对mace做一个全面的总结。本部分的学习需要掌握JNI/NDK技术，若有问题浏览前面文章。
MACE(1)-----环境搭建：https://www.cnblogs.com/missidiot/p/9480033.html
MACE(2)-----模型编译：https://www.cnblogs.com/missidiot/p/9509831.html
JNI/NDK：https://www.cnblogs.com/missidiot/p/9716902.html
经过mace环境编译出文件如下：
此处应该有图！！！
给Android studio配置NDK版本，其版本与编译版本应一致，本文是r-16b。
新建工程，勾选c++支持选项框。
其c++标准库选择c++11。
以上工程构建完毕。
Android studio2.2版本以上采用的是CMake编译，加载库在CMakeLists.txt文件中配置。在MainActivity中加载库，如下：
库的名称自己更改：比如本文改为"mace_jni"，相对应的在CMakeLists.txt文件中修改名称和创建对应的cpp文件，即mace_jni.cpp，如下图：
在MainActivity中加载库；
static {
System.loadLibrary("mace_jni");
}
在CMakeLists.txt文件中修改；（刚开始文件如下）
cmake_minimum_required(VERSION 3.4.1)
add_library(
mace_jni
SHARED
src/main/cpp/mace_jni.cpp )
find_library(
log-lib
log )
target_link_libraries(
mace_jni
${log-lib} )
CMakeLists最终文件如下：（加载编译出的a库）
cmake_minimum_required(VERSION 3.4.1)
#set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/../app/libs/${ANDROID_ABI})
# 这块路径有点问题
include_directories(${CMAKE_SOURCE_DIR}/)
include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/public)
# libmace.a是mace编译生成的，这块以后要改的在这块
set(mace_lib ${CMAKE_SOURCE_DIR}/src/main/cpp/lib/arm64-v8a/libmace.a)
# set(mace_lib ${CMAKE_SOURCE_DIR}/src/main/cpp/lib/armeabi-v7a/libmace.a)
# mobilneet.a也是mace环境编译生成的，后期如果生成的话要改在这里
set(mobilenet_lib ${CMAKE_SOURCE_DIR}/src/main/cpp/model/arm64-v8a/mobilenet.a)
# set(mobilenet_lib ${CMAKE_SOURCE_DIR}/src/main/cpp/model/armeabi-v7a/mobilenet.a)
add_library (mace_lib STATIC IMPORTED)
set_target_properties(mace_lib PROPERTIES IMPORTED_LOCATION ${mace_lib})
add_library (mobilenet_lib STATIC IMPORTED)
set_target_properties(mobilenet_lib PROPERTIES IMPORTED_LOCATION ${mobilenet_lib})
add_library( # Sets the name of the library.
mace_jni
SHARED
src/main/cpp/mace_jni.cpp
)
find_library(
log-lib
log )
target_link_libraries( # Specifies the target library.
mace_jni
mace_lib
mobilenet_lib
${log-lib} )
创建mace_jni.cpp文件，实现native方法。
在java包下新建JniUtils.java，将native方法的声明放在其中，当然也将MainActivity中的加载库代码剪切放在JniUtils文件中。并声明三个方法，会自动在mace_jni.cpp下自动被声明。新建方法会显示红色报错，在AS中快捷键是alt+enter创建方法在mace_jni.cpp文件中。
package com.tcl.weilong.mace;
public class JniUtils {
static {
System.loadLibrary("mace_jni");
}
/**
* 给模型设置参数
* @param ompNumThreads
* @param cpuAffinityPolicy
* @param gpuPerfHint
* @param gpuPriorityHint
* @param kernelPath
* @return
*/
public native int maceMobilenetSetAttrs(int ompNumThreads, int cpuAffinityPolicy, int gpuPerfHint, int gpuPriorityHint, String kernelPath);
/**
* 给模型创建运行环境
* @param model
* @param device
* @return
*/
public native int maceMobilenetCreateEngine(String model, String device);
/**
* 模型具体核心功能，识别图片
* @param input
* @return
*/
public native float[] maceMobilenetClassify(float[] input);
}
在mace_jni.cpp文件中自动生成对声明方法的实现声明：
在build.gradle文件中更改为如下代码：
externalNativeBuild {
cmake {
cppFlags "-std=c++11 -fopenmp"
abiFilters "arm64-v8a"
}
}
将mace附带的example工程中的lib，model，public三个文件拷贝到cpp文件夹下面并在加载时候修改路径，按如下目录结构。
最为该工程核心的是在java声明的native方法在底层c/c++中具体实现，以下代码是以上三个方法在mace_jni.cpp文件中的具体实现：
#include <jni.h>
#include <algorithm>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <numeric>
#include "public/mace.h"
#include "public/mace_runtime.h"
#include "public/mace_engine_factory.h"
namespace {
struct ModelInfo {
std::string input_name;
std::string output_name;
std::vector<int64_t> input_shape;
std::vector<int64_t> output_shape;
};
//有的地方叫.cc也可以叫.cpp其实一个意思，实质为区别c文件的
struct MaceContext {
std::shared_ptr<mace::MaceEngine> engine;
std::shared_ptr<mace::KVStorageFactory> storage_factory;
std::string model_name;
mace::DeviceType device_type = mace::DeviceType::CPU;
//模型的输入输出在这里改
std::map<std::string, ModelInfo> model_infos = {
{"mobilenet_v1", {"input", "MobilenetV1/Predictions/Reshape_1",
{1, 224, 224, 3}, {1, 1001}}},
{"mobilenet_v2", {"input", "MobilenetV2/Predictions/Reshape_1",
{1, 224, 224, 3}, {1, 1001}}}
};
};
mace::DeviceType ParseDeviceType(const std::string &device) {
if (device.compare("CPU") == 0) {
return mace::DeviceType::CPU;
} else if (device.compare("GPU") == 0) {
return mace::DeviceType::GPU;
} else if (device.compare("HEXAGON") == 0) {
return mace::DeviceType::HEXAGON;
} else {
return mace::DeviceType::CPU; //默认是返回CPU
}
}
MaceContext& GetMaceContext() {
static auto *mace_context = new MaceContext;
return *mace_context;
}
} //namcspace
/**
* java+包名+类名+函数名
* Java+com.tcl.weilong.mace+JniUtils+maceMobilenetSetAttrs
*/
extern "C"
jint Java_com_tcl_weilong_mace_JniUtils_maceMobilenetSetAttrs(JNIEnv *env, jobject instance,
jint ompNumThreads, jint cpuAffinityPolicy,
jint gpuPerfHint, jint gpuPriorityHint,
jstring kernelPath_) {
MaceContext &mace_context = GetMaceContext();
mace::MaceStatus status;
// openmp ？？
status = mace::SetOpenMPThreadPolicy(
ompNumThreads,
static_cast<mace::CPUAffinityPolicy>(cpuAffinityPolicy));
// gpu
mace::SetGPUHints(
static_cast<mace::GPUPerfHint>(gpuPerfHint),
static_cast<mace::GPUPriorityHint>(gpuPriorityHint));
// opencl cache
const char *kernel_path_ptr = env->GetStringUTFChars(kernelPath_, nullptr);
if (kernel_path_ptr == nullptr) return JNI_ERR;
const std::string kernel_file_path(kernel_path_ptr);
mace_context.storage_factory.reset(
new mace::FileStorageFactory(kernel_file_path));
mace::SetKVStorageFactory(mace_context.storage_factory);
env->ReleaseStringUTFChars(kernelPath_, kernel_path_ptr);
return JNI_OK;
}
extern "C"
jint Java_com_tcl_weilong_mace_JniUtils_maceMobilenetCreateEngine(JNIEnv *env, jobject instance,
jstring model_, jstring device_) {
MaceContext &mace_context = GetMaceContext();
// parse model name
const char *model_name_ptr = env->GetStringUTFChars(model_, nullptr);
if (model_name_ptr == nullptr) return JNI_ERR;
mace_context.model_name.assign(model_name_ptr);
env->ReleaseStringUTFChars(model_, model_name_ptr);
// load model input and output name
// auto model_info_iter = mace_context.model_infos.find(mace_context.model_name);
auto model_info_iter = mace_context.model_infos.find(mace_context.model_name);
if (model_info_iter == mace_context.model_infos.end()) {
return JNI_ERR;
}
std::vector<std::string> input_names = {model_info_iter->second.input_name};
std::vector<std::string> output_names = {model_info_iter->second.output_name};
// get device
const char *device_ptr = env->GetStringUTFChars(device_, nullptr);
if (device_ptr == nullptr) return JNI_ERR;
mace_context.device_type = ParseDeviceType(device_ptr);
env->ReleaseStringUTFChars(device_, device_ptr);
mace::MaceStatus create_engine_status =
CreateMaceEngineFromCode(mace_context.model_name,
std::string(),
input_names,
output_names,
mace_context.device_type,
&mace_context.engine);
return create_engine_status == mace::MaceStatus::MACE_SUCCESS ?
JNI_OK : JNI_ERR;
}extern "C"
jfloatArray Java_com_tcl_weilong_mace_JniUtils_maceMobilenetClassify(JNIEnv *env, jobject instance,
jfloatArray input_) {
MaceContext &mace_context = GetMaceContext();
// prepare input and output
auto model_info_iter =
mace_context.model_infos.find(mace_context.model_name);
if (model_info_iter == mace_context.model_infos.end()) {
return nullptr;
}
const ModelInfo &model_info = model_info_iter->second;
const std::string &input_name = model_info.input_name;
const std::string &output_name = model_info.output_name;
const std::vector<int64_t> &input_shape = model_info.input_shape;
const std::vector<int64_t> &output_shape = model_info.output_shape;
const int64_t input_size =
std::accumulate(input_shape.begin(), input_shape.end(), 1,
std::multiplies<int64_t>());
const int64_t output_size =
std::accumulate(output_shape.begin(), output_shape.end(), 1,
std::multiplies<int64_t>());
// load input
jfloat *input_data_ptr = env->GetFloatArrayElements(input_, nullptr);
if (input_data_ptr == nullptr) return nullptr;
jsize length = env->GetArrayLength(input_);
if (length != input_size) return nullptr;
std::map<std::string, mace::MaceTensor> inputs;
std::map<std::string, mace::MaceTensor> outputs;
// construct input
auto buffer_in = std::shared_ptr<float>(new float[input_size],
std::default_delete<float[]>());
std::copy_n(input_data_ptr, input_size, buffer_in.get());
env->ReleaseFloatArrayElements(input_, input_data_ptr, 0);
inputs[input_name] = mace::MaceTensor(input_shape, buffer_in);
// construct output
auto buffer_out = std::shared_ptr<float>(new float[output_size],
std::default_delete<float[]>());
outputs[output_name] = mace::MaceTensor(output_shape, buffer_out);
// run model
mace_context.engine->Run(inputs, &outputs);
// transform output
jfloatArray jOutputData = env->NewFloatArray(output_size); // allocate
if (jOutputData == nullptr) return nullptr;
env->SetFloatArrayRegion(jOutputData, 0, output_size,
outputs[output_name].data().get()); // copy
return jOutputData;
}
以上步骤将模型底层运行环境准备好了，接下来继续封装为模型准备数据及其数据结果展示表层工作。
建立AppModel.java为模型准备输入数据和接受模型的预测结果数据作为MainActivity和底层native方法的桥梁。
说明：这个文件有四个方法，首先是对模型的设置参数，第二个是对模型创建一个运行环境实在cpu还是在gpu下运行，第三个是对识别功能准备数据将其转换为rgb，第四个是核心功能即物体识别。
package com.tcl.weilong.mace;
import android.graphics.Bitmap;
import android.os.Environment;
import android.util.Log;
import java.io.File;
import java.nio.FloatBuffer;
public class AppModel {
JniUtils jniUtils = new JniUtils();
//这些参数的值具体代表什么尚未搞清楚
int ompNumThreads = 2; //线程个数
int cpuAffinityPolicy = 0; //
int gpuPerfHint = 3; //
int gpuPriorityHint = 3; //
String kernelPath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "mace"; //内核路径
public static final String[] MODELS = new String[]{"mobilenet_v1", "mobilenet_v2"}; //模型名称，这块不要de
public static final String[] DEVICES = new String[]{"CPU", "GPU"}; //设备
String model = MODELS[1]; //mobilenet_v2
String device = DEVICES[0]; //CPU
private int[] colorValues; //存储RGB颜色数据
private FloatBuffer floatBuffer; //输入缓存
/**
* 给模型设置属性
*/
public void maceMobilenetSetAttrs(){
int attrs;
attrs = jniUtils.maceMobilenetSetAttrs(ompNumThreads,cpuAffinityPolicy,gpuPerfHint,gpuPriorityHint,kernelPath);
Log.d("idiot","attrs="+attrs);
}
/**
* 给模型创建运行引擎，cpu或者gpu
*/
public void maceMobilenetCreateEngine(){
int engine;
engine = jniUtils.maceMobilenetCreateEngine(model,device);
Log.d("idiot","engin="+engine);
}
/**
* 输入数据处理，将照片转换成数组 float[]，bitmap是224*224的大小
* @param bitmap 要处理的原始图片
* @return 将图片处理后转换成像素点进行返回
*/
public FloatBuffer dealPic(Bitmap bitmap){
//这块要创建一个224*224的图片是针对输入原始图片创建的，每一行有224个像素点，共有224行
colorValues = new int[224 * 224]; //存储像素
float[] floatValues = new float[224 * 224 * 3]; //RGB像素*3
floatBuffer = FloatBuffer.wrap(floatValues, 0, 224 * 224 * 3);
//这个函数要深究，从（0，0）点开始平移，平移尺度是单元尺寸的一个宽度。
bitmap.getPixels(colorValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
floatBuffer.rewind(); //？？
//最核心的图像像素点的变化，根本没懂
for (int i = 0; i < colorValues.length; i++) {
int value = colorValues[i];
floatBuffer.put((((value >> 16) & 0xFF) - 128f) / 128f);
floatBuffer.put((((value >> 8) & 0xFF) - 128f) / 128f);
floatBuffer.put(((value & 0xFF) - 128f) / 128f);
}
return floatBuffer;
}
/**
* 模型的分类函数
* @param input 缓存的像素点
* @return 识别结果数据，在类标中匹配识别
*/
public float[] maceMobilenetClassify(FloatBuffer input){
float[] result;
result = jniUtils.maceMobilenetClassify(input.array());
return result;
}
}
以上文件即可实现对模型输入图片的功能，下面的文件是对识别结果进行匹配。创建LableCache.java文件实现：
package com.tcl.weilong.mace;
import android.content.Context;
import android.content.res.AssetManager;
import android.util.Log;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class LabelCache {
private List<Float> floatList = new ArrayList<>(); //每张识别结果的概率
private List<String> resultLabel = new ArrayList<>(); //识别结果缓存列表
private ResultData mResultData; //
/**
* 加载类标的资源文件
* @param context 上下文
*/
public void readCacheLabelFromLocalFile(Context context) {
try {
AssetManager assetManager = context.getAssets(); //获取资源管理器
//从资源管理器中加载标签文件，所有的结果在文本文件中，识别的结果在label中去匹配
BufferedReader reader = new BufferedReader(new InputStreamReader(assetManager.open("cacheLabel.txt")));
String readLine = null;
while ((readLine = reader.readLine()) != null) {
Log.d("labelCache", "readLine = " + readLine);
resultLabel.add(readLine); //原文是移动识别，这样一张大的图片会识别很多个，将所有识别的都放在该列表里，该最简工程只识别了最小识别单元
}
reader.close();
} catch (Exception e) {
Log.e("labelCache", "error " + e);
}
}
/**
* 获取所有识别结果中概率最高的一个值进行返回
* @param floats 识别结果值： result = appModel.maceMobilenetClassify(input);
* @return 将识别的结果值存储到data中返回
*/
public ResultData getResultFirst(float[] floats) {
floatList.clear();
for (float f : floats) {
floatList.add(f);
}
float maxResult = Collections.max(floatList); //在所有识别结果中获取最大的概率即为最终识别结果
int indexResult = floatList.indexOf(maxResult);
if (indexResult < resultLabel.size()) {
String result = resultLabel.get(indexResult);
if (result != null) {
if (mResultData == null) {
mResultData = new ResultData(result, maxResult);
} else {
mResultData.updateData(result, maxResult);
}
return mResultData;
}
}
return null;
}
}
所需的资源文件为cacheLabel.txt文件在assets资源文件夹下面。
以上工作将识别的结果已经拿到，由于结果包括识别名称，识别的时间和相对应的概率，我们需要data包来封装这些数据，创建ResultData.java文件封装。
package com.tcl.weilong.mace;
public class ResultData {
public String name; //识别结果内容
public float probability; //识别的可能性，概率值
public long costTime; // 运行时间
/**
* 构造函数，只有名称和识别概率值
* @param name
* @param probability
*/
public ResultData(String name, float probability) {
this.name = name;
this.probability = probability;
}
/**
* 构造函数
* @param name
*/
public ResultData(String name) {
this.name = name;
}
/**
* 更新名称和概率值，这个函数原工程中使用用于不断的识别，更新名称显示
* @param name
* @param probability
*/
public void updateData(String name, float probability) {
this.name = name;
this.probability = probability;
}
}
接下来对拿到的数据进行展示，展示比较简单。其activity.xml文件如下：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_height="match_parent"
android:layout_width="match_parent">
<ImageView
android:id="@+id/iv"
android:layout_width="match_parent"
android:layout_height="400dp"
android:layout_gravity="center_horizontal" />
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/tv"/>
</LinearLayout>
最后MainActivity.java文件进行调度：
package com.tcl.weilong.mace;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import java.nio.FloatBuffer;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ImageView iv = findViewById(R.id.iv);
TextView tv = findViewById(R.id.tv);
float[] result;
//获取图片，图片的大小是224 * 224，由于模型的识别输入是该大小，如果是一张大图片就会顺次平移类似于CNN一样
BitmapFactory.Options options = new BitmapFactory.Options();
options.inScaled = false;
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.mouse,options);
Log.d("idiot",""+bitmap.getWidth()+";height:"+bitmap.getHeight());
iv.setImageBitmap(bitmap); //只显示了图片，这块没有意义，原意该处为图片的获取及其展示
LabelCache labelCache = new LabelCache(); //模型结果label
Context context = getApplicationContext();
labelCache.readCacheLabelFromLocalFile(context); //加载label资源文件
AppModel appModel = new AppModel();
appModel.maceMobilenetSetAttrs(); //为模型设置环境
appModel.maceMobilenetCreateEngine();
FloatBuffer input = appModel.dealPic(bitmap); //加载输入识别照片，返回缓存的像素点单元
long start = System.currentTimeMillis();
result = appModel.maceMobilenetClassify(input); //该工程的核心功能块，识别图片
long end = System.currentTimeMillis();
long costTime = end - start; //识别一张图片的时间
Toast.makeText(this,"CostTime： "+costTime+" ms",Toast.LENGTH_LONG).show();
ResultData data;
data = labelCache.getResultFirst(result); //将返回的结果对照label处理
data.costTime = costTime;
String resultt = data.name + "
" + data.probability + "
cost time(ms): " + data.costTime;
tv.setText(resultt); //展示结果
}
}
注意：
1.传入的图片是224*224大小，这个问题以后会更改。
2.运行的cpu架构是armv-8的，这个问题没有解决。
模拟器运行结果如下：采用的模拟器时间很慢。
真机测试运行时间和内存消耗结果：
CPU：
GPU：
MACE采用GPU加速，时间和硬件消耗缩减一半左右。