El artículo anterior presentó el proceso de implementación relevante del proceso de implementación del modelo PyTorch (Onnx Runtime) , y luego lo revisó brevemente ~

Introducción a la implementación del modelo de aprendizaje profundo

La implementación del modelo se refiere al proceso de hacer que un modelo de aprendizaje profundo entrenado se ejecute en un entorno específico. Dificultades que enfrenta el despliegue del modelo:

El entorno requerido para ejecutar el modelo es difícil de configurar. Los modelos de aprendizaje profundo generalmente están escritos por algunos marcos, como PyTorch y TensorFlow. Debido a las limitaciones del tamaño del marco y del entorno dependiente, el marco no es adecuado para la instalación en entornos de producción, como teléfonos móviles y placas de desarrollo.

La estructura del modelo de aprendizaje profundo suele ser relativamente grande y requiere mucha potencia informática para satisfacer las necesidades de la operación en tiempo real. Es necesario optimizar la eficiencia operativa.

Debido a estas dificultades, la implementación del modelo no se puede lograr mediante una configuración e instalación sencillas del entorno. Actualmente existe una canalización popular para la implementación de modelos:

Para que el modelo se implemente finalmente en un entorno determinado, se puede usar cualquier marco de aprendizaje profundo para definir la estructura de la red, y los parámetros en la red se pueden determinar mediante el entrenamiento. Después de eso, la estructura y los parámetros del modelo se convertirán en una representación intermedia que solo describe la estructura de la red, y se realizarán algunas optimizaciones para la estructura de la red en la representación intermedia. Finalmente, escrito en un marco de programación de alto rendimiento orientado al hardware (como CUDA, OpenCL), el motor de inferencia que puede ejecutar de manera eficiente los operadores en la red de aprendizaje profundo convertirá la representación intermedia en un formato de archivo específico y ejecutará el modelo. eficientemente en la plataforma de hardware correspondiente.

Entonces, ¿qué debemos hacer si queremos ejecutar nuestro modelo de aprendizaje profundo en el teléfono móvil? A continuación, presentaré el proceso de implementación del aprendizaje profundo del lado del dispositivo. Una vez que comprenda los conceptos básicos, puede intentar ejecutar la instancia de demostración oficial y mejorarla de acuerdo con sus propias necesidades, de modo que pueda implementar el modelo de aprendizaje profundo en tu teléfono móvil~

Proceso de implementación del modelo de aprendizaje profundo del lado del dispositivo

La ruta técnica principal es: marco de entrenamiento modelo de entrenamiento -> conversión de modelo a formato ONNX -> conversión de formato ONNX a otros formatos ( formatos modelo de NCNN, TNN, MNN ) -> implementación en el marco de razonamiento correspondiente.

La aplicación del aprendizaje profundo del lado del dispositivo se puede dividir en las siguientes etapas:

La fase de entrenamiento del modelo resuelve principalmente el entrenamiento del modelo y utiliza los datos etiquetados para entrenar los archivos del modelo correspondiente. Al diseñar un modelo de extremo a lado, es necesario considerar el tamaño del modelo y la cantidad de cómputo;

En la etapa de compresión del modelo, el tamaño del modelo se optimiza principalmente y el tamaño del modelo se puede reducir mediante poda, cuantificación, etc., para que pueda usarse al final;

La fase de implementación del modelo implementa principalmente la implementación del modelo, incluida la gestión y el despliegue del modelo, la supervisión de la operación y el mantenimiento, etc.;

En la etapa de razonamiento del lado final, el razonamiento del modelo se completa principalmente, es decir, se carga el modelo y se completan todos los cálculos relacionados con el razonamiento;

ONNX

ONNX (Open Neural Network Exchange) es un formato lanzado conjuntamente por Facebook y Microsoft en 2017 para descripciones estándar de gráficos computacionales. En la actualidad, bajo el mantenimiento conjunto de varias instituciones, ONNX se ha acoplado a varios marcos de aprendizaje profundo y varios motores de inferencia. Por lo tanto, ONNX se considera un puente entre el marco de aprendizaje profundo y el motor de inferencia, al igual que el lenguaje intermedio del compilador. Debido a la diferente compatibilidad de varios marcos, ONNX generalmente solo se usa para representar gráficos estáticos que son más fáciles de implementar.

