如何将模型部署到安卓移动端，这里有一份简单教程

为了对模型有一个更清晰的理解，你可以在 TensorBoard 中对其可视化。

你需要打开命令提示符，输入：

tensorboard –logdir=output_dir_path

当你成功启动 TensorBoard 后，你将看到下面的对话框，请求你打开 COMPUTER_NAME:6006 的 url 链接。

在你最喜欢的浏览器中输入 URL 地址，会显示出下图所示的界面。

请双击 IMPORT 来可视化你的模型。

仔细查看模型，并且请注意输入和输出节点的名字（架构中的第一个和最后一个节点）。

如果你像我在前面的代码中那样命名你的网络层，那么它 1aa6f 们的名称应该分别是 input_1 和 output_1。

至此，我们的模型已经完全准备就绪，可以进行部署了。

将 TensorFLow Mobile 添加到你的项目中

TensorFlow 有两个移动程序库——「TensorFlow Mobile」和「TensorFlow Lite」。Lite 版本是为极小规模的模型设计的，整个依赖项仅占用大约 1Mb 的空间。Lite 中的模型也经过了更好的优化。最近，在安卓 8 及更高版本中，TensorFlow Lite 使用安卓神经网络 API 进行加速。然而，与「TensorFlow Mobile」不同，Lite 并不能直接用于生产，因为其中一些层的表现可能没有如预期一样好。此外，Windows 系统至今还不支持对 Lite 库的编译，以及将其模型转换为本地格式。因此，在这篇教程中，我坚持使用 TensorFlow Mobile。

接下来，如果你没有现有的安卓项目，请在 Android Studio 中创建一个。在你的 build.gradle 文件中添加 TensorFlow Mobile 依赖。

implementation ‘org.tensorflow:tensorflow-android:+’

此时，你的环境就已经完全设置好了。

在移动 app 中执行推断

在编写代码进行实际推断之前，你需要将转换后的模型（squeezenet.pb）添加到应用程序的资源文件夹中。在 Android Studio 中，右键点击你的项目，跳转至「Add Folder」（添加文件夹）部分，并选择「Assets Folder」（资源文件夹）。这将在你的应用程序目录中创建一个资源文件夹。接下来，你需要将模型复制到资源文件夹中。

你可以通过这个链接（https://github.com/johnolafenwa/Pytorch-Keras-ToAndroid/raw/master/android-sample/app/src/main/assets/labels.json）下载类标签，并且将文件复制到资源文件夹中。

现在你的项目已经包含了进行图像分类所需的一切。

将一个新的 Java 类添加到项目的主程序包中，并将其命名为 ImageUtils，把下面的代码复制到其中。

package com.specpal.mobileai;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.os.Environment;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import org.json.*;

/**
 * Utility class for manipulating images.
 **/
public class ImageUtils {
    /**
     * Returns a transformation matrix from one reference frame into another.
     * Handles cropping (if maintaining aspect ratio is desired) and rotation.
     *
     * @param srcWidth Width of source frame.
     * @param srcHeight Height of source frame.
     * @param dstWidth Width of destination frame.
     * @param dstHeight Height of destination frame.
     * @param applyRotation Amount of rotation to apply from one frame to another.
     *  Must be a multiple of 90.
     * @param maintainAspectRatio If true, will ensure that scaling in x and y remains constant,
     * cropping the image if necessary.
     * @return The transformation fulfilling the desired requirements.
     */
    public static Matrix getTransformationMatrix(
            final int srcWidth,
            final int srcHeight,
            final int dstWidth,
            final int dstHeight,
            final int applyRotation,
            final boolean maintainAspectRatio) {
        final Matrix matrix = new Matrix();

        if (applyRotation != 0) {
            // Translate so center of image is at origin.
            matrix.postTranslate(-srcWidth / 2.0f, -srcHeight / 2.0f);

            // Rotate around origin.
            matrix.postRotate(applyRotation);
        }

        // Account for the already applied rotation, if any, and then determine how
        // much scaling is needed for each axis.
        final boolean transpose = (Math.abs(applyRotation) + 90) % 180 == 0;

        final int inWidth = transpose ? srcHeight : srcWidth;
        final int inHeight = transpose ? srcWidth : srcHeight;

        // Apply scaling if necessary.
        if (inWidth != dstWidth || inHeight != dstHeight) {
            final float scaleFactorX = dstWidth / (float) inWidth;
            final float scaleFactorY = dstHeight / (float) inHeight;

            if (maintainAspectRatio) {
                // Scale by minimum factor so that dst is filled completely while
                // maintaining the aspect ratio. Some image may fall off the edge.
                final float scaleFactor = Math.max(scaleFactorX, scaleFactorY);
                matrix.postScale(scaleFactor, scaleFactor);
            } else {
                // Scale exactly to fill dst from src.
                matrix.postScale(scaleFactorX, scaleFactorY);
            }
        }

        if (applyRotation != 0) {
            // Translate back from origin centered reference to destination frame.
            matrix.postTranslate(dstWidth / 2.0f, dstHeight / 2.0f);
        }

        return matrix;
    }

