Usando a Biblioteca Lingua para Kotlin
Tags: kotlin, nlp, backend, braziliandevs
Published: 2021-08-30 04:12:11

## Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade [Kotlinautas](https://twitter.com/kotlinautas/), uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

![capa Kotlinautas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jreawpvk6whxigcpmctf.png)

## O quê é "Processamento de Linguagem Natural"?

Processamento de linguagem natural (*NLP* em inglês) é uma tecnologia utilizada para que máquinas consigam "entender" linguagem humana. Dessa maneira, poderemos entender um texto que está sendo escrito e prever as proximas palavras que serão inseridas (como a pesquisa do Google), interpretar um texto e separar sentenças, descobrir quem é o sujeito de predicado,etc. **Permitindo que a pessoa usuária e a máquina se conectem, mesmo com a pessoa inserindo informações na sua própria língua.**

## Casos de Uso

Podemos usar *NLP* em chatbots, para identificar que reposta que iremos retornar em um chat, em tradutores, em motores de busca, em sistemas de reconhecimento de voz, etc. Você com certeza já usou *NLP* diversas vezes só hoje.

## Lingua

[Lingua](https://github.com/pemistahl/lingua) é uma biblioteca que utiliza *NLP* para receber um texto, e identificar em qual língua esse texto foi escrito. Podendo desde responder com uma única língua, ou responder com uma lista das línguas mais prováveis desse texto em ordem de probabilidade. Isso pode ser feito em mais de 70 línguas que a Lingua dá suporte.

Lingua é uma biblioteca muito interessante pois ela consegue identificar textos menores que até mesmo um tweet. Frases curtas como `eu gosto de línguas` podem ser processadas e identificadas com altíssimo índice de acerto. Além disso, a Lingua não precisa de configuração. Você pode apenas adicionar a língua como dependência no projeto e começar a usar.

## Criando projeto

Abra seu IntelliJ no menu inicial e clique em *New Project*:

![botão New Project no menu inicial do IntelliJ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/un2csz5urox7cyu11z72.png)

Depois, selecione a opção **Kotlin DSL build script**, selecione também a opção **Kotlin/JVM**, e opicionalmente remova a primeira opção **Java**. Essa opção não vai mudar em nada, pois ela dá suporte do Gradle á linguagem Java, mas apenas iremos usar Kotlin.

Após isso, clique em **Next** e escreva o nome do projeto e a localização na sua máquina. Essas duas opção são completamente pessoais, caso não tenha nenhuma ideia, coloque algo como **Lingua** apenas como identificação.

Agora, com o projeto aberto, vá ao aquivo `build.gradle.kts` e adicione a dependência `implementation("com.github.pemistahl:lingua:1.1.0")`, com a seção `dependencies` ficando assim:

```kotlin
dependencies {
    implementation(kotlin("stdlib"))
    implementation("com.github.pemistahl:lingua:1.1.0")
}
```

Agora, clique no elefante no canto superior direito para carregar as alterações no Gradle.

![Elefante do Gradle no canto superior direito](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xxpoxutbowthbpp4n2m1.png)

Após isso, poderemos começar a programar. Você pode criar um arquivo em `src/main/kotlin/` chamado `main.kt` para ser o arquivo principal da aplicação.

Mas com qualquer nome de arquivo, como você irá usar a Lingua, sempre se lembre de importar a biblioteca no começo do arquivo:

```kotlin
import com.github.pemistahl.lingua.api.*
import com.github.pemistahl.lingua.api.Language.*
```

## Usando Lingua

Agora, vamos começar a utilizar a biblioteca Lingua, primeiro, iremos precisar criar uma variável chamada `detector`, essa variável irá iniciar a Lingua, selecionando quais serão as línguas utilizadas no processamento. Podemos criar essa variável da seguinte forma:

```kotlin
import com.github.pemistahl.lingua.api.*
import com.github.pemistahl.lingua.api.Language.*

fun main(){
	val detector: LanguageDetector = LanguageDetectorBuilder
		.fromLanguages(ENGLISH, FRENCH, PORTUGUESE, SPANISH)
		.build()
}
```

- Primeiro, usamos a classe `LanguageDetectorBuilder` que irá criar esse detector de línguas;
- Depois, usamso o método `.fromLanguages` para selecionar as línguas que serão utilizadas, que no caso serão quatro, inglês, francês, português e espanhol.
- Após isso, é usado o método `.build()` para criar esse objeto.

Agora já temos o detector, e podemos passar um texto, e esse texto será processado, e identificado em alguma das quatro línguas acima:

```kotlin
import com.github.pemistahl.lingua.api.*
import com.github.pemistahl.lingua.api.Language.*

fun main(){
	val detector: LanguageDetector = LanguageDetectorBuilder
		.fromLanguages(ENGLISH, FRENCH, PORTUGUESE, SPANISH)
		.build()

	val linguaDetectada = detector.detectLanguageOf("Estou começando a usar a biblioteca língua. Será que esse texto é em português?")

	println(linguaDetectada)
}
```

- Estamos usando o método `.detectLanguageOf` que recebe um texto, sendo esse o texto que será identificado, com a língua sendo armazenada dentro da variável `linguaDetectada`;
- Depois disso, mostramos a língua na tela;

Quando você rodar esse código, o resultado mostrado na tela será:

```
PORTUGUESE
```

É mostrado esse resultado pois no texto a língua detectada é exatamente o português. Com isso o algoritmo da Lingua acertou exatamente a língua do texto.

Podemos também criar uma lista, mostrando as línguas que tem maior e menor chance de ser a língua desse texto. Isso pode ser feito com o método `.computeLanguageConfidenceValues`. Podemos usar esse método da seguinte maneira:

```kotlin
fun main(){
	val detector: LanguageDetector = LanguageDetectorBuilder
		.fromLanguages(ENGLISH, FRENCH, PORTUGUESE, SPANISH)
		.build()

	val linguaDetectada = detector.computeLanguageConfidenceValues("Estou começando a usar a biblioteca língua. Será que esse texto é em português?")

	println(linguaDetectada)
}
```

- A função `computeLanguageConfidenceValues` tem o mesmo argumento da `detectLanguageOf`, que é o texto a ser analizado;

Agora, teremos uma lista com as prováveis línguas que esse texto seja, ordenadas na mais provável para a menos provável:

```
{PORTUGUESE=1.0, SPANISH=0.7533817345429001, ENGLISH=0.6853709481080371, FRENCH=0.6316653148025655}
```

Podemos também ao invés de informarmos uma lista de línguas, podemos fazer a análise com todas as línguas que a Lingua consegue processar. Isso pode ser feito mudando a variável `detector` dessa maneira:

```kotlin
fun main(){
	val detector: LanguageDetector = LanguageDetectorBuilder
		.fromAllLanguages()
		.build()

	val linguaDetectada = detector.computeLanguageConfidenceValues("Estou começando a usar a biblioteca língua. Será que esse texto é em português?")

	println(linguaDetectada)
}
```

- Removemos a função `fromLanguages` e substituimos pela `fromAllLanguages`, que irá pegar todas as línguas e por isso não precisa de argumentos.

> De preferência, feche todas as aplicações do seu computador e deixe apenas o IntelliJ, pois agora o nosso programa poderá ficar bem pesado para sua memória RAM.

Agora, o retorno será uma grande lista de línguas, mas ainda com o português em primeiro lugar.

```
{PORTUGUESE=1.0, SPANISH=0.7533817345429001, YORUBA=0.7495972792428622, ALBANIAN=0.7181027290765049, CATALAN=0.713746802338343, LATIN=0.6949754472995734, TAGALOG=0.6855063895430864, ENGLISH=0.6853709481080371, ROMANIAN=0.6794936591332706, ITALIAN=0.6679173253169968, SWEDISH=0.6601556689403092, BASQUE=0.6524281569565098, DANISH=0.6519314825344154, AFRIKAANS=0.6499902584538891, CZECH=0.6471280826934549, WELSH=0.6406157240966261, BOSNIAN=0.6397286926412864, ICELANDIC=0.6375697488364883, POLISH=0.6325828791411097, FRENCH=0.6316653148025655, NYNORSK=0.6307779434025214, SWAHILI=0.6279318102474027, LITHUANIAN=0.6269975003513142, ESPERANTO=0.6234916413320327, SLOVAK=0.6114905517288393, FINNISH=0.6048521121567952, SOTHO=0.6030870258335201, GERMAN=0.6028332795451541, DUTCH=0.6007067324050409, IRISH=0.595419190487028, LATVIAN=0.5902925445832143, MALAY=0.5841479746403336, SHONA=0.5811403984841593, CROATIAN=0.5780762123163256, TURKISH=0.5775996331873134, INDONESIAN=0.5749472873862232, HUNGARIAN=0.569379868410504, VIETNAMESE=0.5687304563494823, SLOVENE=0.5684356556401108, MAORI=0.5647527386017551, TSONGA=0.5633425742452374, ZULU=0.5619719968144339, ESTONIAN=0.5581386236360275, AZERBAIJANI=0.5546925581038766, BOKMAL=0.5457814306784645, GANDA=0.5370050699185562, XHOSA=0.5287626938082827, TSWANA=0.5204769697324829, SOMALI=0.5066240947958117}
```

Há outros métodos que podem ser usados para selecionar as línguas que serão utilizadas, como esses:

- `.fromAllSpokenLanguages()` - Seleciona todas as línguas faladas atualmente (remove apenas Latim)
- `.fromAllLanguagesWithCyrillicScript()` - Seleciona apenas as línguas com [Alfabeto Cirílico](https://pt.wikipedia.org/wiki/Alfabeto_cir%C3%ADlico)
- `.fromAllLanguagesWithout(LINGUA)` - Seleciona todas as línguas execeto uma ou mais línguas, sendo o contrário do `fromAllLanguages`

Também podemos determinar uma distância mínima entre a língua com mais chance de ser do texto, e da segunda língua com mais chances de ser do texto. Não há tanta necessidade de mudar esse valor, pois quanto menor o valor, mais vezes a língua do texto será informada de maneira incorreta, e quando maior esse valor, mais vezes o valor será indeterminado, com isso não terá nenhuma língua como resultado.

Para determinar essa distância, podemos usar o método `.withMinimumRelativeDistance`, dessa maneira:

```kotlin
fun main(){
	val detector: LanguageDetector = LanguageDetectorBuilder
		.fromLanguages(ENGLISH, FRENCH, PORTUGUESE, SPANISH)
		.withMinimumRelativeDistance(0.3)
		.build()

	val linguaDetectada = detector.detectLanguageOf("Estou começando a usar a biblioteca língua. Será que esse texto é em português?")

	println(linguaDetectada)
}
```

- a função `withMinimumRelativeDistance` recebe um número decimal, sendo essa a distância entre a 1º e 2º língua;

Caso você tente rodar esse código, o resultado será:

```
UNKNOWN
```

O resultado foi `UNKNOWN` pois a distância entre a 1º e a 2º língua foram menores que 0.3. Por isso, que um `.withMinimumRelativeDistance` alto é melhor para textos grandes que possa ser tirado mais dados sobre.

## Finalização

Neste artigo você aprendeu o básico sobre a biblioteca Lingua, que identifica línguas em textos com uso simples. Caso esse artigo tenha sido útil para você, deixe um coração ou um unicórnio nesse post!

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo [@lissatransborda](https://twitter.com/lissatransborda) 👀