github.com/burakson/lingua-go

1. What does this library do?

Its task is simple: It tells you which language some text is written in. This is very useful as a preprocessing step for linguistic data in natural language processing applications such as text classification and spell checking. Other use cases, for instance, might include routing e-mails to the right geographically located customer service department, based on the e-mails' languages.

2. Why does this library exist?

Language detection is often done as part of large machine learning frameworks or natural language processing applications. In cases where you don't need the full-fledged functionality of those systems or don't want to learn the ropes of those, a small flexible library comes in handy.

So far, the only other comprehensive open source library in the Go ecosystem for this task is Whatlanggo. Unfortunately, it has two major drawbacks:

1. Detection only works with quite lengthy text fragments. For very short text snippets such as Twitter messages, it does not provide adequate results.
2. The more languages take part in the decision process, the less accurate are the detection results.

Lingua aims at eliminating these problems. She nearly does not need any configuration and yields pretty accurate results on both long and short text, even on single words and phrases. She draws on both rule-based and statistical methods but does not use any dictionaries of words. She does not need a connection to any external API or service either. Once the library has been downloaded, it can be used completely offline.

3. Which languages are supported?

Compared to other language detection libraries, Lingua's focus is on quality over quantity, that is, getting detection right for a small set of languages first before adding new ones. Currently, the following 75 languages are supported:

• A
  • Afrikaans
  • Albanian
  • Arabic
  • Armenian
  • Azerbaijani
• B
  • Basque
  • Belarusian
  • Bengali
  • Norwegian Bokmal
  • Bosnian
  • Bulgarian
• C
  • Catalan
  • Chinese
  • Croatian
  • Czech
• D
  • Danish
  • Dutch
• E
  • English
  • Esperanto
  • Estonian
• F
  • Finnish
  • French
• G
  • Ganda
  • Georgian
  • German
  • Greek
  • Gujarati
• H
  • Hebrew
  • Hindi
  • Hungarian
• I
  • Icelandic
  • Indonesian
  • Irish
  • Italian
• J
  • Japanese
• K
  • Kazakh
  • Korean
• L
  • Latin
  • Latvian
  • Lithuanian
• M
  • Macedonian
  • Malay
  • Maori
  • Marathi
  • Mongolian
• N
  • Norwegian Nynorsk
• P
  • Persian
  • Polish
  • Portuguese
  • Punjabi
• R
  • Romanian
  • Russian
• S
  • Serbian
  • Shona
  • Slovak
  • Slovene
  • Somali
  • Sotho
  • Spanish
  • Swahili
  • Swedish
• T
  • Tagalog
  • Tamil
  • Telugu
  • Thai
  • Tsonga
  • Tswana
  • Turkish
• U
  • Ukrainian
  • Urdu
• V
  • Vietnamese
• W
  • Welsh
• X
  • Xhosa
• Y
  • Yoruba
• Z
  • Zulu

4. How good is it?

Lingua is able to report accuracy statistics for some bundled test data available for each supported language. The test data for each language is split into three parts:

1. a list of single words with a minimum length of 5 characters
2. a list of word pairs with a minimum length of 10 characters
3. a list of complete grammatical sentences of various lengths

Both the language models and the test data have been created from separate documents of the Wortschatz corpora offered by Leipzig University, Germany. Data crawled from various news websites have been used for training, each corpus comprising one million sentences. For testing, corpora made of arbitrarily chosen websites have been used, each comprising ten thousand sentences. From each test corpus, a random unsorted subset of 1000 single words, 1000 word pairs and 1000 sentences has been extracted, respectively.

Given the generated test data, I have compared the detection results of Lingua and Whatlanggo running over the data of Lingua's supported 75 languages. Additionally, I have added Google's CLD3 to the comparison with the help of the gocld3 bindings. Languages that are not supported by CLD3 or Whatlanggo are simply ignored during the detection process.

Each of the following sections contains two plots. The bar plot shows the detailed accuracy results for each supported language. The box plot illustrates the distributions of the accuracy values for each classifier. The boxes themselves represent the areas which the middle 50 % of data lie within. Within the colored boxes, the horizontal lines mark the median of the distributions.

