基于树莓派4B与Paddle-Lite实现的手写数字识别

import matplotlib.pyplot as pltfrom PIL import Image

infer_3='data/data1910/infer_3.png'#数字#显示图片通道数image3=Image.open(infer_3)print("infer_3.png通道数为："+str(len(image3.split())))

jpg_3='data/data38289/3.jpg'image3=Image.open(jpg_3)print("3.jpg通道数为："+str(len(image3.split())))

# 清除之前训练及转化的模型# !rm num.nb# !rm mnist.pdparams# !rm -rf saved_infer_model/

import paddleimport paddle.fluid as fluidimport numpy as np
BATCH_SIZE=128#获取训练数据train_set=paddle.dataset.mnist.train()
train_reader=paddle.batch(train_set,batch_size=BATCH_SIZE)#获取测试数据test_set=paddle.dataset.mnist.test()
test_reader=paddle.batch(test_set,batch_size=BATCH_SIZE)

import paddle.fluid as fluidfrom paddle.fluid.dygraph import Linear#定义DNN网络class MyDNN(fluid.dygraph.Layer):
    def __init__(self):
        super(MyDNN,self).__init__()
        self.hidden1 = Linear(28*28,100, act='relu')
        self.hidden2 = Linear(100,100, act='relu')
        self.hidden3 = Linear(100,10, act='softmax')    def forward(self,x):
        #[bs, 1, 28, 28]
        x = fluid.layers.reshape(x, [-1, x.shape[1]*x.shape[2]*x.shape[3]])        #x = fluid.layers.reshape(x, [x.shape[0], -1]) #此方式会在Lite预测中报维度不匹配
        #[bs, 784]
        x = self.hidden1(x)        #[bs, 100]
        x = self.hidden2(x)        #[bs, 100]
        y = self.hidden3(x)        #[bs, 10]
        return y

import paddle.fluid as fluidfrom paddle.fluid.dygraph import Pool2D,Conv2Dfrom paddle.fluid.dygraph import Linear#定义CNN网络class MyCNN(fluid.dygraph.Layer):
    def __init__(self):
        super(MyCNN,self).__init__()
        self.hidden1_1 = Conv2D(num_filters=32, filter_size=3, num_channels=1)
        self.hidden1_2 = Pool2D(pool_size=2, pool_stride=1, pool_type='max')
        self.hidden2_1 = Conv2D(num_filters=64, filter_size=3,num_channels=32)
        self.hidden2_2 = Pool2D(pool_size=2, pool_stride=1, pool_type='max')
        self.hidden3 = Linear(30976,10, act='softmax')    def forward(self,x):
        #[bs, 1, 28, 28]
        x = self.hidden1_1(x)        #[bs, 32, 26, 26]
        x = self.hidden1_2(x)        #[bs, 32, 25, 25]
        x = self.hidden2_1(x)        #[bs, 64, 23, 23]
        x = self.hidden2_2(x)        #[bs, 64, 22, 22]
        x = fluid.layers.reshape(x, [-1, x.shape[1]*x.shape[2]*x.shape[3]])        #[bs, 30976]
        y = self.hidden3(x)        #[bs, 10]
        return y

from paddle.fluid.dygraph import Linear, to_variable, TracedLayerfrom pathlib import Path

