专栏首页CSDN博客《PaddlePaddle从入门到炼丹》十五——把预测模型部署到Android手机上

《PaddlePaddle从入门到炼丹》十五——把预测模型部署到Android手机上

原文博客:Doi技术团队 链接地址:https://blog.doiduoyi.com/authors/1584446358138 初心:记录优秀的Doi技术团队学习经历

前言

现在越来越多的手机要使用到深度学习了,比如一些图像分类,目标检测,风格迁移等等,之前都是把数据提交给服务器完成的。但是提交给服务器有几点不好,首先是速度问题,图片上传到服务器需要时间,客户端接收结果也需要时间,这一来回就占用了一大半的时间,会使得整体的预测速度都变慢了,再且现在手机的性能不断提高,足以做深度学习的预测。其二是隐私问题,如果只是在本地预测,那么用户根本就不用上传图片,安全性也大大提高了。所以本章我们就来学如何包我们训练的PaddlePaddle预测模型部署到Android手机上。

编译paddle-mobile库

想要把PaddlePaddle训练好的预测库部署到Android手机上,还需要借助paddle-mobile框架。paddle-mobile框架主要是为了方便PaddlePaddle训练好的模型部署到移动设备上,比如Android手机,苹果手机,树莓派等等这些移动设备,有了paddle-mobile框架大大方便了把PaddlePaddle的预测库部署到移动设备上,而且paddle-mobile框架针对移动设备做了大量的优化,使用这些预测库在移动设备上有了更好的预测性能。

想要在Android手机上使用paddle-mobile,就要编译Android能够使用的CPP库,在这一部分中,我们介绍两种编译Android的paddle-mobile库,分别是使用Docker编译paddle-mobile库、使用Ubuntu交叉编译paddle-mobile库。

使用Docker编译

为了方便操作,以下的操作都是在root用户的执行的:

1、安装Docker,以下是在Ubuntu下安装的的方式,只要一条命令就可以了:

apt-get install docker.io

2、克隆paddle-mobile源码:

git clone https://github.com/PaddlePaddle/paddle-mobile.git

3、进入到paddle-mobile根目录下编译docker镜像:

cd paddle-mobile
# 编译生成进行,编译时间可能要很长
docker build -t paddle-mobile:dev - < Dockerfile

编译完成可以使用docker images命令查看是否已经生成进行:

root@test:/home/test# docker images
REPOSITORY                          TAG                 IMAGE ID            CREATED             SIZE
paddle-mobile                       dev                 fffbd8779c68        20 hours ago        3.76 GB

4、运行镜像并进入到容器里面,当前目录还是在paddle-mobile根目录下:

docker run -it -v $PWD:/paddle-mobile paddle-mobile:dev

5、在容器里面执行以下两条命令:

root@fc6f7e9ebdf1:/# cd paddle-mobile/
root@fc6f7e9ebdf1:/paddle-mobile# cmake -DCMAKE_TOOLCHAIN_FILE=tools/toolchains/arm-android-neon.cmake

6、(可选)可以使用命令ccmake .配置一些信息,比如可以设置NET仅支持googlenet,这样便于得到的paddle-mobile库会更小一些,修改完成之后,使用c命令保存,使用g退出。笔者一般跳过这个步骤。

                                                    Page 1 of 1
 CMAKE_ASM_FLAGS                                                                                                                                                                                
 CMAKE_ASM_FLAGS_DEBUG                                                                                                                                                                          
 CMAKE_ASM_FLAGS_RELEASE                                                                                                                                                                        
 CMAKE_BUILD_TYPE                                                                                                                                                                               
 CMAKE_INSTALL_PREFIX             /usr/local                                                                                                                                                    
 CMAKE_TOOLCHAIN_FILE             /paddle-mobile/tools/toolchains/arm-android-neon.cmake                                                                                                        
 CPU                              ON                                                                                                                                                            
 DEBUGING                         ON                                                                                                                                                            
 FPGA                             OFF                                                                                                                                                           
 LOG_PROFILE                      ON                                                                                                                                                            
 MALI_GPU                         OFF                                                                                                                                                           
 NET                              defult                                                                                                                                                        
 USE_EXCEPTION                    ON                                                                                                                                                            
 USE_OPENMP                       ON                                                       

7、最后执行一下make就可以了,到这一步就完成了paddle-mobile的编译。

root@fc6f7e9ebdf1:/paddle-mobile# make

8、使用exit命令退出容器,回到Ubuntu本地上。

