Initial implementation of fasttext for language identification

Author: niedev

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "app/src/main/cpp/src/libs/protobuf-lite"]
 	path = app/src/main/cpp/src/libs/protobuf-lite
 	url = https://github.com/niedev/protobuf
+[submodule "app/src/main/cpp/src/fasttext/libs/fastText"]
+	path = app/src/main/cpp/src/fasttext/libs/fastText
+	url = https://github.com/niedev/fastText

app/build.gradle

@@ -129,6 +129,8 @@ dependencies {
     implementation "ai.djl.android:core:0.33.0"
     implementation "ai.djl.huggingface:tokenizers:0.33.0"
     implementation "ai.djl.android:tokenizer-native:0.33.0"
+    // DJL fasttext wrapper
+    implementation 'ai.djl.fasttext:fasttext-engine:0.33.0'
     //protobuf
     implementation "com.google.protobuf:protobuf-javalite:4.33.5"
     // bouncycastle crypto lib
@@ -145,7 +147,7 @@ dependencies {
     implementation 'com.microsoft.onnxruntime:onnxruntime-android:1.23.2'  //latest.release
     implementation 'com.microsoft.onnxruntime:onnxruntime-extensions-android:0.13.0'   //latest.release
     //Ml-Kit
-    implementation 'com.google.mlkit:language-id:17.0.5'
+    //implementation 'com.google.mlkit:language-id:17.0.5'
     //JWS parser
     implementation group: 'com.nimbusds', name: 'nimbus-jose-jwt', version: '5.1'
     implementation files('libs/sqlite4java-android-release.aar')

app/src/main/assets/fasttext.ftz

@@ -64,4 +64,5 @@ target_link_libraries(cache_container_native
         log
 )
 
-add_subdirectory(bergamot_translator)
+add_subdirectory(bergamot_translator)
+add_subdirectory(fasttext)

app/src/main/cpp/src/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Grab all fastText C++ source files
+file(GLOB FASTTEXT_SRC "libs/fastText/src/*.cc")
+
+# Exclude main.cc (contains the CLI tool's main() function, which will cause a build error)
+list(REMOVE_ITEM FASTTEXT_SRC "${CMAKE_CURRENT_SOURCE_DIR}/libs/fastText/src/main.cc")
+
+# Create your shared library, compiling your JNI wrapper AND the fastText source
+add_library(
+        fasttext-lib
+        SHARED
+        FastTextWrapper.cpp
+        ${FASTTEXT_SRC}
+)
+
+# Link standard Android logging
+find_library(log-lib log)
+target_link_libraries(fasttext-lib ${log-lib})

app/src/main/cpp/src/fasttext/CMakeLists.txt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2016 Luca Martino.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copyFile of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+#include <string>
+#include <sstream>
+#include "libs/fastText/src/fasttext.h"
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_nie_translator_rtranslator_voice_1translation_neural_1networks_translation_LanguageDetector_initFastText(JNIEnv* env, jobject /* this */) {
+    // Return a pointer to the native FastText object
+    auto* ft = new fasttext::FastText();
+    return reinterpret_cast<jlong>(ft);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_nie_translator_rtranslator_voice_1translation_neural_1networks_translation_LanguageDetector_loadModel(JNIEnv* env, jobject /* this */, jlong ptr, jstring path) {
+    auto* ft = reinterpret_cast<fasttext::FastText*>(ptr);
+    const char* pathStr = env->GetStringUTFChars(path, nullptr);
+
+    // Load the .bin or .ftz model
+    ft->loadModel(pathStr);
+    env->ReleaseStringUTFChars(path, pathStr);
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_nie_translator_rtranslator_voice_1translation_neural_1networks_translation_LanguageDetector_predictLanguage(JNIEnv* env, jobject /* this */, jlong ptr, jstring text, jdouble confidenceThreshold) {
+    auto* ft = reinterpret_cast<fasttext::FastText*>(ptr);
+    const char* textStr = env->GetStringUTFChars(text, nullptr);
+
+    std::stringstream ioss(textStr);
+    std::vector<std::pair<fasttext::real, std::string>> predictions;
+
+    // Predict the single most likely language (k = 1)
+    ft->predictLine(ioss, predictions, 1, confidenceThreshold);
+    env->ReleaseStringUTFChars(text, textStr);
+
+    if (!predictions.empty()) {
+        std::string label = predictions[0].second;
+        // fastText returns labels like "__label__en". We strip the prefix.
+        std::string prefix = "__label__";
+        if (label.find(prefix) == 0) {
+            label = label.substr(prefix.length());
+        }
+        return env->NewStringUTF(label.c_str());
+    }
+
+    return env->NewStringUTF("und");
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_nie_translator_rtranslator_voice_1translation_neural_1networks_translation_LanguageDetector_release(JNIEnv* env, jobject /* this */, jlong ptr) {
+    auto* ft = reinterpret_cast<fasttext::FastText*>(ptr);
+    delete ft; // Prevent memory leaks
+}

app/src/main/cpp/src/fasttext/FastTextWrapper.cpp

@@ -0,0 +1,87 @@
+package nie.translator.rtranslator.voice_translation.neural_networks.translation;
+
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Paths;
+
+import ai.djl.ModelException;
+import ai.djl.inference.Predictor;
+import ai.djl.modality.Classifications;
+import ai.djl.repository.zoo.Criteria;
+import ai.djl.repository.zoo.ZooModel;
+import ai.djl.translate.TranslateException;
+import nie.translator.rtranslator.voice_translation.neural_networks.NeuralNetworkApiResult;
+
+public class LanguageDetector {
+    // Load the C++ library
+    static {
+        System.loadLibrary("fasttext-lib");
+    }
+
+
+    private static final String TAG = "LanguageDetector";
+    private static final String MODEL_FILE_NAME = "fasttext.ftz";
+
+    private ZooModel<String, Classifications> model;
+    private Predictor<String, Classifications> predictor;
+
+    private long nativePtr = 0;
+    private Context context;
+
+    /**
+     * Initializes the detector. Call this from a background thread during app startup.
+     */
+    public void initialize(Context context) throws IOException, ModelException {
+        File modelFile = new File(context.getFilesDir(), MODEL_FILE_NAME);
+
+        this.context = context;
+        this.nativePtr = initFastText();
+
+        loadModel(nativePtr, modelFile.getAbsolutePath());
+    }
+
+    /**
+     * Predicts the language of a given text string.
+     */
+    public void detectLanguage(String text, double confidenceThreshold, @NonNull DetectLanguageListener listener) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (nativePtr == 0) {
+                        Log.e(TAG, "Model not initialized.");
+                        listener.onSuccess("und");
+                    }
+                    listener.onSuccess(predictLanguage(nativePtr, text));
+
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    Log.e(TAG, "Failed to predict language", e);
+                    listener.onSuccess("und");
+                }
+            }
+        }).start();
+    }
+
+    public abstract static class DetectLanguageListener {
+        public abstract void onSuccess(String languageCode);
+    }
+
+    public void close() {
+        if (nativePtr != 0) {
+            release(nativePtr);
+            nativePtr = 0;
+        }
+    }
+
+
+    private native long initFastText();
+    private native void loadModel(long ptr, String path);
+    private native String predictLanguage(long ptr, String text, double confidenceThreshold);
+    private native void release(long ptr);
+}