!5439 add image_classification in model zoo

Merge pull request !5439 from zhangbiao31/zb0828

model_zoo/official/lite/.gitignore

@@ -0,0 +1,81 @@
+# MindSpore
+build/
+mindspore/lib
+output
+*.ir
+mindspore/ccsrc/schema/inner/*
+
+# Cmake files
+CMakeFiles/
+cmake_install.cmake
+CMakeCache.txt
+Makefile
+cmake-build-debug
+
+# Dynamic libraries
+*.so
+*.so.*
+*.dylib
+
+# Static libraries
+*.la
+*.lai
+*.a
+*.lib
+
+# Protocol buffers
+*_pb2.py
+*.pb.h
+*.pb.cc
+
+# Object files
+*.o
+
+# Editor
+.vscode
+.idea/
+
+# Cquery
+.cquery_cached_index/
+compile_commands.json
+
+# Ctags and cscope
+tags
+TAGS
+CTAGS
+GTAGS
+GRTAGS
+GSYMS
+GPATH
+cscope.*
+
+# Python files
+*__pycache__*
+.pytest_cache
+
+# Mac files
+*.DS_Store
+
+# Test results
+test_temp_summary_event_file/
+*.dot
+*.dat
+*.svg
+*.perf
+*.info
+*.ckpt
+*.shp
+*.pkl
+.clangd
+mindspore/version.py
+mindspore/default_config.py
+mindspore/.commit_id
+onnx.proto
+mindspore/ccsrc/onnx.proto
+
+# Android
+local.properties
+.gradle
+sdk/build
+sdk/.cxx
+app/.cxx

model_zoo/official/lite/app/.gitignore

@@ -0,0 +1 @@
+/build

model_zoo/official/lite/app/CMakeLists.txt

@@ -0,0 +1,94 @@
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+set(CMAKE_VERBOSE_MAKEFILE on)
+set(libs  ${CMAKE_SOURCE_DIR}/libs)
+
+
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY  ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI})
+
+
+# ============== Set MindSpore Dependencies. =============
+include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include)
+include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include/MindSpore)
+include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include/MindSpore/flatbuffers)
+include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include/MindSpore/ir/dtype)
+include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include/MindSpore/schema)
+
+add_library(mindspore-lite SHARED IMPORTED )
+
+set_target_properties(mindspore-lite PROPERTIES IMPORTED_LOCATION
+        ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libmindspore-lite.so)
+# --------------- MindSpore Lite set End. --------------------
+
+
+
+# =============== Set OpenCV Dependencies ===================
+
+include_directories(${CMAKE_SOURCE_DIR}/opencv/sdk/native/jni/include/)
+
+add_library(lib-opencv SHARED IMPORTED )
+
+set_target_properties(lib-opencv PROPERTIES IMPORTED_LOCATION
+        ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libopencv_java4.so)
+
+# --------------- OpenCV set End. ---------------------------
+
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+
+file(GLOB_RECURSE cpp_src "src/main/cpp/*.cpp"  "src/main/cpp/*.h")
+
+add_library( # Sets the name of the library.
+        mlkit-label-MS
+
+        # Sets the library as a shared library.
+        SHARED
+
+        # Provides a relative path to your source file(s).
+        ${cpp_src})
+
+
+# Searches for a specified prebuilt library and stores the path as a
+# variable. Because CMake includes system libraries in the search path by
+# default, you only need to specify the name of the public NDK library
+# you want to add. CMake verifies that the library exists before
+# completing its build.
+
+find_library( # Sets the name of the path variable.
+        log-lib
+
+        # Specifies the name of the NDK library that
+        # you want CMake to locate.
+        log )
+
+
+find_library( jnigraphics-lib jnig·raphics )
+
+# Specifies libraries CMake should link to your target library. You
+# can link multiple libraries, such as libraries you define in this
+# build script, prebuilt third-party libraries, or system libraries.
+add_definitions(-DMNN_USE_LOGCAT)
+target_link_libraries( # Specifies the target library.
+        mlkit-label-MS
+
+        # --- opencv ---
+        lib-opencv
+
+        # --- mindspore ---
+        mindspore-lite
+
+        # --- other dependencies.---
+        -ljnigraphics
+        android
+
+        # Links the target library to the log library
+        ${log-lib}
+        )

model_zoo/official/lite/app/build.gradle

@@ -0,0 +1,84 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 30
+    buildToolsVersion "30.0.1"
+
+    defaultConfig {
+        applicationId "com.huawei.himindsporedemo"
+        minSdkVersion 21
+        targetSdkVersion 30
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"
+                cppFlags ""
+            }
+        }
+        ndk {
+            abiFilters 'arm64-v8a'
+        }
+    }
+    aaptOptions {
+        noCompress '.so', 'ms'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+
+        customDebugType {
+            debuggable true
+        }
+    }
+    externalNativeBuild {
+        cmake {
+            path file('CMakeLists.txt')
+        }
+    }
+    ndkVersion '21.3.6528147'
+
+    sourceSets{
+        main {
+            jniLibs.srcDirs = ['libs']
+        }
+    }
+    packagingOptions{
+        pickFirst 'lib/arm64-v8a/libopencv_java4.so'
+        pickFirst 'lib/arm64-v8a/libmindspore-lite.so'
+        pickFirst 'lib/arm64-v8a/libmlkit-label-MS.so'
+    }
+
+}
+
+
+
+// Before gradle build.
+// To download some necessary libraries.
+apply from:'download.gradle'
+/*if (!file("libs/arm64-v8a/libmindspore-lite.so").exists() ||
+        !file("libs/arm64-v8a/libopencv_java4.so").exists()){
+    apply from:'download.gradle'
+}*/
+
+
+
+dependencies {
+    implementation fileTree(dir: "libs", include: ["*.jar"])
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+//    implementation project(path: ':sdk')
+
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+
+    implementation 'com.google.android.material:material:1.0.0'
+    androidTestImplementation 'com.android.support.test:rules:1.0.2'
+    androidTestImplementation 'com.google.truth:truth:1.0.1'
+}