4.1 Single word detection

Bar plot

4.2 Word pair detection

Bar plot

4.3 Sentence detection

Bar plot

4.4 Average detection

Bar plot

4.5 Mean, median and standard deviation

The table below shows detailed statistics for each language and classifier including mean, median and standard deviation.

Open table

Language	Average	Single Words	Word Pairs	Sentences
	Lingua (high accuracy mode)	Lingua (low accuracy mode)	CLD3	Whatlang	Lingua (high accuracy mode)	Lingua (low accuracy mode)	CLD3	Whatlang	Lingua (high accuracy mode)	Lingua (low accuracy mode)	CLD3	Whatlang	Lingua (high accuracy mode)	Lingua (low accuracy mode)	CLD3	Whatlang
Afrikaans	79	64	55	51	58	38	22	21	81	62	46	39	97	93	98	92
Albanian	88	80	55	-	69	54	18	-	95	86	48	-	100	99	98	-
Arabic	98	94	90	89	96	88	79	77	99	96	92	91	100	99	100	99
Armenian	100	100	99	-	100	100	100	-	100	100	100	-	100	100	97	-
Azerbaijani	90	82	81	64	77	71	62	45	92	78	82	58	99	96	99	91
Basque	84	75	62	-	71	56	33	-	87	76	62	-	93	92	92	-
Belarusian	97	92	84	81	92	80	67	64	99	95	86	80	100	100	100	98
Bengali	100	100	99	100	100	100	98	100	100	100	99	100	100	100	99	100
Bokmal	58	50	-	34	39	27	-	15	59	47	-	28	77	75	-	60
Bosnian	35	29	33	-	29	23	19	-	35	29	28	-	41	36	52	-
Bulgarian	87	78	70	61	70	56	45	37	91	81	66	57	99	96	98	89
Catalan	70	58	48	-	51	33	19	-	74	60	42	-	87	82	84	-
Chinese	100	100	92	100	100	100	92	100	100	100	83	100	100	100	100	100
Croatian	73	60	42	55	53	36	26	28	74	57	42	44	90	86	58	91
Czech	80	71	64	50	66	54	39	31	84	72	65	46	91	87	88	71
Danish	81	70	58	47	61	45	26	24	84	70	54	38	98	95	95	79
Dutch	77	64	58	47	55	36	29	22	81	61	47	36	96	94	97	82
English	81	63	54	49	55	29	22	17	89	62	44	35	99	97	97	94
Esperanto	84	66	57	52	67	44	22	25	85	61	51	45	98	93	98	88
Estonian	92	83	70	61	80	62	41	36	96	88	69	53	100	99	99	94
Finnish	96	91	80	71	90	77	58	45	98	95	84	70	100	100	99	98
French	89	77	55	64	74	52	22	37	94	83	49	59	99	98	94	97
Ganda	91	84	-	-	79	65	-	-	95	87	-	-	100	100	-	-
Georgian	100	100	98	100	100	100	99	100	100	100	100	100	100	100	96	100
German	89	80	66	65	74	57	40	38	94	84	62	60	100	99	98	97
Greek	100	100	100	100	100	100	100	100	100	100	100	100	100	100	100	100
Gujarati	100	100	100	100	100	100	99	100	100	100	100	100	100	100	100	100
Hebrew	100	100	-	90	100	100	-	76	100	100	-	94	100	100	-	99
Hindi	73	33	58	52	61	11	34	27	64	20	45	40	95	67	95	88
Hungarian	95	90	76	62	87	77	53	37	98	94	76	53	100	100	99	95
Icelandic	93	88	71	-	83	72	42	-	97	92	70	-	100	99	99	-
Indonesian	61	47	46	67	39	25	26	39	61	46	45	66	83	71	66	95
Irish	91	85	67	-	82	70	42	-	94	90	66	-	96	95	94	-
Italian	87	71	62	56	69	42	31	25	92	74	57	47	100	98	98	96
Japanese	100	100	98	99	100	100	97	100	100	100	96	100	100	100	100	97
Kazakh	92	90	82	-	80	78	62	-	96	93	83	-	99	99	99	-
Korean	100	100	99	100	100	100	100	100	100	100	100	100	100	100	98	100
Latin	87	73	62	-	72	49	44	-	93	76	58	-	97	94	83	-
Latvian	93	87	75	59	85	75	51	36	97	90	77	54	99	97	98	87
Lithuanian	95	87	72	62	86	76	42	38	98	89	75	56	100	98	99	92
Macedonian	84	72	60	62	66	52	30	39	86	70	54	55	99	95	97	94
Malay	31	31	22	-	26	22	11	-	38	36	22	-	28	35	34	-
Maori	91	82	52	-	82	62	22	-	92	87	43	-	99	98	91	-
Marathi	85	39	84	73	74	16	69	52	85	30	84	74	96	72	98	93
Mongolian	97	95	83	-	93	89	63	-	99	98	87	-	99	99	99	-
Nynorsk	66	52	-	34	41	25	-	10	66	49	-	24	91	81	-	69
Persian	90	80	76	70	78	62	57	46	94	80	70	66	100	98	99	99
Polish	95	90	77	66	85	77	51	45	98	93	80	59	100	99	99	94
Portuguese	81	69	53	57	59	42	21	26	85	70	40	48	99	95	97	96
Punjabi	100	100	100	100	100	100	99	100	100	100	100	100	100	100	100	100
Romanian	87	72	53	59	69	49	24	34	92	74	48	52	99	94	88	90
Russian	90	78	71	53	76	59	48	40	95	84	72	52	98	92	93	68
Serbian	88	78	78	57	74	62	63	34	90	80	75	51	99	91	95	86
Shona	91	81	76	68	78	56	51	44	96	86	79	65	100	100	99	95
Slovak	84	75	63	-	64	49	32	-	90	78	61	-	99	97	96	-
Slovene	82	67	63	48	61	39	29	25	87	68	60	38	99	93	99	81
Somali	92	85	69	68	82	64	38	38	96	90	70	66	100	100	100	99
Sotho	86	72	49	-	67	43	15	-	90	75	33	-	100	97	98	-
Spanish	70	56	48	48	44	26	16	19	69	49	32	33	97	94	96	93
Swahili	81	70	57	-	60	43	25	-	84	68	49	-	98	97	98	-
Swedish	84	72	61	49	64	46	30	24	88	76	56	40	99	94	96	83
Tagalog	78	66	-	52	52	36	-	23	83	67	-	43	98	96	-	90
Tamil	100	100	100	100	100	100	100	100	100	100	100	100	100	100	99	100
Telugu	100	100	99	100	100	100	99	100	100	100	100	100	100	100	99	100
Thai	100	100	99	100	100	100	100	100	100	100	100	100	100	100	98	99
Tsonga	84	72	-	-	66	46	-	-	89	73	-	-	98	97	-	-
Tswana	84	71	-	-	65	44	-	-	88	73	-	-	99	96	-	-
Turkish	94	87	69	54	84	71	41	26	98	91	70	44	100	100	97	92
Ukrainian	92	86	81	72	84	75	62	53	97	92	83	71	95	93	98	93
Urdu	91	80	61	57	80	65	39	31	94	78	53	46	98	96	92	94
Vietnamese	91	87	66	73	79	76	26	36	94	87	74	85	99	98	99	97
Welsh	91	82	69	-	78	61	43	-	96	87	66	-	99	99	98	-
Xhosa	82	69	66	-	64	45	40	-	85	67	65	-	98	94	92	-
Yoruba	74	62	15	22	50	33	5	11	77	61	11	14	96	92	28	41
Zulu	81	70	63	70	62	45	35	44	83	72	63	68	97	94	92	98
Mean	86	77	69	67	74	61	48	48	89	78	67	63	96	93	93	91
Median	89.0	80.0	68.0	62.0	74.0	57.0	41.0	38.0	94.0	81.0	66.0	57.0	99.0	97.0	98.0	94.0
Standard Deviation	13.08	17.29	19.04	20.22	18.41	24.9	27.86	29.28	13.12	18.93	21.83	24.22	11.05	11.91	13.95	11.24

