Hui Zhang
2 years ago
committed by
GitHub
commit
7cab869d63
@ -0,0 +1,7 @@
|
||||
engine/common/base/flags.h
|
||||
engine/common/base/log.h
|
||||
|
||||
tools/valgrind*
|
||||
*log
|
||||
fc_patch/*
|
||||
test
|
||||
@ -0,0 +1,211 @@
|
||||
# >=3.17 support -DCMAKE_FIND_DEBUG_MODE=ON
|
||||
cmake_minimum_required(VERSION 3.17 FATAL_ERROR)
|
||||
|
||||
set(CMAKE_PROJECT_INCLUDE_BEFORE "${CMAKE_CURRENT_SOURCE_DIR}/cmake/EnableCMP0077.cmake")
|
||||
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
||||
|
||||
include(system)
|
||||
|
||||
project(paddlespeech VERSION 0.1)
|
||||
|
||||
set(PPS_VERSION_MAJOR 1)
|
||||
set(PPS_VERSION_MINOR 0)
|
||||
set(PPS_VERSION_PATCH 0)
|
||||
set(PPS_VERSION "${PPS_VERSION_MAJOR}.${PPS_VERSION_MINOR}.${PPS_VERSION_PATCH}")
|
||||
|
||||
# compiler option
|
||||
# Keep the same with openfst, -fPIC or -fpic
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++14 -pthread -fPIC -O0 -Wall -g -ldl")
|
||||
SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} --std=c++14 -pthread -fPIC -O0 -Wall -g -ggdb")
|
||||
SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} --std=c++14 -pthread -fPIC -O3 -Wall")
|
||||
|
||||
set(CMAKE_VERBOSE_MAKEFILE ON)
|
||||
set(CMAKE_FIND_DEBUG_MODE OFF)
|
||||
set(PPS_CXX_STANDARD 14)
|
||||
|
||||
# set std-14
|
||||
set(CMAKE_CXX_STANDARD ${PPS_CXX_STANDARD})
|
||||
|
||||
# Ninja Generator will set CMAKE_BUILD_TYPE to Debug
|
||||
if(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel" FORCE)
|
||||
endif()
|
||||
|
||||
# find_* e.g. find_library work when Cross-Compiling
|
||||
if(ANDROID)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH)
|
||||
endif()
|
||||
|
||||
if(BUILD_IN_MACOS)
|
||||
add_definitions("-DOS_MACOSX")
|
||||
endif()
|
||||
|
||||
# install dir into `build/install`
|
||||
set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR}/install)
|
||||
|
||||
include(FetchContent)
|
||||
include(ExternalProject)
|
||||
|
||||
# fc_patch dir
|
||||
set(FETCHCONTENT_QUIET off)
|
||||
get_filename_component(fc_patch "fc_patch" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
|
||||
set(FETCHCONTENT_BASE_DIR ${fc_patch})
|
||||
|
||||
###############################################################################
|
||||
# Option Configurations
|
||||
###############################################################################
|
||||
# https://github.com/google/brotli/pull/655
|
||||
option(BUILD_SHARED_LIBS "Build shared libraries" ON)
|
||||
|
||||
option(WITH_PPS_DEBUG "debug option" OFF)
|
||||
if (WITH_PPS_DEBUG)
|
||||
add_definitions("-DPPS_DEBUG")
|
||||
endif()
|
||||
|
||||
option(WITH_ASR "build asr" ON)
|
||||
option(WITH_CLS "build cls" ON)
|
||||
option(WITH_VAD "build vad" ON)
|
||||
|
||||
option(WITH_GPU "NNet using GPU." OFF)
|
||||
|
||||
option(WITH_PROFILING "enable c++ profling" OFF)
|
||||
option(WITH_TESTING "unit test" ON)
|
||||
|
||||
option(WITH_ONNX "u2 support onnx runtime" OFF)
|
||||
|
||||
###############################################################################
|
||||
# Include Third Party
|
||||
###############################################################################
|
||||
include(gflags)
|
||||
|
||||
include(glog)
|
||||
|
||||
include(pybind)
|
||||
|
||||
#onnx
|
||||
if(WITH_ONNX)
|
||||
add_definitions(-DUSE_ONNX)
|
||||
endif()
|
||||
|
||||
# gtest
|
||||
if(WITH_TESTING)
|
||||
include(gtest) # download, build, install gtest
|
||||
endif()
|
||||
|
||||
# fastdeploy
|
||||
include(fastdeploy)
|
||||
|
||||
if(WITH_ASR)
|
||||
# openfst
|
||||
include(openfst)
|
||||
add_dependencies(openfst gflags extern_glog)
|
||||
endif()
|
||||
|
||||
###############################################################################
|
||||
# Find Package
|
||||
###############################################################################
|
||||
# https://github.com/Kitware/CMake/blob/v3.1.0/Modules/FindThreads.cmake#L207
|
||||
find_package(Threads REQUIRED)
|
||||
|
||||
if(WITH_ASR)
|
||||
# https://cmake.org/cmake/help/latest/module/FindPython3.html#module:FindPython3
|
||||
find_package(Python3 COMPONENTS Interpreter Development)
|
||||
find_package(pybind11 CONFIG)
|
||||
|
||||
if(Python3_FOUND)
|
||||
message(STATUS "Python3_FOUND = ${Python3_FOUND}")
|
||||
message(STATUS "Python3_EXECUTABLE = ${Python3_EXECUTABLE}")
|
||||
message(STATUS "Python3_LIBRARIES = ${Python3_LIBRARIES}")
|
||||
message(STATUS "Python3_INCLUDE_DIRS = ${Python3_INCLUDE_DIRS}")
|
||||
message(STATUS "Python3_LINK_OPTIONS = ${Python3_LINK_OPTIONS}")
|
||||
set(PYTHON_LIBRARIES ${Python3_LIBRARIES} CACHE STRING "python lib" FORCE)
|
||||
set(PYTHON_INCLUDE_DIR ${Python3_INCLUDE_DIRS} CACHE STRING "python inc" FORCE)
|
||||
endif()
|
||||
|
||||
message(STATUS "PYTHON_LIBRARIES = ${PYTHON_LIBRARIES}")
|
||||
message(STATUS "PYTHON_INCLUDE_DIR = ${PYTHON_INCLUDE_DIR}")
|
||||
include_directories(${PYTHON_INCLUDE_DIR})
|
||||
|
||||
if(pybind11_FOUND)
|
||||
message(STATUS "pybind11_INCLUDES = ${pybind11_INCLUDE_DIRS}")
|
||||
message(STATUS "pybind11_LIBRARIES=${pybind11_LIBRARIES}")
|
||||
message(STATUS "pybind11_DEFINITIONS=${pybind11_DEFINITIONS}")
|
||||
endif()
|
||||
|
||||
|
||||
# paddle libpaddle.so
|
||||
# paddle include and link option
|
||||
# -L/workspace/DeepSpeech-2.x/engine/venv/lib/python3.7/site-packages/paddle/libs -L/workspace/DeepSpeech-2.x/speechx/venv/lib/python3.7/site-packages/paddle/fluid -l:libpaddle.so -l:libdnnl.so.2 -l:libiomp5.so
|
||||
set(EXECUTE_COMMAND "import os"
|
||||
"import paddle"
|
||||
"include_dir = paddle.sysconfig.get_include()"
|
||||
"paddle_dir=os.path.split(include_dir)[0]"
|
||||
"libs_dir=os.path.join(paddle_dir, 'libs')"
|
||||
"fluid_dir=os.path.join(paddle_dir, 'fluid')"
|
||||
"out=' '.join([\"-L\" + libs_dir, \"-L\" + fluid_dir])"
|
||||
"out += \" -l:libpaddle.so -l:libdnnl.so.2 -l:libiomp5.so\"; print(out)"
|
||||
)
|
||||
execute_process(
|
||||
COMMAND python -c "${EXECUTE_COMMAND}"
|
||||
OUTPUT_VARIABLE PADDLE_LINK_FLAGS
|
||||
RESULT_VARIABLE SUCESS)
|
||||
|
||||
message(STATUS PADDLE_LINK_FLAGS= ${PADDLE_LINK_FLAGS})
|
||||
string(STRIP ${PADDLE_LINK_FLAGS} PADDLE_LINK_FLAGS)
|
||||
|
||||
# paddle compile option
|
||||
# -I/workspace/DeepSpeech-2.x/engine/venv/lib/python3.7/site-packages/paddle/include
|
||||
set(EXECUTE_COMMAND "import paddle"
|
||||
"include_dir = paddle.sysconfig.get_include()"
|
||||
"print(f\"-I{include_dir}\")"
|
||||
)
|
||||
execute_process(
|
||||
COMMAND python -c "${EXECUTE_COMMAND}"
|
||||
OUTPUT_VARIABLE PADDLE_COMPILE_FLAGS)
|
||||
message(STATUS PADDLE_COMPILE_FLAGS= ${PADDLE_COMPILE_FLAGS})
|
||||
string(STRIP ${PADDLE_COMPILE_FLAGS} PADDLE_COMPILE_FLAGS)
|
||||
|
||||
# for LD_LIBRARY_PATH
|
||||
# set(PADDLE_LIB_DIRS /workspace/DeepSpeech-2.x/tools/venv/lib/python3.7/site-packages/paddle/fluid:/workspace/DeepSpeech-2.x/tools/venv/lib/python3.7/site-packages/paddle/libs/)
|
||||
set(EXECUTE_COMMAND "import os"
|
||||
"import paddle"
|
||||
"include_dir=paddle.sysconfig.get_include()"
|
||||
"paddle_dir=os.path.split(include_dir)[0]"
|
||||
"libs_dir=os.path.join(paddle_dir, 'libs')"
|
||||
"fluid_dir=os.path.join(paddle_dir, 'fluid')"
|
||||
"out=':'.join([libs_dir, fluid_dir]); print(out)"
|
||||
)
|
||||
execute_process(
|
||||
COMMAND python -c "${EXECUTE_COMMAND}"
|
||||
OUTPUT_VARIABLE PADDLE_LIB_DIRS)
|
||||
message(STATUS PADDLE_LIB_DIRS= ${PADDLE_LIB_DIRS})
|
||||
endif()
|
||||
|
||||
include(summary)
|
||||
|
||||
###############################################################################
|
||||
# Add local library
|
||||
###############################################################################
|
||||
set(ENGINE_ROOT ${CMAKE_SOURCE_DIR}/engine)
|
||||
|
||||
add_subdirectory(engine)
|
||||
|
||||
|
||||
###############################################################################
|
||||
# CPack library
|
||||
###############################################################################
|
||||
# build a CPack driven installer package
|
||||
include (InstallRequiredSystemLibraries)
|
||||
set(CPACK_PACKAGE_NAME "paddlespeech_library")
|
||||
set(CPACK_PACKAGE_VENDOR "paddlespeech")
|
||||
set(CPACK_PACKAGE_VERSION_MAJOR 1)
|
||||
set(CPACK_PACKAGE_VERSION_MINOR 0)
|
||||
set(CPACK_PACKAGE_VERSION_PATCH 0)
|
||||
set(CPACK_PACKAGE_DESCRIPTION "paddlespeech library")
|
||||
set(CPACK_PACKAGE_CONTACT "paddlespeech@baidu.com")
|
||||
set(CPACK_SOURCE_GENERATOR "TGZ")
|
||||
include (CPack)
|
||||
@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env bash
|
||||
set -xe
|
||||
|
||||
BUILD_ROOT=build/Linux
|
||||
BUILD_DIR=${BUILD_ROOT}/x86_64
|
||||
|
||||
mkdir -p ${BUILD_DIR}
|
||||
|
||||
BUILD_TYPE=Release
|
||||
#BUILD_TYPE=Debug
|
||||
BUILD_SO=OFF
|
||||
BUILD_ONNX=ON
|
||||
BUILD_ASR=ON
|
||||
BUILD_CLS=ON
|
||||
BUILD_VAD=ON
|
||||
PPS_DEBUG=OFF
|
||||
FASTDEPLOY_INSTALL_DIR=""
|
||||
|
||||
# the build script had verified in the paddlepaddle docker image.
|
||||
# please follow the instruction below to install PaddlePaddle image.
|
||||
# https://www.paddlepaddle.org.cn/documentation/docs/zh/install/docker/linux-docker.html
|
||||
#cmake -B build -DBUILD_SHARED_LIBS=OFF -DWITH_ASR=OFF -DWITH_CLS=OFF -DWITH_VAD=ON -DFASTDEPLOY_INSTALL_DIR=/workspace/zhanghui/paddle/FastDeploy/build/Android/arm64-v8a-api-21/install
|
||||
cmake -B ${BUILD_DIR} \
|
||||
-DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
|
||||
-DBUILD_SHARED_LIBS=${BUILD_SO} \
|
||||
-DWITH_ONNX=${BUILD_ONNX} \
|
||||
-DWITH_ASR=${BUILD_ASR} \
|
||||
-DWITH_CLS=${BUILD_CLS} \
|
||||
-DWITH_VAD=${BUILD_VAD} \
|
||||
-DFASTDEPLOY_INSTALL_DIR=${FASTDEPLOY_INSTALL_DIR} \
|
||||
-DWITH_PPS_DEBUG=${PPS_DEBUG}
|
||||
|
||||
cmake --build ${BUILD_DIR} -j
|
||||
@ -0,0 +1,39 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -ex
|
||||
|
||||
ANDROID_NDK=/mnt/masimeng/workspace/software/android-ndk-r25b/
|
||||
|
||||
# Setting up Android toolchanin
|
||||
ANDROID_ABI=arm64-v8a # 'arm64-v8a', 'armeabi-v7a'
|
||||
ANDROID_PLATFORM="android-21" # API >= 21
|
||||
ANDROID_STL=c++_shared # 'c++_shared', 'c++_static'
|
||||
ANDROID_TOOLCHAIN=clang # 'clang' only
|
||||
TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake
|
||||
|
||||
# Create build directory
|
||||
BUILD_ROOT=build/Android
|
||||
BUILD_DIR=${BUILD_ROOT}/${ANDROID_ABI}-api-21
|
||||
FASTDEPLOY_INSTALL_DIR="/mnt/masimeng/workspace/FastDeploy/build/Android/arm64-v8a-api-21/install"
|
||||
|
||||
mkdir -p ${BUILD_DIR}
|
||||
cd ${BUILD_DIR}
|
||||
|
||||
# CMake configuration with Android toolchain
|
||||
cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \
|
||||
-DCMAKE_BUILD_TYPE=MinSizeRel \
|
||||
-DANDROID_ABI=${ANDROID_ABI} \
|
||||
-DANDROID_NDK=${ANDROID_NDK} \
|
||||
-DANDROID_PLATFORM=${ANDROID_PLATFORM} \
|
||||
-DANDROID_STL=${ANDROID_STL} \
|
||||
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN} \
|
||||
-DBUILD_SHARED_LIBS=OFF \
|
||||
-DWITH_ASR=OFF \
|
||||
-DWITH_CLS=OFF \
|
||||
-DWITH_VAD=ON \
|
||||
-DFASTDEPLOY_INSTALL_DIR=${FASTDEPLOY_INSTALL_DIR} \
|
||||
-DCMAKE_FIND_DEBUG_MODE=OFF \
|
||||
-Wno-dev ../../..
|
||||
|
||||
# Build FastDeploy Android C++ SDK
|
||||
make
|
||||
@ -0,0 +1,91 @@
|
||||
# https://www.jianshu.com/p/33672fb819f5
|
||||
|
||||
PATH="/Applications/CMake.app/Contents/bin":"$PATH"
|
||||
tools_dir=$1
|
||||
ios_toolchain_cmake=${tools_dir}/"/ios-cmake-4.2.0/ios.toolchain.cmake"
|
||||
fastdeploy_dir=${tools_dir}"/fastdeploy-ort-mac-build/"
|
||||
build_targets=("OS64")
|
||||
build_type_array=("Release")
|
||||
|
||||
#static_name="libocr"
|
||||
#lib_name="libocr"
|
||||
|
||||
# Switch to workpath
|
||||
current_path=`cd $(dirname $0);pwd`
|
||||
work_path=${current_path}/
|
||||
build_path=${current_path}/build/
|
||||
output_path=${current_path}/output/
|
||||
cd ${work_path}
|
||||
|
||||
# Clean
|
||||
rm -rf ${build_path}
|
||||
rm -rf ${output_path}
|
||||
|
||||
if [ "$1"x = "clean"x ]; then
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Build Every Target
|
||||
for target in "${build_targets[@]}"
|
||||
do
|
||||
for build_type in "${build_type_array[@]}"
|
||||
do
|
||||
echo -e "\033[1;36;40mBuilding ${build_type} ${target} ... \033[0m"
|
||||
target_build_path=${build_path}/${target}/${build_type}/
|
||||
mkdir -p ${target_build_path}
|
||||
|
||||
cd ${target_build_path}
|
||||
if [ $? -ne 0 ];then
|
||||
echo -e "\033[1;31;40mcd ${target_build_path} failed \033[0m"
|
||||
exit -1
|
||||
fi
|
||||
|
||||
if [ ${target} == "OS64" ];then
|
||||
fastdeploy_install_dir=${fastdeploy_dir}/arm64
|
||||
else
|
||||
fastdeploy_install_dir=""
|
||||
echo "fastdeploy_install_dir is null"
|
||||
exit -1
|
||||
fi
|
||||
|
||||
cmake -DCMAKE_TOOLCHAIN_FILE=${ios_toolchain_cmake} \
|
||||
-DBUILD_IN_MACOS=ON \
|
||||
-DBUILD_SHARED_LIBS=OFF \
|
||||
-DWITH_ASR=OFF \
|
||||
-DWITH_CLS=OFF \
|
||||
-DWITH_VAD=ON \
|
||||
-DFASTDEPLOY_INSTALL_DIR=${fastdeploy_install_dir} \
|
||||
-DPLATFORM=${target} ../../../
|
||||
|
||||
cmake --build . --config ${build_type}
|
||||
|
||||
mkdir output
|
||||
cp engine/vad/interface/libpps_vad_interface.a output
|
||||
cp engine/vad/interface/vad_interface_main.app/vad_interface_main output
|
||||
cp ${fastdeploy_install_dir}/lib/libfastdeploy.dylib output
|
||||
cp ${fastdeploy_install_dir}/third_libs/install/onnxruntime/lib/libonnxruntime.dylib output
|
||||
|
||||
done
|
||||
done
|
||||
|
||||
## combine all ios libraries
|
||||
#DEVROOT=/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/
|
||||
#LIPO_TOOL=${DEVROOT}/usr/bin/lipo
|
||||
#LIBRARY_PATH=${build_path}
|
||||
#LIBRARY_OUTPUT_PATH=${output_path}/IOS
|
||||
#mkdir -p ${LIBRARY_OUTPUT_PATH}
|
||||
#
|
||||
#${LIPO_TOOL} \
|
||||
# -arch i386 ${LIBRARY_PATH}/ios_x86/Release/${lib_name}.a \
|
||||
# -arch x86_64 ${LIBRARY_PATH}/ios_x86_64/Release/${lib_name}.a \
|
||||
# -arch armv7 ${LIBRARY_PATH}/ios_armv7/Release/${lib_name}.a \
|
||||
# -arch armv7s ${LIBRARY_PATH}/ios_armv7s/Release/${lib_name}.a \
|
||||
# -arch arm64 ${LIBRARY_PATH}/ios_armv8/Release/${lib_name}.a \
|
||||
# -output ${LIBRARY_OUTPUT_PATH}/${lib_name}.a -create
|
||||
#
|
||||
#cp ${work_path}/lib/houyi/lib/ios/libhouyi_score.a ${LIBRARY_OUTPUT_PATH}/
|
||||
#cp ${work_path}/interface/ocr-interface.h ${output_path}
|
||||
#cp ${work_path}/version/release.v ${output_path}
|
||||
#
|
||||
#echo -e "\033[1;36;40mBuild All Target Success At:\n${output_path}\033[0m"
|
||||
#exit 0
|
||||
@ -0,0 +1 @@
|
||||
cmake_policy(SET CMP0077 NEW)
|
||||
@ -0,0 +1,116 @@
|
||||
include(FetchContent)
|
||||
|
||||
set(EXTERNAL_PROJECT_LOG_ARGS
|
||||
LOG_DOWNLOAD 1 # Wrap download in script to log output
|
||||
LOG_UPDATE 1 # Wrap update in script to log output
|
||||
LOG_PATCH 1
|
||||
LOG_CONFIGURE 1# Wrap configure in script to log output
|
||||
LOG_BUILD 1 # Wrap build in script to log output
|
||||
LOG_INSTALL 1
|
||||
LOG_TEST 1 # Wrap test in script to log output
|
||||
LOG_MERGED_STDOUTERR 1
|
||||
LOG_OUTPUT_ON_FAILURE 1
|
||||
)
|
||||
|
||||
if(NOT FASTDEPLOY_INSTALL_DIR)
|
||||
if(ANDROID)
|
||||
FetchContent_Declare(
|
||||
fastdeploy
|
||||
URL https://bj.bcebos.com/fastdeploy/release/android/fastdeploy-android-1.0.4-shared.tgz
|
||||
URL_HASH MD5=2a15301158e9eb157a4f11283689e7ba
|
||||
${EXTERNAL_PROJECT_LOG_ARGS}
|
||||
)
|
||||
add_definitions("-DUSE_PADDLE_LITE_BAKEND")
|
||||
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -mfloat-abi=softfp -mfpu=vfpv3 -mfpu=neon -fPIC -pie -fPIE")
|
||||
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -g0 -O3 -mfloat-abi=softfp -mfpu=vfpv3 -mfpu=neon -fPIC -pie -fPIE")
|
||||
else() # Linux
|
||||
FetchContent_Declare(
|
||||
fastdeploy
|
||||
URL https://paddlespeech.bj.bcebos.com/speechx/fastdeploy/fastdeploy-1.0.5-x86_64-onnx.tar.gz
|
||||
URL_HASH MD5=33900d986ea71aa78635e52f0733227c
|
||||
${EXTERNAL_PROJECT_LOG_ARGS}
|
||||
)
|
||||
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -msse -msse2")
|
||||
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -msse -msse2 -mavx -O3")
|
||||
endif()
|
||||
|
||||
FetchContent_MakeAvailable(fastdeploy)
|
||||
|
||||
set(FASTDEPLOY_INSTALL_DIR ${fc_patch}/fastdeploy-src)
|
||||
endif()
|
||||
|
||||
include(${FASTDEPLOY_INSTALL_DIR}/FastDeploy.cmake)
|
||||
|
||||
# fix compiler flags conflict, since fastdeploy using c++11 for project
|
||||
# this line must after `include(${FASTDEPLOY_INSTALL_DIR}/FastDeploy.cmake)`
|
||||
set(CMAKE_CXX_STANDARD ${PPS_CXX_STANDARD})
|
||||
|
||||
include_directories(${FASTDEPLOY_INCS})
|
||||
|
||||
# install fastdeploy and dependents lib
|
||||
# install_fastdeploy_libraries(${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
|
||||
# No dynamic libs need to install while using
|
||||
# FastDeploy static lib.
|
||||
if(ANDROID AND WITH_ANDROID_STATIC_LIB)
|
||||
return()
|
||||
endif()
|
||||
|
||||
set(DYN_LIB_SUFFIX "*.so*")
|
||||
if(WIN32)
|
||||
set(DYN_LIB_SUFFIX "*.dll")
|
||||
elseif(APPLE)
|
||||
set(DYN_LIB_SUFFIX "*.dylib*")
|
||||
endif()
|
||||
|
||||
if(FastDeploy_DIR)
|
||||
set(DYN_SEARCH_DIR ${FastDeploy_DIR})
|
||||
elseif(FASTDEPLOY_INSTALL_DIR)
|
||||
set(DYN_SEARCH_DIR ${FASTDEPLOY_INSTALL_DIR})
|
||||
else()
|
||||
message(FATAL_ERROR "Please set FastDeploy_DIR/FASTDEPLOY_INSTALL_DIR before call install_fastdeploy_libraries.")
|
||||
endif()
|
||||
|
||||
file(GLOB_RECURSE ALL_NEED_DYN_LIBS ${DYN_SEARCH_DIR}/lib/${DYN_LIB_SUFFIX})
|
||||
file(GLOB_RECURSE ALL_DEPS_DYN_LIBS ${DYN_SEARCH_DIR}/third_libs/${DYN_LIB_SUFFIX})
|
||||
|
||||
if(ENABLE_VISION)
|
||||
# OpenCV
|
||||
if(ANDROID)
|
||||
file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${DYN_LIB_SUFFIX})
|
||||
else()
|
||||
file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_DIR}/../../${DYN_LIB_SUFFIX})
|
||||
endif()
|
||||
|
||||
list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_OPENCV_DYN_LIBS})
|
||||
|
||||
if(WIN32)
|
||||
file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/x64/vc15/bin/${DYN_LIB_SUFFIX})
|
||||
install(FILES ${OPENCV_DYN_LIBS} DESTINATION lib)
|
||||
elseif(ANDROID AND (NOT WITH_ANDROID_OPENCV_STATIC))
|
||||
file(GLOB OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${ANDROID_ABI}/${DYN_LIB_SUFFIX})
|
||||
install(FILES ${OPENCV_DYN_LIBS} DESTINATION lib)
|
||||
else() # linux/mac
|
||||
file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/lib/${DYN_LIB_SUFFIX})
|
||||
install(FILES ${OPENCV_DYN_LIBS} DESTINATION lib)
|
||||
endif()
|
||||
|
||||
# FlyCV
|
||||
if(ENABLE_FLYCV)
|
||||
file(GLOB_RECURSE ALL_FLYCV_DYN_LIBS ${FLYCV_LIB_DIR}/${DYN_LIB_SUFFIX})
|
||||
list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_FLYCV_DYN_LIBS})
|
||||
if(ANDROID AND (NOT WITH_ANDROID_FLYCV_STATIC))
|
||||
install(FILES ${ALL_FLYCV_DYN_LIBS} DESTINATION lib)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(ENABLE_OPENVINO_BACKEND)
|
||||
# need plugins.xml for openvino backend
|
||||
set(OPENVINO_RUNTIME_BIN_DIR ${OPENVINO_DIR}/bin)
|
||||
file(GLOB OPENVINO_PLUGIN_XML ${OPENVINO_RUNTIME_BIN_DIR}/*.xml)
|
||||
install(FILES ${OPENVINO_PLUGIN_XML} DESTINATION lib)
|
||||
endif()
|
||||
|
||||
# Install other libraries
|
||||
install(FILES ${ALL_NEED_DYN_LIBS} DESTINATION lib)
|
||||
install(FILES ${ALL_DEPS_DYN_LIBS} DESTINATION lib)
|
||||
@ -0,0 +1,14 @@
|
||||
include(FetchContent)
|
||||
|
||||
FetchContent_Declare(
|
||||
gflags
|
||||
URL https://paddleaudio.bj.bcebos.com/build/gflag-2.2.2.zip
|
||||
URL_HASH SHA256=19713a36c9f32b33df59d1c79b4958434cb005b5b47dc5400a7a4b078111d9b5
|
||||
)
|
||||
FetchContent_MakeAvailable(gflags)
|
||||
|
||||
# openfst need
|
||||
include_directories(${gflags_BINARY_DIR}/include)
|
||||
link_directories(${gflags_BINARY_DIR})
|
||||
|
||||
#install(FILES ${gflags_BINARY_DIR}/libgflags_nothreads.a DESTINATION lib)
|
||||
@ -0,0 +1,35 @@
|
||||
include(FetchContent)
|
||||
|
||||
if(ANDROID)
|
||||
else() # UNIX
|
||||
add_definitions(-DWITH_GLOG)
|
||||
FetchContent_Declare(
|
||||
glog
|
||||
URL https://paddleaudio.bj.bcebos.com/build/glog-0.4.0.zip
|
||||
URL_HASH SHA256=9e1b54eb2782f53cd8af107ecf08d2ab64b8d0dc2b7f5594472f3bd63ca85cdc
|
||||
CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
|
||||
-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
|
||||
-DCMAKE_CXX_FLAGS=${GLOG_CMAKE_CXX_FLAGS}
|
||||
-DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
|
||||
-DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
|
||||
-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
|
||||
-DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
|
||||
-DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
|
||||
-DCMAKE_POSITION_INDEPENDENT_CODE=ON
|
||||
-DWITH_GFLAGS=OFF
|
||||
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
|
||||
${EXTERNAL_OPTIONAL_ARGS}
|
||||
)
|
||||
set(BUILD_TESTING OFF)
|
||||
FetchContent_MakeAvailable(glog)
|
||||
include_directories(${glog_BINARY_DIR} ${glog_SOURCE_DIR}/src)
|
||||
endif()
|
||||
|
||||
|
||||
if(ANDROID)
|
||||
add_library(extern_glog INTERFACE)
|
||||
add_dependencies(extern_glog gflags)
|
||||
else() # UNIX
|
||||
add_library(extern_glog ALIAS glog)
|
||||
add_dependencies(glog gflags)
|
||||
endif()
|
||||
@ -0,0 +1,27 @@
|
||||
|
||||
include(FetchContent)
|
||||
|
||||
if(ANDROID)
|
||||
else() # UNIX
|
||||
FetchContent_Declare(
|
||||
gtest
|
||||
URL https://paddleaudio.bj.bcebos.com/build/gtest-release-1.11.0.zip
|
||||
URL_HASH SHA256=353571c2440176ded91c2de6d6cd88ddd41401d14692ec1f99e35d013feda55a
|
||||
)
|
||||
FetchContent_MakeAvailable(gtest)
|
||||
|
||||
include_directories(${gtest_BINARY_DIR} ${gtest_SOURCE_DIR}/src)
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
if(ANDROID)
|
||||
add_library(extern_gtest INTERFACE)
|
||||
else() # UNIX
|
||||
add_dependencies(gtest gflags extern_glog)
|
||||
add_library(extern_gtest ALIAS gtest)
|
||||
endif()
|
||||
|
||||
if(WITH_TESTING)
|
||||
enable_testing()
|
||||
endif()
|
||||
@ -0,0 +1,42 @@
|
||||
#the pybind11 is from:https://github.com/pybind/pybind11
|
||||
# Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
|
||||
|
||||
SET(PYBIND_ZIP "v2.10.0.zip")
|
||||
SET(LOCAL_PYBIND_ZIP ${FETCHCONTENT_BASE_DIR}/${PYBIND_ZIP})
|
||||
SET(PYBIND_SRC ${FETCHCONTENT_BASE_DIR}/pybind11)
|
||||
SET(DOWNLOAD_URL "https://paddleaudio.bj.bcebos.com/build/v2.10.0.zip")
|
||||
SET(PYBIND_TIMEOUT 600 CACHE STRING "Timeout in seconds when downloading pybind.")
|
||||
|
||||
IF(NOT EXISTS ${LOCAL_PYBIND_ZIP})
|
||||
FILE(DOWNLOAD ${DOWNLOAD_URL}
|
||||
${LOCAL_PYBIND_ZIP}
|
||||
TIMEOUT ${PYBIND_TIMEOUT}
|
||||
STATUS ERR
|
||||
SHOW_PROGRESS
|
||||
)
|
||||
|
||||
IF(ERR EQUAL 0)
|
||||
MESSAGE(STATUS "download pybind success")
|
||||
ELSE()
|
||||
MESSAGE(FATAL_ERROR "download pybind fail")
|
||||
ENDIF()
|
||||
ENDIF()
|
||||
|
||||
IF(NOT EXISTS ${PYBIND_SRC})
|
||||
EXECUTE_PROCESS(
|
||||
COMMAND ${CMAKE_COMMAND} -E tar xfz ${LOCAL_PYBIND_ZIP}
|
||||
WORKING_DIRECTORY ${FETCHCONTENT_BASE_DIR}
|
||||
RESULT_VARIABLE tar_result
|
||||
)
|
||||
|
||||
file(RENAME ${FETCHCONTENT_BASE_DIR}/pybind11-2.10.0 ${PYBIND_SRC})
|
||||
|
||||
IF (tar_result MATCHES 0)
|
||||
MESSAGE(STATUS "unzip pybind success")
|
||||
ELSE()
|
||||
MESSAGE(FATAL_ERROR "unzip pybind fail")
|
||||
ENDIF()
|
||||
|
||||
ENDIF()
|
||||
|
||||
include_directories(${PYBIND_SRC}/include)
|
||||
@ -0,0 +1,64 @@
|
||||
# Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
function(pps_summary)
|
||||
message(STATUS "")
|
||||
message(STATUS "*************PaddleSpeech Building Summary**********")
|
||||
message(STATUS " PPS_VERSION : ${PPS_VERSION}")
|
||||
message(STATUS " CMake version : ${CMAKE_VERSION}")
|
||||
message(STATUS " CMake command : ${CMAKE_COMMAND}")
|
||||
message(STATUS " UNIX : ${UNIX}")
|
||||
message(STATUS " ANDROID : ${ANDROID}")
|
||||
message(STATUS " System : ${CMAKE_SYSTEM_NAME}")
|
||||
message(STATUS " C++ compiler : ${CMAKE_CXX_COMPILER}")
|
||||
message(STATUS " C++ compiler version : ${CMAKE_CXX_COMPILER_VERSION}")
|
||||
message(STATUS " CXX flags : ${CMAKE_CXX_FLAGS}")
|
||||
message(STATUS " Build type : ${CMAKE_BUILD_TYPE}")
|
||||
message(STATUS " BUILD_SHARED_LIBS : ${BUILD_SHARED_LIBS}")
|
||||
get_directory_property(tmp DIRECTORY ${PROJECT_SOURCE_DIR} COMPILE_DEFINITIONS)
|
||||
message(STATUS " Compile definitions : ${tmp}")
|
||||
message(STATUS " CMAKE_PREFIX_PATH : ${CMAKE_PREFIX_PATH}")
|
||||
message(STATUS " CMAKE_CURRENT_BINARY_DIR : ${CMAKE_CURRENT_BINARY_DIR}")
|
||||
message(STATUS " CMAKE_INSTALL_PREFIX : ${CMAKE_INSTALL_PREFIX}")
|
||||
message(STATUS " CMAKE_INSTALL_LIBDIR : ${CMAKE_INSTALL_LIBDIR}")
|
||||
message(STATUS " CMAKE_MODULE_PATH : ${CMAKE_MODULE_PATH}")
|
||||
message(STATUS " CMAKE_SYSTEM_NAME : ${CMAKE_SYSTEM_NAME}")
|
||||
message(STATUS "")
|
||||
|
||||
message(STATUS " WITH_ASR : ${WITH_ASR}")
|
||||
message(STATUS " WITH_CLS : ${WITH_CLS}")
|
||||
message(STATUS " WITH_VAD : ${WITH_VAD}")
|
||||
message(STATUS " WITH_GPU : ${WITH_GPU}")
|
||||
message(STATUS " WITH_TESTING : ${WITH_TESTING}")
|
||||
message(STATUS " WITH_PROFILING : ${WITH_PROFILING}")
|
||||
message(STATUS " FASTDEPLOY_INSTALL_DIR : ${FASTDEPLOY_INSTALL_DIR}")
|
||||
message(STATUS " FASTDEPLOY_INCS : ${FASTDEPLOY_INCS}")
|
||||
message(STATUS " FASTDEPLOY_LIBS : ${FASTDEPLOY_LIBS}")
|
||||
if(WITH_GPU)
|
||||
message(STATUS " CUDA_DIRECTORY : ${CUDA_DIRECTORY}")
|
||||
endif()
|
||||
|
||||
if(ANDROID)
|
||||
message(STATUS " ANDROID_ABI : ${ANDROID_ABI}")
|
||||
message(STATUS " ANDROID_PLATFORM : ${ANDROID_PLATFORM}")
|
||||
message(STATUS " ANDROID_NDK : ${ANDROID_NDK}")
|
||||
message(STATUS " ANDROID_NDK_VERSION : ${CMAKE_ANDROID_NDK_VERSION}")
|
||||
endif()
|
||||
if (WITH_ASR)
|
||||
message(STATUS " Python executable : ${PYTHON_EXECUTABLE}")
|
||||
message(STATUS " Python includes : ${PYTHON_INCLUDE_DIR}")
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
pps_summary()
|
||||
@ -0,0 +1,106 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. 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.
|
||||
|
||||
# Detects the OS and sets appropriate variables.
|
||||
# CMAKE_SYSTEM_NAME only give us a coarse-grained name of the OS CMake is
|
||||
# building for, but the host processor name like centos is necessary
|
||||
# in some scenes to distinguish system for customization.
|
||||
#
|
||||
# for instance, protobuf libs path is <install_dir>/lib64
|
||||
# on CentOS, but <install_dir>/lib on other systems.
|
||||
|
||||
if(UNIX AND NOT APPLE)
|
||||
# except apple from nix*Os family
|
||||
set(LINUX TRUE)
|
||||
endif()
|
||||
|
||||
if(WIN32)
|
||||
set(HOST_SYSTEM "win32")
|
||||
else()
|
||||
if(APPLE)
|
||||
set(HOST_SYSTEM "macosx")
|
||||
exec_program(
|
||||
sw_vers ARGS
|
||||
-productVersion
|
||||
OUTPUT_VARIABLE HOST_SYSTEM_VERSION)
|
||||
string(REGEX MATCH "[0-9]+.[0-9]+" MACOS_VERSION "${HOST_SYSTEM_VERSION}")
|
||||
if(NOT DEFINED $ENV{MACOSX_DEPLOYMENT_TARGET})
|
||||
# Set cache variable - end user may change this during ccmake or cmake-gui configure.
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET
|
||||
${MACOS_VERSION}
|
||||
CACHE
|
||||
STRING
|
||||
"Minimum OS X version to target for deployment (at runtime); newer APIs weak linked. Set to empty string for default value."
|
||||
)
|
||||
endif()
|
||||
set(CMAKE_EXE_LINKER_FLAGS "-framework CoreFoundation -framework Security")
|
||||
else()
|
||||
|
||||
if(EXISTS "/etc/issue")
|
||||
file(READ "/etc/issue" LINUX_ISSUE)
|
||||
if(LINUX_ISSUE MATCHES "CentOS")
|
||||
set(HOST_SYSTEM "centos")
|
||||
elseif(LINUX_ISSUE MATCHES "Debian")
|
||||
set(HOST_SYSTEM "debian")
|
||||
elseif(LINUX_ISSUE MATCHES "Ubuntu")
|
||||
set(HOST_SYSTEM "ubuntu")
|
||||
elseif(LINUX_ISSUE MATCHES "Red Hat")
|
||||
set(HOST_SYSTEM "redhat")
|
||||
elseif(LINUX_ISSUE MATCHES "Fedora")
|
||||
set(HOST_SYSTEM "fedora")
|
||||
endif()
|
||||
|
||||
string(REGEX MATCH "(([0-9]+)\\.)+([0-9]+)" HOST_SYSTEM_VERSION
|
||||
"${LINUX_ISSUE}")
|
||||
endif()
|
||||
|
||||
if(EXISTS "/etc/redhat-release")
|
||||
file(READ "/etc/redhat-release" LINUX_ISSUE)
|
||||
if(LINUX_ISSUE MATCHES "CentOS")
|
||||
set(HOST_SYSTEM "centos")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT HOST_SYSTEM)
|
||||
set(HOST_SYSTEM ${CMAKE_SYSTEM_NAME})
|
||||
endif()
|
||||
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# query number of logical cores
|
||||
cmake_host_system_information(RESULT CPU_CORES QUERY NUMBER_OF_LOGICAL_CORES)
|
||||
|
||||
mark_as_advanced(HOST_SYSTEM CPU_CORES)
|
||||
|
||||
message(
|
||||
STATUS
|
||||
"Found Paddle host system: ${HOST_SYSTEM}, version: ${HOST_SYSTEM_VERSION}")
|
||||
message(STATUS "Found Paddle host system's CPU: ${CPU_CORES} cores")
|
||||
|
||||
# external dependencies log output
|
||||
set(EXTERNAL_PROJECT_LOG_ARGS
|
||||
LOG_DOWNLOAD
|
||||
0 # Wrap download in script to log output
|
||||
LOG_UPDATE
|
||||
1 # Wrap update in script to log output
|
||||
LOG_CONFIGURE
|
||||
1 # Wrap configure in script to log output
|
||||
LOG_BUILD
|
||||
0 # Wrap build in script to log output
|
||||
LOG_TEST
|
||||
1 # Wrap test in script to log output
|
||||
LOG_INSTALL
|
||||
0 # Wrap install in script to log output
|
||||
)
|
||||
@ -0,0 +1,22 @@
|
||||
project(speechx LANGUAGES CXX)
|
||||
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/kaldi)
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/common)
|
||||
|
||||
add_subdirectory(kaldi)
|
||||
add_subdirectory(common)
|
||||
|
||||
if(WITH_ASR)
|
||||
add_subdirectory(asr)
|
||||
endif()
|
||||
|
||||
if(WITH_CLS)
|
||||
add_subdirectory(audio_classification)
|
||||
endif()
|
||||
|
||||
if(WITH_VAD)
|
||||
add_subdirectory(vad)
|
||||
endif()
|
||||
|
||||
add_subdirectory(codelab)
|
||||
@ -0,0 +1,11 @@
|
||||
cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
|
||||
|
||||
project(ASR LANGUAGES CXX)
|
||||
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/server)
|
||||
|
||||
add_subdirectory(decoder)
|
||||
add_subdirectory(recognizer)
|
||||
add_subdirectory(nnet)
|
||||
add_subdirectory(server)
|
||||
@ -0,0 +1,24 @@
|
||||
set(srcs)
|
||||
list(APPEND srcs
|
||||
ctc_prefix_beam_search_decoder.cc
|
||||
ctc_tlg_decoder.cc
|
||||
)
|
||||
|
||||
add_library(decoder STATIC ${srcs})
|
||||
target_link_libraries(decoder PUBLIC utils fst frontend nnet kaldi-decoder)
|
||||
|
||||
# test
|
||||
set(TEST_BINS
|
||||
ctc_prefix_beam_search_decoder_main
|
||||
ctc_tlg_decoder_main
|
||||
)
|
||||
|
||||
foreach(bin_name IN LISTS TEST_BINS)
|
||||
add_executable(${bin_name} ${CMAKE_CURRENT_SOURCE_DIR}/${bin_name}.cc)
|
||||
target_include_directories(${bin_name} PRIVATE ${SPEECHX_ROOT} ${SPEECHX_ROOT}/kaldi)
|
||||
target_link_libraries(${bin_name} nnet decoder fst utils gflags glog kaldi-base kaldi-matrix kaldi-util)
|
||||
target_compile_options(${bin_name} PRIVATE ${PADDLE_COMPILE_FLAGS})
|
||||
target_include_directories(${bin_name} PRIVATE ${pybind11_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR})
|
||||
target_link_libraries(${bin_name} ${PYTHON_LIBRARIES} ${PADDLE_LINK_FLAGS} -ldl)
|
||||
endforeach()
|
||||
|
||||
@ -0,0 +1,21 @@
|
||||
set(srcs decodable.cc nnet_producer.cc)
|
||||
|
||||
list(APPEND srcs u2_nnet.cc)
|
||||
if(WITH_ONNX)
|
||||
list(APPEND srcs u2_onnx_nnet.cc)
|
||||
endif()
|
||||
add_library(nnet STATIC ${srcs})
|
||||
target_link_libraries(nnet utils)
|
||||
if(WITH_ONNX)
|
||||
target_link_libraries(nnet ${FASTDEPLOY_LIBS})
|
||||
endif()
|
||||
|
||||
target_compile_options(nnet PUBLIC ${PADDLE_COMPILE_FLAGS})
|
||||
target_include_directories(nnet PUBLIC ${pybind11_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR})
|
||||
|
||||
# test bin
|
||||
#set(bin_name u2_nnet_main)
|
||||
#add_executable(${bin_name} ${CMAKE_CURRENT_SOURCE_DIR}/${bin_name}.cc)
|
||||
#target_compile_options(${bin_name} PRIVATE ${PADDLE_COMPILE_FLAGS})
|
||||
#target_include_directories(${bin_name} PRIVATE ${pybind11_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR})
|
||||
#target_link_libraries(${bin_name} ${PYTHON_LIBRARIES} ${PADDLE_LINK_FLAGS})
|
||||
@ -0,0 +1,99 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 "nnet/nnet_producer.h"
|
||||
|
||||
#include "matrix/kaldi-matrix.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
using kaldi::BaseFloat;
|
||||
using std::vector;
|
||||
|
||||
NnetProducer::NnetProducer(std::shared_ptr<NnetBase> nnet,
|
||||
std::shared_ptr<FrontendInterface> frontend,
|
||||
float blank_threshold)
|
||||
: nnet_(nnet), frontend_(frontend), blank_threshold_(blank_threshold) {
|
||||
Reset();
|
||||
}
|
||||
|
||||
void NnetProducer::Accept(const std::vector<kaldi::BaseFloat>& inputs) {
|
||||
frontend_->Accept(inputs);
|
||||
}
|
||||
|
||||
void NnetProducer::Acceptlikelihood(
|
||||
const kaldi::Matrix<BaseFloat>& likelihood) {
|
||||
std::vector<BaseFloat> prob;
|
||||
prob.resize(likelihood.NumCols());
|
||||
for (size_t idx = 0; idx < likelihood.NumRows(); ++idx) {
|
||||
for (size_t col = 0; col < likelihood.NumCols(); ++col) {
|
||||
prob[col] = likelihood(idx, col);
|
||||
}
|
||||
cache_.push_back(prob);
|
||||
}
|
||||
}
|
||||
|
||||
bool NnetProducer::Read(std::vector<kaldi::BaseFloat>* nnet_prob) {
|
||||
bool flag = cache_.pop(nnet_prob);
|
||||
return flag;
|
||||
}
|
||||
|
||||
bool NnetProducer::Compute() {
|
||||
vector<BaseFloat> features;
|
||||
if (frontend_ == NULL || frontend_->Read(&features) == false) {
|
||||
// no feat or frontend_ not init.
|
||||
if (frontend_->IsFinished() == true) {
|
||||
finished_ = true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
CHECK_GE(frontend_->Dim(), 0);
|
||||
VLOG(1) << "Forward in " << features.size() / frontend_->Dim() << " feats.";
|
||||
|
||||
NnetOut out;
|
||||
nnet_->FeedForward(features, frontend_->Dim(), &out);
|
||||
int32& vocab_dim = out.vocab_dim;
|
||||
size_t nframes = out.logprobs.size() / vocab_dim;
|
||||
VLOG(1) << "Forward out " << nframes << " decoder frames.";
|
||||
for (size_t idx = 0; idx < nframes; ++idx) {
|
||||
std::vector<BaseFloat> logprob(
|
||||
out.logprobs.data() + idx * vocab_dim,
|
||||
out.logprobs.data() + (idx + 1) * vocab_dim);
|
||||
// process blank prob
|
||||
float blank_prob = std::exp(logprob[0]);
|
||||
if (blank_prob > blank_threshold_) {
|
||||
last_frame_logprob_ = logprob;
|
||||
is_last_frame_skip_ = true;
|
||||
continue;
|
||||
} else {
|
||||
int cur_max = std::max(logprob.begin(), logprob.end()) - logprob.begin();
|
||||
if (cur_max == last_max_elem_ && cur_max != 0 && is_last_frame_skip_) {
|
||||
cache_.push_back(last_frame_logprob_);
|
||||
last_max_elem_ = cur_max;
|
||||
}
|
||||
last_max_elem_ = cur_max;
|
||||
is_last_frame_skip_ = false;
|
||||
cache_.push_back(logprob);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void NnetProducer::AttentionRescoring(const std::vector<std::vector<int>>& hyps,
|
||||
float reverse_weight,
|
||||
std::vector<float>* rescoring_score) {
|
||||
nnet_->AttentionRescoring(hyps, reverse_weight, rescoring_score);
|
||||
}
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,77 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "base/common.h"
|
||||
#include "base/safe_queue.h"
|
||||
#include "frontend/frontend_itf.h"
|
||||
#include "nnet/nnet_itf.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
class NnetProducer {
|
||||
public:
|
||||
explicit NnetProducer(std::shared_ptr<NnetBase> nnet,
|
||||
std::shared_ptr<FrontendInterface> frontend,
|
||||
float blank_threshold);
|
||||
// Feed feats or waves
|
||||
void Accept(const std::vector<kaldi::BaseFloat>& inputs);
|
||||
|
||||
void Acceptlikelihood(const kaldi::Matrix<BaseFloat>& likelihood);
|
||||
|
||||
// nnet
|
||||
bool Read(std::vector<kaldi::BaseFloat>* nnet_prob);
|
||||
|
||||
bool Empty() const { return cache_.empty(); }
|
||||
|
||||
void SetInputFinished() {
|
||||
LOG(INFO) << "set finished";
|
||||
frontend_->SetFinished();
|
||||
}
|
||||
|
||||
// the compute thread exit
|
||||
bool IsFinished() const {
|
||||
return (frontend_->IsFinished() && finished_);
|
||||
}
|
||||
|
||||
~NnetProducer() {}
|
||||
|
||||
void Reset() {
|
||||
if (frontend_ != NULL) frontend_->Reset();
|
||||
if (nnet_ != NULL) nnet_->Reset();
|
||||
cache_.clear();
|
||||
finished_ = false;
|
||||
}
|
||||
|
||||
void AttentionRescoring(const std::vector<std::vector<int>>& hyps,
|
||||
float reverse_weight,
|
||||
std::vector<float>* rescoring_score);
|
||||
|
||||
bool Compute();
|
||||
private:
|
||||
|
||||
std::shared_ptr<FrontendInterface> frontend_;
|
||||
std::shared_ptr<NnetBase> nnet_;
|
||||
SafeQueue<std::vector<kaldi::BaseFloat>> cache_;
|
||||
std::vector<BaseFloat> last_frame_logprob_;
|
||||
bool is_last_frame_skip_ = false;
|
||||
int last_max_elem_ = -1;
|
||||
float blank_threshold_ = 0.0;
|
||||
bool finished_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(NnetProducer);
|
||||
};
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,145 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 USE_ONNX
|
||||
#include "nnet/u2_nnet.h"
|
||||
#else
|
||||
#include "nnet/u2_onnx_nnet.h"
|
||||
#endif
|
||||
#include "base/common.h"
|
||||
#include "decoder/param.h"
|
||||
#include "frontend/feature_pipeline.h"
|
||||
#include "frontend/wave-reader.h"
|
||||
#include "kaldi/util/table-types.h"
|
||||
#include "nnet/decodable.h"
|
||||
#include "nnet/nnet_producer.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
|
||||
DEFINE_string(wav_rspecifier, "", "test wav rspecifier");
|
||||
DEFINE_string(nnet_prob_wspecifier, "", "nnet porb wspecifier");
|
||||
DEFINE_double(streaming_chunk, 0.36, "streaming feature chunk size");
|
||||
DEFINE_int32(sample_rate, 16000, "sample rate");
|
||||
|
||||
using kaldi::BaseFloat;
|
||||
using kaldi::Matrix;
|
||||
using std::vector;
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
gflags::SetUsageMessage("Usage:");
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, false);
|
||||
google::InitGoogleLogging(argv[0]);
|
||||
google::InstallFailureSignalHandler();
|
||||
FLAGS_logtostderr = 1;
|
||||
|
||||
int32 num_done = 0, num_err = 0;
|
||||
int sample_rate = FLAGS_sample_rate;
|
||||
float streaming_chunk = FLAGS_streaming_chunk;
|
||||
int chunk_sample_size = streaming_chunk * sample_rate;
|
||||
|
||||
CHECK_GT(FLAGS_wav_rspecifier.size(), 0);
|
||||
CHECK_GT(FLAGS_nnet_prob_wspecifier.size(), 0);
|
||||
CHECK_GT(FLAGS_model_path.size(), 0);
|
||||
LOG(INFO) << "input rspecifier: " << FLAGS_wav_rspecifier;
|
||||
LOG(INFO) << "output wspecifier: " << FLAGS_nnet_prob_wspecifier;
|
||||
LOG(INFO) << "model path: " << FLAGS_model_path;
|
||||
|
||||
kaldi::SequentialTableReader<kaldi::WaveHolder> wav_reader(
|
||||
FLAGS_wav_rspecifier);
|
||||
kaldi::BaseFloatMatrixWriter nnet_out_writer(FLAGS_nnet_prob_wspecifier);
|
||||
|
||||
ppspeech::ModelOptions model_opts = ppspeech::ModelOptions::InitFromFlags();
|
||||
ppspeech::FeaturePipelineOptions feature_opts =
|
||||
ppspeech::FeaturePipelineOptions::InitFromFlags();
|
||||
feature_opts.assembler_opts.fill_zero = false;
|
||||
|
||||
#ifndef USE_ONNX
|
||||
std::shared_ptr<ppspeech::U2Nnet> nnet(new ppspeech::U2Nnet(model_opts));
|
||||
#else
|
||||
std::shared_ptr<ppspeech::U2OnnxNnet> nnet(new ppspeech::U2OnnxNnet(model_opts));
|
||||
#endif
|
||||
std::shared_ptr<ppspeech::FeaturePipeline> feature_pipeline(
|
||||
new ppspeech::FeaturePipeline(feature_opts));
|
||||
std::shared_ptr<ppspeech::NnetProducer> nnet_producer(
|
||||
new ppspeech::NnetProducer(nnet, feature_pipeline));
|
||||
kaldi::Timer timer;
|
||||
float tot_wav_duration = 0;
|
||||
|
||||
for (; !wav_reader.Done(); wav_reader.Next()) {
|
||||
std::string utt = wav_reader.Key();
|
||||
const kaldi::WaveData& wave_data = wav_reader.Value();
|
||||
LOG(INFO) << "utt: " << utt;
|
||||
LOG(INFO) << "wav dur: " << wave_data.Duration() << " sec.";
|
||||
double dur = wave_data.Duration();
|
||||
tot_wav_duration += dur;
|
||||
|
||||
int32 this_channel = 0;
|
||||
kaldi::SubVector<kaldi::BaseFloat> waveform(wave_data.Data(),
|
||||
this_channel);
|
||||
int tot_samples = waveform.Dim();
|
||||
LOG(INFO) << "wav len (sample): " << tot_samples;
|
||||
|
||||
int sample_offset = 0;
|
||||
kaldi::Timer timer;
|
||||
|
||||
while (sample_offset < tot_samples) {
|
||||
int cur_chunk_size =
|
||||
std::min(chunk_sample_size, tot_samples - sample_offset);
|
||||
|
||||
std::vector<kaldi::BaseFloat> wav_chunk(cur_chunk_size);
|
||||
for (int i = 0; i < cur_chunk_size; ++i) {
|
||||
wav_chunk[i] = waveform(sample_offset + i);
|
||||
}
|
||||
|
||||
nnet_producer->Accept(wav_chunk);
|
||||
if (cur_chunk_size < chunk_sample_size) {
|
||||
nnet_producer->SetInputFinished();
|
||||
}
|
||||
|
||||
// no overlap
|
||||
sample_offset += cur_chunk_size;
|
||||
}
|
||||
CHECK(sample_offset == tot_samples);
|
||||
|
||||
std::vector<std::vector<kaldi::BaseFloat>> prob_vec;
|
||||
while (1) {
|
||||
std::vector<kaldi::BaseFloat> logprobs;
|
||||
bool isok = nnet_producer->Read(&logprobs);
|
||||
if (nnet_producer->IsFinished()) break;
|
||||
if (isok == false) continue;
|
||||
prob_vec.push_back(logprobs);
|
||||
}
|
||||
{
|
||||
// writer nnet output
|
||||
kaldi::MatrixIndexT nrow = prob_vec.size();
|
||||
kaldi::MatrixIndexT ncol = prob_vec[0].size();
|
||||
LOG(INFO) << "nnet out shape: " << nrow << ", " << ncol;
|
||||
kaldi::Matrix<kaldi::BaseFloat> nnet_out(nrow, ncol);
|
||||
for (int32 row_idx = 0; row_idx < nrow; ++row_idx) {
|
||||
for (int32 col_idx = 0; col_idx < ncol; ++col_idx) {
|
||||
nnet_out(row_idx, col_idx) = prob_vec[row_idx][col_idx];
|
||||
}
|
||||
}
|
||||
nnet_out_writer.Write(utt, nnet_out);
|
||||
}
|
||||
nnet_producer->Reset();
|
||||
}
|
||||
|
||||
nnet_producer->Wait();
|
||||
double elapsed = timer.Elapsed();
|
||||
LOG(INFO) << "Program cost:" << elapsed << " sec";
|
||||
|
||||
LOG(INFO) << "Done " << num_done << " utterances, " << num_err
|
||||
<< " with errors.";
|
||||
return (num_done != 0 ? 0 : 1);
|
||||
}
|
||||
@ -0,0 +1,414 @@
|
||||
// Copyright 2022 Horizon Robotics. All Rights Reserved.
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
// modified from
|
||||
// https://github.com/wenet-e2e/wenet/blob/main/runtime/core/decoder/onnx_asr_model.cc
|
||||
|
||||
#include "nnet/u2_onnx_nnet.h"
|
||||
#include "common/base/config.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
void U2OnnxNnet::LoadModel(const std::string& model_dir) {
|
||||
std::string encoder_onnx_path = model_dir + "/encoder.onnx";
|
||||
std::string rescore_onnx_path = model_dir + "/decoder.onnx";
|
||||
std::string ctc_onnx_path = model_dir + "/ctc.onnx";
|
||||
std::string param_path = model_dir + "/param.onnx";
|
||||
// 1. Load sessions
|
||||
try {
|
||||
encoder_ = std::make_shared<fastdeploy::Runtime>();
|
||||
ctc_ = std::make_shared<fastdeploy::Runtime>();
|
||||
rescore_ = std::make_shared<fastdeploy::Runtime>();
|
||||
fastdeploy::RuntimeOption runtime_option;
|
||||
runtime_option.UseOrtBackend();
|
||||
runtime_option.UseCpu();
|
||||
runtime_option.SetCpuThreadNum(1);
|
||||
runtime_option.SetModelPath(encoder_onnx_path.c_str(), "", fastdeploy::ModelFormat::ONNX);
|
||||
assert(encoder_->Init(runtime_option));
|
||||
runtime_option.SetModelPath(rescore_onnx_path.c_str(), "", fastdeploy::ModelFormat::ONNX);
|
||||
assert(rescore_->Init(runtime_option));
|
||||
runtime_option.SetModelPath(ctc_onnx_path.c_str(), "", fastdeploy::ModelFormat::ONNX);
|
||||
assert(ctc_->Init(runtime_option));
|
||||
} catch (std::exception const& e) {
|
||||
LOG(ERROR) << "error when load onnx model: " << e.what();
|
||||
exit(0);
|
||||
}
|
||||
|
||||
Config conf(param_path);
|
||||
encoder_output_size_ = conf.Read("output_size", encoder_output_size_);
|
||||
num_blocks_ = conf.Read("num_blocks", num_blocks_);
|
||||
head_ = conf.Read("head", head_);
|
||||
cnn_module_kernel_ = conf.Read("cnn_module_kernel", cnn_module_kernel_);
|
||||
subsampling_rate_ = conf.Read("subsampling_rate", subsampling_rate_);
|
||||
right_context_ = conf.Read("right_context", right_context_);
|
||||
sos_= conf.Read("sos_symbol", sos_);
|
||||
eos_= conf.Read("eos_symbol", eos_);
|
||||
is_bidecoder_= conf.Read("is_bidirectional_decoder", is_bidecoder_);
|
||||
chunk_size_= conf.Read("chunk_size", chunk_size_);
|
||||
num_left_chunks_ = conf.Read("left_chunks", num_left_chunks_);
|
||||
|
||||
LOG(INFO) << "Onnx Model Info:";
|
||||
LOG(INFO) << "\tencoder_output_size " << encoder_output_size_;
|
||||
LOG(INFO) << "\tnum_blocks " << num_blocks_;
|
||||
LOG(INFO) << "\thead " << head_;
|
||||
LOG(INFO) << "\tcnn_module_kernel " << cnn_module_kernel_;
|
||||
LOG(INFO) << "\tsubsampling_rate " << subsampling_rate_;
|
||||
LOG(INFO) << "\tright_context " << right_context_;
|
||||
LOG(INFO) << "\tsos " << sos_;
|
||||
LOG(INFO) << "\teos " << eos_;
|
||||
LOG(INFO) << "\tis bidirectional decoder " << is_bidecoder_;
|
||||
LOG(INFO) << "\tchunk_size " << chunk_size_;
|
||||
LOG(INFO) << "\tnum_left_chunks " << num_left_chunks_;
|
||||
|
||||
// 3. Read model nodes
|
||||
LOG(INFO) << "Onnx Encoder:";
|
||||
GetInputOutputInfo(encoder_, &encoder_in_names_, &encoder_out_names_);
|
||||
LOG(INFO) << "Onnx CTC:";
|
||||
GetInputOutputInfo(ctc_, &ctc_in_names_, &ctc_out_names_);
|
||||
LOG(INFO) << "Onnx Rescore:";
|
||||
GetInputOutputInfo(rescore_, &rescore_in_names_, &rescore_out_names_);
|
||||
}
|
||||
|
||||
U2OnnxNnet::U2OnnxNnet(const ModelOptions& opts) : opts_(opts) {
|
||||
LoadModel(opts_.model_path);
|
||||
}
|
||||
|
||||
// shallow copy
|
||||
U2OnnxNnet::U2OnnxNnet(const U2OnnxNnet& other) {
|
||||
// metadatas
|
||||
encoder_output_size_ = other.encoder_output_size_;
|
||||
num_blocks_ = other.num_blocks_;
|
||||
head_ = other.head_;
|
||||
cnn_module_kernel_ = other.cnn_module_kernel_;
|
||||
right_context_ = other.right_context_;
|
||||
subsampling_rate_ = other.subsampling_rate_;
|
||||
sos_ = other.sos_;
|
||||
eos_ = other.eos_;
|
||||
is_bidecoder_ = other.is_bidecoder_;
|
||||
chunk_size_ = other.chunk_size_;
|
||||
num_left_chunks_ = other.num_left_chunks_;
|
||||
offset_ = other.offset_;
|
||||
|
||||
// session
|
||||
encoder_ = other.encoder_;
|
||||
ctc_ = other.ctc_;
|
||||
rescore_ = other.rescore_;
|
||||
|
||||
// node names
|
||||
encoder_in_names_ = other.encoder_in_names_;
|
||||
encoder_out_names_ = other.encoder_out_names_;
|
||||
ctc_in_names_ = other.ctc_in_names_;
|
||||
ctc_out_names_ = other.ctc_out_names_;
|
||||
rescore_in_names_ = other.rescore_in_names_;
|
||||
rescore_out_names_ = other.rescore_out_names_;
|
||||
}
|
||||
|
||||
void U2OnnxNnet::GetInputOutputInfo(const std::shared_ptr<fastdeploy::Runtime>& runtime,
|
||||
std::vector<std::string>* in_names, std::vector<std::string>* out_names) {
|
||||
std::vector<fastdeploy::TensorInfo> inputs_info = runtime->GetInputInfos();
|
||||
(*in_names).resize(inputs_info.size());
|
||||
for (int i = 0; i < inputs_info.size(); ++i){
|
||||
fastdeploy::TensorInfo info = inputs_info[i];
|
||||
|
||||
std::stringstream shape;
|
||||
for(int j = 0; j < info.shape.size(); ++j){
|
||||
shape << info.shape[j];
|
||||
shape << " ";
|
||||
}
|
||||
LOG(INFO) << "\tInput " << i << " : name=" << info.name << " type=" << info.dtype
|
||||
<< " dims=" << shape.str();
|
||||
(*in_names)[i] = info.name;
|
||||
}
|
||||
std::vector<fastdeploy::TensorInfo> outputs_info = runtime->GetOutputInfos();
|
||||
(*out_names).resize(outputs_info.size());
|
||||
for (int i = 0; i < outputs_info.size(); ++i){
|
||||
fastdeploy::TensorInfo info = outputs_info[i];
|
||||
|
||||
std::stringstream shape;
|
||||
for(int j = 0; j < info.shape.size(); ++j){
|
||||
shape << info.shape[j];
|
||||
shape << " ";
|
||||
}
|
||||
LOG(INFO) << "\tOutput " << i << " : name=" << info.name << " type=" << info.dtype
|
||||
<< " dims=" << shape.str();
|
||||
(*out_names)[i] = info.name;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<NnetBase> U2OnnxNnet::Clone() const {
|
||||
auto asr_model = std::make_shared<U2OnnxNnet>(*this);
|
||||
// reset inner state for new decoding
|
||||
asr_model->Reset();
|
||||
return asr_model;
|
||||
}
|
||||
|
||||
void U2OnnxNnet::Reset() {
|
||||
offset_ = 0;
|
||||
encoder_outs_.clear();
|
||||
cached_feats_.clear();
|
||||
// Reset att_cache
|
||||
if (num_left_chunks_ > 0) {
|
||||
int required_cache_size = chunk_size_ * num_left_chunks_;
|
||||
offset_ = required_cache_size;
|
||||
att_cache_.resize(num_blocks_ * head_ * required_cache_size *
|
||||
encoder_output_size_ / head_ * 2,
|
||||
0.0);
|
||||
const std::vector<int64_t> att_cache_shape = {num_blocks_, head_, required_cache_size,
|
||||
encoder_output_size_ / head_ * 2};
|
||||
att_cache_ort_.SetExternalData(att_cache_shape, fastdeploy::FDDataType::FP32, att_cache_.data());
|
||||
} else {
|
||||
att_cache_.resize(0, 0.0);
|
||||
const std::vector<int64_t> att_cache_shape = {num_blocks_, head_, 0,
|
||||
encoder_output_size_ / head_ * 2};
|
||||
att_cache_ort_.SetExternalData(att_cache_shape, fastdeploy::FDDataType::FP32, att_cache_.data());
|
||||
}
|
||||
|
||||
// Reset cnn_cache
|
||||
cnn_cache_.resize(
|
||||
num_blocks_ * encoder_output_size_ * (cnn_module_kernel_ - 1), 0.0);
|
||||
const std::vector<int64_t> cnn_cache_shape = {num_blocks_, 1, encoder_output_size_,
|
||||
cnn_module_kernel_ - 1};
|
||||
cnn_cache_ort_.SetExternalData(cnn_cache_shape, fastdeploy::FDDataType::FP32, cnn_cache_.data());
|
||||
}
|
||||
|
||||
void U2OnnxNnet::FeedForward(const std::vector<BaseFloat>& features,
|
||||
const int32& feature_dim,
|
||||
NnetOut* out) {
|
||||
kaldi::Timer timer;
|
||||
|
||||
std::vector<kaldi::BaseFloat> ctc_probs;
|
||||
ForwardEncoderChunkImpl(
|
||||
features, feature_dim, &out->logprobs, &out->vocab_dim);
|
||||
VLOG(1) << "FeedForward cost: " << timer.Elapsed() << " sec. "
|
||||
<< features.size() / feature_dim << " frames.";
|
||||
}
|
||||
|
||||
void U2OnnxNnet::ForwardEncoderChunkImpl(
|
||||
const std::vector<kaldi::BaseFloat>& chunk_feats,
|
||||
const int32& feat_dim,
|
||||
std::vector<kaldi::BaseFloat>* out_prob,
|
||||
int32* vocab_dim) {
|
||||
|
||||
// 1. Prepare onnx required data, splice cached_feature_ and chunk_feats
|
||||
// chunk
|
||||
int num_frames = chunk_feats.size() / feat_dim;
|
||||
VLOG(3) << "num_frames: " << num_frames;
|
||||
VLOG(3) << "feat_dim: " << feat_dim;
|
||||
const int feature_dim = feat_dim;
|
||||
std::vector<float> feats;
|
||||
feats.insert(feats.end(), chunk_feats.begin(), chunk_feats.end());
|
||||
fastdeploy::FDTensor feats_ort;
|
||||
const std::vector<int64_t> feats_shape = {1, num_frames, feature_dim};
|
||||
feats_ort.SetExternalData(feats_shape, fastdeploy::FDDataType::FP32, feats.data());
|
||||
|
||||
// offset
|
||||
int64_t offset_int64 = static_cast<int64_t>(offset_);
|
||||
fastdeploy::FDTensor offset_ort;
|
||||
offset_ort.SetExternalData({}, fastdeploy::FDDataType::INT64, &offset_int64);
|
||||
|
||||
// required_cache_size
|
||||
int64_t required_cache_size = chunk_size_ * num_left_chunks_;
|
||||
fastdeploy::FDTensor required_cache_size_ort("");
|
||||
required_cache_size_ort.SetExternalData({}, fastdeploy::FDDataType::INT64, &required_cache_size);
|
||||
|
||||
// att_mask
|
||||
fastdeploy::FDTensor att_mask_ort;
|
||||
std::vector<uint8_t> att_mask(required_cache_size + chunk_size_, 1);
|
||||
if (num_left_chunks_ > 0) {
|
||||
int chunk_idx = offset_ / chunk_size_ - num_left_chunks_;
|
||||
if (chunk_idx < num_left_chunks_) {
|
||||
for (int i = 0; i < (num_left_chunks_ - chunk_idx) * chunk_size_; ++i) {
|
||||
att_mask[i] = 0;
|
||||
}
|
||||
}
|
||||
const std::vector<int64_t> att_mask_shape = {1, 1, required_cache_size + chunk_size_};
|
||||
att_mask_ort.SetExternalData(att_mask_shape, fastdeploy::FDDataType::BOOL, reinterpret_cast<bool*>(att_mask.data()));
|
||||
}
|
||||
|
||||
// 2. Encoder chunk forward
|
||||
std::vector<fastdeploy::FDTensor> inputs(encoder_in_names_.size());
|
||||
for (int i = 0; i < encoder_in_names_.size(); ++i) {
|
||||
std::string name = encoder_in_names_[i];
|
||||
if (!strcmp(name.data(), "chunk")) {
|
||||
inputs[i] = std::move(feats_ort);
|
||||
inputs[i].name = "chunk";
|
||||
} else if (!strcmp(name.data(), "offset")) {
|
||||
inputs[i] = std::move(offset_ort);
|
||||
inputs[i].name = "offset";
|
||||
} else if (!strcmp(name.data(), "required_cache_size")) {
|
||||
inputs[i] = std::move(required_cache_size_ort);
|
||||
inputs[i].name = "required_cache_size";
|
||||
} else if (!strcmp(name.data(), "att_cache")) {
|
||||
inputs[i] = std::move(att_cache_ort_);
|
||||
inputs[i].name = "att_cache";
|
||||
} else if (!strcmp(name.data(), "cnn_cache")) {
|
||||
inputs[i] = std::move(cnn_cache_ort_);
|
||||
inputs[i].name = "cnn_cache";
|
||||
} else if (!strcmp(name.data(), "att_mask")) {
|
||||
inputs[i] = std::move(att_mask_ort);
|
||||
inputs[i].name = "att_mask";
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<fastdeploy::FDTensor> ort_outputs;
|
||||
assert(encoder_->Infer(inputs, &ort_outputs));
|
||||
|
||||
offset_ += static_cast<int>(ort_outputs[0].shape[1]);
|
||||
att_cache_ort_ = std::move(ort_outputs[1]);
|
||||
cnn_cache_ort_ = std::move(ort_outputs[2]);
|
||||
|
||||
std::vector<fastdeploy::FDTensor> ctc_inputs;
|
||||
ctc_inputs.emplace_back(std::move(ort_outputs[0]));
|
||||
// ctc_inputs[0] = std::move(ort_outputs[0]);
|
||||
ctc_inputs[0].name = ctc_in_names_[0];
|
||||
|
||||
std::vector<fastdeploy::FDTensor> ctc_ort_outputs;
|
||||
assert(ctc_->Infer(ctc_inputs, &ctc_ort_outputs));
|
||||
encoder_outs_.emplace_back(std::move(ctc_inputs[0])); // *****
|
||||
|
||||
float* logp_data = reinterpret_cast<float*>(ctc_ort_outputs[0].Data());
|
||||
|
||||
// Copy to output, (B=1,T,D)
|
||||
std::vector<int64_t> ctc_log_probs_shape = ctc_ort_outputs[0].shape;
|
||||
CHECK_EQ(ctc_log_probs_shape.size(), 3);
|
||||
int B = ctc_log_probs_shape[0];
|
||||
CHECK_EQ(B, 1);
|
||||
int T = ctc_log_probs_shape[1];
|
||||
int D = ctc_log_probs_shape[2];
|
||||
*vocab_dim = D;
|
||||
|
||||
out_prob->resize(T * D);
|
||||
std::memcpy(
|
||||
out_prob->data(), logp_data, T * D * sizeof(kaldi::BaseFloat));
|
||||
return;
|
||||
}
|
||||
|
||||
float U2OnnxNnet::ComputeAttentionScore(const float* prob,
|
||||
const std::vector<int>& hyp, int eos,
|
||||
int decode_out_len) {
|
||||
float score = 0.0f;
|
||||
for (size_t j = 0; j < hyp.size(); ++j) {
|
||||
score += *(prob + j * decode_out_len + hyp[j]);
|
||||
}
|
||||
score += *(prob + hyp.size() * decode_out_len + eos);
|
||||
return score;
|
||||
}
|
||||
|
||||
void U2OnnxNnet::AttentionRescoring(const std::vector<std::vector<int>>& hyps,
|
||||
float reverse_weight,
|
||||
std::vector<float>* rescoring_score) {
|
||||
CHECK(rescoring_score != nullptr);
|
||||
int num_hyps = hyps.size();
|
||||
rescoring_score->resize(num_hyps, 0.0f);
|
||||
|
||||
if (num_hyps == 0) {
|
||||
return;
|
||||
}
|
||||
// No encoder output
|
||||
if (encoder_outs_.size() == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<int64_t> hyps_lens;
|
||||
int max_hyps_len = 0;
|
||||
for (size_t i = 0; i < num_hyps; ++i) {
|
||||
int length = hyps[i].size() + 1;
|
||||
max_hyps_len = std::max(length, max_hyps_len);
|
||||
hyps_lens.emplace_back(static_cast<int64_t>(length));
|
||||
}
|
||||
|
||||
std::vector<float> rescore_input;
|
||||
int encoder_len = 0;
|
||||
for (int i = 0; i < encoder_outs_.size(); i++) {
|
||||
float* encoder_outs_data = reinterpret_cast<float*>(encoder_outs_[i].Data());
|
||||
for (int j = 0; j < encoder_outs_[i].Numel(); j++) {
|
||||
rescore_input.emplace_back(encoder_outs_data[j]);
|
||||
}
|
||||
encoder_len += encoder_outs_[i].shape[1];
|
||||
}
|
||||
|
||||
std::vector<int64_t> hyps_pad;
|
||||
|
||||
for (size_t i = 0; i < num_hyps; ++i) {
|
||||
const std::vector<int>& hyp = hyps[i];
|
||||
hyps_pad.emplace_back(sos_);
|
||||
size_t j = 0;
|
||||
for (; j < hyp.size(); ++j) {
|
||||
hyps_pad.emplace_back(hyp[j]);
|
||||
}
|
||||
if (j == max_hyps_len - 1) {
|
||||
continue;
|
||||
}
|
||||
for (; j < max_hyps_len - 1; ++j) {
|
||||
hyps_pad.emplace_back(0);
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<int64_t> hyps_pad_shape = {num_hyps, max_hyps_len};
|
||||
const std::vector<int64_t> hyps_lens_shape = {num_hyps};
|
||||
const std::vector<int64_t> decode_input_shape = {1, encoder_len, encoder_output_size_};
|
||||
|
||||
fastdeploy::FDTensor hyps_pad_tensor_;
|
||||
hyps_pad_tensor_.SetExternalData(hyps_pad_shape, fastdeploy::FDDataType::INT64, hyps_pad.data());
|
||||
fastdeploy::FDTensor hyps_lens_tensor_;
|
||||
hyps_lens_tensor_.SetExternalData(hyps_lens_shape, fastdeploy::FDDataType::INT64, hyps_lens.data());
|
||||
fastdeploy::FDTensor decode_input_tensor_;
|
||||
decode_input_tensor_.SetExternalData(decode_input_shape, fastdeploy::FDDataType::FP32, rescore_input.data());
|
||||
|
||||
std::vector<fastdeploy::FDTensor> rescore_inputs(3);
|
||||
|
||||
rescore_inputs[0] = std::move(hyps_pad_tensor_);
|
||||
rescore_inputs[0].name = rescore_in_names_[0];
|
||||
rescore_inputs[1] = std::move(hyps_lens_tensor_);
|
||||
rescore_inputs[1].name = rescore_in_names_[1];
|
||||
rescore_inputs[2] = std::move(decode_input_tensor_);
|
||||
rescore_inputs[2].name = rescore_in_names_[2];
|
||||
|
||||
std::vector<fastdeploy::FDTensor> rescore_outputs;
|
||||
assert(rescore_->Infer(rescore_inputs, &rescore_outputs));
|
||||
|
||||
float* decoder_outs_data = reinterpret_cast<float*>(rescore_outputs[0].Data());
|
||||
float* r_decoder_outs_data = reinterpret_cast<float*>(rescore_outputs[1].Data());
|
||||
|
||||
int decode_out_len = rescore_outputs[0].shape[2];
|
||||
|
||||
for (size_t i = 0; i < num_hyps; ++i) {
|
||||
const std::vector<int>& hyp = hyps[i];
|
||||
float score = 0.0f;
|
||||
// left to right decoder score
|
||||
score = ComputeAttentionScore(
|
||||
decoder_outs_data + max_hyps_len * decode_out_len * i, hyp, eos_,
|
||||
decode_out_len);
|
||||
// Optional: Used for right to left score
|
||||
float r_score = 0.0f;
|
||||
if (is_bidecoder_ && reverse_weight > 0) {
|
||||
std::vector<int> r_hyp(hyp.size());
|
||||
std::reverse_copy(hyp.begin(), hyp.end(), r_hyp.begin());
|
||||
// right to left decoder score
|
||||
r_score = ComputeAttentionScore(
|
||||
r_decoder_outs_data + max_hyps_len * decode_out_len * i, r_hyp, eos_,
|
||||
decode_out_len);
|
||||
}
|
||||
// combined left-to-right and right-to-left score
|
||||
(*rescoring_score)[i] =
|
||||
score * (1 - reverse_weight) + r_score * reverse_weight;
|
||||
}
|
||||
}
|
||||
|
||||
void U2OnnxNnet::EncoderOuts(
|
||||
std::vector<std::vector<kaldi::BaseFloat>>* encoder_out) const {
|
||||
}
|
||||
|
||||
} //namepace ppspeech
|
||||
@ -0,0 +1,97 @@
|
||||
// Copyright 2022 Horizon Robotics. All Rights Reserved.
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
// modified from
|
||||
// https://github.com/wenet-e2e/wenet/blob/main/runtime/core/decoder/onnx_asr_model.h
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "base/common.h"
|
||||
#include "matrix/kaldi-matrix.h"
|
||||
#include "nnet/nnet_itf.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
|
||||
#include "fastdeploy/runtime.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
class U2OnnxNnet : public U2NnetBase {
|
||||
|
||||
public:
|
||||
explicit U2OnnxNnet(const ModelOptions& opts);
|
||||
U2OnnxNnet(const U2OnnxNnet& other);
|
||||
|
||||
void FeedForward(const std::vector<kaldi::BaseFloat>& features,
|
||||
const int32& feature_dim,
|
||||
NnetOut* out) override;
|
||||
|
||||
void Reset() override;
|
||||
|
||||
bool IsLogProb() override { return true; }
|
||||
|
||||
void Dim();
|
||||
|
||||
void LoadModel(const std::string& model_dir);
|
||||
|
||||
std::shared_ptr<NnetBase> Clone() const override;
|
||||
|
||||
void ForwardEncoderChunkImpl(
|
||||
const std::vector<kaldi::BaseFloat>& chunk_feats,
|
||||
const int32& feat_dim,
|
||||
std::vector<kaldi::BaseFloat>* ctc_probs,
|
||||
int32* vocab_dim) override;
|
||||
|
||||
float ComputeAttentionScore(const float* prob, const std::vector<int>& hyp,
|
||||
int eos, int decode_out_len);
|
||||
|
||||
void AttentionRescoring(const std::vector<std::vector<int>>& hyps,
|
||||
float reverse_weight,
|
||||
std::vector<float>* rescoring_score) override;
|
||||
|
||||
void EncoderOuts(
|
||||
std::vector<std::vector<kaldi::BaseFloat>>* encoder_out) const;
|
||||
|
||||
void GetInputOutputInfo(const std::shared_ptr<fastdeploy::Runtime>& runtime,
|
||||
std::vector<std::string>* in_names,
|
||||
std::vector<std::string>* out_names);
|
||||
private:
|
||||
ModelOptions opts_;
|
||||
|
||||
int encoder_output_size_ = 0;
|
||||
int num_blocks_ = 0;
|
||||
int cnn_module_kernel_ = 0;
|
||||
int head_ = 0;
|
||||
|
||||
// sessions
|
||||
std::shared_ptr<fastdeploy::Runtime> encoder_ = nullptr;
|
||||
std::shared_ptr<fastdeploy::Runtime> rescore_ = nullptr;
|
||||
std::shared_ptr<fastdeploy::Runtime> ctc_ = nullptr;
|
||||
|
||||
|
||||
// node names
|
||||
std::vector<std::string> encoder_in_names_, encoder_out_names_;
|
||||
std::vector<std::string> ctc_in_names_, ctc_out_names_;
|
||||
std::vector<std::string> rescore_in_names_, rescore_out_names_;
|
||||
|
||||
// caches
|
||||
fastdeploy::FDTensor att_cache_ort_;
|
||||
fastdeploy::FDTensor cnn_cache_ort_;
|
||||
std::vector<fastdeploy::FDTensor> encoder_outs_;
|
||||
|
||||
std::vector<float> att_cache_;
|
||||
std::vector<float> cnn_cache_;
|
||||
};
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,26 @@
|
||||
set(srcs)
|
||||
|
||||
list(APPEND srcs
|
||||
recognizer_controller.cc
|
||||
recognizer_controller_impl.cc
|
||||
recognizer_instance.cc
|
||||
recognizer.cc
|
||||
)
|
||||
|
||||
add_library(recognizer STATIC ${srcs})
|
||||
target_link_libraries(recognizer PUBLIC decoder)
|
||||
|
||||
set(TEST_BINS
|
||||
recognizer_batch_main
|
||||
recognizer_batch_main2
|
||||
recognizer_main
|
||||
)
|
||||
|
||||
foreach(bin_name IN LISTS TEST_BINS)
|
||||
add_executable(${bin_name} ${CMAKE_CURRENT_SOURCE_DIR}/${bin_name}.cc)
|
||||
target_include_directories(${bin_name} PRIVATE ${SPEECHX_ROOT} ${SPEECHX_ROOT}/kaldi)
|
||||
target_link_libraries(${bin_name} recognizer nnet decoder fst utils gflags glog kaldi-base kaldi-matrix kaldi-util)
|
||||
target_compile_options(${bin_name} PRIVATE ${PADDLE_COMPILE_FLAGS})
|
||||
target_include_directories(${bin_name} PRIVATE ${pybind11_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR})
|
||||
target_link_libraries(${bin_name} ${PYTHON_LIBRARIES} ${PADDLE_LINK_FLAGS} -ldl)
|
||||
endforeach()
|
||||
@ -0,0 +1,46 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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 "recognizer/recognizer.h"
|
||||
#include "recognizer/recognizer_instance.h"
|
||||
|
||||
bool InitRecognizer(const std::string& model_file,
|
||||
const std::string& word_symbol_table_file,
|
||||
const std::string& fst_file,
|
||||
int num_instance) {
|
||||
return ppspeech::RecognizerInstance::GetInstance().Init(model_file,
|
||||
word_symbol_table_file,
|
||||
fst_file,
|
||||
num_instance);
|
||||
}
|
||||
|
||||
int GetRecognizerInstanceId() {
|
||||
return ppspeech::RecognizerInstance::GetInstance().GetRecognizerInstanceId();
|
||||
}
|
||||
|
||||
void InitDecoder(int instance_id) {
|
||||
return ppspeech::RecognizerInstance::GetInstance().InitDecoder(instance_id);
|
||||
}
|
||||
|
||||
void AcceptData(const std::vector<float>& waves, int instance_id) {
|
||||
return ppspeech::RecognizerInstance::GetInstance().Accept(waves, instance_id);
|
||||
}
|
||||
|
||||
void SetInputFinished(int instance_id) {
|
||||
return ppspeech::RecognizerInstance::GetInstance().SetInputFinished(instance_id);
|
||||
}
|
||||
|
||||
std::string GetFinalResult(int instance_id) {
|
||||
return ppspeech::RecognizerInstance::GetInstance().GetResult(instance_id);
|
||||
}
|
||||
@ -0,0 +1,28 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
bool InitRecognizer(const std::string& model_file,
|
||||
const std::string& word_symbol_table_file,
|
||||
const std::string& fst_file,
|
||||
int num_instance);
|
||||
int GetRecognizerInstanceId();
|
||||
void InitDecoder(int instance_id);
|
||||
void AcceptData(const std::vector<float>& waves, int instance_id);
|
||||
void SetInputFinished(int instance_id);
|
||||
std::string GetFinalResult(int instance_id);
|
||||
@ -0,0 +1,172 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 "common/base/thread_pool.h"
|
||||
#include "common/utils/file_utils.h"
|
||||
#include "common/utils/strings.h"
|
||||
#include "decoder/param.h"
|
||||
#include "frontend/wave-reader.h"
|
||||
#include "kaldi/util/table-types.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
#include "recognizer/recognizer_controller.h"
|
||||
|
||||
DEFINE_string(wav_rspecifier, "", "test feature rspecifier");
|
||||
DEFINE_string(result_wspecifier, "", "test result wspecifier");
|
||||
DEFINE_double(streaming_chunk, 0.36, "streaming feature chunk size");
|
||||
DEFINE_int32(sample_rate, 16000, "sample rate");
|
||||
DEFINE_int32(njob, 3, "njob");
|
||||
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
void SplitUtt(string wavlist_file,
|
||||
vector<vector<string>>* uttlists,
|
||||
vector<vector<string>>* wavlists,
|
||||
int njob) {
|
||||
vector<string> wavlist;
|
||||
wavlists->resize(njob);
|
||||
uttlists->resize(njob);
|
||||
ppspeech::ReadFileToVector(wavlist_file, &wavlist);
|
||||
for (size_t idx = 0; idx < wavlist.size(); ++idx) {
|
||||
string utt_str = wavlist[idx];
|
||||
vector<string> utt_wav = ppspeech::StrSplit(utt_str, " \t");
|
||||
LOG(INFO) << utt_wav[0];
|
||||
CHECK_EQ(utt_wav.size(), size_t(2));
|
||||
uttlists->at(idx % njob).push_back(utt_wav[0]);
|
||||
wavlists->at(idx % njob).push_back(utt_wav[1]);
|
||||
}
|
||||
}
|
||||
|
||||
void recognizer_func(ppspeech::RecognizerController* recognizer_controller,
|
||||
std::vector<string> wavlist,
|
||||
std::vector<string> uttlist,
|
||||
std::vector<string>* results) {
|
||||
int32 num_done = 0, num_err = 0;
|
||||
double tot_wav_duration = 0.0;
|
||||
double tot_attention_rescore_time = 0.0;
|
||||
double tot_decode_time = 0.0;
|
||||
int chunk_sample_size = FLAGS_streaming_chunk * FLAGS_sample_rate;
|
||||
if (wavlist.empty()) return;
|
||||
|
||||
results->reserve(wavlist.size());
|
||||
for (size_t idx = 0; idx < wavlist.size(); ++idx) {
|
||||
std::string utt = uttlist[idx];
|
||||
std::string wav_file = wavlist[idx];
|
||||
std::ifstream infile;
|
||||
infile.open(wav_file, std::ifstream::in);
|
||||
kaldi::WaveData wave_data;
|
||||
wave_data.Read(infile);
|
||||
int32 recog_id = -1;
|
||||
while (recog_id == -1) {
|
||||
recog_id = recognizer_controller->GetRecognizerInstanceId();
|
||||
}
|
||||
recognizer_controller->InitDecoder(recog_id);
|
||||
LOG(INFO) << "utt: " << utt;
|
||||
LOG(INFO) << "wav dur: " << wave_data.Duration() << " sec.";
|
||||
double dur = wave_data.Duration();
|
||||
tot_wav_duration += dur;
|
||||
|
||||
int32 this_channel = 0;
|
||||
kaldi::SubVector<kaldi::BaseFloat> waveform(wave_data.Data(),
|
||||
this_channel);
|
||||
int tot_samples = waveform.Dim();
|
||||
LOG(INFO) << "wav len (sample): " << tot_samples;
|
||||
|
||||
int sample_offset = 0;
|
||||
kaldi::Timer local_timer;
|
||||
|
||||
while (sample_offset < tot_samples) {
|
||||
int cur_chunk_size =
|
||||
std::min(chunk_sample_size, tot_samples - sample_offset);
|
||||
|
||||
std::vector<kaldi::BaseFloat> wav_chunk(cur_chunk_size);
|
||||
for (int i = 0; i < cur_chunk_size; ++i) {
|
||||
wav_chunk[i] = waveform(sample_offset + i);
|
||||
}
|
||||
|
||||
recognizer_controller->Accept(wav_chunk, recog_id);
|
||||
// no overlap
|
||||
sample_offset += cur_chunk_size;
|
||||
}
|
||||
recognizer_controller->SetInputFinished(recog_id);
|
||||
CHECK(sample_offset == tot_samples);
|
||||
std::string result = recognizer_controller->GetFinalResult(recog_id);
|
||||
if (result.empty()) {
|
||||
// the TokenWriter can not write empty string.
|
||||
++num_err;
|
||||
LOG(INFO) << " the result of " << utt << " is empty";
|
||||
result = " ";
|
||||
}
|
||||
|
||||
tot_decode_time += local_timer.Elapsed();
|
||||
LOG(INFO) << utt << " " << result;
|
||||
LOG(INFO) << " RTF: " << local_timer.Elapsed() / dur << " dur: " << dur
|
||||
<< " cost: " << local_timer.Elapsed();
|
||||
|
||||
results->push_back(result);
|
||||
++num_done;
|
||||
}
|
||||
LOG(INFO) << "Done " << num_done << " out of " << (num_err + num_done);
|
||||
LOG(INFO) << "total wav duration is: " << tot_wav_duration << " sec";
|
||||
LOG(INFO) << "total decode cost:" << tot_decode_time << " sec";
|
||||
LOG(INFO) << "RTF is: " << tot_decode_time / tot_wav_duration;
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
gflags::SetUsageMessage("Usage:");
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, false);
|
||||
google::InitGoogleLogging(argv[0]);
|
||||
google::InstallFailureSignalHandler();
|
||||
FLAGS_logtostderr = 1;
|
||||
|
||||
int sample_rate = FLAGS_sample_rate;
|
||||
float streaming_chunk = FLAGS_streaming_chunk;
|
||||
int chunk_sample_size = streaming_chunk * sample_rate;
|
||||
kaldi::TokenWriter result_writer(FLAGS_result_wspecifier);
|
||||
int njob = FLAGS_njob;
|
||||
LOG(INFO) << "sr: " << sample_rate;
|
||||
LOG(INFO) << "chunk size (s): " << streaming_chunk;
|
||||
LOG(INFO) << "chunk size (sample): " << chunk_sample_size;
|
||||
|
||||
ppspeech::RecognizerResource resource =
|
||||
ppspeech::RecognizerResource::InitFromFlags();
|
||||
ppspeech::RecognizerController recognizer_controller(njob, resource);
|
||||
ThreadPool threadpool(njob);
|
||||
vector<vector<string>> wavlist;
|
||||
vector<vector<string>> uttlist;
|
||||
vector<vector<string>> resultlist(njob);
|
||||
vector<std::future<void>> futurelist;
|
||||
SplitUtt(FLAGS_wav_rspecifier, &uttlist, &wavlist, njob);
|
||||
for (size_t i = 0; i < njob; ++i) {
|
||||
std::future<void> f = threadpool.enqueue(recognizer_func,
|
||||
&recognizer_controller,
|
||||
wavlist[i],
|
||||
uttlist[i],
|
||||
&resultlist[i]);
|
||||
futurelist.push_back(std::move(f));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < njob; ++i) {
|
||||
futurelist[i].get();
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < njob; ++idx) {
|
||||
for (size_t utt_idx = 0; utt_idx < uttlist[idx].size(); ++utt_idx) {
|
||||
string utt = uttlist[idx][utt_idx];
|
||||
string result = resultlist[idx][utt_idx];
|
||||
result_writer.Write(utt, result);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,168 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 "common/base/thread_pool.h"
|
||||
#include "common/utils/file_utils.h"
|
||||
#include "common/utils/strings.h"
|
||||
#include "decoder/param.h"
|
||||
#include "frontend/wave-reader.h"
|
||||
#include "kaldi/util/table-types.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
#include "recognizer/recognizer.h"
|
||||
|
||||
DEFINE_string(wav_rspecifier, "", "test feature rspecifier");
|
||||
DEFINE_string(result_wspecifier, "", "test result wspecifier");
|
||||
DEFINE_double(streaming_chunk, 0.36, "streaming feature chunk size");
|
||||
DEFINE_int32(sample_rate, 16000, "sample rate");
|
||||
DEFINE_int32(njob, 3, "njob");
|
||||
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
void SplitUtt(string wavlist_file,
|
||||
vector<vector<string>>* uttlists,
|
||||
vector<vector<string>>* wavlists,
|
||||
int njob) {
|
||||
vector<string> wavlist;
|
||||
wavlists->resize(njob);
|
||||
uttlists->resize(njob);
|
||||
ppspeech::ReadFileToVector(wavlist_file, &wavlist);
|
||||
for (size_t idx = 0; idx < wavlist.size(); ++idx) {
|
||||
string utt_str = wavlist[idx];
|
||||
vector<string> utt_wav = ppspeech::StrSplit(utt_str, " \t");
|
||||
LOG(INFO) << utt_wav[0];
|
||||
CHECK_EQ(utt_wav.size(), size_t(2));
|
||||
uttlists->at(idx % njob).push_back(utt_wav[0]);
|
||||
wavlists->at(idx % njob).push_back(utt_wav[1]);
|
||||
}
|
||||
}
|
||||
|
||||
void recognizer_func(std::vector<string> wavlist,
|
||||
std::vector<string> uttlist,
|
||||
std::vector<string>* results) {
|
||||
int32 num_done = 0, num_err = 0;
|
||||
double tot_wav_duration = 0.0;
|
||||
double tot_attention_rescore_time = 0.0;
|
||||
double tot_decode_time = 0.0;
|
||||
int chunk_sample_size = FLAGS_streaming_chunk * FLAGS_sample_rate;
|
||||
if (wavlist.empty()) return;
|
||||
|
||||
results->reserve(wavlist.size());
|
||||
for (size_t idx = 0; idx < wavlist.size(); ++idx) {
|
||||
std::string utt = uttlist[idx];
|
||||
std::string wav_file = wavlist[idx];
|
||||
std::ifstream infile;
|
||||
infile.open(wav_file, std::ifstream::in);
|
||||
kaldi::WaveData wave_data;
|
||||
wave_data.Read(infile);
|
||||
int32 recog_id = -1;
|
||||
while (recog_id == -1) {
|
||||
recog_id = GetRecognizerInstanceId();
|
||||
}
|
||||
InitDecoder(recog_id);
|
||||
LOG(INFO) << "utt: " << utt;
|
||||
LOG(INFO) << "wav dur: " << wave_data.Duration() << " sec.";
|
||||
double dur = wave_data.Duration();
|
||||
tot_wav_duration += dur;
|
||||
|
||||
int32 this_channel = 0;
|
||||
kaldi::SubVector<kaldi::BaseFloat> waveform(wave_data.Data(),
|
||||
this_channel);
|
||||
int tot_samples = waveform.Dim();
|
||||
LOG(INFO) << "wav len (sample): " << tot_samples;
|
||||
|
||||
int sample_offset = 0;
|
||||
kaldi::Timer local_timer;
|
||||
|
||||
while (sample_offset < tot_samples) {
|
||||
int cur_chunk_size =
|
||||
std::min(chunk_sample_size, tot_samples - sample_offset);
|
||||
|
||||
std::vector<kaldi::BaseFloat> wav_chunk(cur_chunk_size);
|
||||
for (int i = 0; i < cur_chunk_size; ++i) {
|
||||
wav_chunk[i] = waveform(sample_offset + i);
|
||||
}
|
||||
|
||||
AcceptData(wav_chunk, recog_id);
|
||||
// no overlap
|
||||
sample_offset += cur_chunk_size;
|
||||
}
|
||||
SetInputFinished(recog_id);
|
||||
CHECK(sample_offset == tot_samples);
|
||||
std::string result = GetFinalResult(recog_id);
|
||||
if (result.empty()) {
|
||||
// the TokenWriter can not write empty string.
|
||||
++num_err;
|
||||
LOG(INFO) << " the result of " << utt << " is empty";
|
||||
result = " ";
|
||||
}
|
||||
|
||||
tot_decode_time += local_timer.Elapsed();
|
||||
LOG(INFO) << utt << " " << result;
|
||||
LOG(INFO) << " RTF: " << local_timer.Elapsed() / dur << " dur: " << dur
|
||||
<< " cost: " << local_timer.Elapsed();
|
||||
|
||||
results->push_back(result);
|
||||
++num_done;
|
||||
}
|
||||
LOG(INFO) << "Done " << num_done << " out of " << (num_err + num_done);
|
||||
LOG(INFO) << "total wav duration is: " << tot_wav_duration << " sec";
|
||||
LOG(INFO) << "total decode cost:" << tot_decode_time << " sec";
|
||||
LOG(INFO) << "RTF is: " << tot_decode_time / tot_wav_duration;
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
gflags::SetUsageMessage("Usage:");
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, false);
|
||||
google::InitGoogleLogging(argv[0]);
|
||||
google::InstallFailureSignalHandler();
|
||||
FLAGS_logtostderr = 1;
|
||||
|
||||
int sample_rate = FLAGS_sample_rate;
|
||||
float streaming_chunk = FLAGS_streaming_chunk;
|
||||
int chunk_sample_size = streaming_chunk * sample_rate;
|
||||
kaldi::TokenWriter result_writer(FLAGS_result_wspecifier);
|
||||
int njob = FLAGS_njob;
|
||||
LOG(INFO) << "sr: " << sample_rate;
|
||||
LOG(INFO) << "chunk size (s): " << streaming_chunk;
|
||||
LOG(INFO) << "chunk size (sample): " << chunk_sample_size;
|
||||
|
||||
InitRecognizer(FLAGS_model_path, FLAGS_word_symbol_table, FLAGS_graph_path, njob);
|
||||
ThreadPool threadpool(njob);
|
||||
vector<vector<string>> wavlist;
|
||||
vector<vector<string>> uttlist;
|
||||
vector<vector<string>> resultlist(njob);
|
||||
vector<std::future<void>> futurelist;
|
||||
SplitUtt(FLAGS_wav_rspecifier, &uttlist, &wavlist, njob);
|
||||
for (size_t i = 0; i < njob; ++i) {
|
||||
std::future<void> f = threadpool.enqueue(recognizer_func,
|
||||
wavlist[i],
|
||||
uttlist[i],
|
||||
&resultlist[i]);
|
||||
futurelist.push_back(std::move(f));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < njob; ++i) {
|
||||
futurelist[i].get();
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < njob; ++idx) {
|
||||
for (size_t utt_idx = 0; utt_idx < uttlist[idx].size(); ++utt_idx) {
|
||||
string utt = uttlist[idx][utt_idx];
|
||||
string result = resultlist[idx][utt_idx];
|
||||
result_writer.Write(utt, result);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,70 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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 "recognizer/recognizer_controller.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
RecognizerController::RecognizerController(int num_worker, RecognizerResource resource) {
|
||||
recognizer_workers.resize(num_worker);
|
||||
for (size_t i = 0; i < num_worker; ++i) {
|
||||
recognizer_workers[i].reset(new ppspeech::RecognizerControllerImpl(resource));
|
||||
waiting_workers.push(i);
|
||||
}
|
||||
}
|
||||
|
||||
int RecognizerController::GetRecognizerInstanceId() {
|
||||
if (waiting_workers.empty()) {
|
||||
return -1;
|
||||
}
|
||||
int idx = -1;
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex_);
|
||||
idx = waiting_workers.front();
|
||||
waiting_workers.pop();
|
||||
}
|
||||
return idx;
|
||||
}
|
||||
|
||||
RecognizerController::~RecognizerController() {
|
||||
for (size_t i = 0; i < recognizer_workers.size(); ++i) {
|
||||
recognizer_workers[i]->WaitFinished();
|
||||
}
|
||||
}
|
||||
|
||||
void RecognizerController::InitDecoder(int idx) {
|
||||
recognizer_workers[idx]->InitDecoder();
|
||||
}
|
||||
|
||||
std::string RecognizerController::GetFinalResult(int idx) {
|
||||
recognizer_workers[idx]->WaitDecoderFinished();
|
||||
recognizer_workers[idx]->AttentionRescoring();
|
||||
std::string result = recognizer_workers[idx]->GetFinalResult();
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex_);
|
||||
waiting_workers.push(idx);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void RecognizerController::Accept(std::vector<float> data, int idx) {
|
||||
recognizer_workers[idx]->Accept(data);
|
||||
}
|
||||
|
||||
void RecognizerController::SetInputFinished(int idx) {
|
||||
recognizer_workers[idx]->SetInputFinished();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <queue>
|
||||
#include <memory>
|
||||
|
||||
#include "recognizer/recognizer_controller_impl.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
class RecognizerController {
|
||||
public:
|
||||
explicit RecognizerController(int num_worker, RecognizerResource resource);
|
||||
~RecognizerController();
|
||||
int GetRecognizerInstanceId();
|
||||
void InitDecoder(int idx);
|
||||
void Accept(std::vector<float> data, int idx);
|
||||
void SetInputFinished(int idx);
|
||||
std::string GetFinalResult(int idx);
|
||||
|
||||
private:
|
||||
std::queue<int> waiting_workers;
|
||||
std::mutex mutex_;
|
||||
std::vector<std::unique_ptr<ppspeech::RecognizerControllerImpl>> recognizer_workers;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(RecognizerController);
|
||||
};
|
||||
|
||||
}
|
||||
@ -0,0 +1,89 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "decoder/common.h"
|
||||
#include "fst/fstlib.h"
|
||||
#include "fst/symbol-table.h"
|
||||
#include "nnet/u2_nnet.h"
|
||||
#include "nnet/nnet_producer.h"
|
||||
#ifdef USE_ONNX
|
||||
#include "nnet/u2_onnx_nnet.h"
|
||||
#endif
|
||||
#include "nnet/decodable.h"
|
||||
#include "recognizer/recognizer_resource.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
class RecognizerControllerImpl {
|
||||
public:
|
||||
explicit RecognizerControllerImpl(const RecognizerResource& resource);
|
||||
~RecognizerControllerImpl();
|
||||
void Accept(std::vector<float> data);
|
||||
void InitDecoder();
|
||||
void SetInputFinished();
|
||||
std::string GetFinalResult();
|
||||
std::string GetPartialResult();
|
||||
void Rescoring();
|
||||
void Reset();
|
||||
void WaitDecoderFinished();
|
||||
void WaitFinished();
|
||||
void AttentionRescoring();
|
||||
bool DecodedSomething() const {
|
||||
return !result_.empty() && !result_[0].sentence.empty();
|
||||
}
|
||||
int FrameShiftInMs() const {
|
||||
return 1; //todo
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
static void RunNnetEvaluation(RecognizerControllerImpl* me);
|
||||
void RunNnetEvaluationInternal();
|
||||
static void RunDecoder(RecognizerControllerImpl* me);
|
||||
void RunDecoderInternal();
|
||||
void UpdateResult(bool finish = false);
|
||||
|
||||
std::shared_ptr<Decodable> decodable_;
|
||||
std::unique_ptr<DecoderBase> decoder_;
|
||||
std::shared_ptr<NnetProducer> nnet_producer_;
|
||||
|
||||
// e2e unit symbol table
|
||||
std::shared_ptr<fst::SymbolTable> symbol_table_ = nullptr;
|
||||
std::vector<DecodeResult> result_;
|
||||
|
||||
RecognizerResource opts_;
|
||||
bool abort_ = false;
|
||||
// global decoded frame offset
|
||||
int global_frame_offset_;
|
||||
// cur decoded frame num
|
||||
int num_frames_;
|
||||
// timestamp gap between words in a sentence
|
||||
const int time_stamp_gap_ = 100;
|
||||
bool input_finished_;
|
||||
|
||||
std::mutex nnet_mutex_;
|
||||
std::mutex decoder_mutex_;
|
||||
std::condition_variable nnet_condition_;
|
||||
std::condition_variable decoder_condition_;
|
||||
std::thread nnet_thread_;
|
||||
std::thread decoder_thread_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(RecognizerControllerImpl);
|
||||
};
|
||||
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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 "recognizer/recognizer_instance.h"
|
||||
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
RecognizerInstance& RecognizerInstance::GetInstance() {
|
||||
static RecognizerInstance instance;
|
||||
return instance;
|
||||
}
|
||||
|
||||
bool RecognizerInstance::Init(const std::string& model_file,
|
||||
const std::string& word_symbol_table_file,
|
||||
const std::string& fst_file,
|
||||
int num_instance) {
|
||||
RecognizerResource resource = RecognizerResource::InitFromFlags();
|
||||
resource.model_opts.model_path = model_file;
|
||||
//resource.vocab_path = word_symbol_table_file;
|
||||
if (!fst_file.empty()) {
|
||||
resource.decoder_opts.tlg_decoder_opts.fst_path = fst_file;
|
||||
resource.decoder_opts.tlg_decoder_opts.fst_path = word_symbol_table_file;
|
||||
} else {
|
||||
resource.decoder_opts.ctc_prefix_search_opts.word_symbol_table =
|
||||
word_symbol_table_file;
|
||||
}
|
||||
recognizer_controller_ = std::make_unique<RecognizerController>(num_instance, resource);
|
||||
return true;
|
||||
}
|
||||
|
||||
void RecognizerInstance::InitDecoder(int idx) {
|
||||
recognizer_controller_->InitDecoder(idx);
|
||||
return;
|
||||
}
|
||||
|
||||
int RecognizerInstance::GetRecognizerInstanceId() {
|
||||
return recognizer_controller_->GetRecognizerInstanceId();
|
||||
}
|
||||
|
||||
void RecognizerInstance::Accept(const std::vector<float>& waves, int idx) const {
|
||||
recognizer_controller_->Accept(waves, idx);
|
||||
return;
|
||||
}
|
||||
|
||||
void RecognizerInstance::SetInputFinished(int idx) const {
|
||||
recognizer_controller_->SetInputFinished(idx);
|
||||
return;
|
||||
}
|
||||
|
||||
std::string RecognizerInstance::GetResult(int idx) const {
|
||||
return recognizer_controller_->GetFinalResult(idx);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "base/common.h"
|
||||
#include "recognizer/recognizer_controller.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
class RecognizerInstance {
|
||||
public:
|
||||
static RecognizerInstance& GetInstance();
|
||||
RecognizerInstance() {}
|
||||
~RecognizerInstance() {}
|
||||
bool Init(const std::string& model_file,
|
||||
const std::string& word_symbol_table_file,
|
||||
const std::string& fst_file,
|
||||
int num_instance);
|
||||
int GetRecognizerInstanceId();
|
||||
void InitDecoder(int idx);
|
||||
void Accept(const std::vector<float>& waves, int idx) const;
|
||||
void SetInputFinished(int idx) const;
|
||||
std::string GetResult(int idx) const;
|
||||
|
||||
private:
|
||||
std::unique_ptr<RecognizerController> recognizer_controller_;
|
||||
};
|
||||
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1 @@
|
||||
#add_subdirectory(websocket)
|
||||
@ -0,0 +1,3 @@
|
||||
# add_definitions("-DUSE_PADDLE_INFERENCE_BACKEND")
|
||||
add_definitions("-DUSE_ORT_BACKEND")
|
||||
add_subdirectory(nnet)
|
||||
@ -0,0 +1,11 @@
|
||||
set(srcs
|
||||
panns_nnet.cc
|
||||
panns_interface.cc
|
||||
)
|
||||
|
||||
add_library(cls SHARED ${srcs})
|
||||
target_link_libraries(cls PRIVATE ${FASTDEPLOY_LIBS} kaldi-matrix kaldi-base frontend utils )
|
||||
|
||||
set(bin_name panns_nnet_main)
|
||||
add_executable(${bin_name} ${CMAKE_CURRENT_SOURCE_DIR}/${bin_name}.cc)
|
||||
target_link_libraries(${bin_name} gflags glog cls)
|
||||
@ -0,0 +1,79 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 "audio_classification/nnet/panns_interface.h"
|
||||
|
||||
#include "audio_classification/nnet/panns_nnet.h"
|
||||
#include "common/base/config.h"
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
void* ClsCreateInstance(const char* conf_path) {
|
||||
Config conf(conf_path);
|
||||
// cls init
|
||||
ppspeech::ClsNnetConf cls_nnet_conf;
|
||||
cls_nnet_conf.wav_normal_ = conf.Read("wav_normal", true);
|
||||
cls_nnet_conf.wav_normal_type_ =
|
||||
conf.Read("wav_normal_type", std::string("linear"));
|
||||
cls_nnet_conf.wav_norm_mul_factor_ = conf.Read("wav_norm_mul_factor", 1.0);
|
||||
cls_nnet_conf.model_file_path_ = conf.Read("model_path", std::string(""));
|
||||
cls_nnet_conf.param_file_path_ = conf.Read("param_path", std::string(""));
|
||||
cls_nnet_conf.dict_file_path_ = conf.Read("dict_path", std::string(""));
|
||||
cls_nnet_conf.num_cpu_thread_ = conf.Read("num_cpu_thread", 12);
|
||||
cls_nnet_conf.samp_freq = conf.Read("samp_freq", 32000);
|
||||
cls_nnet_conf.frame_length_ms = conf.Read("frame_length_ms", 32);
|
||||
cls_nnet_conf.frame_shift_ms = conf.Read("frame_shift_ms", 10);
|
||||
cls_nnet_conf.num_bins = conf.Read("num_bins", 64);
|
||||
cls_nnet_conf.low_freq = conf.Read("low_freq", 50);
|
||||
cls_nnet_conf.high_freq = conf.Read("high_freq", 14000);
|
||||
cls_nnet_conf.dither = conf.Read("dither", 0.0);
|
||||
|
||||
ppspeech::ClsNnet* cls_model = new ppspeech::ClsNnet();
|
||||
int ret = cls_model->Init(cls_nnet_conf);
|
||||
return static_cast<void*>(cls_model);
|
||||
}
|
||||
|
||||
int ClsDestroyInstance(void* instance) {
|
||||
ppspeech::ClsNnet* cls_model = static_cast<ppspeech::ClsNnet*>(instance);
|
||||
if (cls_model != NULL) {
|
||||
delete cls_model;
|
||||
cls_model = NULL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ClsFeedForward(void* instance,
|
||||
const char* wav_path,
|
||||
int topk,
|
||||
char* result,
|
||||
int result_max_len) {
|
||||
ppspeech::ClsNnet* cls_model = static_cast<ppspeech::ClsNnet*>(instance);
|
||||
if (cls_model == NULL) {
|
||||
printf("instance is null\n");
|
||||
return -1;
|
||||
}
|
||||
int ret = cls_model->Forward(wav_path, topk, result, result_max_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ClsReset(void* instance) {
|
||||
ppspeech::ClsNnet* cls_model = static_cast<ppspeech::ClsNnet*>(instance);
|
||||
if (cls_model == NULL) {
|
||||
printf("instance is null\n");
|
||||
return -1;
|
||||
}
|
||||
cls_model->Reset();
|
||||
return 0;
|
||||
}
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,27 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
void* ClsCreateInstance(const char* conf_path);
|
||||
int ClsDestroyInstance(void* instance);
|
||||
int ClsFeedForward(void* instance,
|
||||
const char* wav_path,
|
||||
int topk,
|
||||
char* result,
|
||||
int result_max_len);
|
||||
int ClsReset(void* instance);
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,227 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 "audio_classification/nnet/panns_nnet.h"
|
||||
#ifdef WITH_PROFILING
|
||||
#include "kaldi/base/timer.h"
|
||||
#endif
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
ClsNnet::ClsNnet() {
|
||||
// wav_reader_ = NULL;
|
||||
runtime_ = NULL;
|
||||
}
|
||||
|
||||
void ClsNnet::Reset() {
|
||||
// wav_reader_->Clear();
|
||||
ss_.str("");
|
||||
}
|
||||
|
||||
int ClsNnet::Init(const ClsNnetConf& conf) {
|
||||
conf_ = conf;
|
||||
// init fbank opts
|
||||
fbank_opts_.frame_opts.samp_freq = conf.samp_freq;
|
||||
fbank_opts_.frame_opts.frame_length_ms = conf.frame_length_ms;
|
||||
fbank_opts_.frame_opts.frame_shift_ms = conf.frame_shift_ms;
|
||||
fbank_opts_.mel_opts.num_bins = conf.num_bins;
|
||||
fbank_opts_.mel_opts.low_freq = conf.low_freq;
|
||||
fbank_opts_.mel_opts.high_freq = conf.high_freq;
|
||||
fbank_opts_.frame_opts.dither = conf.dither;
|
||||
fbank_opts_.use_log_fbank = false;
|
||||
|
||||
// init dict
|
||||
if (conf.dict_file_path_ != "") {
|
||||
ReadFileToVector(conf.dict_file_path_, &dict_);
|
||||
}
|
||||
|
||||
// init model
|
||||
fastdeploy::RuntimeOption runtime_option;
|
||||
|
||||
#ifdef USE_PADDLE_INFERENCE_BACKEND
|
||||
runtime_option.SetModelPath(conf.model_file_path_,
|
||||
conf.param_file_path_,
|
||||
fastdeploy::ModelFormat::PADDLE);
|
||||
runtime_option.UsePaddleInferBackend();
|
||||
#elif defined(USE_ORT_BACKEND)
|
||||
runtime_option.SetModelPath(
|
||||
conf.model_file_path_, "", fastdeploy::ModelFormat::ONNX); // onnx
|
||||
runtime_option.UseOrtBackend(); // onnx
|
||||
#elif defined(USE_PADDLE_LITE_BACKEND)
|
||||
runtime_option.SetModelPath(conf.model_file_path_,
|
||||
conf.param_file_path_,
|
||||
fastdeploy::ModelFormat::PADDLE);
|
||||
runtime_option.UseLiteBackend();
|
||||
#endif
|
||||
|
||||
runtime_option.SetCpuThreadNum(conf.num_cpu_thread_);
|
||||
// runtime_option.DeletePaddleBackendPass("simplify_with_basic_ops_pass");
|
||||
runtime_ = std::unique_ptr<fastdeploy::Runtime>(new fastdeploy::Runtime());
|
||||
if (!runtime_->Init(runtime_option)) {
|
||||
std::cerr << "--- Init FastDeploy Runitme Failed! "
|
||||
<< "\n--- Model: " << conf.model_file_path_ << std::endl;
|
||||
return -1;
|
||||
} else {
|
||||
std::cout << "--- Init FastDeploy Runitme Done! "
|
||||
<< "\n--- Model: " << conf.model_file_path_ << std::endl;
|
||||
}
|
||||
|
||||
Reset();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ClsNnet::Forward(const char* wav_path,
|
||||
int topk,
|
||||
char* result,
|
||||
int result_max_len) {
|
||||
#ifdef WITH_PROFILING
|
||||
kaldi::Timer timer;
|
||||
timer.Reset();
|
||||
#endif
|
||||
// read wav
|
||||
std::ifstream infile(wav_path, std::ifstream::in);
|
||||
kaldi::WaveData wave_data;
|
||||
wave_data.Read(infile);
|
||||
int32 this_channel = 0;
|
||||
kaldi::Matrix<float> wavform_kaldi = wave_data.Data();
|
||||
// only get channel 0
|
||||
int wavform_len = wavform_kaldi.NumCols();
|
||||
std::vector<float> wavform(wavform_kaldi.Data(),
|
||||
wavform_kaldi.Data() + wavform_len);
|
||||
WaveformFloatNormal(&wavform);
|
||||
WaveformNormal(&wavform,
|
||||
conf_.wav_normal_,
|
||||
conf_.wav_normal_type_,
|
||||
conf_.wav_norm_mul_factor_);
|
||||
#ifdef PPS_DEBUG
|
||||
{
|
||||
std::ofstream fp("cls.wavform", std::ios::out);
|
||||
for (int i = 0; i < wavform.size(); ++i) {
|
||||
fp << std::setprecision(18) << wavform[i] << " ";
|
||||
}
|
||||
fp << "\n";
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_PROFILING
|
||||
printf("wav read consume: %fs\n", timer.Elapsed());
|
||||
#endif
|
||||
|
||||
#ifdef WITH_PROFILING
|
||||
timer.Reset();
|
||||
#endif
|
||||
|
||||
std::vector<float> feats;
|
||||
std::unique_ptr<ppspeech::FrontendInterface> data_source(
|
||||
new ppspeech::DataCache());
|
||||
ppspeech::Fbank fbank(fbank_opts_, std::move(data_source));
|
||||
fbank.Accept(wavform);
|
||||
fbank.SetFinished();
|
||||
fbank.Read(&feats);
|
||||
|
||||
int feat_dim = fbank_opts_.mel_opts.num_bins;
|
||||
int num_frames = feats.size() / feat_dim;
|
||||
|
||||
for (int i = 0; i < num_frames; ++i) {
|
||||
for (int j = 0; j < feat_dim; ++j) {
|
||||
feats[i * feat_dim + j] = PowerTodb(feats[i * feat_dim + j]);
|
||||
}
|
||||
}
|
||||
#ifdef PPS_DEBUG
|
||||
{
|
||||
std::ofstream fp("cls.feat", std::ios::out);
|
||||
for (int i = 0; i < num_frames; ++i) {
|
||||
for (int j = 0; j < feat_dim; ++j) {
|
||||
fp << std::setprecision(18) << feats[i * feat_dim + j] << " ";
|
||||
}
|
||||
fp << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_PROFILING
|
||||
printf("extract fbank consume: %fs\n", timer.Elapsed());
|
||||
#endif
|
||||
|
||||
// infer
|
||||
std::vector<float> model_out;
|
||||
#ifdef WITH_PROFILING
|
||||
timer.Reset();
|
||||
#endif
|
||||
ModelForward(feats.data(), num_frames, feat_dim, &model_out);
|
||||
#ifdef WITH_PROFILING
|
||||
printf("fast deploy infer consume: %fs\n", timer.Elapsed());
|
||||
#endif
|
||||
#ifdef PPS_DEBUG
|
||||
{
|
||||
std::ofstream fp("cls.logits", std::ios::out);
|
||||
for (int i = 0; i < model_out.size(); ++i) {
|
||||
fp << std::setprecision(18) << model_out[i] << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// construct result str
|
||||
ss_ << "{";
|
||||
GetTopkResult(topk, model_out);
|
||||
ss_ << "}";
|
||||
|
||||
if (result_max_len <= ss_.str().size()) {
|
||||
printf("result_max_len is short than result len\n");
|
||||
}
|
||||
snprintf(result, result_max_len, "%s", ss_.str().c_str());
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ClsNnet::ModelForward(float* features,
|
||||
const int num_frames,
|
||||
const int feat_dim,
|
||||
std::vector<float>* model_out) {
|
||||
// init input tensor shape
|
||||
fastdeploy::TensorInfo info = runtime_->GetInputInfo(0);
|
||||
info.shape = {1, num_frames, feat_dim};
|
||||
|
||||
std::vector<fastdeploy::FDTensor> input_tensors(1);
|
||||
std::vector<fastdeploy::FDTensor> output_tensors(1);
|
||||
|
||||
input_tensors[0].SetExternalData({1, num_frames, feat_dim},
|
||||
fastdeploy::FDDataType::FP32,
|
||||
static_cast<void*>(features));
|
||||
|
||||
// get input name
|
||||
input_tensors[0].name = info.name;
|
||||
|
||||
runtime_->Infer(input_tensors, &output_tensors);
|
||||
|
||||
// output_tensors[0].PrintInfo();
|
||||
std::vector<int64_t> output_shape = output_tensors[0].Shape();
|
||||
model_out->resize(output_shape[0] * output_shape[1]);
|
||||
memcpy(static_cast<void*>(model_out->data()),
|
||||
output_tensors[0].Data(),
|
||||
output_shape[0] * output_shape[1] * sizeof(float));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ClsNnet::GetTopkResult(int k, const std::vector<float>& model_out) {
|
||||
std::vector<float> values;
|
||||
std::vector<int> indics;
|
||||
TopK(model_out, k, &values, &indics);
|
||||
for (int i = 0; i < k; ++i) {
|
||||
if (i != 0) {
|
||||
ss_ << ",";
|
||||
}
|
||||
ss_ << "\"" << dict_[indics[i]] << "\":\"" << values[i] << "\"";
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,74 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "common/frontend/data_cache.h"
|
||||
#include "common/frontend/fbank.h"
|
||||
#include "common/frontend/feature-fbank.h"
|
||||
#include "common/frontend/frontend_itf.h"
|
||||
#include "common/frontend/wave-reader.h"
|
||||
#include "common/utils/audio_process.h"
|
||||
#include "common/utils/file_utils.h"
|
||||
#include "fastdeploy/runtime.h"
|
||||
#include "kaldi/util/kaldi-io.h"
|
||||
#include "kaldi/util/table-types.h"
|
||||
|
||||
namespace ppspeech {
|
||||
struct ClsNnetConf {
|
||||
// wav
|
||||
bool wav_normal_;
|
||||
std::string wav_normal_type_;
|
||||
float wav_norm_mul_factor_;
|
||||
// model
|
||||
std::string model_file_path_;
|
||||
std::string param_file_path_;
|
||||
std::string dict_file_path_;
|
||||
int num_cpu_thread_;
|
||||
// fbank
|
||||
float samp_freq;
|
||||
float frame_length_ms;
|
||||
float frame_shift_ms;
|
||||
int num_bins;
|
||||
float low_freq;
|
||||
float high_freq;
|
||||
float dither;
|
||||
};
|
||||
|
||||
class ClsNnet {
|
||||
public:
|
||||
ClsNnet();
|
||||
int Init(const ClsNnetConf& conf);
|
||||
int Forward(const char* wav_path,
|
||||
int topk,
|
||||
char* result,
|
||||
int result_max_len);
|
||||
void Reset();
|
||||
|
||||
private:
|
||||
int ModelForward(float* features,
|
||||
const int num_frames,
|
||||
const int feat_dim,
|
||||
std::vector<float>* model_out);
|
||||
int ModelForwardStream(std::vector<float>* feats);
|
||||
int GetTopkResult(int k, const std::vector<float>& model_out);
|
||||
|
||||
ClsNnetConf conf_;
|
||||
knf::FbankOptions fbank_opts_;
|
||||
std::unique_ptr<fastdeploy::Runtime> runtime_;
|
||||
std::vector<std::string> dict_;
|
||||
std::stringstream ss_;
|
||||
};
|
||||
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,51 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. 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 <fstream>
|
||||
#include <string>
|
||||
|
||||
#include "gflags/gflags.h"
|
||||
#include "glog/logging.h"
|
||||
#include "audio_classification/nnet/panns_interface.h"
|
||||
|
||||
DEFINE_string(conf_path, "", "config path");
|
||||
DEFINE_string(scp_path, "", "wav scp path");
|
||||
DEFINE_string(topk, "", "print topk results");
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
gflags::SetUsageMessage("Usage:");
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, false);
|
||||
google::InitGoogleLogging(argv[0]);
|
||||
google::InstallFailureSignalHandler();
|
||||
FLAGS_logtostderr = 1;
|
||||
CHECK_GT(FLAGS_conf_path.size(), 0);
|
||||
CHECK_GT(FLAGS_scp_path.size(), 0);
|
||||
CHECK_GT(FLAGS_topk.size(), 0);
|
||||
void* instance = ppspeech::ClsCreateInstance(FLAGS_conf_path.c_str());
|
||||
int ret = 0;
|
||||
// read wav
|
||||
std::ifstream ifs(FLAGS_scp_path);
|
||||
std::string line = "";
|
||||
int topk = std::atoi(FLAGS_topk.c_str());
|
||||
while (getline(ifs, line)) {
|
||||
// read wav
|
||||
char result[1024] = {0};
|
||||
ret = ppspeech::ClsFeedForward(
|
||||
instance, line.c_str(), topk, result, 1024);
|
||||
printf("%s %s\n", line.c_str(), result);
|
||||
ret = ppspeech::ClsReset(instance);
|
||||
}
|
||||
ret = ppspeech::ClsDestroyInstance(instance);
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
|
||||
|
||||
if(ANDROID)
|
||||
else() #Unix
|
||||
add_subdirectory(glog)
|
||||
endif()
|
||||
@ -1,8 +1,8 @@
|
||||
cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
|
||||
|
||||
add_executable(glog_main ${CMAKE_CURRENT_SOURCE_DIR}/glog_main.cc)
|
||||
target_link_libraries(glog_main glog)
|
||||
target_link_libraries(glog_main extern_glog)
|
||||
|
||||
|
||||
add_executable(glog_logtostderr_main ${CMAKE_CURRENT_SOURCE_DIR}/glog_logtostderr_main.cc)
|
||||
target_link_libraries(glog_logtostderr_main glog)
|
||||
target_link_libraries(glog_logtostderr_main extern_glog)
|
||||
@ -0,0 +1,19 @@
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../
|
||||
)
|
||||
add_subdirectory(base)
|
||||
add_subdirectory(utils)
|
||||
add_subdirectory(matrix)
|
||||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/frontend
|
||||
)
|
||||
add_subdirectory(frontend)
|
||||
|
||||
add_library(common INTERFACE)
|
||||
target_link_libraries(common INTERFACE base utils kaldi-matrix frontend)
|
||||
install(TARGETS base DESTINATION lib)
|
||||
install(TARGETS utils DESTINATION lib)
|
||||
install(TARGETS kaldi-matrix DESTINATION lib)
|
||||
install(TARGETS frontend DESTINATION lib)
|
||||
@ -0,0 +1,43 @@
|
||||
|
||||
|
||||
if(WITH_ASR)
|
||||
add_compile_options(-DWITH_ASR)
|
||||
set(PPS_FLAGS_LIB "fst/flags.h")
|
||||
else()
|
||||
set(PPS_FLAGS_LIB "gflags/gflags.h")
|
||||
endif()
|
||||
|
||||
if(ANDROID)
|
||||
set(PPS_GLOG_LIB "base/log_impl.h")
|
||||
else() #UNIX
|
||||
if(WITH_ASR)
|
||||
set(PPS_GLOG_LIB "fst/log.h")
|
||||
else()
|
||||
set(PPS_GLOG_LIB "glog/logging.h")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
configure_file(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/flags.h.in
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/flags.h @ONLY
|
||||
)
|
||||
message(STATUS "Generated ${CMAKE_CURRENT_SOURCE_DIR}/flags.h")
|
||||
|
||||
configure_file(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/log.h.in
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/log.h @ONLY
|
||||
)
|
||||
message(STATUS "Generated ${CMAKE_CURRENT_SOURCE_DIR}/log.h")
|
||||
|
||||
|
||||
if(ANDROID)
|
||||
set(csrc
|
||||
log_impl.cc
|
||||
glog_utils.cc
|
||||
)
|
||||
add_library(base ${csrc})
|
||||
target_link_libraries(base gflags)
|
||||
else() # UNIX
|
||||
set(csrc)
|
||||
add_library(base INTERFACE)
|
||||
endif()
|
||||
@ -0,0 +1,343 @@
|
||||
// Copyright (c) code is from
|
||||
// https://blog.csdn.net/huixingshao/article/details/45969887.
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
using namespace std;
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma region ParseIniFile
|
||||
#endif
|
||||
|
||||
/*
|
||||
* \brief Generic configuration Class
|
||||
*
|
||||
*/
|
||||
class Config {
|
||||
// Data
|
||||
protected:
|
||||
std::string m_Delimiter; //!< separator between key and value
|
||||
std::string m_Comment; //!< separator between value and comments
|
||||
std::map<std::string, std::string>
|
||||
m_Contents; //!< extracted keys and values
|
||||
|
||||
typedef std::map<std::string, std::string>::iterator mapi;
|
||||
typedef std::map<std::string, std::string>::const_iterator mapci;
|
||||
// Methods
|
||||
public:
|
||||
Config(std::string filename,
|
||||
std::string delimiter = "=",
|
||||
std::string comment = "#");
|
||||
Config();
|
||||
template <class T>
|
||||
T Read(const std::string& in_key) const; //!< Search for key and read value
|
||||
//! or optional default value, call
|
||||
//! as read<T>
|
||||
template <class T>
|
||||
T Read(const std::string& in_key, const T& in_value) const;
|
||||
template <class T>
|
||||
bool ReadInto(T* out_var, const std::string& in_key) const;
|
||||
template <class T>
|
||||
bool ReadInto(T* out_var,
|
||||
const std::string& in_key,
|
||||
const T& in_value) const;
|
||||
bool FileExist(std::string filename);
|
||||
void ReadFile(std::string filename,
|
||||
std::string delimiter = "=",
|
||||
std::string comment = "#");
|
||||
|
||||
// Check whether key exists in configuration
|
||||
bool KeyExists(const std::string& in_key) const;
|
||||
|
||||
// Modify keys and values
|
||||
template <class T>
|
||||
void Add(const std::string& in_key, const T& in_value);
|
||||
void Remove(const std::string& in_key);
|
||||
|
||||
// Check or change configuration syntax
|
||||
std::string GetDelimiter() const { return m_Delimiter; }
|
||||
std::string GetComment() const { return m_Comment; }
|
||||
std::string SetDelimiter(const std::string& in_s) {
|
||||
std::string old = m_Delimiter;
|
||||
m_Delimiter = in_s;
|
||||
return old;
|
||||
}
|
||||
std::string SetComment(const std::string& in_s) {
|
||||
std::string old = m_Comment;
|
||||
m_Comment = in_s;
|
||||
return old;
|
||||
}
|
||||
|
||||
// Write or read configuration
|
||||
friend std::ostream& operator<<(std::ostream& os, const Config& cf);
|
||||
friend std::istream& operator>>(std::istream& is, Config& cf);
|
||||
|
||||
protected:
|
||||
template <class T>
|
||||
static std::string T_as_string(const T& t);
|
||||
template <class T>
|
||||
static T string_as_T(const std::string& s);
|
||||
static void Trim(std::string* inout_s);
|
||||
|
||||
|
||||
// Exception types
|
||||
public:
|
||||
struct File_not_found {
|
||||
std::string filename;
|
||||
explicit File_not_found(const std::string& filename_ = std::string())
|
||||
: filename(filename_) {}
|
||||
};
|
||||
struct Key_not_found { // thrown only by T read(key) variant of read()
|
||||
std::string key;
|
||||
explicit Key_not_found(const std::string& key_ = std::string())
|
||||
: key(key_) {}
|
||||
};
|
||||
};
|
||||
|
||||
/* static */
|
||||
template <class T>
|
||||
std::string Config::T_as_string(const T& t) {
|
||||
// Convert from a T to a string
|
||||
// Type T must support << operator
|
||||
std::ostringstream ost;
|
||||
ost << t;
|
||||
return ost.str();
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
template <class T>
|
||||
T Config::string_as_T(const std::string& s) {
|
||||
// Convert from a string to a T
|
||||
// Type T must support >> operator
|
||||
T t;
|
||||
std::istringstream ist(s);
|
||||
ist >> t;
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
template <>
|
||||
inline std::string Config::string_as_T<std::string>(const std::string& s) {
|
||||
// Convert from a string to a string
|
||||
// In other words, do nothing
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
template <>
|
||||
inline bool Config::string_as_T<bool>(const std::string& s) {
|
||||
// Convert from a string to a bool
|
||||
// Interpret "false", "F", "no", "n", "0" as false
|
||||
// Interpret "true", "T", "yes", "y", "1", "-1", or anything else as true
|
||||
bool b = true;
|
||||
std::string sup = s;
|
||||
for (std::string::iterator p = sup.begin(); p != sup.end(); ++p)
|
||||
*p = toupper(*p); // make string all caps
|
||||
if (sup == std::string("FALSE") || sup == std::string("F") ||
|
||||
sup == std::string("NO") || sup == std::string("N") ||
|
||||
sup == std::string("0") || sup == std::string("NONE"))
|
||||
b = false;
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
T Config::Read(const std::string& key) const {
|
||||
// Read the value corresponding to key
|
||||
mapci p = m_Contents.find(key);
|
||||
if (p == m_Contents.end()) throw Key_not_found(key);
|
||||
return string_as_T<T>(p->second);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
T Config::Read(const std::string& key, const T& value) const {
|
||||
// Return the value corresponding to key or given default value
|
||||
// if key is not found
|
||||
mapci p = m_Contents.find(key);
|
||||
if (p == m_Contents.end()) {
|
||||
printf("%s = %s(default)\n", key.c_str(), T_as_string(value).c_str());
|
||||
return value;
|
||||
} else {
|
||||
printf("%s = %s\n", key.c_str(), T_as_string(p->second).c_str());
|
||||
return string_as_T<T>(p->second);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool Config::ReadInto(T* var, const std::string& key) const {
|
||||
// Get the value corresponding to key and store in var
|
||||
// Return true if key is found
|
||||
// Otherwise leave var untouched
|
||||
mapci p = m_Contents.find(key);
|
||||
bool found = (p != m_Contents.end());
|
||||
if (found) *var = string_as_T<T>(p->second);
|
||||
return found;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool Config::ReadInto(T* var, const std::string& key, const T& value) const {
|
||||
// Get the value corresponding to key and store in var
|
||||
// Return true if key is found
|
||||
// Otherwise set var to given default
|
||||
mapci p = m_Contents.find(key);
|
||||
bool found = (p != m_Contents.end());
|
||||
if (found)
|
||||
*var = string_as_T<T>(p->second);
|
||||
else
|
||||
var = value;
|
||||
return found;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
void Config::Add(const std::string& in_key, const T& value) {
|
||||
// Add a key with given value
|
||||
std::string v = T_as_string(value);
|
||||
std::string key = in_key;
|
||||
Trim(&key);
|
||||
Trim(&v);
|
||||
m_Contents[key] = v;
|
||||
return;
|
||||
}
|
||||
|
||||
Config::Config(string filename, string delimiter, string comment)
|
||||
: m_Delimiter(delimiter), m_Comment(comment) {
|
||||
// Construct a Config, getting keys and values from given file
|
||||
|
||||
std::ifstream in(filename.c_str());
|
||||
|
||||
if (!in) throw File_not_found(filename);
|
||||
|
||||
in >> (*this);
|
||||
}
|
||||
|
||||
|
||||
Config::Config() : m_Delimiter(string(1, '=')), m_Comment(string(1, '#')) {
|
||||
// Construct a Config without a file; empty
|
||||
}
|
||||
|
||||
|
||||
bool Config::KeyExists(const string& key) const {
|
||||
// Indicate whether key is found
|
||||
mapci p = m_Contents.find(key);
|
||||
return (p != m_Contents.end());
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
void Config::Trim(string* inout_s) {
|
||||
// Remove leading and trailing whitespace
|
||||
static const char whitespace[] = " \n\t\v\r\f";
|
||||
inout_s->erase(0, inout_s->find_first_not_of(whitespace));
|
||||
inout_s->erase(inout_s->find_last_not_of(whitespace) + 1U);
|
||||
}
|
||||
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const Config& cf) {
|
||||
// Save a Config to os
|
||||
for (Config::mapci p = cf.m_Contents.begin(); p != cf.m_Contents.end();
|
||||
++p) {
|
||||
os << p->first << " " << cf.m_Delimiter << " ";
|
||||
os << p->second << std::endl;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
void Config::Remove(const string& key) {
|
||||
// Remove key and its value
|
||||
m_Contents.erase(m_Contents.find(key));
|
||||
return;
|
||||
}
|
||||
|
||||
std::istream& operator>>(std::istream& is, Config& cf) {
|
||||
// Load a Config from is
|
||||
// Read in keys and values, keeping internal whitespace
|
||||
typedef string::size_type pos;
|
||||
const string& delim = cf.m_Delimiter; // separator
|
||||
const string& comm = cf.m_Comment; // comment
|
||||
const pos skip = delim.length(); // length of separator
|
||||
|
||||
string nextline = ""; // might need to read ahead to see where value ends
|
||||
|
||||
while (is || nextline.length() > 0) {
|
||||
// Read an entire line at a time
|
||||
string line;
|
||||
if (nextline.length() > 0) {
|
||||
line = nextline; // we read ahead; use it now
|
||||
nextline = "";
|
||||
} else {
|
||||
std::getline(is, line);
|
||||
}
|
||||
|
||||
// Ignore comments
|
||||
line = line.substr(0, line.find(comm));
|
||||
|
||||
// Parse the line if it contains a delimiter
|
||||
pos delimPos = line.find(delim);
|
||||
if (delimPos < string::npos) {
|
||||
// Extract the key
|
||||
string key = line.substr(0, delimPos);
|
||||
line.replace(0, delimPos + skip, "");
|
||||
|
||||
// See if value continues on the next line
|
||||
// Stop at blank line, next line with a key, end of stream,
|
||||
// or end of file sentry
|
||||
bool terminate = false;
|
||||
while (!terminate && is) {
|
||||
std::getline(is, nextline);
|
||||
terminate = true;
|
||||
|
||||
string nlcopy = nextline;
|
||||
Config::Trim(&nlcopy);
|
||||
if (nlcopy == "") continue;
|
||||
|
||||
nextline = nextline.substr(0, nextline.find(comm));
|
||||
if (nextline.find(delim) != string::npos) continue;
|
||||
|
||||
nlcopy = nextline;
|
||||
Config::Trim(&nlcopy);
|
||||
if (nlcopy != "") line += "\n";
|
||||
line += nextline;
|
||||
terminate = false;
|
||||
}
|
||||
|
||||
// Store key and value
|
||||
Config::Trim(&key);
|
||||
Config::Trim(&line);
|
||||
cf.m_Contents[key] = line; // overwrites if key is repeated
|
||||
}
|
||||
}
|
||||
|
||||
return is;
|
||||
}
|
||||
bool Config::FileExist(std::string filename) {
|
||||
bool exist = false;
|
||||
std::ifstream in(filename.c_str());
|
||||
if (in) exist = true;
|
||||
return exist;
|
||||
}
|
||||
|
||||
void Config::ReadFile(string filename, string delimiter, string comment) {
|
||||
m_Delimiter = delimiter;
|
||||
m_Comment = comment;
|
||||
std::ifstream in(filename.c_str());
|
||||
|
||||
if (!in) throw File_not_found(filename);
|
||||
|
||||
in >> (*this);
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma endregion ParseIniFIle
|
||||
#endif
|
||||
@ -0,0 +1,12 @@
|
||||
|
||||
#include "base/glog_utils.h"
|
||||
|
||||
namespace google {
|
||||
void InitGoogleLogging(const char* name) {
|
||||
LOG(INFO) << "dummpy InitGoogleLogging.";
|
||||
}
|
||||
|
||||
void InstallFailureSignalHandler() {
|
||||
LOG(INFO) << "dummpy InstallFailureSignalHandler.";
|
||||
}
|
||||
} // namespace google
|
||||
@ -0,0 +1,9 @@
|
||||
#pragma once
|
||||
|
||||
#include "base/common.h"
|
||||
|
||||
namespace google {
|
||||
void InitGoogleLogging(const char* name);
|
||||
|
||||
void InstallFailureSignalHandler();
|
||||
} // namespace google
|
||||
@ -0,0 +1,105 @@
|
||||
#include "base/log.h"
|
||||
|
||||
DEFINE_int32(logtostderr, 0, "logging to stderr");
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
static char __progname[] = "paddlespeech";
|
||||
|
||||
namespace log {
|
||||
|
||||
std::mutex LogMessage::lock_;
|
||||
std::string LogMessage::s_debug_logfile_("");
|
||||
std::string LogMessage::s_info_logfile_("");
|
||||
std::string LogMessage::s_warning_logfile_("");
|
||||
std::string LogMessage::s_error_logfile_("");
|
||||
std::string LogMessage::s_fatal_logfile_("");
|
||||
|
||||
void LogMessage::get_curr_proc_info(std::string* pid, std::string* proc_name) {
|
||||
std::stringstream ss;
|
||||
ss << getpid();
|
||||
ss >> *pid;
|
||||
*proc_name = ::ppspeech::__progname;
|
||||
}
|
||||
|
||||
LogMessage::LogMessage(const char* file,
|
||||
int line,
|
||||
Severity level,
|
||||
bool verbose,
|
||||
bool out_to_file /* = false */)
|
||||
: level_(level), verbose_(verbose), out_to_file_(out_to_file) {
|
||||
if (FLAGS_logtostderr == 0) {
|
||||
stream_ = static_cast<std::ostream*>(&std::cout);
|
||||
} else if (FLAGS_logtostderr == 1) {
|
||||
stream_ = static_cast<std::ostream*>(&std::cerr);
|
||||
} else if (out_to_file_) {
|
||||
// logfile
|
||||
lock_.lock();
|
||||
init(file, line);
|
||||
}
|
||||
}
|
||||
|
||||
LogMessage::~LogMessage() {
|
||||
stream() << std::endl;
|
||||
|
||||
if (out_to_file_) {
|
||||
lock_.unlock();
|
||||
}
|
||||
|
||||
if (verbose_ && level_ == FATAL) {
|
||||
std::abort();
|
||||
}
|
||||
}
|
||||
|
||||
std::ostream* LogMessage::nullstream() {
|
||||
thread_local static std::ofstream os;
|
||||
thread_local static bool flag_set = false;
|
||||
if (!flag_set) {
|
||||
os.setstate(std::ios_base::badbit);
|
||||
flag_set = true;
|
||||
}
|
||||
return &os;
|
||||
}
|
||||
|
||||
void LogMessage::init(const char* file, int line) {
|
||||
time_t t = time(0);
|
||||
char tmp[100];
|
||||
strftime(tmp, sizeof(tmp), "%Y%m%d-%H%M%S", localtime(&t));
|
||||
|
||||
if (s_info_logfile_.empty()) {
|
||||
std::string pid;
|
||||
std::string proc_name;
|
||||
get_curr_proc_info(&pid, &proc_name);
|
||||
|
||||
s_debug_logfile_ =
|
||||
std::string("log." + proc_name + ".log.DEBUG." + tmp + "." + pid);
|
||||
s_info_logfile_ =
|
||||
std::string("log." + proc_name + ".log.INFO." + tmp + "." + pid);
|
||||
s_warning_logfile_ =
|
||||
std::string("log." + proc_name + ".log.WARNING." + tmp + "." + pid);
|
||||
s_error_logfile_ =
|
||||
std::string("log." + proc_name + ".log.ERROR." + tmp + "." + pid);
|
||||
s_fatal_logfile_ =
|
||||
std::string("log." + proc_name + ".log.FATAL." + tmp + "." + pid);
|
||||
}
|
||||
|
||||
thread_local static std::ofstream ofs;
|
||||
if (level_ == DEBUG) {
|
||||
ofs.open(s_debug_logfile_.c_str(), std::ios::out | std::ios::app);
|
||||
} else if (level_ == INFO) {
|
||||
ofs.open(s_info_logfile_.c_str(), std::ios::out | std::ios::app);
|
||||
} else if (level_ == WARNING) {
|
||||
ofs.open(s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
|
||||
} else if (level_ == ERROR) {
|
||||
ofs.open(s_error_logfile_.c_str(), std::ios::out | std::ios::app);
|
||||
} else {
|
||||
ofs.open(s_fatal_logfile_.c_str(), std::ios::out | std::ios::app);
|
||||
}
|
||||
|
||||
stream_ = &ofs;
|
||||
|
||||
stream() << tmp << " " << file << " line " << line << "; ";
|
||||
stream() << std::flush;
|
||||
}
|
||||
} // namespace log
|
||||
} // namespace ppspeech
|
||||
@ -0,0 +1,173 @@
|
||||
// Copyright (c) 2023 PaddlePaddle Authors. 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.
|
||||
|
||||
// modified from https://github.com/Dounm/dlog
|
||||
// modified form
|
||||
// https://android.googlesource.com/platform/art/+/806defa/src/logging.h
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <mutex>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
#include "base/common.h"
|
||||
#include "base/macros.h"
|
||||
#ifndef WITH_GLOG
|
||||
#include "base/glog_utils.h"
|
||||
#endif
|
||||
|
||||
DECLARE_int32(logtostderr);
|
||||
|
||||
namespace ppspeech {
|
||||
|
||||
namespace log {
|
||||
|
||||
enum Severity {
|
||||
DEBUG,
|
||||
INFO,
|
||||
WARNING,
|
||||
ERROR,
|
||||
FATAL,
|
||||
NUM_SEVERITIES,
|
||||
};
|
||||
|
||||
class LogMessage {
|
||||
public:
|
||||
static void get_curr_proc_info(std::string* pid, std::string* proc_name);
|
||||
|
||||
LogMessage(const char* file,
|
||||
int line,
|
||||
Severity level,
|
||||
bool verbose,
|
||||
bool out_to_file = false);
|
||||
|
||||
~LogMessage();
|
||||
|
||||
std::ostream& stream() { return verbose_ ? *stream_ : *nullstream(); }
|
||||
|
||||
private:
|
||||
void init(const char* file, int line);
|
||||
std::ostream* nullstream();
|
||||
|
||||
private:
|
||||
std::ostream* stream_;
|
||||
std::ostream* null_stream_;
|
||||
Severity level_;
|
||||
bool verbose_;
|
||||
bool out_to_file_;
|
||||
|
||||
static std::mutex lock_; // stream write lock
|
||||
static std::string s_debug_logfile_;
|
||||
static std::string s_info_logfile_;
|
||||
static std::string s_warning_logfile_;
|
||||
static std::string s_error_logfile_;
|
||||
static std::string s_fatal_logfile_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(LogMessage);
|
||||
};
|
||||
|
||||
|
||||
} // namespace log
|
||||
|
||||
} // namespace ppspeech
|
||||
|
||||
|
||||
#ifndef PPS_DEBUG
|
||||
#define DLOG_INFO \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::INFO, false)
|
||||
#define DLOG_WARNING \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::WARNING, false)
|
||||
#define DLOG_ERROR \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::ERROR, false)
|
||||
#define DLOG_FATAL \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::FATAL, false)
|
||||
#else
|
||||
#define DLOG_INFO \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::INFO, true)
|
||||
#define DLOG_WARNING \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::WARNING, true)
|
||||
#define DLOG_ERROR \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::ERROR, true)
|
||||
#define DLOG_FATAL \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::FATAL, true)
|
||||
#endif
|
||||
|
||||
|
||||
#define LOG_INFO \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::INFO, true)
|
||||
#define LOG_WARNING \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::WARNING, true)
|
||||
#define LOG_ERROR \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::ERROR, true)
|
||||
#define LOG_FATAL \
|
||||
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::FATAL, true)
|
||||
|
||||
|
||||
#define LOG_0 LOG_DEBUG
|
||||
#define LOG_1 LOG_INFO
|
||||
#define LOG_2 LOG_WARNING
|
||||
#define LOG_3 LOG_ERROR
|
||||
#define LOG_4 LOG_FATAL
|
||||
|
||||
#define LOG(level) LOG_##level.stream()
|
||||
|
||||
#define DLOG(level) DLOG_##level.stream()
|
||||
|
||||
#define VLOG(verboselevel) LOG(verboselevel)
|
||||
|
||||
#define CHECK(exp) \
|
||||
ppspeech::log::LogMessage( \
|
||||
__FILE__, __LINE__, ppspeech::log::FATAL, !(exp)) \
|
||||
.stream() \
|
||||
<< "Check Failed: " #exp
|
||||
|
||||
#define CHECK_EQ(x, y) CHECK((x) == (y))
|
||||
#define CHECK_NE(x, y) CHECK((x) != (y))
|
||||
#define CHECK_LE(x, y) CHECK((x) <= (y))
|
||||
#define CHECK_LT(x, y) CHECK((x) < (y))
|
||||
#define CHECK_GE(x, y) CHECK((x) >= (y))
|
||||
#define CHECK_GT(x, y) CHECK((x) > (y))
|
||||
#ifdef PPS_DEBUG
|
||||
#define DCHECK(x) CHECK(x)
|
||||
#define DCHECK_EQ(x, y) CHECK_EQ(x, y)
|
||||
#define DCHECK_NE(x, y) CHECK_NE(x, y)
|
||||
#define DCHECK_LE(x, y) CHECK_LE(x, y)
|
||||
#define DCHECK_LT(x, y) CHECK_LT(x, y)
|
||||
#define DCHECK_GE(x, y) CHECK_GE(x, y)
|
||||
#define DCHECK_GT(x, y) CHECK_GT(x, y)
|
||||
#else
|
||||
#define DCHECK(condition) \
|
||||
while (false) CHECK(condition)
|
||||
#define DCHECK_EQ(val1, val2) \
|
||||
while (false) CHECK_EQ(val1, val2)
|
||||
#define DCHECK_NE(val1, val2) \
|
||||
while (false) CHECK_NE(val1, val2)
|
||||
#define DCHECK_LE(val1, val2) \
|
||||
while (false) CHECK_LE(val1, val2)
|
||||
#define DCHECK_LT(val1, val2) \
|
||||
while (false) CHECK_LT(val1, val2)
|
||||
#define DCHECK_GE(val1, val2) \
|
||||
while (false) CHECK_GE(val1, val2)
|
||||
#define DCHECK_GT(val1, val2) \
|
||||
while (false) CHECK_GT(val1, val2)
|
||||
#define DCHECK_STREQ(str1, str2) \
|
||||
while (false) CHECK_STREQ(str1, str2)
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue