Zintegruj klasyfikator języka naturalnego

Interfejs API NLClassifier biblioteki zadań klasyfikuje tekst wejściowy na różne kategorie i jest wszechstronnym i konfigurowalnym interfejsem API, który może obsługiwać większość modeli klasyfikacji tekstu.

Kluczowe cechy API NLClassifier

• Pobiera pojedynczy ciąg jako dane wejściowe, dokonuje klasyfikacji za pomocą ciągu i wyjść pary jako wyniki klasyfikacji.

• Opcjonalna tokenizacja Regex dostępna dla tekstu wejściowego.

• Konfigurowalny w celu dostosowania różnych modeli klasyfikacji.

Obsługiwane modele NLClassifier

Gwarantujemy zgodność następujących modeli z interfejsem API NLClassifier .

• Model klasyfikacji sentymentu do recenzji filmów .

• Modele ze specyfikacją average_word_vec stworzone przez TensorFlow Lite Model Maker do klasyfikacji tekstu .

• Modele niestandardowe, które spełniają wymagania dotyczące zgodności modeli .

Uruchom wnioskowanie w Javie

Zobacz aplikację referencyjną klasyfikacji tekstu , aby zapoznać się z przykładem użycia NLClassifier w aplikacji na Androida.

Krok 1: Importuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu asset modułu Android, w którym będzie uruchamiany model. Określ, że plik nie powinien być skompresowany, i dodaj bibliotekę TensorFlow Lite do pliku build.gradle modułu:

android {
    // Other settings

    // Specify tflite file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }

}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.3.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

Krok 2: Uruchom wnioskowanie za pomocą interfejsu API

// Initialization, use NLClassifierOptions to configure input and output tensors
NLClassifierOptions options =
    NLClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setInputTensorName(INPUT_TENSOR_NAME)
        .setOutputScoreTensorName(OUTPUT_SCORE_TENSOR_NAME)
        .build();
NLClassifier classifier =
    NLClassifier.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Category> results = classifier.classify(input);

Zobacz kod źródłowy, aby uzyskać więcej opcji konfiguracji NLClassifier .

Uruchom wnioskowanie w Swift

Krok 1: Importuj CocoaPods

Dodaj tensorFlowLiteTaskText pod w pliku Podfile

target 'MySwiftAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskText', '~> 0.2.0'
end

Krok 2: Uruchom wnioskowanie za pomocą interfejsu API

// Initialization
var modelOptions:TFLNLClassifierOptions = TFLNLClassifierOptions()
modelOptions.inputTensorName = inputTensorName
modelOptions.outputScoreTensorName = outputScoreTensorName
let nlClassifier = TFLNLClassifier.nlClassifier(
      modelPath: modelPath,
      options: modelOptions)

// Run inference
let categories = nlClassifier.classify(text: input)

Więcej szczegółów znajdziesz w kodzie źródłowym .

Uruchom wnioskowanie w C++

// Initialization
NLClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
std::unique_ptr<NLClassifier> classifier = NLClassifier::CreateFromOptions(options).value();

// Run inference
std::vector<core::Category> categories = classifier->Classify(kInput);

Więcej szczegółów znajdziesz w kodzie źródłowym .

Przykładowe wyniki

Oto przykład wyników klasyfikacji modelu recenzji filmów .

Wejście: „Co za strata czasu”.

Wyjście:

category[0]: 'Negative' : '0.81313'
category[1]: 'Positive' : '0.18687'

Wypróbuj proste narzędzie demonstracyjne CLI dla NLClassifier z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności modelu

W zależności od przypadku użycia interfejs API NLClassifier może załadować model TFLite z metadanymi modelu TFLite lub bez niego . Zobacz przykłady tworzenia metadanych dla klasyfikatorów języka naturalnego za pomocą interfejsu API TensorFlow Lite Metadata Writer .

Kompatybilne modele powinny spełniać następujące wymagania:

• Tensor wejściowy: (kTfLiteString/kTfLiteInt32)

  • Dane wejściowe modelu powinny być albo nieprzetworzonym ciągiem wejściowym tensora kTfLiteString, albo tensorem kTfLiteInt32 dla indeksów tokenizowanych wyrażeń regularnych w nieprzetworzonym ciągu wejściowym.
  • Jeśli typ danych wejściowych to kTfLiteString, dla modelu nie są wymagane żadne metadane .
  • Jeśli typem danych wejściowych jest RegexTokenizer , należy skonfigurować RegexTokenizer w Metadata tensora wejściowego.

• Tensor wyniku wyjściowego: (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

  • Obowiązkowy tensor wyjściowy dla wyniku w każdej sklasyfikowanej kategorii.

  • Jeśli type jest jednym z typów Int, dekwantyzuj go, aby podwoić/pływać do odpowiednich platform

  • Może mieć opcjonalny skojarzony plik w odpowiednich metadanych tensora wyjściowego dla etykiet kategorii, plik powinien być zwykłym plikiem tekstowym z jedną etykietą w wierszu, a liczba etykiet powinna odpowiadać liczbie kategorii w danych wyjściowych modelu. Zobacz przykładowy plik etykiety .

• Tensor etykiety wyjściowej: (kTfLiteString/kTfLiteInt32)

  • Opcjonalny tensor wyniku dla etykiety dla każdej kategorii powinien mieć taką samą długość jak tensor wyniku wyniku. Jeśli tensor nie jest obecny, interfejs API używa indeksów wyników jako nazw klas.

  • Zostanie zignorowany, jeśli skojarzony plik etykiety jest obecny w metadanych tensora wyniku wyjściowego.