5. Why is it better than other libraries?

Every language detector uses a probabilistic n-gram model trained on the character distribution in some training corpus. Most libraries only use n-grams of size 3 (trigrams) which is satisfactory for detecting the language of longer text fragments consisting of multiple sentences. For short phrases or single words, however, trigrams are not enough. The shorter the input text is, the less n-grams are available. The probabilities estimated from such few n-grams are not reliable. This is why Lingua makes use of n-grams of sizes 1 up to 5 which results in much more accurate prediction of the correct language.

A second important difference is that Lingua does not only use such a statistical model, but also a rule-based engine. This engine first determines the alphabet of the input text and searches for characters which are unique in one or more languages. If exactly one language can be reliably chosen this way, the statistical model is not necessary anymore. In any case, the rule-based engine filters out languages that do not satisfy the conditions of the input text. Only then, in a second step, the probabilistic n-gram model is taken into consideration. This makes sense because loading less language models means less memory consumption and better runtime performance.

In general, it is always a good idea to restrict the set of languages to be considered in the classification process using the respective api methods. If you know beforehand that certain languages are never to occur in an input text, do not let those take part in the classifcation process. The filtering mechanism of the rule-based engine is quite good, however, filtering based on your own knowledge of the input text is always preferable.

6. Test report generation

If you want to reproduce the accuracy results above, you can generate the test reports yourself for both classifiers and all languages by doing:

cd cmd
go run accuracy_reporter.go

For gocld3 to run successfully, you need to install the exact version 3.17.3 of Google's protocol buffers which is a bit unfortunate. For each detector and language, a test report file is then written into /accuracy-reports. As an example, here is the current output of the Lingua German report:

##### German #####

>>> Accuracy on average: 89.23%

>> Detection of 1000 single words (average length: 9 chars)
Accuracy: 73.90%
Erroneously classified as Dutch: 2.30%, Danish: 2.10%, English: 2.00%, Latin: 1.90%, Bokmal: 1.60%, Basque: 1.20%, French: 1.20%, Italian: 1.20%, Esperanto: 1.10%, Swedish: 1.00%, Afrikaans: 0.80%, Tsonga: 0.70%, Nynorsk: 0.60%, Portuguese: 0.60%, Yoruba: 0.60%, Finnish: 0.50%, Sotho: 0.50%, Welsh: 0.50%, Estonian: 0.40%, Irish: 0.40%, Polish: 0.40%, Spanish: 0.40%, Swahili: 0.40%, Tswana: 0.40%, Bosnian: 0.30%, Icelandic: 0.30%, Tagalog: 0.30%, Albanian: 0.20%, Catalan: 0.20%, Croatian: 0.20%, Indonesian: 0.20%, Lithuanian: 0.20%, Maori: 0.20%, Romanian: 0.20%, Xhosa: 0.20%, Zulu: 0.20%, Latvian: 0.10%, Malay: 0.10%, Slovak: 0.10%, Slovene: 0.10%, Somali: 0.10%, Turkish: 0.10%

>> Detection of 1000 word pairs (average length: 18 chars)
Accuracy: 94.10%
Erroneously classified as Dutch: 0.90%, Latin: 0.80%, English: 0.70%, Swedish: 0.60%, Danish: 0.50%, French: 0.40%, Bokmal: 0.30%, Irish: 0.20%, Tagalog: 0.20%, Afrikaans: 0.10%, Esperanto: 0.10%, Estonian: 0.10%, Finnish: 0.10%, Italian: 0.10%, Maori: 0.10%, Nynorsk: 0.10%, Somali: 0.10%, Swahili: 0.10%, Tsonga: 0.10%, Turkish: 0.10%, Welsh: 0.10%, Zulu: 0.10%

>> Detection of 1000 sentences (average length: 111 chars)
Accuracy: 99.70%
Erroneously classified as Dutch: 0.20%, Latin: 0.10%

7. How to add it to your project?

go get github.com/pemistahl/lingua-go

8. How to build?

Lingua requires at least Go version 1.18.

git clone https://github.com/pemistahl/lingua-go.git
cd lingua-go
go build

The source code is accompanied by an extensive unit test suite. To run the tests, simply say:

go test

9. How to use?

9.1 Basic usage

package main

import (
    "fmt"
    "github.com/pemistahl/lingua-go"
)

func main() {
    languages := []lingua.Language{
        lingua.English,
        lingua.French,
        lingua.German,
        lingua.Spanish,
    }

    detector := lingua.NewLanguageDetectorBuilder().
        FromLanguages(languages...).
        Build()

    if language, exists := detector.DetectLanguageOf("languages are awesome"); exists {
        fmt.Println(language)
    }

    // Output: English
}

9.2 Minimum relative distance

By default, Lingua returns the most likely language for a given input text. However, there are certain words that are spelled the same in more than one language. The word prologue, for instance, is both a valid English and French word. Lingua would output either English or French which might be wrong in the given context. For cases like that, it is possible to specify a minimum relative distance that the logarithmized and summed up probabilities for each possible language have to satisfy. It can be stated in the following way:

package main

import (
    "fmt"
    "github.com/pemistahl/lingua-go"
)

func main() {
    languages := []lingua.Language{
        lingua.English,
        lingua.French,
        lingua.German,
        lingua.Spanish,
    }

    detector := lingua.NewLanguageDetectorBuilder().
        FromLanguages(languages...).
        WithMinimumRelativeDistance(0.9).
        Build()

    language, exists := detector.DetectLanguageOf("languages are awesome")

    fmt.Println(language)
    fmt.Println(exists)

    // Output:
    // Unknown
    // false
}

Be aware that the distance between the language probabilities is dependent on the length of the input text. The longer the input text, the larger the distance between the languages. So if you want to classify very short text phrases, do not set the minimum relative distance too high. Otherwise Unknown will be returned most of the time as in the example above. This is the return value for cases where language detection is not reliably possible. This value is not meant to be included in the set of input languages when building the language detector. If you include it, it will be automatically removed from the set of input languages.

9.3 Confidence values

Knowing about the most likely language is nice but how reliable is the computed likelihood? And how less likely are the other examined languages in comparison to the most likely one? These questions can be answered as well:

package main

import (
    "fmt"
    "github.com/pemistahl/lingua-go"
)

func main() {
    languages := []lingua.Language{
        lingua.English,
        lingua.French,
        lingua.German,
        lingua.Spanish,
    }

    detector := lingua.NewLanguageDetectorBuilder().
        FromLanguages(languages...).
        Build()

    confidenceValues := detector.ComputeLanguageConfidenceValues("languages are awesome")

    for _, elem := range confidenceValues {
        fmt.Printf("%s: %.2f\n", elem.Language(), elem.Value())
    }

    // Output:
    // English: 0.93
    // French: 0.04
    // German: 0.02
    // Spanish: 0.01
}

In the example above, a slice of ConfidenceValue is returned containing all possible languages sorted by their confidence value in descending order. Each value is a probability between 0.0 and 1.0. The probabilities of all languages will sum to 1.0. If the language is unambiguously identified by the rule engine, the value 1.0 will always be returned for this language. The other languages will receive a value of 0.0.

There is also a method for returning the confidence value for one specific language only:

confidence := detector.ComputeLanguageConfidence("languages are awesome", lingua.French)
fmt.Printf("%.2f", confidence)

// Output:
// 0.04

The value that this method computes is a number between 0.0 and 1.0. If the language is unambiguously identified by the rule engine, the value 1.0 will always be returned. If the given language is not supported by this detector instance, the value 0.0 will always be returned.

9.4 Eager loading versus lazy loading

By default, Lingua uses lazy-loading to load only those language models on demand which are considered relevant by the rule-based filter engine. For web services, for instance, it is rather beneficial to preload all language models into memory to avoid unexpected latency while waiting for the service response. If you want to enable the eager-loading mode, you can do it like this:

lingua.NewLanguageDetectorBuilder().
    FromAllLanguages().
    WithPreloadedLanguageModels().
    Build()