my_file = Path("mnist.pdparams")
Batch=0best_acc=0Batchs=[]
all_train_accs=[]
all_train_loss=[]with fluid.dygraph.guard():
    model=MyDNN()#模型实例化
    if my_file.exists():
        model_dict,_=fluid.load_dygraph('mnist')
        model.load_dict(model_dict)#加载模型参数
        print("已经加载模型！")        #模型评估
        with fluid.dygraph.guard():
            accs = []
            model_dict, _ = fluid.load_dygraph('mnist')
            model = MyDNN()
            model.load_dict(model_dict) #加载模型参数
            model.eval() #训练模式
            for batch_id,data in enumerate(test_reader()):#测试集
                images=np.array([x[0].reshape(1, 28, 28) for x in data],np.float32)
                labels=np.array([x[1] for x in data]).astype('int64').reshape(-1,1)
                image=fluid.dygraph.to_variable(images)
                label=fluid.dygraph.to_variable(labels)
                predict=model(image)
                acc=fluid.layers.accuracy(predict,label)
                accs.append(acc.numpy()[0])
                avg_acc = np.mean(accs)            print("当前模型Accuracy:"+ str(avg_acc))
            best_acc=avg_acc

    model.train()#训练模式
    opt=fluid.optimizer.AdamOptimizer(learning_rate=0.001, parameter_list=model.parameters())#优化器选用Adam，学习率为0.001.
    epochs_num=1 #迭代次数

    for pass_num in range(epochs_num):        
        for batch_id,data in enumerate(train_reader()):#训练集
            # 输入的原始图像数据，大小为1*28*28
            images=np.array([x[0].reshape(1, 28, 28) for x in data],np.float32)            # 标签，名称为label,对应输入图片的类别标签
            labels=np.array([x[1] for x in data]).astype('int64').reshape(-1,1)
            image=fluid.dygraph.to_variable(images)
            label=fluid.dygraph.to_variable(labels)
            predict=model(image)#预测
            #使用交叉熵损失函数,描述真实样本标签和预测概率之间的差值
            loss=fluid.layers.cross_entropy(predict,label)            # 使用类交叉熵函数计算predict和label之间的损失函数
            avg_loss=fluid.layers.mean(loss)#获取loss值
            # 计算分类准确率
            acc=fluid.layers.accuracy(predict,label)#计算精度
            Batch = Batch + BATCH_SIZE
            Batchs.append(Batch)
            all_train_loss.append(avg_loss.numpy()[0])
            all_train_accs.append(acc.numpy()[0])            if batch_id!=0 and batch_id%100==0:                print("pass:{},batch_id:{},train_loss:{},train_acc:{}".format(pass_num,batch_id,avg_loss.numpy(),acc.numpy()))

            avg_loss.backward()
            opt.minimize(avg_loss)
            model.clear_gradients()

        accs = []        for batch_id,data in enumerate(test_reader()):#测试集
            images=np.array([x[0].reshape(1, 28, 28) for x in data],np.float32)
            labels=np.array([x[1] for x in data]).astype('int64').reshape(-1,1)
            image=fluid.dygraph.to_variable(images)
            label=fluid.dygraph.to_variable(labels)
            predict=model(image)
            loss=fluid.layers.cross_entropy(predict,label)
            avg_loss=fluid.layers.mean(loss)
            acc=fluid.layers.accuracy(predict,label)
            accs.append(acc.numpy()[0])
            avg_acc = np.mean(accs)            if batch_id!=0 and batch_id%10==0:                print("pass:{},batch_id:{},test_loss:{},test_acc:{}".format(pass_num,batch_id,avg_loss.numpy(),acc.numpy()))        print("Accuracy:" + str(avg_acc))   

        if avg_acc > best_acc:
            best_acc = avg_acc            # 保存动态图模型     
            fluid.save_dygraph(model.state_dict(),'mnist')            # 保存静态图模型
            out_dygraph, static_layer = TracedLayer.trace(model, inputs=[image])
            static_layer.save_inference_model(dirname='./saved_infer_model') # 将静态图模型保存为预测模型
            print("\n\n Saved \n\n")

import matplotlib.pyplot as pltdef draw_train_acc(Batchs, train_accs):
    title="training accs"
    plt.title(title, fontsize=24)
    plt.xlabel("batch", fontsize=14)
    plt.ylabel("acc", fontsize=14)
    plt.plot(Batchs, train_accs, color='green', label='training accs')
    plt.legend()
    plt.grid()
    plt.show()def draw_train_loss(Batchs, train_loss):
    title="training loss"
    plt.title(title, fontsize=24)
    plt.xlabel("batch", fontsize=14)
    plt.ylabel("loss", fontsize=14)
    plt.plot(Batchs, train_loss, color='red', label='training loss')
    plt.legend()
    plt.grid()
    plt.show()

draw_train_acc(Batchs,all_train_accs)
draw_train_loss(Batchs,all_train_loss)

#模型评估with fluid.dygraph.guard():
    accs = []
    model_dict, _ = fluid.load_dygraph('mnist')
    model = MyDNN()
    model.load_dict(model_dict) #加载模型参数
    model.eval() #训练模式
    for batch_id,data in enumerate(test_reader()):#测试集
        images=np.array([x[0].reshape(1, 28, 28) for x in data],np.float32)
        labels=np.array([x[1] for x in data]).astype('int64').reshape(-1,1)
        image=fluid.dygraph.to_variable(images)
        label=fluid.dygraph.to_variable(labels)
        predict=model(image)
        acc=fluid.layers.accuracy(predict,label)
        accs.append(acc.numpy()[0])
        avg_acc = np.mean(accs)    print(avg_acc)

import paddle.fluid as fluidfrom PIL import Imageimport matplotlib.pyplot as pltimport numpy as npimport osimport timedef load_image(file):
    img=Image.open(file).convert('L')#以灰度图的方式读取待测图片
    img=img.resize((28,28),Image.ANTIALIAS)#调整大小
    img=np.array(img).reshape(1,1,28,28).astype('float32')
    img=img/255*2.0-1.0#归一化
    print(img.shape)    return imgfor i in range(10):
    infer_path='data/data38289/'+ str(i) + '.jpg'#数字
    print(infer_path)    #显示待预测的图片
    image=Image.open(infer_path).convert('L')
    image=image.resize((100,100),Image.ANTIALIAS)
    plt.imshow(image)
    plt.show()    #构建预测动态图过程
    with fluid.dygraph.guard():
        model=MyDNN()#模型实例化
        model_dict,_=fluid.load_dygraph('mnist')
        model.load_dict(model_dict)#加载模型参数
        model.eval()#评估模式
        img=load_image(infer_path)
        img=fluid.dygraph.to_variable(img)#将np数组转换为dygraph动态图的variable
        result=model(img)        print('预测的结果是:{}'.format(np.argmax(result.numpy())))
    
    time.sleep(1.5)

####编译Paddle-Lite V2.6.1 opt工具##### !unzip work/Paddle-Lite-2.6.1.zip# %cd Paddle-Lite-2.6.1# !rm -rf third-party # !./lite/tools/build.sh build_optimize_tool# !cp /home/aistudio/Paddle-Lite-2.6.1/build.opt/lite/api/opt ~# %cd ~

!chmod +x opt
!./opt --model_dir=saved_infer_model --optimize_out_type=naive_buffer --optimize_out=num

apt updateapt-get install -y --no-install-recommends \
  gcc g++ git make wget python unzip

apt-get install -y --no-install-recommends \
  g++-arm-linux-gnueabi gcc-arm-linux-gnueabi \
  g++-arm-linux-gnueabihf gcc-arm-linux-gnueabihf \
  gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

wget -c https://mms-res.cdn.bcebos.com/cmake-3.10.3-Linux-x86_64.tar.gz && \    tar xzf cmake-3.10.3-Linux-x86_64.tar.gz && \    mv cmake-3.10.3-Linux-x86_64 /opt/cmake-3.10 && \  
    ln -s /opt/cmake-3.10/bin/cmake /usr/bin/cmake && \    ln -s /opt/cmake-3.10/bin/ccmake /usr/bin/ccmake

apt updateapt-get install -y --no-install-recomends \
  gcc g++ make wget python unzip patchelf python-dev

wget https://www.cmake.org/files/v3.10/cmake-3.10.3.tar.gz
tar -zxvf cmake-3.10.3.tar.gzcd cmake-3.10.3./configuremakesudo make install

cmake_minimum_required(VERSION 3.10)set(CMAKE_SYSTEM_NAME Linux)set(TARGET_ARCH_ABI "armv8")set(PADDLE_LITE_DIR "../Paddle-Lite")if(TARGET_ARCH_ABI STREQUAL "armv8")
    set(CMAKE_SYSTEM_PROCESSOR aarch64)
    set(CMAKE_C_COMPILER "aarch64-linux-gnu-gcc")
    set(CMAKE_CXX_COMPILER "aarch64-linux-gnu-g++")elseif(TARGET_ARCH_ABI STREQUAL "armv7hf")
    set(CMAKE_SYSTEM_PROCESSOR arm)
    set(CMAKE_C_COMPILER "arm-linux-gnueabihf-gcc")
    set(CMAKE_CXX_COMPILER "arm-linux-gnueabihf-g++")else()
    message(FATAL_ERROR "Unknown arch abi ${TARGET_ARCH_ABI}, only support armv8 and armv7hf.")
    return()endif()project(num)message(STATUS "TARGET ARCH ABI: ${TARGET_ARCH_ABI}")message(STATUS "PADDLE LITE DIR: ${PADDLE_LITE_DIR}")include_directories(${PADDLE_LITE_DIR}/include)link_directories(${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI})set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")if(TARGET_ARCH_ABI STREQUAL "armv8")
    set(CMAKE_CXX_FLAGS "-march=armv8-a ${CMAKE_CXX_FLAGS}")
    set(CMAKE_C_FLAGS "-march=armv8-a ${CMAKE_C_FLAGS}")elseif(TARGET_ARCH_ABI STREQUAL "armv7hf")
    set(CMAKE_CXX_FLAGS "-march=armv7-a -mfloat-abi=hard -mfpu=neon-vfpv4 ${CMAKE_CXX_FLAGS}")
    set(CMAKE_C_FLAGS "-march=armv7-a -mfloat-abi=hard -mfpu=neon-vfpv4 ${CMAKE_C_FLAGS}" )endif()find_package(OpenMP REQUIRED)if(OpenMP_FOUND OR OpenMP_CXX_FOUND)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
    message(STATUS "Found OpenMP ${OpenMP_VERSION} ${OpenMP_CXX_VERSION}")
    message(STATUS "OpenMP C flags:  ${OpenMP_C_FLAGS}")
    message(STATUS "OpenMP CXX flags:  ${OpenMP_CXX_FLAGS}")
    message(STATUS "OpenMP OpenMP_CXX_LIB_NAMES:  ${OpenMP_CXX_LIB_NAMES}")
    message(STATUS "OpenMP OpenMP_CXX_LIBRARIES:  ${OpenMP_CXX_LIBRARIES}")else()
    message(FATAL_ERROR "Could not found OpenMP!")
    return()endif()find_package(OpenCV REQUIRED)if(OpenCV_FOUND OR OpenCV_CXX_FOUND)
    include_directories(${OpenCV_INCLUDE_DIRS})
    message(STATUS "OpenCV library status:")
    message(STATUS "    version: ${OpenCV_VERSION}")
    message(STATUS "    libraries: ${OpenCV_LIBS}")
    message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")else()
    message(FATAL_ERROR "Could not found OpenCV!")
    return()endif()add_executable(num num.cc)target_link_libraries(num paddle_light_api_shared ${OpenCV_LIBS})

#include <iostream>#include <string>#include <vector>#include <opencv2/highgui.hpp>#include "opencv2/core.hpp"#include "opencv2/imgcodecs.hpp"#include "opencv2/imgproc.hpp"#include "paddle_api.h"  // NOLINT

using namespace paddle::lite_api;  // NOLINTconst std::vector<float> INPUT_MEAN = {0.f};const std::vector<float> INPUT_STD = {1.f};

int64_t ShapeProduction(const shape_t& shape) {  int64_t res = 1;  for (auto i : shape) res *= i;  return res;
}

void RunModel(cv::Mat &photo,std::shared_ptr<paddle::lite_api::PaddlePredictor> &predictor)

//Pre_process
    cv::cvtColor(photo, photo, CV_BGR2GRAY);//三通道 -> 灰度
    if(photo.cols != 28 || photo.rows != 28) { 
        std::cout << "当前图像尺寸为:"
                  << photo.cols
                  << "x"
                  << photo.rows
                  << std::endl;
        cv::resize(photo, photo, cv::Size(28, 28), 0.f, 0.f);
        std::cout << "img has been resize."
                  << std::endl;
    }
    photo.convertTo(photo, CV_32FC1, 1.f / 255.f * 2.f , -1.f);//归一化//    std::cout << photo << std::endl;//查看形状//    cv::imshow("num", photo);//    cv::waitKey(0);