Entre ellos, torch.onnx.export es la función que viene con PyTorch para convertir el modelo a formato ONNX. Los primeros tres parámetros son el modelo a convertir, cualquier conjunto de entradas al modelo y el nombre de archivo del archivo ONNX exportado.

Del modelo de PyTorch al modelo ONNX, PyTorch proporciona un método de conversión de modelo llamado seguimiento: dado un conjunto de entradas, y luego ejecuta el modelo nuevamente, es decir, registra el gráfico de cálculo correspondiente a este conjunto de entradas y guárdelo como ONNX formato. La función de exportación utiliza el método de exportación de seguimiento, que debe proporcionar cualquier conjunto de entradas para permitir que se ejecute el modelo. La imagen de prueba tiene un tamaño de 256x256 de tres canales, y aquí también se construye un tensor aleatorio de la misma forma.

opset_version indica la versión del conjunto de operadores ONNX. input_names , output_names son los nombres de los tensores de entrada y salida. El código se ejecuta correctamente y se agregaráarchivo de modelo ONNX de srcnn.onnx en el directorio.

NCNN

ncnn es un marco de computación directa de red neuronal de alto rendimiento optimizado para teléfonos móviles. ncnn ha considerado profundamente la implementación y el uso de terminales móviles desde el comienzo del diseño. Sin dependencias de terceros, multiplataforma y la velocidad de la CPU móvil es más rápida que todos los marcos de código abierto conocidos. Basado en ncnn, los desarrolladores pueden trasplantar fácilmente algoritmos de aprendizaje profundo a teléfonos móviles para una ejecución eficiente, desarrollar aplicaciones de inteligencia artificial y poner la IA al alcance de su mano. ncnn se usa actualmente en muchas aplicaciones de Tencent, como: QQ, Qzone, WeChat, Tiantian Ptu, etc.

práctica de despliegue

A. Archivo de modelo convertido a archivo ONNX

Hay dos formas de guardar el modelo en Pytorch: El primer método solo guarda los parámetros del modelo. El segundo método guarda el modelo completo.

Guardar solo los parámetros del modelo:

print(model.state_dict().keys()) #salir nombre del parámetro del modelo

# guardar los parámetros del modelo en la ruta "./data/model_parameter.pkl"
torch.save(model.state_dict(), "./data/model_parameter.pkl ) ")
new_model = Model() # llamar al modelo Model
new_model.load_state_dict(torch.load("./data/model_parameter.pkl")) # cargar los parámetros del modelo
new_model.forward(input) # usar

Guarde el modelo completo directamente:

torch.save(model, './data/model.pkl') #Guardar todo el modelo
new_model = torch.load('./data/model.pkl') #cargar el modelo

En la actualidad, la mayoría de las aplicaciones solo guardan los parámetros del modelo, crean la estructura del modelo cuando la usan y luego cargan el modelo. Por lo general, los modelos preentrenados que descargamos son archivos que solo guardan los parámetros del modelo. Este tipo de archivo de modelo no se puede usar para hacer inferencias directamente. Necesita recrear y cargar la estructura del modelo, y luego guardarla y convertirla. El siguiente es el código para convertir el modelo a ONNX: debe crear la estructura del modelo y cargar el modelo antes de guardarlo.

Los modelos se guardan y transforman con entrada estática:

# onnx模型导入
import onnx
import torch
import torch.nn as nn
import torchvision.models as models

class Net(nn.Module):
    def __init__(self, prior_size):
         …………………

    def forward(self, x) :
        …………………
        return x

model = Net(prior_size)
model.load_state_dict(torch.load('xxx.model', map_location='cpu'))
model.eval()

input_names = ['input']
output_names = ['salida']
# 规定输入尺寸
x = torch.randn(1, 3, 240, 320, require_grad=True)
torch.onnx.export(modelo, x, 'best.onnx', input_names=input_names, output_names= nombres_de_salida, detallado='Verdadero')

Los modelos se guardan y transforman con entrada dinámica:

# onnx model
import import onnx
import torch
import torch.nn as nn
import torchvision.models as models

class Net(nn.Module):
    def __init__(self, prior_size):
         ………………

    def forward(self, x) :
        ………………
        return x

modelo = Net(tamaño_anterior)
modelo.load_state_dict(torch.load('xxx.model', map_location='cpu'))
modelo.eval()