Multiple instances of LanguageDetector share the same language models in memory which are accessed asynchronously by the instances.

9.5 Low accuracy mode versus high accuracy mode

Lingua's high detection accuracy comes at the cost of being noticeably slower than other language detectors. The large language models also consume significant amounts of memory. These requirements might not be feasible for systems running low on resources. If you want to classify mostly long texts or need to save resources, you can enable a low accuracy mode that loads only a small subset of the language models into memory:

lingua.NewLanguageDetectorBuilder().
    FromAllLanguages().
    WithLowAccuracyMode().
    Build()

The downside of this approach is that detection accuracy for short texts consisting of less than 120 characters will drop significantly. However, detection accuracy for texts which are longer than 120 characters will remain mostly unaffected.

In high accuracy mode (the default), the language detector consumes approximately 1,800 MB of memory if all language models are loaded. In low accuracy mode, memory consumption is reduced to approximately 110 MB. The goal is to further reduce memory consumption in later releases.

An alternative for a smaller memory footprint and faster performance is to reduce the set of languages when building the language detector. In most cases, it is not advisable to build the detector from all supported languages. When you have knowledge about the texts you want to classify you can almost always rule out certain languages as impossible or unlikely to occur.

9.6 Detection of multiple languages in mixed-language texts

In contrast to most other language detectors, Lingua is able to detect multiple languages in mixed-language texts. This feature can yield quite reasonable results but it is still in an experimental state and therefore the detection result is highly dependent on the input text. It works best in high-accuracy mode with multiple long words for each language. The shorter the phrases and their words are, the less accurate are the results. Reducing the set of languages when building the language detector can also improve accuracy for this task if the languages occurring in the text are equal to the languages supported by the respective language detector instance.

package main

import (
    "fmt"
    "github.com/pemistahl/lingua-go"
)

func main() {
    languages := []lingua.Language{
        lingua.English,
        lingua.French,
        lingua.German,
    }

    detector := lingua.NewLanguageDetectorBuilder().
        FromLanguages(languages...).
        Build()

    sentence := "Parlez-vous français? " + 
        "Ich spreche Französisch nur ein bisschen. " +
        "A little bit is better than nothing."

    for _, result := range detector.DetectMultipleLanguagesOf(sentence) {
        fmt.Printf("%s: '%s'\n", result.Language(), sentence[result.StartIndex():result.EndIndex()])
    }

    // Output:
    // French: 'Parlez-vous français? '
    // German: 'Ich spreche Französisch nur ein bisschen. '
    // English: 'A little bit is better than nothing.'
}

In the example above, a slice of DetectionResult is returned. Each entry in the slice describes a contiguous single-language text section, providing start and end indices of the respective substring.

9.7 Methods to build the LanguageDetector

There might be classification tasks where you know beforehand that your language data is definitely not written in Latin, for instance. The detection accuracy can become better in such cases if you exclude certain languages from the decision process or just explicitly include relevant languages:

// Include all languages available in the library.
lingua.NewLanguageDetectorBuilder().FromAllLanguages()

// Include only languages that are not yet extinct (= currently excludes Latin).
lingua.NewLanguageDetectorBuilder().FromAllSpokenLanguages()

// Include only languages written with Cyrillic script.
lingua.NewLanguageDetectorBuilder().FromAllLanguagesWithCyrillicScript()

// Exclude only the Spanish language from the decision algorithm.
lingua.NewLanguageDetectorBuilder().FromAllLanguagesWithout(lingua.Spanish)

// Only decide between English and German.
lingua.NewLanguageDetectorBuilder().FromLanguages(lingua.English, lingua.German)

// Select languages by ISO 639-1 code.
lingua.NewLanguageDetectorBuilder().FromIsoCodes639_1(lingua.EN, lingua.DE)

// Select languages by ISO 639-3 code.
lingua.NewLanguageDetectorBuilder().FromIsoCodes639_3(lingua.ENG, lingua.DEU)

10. What's next for version 1.5.0?

Take a look at the planned issues.

11. Contributions

Any contributions to Lingua are very much appreciated. Please read the instructions in CONTRIBUTING.md for how to add new languages to the library.