root@fc6f7e9ebdf1:/paddle-mobile# exit

9、在paddle-mobile根目录下,有一个build目录,我们编译好的paddle-mobile库就在这里。

root@test:/home/test/paddle-mobile/build# ls
libpaddle-mobile.so

libpaddle-mobile.so就是我们在开发Android项目的时候使用到的paddle-mobile库。

使用Ubuntu编译

1、首先要下载和解压NDK。

wget https://dl.google.com/android/repository/android-ndk-r17b-linux-x86_64.zip
unzip android-ndk-r17b-linux-x86_64.zip

2、设置NDK环境变量,目录是NDK的解压目录。

export NDK_ROOT="/home/test/android-ndk-r17b"

设置好之后,可以使用以下的命令查看配置情况。

root@test:/home/test# echo $NDK_ROOT
/home/test/android-ndk-r17b

3、安装cmake,需要安装较高版本的,笔者的cmake版本是3.11.2。

  • 下载cmake源码
wget https://cmake.org/files/v3.11/cmake-3.11.2.tar.gz
  • 解压cmake源码
tar -zxvf cmake-3.11.2.tar.gz
  • 进入到cmake源码根目录,并执行bootstrap
cd cmake-3.11.2
./bootstrap
  • 最后执行以下两条命令开始安装cmake。
make
make install
  • 安装完成之后,可以使用cmake --version是否安装成功.
root@test:/home/test/paddlepaddle# cmake --version
cmake version 3.11.2

CMake suite maintained and supported by Kitware (kitware.com/cmake).

4、克隆paddle-mobile源码。

git clone https://github.com/PaddlePaddle/paddle-mobile.git

5、进入到paddle-mobile目录下,执行编译。

cd paddle-mobile/
cmake -DCMAKE_TOOLCHAIN_FILE=tools/toolchains/arm-android-neon.cmake
make

6、最后会在paddle-mobile/build目录下生产paddle-mobile库。

root@test:/home/test/paddle-mobile/build# ls
libpaddle-mobile.so

libpaddle-mobile.so就是我们在开发Android项目的时候使用到的paddle-mobile库。

创建Android项目

首先使用Android Studio创建一个普通的Android项目,我们可以不用选择CPP的支持,因为我们已经编译好了CPP。之后按照以下的步骤开始执行:

1、在main目录下创建两个assets/infer_model文件夹,这个文件夹我们将会使用它来存放PaddlePaddle训练好的预测模型,本章我们使用的预测模型是《PaddlePaddle从入门到炼丹》十一——自定义图像数据集识别训练得到的预测模型,我们训练好的模型复制到这个文件夹下。

2、在main目录下创建一个jniLibs文件夹,这个文件夹是存放CPP编译库的,就是编译paddle-mobile库部分编译的libpaddle-mobile.so

3、在Android项目的配置文件夹中加上权限声明,因为我们要使用到读取相册和使用相机,所以加上以下的权限声明:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

4、修改activity_main.xml界面,修改成如下:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <LinearLayout
        android:id="@+id/ll"
        android:orientation="horizontal"
        android:layout_alignParentBottom="true"
        android:layout_width="match_parent"
        android:layout_height="50dp">

        <Button
            android:layout_weight="1"
            android:id="@+id/load"
            android:text="加载模型"
            android:layout_width="0dp"
            android:layout_height="match_parent" />

        <Button
            android:id="@+id/clear"
            android:layout_weight="1"
            android:text="清空模型"
            android:layout_width="0dp"
            android:layout_height="match_parent" />

        <Button
            android:id="@+id/infer"
            android:layout_weight="1"
            android:text="预测图片"
            android:layout_width="0dp"
            android:layout_height="match_parent" />
    </LinearLayout>

    <TextView
        android:layout_above="@id/ll"
        android:id="@+id/show"
        android:hint="这里显示预测结果"
        android:layout_width="match_parent"
        android:layout_height="100dp" />

    <ImageView
        android:id="@+id/image_view"
        android:layout_above="@id/show"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</RelativeLayout>

5、创建一个com.baidu.paddle包,在这个包下创建的Java程序,这个Java程序就是用于调用paddle-mobile的CPP动态库的。它提供了多种方法给我们使用,我们主要使用到加载模型的方法load(String modelDir),清空已加载的方法clear(),还有最最重要的预测方法predictImage(float[] buf, int[]ddims)

package com.baidu.paddle;

public class PML {
    // set thread num
    public static native void setThread(int threadCount);

    //Load seperated parameters
    public static native boolean load(String modelDir);

    // load qualified model
    public static native boolean loadQualified(String modelDir);

    // Load combined parameters
    public static native boolean loadCombined(String modelPath, String paramPath);

    // load qualified model
    public static native boolean loadCombinedQualified(String modelPath, String paramPath);

    // object detection
    public static native float[] predictImage(float[] buf, int[]ddims);

    // predict yuv image
    public static native float[] predictYuv(byte[] buf, int imgWidth, int imgHeight, int[] ddims, float[]meanValues);

    // clear model
    public static native void clear();
}

6、然后在项目的主要包下创建一个Utils.java的工具类。这个工具类主要编写一些图像的处理方法,和一些模型复制方法等,我们下面将一一介绍这些方法。

该方法是用于获取预测结果中概率最大的标签,参数是执行预测的结果,这个结果是对应没有类别的概率,这个方法就判断哪个类别的概率最大,然后就返回概率最大的标签。

// 获取预测值中最大概率的标签
public static int getMaxResult(float[] result) {
    float probability = result[0];
    int r = 0;
    for (int i = 0; i < result.length; i++) {
        if (probability < result[i]) {
            probability = result[i];
            r = i;
        }
    }
    return r;
}

该方法是把图片转换成预测需要用的数据格式浮点数组。在转换的过程中也对图像做了预处理,这个预处理需要跟训练的预处理的方式一样,否则无法正确预测。还有指定了处理后图片的大小,根据参数输入的宽度和高度,把图片压缩到这些自定的大小。还有把图片的通道顺序改为RGB,同时每个像素除以255,这个操作跟训练的时候一样。

// 对将要预测的图片进行预处理
public static float[] getScaledMatrix(Bitmap bitmap, int desWidth, int desHeight) {
    float[] dataBuf = new float[3 * desWidth * desHeight];
    int rIndex;
    int gIndex;
    int bIndex;
    int[] pixels = new int[desWidth * desHeight];
    Bitmap bm = Bitmap.createScaledBitmap(bitmap, desWidth, desHeight, false);
    bm.getPixels(pixels, 0, desWidth, 0, 0, desWidth, desHeight);
    int j = 0;
    int k = 0;
    for (int i = 0; i < pixels.length; i++) {
        int clr = pixels[i];
        j = i / desHeight;
        k = i % desWidth;
        rIndex = j * desWidth + k;
        gIndex = rIndex + desHeight * desWidth;
        bIndex = gIndex + desHeight * desWidth;
        // 转成RGB通道顺序,并除以255,跟训练的预处理一样
        dataBuf[rIndex] = (float) (((clr & 0x00ff0000) >> 16) / 255.0);
        dataBuf[gIndex] = (float) (((clr & 0x0000ff00) >> 8) / 255.0);
        dataBuf[bIndex] = (float) (((clr & 0x000000ff)) / 255.0);

    }
    if (bm.isRecycled()) {
        bm.recycle();
    }
    return dataBuf;
}

该方法是对图片进行压缩,避免图片过大,超过内存支出。把图片的最大长度压缩到500以内。

// 压缩图片,避免图片过大
public static Bitmap getScaleBitmap(String filePath) {
    BitmapFactory.Options opt = new BitmapFactory.Options();
    opt.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(filePath, opt);

    int bmpWidth = opt.outWidth;
    int bmpHeight = opt.outHeight;

    int maxSize = 500;

    // compress picture with inSampleSize
    opt.inSampleSize = 1;
    while (true) {
        if (bmpWidth / opt.inSampleSize < maxSize || bmpHeight / opt.inSampleSize < maxSize) {
            break;
        }
        opt.inSampleSize *= 2;
    }
    opt.inJustDecodeBounds = false;
    return BitmapFactory.decodeFile(filePath, opt);
}

该方法是根据相册返回的URI转换为图片的绝对路径,用于之后使用这个路径获取图片内容。

// 根据相册返回的URI返回图片的绝对路径
public static String getPathFromURI(Context context, Uri uri) {
    String result;
    Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
    if (cursor == null) {
        result = uri.getPath();
    } else {
        cursor.moveToFirst();
        int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
        result = cursor.getString(idx);
        cursor.close();
    }
    return result;
}

该方法是把assets资源文件下的预测文件复制到缓存目录,用于之后加载模型文件。

