Sentiment Analysis with Dart + TensorFlow Lite

Introduction

Sentiment analysis is a common NLP task for mobile apps: classify user feedback, moderate comments, or drive personalized UX. In Flutter mobile development, running a lightweight TensorFlow Lite (TFLite) model on-device gives low latency and privacy benefits. This tutorial shows how to integrate a TFLite sentiment model with Dart, handle tokenization and preprocessing, run inference with tflite_flutter, and optimize for mobile.

Choosing and Preparing a TFLite Model

Start with a compact model: MobileBERT, DistilBERT, or a small LSTM/Conv1D trained for sentiment. For mobile, convert TensorFlow or Keras models to TFLite and ideally quantize (8-bit) to reduce size and increase performance.

Basic conversion steps (outside Dart): train/export a SavedModel, then use the TensorFlow Lite converter with post-training quantization. Ensure the model expects integer token ids (commonly int32 or uint8). Include a vocabulary file or SentencePiece model needed for tokenization.

On Android/iOS, include the .tflite and vocab files in your Flutter assets and declare them in pubspec.yaml.

Tokenization and Preprocessing in Dart

Tokenization is the most important preprocessing step. For transformer-based models use the same tokenization method as training (WordPiece, SentencePiece). If you used SentencePiece, you can either run it via a native library binding or precompute an ID map and implement token lookup in Dart.

A minimal whitespace tokenizer is sufficient only for simple LSTM models. Below is a concise Dart tokenizer example mapping tokens to IDs from a small vocab asset and padding/truncating to maxLen.

Map<String,int> vocab = {'[PAD]':0, '[UNK]':1, 'i':2, 'love':3, 'flutter':4};
List<int> tokenize(String text) {
  final tokens = text.toLowerCase().split(RegExp(r"\s+"));
  return tokens.map((t) => vocab[t] ?? vocab['[UNK]']!).toList();
}
List<int> pad(List<int> ids, int maxLen) {
  if (ids.length > maxLen) return ids.sublist(0, maxLen);
  return ids + List.filled(maxLen - ids.length, vocab['[PAD]']!);
}

For production, load a real vocab map from an asset JSON or TSV. Keep preprocessing deterministic (same lowercasing, special tokens, and truncation strategy as training).

Running Inference with tflite_flutter

Use the tflite_flutter plugin to run TFLite models in Dart. It provides a lightweight Interpreter API and supports delegates (NNAPI, GPU) when available.

Example: load interpreter, prepare input tensor, and run inference. The exact input shape and types depend on your model (e.g., [1, maxLen] int32), and output might be logits or probabilities (sigmoid for binary, softmax for multi-class).

import 'package:tflite_flutter/tflite_flutter.dart';

final interpreter = await Interpreter.fromAsset("sentiment.tflite");
final input = List.generate(1, (_) => pad(tokenize(text), maxLen));
final output = List.filled(1 * 1, 0.0).reshape([1, 1]);
interpreter.run(input, output);
final score = output[0][0]; // interpret depending on model (sigmoid/softmax)

After inference, apply the same activation expected by your model (sigmoid -> threshold at 0.5, softmax -> argmax). Convert logits to a human label and present it in the UI.

Optimization and Deployment Tips

• Quantize: Post-training integer quantization reduces size and often improves CPU performance. For models using embeddings or transformers, ensure token inputs match quantized input types.

• Use delegates: Enable NNAPI on Android or Metal/GPU delegates to accelerate inference where available. tflite_flutter supports specifying delegates when creating the Interpreter.

• Batch and cache: For interactive apps, run inference on a background isolate to avoid UI jank and cache model and tokenizer objects.

• Model size vs. accuracy: MobileBERT or distilled transformer variants give good accuracy/size tradeoffs. For tiny apps, a small Conv1D/LSTM can be simpler to run and tokenize.

• Test edge cases: Non-English text, emojis, and punctuation handling must match training preprocessing.

Vibe Studio

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

Running sentiment analysis on-device with Flutter and TFLite is practical and performant when you align preprocessing, model inputs, and output interpretation. Use tflite_flutter to integrate the interpreter, implement deterministic tokenization in Dart (or bind a tokenizer), and optimize with quantization and delegates. With these steps you can deliver fast, private, and offline-capable sentiment features in your mobile app.