Merge pull request #9 from am15h/ci

CI and example code update

Author: am15h

.github/workflows/flutter_drive.yml

@@ -0,0 +1,40 @@
+name: Flutter CI
+
+on:
+  push:
+    branches: [ master, actions]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  android-integration-test:
+    name: Android
+    runs-on: macOS-latest
+    strategy:
+      matrix:
+        device:
+          - "pixel_xl"
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-java@v1
+        with:
+          java-version: '8.x'
+      - uses: subosito/flutter-action@v1
+        with:
+          flutter-version: '1.12.13+hotfix.5'
+          channel: 'stable'
+      - name: run tests
+        timeout-minutes: 30
+        uses: reactivecircus/android-emulator-runner@v2
+        env:
+          ANDROID_SIGN_PWD: ${{ secrets.ANDROID_SIGN_PWD }}
+          SECRET_REPO: ${{ secrets.SECRET_REPO }}
+          GITHUB_TOKEN: ${{ secrets.MY_GITHUB_TOKEN }}
+        with:
+          api-level: 29
+          profile: ${{ matrix.device }}
+          script: |
+            cd ./example/image_classification && flutter pub get
+            cd ./example/image_classification && flutter driver --driver='test_driver/image_classification_e2e_test.dart' test/image_classification_e2e.dart

example/image_classification/android/app/src/main/jniLibs/arm64-v8a/libtensorflowlite_c.so

@@ -1,13 +1,14 @@
-import 'dart:io';
 import 'dart:math';
 