model_zoo/official/lite/app/download.gradle

@@ -0,0 +1,73 @@
+/**
+ * To download necessary library from HuaWei server.
+ * Including mindspore-lite .so file, opencv .so file and model file.
+ * The libraries can be downloaded manually.
+ */
+
+
+def targetModelFile = "src/main/assets/model/mobilenetv2.ms"
+def openCVLibrary_arm64 = "libs/arm64-v8a/libopencv_java4.so"
+def mindSporeLibrary_arm64 = "libs/arm64-v8a/libmindspore-lite.so"
+
+def modelDownloadUrl = "https://download.mindspore.cn/model_zoo/official/lite/mobilenetv2_openimage_lite/mobilenetv2.ms"
+def opencvDownloadUrl = "https://download.mindspore.cn/model_zoo/official/lite/lib/opencv%204.4.0/libopencv_java4.so"
+def mindsporeLiteDownloadUrl = "https://download.mindspore.cn/model_zoo/official/lite/lib/mindspore%20version%200.7/libmindspore-lite.so"
+
+
+task downloadModelFile(type: DownloadUrlTask) {
+    doFirst {
+        println "Downloading ${modelDownloadUrl}"
+    }
+    sourceUrl = "${modelDownloadUrl}"
+    target = file("${targetModelFile}")
+}
+
+
+task downloadOpenCVLibrary(type: DownloadUrlTask) {
+    doFirst {
+        println "Downloading ${opencvDownloadUrl}"
+    }
+    sourceUrl = "${opencvDownloadUrl}"
+    target = file("${openCVLibrary_arm64}")
+}
+
+task downloadMindSporeLibrary(type: DownloadUrlTask) {
+    doFirst {
+        println "Downloading ${mindsporeLiteDownloadUrl}"
+    }
+    sourceUrl = "${mindsporeLiteDownloadUrl}"
+    target = file("${mindSporeLibrary_arm64}")
+}
+
+/*
+ * Using preBuild to download mindspore library, opencv library and model file.
+ * Run before gradle build.
+ */
+if (file("libs/arm64-v8a/libmindspore-lite.so").exists()){
+    downloadMindSporeLibrary.enabled = false
+}
+
+if (file("libs/arm64-v8a/libopencv_java4.so.so").exists()){
+    downloadOpenCVLibrary.enabled = false
+}
+if (file("src/main/assets/model/mobilenetv2.ms").exists()){
+    downloadModelFile.enabled = false
+}
+
+preBuild.dependsOn downloadMindSporeLibrary
+preBuild.dependsOn downloadOpenCVLibrary
+preBuild.dependsOn downloadModelFile
+
+
+class DownloadUrlTask extends DefaultTask {
+    @Input
+    String sourceUrl
+
+    @OutputFile
+    File target
+
+    @TaskAction
+    void download() {
+        ant.get(src: sourceUrl, dest: target)
+    }
+}

