Unlock the Power of Named Entity Recognition using TFLite on Android

Are you tired of manually extracting valuable information from unstructured text data? Do you want to build an Android app that can automatically identify and extract specific entities like names, locations, and organizations from user input? Look no further! In this comprehensive guide, we’ll explore the world of Named Entity Recognition (NER) using TensorFlow Lite (TFLite) on Android, and show you how to create a powerful and efficient NER model that can supercharge your Android app.

What is Named Entity Recognition?

Named Entity Recognition is a sub-task of Natural Language Processing (NLP) that involves identifying and categorizing named entities in unstructured text into predefined categories such as:

• Person: Names of individuals, e.g., John Smith
• Organization: Names of companies, institutions, and organizations, e.g., Google, NASA
• Location: Names of cities, countries, and addresses, e.g., New York, Tokyo, 123 Main Street
• Event: Names of events, e.g., World Cup, Olympics
• Date: Dates and times, e.g., January 1, 2022, 12:00 PM

NER is a fundamental step in many NLP applications, including information retrieval, sentiment analysis, and text summarization. With the rise of mobile devices, NER on Android has become increasingly important for building intelligent and personalized apps.

Why Use TFLite for NER on Android?

TensorFlow Lite is a lightweight, open-source framework for deploying machine learning models on mobile and embedded devices. TFLite provides several benefits for NER on Android, including:

• Fast inference speed: TFLite’s optimized models and TensorFlow’s XLA compiler enable fast inference on Android devices.
• Low latency: TFLite’s models are designed to run on-device, reducing latency and improving real-time performance.
• Small model size: TFLite’s models are compressed and optimized for mobile devices, reducing storage requirements and memory usage.
• Hardware acceleration: TFLite takes advantage of Android’s Neural Networks API (NNAPI) to accelerate model inference on supported devices.

Building an NER Model with TensorFlow

Before we dive into TFLite, let’s build a basic NER model using TensorFlow. We’ll use the popular spaCy library and the CoNLL-2003 dataset to train our model.

import pandas as pd
import numpy as np
import spacy
from spacy.training import Example
from sklearn.model_selection import train_test_split

# Load the CoNLL-2003 dataset
train_data = pd.read_csv("conll2003/en/ner/train.txt", header=None, names=["text", "label"])
test_data = pd.read_csv("conll2003/en/ner/test.txt", header=None, names=["text", "label"])

# Split the data into training and testing sets
train_text, val_text, train_labels, val_labels = train_test_split(train_data["text"], train_data["label"], test_size=0.2, random_state=42)

# Create a spaCy model and processing pipeline
nlp = spacy.load("en_core_web_sm")
pipeline = nlp.create_pipe("ner")

# Add the NER component to the pipeline
nlp.add_pipe(pipeline)

# Train the model
for i in range(10):
    losses = {}
    for text, annotations in zip(train_text, train_labels):
        example = Example.from_dict(nlp.make_doc(text), annotations)
        nlp.update([example], losses=losses)

    print("Loss:", losses["ner"])

# Evaluate the model
test_pred = []
for text in test_text:
    doc = nlp(text)
    test_pred.extend([entity.label_ for entity in doc.ents])

print("F1-score:", f1_score(test_labels, test_pred, average="macro"))

import tensorflow as tf

# Load the trained spaCy model
nlp = spacy.load("en_core_web_sm")

# Create a TensorFlow model from the spaCy model
tf_model = tf.keras.models.Model(inputs=nlp.get_input_specs()[0]["tensor_shape"], outputs=nlp.get_output_specs()[0]["tensor_shape"])

# Convert the TensorFlow model to TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(tf_model)
tflite_model = converter.convert()

# Save the TFLite model to a file
with open("ner_model.tflite", "wb") as f:
    f.write(tflite_model)

// Load the TFLite model
TensorFlowLite tensorFlowLite = new TensorFlowLite();

// Initialize the model
TensorFlowLite.Model model = tensorFlowLite.LoadFromFile("ner_model.tflite");

// Create an input tensor
TensorFlowLite.Tensor inputTensor = tensorFlowLite.CreateTensorFloat32(new int[] { 1, 1, 1, 100 }); // batch size, sequence length, embedding size

// Create an output tensor
TensorFlowLite.Tensor outputTensor = tensorFlowLite.CreateTensorFloat32(new int[] { 1, 100, 9 }); // batch size, sequence length, num entities

// Run the model inference
tensorFlowLite.Run(model, inputTensor, outputTensor);

// Get the user input
EditText userInputEditText = findViewById(R.id.user_input);
String userInputText = userInputEditText.getText().toString();

// Preprocess the input text
String[] tokens = userInputText.split("\\s+");
float[] inputArray = new float[tokens.length * 100];
for (int i = 0; i < tokens.length; i++) {
    inputArray[i * 100] = Float.parseFloat(tokens[i]);
}

// Create a tensor from the input array
TensorBuffer inputTensorBuffer = TensorBuffer.createFixedSize(new int[] { 1, 1, 100 }, DataType.FLOAT32);
inputTensorBuffer.loadArray(inputArray);

// Run the model inference
tflite.run(inputTensorBuffer, outputTensorBuffer);

// Get the output tensor
float[] outputArray = outputTensorBuffer.getFloatArray();

// Extract the entities from the output
List<String> entities = new ArrayList<>();
for (int i = 0; i < outputArray.length; i++) {
    if (outputArray[i] > 0.5f) {
        entities.add(tokens[i / 9]);
    }
}

// Display the extracted entities
TextView entitiesTextView = findViewById(R.id.entities);
entitiesTextView.setText("Extracted Entities: " + entities.toString());