Mentions légales du service

Skip to content
Snippets Groups Projects
Commit bdc47632 authored by Jérôme Euzenat's avatar Jérôme Euzenat
Browse files

- added/improved micro, eval, testgen documentation

parent 4510c039
Branches
Tags
No related merge requests found
Hide whitespace changes
Inline Side-by-side
html/credits.html
+ 2
− 2
View file @ bdc47632
......@@ -32,13 +32,13 @@ IDDN.FR. 001.050019 .000.S.P.2 011.000.2090 0
<dt><a href="http://www.ai.univ-paris8.fr/~leduc/">Chan Le Duc</a></dt><dd>has developed the NeOn plug-in and improves the whole system.</dd>
<dt><a href="http://www.inrialpes.fr/exmo/people/jdavid/">Jérôme
David</a></dt><dd>developed the Ontology part of the API (ontowrap).</dd>
<dt>Maria Ro&scedil;oiu</dt><dd>developed the generator interface (gen).</dd>
<dt><a href="http://www.inrialpes.fr/exmo/people/pierson/">Jérôme Pierson</a></dt><dd>initially developed the
WordNet interface (now in <a href="http://ontosim.gforge.inria.fr">OntoSim</a>) and the agent profile for the Alignment Server</dd>
<dt>Seunkeun Lee</dt><dd>developped the low-level
storage layer and the web service profile for the Alignment Server</dd>
<dt><a href="http://www.eurecom.fr/~troncy/">Raphaël Troncy</a></dt><dd>fixed the basic
implementation of BasicAlignment for n:m alignments.</dd>
<dt>Maria Rosoiu</dt><dd>developed the generator interface (gen).</dd>
<dt>Arun Sharma</dt><dd>Developed the query interface</dd>
<dt><a href="http://www.scharffe.fr/">François Scharffe</a></dt><dd>developed the initial version of EDOAL</dd>
<dt><a href="http://web.comlab.ox.ac.uk/isg/people/giorgos.stoilos/">Giorgos
......@@ -61,7 +61,7 @@ Raphael Voltz</dt><dd>provided some code snippets for
<h2>Copyright owners</h2>
<p>
Copyright (C) 2003-2011 INRIA (most of the code)<br />
Copyright (C) 2003-2012 INRIA (most of the code)<br />
Copyright (C) 2004-2005 Université de Montréal (parts of the impl/ and
ling/ directories)<br />
Copyright (C) 2005 CNR Pisa. (parts of BasicAlignment)<br />
......
html/eval.html
+ 333
− 43
View file @ bdc47632
<html>
<head>
<title>Evaluating alignments</title>
<title>Alignment API: Evaluating alignments</title>
<!--style type="text/css">@import url(style.css);</style-->
<link rel="stylesheet" type="text/css" href="base.css" />
<link rel="stylesheet" type="text/css" href="style.css" />
</head>
<body bgcolor="#ffffff">
<h1 class="titre">Evaluating alignments</h1>
<h1 class="titre">Alignment API: Evaluating alignments</h1>
<p>On top of the alignment API, there is an evaluation API and an
implementation described here. It is included in the
<a href="align.html">Alignment toolkit</a></p>
<p>A good reason for having a separate Alignment format is to be able
to compare the alignments provided by different matching algorithms. They can be compared
with each other or against a ``correct'' alignment.
</p>
<p>
The alignment API defines an <tt>Evaluator</tt> interface which can
be used for developing different tools. This interface has
an <tt>eval</tt> method which takes two alignments as input and which
evaluates the second one with respect to the first one which is taken
as a reference alignments.
</p>
<p>
This allows for implementing various measures and displaying various
reports. Some examples are given below.
</p>
<h2>Evaluating</h2>
<p>For demonstrating the use of the API, we implement it and use it
through a particular processor
(<tt>fr.inrialpes.exmo.align.cli.EvalAlign</tt>) which:
<ul compact="1">
<li>Reads two OWL/RDF ontologies;</li>
<li>Creates an alignment object;</li>
<li>Computes the alignment between these ontologies;</li>
<li>Displays the result.</li>
</ul>
Running the program is achieved through:
<div class="fragment"><pre>
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.EvalAlign
Require two alignement filenames
<p>There is a command line utility
(<tt>fr.inrialpes.exmo.align.cli.EvalAlign</tt>) allowing for taking
advantage of evaluators. It is called in the following way:
<div class="fragment">
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.EvalAlign file://result/align1.owl file://result/align2.owl
</div>
For instance (<tt>$CWD</tt> is the current directory):
<div class="fragment">
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.EvalAlign -i fr.inrialpes.exmo.align.impl.eval.PRecEvaluator file://$CWD/aligns/bibref.owl file://$CWD/aligns/EditDistName.owl
</div>
would yield:
<div class="owl"><pre>
&lt;?xml version='1.0' encoding='utf-8' standalone='yes'?>
&lt;rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:map='http://www.atl.external.lmco.com/projects/ontology/ResultsOntology.n3#'>
&lt;map:output rdf:about=''>
&lt;map:precision>0.6976744186046512&lt;/map:precision>
&lt;map:recall>0.9375&lt;/map:recall>
&lt;fallout>0.3023255813953488&lt;/fallout>
&lt;map:fMeasure>0.8000000000000002&lt;/map:fMeasure>
&lt;map:oMeasure>0.53125&lt;/map:oMeasure>
&lt;result>1.34375&lt;/result>
&lt;/map:output>
&lt;/rdf:RDF>
</pre></div>
The default format is the <a href="http://www.atl.external.lmco.com/projects/ontology/">format developed at Lockheed</a>
extended with a few attributes, but any other format could have been generated.
See below for more graphical formats.
</p>
<p>
The option of <tt>EvalAlign</tt> are:
<div class="fragment">
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.EvalAlign --help
usage: EvalAlign [options] file1 file2
options are:
--debug[=n] -d[=n] Report debug info at level ,
--impl[=classname] -i classname Use classname for implementing Evaluator
--help -h Print this message
</pre></div>
or ($CWD is the current directory)
<div class="fragment"><pre>
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.EvalAlign file://$CWD/result/align1.owl file://$CWD/result/align2.owl
</pre></div>
--debug[=n] -d [n] Report debug info at level n
--impl=className -i classname Use the given Evaluator implementation.
--output=filename -o filename Output the result in filename
--help -h Print this message
Alignment API implementation 4.3 (1698M) ($Id$)
</div>
The <tt>-i</tt> switch enables changing the evaluator to be used (by
default, <tt>PRecEvaluator</tt> is used).
</p>
<h2>Built-in evaluators</h2>
<p>
The Alignment API offers the <tt>Evaluator</tt> interface for
implementing evaluation measures of alignments. It takes two
alignments and evaluates the second with respect to the first one (reference).
</p>
<p>
There are already some implementations available in the Alignment API implementation:
<dl>
<dt><tt>PRecEvaluator</tt></dt><dd> implements a classical precision/recall/fallout evaluation as well as the
derived measures introduced in \cite{do2002a}. Precision is the
ratio between true positive and all aligned objects; Recall is the ratio between the true positive and all
the correspondences that should have been found. It also provides
derived measures (F-measure, overall, noise, etc.).</dd>
<dt><tt>ExtPRecEvaluator</tt></dt><dd> implements a relaxed precision and recall as defined by Ehrig and Euzenat in 2005. This provides higher values for precision and recall based on the proximity of obtained results with expected results. There are three flavours of relaxed measures: symmetric, effort-based and oriented.</dd>
<dt><tt>SemPRecEvaluator</tt></dt><dd>implements the semantic
precision and recall proposed by Euzenat in 2007. This
computation may be long and requires the use of an OWL reasonner
such as Pellet.</dd>
<dt><tt>WeightedPREvaluator</tt></dt><dd>computes the classical
precision and recall measures weighted by the confidence measures
provided in the Alignements.</dd>
<dt><tt>SymMeanEvaluator</tt></dt><dd> implements a weighted symmetric difference between the entities that are in one alignment and those common to both alignments
(missing correspondences count for 0., others weight 1. complemented by the difference between their strengths).
This is thus a measure for the similarity of two alignments.
The result is here split between the kinds of entity considered (Class/Property/Individual).</dd>
<dt><tt>DiffEvaluator</tt></dt><dd>computes the difference between two
alignments classifying the correspondences in three categories
(true positive, false positive and false negative). This
evaluator does not really compute a measure (it could be used for
computing precision and recall). It is used by the <a href="aserv.html">Alignment server</a></dd>
</dl>
</p>
<h2>Batch evaluation</h2>
<p>
There is another utility (<tt>GroupEval</tt>) which allows to
implement batch evaluation. It starts with a directory containing a
set of subdirectories (like the output of the
batch <tt>GroupAlign</tt> command). Each subdirectory contains a reference alignment (usually called <tt>refalign.rdf</tt>) and a set of alignments (named <tt>matcher1.rdf</tt>... <tt>matcher3.rdf</tt>).
</p>
<p>
Invoking <tt>GroupEval</tt> with the list of files to consider (-l argument) and the set of evaluation results to provide (-f argument with profm, for precision, recall, overall, fallout, f-measure as possible measures)
returns:
<div class="fragment">
$ java -cp ../lib/procalign.jar fr.inrialpes.exmo.align.cli.GroupEval -l "refalign,matcher1,matcher2,matcher3" -f "pr" -c
</div>
</p>
<center>
<table border='2' frame='sides' rules='groups'>
<colgroup align='center' />
<colgroup align='center' span='2' />
<colgroup align='center' span='2' />
<colgroup align='center' span='2' />
<colgroup align='center' span='2' />
<thead valign='top'><tr><th>algo</th>
<th colspan='2'>refalign</th>
<th colspan='2'>matcher1</th>
<th colspan='2'>matcher2</th>
<th colspan='2'>matcher3</th>
</tr></thead><tbody><tr><td>test</td>
<td>Prec.</td>
<td>Rec.</td>
<td>Prec.</td>
<td>Rec.</td>
<td>Prec.</td>
<td>Rec.</td>
<td>Prec.</td>
<td>Rec.</td>
</tr></tbody><tbody>
<tr><td colspan="9" align="center">...</td></tr>
<tr>
<td>265-8</td>
<td>1.00</td>
<td>1.00</td>
<td>0.22</td>
<td>0.25</td>
<td>1.00</td>
<td>0.33</td>
<td>0.87</td>
<td>0.31</td>
</tr>
<tr bgcolor="lightblue">
<td>266</td>
<td>1.00</td>
<td>1.00</td>
<td>0.00</td>
<td>0.00</td>
<td>1.00</td>
<td>0.00</td>
<td>1.00</td>
<td>0.00</td>
</tr>
<tr>
<td>266-2</td>
<td>1.00</td>
<td>1.00</td>
<td>0.81</td>
<td>0.81</td>
<td>1.00</td>
<td>0.81</td>
<td>0.94</td>
<td>0.82</td>
</tr>
<tr bgcolor="lightblue">
<td>266-4</td>
<td>1.00</td>
<td>1.00</td>
<td>0.62</td>
<td>0.62</td>
<td>1.00</td>
<td>0.62</td>
<td>0.85</td>
<td>0.64</td>
</tr>
<tr>
<td>266-6</td>
<td>1.00</td>
<td>1.00</td>
<td>0.42</td>
<td>0.42</td>
<td>1.00</td>
<td>0.42</td>
<td>0.85</td>
<td>0.48</td>
</tr>
<tr bgcolor="lightblue">
<td>266-8</td>
<td>1.00</td>
<td>1.00</td>
<td>0.23</td>
<td>0.23</td>
<td>1.00</td>
<td>0.23</td>
<td>0.81</td>
<td>0.30</td>
</tr>
<tr bgcolor="yellow"><td>H-mean</td><td>1.00</td>
<td>1.00</td>
<td>0.50</td>
<td>0.52</td>
<td>0.98</td>
<td>0.56</td>
<td>0.93</td>
<td>0.53</td>
</tr>
</tbody></table>
<b>HTML Table of precision and recall results generated by <tt>GroupEval</tt>.</b>
</center>
<p>
<tt>GroupEval</tt> accepts the following arguments:
<div class="fragment">
$ java -cp lib/procalign.jar fr.inrialpes.exmo.align.cli.GroupEval --help
usage: GroupEval [options]
options are:
--format=prfot -r prfot Specifies the output order (precision/recall/f-measure/overall/time)
--output=filename -o filename Specifies a file to which the output will go
--reference=filename -r filename Specifies the name of the reference alignment file (default: refalign.rdf)
--type=html|xml|tex|ascii|triangle -t html|xml|tex|ascii Specifies the output format
--list=algo1,...,algon -l algo1,...,algon Sequence of the filenames to consider
--color=color -c color Specifies if the output must color even lines of the output
--debug[=n] -d [n] Report debug info at level n
--help -h Print this message
Alignment API implementation 4.3 (1698M) ($Id$)
</div>
</p>
<p>
Similar commands exists for different <tt>Evaluator</tt>
(unfortunately we did not found time to correctly unify this, but this
could be done). These are:
<dl>
<dt><tt>ExtGroupEval</tt></dt><dd>for <tt>ExtPRecEvaluator</tt></dd>
<dt><tt>WGroupEval</tt></dt><dd>for <tt>WeightedPREvaluator</tt></dd>
</dl>
<p>
<h2>Plot functions</h2>
<p>
There are also two classes able to plot the result of several matching systems. The first ploting function is <tt>GenPlot</tt>.
It generates the precision/recall graphs as gnu-plot files and generates a Latex file corresponding to Figure~\ref{fig:prgraph}.
<div class="fragment">
$ java -cp ../lib/procalign.jar fr.inrialpes.exmo.align.cli.GenPlot -l "refalign,edna,ASMOV..." -t tex -o prgraph.tex
</div>
</p>
<center>
<img src="img/prgraph.png" /><br />
<b>Example of precision/recall graphs in LaTeX, as plotted by <tt>GenPlot</tt>.</b>
</center>
<p>
<tt>GenPlot</tt> accepts the following arguments:
<div class="fragment">
$ java -cp /Java/alignapi/lib/procalign.jar fr.inrialpes.exmo.align.cli.GenPlot --help
usage: GenPlot [options]
options are:
--type=tsv|tex|html(|xml) -t tsv|tex|html(|xml) Specifies the output format
--graph=class -g class Specifies the class of Evaluator to be used
--evaluator=class -e class Specifies the class of GraphEvaluator (plotter) to be used
--list=algo1,...,algon -l algo1,...,algon Sequence of the filenames to consider
--debug[=n] -d [n] Report debug info at level n
--help -h Print this message
</div>
The plots are provided for PGF LaTeX as gnuplot tables.
The HTML plot uses the Google chart API.
The CSV version should help importing in a spreadsheet.
</p>
<p>
The <tt>-e</tt> uses an extension of the <tt>GraphEvaluator</tt>
abstract class, i.e., an evaluator which computes a list
of <tt>Pair</tt> objects representing points on a plot. Such lists
of pairs are used by the <tt>GenPlot</tt> command line utility. This
abstract class does not implements the <tt>Evaluator</tt> interface
but its implementation may use such evaluators. This is the case of
the available:
<dl>
<dt><tt>PRGraphEvaluator</tt></dt><dd>for plotting precision-at-<i>n</i> graphs or precision recall graphs.
This class implements an accurate computation of the values. It also
computes MAP (mean average precision).</dd>
<dt><tt>AveragePRGraphEvaluator</tt></dt><dd>is also for plotting
precision-at-<i>n</i> graphs with the classical way of doing it:
interpolating missing values and forcing monotonic behaviour. It
also computes the MAP.</dd>
<dt><tt>ROCCurveEvaluator</tt></dt><dd>computes the Receiver operating
characteristic or ROC curves. It also computes the area under
curves (AUC).</dd>
<dt><tt>ThresholdGraphEvaluator</tt></dt><dd>computes the graph
representing a measure (precision, recall, F-measure) in function of
a confidence measure threshold. For each threshold, and for each
alignment, the value of the measure is computed.</dd>
</dl>
</p>
<p>
A simpler representation places each system in a plane so that their position corresponds to their distance from 0 precision and 0 recall.
This graphic representation is obtained through the <tt>GroupEval</tt>
class by generating a Latex file corresponding in the following figure.
<div class="fragment">
$ java -cp ../lib/procalign.jar fr.inrialpes.exmo.align.cli.GroupEval -t triangle -l "refalign,matcher1,matcher2,..." > triangle.tex
</div>
</p>
<center>
<img src="img/triangle.png" /><br />
<b>Another representation of precision and recall generated by <tt>GroupEval</tt>: the closer to the top, the
better.</b>
</center>
<h2>Implementing and extending the API</h2>
<p>A (default) impplementation of this API can be found in
the <tt>fr.inrialpes.exmo.align.impl</tt> package.</p>
<p>
Creating new evaluators requires to implement the <tt>Evaluator</tt> interface.
The implementation of the API provides a <tt>fr.inrialpes.exmo.align.impl.BasicEvaluator</tt> which
implements an abstract container for the evaluation (it has no <tt>eval</tt> method).
The <tt>BasicEvaluator</tt> defines the storage
sructures for alignment, but that is all.
</p>
<p>
Implementing a particular evaluator thus consists in creating a new subclass of
<tt>BasicEvaluator</tt> and implementing its <tt>eval</tt> method that will compare
two alignments (the first one can be considered as the reference
alignment).
</p>
<p>Adding new evaluations methods amounts to create a
new <tt>Evaluator</tt>
class implementing the interface. Generally, this can extend the
proposed <tt>fr.inrialpes.exmo.align.impl.BasicEvaluator</tt>
proposed <tt>BasicEvaluator</tt>
class.</p>
<p>The <tt>BasicEvaluator</tt> has the good taste of defining the storage
sructures for alignment, but that is all.</p>
<p>The <tt>BasicEvaluator</tt> has been extended so as to provide
different evaluation:
<dl>
<dt><tt>PRecEvaluator</tt></dt><dd>computes
Precision/Recall rates as well as derived measures.</dd>
<dt><tt>ExtPRecEvaluator</tt></dt><dd>provide the relaxed precision
and recall as defined in a paper by Ehrig and Euzenat in 2005.</dd>
<dt><tt></tt></dt><dd></dd>
</dl>
</p>
</p>
<address>
<small>
<hr />
<center>http://alignapi.gforge.inria.fr/align.html</center>
<center>http://alignapi.gforge.inria.fr/eval.html</center>
<hr />
$Id$
</small>
......
html/img/prgraph.png 0 → 100644
+ 0
− 0
View file @ bdc47632
html/img/prgraph.png