    public static Bitmap processBitmap(Bitmap source,int size){

        int image_height = source.getHeight();
        int image_width = source.getWidth();

        Bitmap croppedBitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);

        Matrix frameToCropTransformations = getTransformationMatrix(image_width,image_height,size,size,0,false);
        Matrix cropToFrameTransformations = new Matrix();
        frameToCropTransformations.invert(cropToFrameTransformations);

        final Canvas canvas = new Canvas(croppedBitmap);
        canvas.drawBitmap(source, frameToCropTransformations, null);

        return croppedBitmap;

    }

    public static float[] normalizeBitmap(Bitmap source,int size,float mean,float std){

        float[] output = new float[size * size * 3];

        int[] intValues = new int[source.getHeight() * source.getWidth()];

        source.getPixels(intValues, 0, source.getWidth(), 0, 0, source.getWidth(), source.getHeight());
        for (int i = 0; i < intValues.length; ++i) {
            final int val = intValues[i];
            output[i * 3] = (((val >> 16) & 0xFF) - mean)/std;
            output[i * 3 + 1] = (((val >> 8) & 0xFF) - mean)/std;
            output[i * 3 + 2] = ((val & 0xFF) - mean)/std;
        }

        return output;

    }

    public static Object[] argmax(float[] array){

        int best = -1;
        float best_confidence = 0.0f;

        for(int i = 0;i < array.length;i++){

            float value = array[i];

            if (value > best_confidence){

                best_confidence = value;
                best = i;
            }
        }

        return new Object[]{best,best_confidence};

    }

    public static String getLabel( InputStream jsonStream,int index){
        String label = "";
        try {

            byte[] jsonData = new byte[jsonStream.available()];
            jsonStream.read(jsonData);
            jsonStream.close();

            String jsonString = new String(jsonData,"utf-8");

            JSONObject object = new JSONObject(jsonString);

            label = object.getString(String.valueOf(index));

        }
        catch (Exception e){

        }
        return label;
    }
}

在你的主活动（main activity）中创建 ImageView 和 TextView。它们将被用于显示图像和预测结果。

在主活动中，你需要加载 TensorFlow-inference 库，并且初始化一些类变量。在 onCreat 方法前添加以下内容：

 //Load the tensorflow inference library
    static {
        System.loadLibrary("tensorflow_inference");
    }

    //PATH TO OUR MODEL FILE AND NAMES OF THE INPUT AND OUTPUT NODES
    private String MODEL_PATH = "file:///android_asset/squeezenet.pb";
    private String INPUT_NAME = "input_1";
    private String OUTPUT_NAME = "output_1";
    private TensorFlowInferenceInterface tf;

    //ARRAY TO HOLD THE PREDICTIONS AND FLOAT VALUES TO HOLD THE IMAGE DATA
    float[] PREDICTIONS = new float[1000];
    private float[] floatValues;
    private int[] INPUT_SIZE = {224,224,3};

    ImageView imageView;
    TextView resultView;
    Snackbar progressBar;

