Upload 4 files

README.md

@@ -1,3 +0,0 @@
----
-license: mit
----

convert.py

@@ -0,0 +1,23 @@
+from onnx import numpy_helper
+import numpy as np
+import onnx
+import ffmpeg
+import argparse
+
+# Parameter settings
+parser = argparse.ArgumentParser(description='Whisper format converter')
+parser.add_argument('--ipath', metavar='S', help='path to the input file')
+parser.add_argument('--opath', metavar='S', help='path to the output file (.pb extension)')
+args = parser.parse_args()
+
+if __name__ == '__main__':
+
+    out, _ = (
+        ffmpeg.input(args.ipath, threads=0)
+        .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=16000)
+        .run(cmd=["ffmpeg", "-nostdin"], capture_stdout=True, capture_stderr=True)
+    )
+    audio = np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
+
+    onnx_tp = numpy_helper.from_array(audio, 'raw_audio')
+    onnx.save_tensor(onnx_tp, args.opath)

main.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+#include "xg_runtime_api.h"
+
+
+void test_whisper(const std::string& weight_path, const std::string& input_path);
+
+int main(int argc, char** argv) {
+
+	if (argc == 3)
+	{
+		std::string weight_path = argv[1];
+	    std::string input_path = argv[2];
+	    test_whisper(weight_path, input_path);
+	}
+
+	return 0;
+}
+
+void test_whisper(const std::string& weight_path, const std::string& input_path)
+{
+	XgModelInfo minfo = {};
+	xg_get_model_info(&minfo);
+	std::cout << minfo.model_name << " " << minfo.model_version << std::endl;
+    
+	std::cout << "initing graph" << std::endl;
+	XgGraph* graph = nullptr;
+	if (xg_init_graph(weight_path, XGWeightSource::XG_ONNX, &graph) != XGResult::XG_SUCCESS)
+	{
+		std::cout << "Graph init error" << std::endl;
+		return;
+	}
+	else
+	{
+		std::cout << "Graph init: successful" << std::endl;
+	}
+
+	XgData* input_data = nullptr;
+	if (xg_allocate_input_compatible_data(0, &input_data) != XGResult::XG_SUCCESS)
+	{
+		std::cout << "Input allocation error" << std::endl;
+		return;
+	}
+	else
+	{
+		std::cout << "Input allocation: successful" << std::endl;
+	}
+        
+	// load the data into XgData
+	reinterpret_cast<std::string*>(input_data->raw_data)[0] = input_path;
+
+	if (xg_set_input_data(graph, 0, input_data) != XGResult::XG_SUCCESS)
+	{
+		std::cout << "Input data set error" << std::endl;
+		return;
+	}
+	else
+	{
+		std::cout << "Input data set: successful" << std::endl;
+	}
+    
+	// execute the graph
+	xg_execute_graph(graph);
+
+	// write output
+	XgData* output_data = nullptr;
+	if (xg_get_output_data(graph, 0, &output_data) != XGResult::XG_SUCCESS)
+	{
+		std::cout << "Getting output error" << std::endl;
+		return;
+	}
+	else
+	{
+		std::cout << "Getting output: successful" << std::endl;
+	}
+
+	// print output
+	std::string* o1 = reinterpret_cast<std::string*>(output_data->raw_data);
+	std::cout << o1[0] << std::endl;
+}

xg_runtime_api.h

@@ -0,0 +1,138 @@
+#ifndef __XG_RUNTIME_API__
+#define __XG_RUNTIME_API__
+
+#include <vector>
+#include <string>
+
+#if _WIN32
+    #define XG_API extern "C" __declspec(dllexport)
+#elif __unix__ || __linux__
+    #define XG_API extern "C"
+#endif
+
+// XG type definitions
+
+enum class XGResult
+{
+	XG_SUCCESS,
+	XG_INPUT_SIZE_MISSMATCH,
+	XG_INPUT_TYPE_MISSMATCH,
+	XG_WRONG_INPUT_INDEX,
+	XG_WRONG_OUTPUT_INDEX,
+	// device related
+	XG_DEVICE_NOT_SUPPORTED,
+	XG_MEMORY_ALLOCATION_FAILED,
+	// weight file access
+	XG_FILE_NOT_FOUND,
+	XG_EXECUTION_FAILED
+};
+
+enum class XGWeightSource
+{
+	XG_ONNX,
+	XG_XGDB
+};
+
+enum class XGDataType
+{
+	XG_BOOL,
+	XG_TOKEN,
+	XG_STRING,
+	XG_UINT8,
+	XG_UINT16,
+	XG_UINT32,
+	XG_UINT64,
+	XG_INT8,
+	XG_INT16,
+	XG_INT32,
+	XG_INT64,
+	XG_BFLOAT16,
+	XG_FLOAT16,
+	XG_FLOAT32,
+	XG_FLOAT64
+};
+
+// access information about the contained model
+struct XgModelInfo
+{
+	std::string model_name;
+	std::string model_version;
+	std::string device;    // cpu, gpu, tpu etc.
+	std::string hardware;  // e.g. intel i7 9th gen
+	unsigned int num_inputs;
+	unsigned int num_outputs;
+};
+
+XG_API void xg_get_model_info(
+	XgModelInfo* model_info
+);
+
+XG_API bool is_current_device_supported();  // may be list the supported devices on this machine
+
+// create graph
+struct XgGraph;
+
+XG_API XGResult xg_init_graph(
+	const std::string& weight_path, 
+	const XGWeightSource weight_source,
+	XgGraph** graph
+);
+XG_API XGResult xg_execute_graph(
+	XgGraph* graph
+);
+XG_API XGResult xg_destroy_graph(
+	XgGraph** graph
+);
+
+// set the input to the graph,
+// query the output
+
+struct XgData
+{
+	XGDataType dtype;
+	unsigned int size_in_bytes;
+	unsigned int dimension;
+	unsigned int length;
+	unsigned int* shape;
+	char* raw_data;
+};
+
+XG_API unsigned int xg_calculate_tensor_size_in_bytes(
+	const XGDataType dtype,
+	const unsigned int* shape,
+	const unsigned int dimension
+);
+XG_API XGResult xg_allocate_input_compatible_data(
+	const unsigned int input_idx,
+	XgData** data
+);
+XG_API XGResult xg_destroy_data(
+	XgData** data
+);
+XG_API XGResult xg_get_output_data(
+	const XgGraph* graph,
+	const unsigned int output_idx,
+	XgData** data
+);
+XG_API XGResult xg_set_input_data(
+	const XgGraph* graph,
+	const unsigned int input_idx,
+	const XgData* data
+);
+
+// helper functions
+XG_API bool xg_is_data_bool(const XgData* data);
+XG_API bool xg_is_data_uint8(const XgData* data);
+XG_API bool xg_is_data_uint16(const XgData* data);
+XG_API bool xg_is_data_uint32(const XgData* data);
+XG_API bool xg_is_data_uint64(const XgData* data);
+XG_API bool xg_is_data_int8(const XgData* data);
+XG_API bool xg_is_data_int16(const XgData* data);
+XG_API bool xg_is_data_int32(const XgData* data);
+XG_API bool xg_is_data_int64(const XgData* data);
+XG_API bool xg_is_data_bfloat16(const XgData* data);
+XG_API bool xg_is_data_float16(const XgData* data);
+XG_API bool xg_is_data_float32(const XgData* data);
+XG_API bool xg_is_data_float64(const XgData* data);
+
+#endif  // __XG_RUNTIME_API__