Skip to content

Mace
Mace

Xiaomi / Mace

通知 107
Star 40
Fork 27
Mace
Mace
“4be0b9cb797e8cc93d676c3abb8f10da24cf013a”上不存在“data_backup/1.leetcode/1674-使数组互补的最少操作次数/solution.md”
提交 b7dcd8aa 编写于 作者: L liuqi
浏览文件
操作

remove used example code.

上级 650c9393
显示空白变更内容
内联 并排
Showing with 44 addition and 351 deletion
mace/examples/BUILD
浏览文件 @ b7dcd8aa
...@@ -39,15 +39,3 @@ cc_binary( ...@@ -39,15 +39,3 @@ cc_binary(
"//mace/utils:command_line_flags", "//mace/utils:command_line_flags",
], ],
) )
cc_binary(
name = "example",
srcs = ["example.cc"],
copts = ["-std=c++11", "-D_GLIBCXX_USE_C99_MATH_TR1"],
linkopts = ["-fopenmp"],
linkstatic = 1,
deps = [
"//mace/codegen:generated_models_lib",
"//mace/utils:command_line_flags",
],
)
mace/examples/example.cc 已删除 100644 → 0
浏览文件 @ 650c9393
//
// Copyright (c) 2017 XiaoMi All rights reserved.
//
/**
* Usage:
* mace_run --model=mobi_mace.pb \
* --input=input_node \
* --output=MobilenetV1/Logits/conv2d/convolution \
* --input_shape=1,3,224,224 \
* --input_file=input_data \
* --output_file=mace.out \
* --device=NEON
*/
#include <sys/time.h>
#include <fstream>
#include <numeric>
#include <iostream>
#include <cstdlib>
#include "mace/utils/command_line_flags.h"
#include "mace/core/mace.h"
#include "mace/utils/logging.h"
using namespace std;
using namespace mace;
namespace mace {
extern NetDef MACE_MODEL_FUNCTION();
}
void ParseShape(const string &str, vector<int64_t> *shape) {
string tmp = str;
while (!tmp.empty()) {
int dim = atoi(tmp.data());
shape->push_back(dim);
size_t next_offset = tmp.find(",");
if (next_offset == string::npos) {
break;
} else {
tmp = tmp.substr(next_offset + 1);
}
}
}
DeviceType ParseDeviceType(const string &device_str) {
if(device_str.compare("CPU") == 0) {
return DeviceType::CPU;
} else if (device_str.compare("NEON") == 0) {
return DeviceType::NEON;
} else if (device_str.compare("OPENCL") == 0) {
return DeviceType::OPENCL;
} else {
return DeviceType::CPU;
}
}
int main(int argc, char **argv) {
string model_file;
string input_node;
string output_node;
string input_shape;
string input_file;
string output_file;
string device;
int round = 1;
std::vector<Flag> flag_list = {
Flag("model", &model_file, "model file name"),
Flag("input", &input_node, "input node"),
Flag("output", &output_node, "output node"),
Flag("input_shape", &input_shape, "input shape, separated by comma"),
Flag("input_file", &input_file, "input file name"),
Flag("output_file", &output_file, "output file name"),
Flag("device", &device, "CPU/NEON"),
Flag("round", &round, "round"),
};
string usage = Flags::Usage(argv[0], flag_list);
const bool parse_result = Flags::Parse(&argc, argv, flag_list);
if (!parse_result) {
LOG(ERROR) << usage;
return -1;
}
VLOG(0) << "model: " << model_file << std::endl
<< "input: " << input_node << std::endl
<< "output: " << output_node << std::endl
<< "input_shape: " << input_shape << std::endl
<< "input_file: " << input_file << std::endl
<< "output_file: " << output_file << std::endl
<< "device: " << device << std::endl
<< "round: " << round << std::endl;
vector<int64_t> shape;
ParseShape(input_shape, &shape);
// load model
NetDef net_def = mace::MACE_MODEL_FUNCTION();
DeviceType device_type = ParseDeviceType(device);
VLOG(0) << device_type;
int64_t input_size = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<int64_t>());
std::unique_ptr<float[]> input_data(new float[input_size]);
// load input
ifstream in_file(input_file, ios::in | ios::binary);
in_file.read(reinterpret_cast<char *>(input_data.get()),
input_size * sizeof(float));
in_file.close();
// Init model
VLOG(0) << "Run init";
mace::MaceEngine engine(&net_def, device_type);
VLOG(0) << "Run model";
std::vector<int64_t> output_shape;
timeval tv1, tv2;
gettimeofday(&tv1, NULL);
for (int i = 0; i < round; ++i) {
engine.Run(input_data.get(), shape, output_shape);
}
gettimeofday(&tv2, NULL);
std::cout << "avg duration: "
<< ((tv2.tv_sec - tv1.tv_sec) * 1000 +
(tv2.tv_usec - tv1.tv_usec) / 1000) /
round
<< endl;
const float *output = engine.Run(input_data.get(), shape, output_shape);
if (output != nullptr) {
ofstream out_file(output_file, ios::binary);
int64_t output_size = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int64_t>());
out_file.write((const char *) (output),
output_size * sizeof(float));
out_file.flush();
out_file.close();
stringstream ss;
ss << "Output shape: [";
for (auto i : output_shape) {
ss << i << ", ";
}
ss << "]";
VLOG(0) << ss.str();
}
}
\ No newline at end of file
mace/examples/mace_run.cc
浏览文件 @ b7dcd8aa
...@@ -12,11 +12,14 @@ ...@@ -12,11 +12,14 @@
* --output_file=mace.out \ * --output_file=mace.out \
* --device=NEON * --device=NEON
*/ */
#include <sys/time.h>
#include <fstream> #include <fstream>
#include "mace/core/net.h" #include <numeric>
#include "mace/core/workspace.h" #include <iostream>
#include <cstdlib>
#include "mace/utils/command_line_flags.h" #include "mace/utils/command_line_flags.h"
#include "mace/utils/env_time.h" #include "mace/core/mace.h"
#include "mace/utils/logging.h"
using namespace std; using namespace std;
using namespace mace; using namespace mace;
...@@ -24,7 +27,7 @@ using namespace mace; ...@@ -24,7 +27,7 @@ using namespace mace;
namespace mace { namespace mace {
extern NetDef MACE_MODEL_FUNCTION(); extern NetDef MACE_MODEL_FUNCTION();
} }
void ParseShape(const string &str, vector<index_t> *shape) { void ParseShape(const string &str, vector<int64_t> *shape) {
string tmp = str; string tmp = str;
while (!tmp.empty()) { while (!tmp.empty()) {
int dim = atoi(tmp.data()); int dim = atoi(tmp.data());
...@@ -88,84 +91,59 @@ int main(int argc, char **argv) { ...@@ -88,84 +91,59 @@ int main(int argc, char **argv) {
<< "device: " << device << std::endl << "device: " << device << std::endl
<< "round: " << round << std::endl; << "round: " << round << std::endl;
vector<index_t> shape; vector<int64_t> shape;
ParseShape(input_shape, &shape); ParseShape(input_shape, &shape);
int64_t t0 = utils::NowMicros(); // load model
NetDef net_def = mace::MACE_MODEL_FUNCTION(); NetDef net_def = mace::MACE_MODEL_FUNCTION();
int64_t t1 = utils::NowMicros();
LOG(INFO) << "CreateNetDef duration: " << t1 - t0 << "us";
int64_t init_micros = t1 - t0;
t0 = utils::NowMicros();
DeviceType device_type = ParseDeviceType(device); DeviceType device_type = ParseDeviceType(device);
VLOG(1) << "Device Type" << device_type; VLOG(0) << device_type;
Workspace ws; int64_t input_size = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<int64_t>());
ws.LoadModelTensor(net_def, device_type); std::unique_ptr<float[]> input_data(new float[input_size]);
Tensor *input_tensor =
ws.CreateTensor(input_node + ":0", GetDeviceAllocator(device_type), DT_FLOAT);
input_tensor->Resize(shape);
t1 = utils::NowMicros();
init_micros += t1 - t0;
LOG(INFO) << "CreateWorkspaceTensor duration: " << t1 - t0 << "us";
// Init model
VLOG(0) << "Run init";
t0 = utils::NowMicros();
auto net = CreateNet(net_def, &ws, device_type, NetMode::INIT);
net->Run();
t1 = utils::NowMicros();
init_micros += t1 - t0;
LOG(INFO) << "Net init duration: " << t1 - t0 << "us";
// run model
t0 = utils::NowMicros();
net = CreateNet(net_def, &ws, device_type);
t1 = utils::NowMicros();
init_micros += t1 - t0;
LOG(INFO) << "Total init duration: " << init_micros << "us";
{
Tensor::MappingGuard input_guard(input_tensor);
float *input_data = input_tensor->mutable_data<float>();
// load input // load input
ifstream in_file(input_file, ios::in | ios::binary); ifstream in_file(input_file, ios::in | ios::binary);
in_file.read(reinterpret_cast<char *>(input_data), in_file.read(reinterpret_cast<char *>(input_data.get()),
input_tensor->size() * sizeof(float)); input_size * sizeof(float));
in_file.close(); in_file.close();
}
// Init model
VLOG(0) << "Run init";
mace::MaceEngine engine(&net_def, device_type);
std::vector<int64_t> output_shape;
VLOG(0) << "warm up";
// warm up // warm up
VLOG(0) << "Warm up"; for (int i = 0; i < 1; ++i) {
t0 = utils::NowMicros(); engine.Run(input_data.get(), shape, output_shape);
net->Run();
t1 = utils::NowMicros();
LOG(INFO) << "1st run duration: " << t1 - t0 << "us";
VLOG(0) << "Run";
t0 = utils::NowMicros();
for (int i = 0; i < round; ++i) {
net->Run();
} }
t1 = utils::NowMicros();
LOG(INFO) << "Average duration: " << (t1 - t0) / round << "us";
// save output
const Tensor *output = ws.GetTensor(output_node + ":0");
std::remove(output_file.c_str()); VLOG(0) << "Run model";
timeval tv1, tv2;
gettimeofday(&tv1, NULL);
for (int i = 0; i < round; ++i) {
engine.Run(input_data.get(), shape, output_shape);
}
gettimeofday(&tv2, NULL);
std::cout << "avg duration: "
<< ((tv2.tv_sec - tv1.tv_sec) * 1000 +
(tv2.tv_usec - tv1.tv_usec) / 1000) /
round
<< endl;
const float *output = engine.Run(input_data.get(), shape, output_shape);
if (output != nullptr) { if (output != nullptr) {
Tensor::MappingGuard output_guard(output);
ofstream out_file(output_file, ios::binary); ofstream out_file(output_file, ios::binary);
out_file.write((const char *)(output->data<float>()), int64_t output_size = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int64_t>());
output->size() * sizeof(float)); out_file.write((const char *) (output),
output_size * sizeof(float));
out_file.flush(); out_file.flush();
out_file.close(); out_file.close();
stringstream ss; stringstream ss;
ss << "Output shape: ["; ss << "Output shape: [";
for (int i = 0; i < output->dim_size(); ++i) { for (auto i : output_shape) {
ss << output->dim(i) << ", "; ss << i << ", ";
} }
ss << "]"; ss << "]";
VLOG(0) << ss.str(); VLOG(0) << ss.str();
......
tools/validate_example.sh 已删除 100644 → 0
浏览文件 @ 650c9393
#!/bin/bash
# Must run at root dir of mace project.
set +x
Usage() {
echo 'Usage: bash tools/validate_gcn.sh tf_model_path image_size [tuning]'
}
if [ $# -lt 2 ];then
Usage
exit -1
fi
TF_MODEL_FILE_PATH=$1
MODEL_DIR=$(dirname ${TF_MODEL_FILE_PATH})
MACE_SOURCE_DIR=`/bin/pwd`
MACE_MODEL_NAME='mace_model.pb'
INPUT_FILE_NAME='model_input'
OUTPUT_FILE_NAME='gcn.out'
OUTPUT_LIST_FILE='gcn.list'
PHONE_DATA_DIR="/data/local/tmp/${MACE_MODEL_NAME}"
KERNEL_DIR="${PHONE_DATA_DIR}/cl/"
IMAGE_SIZE=$2
MODEL_TAG=GCN${IMAGE_SIZE}
CODEGEN_DIR=${MACE_SOURCE_DIR}/mace/codegen
MODEL_CODEGEN_DIR=${CODEGEN_DIR}/models/gcn-$IMAGE_SIZE
CL_CODEGEN_DIR=${CODEGEN_DIR}/opencl
CL_BIN_DIR=${CODEGEN_DIR}/opencl_bin
TUNING_CODEGEN_DIR=${CODEGEN_DIR}/tuning
TUNING_OR_NOT=${3:-0}
build_and_run()
{
EMBED_OPENCL_BINARY=$1
if [ "$EMBED_OPENCL_BINARY" = true ]; then
EMBED_OPENCL_BINARY_BUILD_FLAGS="--define embed_binary_program=true"
fi
bazel build -c opt --strip always mace/examples:example \
--crosstool_top=//external:android/crosstool \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
--cpu=arm64-v8a \
$EMBED_OPENCL_BINARY_BUILD_FLAGS \
--copt=-DMACE_MODEL_FUNCTION=Create${MODEL_TAG}
adb shell "mkdir -p ${PHONE_DATA_DIR}"
if [ "$EMBED_OPENCL_BINARY" = false ]; then
adb shell "rm -rf ${KERNEL_DIR}"
adb shell "mkdir -p ${KERNEL_DIR}"
adb push mace/kernels/opencl/cl/. ${KERNEL_DIR}
fi
adb push ${MODEL_DIR}/${INPUT_FILE_NAME} ${PHONE_DATA_DIR}
adb push bazel-bin/mace/examples/example ${PHONE_DATA_DIR}
num_threads=${1:-4}
if [[ "${TUNING_OR_NOT}" != "0" && "$EMBED_OPENCL_BINARY" != true ]];then
tuning_flag=1
else
tuning_flag=0
fi
adb </dev/null shell MACE_TUNING=${tuning_flag} \
MACE_CPP_MIN_VLOG_LEVEL=0 \
MACE_RUN_PARAMETER_PATH=${PHONE_DATA_DIR}/mace_run.config \
MACE_KERNEL_PATH=$KERNEL_DIR \
OMP_NUM_THREADS=$num_threads \
${PHONE_DATA_DIR}/example \
--model=${PHONE_DATA_DIR}/${MACE_MODEL_NAME} \
--input=mace_input_node \
--output=mace_output_node \
--input_shape="1,${IMAGE_SIZE},${IMAGE_SIZE},3"\
--input_file=${PHONE_DATA_DIR}/${INPUT_FILE_NAME} \
--output_file=${PHONE_DATA_DIR}/${OUTPUT_FILE_NAME} \
--device=OPENCL \
--round=2
}
echo "Step 1: Generate input data"
python tools/validate.py --generate_data true --random_seed 1 \
--input_file=${MODEL_DIR}/${INPUT_FILE_NAME} \
--input_shape="${IMAGE_SIZE},${IMAGE_SIZE},3"
echo "Step 2: Convert tf model to mace model and optimize memory"
bazel build //mace/python/tools:tf_converter
rm -rf ${CODEGEN_DIR}/models
mkdir -p ${MODEL_CODEGEN_DIR}
bazel-bin/mace/python/tools/tf_converter --input=${TF_MODEL_FILE_PATH} \
--output=${MODEL_CODEGEN_DIR}/mace_gcn${IMAGE_SIZE}.cc \
--input_node=input \
--output_node=GCN/br_result_2/fcn_br \
--data_type=DT_HALF \
--runtime=gpu \
--output_type=source \
--template=${MACE_SOURCE_DIR}/mace/python/tools/model.template \
--model_tag=${MODEL_TAG} \
--confuse=True
echo "Step 3: Run model on the phone with files"
build_and_run false
echo "Step 4: Generate OpenCL binary program and config code"
rm -rf ${CL_BIN_DIR}
adb pull ${KERNEL_DIR} ${CL_BIN_DIR}
rm -rf ${CL_CODEGEN_DIR}
mkdir -p ${CL_CODEGEN_DIR}
python mace/python/tools/opencl_codegen.py \
--cl_binary_dir=${CL_BIN_DIR} --output_path=${CL_CODEGEN_DIR}/opencl_compiled_program.cc
echo "Step 5: Generate tuning source file"
adb pull ${PHONE_DATA_DIR}/mace_run.config ${CL_BIN_DIR}
mkdir -p ${TUNING_CODEGEN_DIR}
python mace/python/tools/binary_codegen.py \
--binary_file=${CL_BIN_DIR}/mace_run.config --output_path=${TUNING_CODEGEN_DIR}/tuning_params.cc
echo "Step 6: Run model on the phone using binary"
build_and_run true
echo "Step 7: Pull the mace run result."
rm -rf ${MODEL_DIR}/${OUTPUT_FILE_NAME}
adb </dev/null pull ${PHONE_DATA_DIR}/${OUTPUT_FILE_NAME} ${MODEL_DIR}
echo "Step 8: Validate the result"
python tools/validate.py --model_file ${TF_MODEL_FILE_PATH} \
--input_file ${MODEL_DIR}/${INPUT_FILE_NAME} \
--mace_out_file ${MODEL_DIR}/${OUTPUT_FILE_NAME} \
--input_node input \
--output_node GCN/br_result_2/fcn_br\
--input_shape "${IMAGE_SIZE},${IMAGE_SIZE},3" \
--output_shape "1,${IMAGE_SIZE},${IMAGE_SIZE},2"
tools/validate_gcn.sh
浏览文件 @ b7dcd8aa
...@@ -71,7 +71,7 @@ build_and_run() ...@@ -71,7 +71,7 @@ build_and_run()
--input_file=${PHONE_DATA_DIR}/${INPUT_FILE_NAME} \ --input_file=${PHONE_DATA_DIR}/${INPUT_FILE_NAME} \
--output_file=${PHONE_DATA_DIR}/${OUTPUT_FILE_NAME} \ --output_file=${PHONE_DATA_DIR}/${OUTPUT_FILE_NAME} \
--device=OPENCL \ --device=OPENCL \
--round=1 --round=2
} }
echo "Step 1: Generate input data" echo "Step 1: Generate input data"
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或