Después de leer este artículo, puede usar el modelo DNN para entrenar desde la nube, guardar el modelo en formato .h5 (basado en keras) o en formato de modelo guardado (versión tf2.0), convertir el modelo a tflite y usar Android Studio. escribir un programa de interfaz java para implementar La predicción de inferencia final del modelo se utiliza para mostrar los resultados de la inferencia en el teléfono móvil utilizando el simulador de teléfono móvil que viene con el estudio, el efecto final es el siguiente.
Pasos de implementación:
1. Descargue el conjunto de datos MPG
2. Utilice tf2.0 para implementar el entrenamiento en la nube y generar el directorio mymodel.h5 o .savedmodel
Puede consultar esta publicación, que es relativamente clara.
3. Convertir a tflite
Código de referencia: tome .h5 como ejemplo, otros similares
mimodelo = load_model('mimodelo.h5')
convertidor = tf.lite.TFLiteConverter.from_keras_model(mimodelo)
convertidor.post_training_quantize = Verdadero
tflite_model = convertidor.convert()
open('converted_model.tflite', 'wb').write(tflite_model )
4. Utilice Android Studio para empaquetarlo en apk y completar la inferencia y predicción en el teléfono móvil.
Este paso no es familiar para los estudiantes que solo están familiarizados con la nube, porque la versión móvil de Android es diferente, por lo que se puede empaquetar en una apk para implementarlo. Este paso está escrito con un poco más de detalle.
4.1 Utilice Android Studio para crear un nuevo proyecto. Consulte la siguiente figura para configurar los elementos.
4.2 Agregar un control que pueda mostrar resultados de predicción
Android -> aplicación -> res -> diseño -> actividad_main.xml android:id="@+id/result"
4.3 Coloque el modelo tflite convertido en el directorio app-src-main-assets;
4.4 Modifique los siguientes archivos, este paso es crítico:
Modifique los scripts de Gradle -> build.gradle en la aplicación. Tenga en cuenta que es Módulo:My_Application.app. Agregue dependencias:
implementación 'org.tensorflow:tensorflow-lite:+'
Agregue también el siguiente código:
aaptOptions {
noCompress "tflite"
}
El código completo de build.gradle, como referencia, puede no ser exactamente el mismo:
complementos {
id 'com.android.application'
}
android {
compileSdkVersion 33
buildToolsVersion "33.0.0"
defaultConfig {
applicationId "com.example.myapplication"
minSdkVersion 26
targetSdkVersion 33
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner "
}
buildTypes {
lanzamiento {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
aaptOptions {
noCompress "tflite"
implementación 'androidx.constraintlayout:constraintlayout:2.0.1'
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
buildFeatures {
viewBinding true
}
sourceSets {
main {
activos {
srcDirs 'src\\main\\assets'
}
}
}
}
dependencias {
implementación 'androidx.appcompat:appcompat:1.2.0 '
implementación 'com.google.android.material:material:1.2.1'
testImplementation 'junit:junit:4.+'
androidTestImplementation 'androidx.test.ext:junit:1.1.2'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
implementación 'org.tensorflow:tensorflow-lite:+'
}
4.5 Modificar aplicación -> java -> com.example.myapplication -> MainActivity Este paso es principalmente para cargar el modelo tflite, definir entrada y salida, llamar a la inferencia del modelo y mostrar los resultados de la inferencia en el simulador del teléfono móvil Android:
El código completo de MainActivity es el siguiente, con los principales cambios resaltados en negro y negrita:
paquete com.ejemplo.miaplicación;
importar androidx.appcompat.app.AppCompatActivity;
importar android.content.Context;
importar android.content.res.AssetFileDescriptor;
importar android.os.Bundle;
importar android.util.Log;
importar android.widget.TextView;
importar android.widget.Toast;
importar java.io.FileInputStream;
importar java.io.IOException;
importar java.nio.MappedByteBuffer;
importar java.nio.channels.FileChannel;
importar org.tensorflow.lite.Interpreter;
la clase pública MainActivity extiende AppCompatActivity {
etiqueta de cadena final estática privada = "Prueba";
Intérprete privado tflite;
Contexto privado mContext;
@Anular
void protegido onCreate (Bundle saveInstanceState) {
super.onCreate (savedInstanceState);
setContentView(R.layout.activity_main);
cargarModule();
}
private void loadModule() { String model = "converted_model";//模型的名字
try {
Opciones de Interpreter.Options = new Interpreter.Options();
opciones.setNumThreads(4);
opciones.setUseNNAPI(verdadero);
opciones.setAllowFp16PrecisionForFp32(verdadero); // 加载模型文件
tflite = new Interpreter(loadModelFile(modelo), opciones);
Toast.makeText(MainActivity.this, modelo + "carga del modelo exitosa", Toast.LENGTH_SHORT).show();
// Prueba de prueba
();
} catch (IOException e) { Toast.makeText(MainActivity.this, modelo + "fallo de carga del modelo", Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
}
// 加载模型文件的函数private MappedByteBuffer loadModelFile(String model) lanza IOException {
AssetFileDescriptor fileDescriptor = getApplicationContext().getAssets().openFd(model + ".tflite");
FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
FileChannel fileChannel = inputStream.getChannel();
inicio largoOffset = fileDescriptor.getStartOffset();
largo declaradoLongitud = fileDescriptor.getDeclaredLength();
return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declareLength);
}
public void test() {
Log.d(TAG, "-----test()----");
try {
// Razonamiento Inicialización de datos de predicción
// 30.02904
float[] inputData = new float[]{-0.869348F, -1.009459F, -0.784052F, -1.025303F, -0.379759F, -0.516397F, 0.774676F, -0.465148F,
-0.4952 25F };
// Salida del modelo, la definición debe ser coherente con la salida del modelo. En la sección anterior, verificamos la entrada y la salida float[][] labelProbArray = new float[1][1];
// Aquí necesitas usar ByteBuffer para la entrada. Los datos son (1,400) números flotantes
// Ejecuta la función de predicción del modelo tflite.run(inputData, labelProbArray);
// De acuerdo con la definición del modelo, genera la información correspondiente. Resultado de cadena ;
resultado = labelProbArray[0][0] + "";
Log.d("prueba", "setText = " + resultado);
TextView tv = findViewById(R.id.result);
tv.setText(resultado);
} captura (Excepción e) {
e.printStackTrace();
}
}
}
4.6 Simplemente ejecute la aplicación y se generará el apk.
4.5 Visualización final de resultados, fin
Manejo de errores:
1. Las aplicaciones destinadas a Android 12 y versiones posteriores deben especificar un valor explícito para `android:exported` cuando el componente correspondiente tiene un filtro de intención definido. Consulte https://developer.android.com/guide/topics/manifest/activity-element#exported para obtener más detalles.
como sigue:
Modificar: aplicación -> manifiestos -> AndroidManifest.xml, agregue el siguiente código
android: exportado = "verdadero"