// 复制莫模型文件到缓存目录
public static void copyFileFromAsset(Context context, String oldPath, String newPath) {
    try {
        // 预测模型文件在assets中的位置
        String[] fileNames = context.getAssets().list(oldPath);
        if (fileNames.length > 0) {
            // directory
            File file = new File(newPath);
            if (!file.exists()) {
                file.mkdirs();
            }
            // copy recursivelyC
            for (String fileName : fileNames) {
                copyFileFromAsset(context, oldPath + "/" + fileName, newPath + "/" + fileName);
            }
        } else {
            // file
            File file = new File(newPath);
            // if file exists will never copy
            if (file.exists()) {
                return;
            }

            // copy file to new path
            InputStream is = context.getAssets().open(oldPath);
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buffer = new byte[1024];
            int byteCount;
            while ((byteCount = is.read(buffer)) != -1) {
                fos.write(buffer, 0, byteCount);
            }
            fos.flush();
            is.close();
            fos.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

7、最后修改MainActivity.java,修改如下:

这里做一些初始化操作,如加载PaddleMobile的动态库,指定图片的形状。

    private String model_path;
    // 模型文件夹
    private String assets_path = "infer_model";
    private boolean load_result = false;
    // 输入图片的形状,分别是:batch size、通道数、宽度、高度
    private int[] ddims = {1, 3, 224, 224};
    private ImageView imageView;
    private TextView showTv;

    // 加载PaddleMobile的动态库
    static {
        try {
            System.loadLibrary("paddle-mobile");

        } catch (Exception e) {
            e.printStackTrace();

        }
    }

该方法是初始化控件,和定义按钮的点击事件,如加载模型点击事件,清空模型点击事件,打开相册预测图片点击事件。

    // 初始化控件
    private void initView(){
        Button loadBtn = findViewById(R.id.load);
        Button clearBtn = findViewById(R.id.clear);
        Button inferBtn = findViewById(R.id.infer);
        showTv = findViewById(R.id.show);
        imageView = findViewById(R.id.image_view);

        // 加载模型点击事件
        loadBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                load_result = PML.load(model_path);
                if (load_result) {
                    Toast.makeText(MainActivity.this, "模型加载成功", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(MainActivity.this, "模型加载失败", Toast.LENGTH_SHORT).show();
                }
            }
        });

        // 清空模型点击事件
        clearBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                PML.clear();
                load_result = false;
                Toast.makeText(MainActivity.this, "模型已清空", Toast.LENGTH_SHORT).show();
            }
        });

        // 打开相册选择图片预测点击事件
        inferBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (load_result){
                    Intent intent = new Intent(Intent.ACTION_PICK);
                    intent.setType("image/*");
                    startActivityForResult(intent, 1);
                } else {
                    Toast.makeText(MainActivity.this, "模型未加载", Toast.LENGTH_SHORT).show();
                }
            }
        });

    }

该方法是一个回调方法,主要是打开相册后的回调预测操作。使用返回的URI转换为绝对路径,然后使用这个图片路径转换成Bitmap用于显示,同时也使用这个路径执行预测操作。

    // 回调事件
    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        String image_path;
        if (resultCode == Activity.RESULT_OK) {
            switch (requestCode) {
                case 1:
                    if (data == null) {
                        return;
                    }
                    // 获取相册返回的URI
                    Uri image_uri = data.getData();
                    // 根据图片的URI获取绝对路径
                    image_path = Utils.getPathFromURI(MainActivity.this, image_uri);
                    // 压缩图片用于显示
                    Bitmap bitmap = Utils.getScaleBitmap(image_path);
                    imageView.setImageBitmap(bitmap);
                    // 开始预测图片
                    predictImage(image_path);
                    break;
            }
        }
    }