53.3 KiB

html/img/triangle.png 0 → 100644
+ 0
− 0
View file @ bdc47632
html/img/triangle.png

52.5 KiB

html/index.html
+ 3
− 3
View file @ bdc47632
......@@ -47,7 +47,7 @@ New Alignment API 4.3. <a href="http://gforge.inria.fr/frs/?group_id=117">Get it
<li>Piping alignment algorithms (improving an existing alignment);</li>
<li>Manipulating (thresholding and hardening);</li>
<li>Generating processing output (transformations, axioms, rules);</li>
<li>Comparing alignments.</li>
<li>Generating tests and comparing alignments (diff, precision, recall).</li>
</ul>
</p>
......@@ -71,7 +71,7 @@ Hence, it is <i>not</i> a matcher. A few examples of trivial matchers are provid
Taking such examples, which can be programmed in a couple of hours, as
real matchers and comparing this with other matchers is meaningless
(only when these matchers are worse than that, this is a meaningful result).
Moreover, mentionning that these systems have been compared with "The
Moreover, mentioning that these systems have been compared with "The
Alignment API" without qualification is <i>not</i> appropriate. So
please, compare your systems with serious competitors (hint: those
which publish papers telling that their systems are good matchers; you
......@@ -137,7 +137,7 @@ the <a href="edoal.html">Expressive and Declarative Ontology Alignment Language
<p><dl>
<dt><a href="neontk/">NeOn Alignment plug-in</a></dt>
<dd>Alignment API and server plug-in for the NeOn toolkit.</dd>
<dt><a href=""></a>Microalign</dt>
<dt><a href="micro.html">Microalign</a></dt>
<dd>Stripped down Alignment API and implementation for Android.</dd>
</dl>
</p>
......
html/micro.html 0 → 100644
+ 147
− 0
View file @ bdc47632
<html>
<head>
<title>Alignment API: lightweight versions</title>
<link rel="stylesheet" type="text/css" href="base.css" />
<link rel="stylesheet" type="text/css" href="style.css" />
</head>
<body bgcollor="#ffffff">
<h1 class="titre">Alignment API: lightweight versions</h1>
<p>
Because we want the Alignment API to be used in resource-limited
environments, we experiment with offering minimal versions.
</p>
<p>
The <tt>plugins/android</tt> folder contains necessary tools for generating
stripped down versions of the Alignment API so that they can be embedded in a small
platform (the target being the Android platform for
our <a href="http://swip.inrialpes.fr">own purposes</a>).
</p>
<h2>Microalign</h2>
<p>
So far, we only offer a client version of the API implementation
which should be suitable for any program which simply wants to
retrieve and manipulate alignments. This version does not embark any matcher,
evaluator, <span color="red">test generator</span>, server, or command
line interfaces. So if you have implemented a matcher, it should work
simply with this version. Microalign can still act as a client for the
Alignment server and retrieve alignments from the server.
</p>
<h3>What is included/excluded</h3>
<pre>
+ org.semanticweb.owl.align (API)
+ fr.inrialpes.exmo
+ .ontowrap (Ontology API wrappers)
- .* (All implementations)
+ .align (Implementation)
- .cli (Command line interface)
+ .util (Utility classes)
- .gen (Test generator)
- .service (Alignement server)
+ .impl (Basic implementation)
- .eval (Evaluators)
- .matchers (Matchers)
+ .parser (Parsers)
</pre>
<p>
Only the libraries related to Jena are needed:
Jena (+ icu4j and iri), log4j, xerces (+resolver) and xsdlib (+relaxngDatatype).
</p>
<h3>Further stripping</h3>
<p>
We are currently experimenting with <a href="http://proguard.sourceforge.net/">ProGuard</a> in order
to strip down the code further. The results are displayed with the "*"
prefix in the table below.
</p>
<h3>How to generate</h3>
<p>
It is necessary to go in the plugin/android directory and use the ant file.
<pre>
$ ant compileall ==> compile the strict necessary
$ ant jar ==> generate the microalign.jar library
$ ant zip ==> gerenate the malign.zip file with necessary jars
$ ant testindep ==> recompile the sources in isolation for testing independence
$ ant clean ==> restore the initial state of this directory
$ ant shrink ==> uses proguard to shrink the Jar file (experimental)
</pre>
</p>
<h3>How to use</h3>
<p>Move the content of the <tt>microalign.zip</tt> file in the lib(s) directory of your Android project.
</p>
<p>The <tt>microalign.jar</tt> may be used alone if a version of Jena is already embedded.</p>
<h2>Other profiles</h2>
<p>
Of course, you can define other profiles by modifying the build.xml file.
</p>
<p>
We are considering, introducing a pair of other profiles:
<dl>
<dt>align</dt><dd>the API itself, without any implementation, is already a minimal
version of the API which requires no additional libraries;</dd>
<dt>picoalign</dt><dd>an even smaller package without jena and edoal;</dd>
<dt>microalign</dt><dd>The procalign.jar generated here is called microalign.jar and contains
around 30k of ontowrap.jar.</dd>
<dt>aservlite</dt><dd>a minimal Alignment server version.</dd>
</dl>
</p>
<!--p>
One can further imagine dropping more from the API, i.e., suppressing
the alignment RDFParser (which requires Jena) and the whole Jena. This would lead
to the inability to parse EDOAL, so it could be suppressed as well. We
call the bare minimal version picoalign. However, some rendering
classes make reference to EDOAL and the AligmnentParser itself refers
to the RDFParser. Hence, producing picoalign would require
reengineering the code further.
</p-->
<p>
The resulting sizes to be embedded are the following:
<center>
<table border="1">
<th><td>standard</td><td>micro</td><td>micro*</td><td>pico</td><td>align</td></th>
<tr><td>align.jar</td><td>16k</td><td>16k</td><td>16k</td><td>16k</td><td>16k</td></tr>
<tr><td>ontowrap.jar</td><td>61k</td><td>-</td><td></td><td></td><td></td></tr>
<tr><td>procalign.jar</td><td>238k</td><td>154k</td><td>95k?</td><td>152k</td><td></td></tr>
<tr><td>alignsvc.jar</td><td>98k</td><td>-</td><td></td><td></td><td></td></tr>
<tr><td>lib</td><td>29232k</td><td>7444k</td><td>7444k</td><td>2272k</td><td></td></tr>
</table>
</center>
</p>
<p>
It is clear that the only interest of
picoalign comes from dropping Jena. One can also use <a href="http://code.google.com/p/androjena/">androjena</a>
which amounts to 5332k (version 0.5 12/2010; all Jena libs involved).
<a href="http://poseidon.ws.dei.polimi.it/ca/?page_id=59">&mu;jena</a> is a rewritting of Jena for MIDP-2.0/CLDC-1.1
mobile phones (but some have managed to use it under Android). It has
been developed in 2007, but the 1.5 version dates back to 2010.
It only weights 393k but can only parse ntriples. The authors have
been able to demonstrate its use in running an ontology matcher (XSom)
on a phone!
</p>
<address>
<small>
<hr />
<center>http://alignapi.gforge.inria.fr/micro.html</center>
<hr />
$Id$
</small>
</address>
</body>
</html>
html/testgen.html
+ 27
− 25
View file @ bdc47632
......@@ -9,9 +9,9 @@
<h1 class="titre">Alignment API: test generation framework</h1>
<p>The Alignment API implementation offers facilities to
automatically generate data test sets that can be used for
automatically generate test sets that can be used for
evaluating alignments.</p>
<p>These facilities works only on OWL ontologies and are dependent on
<p>These facilities work only on OWL ontologies and are dependent on
the Jena API (which is included in the API lib directory).</p>
<p>It allows for generating altered ontologies from a seed ontology
and generating the reference alignment between the two ontologies).</p>
......@@ -20,9 +20,6 @@
<h3>Generating tests from the command line</h3>
<center>
<img width="72%" src="img/testgeneration.png">
</center>
<p>
It is possible to use the command line command <tt>TestGen</tt> in
order to generate tests.
......@@ -37,13 +34,17 @@ such that:
<li>seed ontology is the ontology which is altered for producing the test;</li>
<li>outputurl is the url prefix that will be used for the generated ontology;</li>
<li>outputdir is the directory in which the test will be generated;</li>
<li>-Dparameter=value are the parameters used for generating this tests (see Alterator section below)</li>
<li>-Dparameter=value are the parameters used for generating this tests (see <tt>Alterator</tt> section below).</li>
</ul>
For instance:
<div class="fragment">
$ java -Xmx1200m -cp $JAVALIB/procalign.jar fr.inrialpes.exmo.align.cli.TestGen -u http://example.com/mynewtest -o mynewtest -DremoveComments=1. -DrenameClasses=.75 -DremoveProperties=.5 biblio.owl
$ java -Xmx1200m -cp $JAVALIB/procalign.jar fr.inrialpes.exmo.align.cli.TestGen -u http://example.com/mynewtest -o mynewtest -DremoveClasses=.4 -DnoHierarchy=1. -DrenameProperties=1. biblio.owl
</div>
applies the modification of the following figure:
</p>
<center>
<img width="72%" src="img/testgeneration.png">
</center>
<p>
It may also be used for generating a whole test set (see below) by:
<div class="fragment">
......@@ -80,7 +81,8 @@ for generating a test set (here <tt>BenchmarkGenerator</tt>).
<h2>Ontology alterators</h2>
<p>
The tests are generated from the notion of <tt>Alterators</tt>.
The tests are generated from the notion of <tt>Alterators</tt>, instances of
the <tt>fr.inrialpes.exmo.align.gen.Alterator</tt>.
Ontology alterators are classes, implementing
the <tt>Alterator</tt> interface.
</p>
......@@ -88,9 +90,7 @@ the <tt>Alterator</tt> interface.
<img width="36%" src="img/alterator.png">
</center>
<p>
The test framework is based on the notion of <tt>Alterator</tt> instances of
the <tt>fr.inrialpes.exmo.align.gen.Alterator</tt>. An
alterator, takes as input an ontology (Jena <tt>OntModel</tt>) and an
An alterator, takes as input an ontology (Jena <tt>OntModel</tt>) and an
alignment (<tt>Alignment</tt>) and generates an altered ontology and
alignment. Following the schema of the figure.
</p>
......@@ -111,7 +111,7 @@ The available predefined alterators are:
<dd>adds <i>p</i>% properties.</dd>
<dt>FlattenLevel [levelFlattened=<i>n</i>]</dt>
<dd>removes all classes of level <i>n</i> (their subclasses are
directly conenected to their superclasses).</dd>
directly connected to their superclasses).</dd>
<!--dt>RemoveClassLevel []</dt>
<dd></dd-->
<dt>RemoveClasses [removeClasses=<i>p</i>]</dt>
......@@ -143,11 +143,11 @@ only to write the <tt>modify( Properties )</tt> method if it extends
<tt>BasicAlterator</tt>.
</p>
<p>
An alterator follows a particulat lifecycle:
An alterator follows a particular lifecycle:
</p>
<h4>Creation</h4>
<p>
The Alterator is created either:
The <tt>Alterator</tt> is created either:
<ul>
<li>from a seed ontology and generate the alignment between this ontology itself</li>
<li>from a previous alterator from which it will take the output ontology and alignment as input.</li>
......@@ -192,7 +192,7 @@ public ClassHierarchy getHierarchy();
It is often useful to relocate the results, i.e., to change their
namespaces in both the ontologies and alignments to output. This is
achieved with the following methods (the namespaces are those of the
source and target ontology respectively):
source and target ontologies respectively):
<div class="owl" id="qu1"><pre>
public void relocateTest( String namespace1, String namespace2 );
public void relocateTest( String namespace2 );
......@@ -213,8 +213,8 @@ public OntModel getModifiedOntology();
<p>
Full test sets can be generated from one seed ontology (see Figure). For that
purpose, the structure of the test set is defined through a
structure which described how a test is generated from scratch or from
purpose, the test set is defined through a
structure which describes how a test is generated from scratch or from
other tests in the test set.
</p>
<center>
......@@ -239,7 +239,11 @@ is able to parse).
<h4>Adaptive benchmark generator</h4>
<p>Not available yet.</p>
<p>
The <tt>DiscriminatGenerator</tt> class is a template to generate
a test set altering regularly one or several dimensions (each one
represented by an alterator).
</p>
<h4>Hidden ontology generator</h4>
......@@ -249,14 +253,12 @@ is able to parse).
<p>
Designing a whole test set can be achieved, as it is done for
Benchmarks, by extending the <tt>TestSet</tt> class and creating
Benchmarks, by extending the <tt>TestSet</tt> abstract class and creating
a hierarchy of tests (each one built from another; but this can be
achieved by having all tests generated from the init ontology).
</p>
<p>
New test sets can be obtained by extending the <tt>TestSet</tt>
abstract class. The only abstract method is:
The only abstract method is:
<div class="owl" id="qu1"><pre>
public abstract void initTestCases( Properties params );
</pre></div>
......@@ -271,7 +273,7 @@ void addTestChild( String labelParentTest, String labelNewTest,
Properties alterationSpecification );
</pre></div>
<tt>initTestCases</tt> is only used for creating this structure which
will be later processed to generate a particular test from a precise
will be later processed to generate a particular test set from a precise
seed ontology and various modalities (in particular if each test will
be generated intependently of the others (random) or if they will be
generated incrementally by further alterating previous tests (continuous).
......@@ -283,14 +285,14 @@ generated incrementally by further alterating previous tests (continuous).
Ontology network alterators obey to the <tt>OntologyNetworkWeakener</tt> interface.
This interface is very simple since it consists of one single
method: <tt>weaken</tt> taking as argument an onology network, an int
(absolute value) or a double (percentage) characterizing the amount of
(absolute value) or a double (percentage) characterising the amount of
alteration and a set of optional parameters in a <tt>Properties</tt>
object.
Each alterator returns a brand new ontology network with eventually
modified alignments.
</p>
<p>
Ontology network alterators cannot be obtained at command line.
Ontology network alterators cannot be used from command line.
</p>
<h3>Predefined network alterators</h3>
<p>
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment