Bech: Lien page anglaise

2014-10-07T13:07:14Z

Lien page anglaise

Bech: /* Fonctions d'exécution apertium */ nom de lien choisi en français

2012-05-31T15:18:51Z

Fonctions d'exécution apertium: nom de lien choisi en français

Bech: /* Fonctions lttoolbox */ nom de lien choisi en français

2012-05-31T15:17:53Z

Fonctions lttoolbox: nom de lien choisi en français

Bech: /* Fonctions lttoolbox */ lien direct

2012-05-31T14:54:14Z

Fonctions lttoolbox: lien direct

Bech: /* Téléchargement, compilation, installation */ suppression traduction malencontreuse

2012-05-31T14:53:31Z

Téléchargement, compilation, installation: suppression traduction malencontreuse

Bech: fin de la traduction

2012-05-31T14:49:01Z

fin de la traduction

Show changes

Bech: suite traduction

2012-05-31T07:04:47Z

suite traduction

Show changes

Bech: Traduction partielle (copie d'un début de traduction hors ligne)

2012-05-30T21:34:12Z

Traduction partielle (copie d'un début de traduction hors ligne)

New page

== Qu'est ce que lttoolbox-java ==

lttoolbox-java est un portage Java de la totalité du système d'exécution Apertium, ''incluant à la fois lttoolbox et apertium''.

=== Fonctions lttoolbox ===

[[lttoolbox]] peut faire les choses suivantes

* Compiler : fabriquer des fichiers binaires à partir des fichiers .dix (lt-comp),
* Traiter : analyser ou générer du texte (lt-proc) et
* Etendre : développer un fichier dictionnaire .dix (lt-expand).

Le portage Java de lttoolbox est aussi capable de

* [[Compounding]] (expérimental)
* [[Flag diacritics]] (très expérimental)
* Valider des fichiers .dix

=== Fonctions d'exécution apertium ===

Le portage Java implémente les fonctions typiques utilisées par Apertium pendant l'exécution.

* Lire les fichiers .mode et exécuter les étapes qu'ils contiennent
* Exécuter le tagger
* Exécuter les étapes de transfert (toutes les trois)

Le portage Java a besoin des binaires C++ pour préparer/développer une paire de langue, par exemple pour compiler les fichiers de transfert et entrainer le tagger.

Le portage Java de lttoolbox est aussi capable de
* Générer le [[bytecode for transfer]] et l'exécuter. Le bytecode s'exécute typiquement 10 fois plus vite que la version C++.

== Pourquoi ==

Un "portage Java" d'Apertium permet l'utilisation sur

* Windows,
* J2ME/téléphones Android,
* pages web (applets),
* application de bureau,
* applications serveur Java.

Les deux derniers points sont capitaux comme, par exemple un plugin OpenOffice.org devrait être indépendant de la plateforme pour être maintenable.

On n'a vu personne implanter Apertium sur une application de bureau. Actuellement Apertium est utilisable dans un sous répertoire local mais l'installation n'est pas triviale pour l'utilisateur final.

Avoir une version paquagée facile à utiliser d'Apertium prête pour supporter les machines de traduction dans un programme plus large serait très sympa.
Idéalement ça pourrait être un fichier JAR contenant Apertium, dépendant seulement de JRE et un fichier JAR additionnel par paire de langue.

Une autre approche d'"implantation" est d'utiliser un client stub(?) pour l'un de nos [[services Apertium]], mais il peut y avoir des raisons qui font préférer d'avoir les choses installées locallement (on n'a pas besoin de les répéter ici).

== Caractéristiques ==

* Compatibilité binaire avec lttoolbox. lttoolbox-java est capable de '''lire''' et '''d'écrire''' les fichiers binaires lttoolbox et génère exactement la même sortie
* Il y une suite de tests comprehensible qui teste à la fois lttoolbox (C++) et lttoolbox-java.

== Installation ==

=== Prérequis : ===

* java-runtime
* apache-ant (pour compilation)

Sous Arch Linux, vous pouvez installer les prérequis avec

pacman -S openjdk6 apache-ant

Sous Debian/Ubuntu:

sudo apt-get install ant ant-optional # quoi d'autre ??

=== Téléchargement, compilation, installation ===

Téléchargez la [https://sourceforge.net/projects/apertium/files/lttoolbox-java/ version] la plus récente ou récupérez-la depuis SVN :
<pre>
svn co https://apertium.svn.sourceforge.net/svnroot/apertium/trunk/lttoolbox-java
</pre>

Utilisez Netbeans ou Unix, ou n'importe quoi qui vous va le mieux :
<pre>
sh autogen.sh
make
sudo make install
</pre>

Vous pouvez aussi construire et installer en utilisant Maven 2 (http://maven.apache.org), en tapant :
<pre>
mvn install -DskipTests
</pre>

Voir aussi le fichier README

== Utilisation ==

<pre>
$ java -jar dist/lttoolbox.jar
lttoolbox: is a toolbox for lexical processing, morphological analysis and generation of words

USAGE: java -jar dist/lttoolbox.jar [task]

Exemples:

java -jar dist/lttoolbox.jar lt-expand dictionary.dix expands a dictionary
java -jar dist/lttoolbox.jar lt-comp lr dic.dix dic.bin compiles a dictionary
java -jar dist/lttoolbox.jar lt-proc dic.bin morphological analysis
</pre>

or, using the a shell scripts:

<pre>
$ lt-comp-j
v3.2j: build a letter transducer from a dictionary
USAGE: LTComp lr | rl dictionary_file output_file [acx_file]
Modes:
lr: left-to-right compilation
rl: right-to-left compilation
</pre>

<pre>
$ lt-proc-j
LTProc: process a stream with a letter transducer
USAGE: LTProc [-c] [-a|-g|-n|-d|-b|-p|-s|-t] fst_file [input_file [output_file]]
Options:
-a: morphological analysis (default behavior)
-c: use the literal case of the incoming characters
-e: morphological analysis, with compound analysis on unknown words
-f: match flags (experimental)
-g: morphological generation
-n: morph. generation without unknown word marks
-d: morph. generation with all the stuff
-t: morph. generation, but retaining part-of-speech
-p: post-generation
-s: SAO annotation system input processing
-t: apply transliteration dictionary
-z: flush output on the null character
-v: version
-D: debug; print diagnostics to stderr
-h: show this help
</pre>

<pre>
$ lt-expand-j
v3.2j: expand the contents of a dictionary fileUSAGE: LTExpand dictionary_file [output_file]
</pre>

<pre>
$ lt-validate-j
v3.2j: validate an XML file according to a schema
USAGE : LTValidate -dix dictionary.xml
LTValidate -acx dictionary.acx
</pre>

=== Exemples ===

Use the new compounding feature:
echo "lambakjöti" | java -jar dist/lttoolbox.jar lt-proc -e /home/j/esperanto/apertium/apertium-is-en/is.bin
^lambakjöti/lamb<n><nt><pl><gen><ind>+kjöt<n><nt><sg><dat><ind>$

=== Encoding problems ===

Try -Dfile.encoding=UTF-8, like

echo "lambakjöti" | java -Dfile.encoding=UTF-8 -jar dist/lttoolbox.jar lt-proc -e /home/j/esperanto/apertium/apertium-is-en/is.bin
^lambakjöti/lamb<n><nt><pl><gen><ind>+kjöt<n><nt><sg><dat><ind>$

===Mac users===

You need JDK1.6. Try

/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Commands/java -jar dist/lttoolbox.jar

=== Windows usage ===

By default, the windows console uses UTF-16, whereas apertium's data
is encoded with utf-8. This command switches the dos box to utf-8:

<pre>
chcp 65001
</pre>

Note: you also need to use an unicode-capable font for the windows console, like Lucida Console (Properties -> Font).

Also, don't forget to set these Runtime flags: -Xms64m -Xmx800 -Dfile.encoding=UTF-8

== Reasons for a portage Java ==
* There are several devices (mobile phones, for example) which can run quite complicated software, but only if written in Java. lttoolbox is the first step to having Apertium run on these devices.
* Windows port. It won't be as powerfull as Unix based system, but it will be there
* Apertium will be the first MT system *ever* that can be demonstrated within a Java applets
* Transfer in bytecode has a promise of speedup factor 4 - compared to what we use now (interpreted XML). And transfer CPU usage is dominating when processing large amounts of text

== Performance of portage Java ==

Compatibility and performance can be checked by invoking test_java_and_c.sh in testdata/regression.

=== Single-core processor (Jimmy O'Regan) ===

<pre>
java version "1.6.0_18"
OpenJDK Runtime Environment (IcedTea6 1.8) (6b18~pre4-1ubuntu1)
OpenJDK Client VM (build 16.0-b13, mixed mode, sharing)
C analysis is... 0.59sec
OK
Java analysis is... 1.15sec
OK
C generator -g is ... 0.54sec
OK
Java generator -g is ... 1.13sec
OK
C generator -d is ... 0.56sec
OK
Java generator -d is ... 1.12sec
OK
C generator -n is ... 0.52sec
OK
Java generator -n is ... 1.12sec
OK
C postgenerator -p is ... 0.07sec
OK
Java postgenerator -p is ... 0.33sec
OK
All tests passed
</pre>

=== Dual-core processor (Jacob) ===

<pre>
Java HotSpot(TM) Client VM (build 1.6.0-beta2-b86, mixed mode, sharing)
C analysis is... 0.39sec
OK
Java analysis is... 0.66sec
OK
C generator -g is ... 0.32sec
OK
Java generator -g is ... 0.62sec
OK
C generator -d is ... 0.33sec
OK
Java generator -d is ... 0.58sec
OK
C generator -n is ... 0.32sec
OK
Java generator -n is ... 0.64sec
OK
C postgenerator -p is ... 0.03sec
OK
Java postgenerator -p is ... 0.20sec
OK
All tests passed
</pre>

As you see Java version is currently (april 2010) a factor 2 slower than the C version. There are ways to remedy this (using simple types collection classes), but it hasnt been implemented, as no-one has requested it.

It still gives great performance, however, and Apertium running on Java is very fast, compared to other MT systems. The overhead of using the Java version instead of the C version is negligible, as transfer is the big ressource hog anyway.

The above test compares the basic lttoolbox fonctions. As Java transfer is much faster the result of performance test of a pure-Java and pure-C++ chain are comparable (and mostly in Java's favor). A hybrid can be made which beats performance of both systems.

== Known bugs ==

There are currently (jan 2010) problems compiling some very seldom strange constructs (testdata/strange.dix).
You can use the C version to compile these, and the binary files will work fine when used from lttoolbox-java.

==Thanks==

* Nic Cottrell contributed an initial version of a portage Java of [[lttoolbox]].
* During [[Google Summer of Code|GSOC2009]] [[User:Rah|Raphaël]] and [[User:Sortiz|Sergio]] worked on it, but processing still didnt work (compilation and expansion worked)
* November 2009 [[User:Jacob Nordfalk|Jacob Nordfalk]] finished it up and optimized some parts of it
* During GSOC 2010 Jacob mentored a full [[User:Kanmuri/GSoC 2010 Application/Java Runtime Port|Java Runtime Port of Apertium]] (i.e. not just lttoolbox) made by [[User:Kanmuri|Stephen Tigner]].

[[Category:Lttoolbox]]
[[Category:Documentation en français]]

← Older revision		Revision as of 13:07, 7 October 2014
Line 1:		Line 1:
			[[Lttoolbox-java\|In English]]

	== Qu'est ce que lttoolbox-java ==		== Qu'est ce que lttoolbox-java ==

@@ Line 28: / Line 28: @@
 Le portage Java de lttoolbox est aussi capable de
-* Générer le [[bytecode for transfer]] et l'exécuter. Le bytecode s'exécute typiquement 10 fois plus vite que la version C++.
+* Générer le [[bytecode pour le transfert]] et l'exécuter. Le bytecode s'exécute typiquement 10 fois plus vite que la version C++.
 == Pourquoi ==

@@ Line 13: / Line 13: @@
 Le portage Java de lttoolbox est aussi capable de
-* [[Compounds]] (expérimental)
+* [[Composants]] (expérimental)
 * [[Flag diacritics]] (très expérimental)
 * Valider des fichiers .dix

@@ Line 85: / Line 85: @@
 Vous pouvez aussi construire et installer en utilisant Maven 2 (http://maven.apache.org), en tapant :
 <pre>
-mvn install -Descripteurs
+mvn install -DskipTests
 </pre>

Lttoolbox-java (français) - Revision history