该方法是预测操作的方法,参数是图片的绝对路径,首先根据图片获取已经压缩过的Bitmap,然后使用这个Bitmap转换成预处理后的浮点数组,最后执行预测操作。再根据预测结果提取最大概率的标签,并获取该标签的类别名称。

    // 根据图片的路径预测图片
    private void predictImage(String image_path) {
        // 把图片进行压缩
        Bitmap bmp = Utils.getScaleBitmap(image_path);
        // 把图片转换成浮点数组,用于预测
        float[] inputData = Utils.getScaledMatrix(bmp, ddims[2], ddims[3]);
        try {
            long start = System.currentTimeMillis();
            // 执行预测,获取预测结果
            float[] result = PML.predictImage(inputData, ddims);
            long end = System.currentTimeMillis();
            // 获取概率最大的标签
            int r = Utils.getMaxResult(result);
            // 获取标签对应的类别名称
            String[] names = {"苹果", "哈密瓜", "胡萝卜", "樱桃", "黄瓜", "西瓜"};
            String show_text = "标签:" + r + "\n名称:" + names[r] + "\n概率:" + result[r] + "\n时间:" + (end - start) + "ms";
            // 显示预测结果
            showTv.setText(show_text);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这主要是用于动态获取权限,因为读取外部文件需要读取外部文件的权限,又因为读取外部文件权限是属于危险权限,需要动态获取。

    // 多权限动态申请
    private void requestPermissions() {
        List<String> permissionList = new ArrayList<>();
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        }

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            permissionList.add(Manifest.permission.READ_EXTERNAL_STORAGE);
        }

        // if list is not empty will request permissions
        if (!permissionList.isEmpty()) {
            ActivityCompat.requestPermissions(this, permissionList.toArray(new String[permissionList.size()]), 1);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case 1:
                if (grantResults.length > 0) {
                    for (int i = 0; i < grantResults.length; i++) {

                        int grantResult = grantResults[i];
                        if (grantResult == PackageManager.PERMISSION_DENIED) {
                            String s = permissions[i];
                            Toast.makeText(this, s + " permission was denied", Toast.LENGTH_SHORT).show();
                        }
                    }
                }
                break;
        }
    }

然后修改onCreate,首先获取缓存文件路径,然后初始化视图控件和动态获取权限,最后把预测模型文件复制到缓存路径下。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        model_path = getCacheDir().getAbsolutePath() + File.separator + "infer_model";
        // 初始化控件
        initView();
        // 动态请求权限
        requestPermissions();
        // 从assets中复制模型文件到缓存目录下
        Utils.copyFileFromAsset(this, assets_path, model_path);
    }

8、最后运行项目,选择图片预测会得到以下的效果:

GitHub地址:https://github.com/yeyupiaoling/LearnPaddle2/tree/master/note15

上一章:《PaddlePaddle从入门到炼丹》十四——把预测模型部署在服务器

参考资料

  1. https://github.com/PaddlePaddle/paddle-mobile
  2. https://blog.csdn.net/qq_33200967/article/details/81066970

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 在Android手机上使用PaddleMobile实现图像分类

    现在越来越多的手机要使用到深度学习了,比如一些图像分类,目标检测,风格迁移等等,之前都是把数据提交给服务器完成的。但是提交给服务器有几点不好,首先是速度问题,图...

    夜雨飘零
  • 《我的PaddlePaddle学习之路》笔记二——MNIST手写数字识别

    如题目所示,本次训练使用到的是MNIST数据库的手写数字,这个数据集包含60,000个示例的训练集以及10,000个示例的测试集.图片是28x28的像素矩阵,标...

    夜雨飘零
  • 基于Paddle Lite在Android手机上实现图像分类

    Paddle Lite是飞桨基于Paddle Mobile全新升级推出的端侧推理引擎,在多硬件、多平台以及硬件混合调度的支持上更加完备,为包括手机在内的端侧场景...

    夜雨飘零
  • Java高编译低运行错误(ConcurrentHashMap.keySet)

    本地使用maven编译和运行时一切都正常,但是通过ci的方式,编译、打包、发布到部署环境,运行时抛出了一条显而易见的JDK版本的错误。

    lambeta
  • BubbleSort-冒泡排序

    sr
  • 【Gym 100812C】Story of Princess (走完图所有边)

    给你一个图,n个点m条边,求走遍所有边,至少经过几次点,及输出依次经过的点。n and m (2 ≤ n ≤ 10^5, 1 ≤ m ≤ 2·10^5)

    饶文津
  • UIAutomator2.0和AccessibilityService实现分析

    UiAutomator是Android 4.1以上提供的一个UI自动化测试工具,4.3升级到了UiAutomator2.0,实现方式也从UiTestAutoma...

    drunkdream
  • Android自定义View实现水波纹效果

    介绍:水波纹散开效果的控件在 App 里面还是比较常见的,例如 网易云音乐歌曲识别,附近搜索场景。

    砸漏
  • leetcode周赛130 | 题解速递

    leetcode周赛题解,后面每周如果有时间就做周赛题目,不单独发leetcode的题目了,做多了感觉都可以在以前的题目里面找到类似的。

    ACM算法日常
  • HashMap在Java1.7与1.8中的区别

    使用一个Entry数组来存储数据,用key的hashcode取模来决定key会被放到数组里的位置,如果hashcode相同,或者hashcode取模后的结果相同...

    哲洛不闹

扫码关注云+社区

领取腾讯云代金券