model_zoo/official/lite/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

model_zoo/official/lite/app/src/androidTest/java/com/huawei/himindsporedemo/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package com.huawei.himindsporedemo;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+        assertEquals("com.huawei.himindsporedemo", appContext.getPackageName());
+    }
+}

model_zoo/official/lite/app/src/main/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.huawei.himindsporedemo"
+    android:versionCode="1"
+    android:versionName="1.0">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.WRITE_INTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_INTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEM" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+        <activity
+            android:name=".widget.CameraActivity"
+            android:screenOrientation="portrait">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

model_zoo/official/lite/app/src/main/cpp/MindSporeNetnative.h

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2018-2019. All rights reserved.
+ */
+
+#ifndef MINDSPORE_JNI_HMS_DEBUG_MINDSPORENETNATIVE_H
+#define MINDSPORE_JNI_HMS_DEBUG_MINDSPORENETNATIVE_H
+
+#endif //MINDSPORE_JNI_HMS_DEBUG_MINDSPORENETNATIVE_H

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/MSNetWork.cpp

@@ -0,0 +1,41 @@
+#include "MSNetWork.h"
+#include <iostream>
+#include <android/log.h>
+#include "errorcode.h"
+
+#define MS_PRINT(format, ...) __android_log_print(ANDROID_LOG_INFO, "MSJNI", format, ##__VA_ARGS__)
+
+MSNetWork::MSNetWork(void) : session(nullptr) {}
+MSNetWork::~MSNetWork(void) {}
+
+
+void MSNetWork::CreateSessionMS(char* modelBuffer, size_t bufferLen, mindspore::lite::Context* ctx)
+{
+    session = mindspore::session::LiteSession::CreateSession(ctx);
+    if (session == nullptr){
+        MS_PRINT("Create Session failed.");
+        return;
+    }
+
+    // Compile model.
+    auto model = mindspore::lite::Model::Import(modelBuffer, bufferLen);
+    if (model == nullptr){
+        MS_PRINT("Import model failed.");
+        return;
+    }
+
+    int ret = session->CompileGraph(model);
+    if (ret != mindspore::lite::RET_OK){
+        MS_PRINT("CompileGraph failed.");
+        return;
+    }
+
+}
+
+int MSNetWork::ReleaseNets(void)
+{
+    delete session;
+//    delete model;
+    return 0;
+}
+

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/MSNetWork.h