+import 'package:image/image.dart';
 import 'package:collection/collection.dart';
 import 'package:logger/logger.dart';
 import 'package:tflite_flutter/tflite_flutter.dart';
 import 'package:tflite_flutter_helper/tflite_flutter_helper.dart';
 
 abstract class Classifier {
-  Interpreter _interpreter;
+  Interpreter interpreter;
+  InterpreterOptions _interpreterOptions;
 
   var logger = Logger();
 
@@ -19,38 +20,51 @@ abstract class Classifier {
 
   TfLiteType _outputType = TfLiteType.uint8;
 
-  final String _labelsFileName = 'assets/labels_mobilenet_quant_v1_224.txt';
+  final String _labelsFileName = 'assets/labels.txt';
 
   final int _labelsLength = 1001;
 
-  List<String> _labels;
+  var _probabilityProcessor;
+
+  List<String> labels;
 
   String get modelName;
 
   NormalizeOp get preProcessNormalizeOp;
   NormalizeOp get postProcessNormalizeOp;
 
-  Classifier() {
-    _loadModel();
-    _loadLabels();
+  Classifier({int numThreads}) {
+    _interpreterOptions = InterpreterOptions();
+
+    if (numThreads != null) {
+      _interpreterOptions.threads = numThreads;
+    }
+
+    loadModel();
+    loadLabels();
   }
 
-  Future<void> _loadModel() async {
-    _interpreter = await Interpreter.fromAsset(modelName);
-    if (_interpreter != null) {
+  Future<void> loadModel() async {
+    try {
+      interpreter =
+          await Interpreter.fromAsset(modelName, options: _interpreterOptions);
       print('Interpreter Created Successfully');
-      _inputShape = _interpreter.getInputTensor(0).shape;
-      _outputShape = _interpreter.getOutputTensor(0).shape;
-      _outputType = _interpreter.getOutputTensor(0).type;
+
+      _inputShape = interpreter.getInputTensor(0).shape;
+      _outputShape = interpreter.getOutputTensor(0).shape;
+      _outputType = interpreter.getOutputTensor(0).type;
+
       _outputBuffer = TensorBuffer.createFixedSize(_outputShape, _outputType);
-    } else {
-      print('Unable to create interpreter');
+      _probabilityProcessor =
+          TensorProcessorBuilder().add(postProcessNormalizeOp).build();
+    } catch (e) {
+      print('Unable to create interpreter, Caught Exception: ${e.toString()}');
     }
   }
 
-  Future<void> _loadLabels() async {
-    _labels = await FileUtil.loadLabels(_labelsFileName);
-    if (_labels.length == _labelsLength) {
+  Future<void> loadLabels() async {
+    labels = await FileUtil.loadLabels(_labelsFileName);
+    if (labels.length == _labelsLength) {
       print('Labels loaded successfully');
     } else {
       print('Unable to load labels');
@@ -68,30 +82,39 @@ abstract class Classifier {
         .process(_inputImage);
   }
 
-  Future<Category> predict(File imageFile) async {
-    _inputImage = TensorImage.fromFile(imageFile);
+  Category predict(Image image) {
+    if (interpreter == null) {
+      throw StateError('Cannot run inference, Intrepreter is null');
+    }
+    final pres = DateTime.now().millisecondsSinceEpoch;
+    _inputImage = TensorImage.fromImage(image);
     _inputImage = _preProcess();
+    final pre = DateTime.now().millisecondsSinceEpoch - pres;
 
-    logger.d(_inputImage.tensorBuffer.getDoubleList().sublist(0, 30));
+    print('Time to load image: $pre ms');
 
-    final st = DateTime.now().millisecondsSinceEpoch;
-    _interpreter.run(_inputImage.buffer, _outputBuffer.getBuffer());
-    logger.d(
-        'Run Time :' + (DateTime.now().millisecondsSinceEpoch - st).toString());
+    final runs = DateTime.now().millisecondsSinceEpoch;
+    interpreter.run(_inputImage.buffer, _outputBuffer.getBuffer());
+    final run = DateTime.now().millisecondsSinceEpoch - runs;
 
-    final _probabilityProcessor =
-        TensorProcessorBuilder().add(postProcessNormalizeOp).build();
+    print('Time to run inference: $run ms');
 
     Map<String, double> labeledProb = TensorLabel.fromList(
-            _labels, _probabilityProcessor.process(_outputBuffer))
+            labels, _probabilityProcessor.process(_outputBuffer))
         .getMapWithFloatValue();
-
     final pred = getTopProbability(labeledProb);
+
     return Category(pred.key, pred.value);
   }
+
+  void close() {
+    if (interpreter != null) {
+      interpreter.close();
+    }
+  }
 }
 
-getTopProbability(Map<String, double> labeledProb) {
+MapEntry<String, double> getTopProbability(Map<String, double> labeledProb) {
   var pq = PriorityQueue<MapEntry<String, double>>(compare);
   pq.addAll(labeledProb.entries);
 

example/image_classification/android/app/src/main/jniLibs/armeabi-v7a/libtensorflowlite_c.so

@@ -2,6 +2,8 @@ import 'package:imageclassification/classifier.dart';
 import 'package:tflite_flutter_helper/tflite_flutter_helper.dart';
 
 class ClassifierFloat extends Classifier {
+  ClassifierFloat({int numThreads}) : super(numThreads: numThreads);
+
   @override
   String get modelName => 'mobilenet_v1_1.0_224.tflite';
 

example/image_classification/android/app/src/main/jniLibs/x86/libtensorflowlite_c.so

@@ -2,6 +2,8 @@ import 'package:imageclassification/classifier.dart';
 import 'package:tflite_flutter_helper/src/common/ops/normailze_op.dart';
 
 class ClassifierQuant extends Classifier {
+  ClassifierQuant({int numThreads: 1}) : super(numThreads: numThreads);
+
   @override
   String get modelName => 'mobilenet_v1_1.0_224_quant.tflite';
 

example/image_classification/assets/labels_mobilenet_quant_v1_224.txt renamed to example/image_classification/assets/labels.txt

@@ -1,21 +1,19 @@
 import 'dart:io';
-import 'package:flutter/foundation.dart' as f;
+import 'package:image/image.dart' as img;
 import 'package:flutter/material.dart';
 import 'package:image_picker/image_picker.dart';
 import 'package:imageclassification/classifier.dart';
 import 'package:imageclassification/classifier_quant.dart';
 import 'package:logger/logger.dart';
 import 'package:tflite_flutter_helper/tflite_flutter_helper.dart';
 
-import 'classifier_float.dart';
-
 void main() => runApp(MyApp());
 
 class MyApp extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
-      title: 'Flutter Demo',
+      title: 'Image Classification',
       theme: ThemeData(
         primarySwatch: Colors.orange,
       ),
@@ -43,8 +41,16 @@ class _MyHomePageState extends State<MyHomePage> {
 
   Image _imageWidget;
 
+  img.Image fox;
+
   Category category;
 
+  @override
+  void initState() {
+    super.initState();
+    _classifier = ClassifierQuant();
+  }
+
   Future getImage() async {
     final pickedFile = await picker.getImage(source: ImageSource.gallery);
 
@@ -58,21 +64,12 @@ class _MyHomePageState extends State<MyHomePage> {
     });
   }
 
-  @override
-  void initState() {
-    super.initState();
-    _classifier = ClassifierQuant();
-  }
+  void _predict() async {
+    img.Image imageInput = img.decodeImage(_image.readAsBytesSync());
+    var pred = _classifier.predict(imageInput);
 
-  void _predict() {
-    int st = DateTime.now().millisecondsSinceEpoch;
-    final pred = _classifier.predict(_image);
-    pred.then((category) {
-      int en = DateTime.now().millisecondsSinceEpoch;
-      logger.d('Total Time: ${en - st}');
-      setState(() {
-        this.category = category;
-      });
+    setState(() {
+      this.category = pred;
     });
   }