Tiny Lingua is a fork of the Lingua project with the intention
to increase detection speed and reduce memory consumption. See Performance optimizations.md
for a detailed description of considered and implemented performance optimizations of this project.
Some of the changes have already backported to the original Lingua project.
In general you should notice the following improvements when using this library:
- Faster memory model load times
This is especially noticeable when configuring Tiny Lingua to preload the models for all languages. - Reduced memory usage for language models
With all language models loaded the original Lingua library requires > 1.2 GB of memory whereas this library requires ~150 MB. (Though in most use cases detection of all supported languages is not necessary and a subset of these languages suffices.) - Reduced memory consumption during language detection
The original Lingua library can require multiple MBs of temporary memory during language detection, whereas this library only requires a fraction of that. - Better parallelization
For multi-core processors this library distributes the work more evenly across the cores to increase language detection speed.
One main goal of this project is to provide the same language detection accuracy as the original Lingua project; in fact its model files are based on the model files of the original Lingua project in the corresponding version. Additionally, the API should be as close as the possible to the original API. The package names are the same, so this library can be easily used as replacement. However, there are some differences:
- The package
com.github.pemistahl.lingua.api.io
has been removed
Most likely this does not affect many users because you would normally not create your own language models, but rely on the models provided by Lingua itself. - The format of the binary models stored in the JAR file is an implementation detail
The format may change at any point and users of this library should not make any assumptions about it.
The detection confidence values returned by this library won't be exactly the same as the ones returned by the original Lingua library. However, the differences should be negligible.
- The code is not well tested. However, at least the regular accuracy report is generated and it is compared against the previous report to detect any regression regarding detection accuracy.
- The code may not be easily maintainable and integrating future upstream Lingua changes might be difficult.
The versioning scheme is <version>-L<upstream-lingua-version>
. For example 1.0.0-L1.2.2
means:
- Tiny Lingua version 1.0.0
- based on upstream Lingua version 1.2.2
Note that the upstream Lingua version number does not guarantee that all of the APIs and functionality are supported. Some features might be omitted (or replaced) in this library.
IntelliJ IDEA currently has problems setting up the project when importing it from Gradle: The test
code under src/test/kotlin
is unable to find the classes from the main code.
(this only affects IntelliJ; ./gradlew
is not affected)
A temporary workaround for this is:
- Right-click the top-level project folder in the "Project" tab and select "Open Module Settings"
- Remove the "buildSrc.main" module
- Select the "main" module
- Select the "Sources" tab
- On the right remove all "Content Root" entries
- Safe and close the module settings
- Open the module settings again
- Select the "main" module
- Select the "Sources" tab
- Click "Add Content Root"
- Select
lingua/src/main
(it should automatically add thekotlin
andjava-9
subdirectories as Source Folders)
- Safe and close the module settings
However, when IntelliJ reloads the project from the Gradle build files this configuration change has to be done again.
The reason for this might be the non-standard way buildSrc/build.gradle.kts
includes source files from
the main source code.
The original README description (possibly with some adjustments) follows below:
- this library tries to solve language detection of very short words and phrases, even shorter than tweets
- makes use of both statistical and rule-based approaches
- outperforms Apache Tika, Apache OpenNLP and Optimaize Language Detector for more than 70 languages
- works within every Java 11+ application
- no additional training of language models necessary
- api for adding your own language models
- offline usage without having to connect to an external service or API
- can be used in a REPL for a quick try-out
Its task is simple: It tells you which language some provided textual data 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.
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, three other comprehensive open source libraries working on the JVM for this task are Apache Tika, Apache OpenNLP and Optimaize Language Detector. Unfortunately, especially the latter has three major drawbacks:
- Detection only works with quite lengthy text fragments. For very short text snippets such as Twitter messages, it doesn't provide adequate results.
- The more languages take part in the decision process, the less accurate are the detection results.
- Configuration of the library is quite cumbersome and requires some knowledge about the statistical methods that are used internally.
Lingua aims at eliminating these problems. It nearly doesn't need any configuration and yields pretty accurate results on both long and short text, even on single words and phrases. It draws on both rule-based and statistical methods but does not use any dictionaries of words. It does not need a connection to any external API or service either. Once the library has been downloaded, it can be used completely offline.
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
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:
- a list of single words with a minimum length of 5 characters
- a list of word pairs with a minimum length of 10 characters
- 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, Apache Tika, Apache OpenNLP and Optimaize Language Detector using parameterized JUnit tests running over the data of Lingua's supported 75 languages. Languages that are not supported by the other libraries are simply ignored for those 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.
The table below shows detailed statistics for each language and classifier including mean, median and standard deviation.
Open table
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.
If you want to reproduce the accuracy results above, you can generate the test reports yourself for all four classifiers and all languages by doing:
./gradlew accuracyReport
You can also restrict the classifiers and languages to generate reports for by passing arguments to the Gradle task. The following task generates reports for Lingua and the languages English and German only:
./gradlew accuracyReport -Pdetectors=Lingua -Planguages=English,German
By default, only a single CPU core is used for report generation. If you have a multi-core CPU in your machine, you can fork as many processes as you have CPU cores. This speeds up report generation significantly. However, be aware that forking more than one process can consume a lot of RAM. You do it like this:
./gradlew accuracyReport -PcpuCores=2
For each detector and language, a test report file is then written into /accuracy-reports
,
to be found next to the src
directory. As an example, here is the current output of the Lingua German report:
##### GERMAN #####
Legend: 'low accuracy mode | high accuracy mode'
>>> Accuracy on average: 79.80% | 89.23%
>> Detection of 1000 single words (average length: 9 chars)
Accuracy: 56.70% | 73.90%
Erroneously classified as DUTCH: 2.80% | 2.30%, DANISH: 2.20% | 2.10%, ENGLISH: 1.90% | 2.00%, LATIN: 1.90% | 1.90%, BOKMAL: 2.40% | 1.60%, BASQUE: 1.60% | 1.20%, ITALIAN: 1.00% | 1.20%, FRENCH: 1.60% | 1.20%, ESPERANTO: 1.10% | 1.10%, SWEDISH: 3.20% | 1.00%, AFRIKAANS: 1.30% | 0.80%, TSONGA: 1.50% | 0.70%, NYNORSK: 1.40% | 0.60%, PORTUGUESE: 0.50% | 0.60%, YORUBA: 0.40% | 0.60%, SOTHO: 0.70% | 0.50%, FINNISH: 0.80% | 0.50%, WELSH: 1.30% | 0.50%, SPANISH: 1.20% | 0.40%, SWAHILI: 0.60% | 0.40%, TSWANA: 2.20% | 0.40%, POLISH: 0.70% | 0.40%, ESTONIAN: 0.90% | 0.40%, IRISH: 0.50% | 0.40%, TAGALOG: 0.10% | 0.30%, ICELANDIC: 0.30% | 0.30%, BOSNIAN: 0.10% | 0.30%, LITHUANIAN: 0.80% | 0.20%, MAORI: 0.50% | 0.20%, INDONESIAN: 0.40% | 0.20%, ALBANIAN: 0.60% | 0.20%, CATALAN: 0.70% | 0.20%, ZULU: 0.30% | 0.20%, ROMANIAN: 1.20% | 0.20%, CROATIAN: 0.10% | 0.20%, XHOSA: 0.40% | 0.20%, TURKISH: 0.70% | 0.10%, MALAY: 0.50% | 0.10%, LATVIAN: 0.40% | 0.10%, SLOVENE: 0.00% | 0.10%, SLOVAK: 0.30% | 0.10%, SOMALI: 0.00% | 0.10%, HUNGARIAN: 0.40% | 0.00%, SHONA: 0.80% | 0.00%, VIETNAMESE: 0.40% | 0.00%, CZECH: 0.30% | 0.00%, GANDA: 0.20% | 0.00%, AZERBAIJANI: 0.10% | 0.00%
>> Detection of 1000 word pairs (average length: 18 chars)
Accuracy: 83.50% | 94.10%
Erroneously classified as DUTCH: 1.50% | 0.90%, LATIN: 1.00% | 0.80%, ENGLISH: 1.40% | 0.70%, SWEDISH: 1.40% | 0.60%, DANISH: 1.20% | 0.50%, FRENCH: 0.60% | 0.40%, BOKMAL: 1.40% | 0.30%, TAGALOG: 0.10% | 0.20%, IRISH: 0.20% | 0.20%, TURKISH: 0.10% | 0.10%, NYNORSK: 0.90% | 0.10%, TSONGA: 0.40% | 0.10%, ZULU: 0.10% | 0.10%, ESPERANTO: 0.30% | 0.10%, AFRIKAANS: 0.60% | 0.10%, ITALIAN: 0.10% | 0.10%, ESTONIAN: 0.30% | 0.10%, FINNISH: 0.40% | 0.10%, SOMALI: 0.00% | 0.10%, SWAHILI: 0.20% | 0.10%, MAORI: 0.00% | 0.10%, WELSH: 0.10% | 0.10%, LITHUANIAN: 0.40% | 0.00%, INDONESIAN: 0.10% | 0.00%, CATALAN: 0.30% | 0.00%, LATVIAN: 0.20% | 0.00%, XHOSA: 0.30% | 0.00%, SPANISH: 0.50% | 0.00%, MALAY: 0.10% | 0.00%, SLOVAK: 0.10% | 0.00%, BASQUE: 0.40% | 0.00%, YORUBA: 0.20% | 0.00%, TSWANA: 0.30% | 0.00%, SHONA: 0.10% | 0.00%, PORTUGUESE: 0.10% | 0.00%, SOTHO: 0.30% | 0.00%, CZECH: 0.10% | 0.00%, ALBANIAN: 0.40% | 0.00%, AZERBAIJANI: 0.10% | 0.00%, ICELANDIC: 0.10% | 0.00%, SLOVENE: 0.10% | 0.00%
>> Detection of 1000 sentences (average length: 111 chars)
Accuracy: 99.20% | 99.70%
Erroneously classified as DUTCH: 0.00% | 0.20%, LATIN: 0.20% | 0.10%, NYNORSK: 0.10% | 0.00%, SPANISH: 0.10% | 0.00%, DANISH: 0.10% | 0.00%, SOTHO: 0.20% | 0.00%, ZULU: 0.10% | 0.00%
The plots have been created with Python and the libraries Pandas, Matplotlib and Seaborn.
If you have a global Python 3 installation and the python3
command available on your command line,
you can redraw the plots after modifying the test reports by executing the following Gradle task:
./gradlew drawAccuracyPlots
The detailed statistics table that contains all accuracy values can be written with:
./gradlew writeAccuracyTable
Lingua is hosted on GitHub Packages and Maven Central.
// Groovy syntax
implementation 'com.github.pemistahl:lingua:1.2.2'
// Kotlin syntax
implementation("com.github.pemistahl:lingua:1.2.2")
<dependency>
<groupId>com.github.pemistahl</groupId>
<artifactId>lingua</artifactId>
<version>1.2.2</version>
</dependency>
Lingua uses Gradle to build and requires Java >= 1.8 for that.
git clone https://github.com/pemistahl/lingua.git
cd lingua
./gradlew build
Several jar archives can be created from the project.
./gradlew jar
assembleslingua-1.2.2.jar
containing the compiled sources only../gradlew sourcesJar
assembleslingua-1.2.2-sources.jar
containing the plain source code../gradlew jarWithDependencies
assembleslingua-1.2.2-with-dependencies.jar
containing the compiled sources and all external dependencies needed at runtime. This jar file can be included in projects without dependency management systems. It can also be used to run Lingua in standalone mode (see below).
Lingua can be used programmatically in your own code or in standalone mode.
The API is pretty straightforward and can be used in both Kotlin and Java code.
/* Kotlin */
import com.github.pemistahl.lingua.api.*
import com.github.pemistahl.lingua.api.Language.*
val detector: LanguageDetector = LanguageDetectorBuilder.fromLanguages(ENGLISH, FRENCH, GERMAN, SPANISH).build()
val detectedLanguage: Language = detector.detectLanguageOf(text = "languages are awesome")
The public API of Lingua never returns null
somewhere, so it is safe to be used from within Java code as well.
/* Java */
import com.github.pemistahl.lingua.api.*;
import static com.github.pemistahl.lingua.api.Language.*;
final LanguageDetector detector = LanguageDetectorBuilder.fromLanguages(ENGLISH, FRENCH, GERMAN, SPANISH).build();
final Language detectedLanguage = detector.detectLanguageOf("languages are awesome");
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:
val detector = LanguageDetectorBuilder
.fromAllLanguages()
.withMinimumRelativeDistance(0.25) // minimum: 0.00 maximum: 0.99 default: 0.00
.build()
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 you will get most results
returned as Language.UNKNOWN
which is the return value for cases where language detection is not reliably
possible.
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:
val detector = LanguageDetectorBuilder.fromLanguages(GERMAN, ENGLISH, FRENCH, SPANISH).build()
val confidenceValues = detector.computeLanguageConfidenceValues(text = "Coding is fun.")
// {
// ENGLISH=1.0,
// GERMAN=0.8665738136456169,
// FRENCH=0.8249537317466078,
// SPANISH=0.7792362923625288
// }
In the example above, a map of all possible languages is returned, sorted by their confidence value in descending order. The values that the detector computes are part of a relative confidence metric, not of an absolute one. Each value is a number between 0.0 and 1.0. The most likely language is always returned with value 1.0. All other languages get values assigned which are lower than 1.0, denoting how less likely those languages are in comparison to the most likely language.
The map returned by this method does not necessarily contain all languages which the calling
instance of LanguageDetector
was built from. If the rule-based engine decides that a specific
language is truly impossible, then it will not be part of the returned map. Likewise, if no
ngram probabilities can be found within the detector's languages for the given input text, the
returned map will be empty. The confidence value for each language not being part of the
returned map is assumed to be 0.0.
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:
LanguageDetectorBuilder.fromAllLanguages().withPreloadedLanguageModels().build()
Multiple instances of LanguageDetector
share the same language models in memory which are
accessed asynchronously by the instances.
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:
LanguageDetectorBuilder.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.
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.
There might be classification tasks where you know beforehand that your language data is definitely not written in Latin, for instance (what a surprise :-). 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
// WARNING: in the worst case this produces high memory
// consumption of approximately 3.5GB
// and slow runtime performance
// (in high accuracy mode)
LanguageDetectorBuilder.fromAllLanguages()
// include only languages that are not yet extinct (= currently excludes Latin)
LanguageDetectorBuilder.fromAllSpokenLanguages()
// include only languages written with Cyrillic script
LanguageDetectorBuilder.fromAllLanguagesWithCyrillicScript()
// exclude only the Spanish language from the decision algorithm
LanguageDetectorBuilder.fromAllLanguagesWithout(Language.SPANISH)
// only decide between English and German
LanguageDetectorBuilder.fromLanguages(Language.ENGLISH, Language.GERMAN)
// select languages by ISO 639-1 code
LanguageDetectorBuilder.fromIsoCodes639_1(IsoCode639_1.EN, IsoCode639_3.DE)
// select languages by ISO 639-3 code
LanguageDetectorBuilder.fromIsoCodes639_3(IsoCode639_3.ENG, IsoCode639_3.DEU)
Internally, Lingua efficiently uses all cores of your CPU in order to speed up loading the language models and language detection itself. For this purpose, an internal thread pool is used. If the library is used within an application server, the consumed memory will not be freed automatically when the application is undeployed.
If you want to free all of Lingua's resources, you will have to do this manually by calling
detector.unloadLanguageModels()
during the undeployment. This will clear all loaded language models
from memory but the thread pool will keep running.
9.2 Standalone mode Top โฒ
If you want to try out Lingua before you decide whether to use it or not, you can run it in a REPL and immediately see its detection results.
- With Gradle:
./gradlew runLinguaOnConsole --console=plain
- Without Gradle:
java -jar lingua-1.2.2-with-dependencies.jar
Then just play around:
This is Lingua.
Select the language models to load.
1: enter language iso codes manually
2: all supported languages
Type a number and press <Enter>.
Type :quit to exit.
> 1
List some language iso 639-1 codes separated by spaces and press <Enter>.
Type :quit to exit.
> en fr de es
Loading language models...
Done. 4 language models loaded lazily.
Type some text and press <Enter> to detect its language.
Type :quit to exit.
> languages
ENGLISH
> Sprachen
GERMAN
> langues
FRENCH
> :quit
Bye! Ciao! Tschรผss! Salut!
In case you want to contribute something to Lingua, then you are encouraged to do so. Do you have ideas for improving the API? Are there some specific languages that you want to have supported early? Or have you found any bugs so far? Feel free to open an issue or send a pull request. It's very much appreciated.
For pull requests, please make sure that all unit tests pass and that the code is formatted according to
the official Kotlin style guide. You can check this by running the Kotlin linter ktlint
using ./gradlew ktlintCheck
. Most issues which the linter identifies can be fixed by running ./gradlew ktlintFormat
.
All other issues, especially lines which are longer than 120 characters, cannot be fixed automatically. In this case,
please format the respective lines by hand. You will notice that the build will fail if the formatting is not correct.
All kinds of pull requests are welcome. The most favorite ones are new language additions. If you want to contribute new languages to Lingua, here comes a detailed manual explaining how to accomplish that.
Thank you very much in advance for all contributions, however small they may be.
In order to execute the steps below, you will need Java 8 or greater. Even though the library itself
runs on Java >= 6, the FilesWriter
classes make use of the java.nio api which was
introduced with Java 8.
- Clone Lingua's repository to your own computer as described in section 8.
- Open enums
IsoCode639_1
andIsoCode639_3
and add the language's iso codes. Among other sites, Wikipedia provides a comprehensive list. - Open enum
Language
and add a new entry for your language. If the language is written with a script that is not yet supported by Lingua'sAlphabet
enum, then add a new entry for it there as well. - If your language's script contains characters that are completely unique to it, then add them to the
respective entry in the
Language
enum. However, if the characters occur in more than one language but not in all languages, then add them to theCHARS_TO_LANGUAGES_MAPPING
constant in classConstant
instead. - Use
LanguageModelFilesWriter
to create the language model files. The training data file used for ngram probability estimation is not required to have a specific format other than to be a valid txt file. - Create a new subdirectory in
/src/main/resources/language-models
and put the generated language model files in there. Do not rename the language model files. The name of the subdirectory must be the language's ISO 639-1 code, completely lowercased. - Use
TestDataFilesWriter
to create the test data files used for accuracy report generation. The input file from which to create the test data should have each sentence on a separate line. - Put the generated test data files in
/src/accuracyReport/resources/language-testdata
. Do not rename the test data files. - For accuracy report generation, create an abstract base class for the main logic in
/src/accuracyReport/kotlin/com/github/pemistahl/lingua/report/config
. Look at the other languages' files in this directory to see how the class must look like. It should be pretty self-explanatory. - Create a concrete test class in
/src/accuracyReport/kotlin/com/github/pemistahl/lingua/report/lingua
. Look at the other languages' files in this directory to see how the class must look like. It should be pretty self-explanatory. If one of the other language detector libraries supports your language already, you can add test classes for those as well. Each library has its own directory for this purpose. - Fix the existing unit tests by adding your new language.
- Add your new language to property
linguaSupportedLanguages
in/gradle.properties
. - Run
./gradlew accuracyReport
and add the updated accuracy reports to your pull request. - Run
./gradlew drawAccuracyPlots
and add the updated plots to your pull request. - Run
./gradlew writeAccuracyTable
and add the updated accuracy table to your pull request. - Be happy! :-) You have successfully contributed a new language and have thereby significantly widened this library's fields of application.
Take a look at the planned issues.