m    – 目标矩阵。如果m在运算前没有合适的尺寸或类型，将被重新分配。rtype – 目标矩阵的类型。因为目标矩阵的通道数与源矩阵一样，所以rtype也可以看做是目标矩阵的位深度。如果rtype为负值，目标矩阵和源矩阵将使用同样的类型。alpha – 尺度变换因子（可选）。beta  – 附加到尺度变换后的值上的偏移量（可选）。

    // Get Input Tensor
    std::unique_ptr<Tensor> input_tensor(std::move(predictor->GetInput(0)));
    input_tensor->Resize({1, 1, 28, 28});    auto* input_data = input_tensor->mutable_data<float>();

    // NHWC->NCHW
    const float *image_data = reinterpret_cast<const float *>(photo.data);    float32x4_t vmean0 = vdupq_n_f32(INPUT_MEAN[0]);    float32x4_t vscale0 = vdupq_n_f32(1.0f / INPUT_STD[0]);    float *input_data_c0 = input_data;    int i = 0;    for (; i < photo.cols*photo.rows ; i += 1) {      float32x4x3_t vin3 = vld3q_f32(image_data);      float32x4_t vsub0 = vsubq_f32(vin3.val[0], vmean0);      float32x4_t vs0 = vmulq_f32(vsub0, vscale0);      vst1q_f32(input_data_c0, vs0);
      image_data += 1;
      input_data_c0 += 1;
    }    for (; i < photo.cols*photo.rows ; i++) {
      *(input_data_c0++) = (*(image_data++) - INPUT_MEAN[0]) / INPUT_STD[0];
    }

predictor->Run();

// Get Output Tensorstd::unique_ptr<const Tensor> output_tensor(std::move(predictor->GetOutput(0)));auto output_data = output_tensor->data<float>();auto output_shape = output_tensor->shape();int64_t outputSize = ShapeProduction(output_shape);for(int i =0 ;i<outputSize ; i++) {    if(output_data[i] > 0.5f )
        std::cout << "预测结果为:" << i << " Acc:" << output_data[i] << std::endl;
}

std::string num_model = argv[1];const int CPU_THREAD_NUM = 4;const paddle::lite_api::PowerMode CPU_POWER_MODE = paddle::lite_api::PowerMode::LITE_POWER_FULL;// DetectionMobileConfig config;
config.set_threads(CPU_THREAD_NUM);
config.set_power_mode(CPU_POWER_MODE);
config.set_model_from_file(num_model);//v2.6 API// Create Predictor For Detction Modelstd::shared_ptr<PaddlePredictor> predictor = CreatePaddlePredictor<MobileConfig>(config);if (argc == 3){
  std::string img_path = argv[2];
  std::cout << argv[2] << std::endl;
  cv::Mat photo = imread(img_path, cv::IMREAD_COLOR);  RunModel(photo,predictor);
  cv::imshow("num", photo);
  cv::waitKey(0);
}else {  exit(1);
}return 0;

#!/bin/bash# configureTARGET_ARCH_ABI=armv8 # for RK3399, set to default arch abi#TARGET_ARCH_ABI=armv7hf # for Raspberry Pi 3BPADDLE_LITE_DIR=../Paddle-Lite# buildrm -rf build
mkdir buildcd build
cmake -DPADDLE_LITE_DIR=${PADDLE_LITE_DIR} -DTARGET_ARCH_ABI=${TARGET_ARCH_ABI} ..
make

#!/bin/bash# configureTARGET_ARCH_ABI=armv8 # for RK3399, set to default arch abi#TARGET_ARCH_ABI=armv7hf # for Raspberry Pi 3BPADDLE_LITE_DIR=../Paddle-Lite#runcd build
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/0.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/1.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/2.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/3.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/4.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/5.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/6.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/7.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/8.jpg
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PADDLE_LITE_DIR}/libs/${TARGET_ARCH_ABI} ./num ../models/num.nb ../images/9.jpg