input_names = ['input']
output_names = [ 'salida']
# Especificar tamaño de entrada
x = torch.randn(1, 3, 240, 320, require_grad=True)
# Configuración de entrada dinámica
dynamic_axes = {'input': {0: 'batch_size', 1: 'channel ', 2: "alto", 3: 'ancho'},
              'salida': {0: 'tamaño_de_lote', 1: 'canal', 2: "alto", 3: 'ancho'}}
torch.onnx.export(modelo, x, 'best_dynamic.onnx', input_names=input_names, nombres_de_salida=nombres_de_salida, detallado='Verdadero', ejes_dinámicos=ejes_dinámicos)

Verifique que la conversión del modelo haya sido exitosa:

# 验证onnx模型
import onnx

model_onnx = onnx.load("best.onnx") # 加载onnx模型
onnx.checker.check_model(model_onnx) # 验证onnx模型是否成功导出
# 如果没有报错，表示导出成功
# #测试onnx 模型
import onnxruntime
import numpy as np

# 创建会话
# session = onnxruntime.InferenceSession("best.onnx", providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
session = onnxruntime.InferenceSession("best.onnx", providers=['CPUExecutionProvider'])
x = np.random.randn(1, 3, 240, 320)
ort_input = {session.get_inputs()[0].name: x.astype(np.float32)}
ort_output = session.run(None, ort_input)
# 如果没有报错，表示执行成功

b.ONNX格式模型->端侧推理框架模型(NCNN格式)

（1）直接用模型转换工具，输入ONNX文件，生成NCNN文件(.param & .bin)

https://convertmodel.com/#input=onnx&output=onnx

（2）使用代码进行转化

将onnx转换为ncnn模型前，需要简化onnx模型，以免出现不可编译的情况。

首先安装onnx-smiplifier

pip install onnx-simplifier

然后简化onnx模型

python3 -m onnxsim my_mobileface.onnx my_mobileface-sim.onnx

onnx转换为ncnn，需要使用在ncnn/build/tools/onnx2ncnn,需要在Ubuntu中先安装ncnn,Ubuntu中安装ncnn方法，可以按这个链接安装，我已验证过。如果之前安装过opencv,就直接装ncnn就行。装好之后，找到onnx2ncnn文件的路径，输入下面命令。

./onnx2ncnn my_mobileface-sim.onnx my_mobileface.param my_mobileface.bin

生成的.bin与.param文件就是在Android上需要使用的NCNN模型文件。

c.在Android studio项目中使用模型文件

强烈建议可以先跑通ncnn官方给的几个在Android端部署的例子，然后可以根据自己的需求进行改进，下面是ncnn使用样例：

• https://github.com/nihui/ncnn-android-squeezenet

• https://github.com/nihui/ncnn-android-styletransfer

• https://github.com/nihui/ncnn-android-mobilenetssd

• https://github.com/moli232777144/mtcnn_ncnn

• https://github.com/nihui/ncnn-android-yolov5

• https://github.com/xiang-wuu/ncnn-android-yolov7

• https://github.com/shaoshengsong/qt_android_ncnn_lib_encrypt_example

搭建ncnn环境

从 https://github.com/Tencent/ncnn/releases 下载NCNN压缩包，然后提取压缩包内容到app/src/main/jni, 然后修改app/src/main/jni/CMakeLists.txt中的ncnn_DIR路径。

我的CMakeLists.txt配置如下：

project(styletransferncnn)
cmake_minimum_required(VERSIÓN 3.4.1)

set(ncnn_DIR ${CMAKE_SOURCE_DIR}/ncnn-20230517-android-vulkan/${ANDROID_ABI}/lib/cmake/ncnn)
find_package(ncnn NECESARIO)

add_library(styletransferncnn SHARED styletransferncnn_jni. cpp )

target_link_libraries(styletransferncnn ncnn)

Después de configurar ncnn, puede ejecutar e inferir archivos de modelo de aprendizaje profundo en el lado de Android. Por ejemplo, después de configurar los requisitos anteriores, puede ejecutar las muestras oficiales proporcionadas por ncnn. La siguiente figura es un ejemplo de cómo ejecutar la clasificación de imágenes en el lado de Android:

La siguiente figura es un ejemplo de mi propia mejora de la superresolución de la imagen de implementación basada en la muestra oficial:

La imagen de la izquierda es la imagen antes de la súper resolución y la imagen de la derecha es la imagen después de la súper resolución.

Proceso de implementación de Android del modelo PyTorch (NCNN)