O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

Implementar o classificador de texto

O classificador de texto usa técnicas de aprendizado de máquina para ajudar os desenvolvedores classificar textos.

Classificador de texto da versão do Android 11

O Android 11 introduz um padrão atualizável implementação do serviço de classificador de texto na módulo ExtServices. Em dispositivos com o Android 11 ou superior, os getTextClassifier() retorna essa implementação padrão no módulo ExtServices. Recomendamos que os fabricantes de dispositivos usem essa implementação TextClassifierService, porque ele pode ser atualizado pelo OTA principal. atualizações.

O Android 11 também remove o classificador de texto local uma implementação padrão introduzida Android 8.1. Como resultado, getLocalTextClassifier() retorna um classificador de texto NO_OP. Em vez de anúncios da implementação, use o getDefaultTextClassifierImplementation() .

Para fabricantes de dispositivos que talvez queiram usar a própria classificação de texto algoritmos, eles podem implementar um serviço de classificador de texto personalizado especificando config_defaultTextClassifierPackage neste local: config.xml . Se essa configuração não for especificada, a implementação padrão do sistema é usado. Implementações personalizadas podem receber uma instância do padrão de implementação chamando TextClassifierService.getDefaultTextClassifierImplementation(Context) Para mais informações, consulte Como implementar um serviço de classificador de texto personalizado.

Teste

Para validar sua implementação do serviço de classificador de texto, use o método Testes do conjunto de teste de compatibilidade (CTS) em platform/cts/tests/tests/textclassifier/

Melhorias no classificador de texto da versão do Android 10

O Android 10 introduz dois métodos para a API TextClassifier: suggestConversationActions e detectLanguage. O método suggestConversationActions gera respostas sugeridas e ações de uma determinada conversa e o método detectLanguage detecta o idioma do texto.

Os arquivos de modelo para esses métodos são mostrados abaixo e podem ser encontrados em external/libtextclassifier/models/

suggestionConversationActions: actions_suggestions.universal.model
detectLanguage: lang_id.model

Para liberar um dispositivo com os arquivos de modelo mais recentes na imagem de fábrica, o seguinte:

Busque os arquivos de modelo mais recentes.

external/libtextclassifier/models/update.sh

Renomeie os arquivos baixados para substituir os atuais.

Verifique a configuração.

adb shell dumpsys textclassification

Este é um exemplo da saída desse comando.

TextClassifierImpl:
  Annotator model file(s):
    ModelFile { path=/etc/textclassifier/textclassifier.universal.model name=textclassifier.universal.model version=608 locales=und }
    ModelFile { path=/etc/textclassifier/textclassifier.en.model name=textclassifier.en.model version=608 locales=en }
  LangID model file(s):
    ModelFile { path=/etc/textclassifier/lang_id.model name=lang_id.model version=0 locales=und }
  Actions model file(s):
    ModelFile { path=/etc/textclassifier/actions_suggestions.universal.model name=actions_suggestions.universal.model version=0 locales=und }

Melhorias no classificador de texto da versão do Android 9

O Android 9 estendeu o texto framework de classificação introduzido no Android 8.1 com o novo texto serviço de classificação. O serviço de classificador de texto é a forma recomendada para OEMs para oferecer suporte ao sistema de classificação de texto. O serviço de classificador de texto pode fazer parte de qualquer APK do sistema e ser atualizado quando necessário.

O Android 9 inclui um classificador de texto padrão implementação do serviço ( TextClassifierImpl) que é usado, a menos que você o substitua por um serviço de classificador de texto personalizado implementação.

Implementar um serviço de classificador de texto personalizado

As seções a seguir descrevem como implementar um classificador de texto personalizado ou serviço que você desenvolve.

Estender android.service.textclassifier.TextClassifierService

public final class TextClassifierServiceImpl
        extends TextClassifierService {

    // Returns TextClassifierImpl.
    private final TextClassifier tc = getLocalTextClassifier();

    @Override
    public void onSuggestSelection(
            @Nullable TextClassificationSessionId sessionId,
            @NonNull TextSelection.Request request,
            @NonNull CancellationSignal cancellationSignal,
            @NonNull Callback<TextSelection> callback) {
        CompletableFuture.supplyAsync(
                () -> tc.suggestSelection(request))
                .thenAccept(r -> callback.onSuccess(r));
    }

    @Override
    public void onClassifyText(
            @Nullable TextClassificationSessionId sessionId,
		@NonNull TextClassification.Request request,
		@NonNull CancellationSignal cancellationSignal,
		@NonNull Callback<TextClassification> callback) {
        ...
    }

    @Override
    public void onGenerateLinks(
            @Nullable TextClassificationSessionId sessionId,
            @NonNull TextLinks.Request request,
            @NonNull CancellationSignal cancellationSignal,
            @NonNull Callback<TextLinks> callback) {
        ...
    }
    ...
}

Definir o serviço no manifesto do Android

[AndroidManifest.xml] (link em inglês)

<service android:name=".TextClassifierServiceImpl"
  android:permission="android.permission.BIND_TEXTCLASSIFIER_SERVICE">
    <intent-filter>
      <action android:name=
        "android.service.textclassifier.TextClassifierService"/>
    </intent-filter>
</service>

Observe que o serviço precisa exigir android.permission.BIND_TEXTCLASSIFIER_SERVICE e precisam especifique android.service.textclassifier.TextClassifierService intent à ação.

Definir um serviço de classificador de texto padrão do sistema na sobreposição de configuração

[config.xml]

<string name="config_defaultTextClassifierPackage" translatable="false">com.example.textclassifierservice</string>

Criar o serviço de classificador de texto na imagem do sistema

Seu serviço de classificador de texto personalizado pode ser um APK autônomo criado na imagem do sistema ou em parte de outro APK do sistema. O sistema usa PackageManager.MATCH_SYSTEM_ONLY para resolver o serviço.

Teste

Execute testes em android.view.textclassifier.cts.

Outras mudanças de classificação de texto no Android 9

Consulte Como inspecionar módulos de linguagem instalados.

Os arquivos modelo do Android 9 são incompatíveis com Arquivos modelo do Android 8.x.

Os arquivos modelo do Android 9 têm o padrão de nomenclatura: texclassifier.[language-code].model (por exemplo, textclassifier.en.model) em vez de textclassifier.smartselection.en.model no Android 8.x.

Conseguir os arquivos mais recentes do modelo de classificação de texto

Para ter os modelos mais atualizados, é possível executar o script a seguir, que atualiza os modelos de TextClassifier na árvore de origem:

external/libtextclassifier/native/models/update.sh

Classificador de texto da versão 8.1 do Android

O Android 8.1 introduziu a API TextClassfier para implementar textos classificação.

TextClassificationManager tcm =
    context.getSystemService(TextClassificationManager.class);
TextClassifier classifier = tcm.getTextClassifier();
TextSelection selection = classifier.suggestSelection(...);
TextClassification classification = classifier.classifyText(...);

Os desenvolvedores podem definir um classificador de texto personalizado:

tcm.setTextClassifier(customTextClassifier);

No entanto, se um desenvolvedor de apps definir o classificador de texto como null, um sistema classificador de texto padrão é retornado para getTextClassifier().

Consulte android.view.textclassifier.TextClassifierImpl.

TextView e WebView usam o TextClassifier para seleção e texto inteligentes compartilhar recursos.

Figura 1. Uso do TextClassifier

Modelos de rede neural do TextClassifier

O Android Open Source Project (AOSP) tem várias redes neurais modelos para classificação de textos. Cada arquivo de modelo é treinado para um único idioma. É possível instalar qualquer combinação de modelos. Os modelos são definidos em:

external/libtextclassifier/Android.mk

Idioma de pré-instalação modelos em dispositivos

É possível especificar um pacote de modelos de linguagem e instalá-los em um dispositivo:

# -----------------------
# Smart Selection bundles
# -----------------------

include $(CLEAR_VARS)
LOCAL_MODULE           := textclassifier.smartselection.bundle1
LOCAL_REQUIRED_MODULES := textclassifier.smartselection.en.model
LOCAL_REQUIRED_MODULES += textclassifier.smartselection.es.model
LOCAL_REQUIRED_MODULES += textclassifier.smartselection.de.model
LOCAL_REQUIRED_MODULES += textclassifier.smartselection.fr.model
include $(BUILD_STATIC_LIBRARY)

Por exemplo, em device/google/marlin/device-common.mk.

# TextClassifier smart selection model files
PRODUCT_PACKAGES += \
    textclassifier.smartselection.bundle1

Inspecionar o idioma instalado módulos

Use o adb para listar os arquivos no diretório:

$ adb shell ls -l /etc/textclassifier
-rw-r--r-- 1 root root ... textclassifier.smartselection.de.model
-rw-r--r-- 1 root root ... textclassifier.smartselection.en.model
-rw-r--r-- 1 root root ... textclassifier.smartselection.es.model
-rw-r--r-- 1 root root ... textclassifier.smartselection.fr.model

Atualizações do modelo

Os modelos podem ser atualizados com um novo modelo incluído como parte de um sistema atualização de imagem ou de forma dinâmica, com um componente do sistema que a uma atualização pelo sistema API ACTION_UPDATE_SMART_SELECTION intenção. Ao transmitir essa intent de API do sistema, o framework pode atualizar o modelo de idioma do idioma definido no momento. Os próprios modelos o idioma com suporte e um número de versão para que a atualização é usado.

Portanto, você não precisa pré-carregar modelos para todas as linguagens porque elas podem ser adicionadas mais tarde. Se nenhum arquivo de modelo for encontrado para o idioma especificado, a classificação de texto retorna valores de ambiente autônomo.

Testes do conjunto de teste de compatibilidade

Os testes do Conjunto de teste de compatibilidade (CTS) do Android podem ser encontrados em:

cts/tests/tests/view/src/android/view/textclassifier/cts/TextClassificationManagerTest.java

cts/tests/tests/widget/src/android/widget/cts/TextViewTest.java

testSmartSelection
testSmartSelection_dragSelection
testSmartSelection_resetSelection