//FUNCTION TO COMPUTE THE MAXIMUM PREDICTION AND ITS CONFIDENCE
    public Object[] argmax(float[] array){

        int best = -1;
        float best_confidence = 0.0f;

        for(int i = 0;i < array.length;i++){

            float value = array[i];

            if (value > best_confidence){

                best_confidence = value;
                best = i;
            }
        }

        return new Object[]{best,best_confidence};

    }

public void predict(final Bitmap bitmap){

        //Runs inference in background thread
        new AsyncTask<Integer,Integer,Integer>(){

            @Override

            protected Integer doInBackground(Integer ...params){

                //Resize the image into 224 x 224
                Bitmap resized_image = ImageUtils.processBitmap(bitmap,224);

                //Normalize the pixels
                floatValues = ImageUtils.normalizeBitmap(resized_image,224,127.5f,1.0f);

                //Pass input into the tensorflow
                tf.feed(INPUT_NAME,floatValues,1,224,224,3);

                //compute predictions
                tf.run(new String[]{OUTPUT_NAME});

                //copy the output into the PREDICTIONS array
                tf.fetch(OUTPUT_NAME,PREDICTIONS);

                //Obtained highest prediction
                Object[] results = argmax(PREDICTIONS);

                int class_index = (Integer) results[0];
                float confidence = (Float) results[1];

                try{

                    final String conf = String.valueOf(confidence * 100).substring(0,5);

                    //Convert predicted class index into actual label name
                   final String label = ImageUtils.getLabel(getAssets().open("labels.json"),class_index);

                   //Display result on UI
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {

                            progressBar.dismiss();
                            resultView.setText(label + " : " + conf + "%");

                        }
                    });

                }

                catch (Exception e){

                }

                return 0;
            }

        }.execute(0);

    }

请注意，在主用户界面（UI）线程上执行推断可能会挂起应用程序。一般而言，我们总是在后台线程执行推断工作。

为了将本教程的重点放在图像识别的主题上，我简单地使用了一张添加到资源文件夹中的鸟的图像。在标准应用程序中，你应该编写代码从文件系统中加载图片。

你可以向资源文件夹添加任何你想要预测的图像。为了进行一次真实的预测，在下面的代码中，我们为一个按钮添加了一个点击事件的监听器。这个监听器仅仅加载图片并且调用预测函数。

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

        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        //initialize tensorflow with the AssetManager and the Model
        tf = new TensorFlowInferenceInterface(getAssets(),MODEL_PATH);

        imageView = (ImageView) findViewById(R.id.imageview);
        resultView = (TextView) findViewById(R.id.results);

        progressBar = Snackbar.make(imageView,"PROCESSING IMAGE",Snackbar.LENGTH_INDEFINITE);

        final FloatingActionButton predict = (FloatingActionButton) findViewById(R.id.predict);
        predict.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                try{

                    //READ THE IMAGE FROM ASSETS FOLDER
                    InputStream imageStream = getAssets().open("testimage.jpg");

                    Bitmap bitmap = BitmapFactory.decodeStream(imageStream);

                    imageView.setImageBitmap(bitmap);

                    progressBar.show();

                    predict(bitmap);
                }
                catch (Exception e){

                }

            }
        });
    }

稍等片刻，你的安装包就构建好了。你可以安装 APK，运行该应用程序。

运行结果如下：

要想获得更令人兴奋的体验，你应该实现一些新功能，从安卓文件系统加载图像，或者使用相机获取图像，而不是使用资源文件夹。

总结

移动端的深度学习最终将改变我们构建和使用 app 的方式。通过上面的代码片段，你可以很容易地将训练好的 PyTorch 和 Keras 模型导出到 TensorFlow 环境下。借助于 TensorFlow Mobile 的强大功能，并且按照本文中介绍的步骤，你可以为自己的移动应用程序无缝注入优秀的人工智能功能。

安卓项目的全部代码和模型转换器可以在我的 GitHub 上（https://github.com/johnolafenwa/Pytorch-Keras-ToAndroid）获得。

原文链接：https://heartbeat.fritz.ai/deploying-pytorch-and-keras-models-to-android-with-tensorflow-mobile-a16a1fb83f2