@@ -0,0 +1,50 @@
+// * Copyright (c) Huawei Technologies Co., Ltd. 2018-2019. All rights reserved.
+
+#ifndef MSNETWORK_H
+#define MSNETWORK_H
+
+#include <cstdio>
+#include <algorithm>
+#include <fstream>
+#include <functional>
+#include <sstream>
+#include <vector>
+#include <map>
+#include <string>
+#include <memory>
+#include <utility>
+
+#include <context.h>
+#include <lite_session.h>
+#include <model.h>
+#include <errorcode.h>
+
+using namespace mindspore;
+
+struct ImgDims {
+    int channel = 0;
+    int width = 0;
+    int height = 0;
+};
+
+/*struct SessIterm {
+    std::shared_ptr<mindspore::session::LiteSession> sess = nullptr;
+};*/
+
+
+
+class MSNetWork {
+public:
+    MSNetWork();
+    ~MSNetWork();
+
+    void CreateSessionMS(char* modelBuffer, size_t bufferLen, mindspore::lite::Context* ctx);
+    int ReleaseNets(void);
+    mindspore::session::LiteSession *session;
+    mindspore::lite::Model *model;
+
+private:
+    //std::map<std::string, SessIterm> sess;
+};
+
+#endif

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/context.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINDSPORE_LITE_INCLUDE_CONTEXT_H_
+#define MINDSPORE_LITE_INCLUDE_CONTEXT_H_
+
+#include <string>
+#include <memory>
+#include "ms_tensor.h"
+#include "thread_pool_config.h"
+
+namespace mindspore {
+    namespace lite {
+        /// \brief Allocator defined a memory pool for malloc memory and free memory dynamically.
+        ///
+        /// \note List public class and interface for reference.
+        class Allocator;
+
+        /// \brief DeviceType defined for holding user's preferred backend.
+        typedef enum {
+            DT_CPU, /**< CPU device type */
+            DT_GPU, /**< GPU device type */
+            DT_NPU  /**< NPU device type, not supported yet */
+        } DeviceType;
+
+        /// \brief DeviceContext defined for holding DeviceType.
+        typedef struct {
+            DeviceType type; /**< device type */
+        } DeviceContext;
+
+        /// \brief Context defined for holding environment variables during runtime.
+        class MS_API Context {
+        public:
+            /// \brief Constructor of MindSpore Lite Context using default value for parameters.
+            ///
+            /// \return Instance of MindSpore Lite Context.
+            Context();
+
+            /// \brief Constructor of MindSpore Lite Context using input value for parameters.
+            ///
+            /// \param[in] thread_num Define the work thread number during the runtime.
+            /// \param[in] allocator Define the allocator for malloc.
+            /// \param[in] device_ctx Define device information during the runtime.
+            Context(int thread_num, std::shared_ptr<Allocator> allocator, DeviceContext device_ctx);
+
+            /// \brief Destructor of MindSpore Lite Context.
+            virtual ~Context();
+
+        public:
+            bool float16_priority = false; /**< allow priority select float16 kernel */
+            DeviceContext device_ctx_{DT_CPU};
+            int thread_num_ = 2; /**< thread number config for thread pool */
+            std::shared_ptr<Allocator> allocator = nullptr;
+            CpuBindMode cpu_bind_mode_ = MID_CPU;
+        };
+    }
+}  // namespace mindspore::lite
+#endif  // MINDSPORE_LITE_INCLUDE_CONTEXT_H_

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/errorcode.h

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINDSPORE_LITE_INCLUDE_ERRORCODE_H_
+#define MINDSPORE_LITE_INCLUDE_ERRORCODE_H_
+
+namespace mindspore {
+namespace lite {
+/// \brief STATUS defined for holding error code in MindSpore Lite.
+using STATUS = int;
+
+/* Success */
+constexpr int RET_OK = 0; /**< No error occurs. */
+
+/* Common error code, range: [-1, -100]*/
+constexpr int RET_ERROR = -1;         /**< Common error code. */
+constexpr int RET_NULL_PTR = -2;      /**< NULL pointer returned.*/
+constexpr int RET_PARAM_INVALID = -3; /**< Invalid parameter.*/
+constexpr int RET_NO_CHANGE = -4;     /**< No change. */
+constexpr int RET_SUCCESS_EXIT = -5;  /**< No error but exit. */
+constexpr int RET_MEMORY_FAILED = -6; /**< Fail to create memory. */
+
+/* Executor error code, range: [-101,-200] */
+constexpr int RET_OUT_OF_TENSOR_RANGE = -101; /**< Failed to check range. */
+constexpr int RET_INPUT_TENSOR_ERROR = -102;  /**< Failed to check input tensor. */
+constexpr int RET_REENTRANT_ERROR = -103;     /**< Exist executor running. */
+
+/* Graph error code, range: [-201,-300] */
+constexpr int RET_GRAPH_FILE_ERR = -201; /**< Failed to verify graph file. */
+
+/* Node error code, range: [-301,-400] */
+constexpr int RET_NOT_FIND_OP = -301;        /**< Failed to find operator. */
+constexpr int RET_INVALID_OP_NAME = -302;    /**< Invalid operator name. */
+constexpr int RET_INVALID_OP_ATTR = -303;    /**< Invalid operator attr. */
+constexpr int RET_OP_EXECUTE_FAILURE = -304; /**< Failed to execution operator. */
+
+/* Tensor error code, range: [-401,-500] */
+constexpr int RET_FORMAT_ERR = -401; /**< Failed to checking tensor format. */
+
+/* InferShape error code, range: [-501,-600] */
+constexpr int RET_INFER_ERR = -501; /**< Failed to infer shape. */
+constexpr int RET_INFER_INVALID = -502; /**< Invalid infer shape before runtime. */
+}  // namespace lite
+}  // namespace mindspore
+
+#endif  // MINDSPORE_LITE_INCLUDE_ERRORCODE_H_

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/flatbuffers/include/code_generators.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_CODE_GENERATORS_H_
+#define FLATBUFFERS_CODE_GENERATORS_H_
+
+#include <map>
+#include <sstream>
+#include "flatbuffers/idl.h"
+
+namespace flatbuffers {
+
+// Utility class to assist in generating code through use of text templates.
+//
+// Example code:
+//   CodeWriter code;
+//   code.SetValue("NAME", "Foo");
+//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
+//   code.SetValue("NAME", "Bar");
+//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
+//   std::cout << code.ToString() << std::endl;
+//
+// Output:
+//  void Foo() { printf("%s", "Foo"); }
+//  void Bar() { printf("%s", "Bar"); }
+class CodeWriter {
+ public:
+  CodeWriter() {}
+
+  // Clears the current "written" code.
+  void Clear() {
+    stream_.str("");
+    stream_.clear();
+  }
+
+  // Associates a key with a value.  All subsequent calls to operator+=, where
+  // the specified key is contained in {{ and }} delimiters will be replaced by
+  // the given value.
+  void SetValue(const std::string &key, const std::string &value) {
+    value_map_[key] = value;
+  }
+
+  // Appends the given text to the generated code as well as a newline
+  // character.  Any text within {{ and }} delimeters is replaced by values
+  // previously stored in the CodeWriter by calling SetValue above.  The newline
+  // will be suppressed if the text ends with the \\ character.
+  void operator+=(std::string text);
+
+  // Returns the current contents of the CodeWriter as a std::string.
+  std::string ToString() const { return stream_.str(); }
+
+ private:
+  std::map<std::string, std::string> value_map_;
+  std::stringstream stream_;
+};
+
+class BaseGenerator {
+ public:
+  virtual bool generate() = 0;
+
+  static std::string NamespaceDir(const Parser &parser, const std::string &path,
+                                  const Namespace &ns);
+
+ protected:
+  BaseGenerator(const Parser &parser, const std::string &path,
+                const std::string &file_name,
+                const std::string qualifying_start,
+                const std::string qualifying_separator)
+      : parser_(parser),
+        path_(path),
+        file_name_(file_name),
+        qualifying_start_(qualifying_start),
+        qualifying_separator_(qualifying_separator) {}
+  virtual ~BaseGenerator() {}
+
+  // No copy/assign.
+  BaseGenerator &operator=(const BaseGenerator &);
+  BaseGenerator(const BaseGenerator &);
+
+  std::string NamespaceDir(const Namespace &ns) const;
+
+  static const char *FlatBuffersGeneratedWarning();
+
+  static std::string FullNamespace(const char *separator, const Namespace &ns);
+
+  static std::string LastNamespacePart(const Namespace &ns);
+
+  // tracks the current namespace for early exit in WrapInNameSpace
+  // c++, java and csharp returns a different namespace from
+  // the following default (no early exit, always fully qualify),
+  // which works for js and php
+  virtual const Namespace *CurrentNameSpace() const { return nullptr; }
+
+  // Ensure that a type is prefixed with its namespace whenever it is used
+  // outside of its namespace.
+  std::string WrapInNameSpace(const Namespace *ns,
+                              const std::string &name) const;
+
+  std::string WrapInNameSpace(const Definition &def) const;
+
+  std::string GetNameSpace(const Definition &def) const;
+
+  const Parser &parser_;
+  const std::string &path_;
+  const std::string &file_name_;
+  const std::string qualifying_start_;
+  const std::string qualifying_separator_;
+};
+
+struct CommentConfig {
+  const char *first_line;
+  const char *content_line_prefix;
+  const char *last_line;
+};
+
+extern void GenComment(const std::vector<std::string> &dc,
+                       std::string *code_ptr, const CommentConfig *config,
+                       const char *prefix = "");
+
+class FloatConstantGenerator {
+ public:
+  virtual ~FloatConstantGenerator() {}
+  std::string GenFloatConstant(const FieldDef &field) const;
+
+ private:
+  virtual std::string Value(double v, const std::string &src) const = 0;
+  virtual std::string Inf(double v) const = 0;
+  virtual std::string NaN(double v) const = 0;
+
+  virtual std::string Value(float v, const std::string &src) const = 0;
+  virtual std::string Inf(float v) const = 0;
+  virtual std::string NaN(float v) const = 0;
+
+  template<typename T>
+  std::string GenFloatConstantImpl(const FieldDef &field) const;
+};
+
+class SimpleFloatConstantGenerator : public FloatConstantGenerator {
+ public:
+  SimpleFloatConstantGenerator(const char *nan_number,
+                               const char *pos_inf_number,
+                               const char *neg_inf_number);
+
+ private:
+  std::string Value(double v,
+                    const std::string &src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
+
+  const std::string nan_number_;
+  const std::string pos_inf_number_;
+  const std::string neg_inf_number_;
+};
+
+// C++, C#, Java like generator.
+class TypedFloatConstantGenerator : public FloatConstantGenerator {
+ public:
+  TypedFloatConstantGenerator(const char *double_prefix,
+                              const char *single_prefix, const char *nan_number,
+                              const char *pos_inf_number,
+                              const char *neg_inf_number = "");
+
+ private:
+  std::string Value(double v,
+                    const std::string &src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
+
+  std::string MakeNaN(const std::string &prefix) const;
+  std::string MakeInf(bool neg, const std::string &prefix) const;
+
+  const std::string double_prefix_;
+  const std::string single_prefix_;
+  const std::string nan_number_;
+  const std::string pos_inf_number_;
+  const std::string neg_inf_number_;
+};
+
+}  // namespace MindSpore.flatbuffers
+
+#endif  // FLATBUFFERS_CODE_GENERATORS_H_

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/flatbuffers/include/flatc.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <functional>
+#include <limits>
+#include <string>
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+#ifndef FLATC_H_
+#  define FLATC_H_
+
+namespace flatbuffers {
+
+class FlatCompiler {
+ public:
+  // Output generator for the various programming languages and formats we
+  // support.
+  struct Generator {
+    typedef bool (*GenerateFn)(const flatbuffers::Parser &parser,
+                               const std::string &path,
+                               const std::string &file_name);
+    typedef std::string (*MakeRuleFn)(const flatbuffers::Parser &parser,
+                                      const std::string &path,
+                                      const std::string &file_name);
+
+    GenerateFn generate;
+    const char *generator_opt_short;
+    const char *generator_opt_long;
+    const char *lang_name;
+    bool schema_only;
+    GenerateFn generateGRPC;
+    flatbuffers::IDLOptions::Language lang;
+    const char *generator_help;
+    MakeRuleFn make_rule;
+  };
+
+  typedef void (*WarnFn)(const FlatCompiler *flatc, const std::string &warn,
+                         bool show_exe_name);
+
+  typedef void (*ErrorFn)(const FlatCompiler *flatc, const std::string &err,
+                          bool usage, bool show_exe_name);
+
+  // Parameters required to initialize the FlatCompiler.
+  struct InitParams {
+    InitParams()
+        : generators(nullptr),
+          num_generators(0),
+          warn_fn(nullptr),
+          error_fn(nullptr) {}
+
+    const Generator *generators;
+    size_t num_generators;
+    WarnFn warn_fn;
+    ErrorFn error_fn;
+  };
+
+  explicit FlatCompiler(const InitParams &params) : params_(params) {}
+
+  int Compile(int argc, const char **argv);
+
+  std::string GetUsageString(const char *program_name) const;
+
+ private:
+  void ParseFile(flatbuffers::Parser &parser, const std::string &filename,
+                 const std::string &contents,
+                 std::vector<const char *> &include_directories) const;
+
+  void LoadBinarySchema(Parser &parser, const std::string &filename,
+                        const std::string &contents);
+
+  void Warn(const std::string &warn, bool show_exe_name = true) const;
+
+  void Error(const std::string &err, bool usage = true,
+             bool show_exe_name = true) const;
+
+  InitParams params_;
+};
+
+}  // namespace MindSpore.flatbuffers
+
+#endif  // FLATC_H_

model_zoo/official/lite/app/src/main/cpp/include/MindSpore/flatbuffers/include/hash.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_HASH_H_
+#define FLATBUFFERS_HASH_H_
+
+#include <cstdint>
+#include <cstring>
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace flatbuffers {
+
+template<typename T> struct FnvTraits {
+  static const T kFnvPrime;
+  static const T kOffsetBasis;
+};
+
+template<> struct FnvTraits<uint32_t> {
+  static const uint32_t kFnvPrime = 0x01000193;
+  static const uint32_t kOffsetBasis = 0x811C9DC5;
+};
+
+template<> struct FnvTraits<uint64_t> {
+  static const uint64_t kFnvPrime = 0x00000100000001b3ULL;
+  static const uint64_t kOffsetBasis = 0xcbf29ce484222645ULL;
+};
+
+template<typename T> T HashFnv1(const char *input) {
+  T hash = FnvTraits<T>::kOffsetBasis;
+  for (const char *c = input; *c; ++c) {
+    hash *= FnvTraits<T>::kFnvPrime;
+    hash ^= static_cast<unsigned char>(*c);
+  }
+  return hash;
+}
+
+template<typename T> T HashFnv1a(const char *input) {
+  T hash = FnvTraits<T>::kOffsetBasis;
+  for (const char *c = input; *c; ++c) {
+    hash ^= static_cast<unsigned char>(*c);
+    hash *= FnvTraits<T>::kFnvPrime;
+  }
+  return hash;
+}
+
+template <> inline uint16_t HashFnv1<uint16_t>(const char *input) {
+  uint32_t hash = HashFnv1<uint32_t>(input);
+  return (hash >> 16) ^ (hash & 0xffff);
+}
+
+template <> inline uint16_t HashFnv1a<uint16_t>(const char *input) {
+  uint32_t hash = HashFnv1a<uint32_t>(input);
+  return (hash >> 16) ^ (hash & 0xffff);
+}
+
+template <typename T> struct NamedHashFunction {
+  const char *name;
+
+  typedef T (*HashFunction)(const char *);
+  HashFunction function;
+};
+
+const NamedHashFunction<uint16_t> kHashFunctions16[] = {
+  { "fnv1_16",  HashFnv1<uint16_t> },
+  { "fnv1a_16", HashFnv1a<uint16_t> },
+};
+
+const NamedHashFunction<uint32_t> kHashFunctions32[] = {
+  { "fnv1_32", HashFnv1<uint32_t> },
+  { "fnv1a_32", HashFnv1a<uint32_t> },
+};
+
+const NamedHashFunction<uint64_t> kHashFunctions64[] = {
+  { "fnv1_64", HashFnv1<uint64_t> },
+  { "fnv1a_64", HashFnv1a<uint64_t> },
+};
+
+inline NamedHashFunction<uint16_t>::HashFunction FindHashFunction16(
+    const char *name) {
+  std::size_t size = sizeof(kHashFunctions16) / sizeof(kHashFunctions16[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions16[i].name) == 0) {
+      return kHashFunctions16[i].function;
+    }
+  }
+  return nullptr;
+}
+
+inline NamedHashFunction<uint32_t>::HashFunction FindHashFunction32(
+    const char *name) {
+  std::size_t size = sizeof(kHashFunctions32) / sizeof(kHashFunctions32[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions32[i].name) == 0) {
+      return kHashFunctions32[i].function;
+    }
+  }
+  return nullptr;
+}
+
+inline NamedHashFunction<uint64_t>::HashFunction FindHashFunction64(
+    const char *name) {
+  std::size_t size = sizeof(kHashFunctions64) / sizeof(kHashFunctions64[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions64[i].name) == 0) {
+      return kHashFunctions64[i].function;
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace MindSpore.flatbuffers
+
+#endif  // FLATBUFFERS_HASH_H_