You are viewing a plain text version of this content. The canonical link for it is here.
Posted to user@uima.apache.org by José Vicente Moyano Murillo <mo...@aia.es> on 2017/03/09 10:23:08 UTC
Re: Using RUTA
Hi Peter
We have prepared a short test with 2 methods.
The first one is using #, the second one is using %
We expect the same behaviour. But as you will see there are diferences.
Regards
2017-02-28 16:00 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> hmmm ok, maybe my example for testing the rule was too simple.
>
> I will create a more complex example and check the results
>
>
> Peter
>
>
> Am 28.02.2017 um 15:38 schrieb José Vicente Moyano Murillo:
> > Hi Peter,
> >
> > I'm sorry but this example does not work properly. It seems that it is a
> > problem regarding conjunction rules (%)
> >
> > This is our test case and result.
> >
> > We have a book with 5 attributes
> > - name
> > - author
> > - pages
> > - ISBN
> > - Category
> >
> > The rule is validatin name and author.
> >
> > RUTA creates the annotation with the list but the list contains 20 times
> > the las attribute (Category).
> >
> > If we use # it works perfectly. But in general we must use %
> >
> > May be this information will help you.
> >
> > Many thanks
> >
> >
> >
> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pk...@gmail.com>:
> >
> >> Hi,
> >>
> >>
> >> operations directly on lists and arrays are on my todo list but not yet
> >> implemented.
> >>
> >>
> >> Right now, there are still some options like a variable or restricted
> >> assignments.
> >>
> >>
> >> Here's an example with an ANNOTATIONLIST variable:
> >>
> >>
> >> ANNOTATIONLIST list;
> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> >> a1:Attribute{a1.name=="title", a1.ct=="Norse Mythology" ->
> >> ADD(list,a1)}
> >> % a2:Attribute{a2.name=="author", a2.ct=="Neil Gaiman" ->
> >> ADD(list,a2)};
> >> };
> >>
> >>
> >> Variables are global, so you need to clear the list maybe somewhere,
> >> e.g. before the first ADD.
> >>
> >>
> >> In the current trunk, something like the following is also possible:
> >>
> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> >> .name=="title", Attribute.name=="author")})}....
> >>
> >>
> >> Best,
> >>
> >>
> >> Peter
> >>
> >>
> >> Am 28.02.2017 um 14:06 schrieb José Vicente Moyano Murillo:
> >>> Hi Peter, we have another question regarding the same example.
> >>>
> >>> Right now all is working properly (many thanks) and it seems that
> >>> 2.5.1-SNAPSHOT it's fine.
> >>>
> >>> Now we are planning to store some information in the created
> annotation.
> >> We
> >>> want to store all the attributes that matches the RUTA rule.
> >>>
> >>> It is possible to store a1 and a2 in a feature (attributes) of
> NeilsBook?
> >>>
> >>> The example:
> >>>
> >>> Book{-> NeilsBook}<-{
> >>> a1:Attribute{a1.name=="title", a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name=="author", a2.ct=="Neil Gaiman"};
> >>> };
> >>>
> >>> We are using this aproach:
> >>>
> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> >>> a1:Attribute{a1.name=="title", a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name=="author", a2.ct=="Neil Gaiman"};
> >>> };
> >>>
> >>> This example works but it is storing all the annotations "Attribute"
> >>> covered by "Book" and we just want the attributes that matches the
> rule.
> >>>
> >>> Thanks in advance.
> >>>
> >>>
> >>>
> >>>
> >>> 2017-02-24 10:29 GMT+01:00 José Vicente Moyano Murillo <moyanoj@aia.es
> >:
> >>>
> >>>> Many thanks Peter ¡¡¡
> >>>>
> >>>> 2017-02-24 9:46 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> >>>>
> >>>>> Hi,
> >>>>>
> >>>>>
> >>>>> the repo:
> >>>>>
> >>>>> <repository>
> >>>>> <id>apache.snapshots</id>
> >>>>> <name>Apache Snapshot Repository</name>
> >>>>> <url>http://repository.apache.org/snapshots</url>
> >>>>> <releases>
> >>>>> <enabled>false</enabled>
> >>>>> </releases>
> >>>>> </repository>
> >>>>>
> >>>>>
> >>>>> the folder:
> >>>>>
> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> >>>>>
> >>>>>
> >>>>> Best,
> >>>>>
> >>>>> Peter
> >>>>>
> >>>>>
> >>>>>
> >>>>> Am 23.02.2017 um 13:47 schrieb José Vicente Moyano Murillo:
> >>>>>> Hi,
> >>>>>>
> >>>>>> ruta-core.jar it's enough.
> >>>>>>
> >>>>>> It will be fantastic if i could access the snapshot repository.
> >>>>>>
> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> >>>>>>
> >>>>>>> Hi,
> >>>>>>>
> >>>>>>>
> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> >> plugins/update
> >>>>>>> site?
> >>>>>>>
> >>>>>>> I will prepare a new RC for the next release soon.
> >>>>>>>
> >>>>>>> There should be snapshot artifacts built by jenkins in the snapshot
> >>>>>>> repository. I am out-of-office today so do not have the link right
> >>>>> now. (If
> >>>>>>> you want to build it yourself, the svn source repo can be accessed
> by
> >>>>>>> anyone)
> >>>>>>>
> >>>>>>>
> >>>>>>> Best,
> >>>>>>>
> >>>>>>>
> >>>>>>> Peter
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>> Am 23.02.2017 um 08:06 schrieb José Vicente Moyano Murillo:
> >>>>>>>
> >>>>>>>> Hi Peter, good morning.
> >>>>>>>>
> >>>>>>>> Have we any opportunity to get a fixed version? I mean a snapshot
> or
> >>>>> an
> >>>>>>>> access to the repo.
> >>>>>>>>
> >>>>>>>> Regards
> >>>>>>>>
> >>>>>>>> 2017-02-22 10:38 GMT+01:00 José Vicente Moyano Murillo <
> >>>>> moyanoj@aia.es>:
> >>>>>>>> you're right
> >>>>>>>>> % is performing some kind of "or".
> >>>>>>>>>
> >>>>>>>>> So we will wait for the new release.
> >>>>>>>>>
> >>>>>>>>> Many thanks
> >>>>>>>>>
> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klügl <peter.kluegl@averbis.com
> >:
> >>>>>>>>>
> >>>>>>>>> I actually wonder why your rules work. I am quite sure that they
> >>>>> match
> >>>>>>>>>> too often, i. e. they match also if only one of the conjunct
> rule
> >>>>>>>>>> elements match.
> >>>>>>>>>>
> >>>>>>>>>> You can simply try that by using a wrong string in the check
> like
> >>>>> "NG"
> >>>>>>>>>> instead of "Neil Gaiman"
> >>>>>>>>>>
> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and will be
> >>>>> part of
> >>>>>>>>>> the next release.
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Best,
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Peter
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klügl:
> >>>>>>>>>>
> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed. I'll
> >>>>> investigate
> >>>>>>>>>> it.
> >>>>>>>>>>
> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb José Vicente Moyano Murillo:
> >>>>>>>>>>>
> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> >>>>>>>>>>>>
> >>>>>>>>>>>> We tried the first option using Conjunct rules and as you said
> >> it
> >>>>> does
> >>>>>>>>>>> not
> >>>>>>>>>>> work with version 2.5.0. But we change a little your example
> and
> >> it
> >>>>>>>>>>> works
> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> >>>>>>>>>>>> We use theses examples with success:
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{Attribute.name=="author",
> >>>>>>>>>>>> Attribute.ct=="Neil
> >>>>>>>>>>>> Gaiman"};"
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{FEATURE("name","title"), FEATURE("ct",
> "Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology")}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> >>>>>>>>>>>> a1:Attribute and a2:Attribute
> >>>>>>>>>>>>
> >>>>>>>>>>>> In any case thank you very much for your help.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klügl <
> >> peter.kluegl@averbis.com
> >>>>>> :
> >>>>>>>>>>>> Hi,
> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules construct to
> >>>>> specify
> >>>>>>>>>>>> an
> >>>>>>>>>>> AND between two rule element independent of the position:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name=="title", a1.ct=="Norse
> Mythology"}
> >>>>>>>>>>>>> % a2:Attribute{a2.name=="author", a2.ct=="Neil
> Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> However, I just noted that there is a problem with conjunct
> >>>>> rules. I
> >>>>>>>>>>>>> haven't used it in a long time and the test coverage much
> lower
> >>>>> than
> >>>>>>>>>>>> the
> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix it.
> >>>>>>>>>>>>> Without conjunct rules, you need some boolean variables for
> >>>>> cheking
> >>>>>>>>>>>> the
> >>>>>>>>>>> AND, which looks all but declarative:
> >>>>>>>>>>>>> BOOLEAN ft, fa;
> >>>>>>>>>>>>> FOREACH(book) Book{}{
> >>>>>>>>>>>>> book{-> ft = false, fa = false};
> >>>>>>>>>>>>> book->{a1:Attribute{a1.name=="title", a1.ct=="Norse
> >>>>>>>>>>>>> Mythology"->
> >>>>>>>>>>>>> ft=true};};
> >>>>>>>>>>>>> book->{a2:Attribute{a2.name=="author", a2.ct=="Neil
> >>>>> Gaiman"->
> >>>>>>>>>>>>> fa=true};};
> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ... or with a BLOCK...
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> BLOCK(book) Book{}{
> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> >>>>>>>>>>>>> a1:Attribute{a1.name=="title", a1.ct=="Norse
> Mythology"->
> >>>>>>>>>>>>>
> >>>>>>>>>>>> ft=true};
> >>>>>>>>>>> a2:Attribute{a2.name=="author", a2.ct=="Neil Gaiman"->
> >>>>> fa=true};
> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If the order of the attributes is known, you can avoid the
> AND
> >>>>> check
> >>>>>>>>>>>> and
> >>>>>>>>>>> just specify a sequential constraint:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name=="title", a1.ct=="Norse
> Mythology"}
> >>>>>>>>>>>>> # a2:Attribute{a2.name=="author", a2.ct=="Neil
> Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you need to check on the complete title with the URL, you
> >> can
> >>>>>>>>>>>> replace
> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Best,
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Peter
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb José Vicente Moyano Murillo:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Hello everyone
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I'm planning to use RUTA to create some annotations. But i'm
> >> not
> >>>>>>>>>>>>> able to
> >>>>>>>>>>> accomplish my objective.
> >>>>>>>>>>>>>> This is my case right now:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have a text annotated with some annotations "*Book*".
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> >> "*Attribute*"
> >>>>>>>>>>>>>> that
> >>>>>>>>>>>>>> stores some information about the book. Each "*Attribute*"
> >> has a
> >>>>>>>>>>>>> feature
> >>>>>>>>>>> "
> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one "*Book*"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> annotation).
> >>>>>>>>>>> And example could be a text with 2 "*Book*" annotations:
> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" -> covered
> >>>>> text:
> >>>>>>>>>>>>> "Norse
> >>>>>>>>>>> Mythology
> >>>>>>>>>>>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "Neil
> >>>>>>>>>>> Gaiman"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" -> covered
> >>>>> text:
> >>>>>>>>>>>>> "Never
> >>>>>>>>>>> Never
> >>>>>>>>>>>>>> <http://www.barnesandnoble.com/w/never-never-james-
> patterson
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> /1123863634;
> >>>>>>>>>>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> >>>>>>>>>>>> atgap08?ean=
> >>>>>>>>>>> 9780316433174>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "James
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Patterson"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I need to respect this schema but i have this question:
> >>>>>>>>>>>>>> It is possible to create and annotation over a book for a
> >> given
> >>>>>>>>>>>>> author
> >>>>>>>>>>> name
> >>>>>>>>>>>>>> and a given title name?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Thank's in advance
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>
>
>
Re: Using RUTA
Posted by José Vicente Moyano Murillo <mo...@aia.es>.
Hi,
Thanks Peter for your hard work.
Right now we are using BLOCKs and boolean variables to acomplish our
objective. And we can say that all works great.
Regarding the labels and what can be done; we agree that it is difficult to
make a decision.
Once again many thanks.
2017-03-22 17:34 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> Hi,
>
>
> Am 15.03.2017 um 10:24 schrieb José Vicente Moyano Murillo:
> > Great explanation Peter, we see all your comments.
> > Maybe we are doing something wrong to accomplish our pourpouse.
> >
> > But regarding labels. Can we discuss this example?
> >
> > Document{ -> ADD(list, w1), ADD(list, w2), ADD(list, w3), ADD(list, w4),
> > CREATE(Detection, "anchors" = list)} <- {
> > w1:CW{w1.ct=="A" }
> > %
> > w2:CW{w2.ct=="B" }
> > %
> > w3:CW{w3.ct=="B" }
> > %
> > w4:CW{w4.ct=="A" };
> > };
> >
> > In our mind conjuntion rules are aplyed using something like this
> pattern:
> >
> > FOR (PERMUTATION(w1, w2, w3, w4))
> > IF(CONJUNCTION) -> THEN
> >
> >
> > In other words we spect some kind of "interruption" to execute the THEN
> > statement
>
> There is not explicit interruption. The execution is much more
> "brute-force" using the usual ruta rule behavior.
>
> I just summarize my interpretation a bit although you probably know all
> of that already:
>
> There are two special language constructs: an inlined rule as condition
> and a conjunct rule element. For validating the condition of the main
> rule element (Document), the inlined rules need to be validated, meaning
> one of the inlined rules sto match. So, Ruta starts by trying to apply
> the first rule, which is the only rule in this example. The rule
> consists of some conjunct rule elements. Therefore, the rule element
> starts to apply each conjunct rule element separately and all rule
> element matches are remembered/stored. If at least one rule element
> match for each of the conjunct rule elements matched successfully, then
> the actions of all successful rule element matches are executed. If the
> inlined rule was able to match, then the actual rule element matched
> successfully, and the rule matched successfully, and the actions of the
> actual rule are executed.
>
>
> > But it seems that right now, all the permutations are inspected and then
> > the necessary annotations are created and, obviously, w1, w2, w3, w4 have
> > the values of the last iteration.
>
> Yes, since the matching conditions of the conjuncted rule elements are
> equal, the successful rule element matches should build all
> permutations. The variables of the labels (w1,w2...) have the value of
> the last match of the rule element even if it was not successful, the X.
>
> > What do you think?
> >
> >
>
> I am still wondering about what should/can be done to improve this
> situation/use case. If I override the value of the label variables with
> null for an unsuccessful match, it would not solve the problem in this
> current example. Resetting the value to the last valid one makes only
> sense for the conjunct rule, but will be very problematic in all other
> cases.
>
> What I previously did in such cases, was to introduce a new language
> construct that supports the current need, e.g., the conjunct rules.
> Right now, the expressiveness of ruta is high enough that this should
> not happen too often. On the other hand, maybe stepping back a bit and
> looking at the problem to be solved from a different perspective is a
> better approach. Maybe this should not be solved with labels and
> conjunct rules, but maybe rather with something else like
> ONLYONCE/ONLYFIRST, a boolean variable, or a new inlined rule....
>
> Best,
>
> Peter
>
> >
> >
> >
> >
> >
> >
> > 2017-03-13 18:05 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> >
> >> Hi,
> >>
> >>
> >> Am 13.03.2017 um 17:41 schrieb José Vicente Moyano Murillo:
> >>> From our point of view we would expect the same result using # or %
> >> Yes, I thought the same, but after investigating the problem I changed
> >> my mind a bit.
> >> Even if we ignore the label expression overriding the values with 'X's,
> >> there is still a difference. The wildcard # introduces a sequential
> >> constraint, and the conjunction % does not. The former implies a match
> >> only for the next occureence of a valid annotation. And the latter? I
> >> would initially say that the match should not be restricted to the first
> >> one, meaning the first rule element for example will match twice as does
> >> the fourth rule element. This would result in four 'A's in the list
> >> compared to the two for the wildcard.
> >>
> >> And there is also the difference that the execution of the action is
> >> decoupled from the specific rule elements in the conjunct element
> >> (causing the initial problem with the label expression)
> >>
> >>> In any case it is our idea and the truth is that we do not know how to
> >>> predict the impact.
> >> I can totally understand that. I had to debug the implementation myself
> >> quite a bit in order to get to know what is going on. That does not
> >> happen too often to me concerning ruta.
> >>
> >> I am open to suggestions how this situation can be improved. I am not
> >> sure yet what should/can be done.
> >>
> >> Best,
> >>
> >> Peter
> >>
> >>> regards
> >>>
> >>> 2017-03-13 10:56 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> >>>
> >>>> Hi,
> >>>>
> >>>>
> >>>> there is a conceptual problem when using label expressions in those
> >>>> conjunct rules. The label expression stores the value of the matched
> >>>> annotations even if the rule element does not match. It has to since
> the
> >>>> matched annotation may be used to validate the conditions as you do.
> >>>>
> >>>> Maybe the value should be reset if the rule element does not match
> >>>> correctly, but I have to investigate the consequences furhter before I
> >>>> implement this change. Are there opinions?
> >>>>
> >>>>
> >>>> If you change the rule to not use the label expression in the action,
> >>>> there still seems to be a problem with the conjunct rules. e.g. like:
> >>>>
> >>>> Document{ -> CREATE(Detection, "anchors" = list)} <- {
> >>>> w1:CW{w1.ct=="A" -> ADD(list, CW)}
> >>>> %
> >>>> w2:CW{w2.ct=="B" -> ADD(list, CW)}
> >>>> %
> >>>> w3:CW{w3.ct=="B" -> ADD(list, CW)}
> >>>> %
> >>>> w4:CW{w4.ct=="A" -> ADD(list, CW)};
> >>>> };
> >>>>
> >>>>
> >>>> This looks like a bug when validating the match itself depednent on
> the
> >>>> element matches. I need to investigate that further...
> >>>>
> >>>>
> >>>> I'll create a jira ticket for both.
> >>>>
> >>>>
> >>>> Best,
> >>>>
> >>>>
> >>>> Peter
> >>>>
> >>>>
> >>>>
> >>>> Am 09.03.2017 um 11:23 schrieb José Vicente Moyano Murillo:
> >>>>> Hi Peter
> >>>>>
> >>>>> We have prepared a short test with 2 methods.
> >>>>> The first one is using #, the second one is using %
> >>>>>
> >>>>> We expect the same behaviour. But as you will see there are
> diferences.
> >>>>>
> >>>>> Regards
> >>>>>
> >>>>> 2017-02-28 16:00 GMT+01:00 Peter Klügl <peter.kluegl@averbis.com
> >>>>> <ma...@averbis.com>>:
> >>>>>
> >>>>> hmmm ok, maybe my example for testing the rule was too simple.
> >>>>>
> >>>>> I will create a more complex example and check the results
> >>>>>
> >>>>>
> >>>>> Peter
> >>>>>
> >>>>>
> >>>>> Am 28.02.2017 um 15:38 schrieb José Vicente Moyano Murillo:
> >>>>> > Hi Peter,
> >>>>> >
> >>>>> > I'm sorry but this example does not work properly. It seems
> that
> >>>>> it is a
> >>>>> > problem regarding conjunction rules (%)
> >>>>> >
> >>>>> > This is our test case and result.
> >>>>> >
> >>>>> > We have a book with 5 attributes
> >>>>> > - name
> >>>>> > - author
> >>>>> > - pages
> >>>>> > - ISBN
> >>>>> > - Category
> >>>>> >
> >>>>> > The rule is validatin name and author.
> >>>>> >
> >>>>> > RUTA creates the annotation with the list but the list contains
> >>>>> 20 times
> >>>>> > the las attribute (Category).
> >>>>> >
> >>>>> > If we use # it works perfectly. But in general we must use %
> >>>>> >
> >>>>> > May be this information will help you.
> >>>>> >
> >>>>> > Many thanks
> >>>>> >
> >>>>> >
> >>>>> >
> >>>>> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
> >>>>> <ma...@gmail.com>>:
> >>>>> >
> >>>>> >> Hi,
> >>>>> >>
> >>>>> >>
> >>>>> >> operations directly on lists and arrays are on my todo list
> but
> >>>>> not yet
> >>>>> >> implemented.
> >>>>> >>
> >>>>> >>
> >>>>> >> Right now, there are still some options like a variable or
> >>>>> restricted
> >>>>> >> assignments.
> >>>>> >>
> >>>>> >>
> >>>>> >> Here's an example with an ANNOTATIONLIST variable:
> >>>>> >>
> >>>>> >>
> >>>>> >> ANNOTATIONLIST list;
> >>>>> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> >>>>> >> a1:Attribute{a1.name <http://a1.name>=="title",
> >>>>> a1.ct=="Norse Mythology" ->
> >>>>> >> ADD(list,a1)}
> >>>>> >> % a2:Attribute{a2.name <http://a2.name>=="author",
> >>>>> a2.ct=="Neil Gaiman" ->
> >>>>> >> ADD(list,a2)};
> >>>>> >> };
> >>>>> >>
> >>>>> >>
> >>>>> >> Variables are global, so you need to clear the list maybe
> >>>>> somewhere,
> >>>>> >> e.g. before the first ADD.
> >>>>> >>
> >>>>> >>
> >>>>> >> In the current trunk, something like the following is also
> >>>>> possible:
> >>>>> >>
> >>>>> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> >>>>> >> .name=="title", Attribute.name=="author")})}....
> >>>>> >>
> >>>>> >>
> >>>>> >> Best,
> >>>>> >>
> >>>>> >>
> >>>>> >> Peter
> >>>>> >>
> >>>>> >>
> >>>>> >> Am 28.02.2017 um 14:06 schrieb José Vicente Moyano Murillo:
> >>>>> >>> Hi Peter, we have another question regarding the same
> example.
> >>>>> >>>
> >>>>> >>> Right now all is working properly (many thanks) and it seems
> >> that
> >>>>> >>> 2.5.1-SNAPSHOT it's fine.
> >>>>> >>>
> >>>>> >>> Now we are planning to store some information in the created
> >>>>> annotation.
> >>>>> >> We
> >>>>> >>> want to store all the attributes that matches the RUTA rule.
> >>>>> >>>
> >>>>> >>> It is possible to store a1 and a2 in a feature (attributes)
> of
> >>>>> NeilsBook?
> >>>>> >>>
> >>>>> >>> The example:
> >>>>> >>>
> >>>>> >>> Book{-> NeilsBook}<-{
> >>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>>>> a1.ct=="Norse Mythology"}
> >>>>> >>> %
> >>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil
> >>>>> Gaiman"};
> >>>>> >>> };
> >>>>> >>>
> >>>>> >>> We are using this aproach:
> >>>>> >>>
> >>>>> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> >>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>>>> a1.ct=="Norse Mythology"}
> >>>>> >>> %
> >>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil
> >>>>> Gaiman"};
> >>>>> >>> };
> >>>>> >>>
> >>>>> >>> This example works but it is storing all the annotations
> >>>>> "Attribute"
> >>>>> >>> covered by "Book" and we just want the attributes that
> matches
> >>>>> the rule.
> >>>>> >>>
> >>>>> >>> Thanks in advance.
> >>>>> >>>
> >>>>> >>>
> >>>>> >>>
> >>>>> >>>
> >>>>> >>> 2017-02-24 10:29 GMT+01:00 José Vicente Moyano Murillo
> >>>>> <moyanoj@aia.es <ma...@aia.es>>:
> >>>>> >>>
> >>>>> >>>> Many thanks Peter ¡¡¡
> >>>>> >>>>
> >>>>> >>>> 2017-02-24 9:46 GMT+01:00 Peter Klügl
> >>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>> >>>>
> >>>>> >>>>> Hi,
> >>>>> >>>>>
> >>>>> >>>>>
> >>>>> >>>>> the repo:
> >>>>> >>>>>
> >>>>> >>>>> <repository>
> >>>>> >>>>> <id>apache.snapshots</id>
> >>>>> >>>>> <name>Apache Snapshot Repository</name>
> >>>>> >>>>> <url>http://repository.apache.org/snapshots
> >>>>> <http://repository.apache.org/snapshots></url>
> >>>>> >>>>> <releases>
> >>>>> >>>>> <enabled>false</enabled>
> >>>>> >>>>> </releases>
> >>>>> >>>>> </repository>
> >>>>> >>>>>
> >>>>> >>>>>
> >>>>> >>>>> the folder:
> >>>>> >>>>>
> >>>>> >>>>> https://repository.apache.org/
> content/groups/snapshots/org/a
> >>>>> <https://repository.apache.org/content/groups/snapshots/org/a>
> >>>>> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> >>>>> >>>>>
> >>>>> >>>>>
> >>>>> >>>>> Best,
> >>>>> >>>>>
> >>>>> >>>>> Peter
> >>>>> >>>>>
> >>>>> >>>>>
> >>>>> >>>>>
> >>>>> >>>>> Am 23.02.2017 um 13:47 schrieb José Vicente Moyano Murillo:
> >>>>> >>>>>> Hi,
> >>>>> >>>>>>
> >>>>> >>>>>> ruta-core.jar it's enough.
> >>>>> >>>>>>
> >>>>> >>>>>> It will be fantastic if i could access the snapshot
> >>>> repository.
> >>>>> >>>>>>
> >>>>> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klügl
> >>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>> >>>>>>
> >>>>> >>>>>>> Hi,
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> >>>>> >> plugins/update
> >>>>> >>>>>>> site?
> >>>>> >>>>>>>
> >>>>> >>>>>>> I will prepare a new RC for the next release soon.
> >>>>> >>>>>>>
> >>>>> >>>>>>> There should be snapshot artifacts built by jenkins in
> the
> >>>>> snapshot
> >>>>> >>>>>>> repository. I am out-of-office today so do not have the
> >>>>> link right
> >>>>> >>>>> now. (If
> >>>>> >>>>>>> you want to build it yourself, the svn source repo can be
> >>>>> accessed by
> >>>>> >>>>>>> anyone)
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>> Best,
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>> Peter
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>>
> >>>>> >>>>>>> Am 23.02.2017 um 08:06 schrieb José Vicente Moyano
> Murillo:
> >>>>> >>>>>>>
> >>>>> >>>>>>>> Hi Peter, good morning.
> >>>>> >>>>>>>>
> >>>>> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
> >>>>> snapshot or
> >>>>> >>>>> an
> >>>>> >>>>>>>> access to the repo.
> >>>>> >>>>>>>>
> >>>>> >>>>>>>> Regards
> >>>>> >>>>>>>>
> >>>>> >>>>>>>> 2017-02-22 10:38 GMT+01:00 José Vicente Moyano Murillo <
> >>>>> >>>>> moyanoj@aia.es <ma...@aia.es>>:
> >>>>> >>>>>>>> you're right
> >>>>> >>>>>>>>> % is performing some kind of "or".
> >>>>> >>>>>>>>>
> >>>>> >>>>>>>>> So we will wait for the new release.
> >>>>> >>>>>>>>>
> >>>>> >>>>>>>>> Many thanks
> >>>>> >>>>>>>>>
> >>>>> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klügl
> >>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>> >>>>>>>>>
> >>>>> >>>>>>>>> I actually wonder why your rules work. I am quite sure
> >>>>> that they
> >>>>> >>>>> match
> >>>>> >>>>>>>>>> too often, i. e. they match also if only one of the
> >>>>> conjunct rule
> >>>>> >>>>>>>>>> elements match.
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>> You can simply try that by using a wrong string in the
> >>>>> check like
> >>>>> >>>>> "NG"
> >>>>> >>>>>>>>>> instead of "Neil Gaiman"
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes
> and
> >>>>> will be
> >>>>> >>>>> part of
> >>>>> >>>>>>>>>> the next release.
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>> Best,
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>> Peter
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klügl:
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already
> fixed.
> >>>>> I'll
> >>>>> >>>>> investigate
> >>>>> >>>>>>>>>> it.
> >>>>> >>>>>>>>>>
> >>>>> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb José Vicente Moyano
> >>>>> Murillo:
> >>>>> >>>>>>>>>>>
> >>>>> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> We tried the first option using Conjunct rules and
> as
> >>>>> you said
> >>>>> >> it
> >>>>> >>>>> does
> >>>>> >>>>>>>>>>> not
> >>>>> >>>>>>>>>>> work with version 2.5.0. But we change a little your
> >>>>> example and
> >>>>> >> it
> >>>>> >>>>>>>>>>> works
> >>>>> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> >>>>> >>>>>>>>>>>> We use theses examples with success:
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> >>>>> Attribute.ct=="Norse
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>> Mythology"}"
> >>>>> >>>>>>>>>>> %
> >>>>> >>>>>>>>>>>> Attribute{Attribute.name=="author",
> >>>>> >>>>>>>>>>>> Attribute.ct=="Neil
> >>>>> >>>>>>>>>>>> Gaiman"};"
> >>>>> >>>>>>>>>>>> };
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
> >>>>> FEATURE("ct", "Norse
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>> Mythology")}"
> >>>>> >>>>>>>>>>> %
> >>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >>>>> >> FEATURE("ct",
> >>>>> >>>>>>>>>>>> "Neil
> >>>>> >>>>>>>>>>>> Gaiman")};
> >>>>> >>>>>>>>>>>> };
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> >>>>> Attribute.ct=="Norse
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>> Mythology"}"
> >>>>> >>>>>>>>>>> %
> >>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >>>>> >> FEATURE("ct",
> >>>>> >>>>>>>>>>>> "Neil
> >>>>> >>>>>>>>>>>> Gaiman")};
> >>>>> >>>>>>>>>>>> };
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> >>>>> >>>>>>>>>>>> a1:Attribute and a2:Attribute
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> In any case thank you very much for your help.
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klügl <
> >>>>> >> peter.kluegl@averbis.com <ma...@averbis.com>
> >>>>> >>>>>> :
> >>>>> >>>>>>>>>>>> Hi,
> >>>>> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
> >>>>> construct to
> >>>>> >>>>> specify
> >>>>> >>>>>>>>>>>> an
> >>>>> >>>>>>>>>>> AND between two rule element independent of the
> >> position:
> >>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name
> >=="title",
> >>>>> a1.ct=="Norse Mythology"}
> >>>>> >>>>>>>>>>>>> % a2:Attribute{a2.name
> >>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>> >>>>>>>>>>>>> };
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> However, I just noted that there is a problem with
> >>>>> conjunct
> >>>>> >>>>> rules. I
> >>>>> >>>>>>>>>>>>> haven't used it in a long time and the test
> coverage
> >>>>> much lower
> >>>>> >>>>> than
> >>>>> >>>>>>>>>>>> the
> >>>>> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix
> >> it.
> >>>>> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
> >>>>> variables for
> >>>>> >>>>> cheking
> >>>>> >>>>>>>>>>>> the
> >>>>> >>>>>>>>>>> AND, which looks all but declarative:
> >>>>> >>>>>>>>>>>>> BOOLEAN ft, fa;
> >>>>> >>>>>>>>>>>>> FOREACH(book) Book{}{
> >>>>> >>>>>>>>>>>>> book{-> ft = false, fa = false};
> >>>>> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
> >>>>> <http://a1.name>=="title", a1.ct=="Norse
> >>>>> >>>>>>>>>>>>> Mythology"->
> >>>>> >>>>>>>>>>>>> ft=true};};
> >>>>> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
> >>>>> <http://a2.name>=="author", a2.ct=="Neil
> >>>>> >>>>> Gaiman"->
> >>>>> >>>>>>>>>>>>> fa=true};};
> >>>>> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> >>>>> >>>>>>>>>>>>> }
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> ... or with a BLOCK...
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> BLOCK(book) Book{}{
> >>>>> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> >>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name
> >=="title",
> >>>>> a1.ct=="Norse Mythology"->
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>> ft=true};
> >>>>> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name
> >=="author",
> >>>>> a2.ct=="Neil Gaiman"->
> >>>>> >>>>> fa=true};
> >>>>> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> >>>>> >>>>>>>>>>>>> }
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> If the order of the attributes is known, you can
> >>>>> avoid the AND
> >>>>> >>>>> check
> >>>>> >>>>>>>>>>>> and
> >>>>> >>>>>>>>>>> just specify a sequential constraint:
> >>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name
> >=="title",
> >>>>> a1.ct=="Norse Mythology"}
> >>>>> >>>>>>>>>>>>> # a2:Attribute{a2.name
> >>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>> >>>>>>>>>>>>> };
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> If you need to check on the complete title with the
> >>>>> URL, you
> >>>>> >> can
> >>>>> >>>>>>>>>>>> replace
> >>>>> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> >>>>> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> Best,
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> Peter
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb José Vicente Moyano
> >>>>> Murillo:
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> Hello everyone
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
> >>>>> annotations. But i'm
> >>>>> >> not
> >>>>> >>>>>>>>>>>>> able to
> >>>>> >>>>>>>>>>> accomplish my objective.
> >>>>> >>>>>>>>>>>>>> This is my case right now:
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> I have a text annotated with some annotations
> >>>> "*Book*".
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> >>>>> >> "*Attribute*"
> >>>>> >>>>>>>>>>>>>> that
> >>>>> >>>>>>>>>>>>>> stores some information about the book. Each
> >>>>> "*Attribute*"
> >>>>> >> has a
> >>>>> >>>>>>>>>>>>> feature
> >>>>> >>>>>>>>>>> "
> >>>>> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent
> (one
> >>>>> "*Book*"
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> annotation).
> >>>>> >>>>>>>>>>> And example could be a text with 2 "*Book*"
> >> annotations:
> >>>>> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested
> >> attributes
> >>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title"
> ->
> >>>>> covered
> >>>>> >>>>> text:
> >>>>> >>>>>>>>>>>>> "Norse
> >>>>> >>>>>>>>>>> Mythology
> >>>>> >>>>>>>>>>>>>>
> >>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
> >>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil->
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>
> >>>>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> >>>>> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> "
> >>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> >>>>> -> covered
> >>>>> >>>>> text:
> >>>>> >>>>>>>>>>>>> "Neil
> >>>>> >>>>>>>>>>> Gaiman"
> >>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals
> "language"
> >> -
> >>>>> >> covered
> >>>>> >>>>>>>>>>>>>> text:
> >>>>> >>>>>>>>>>>>>> "English"
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested
> >> attributes
> >>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title"
> ->
> >>>>> covered
> >>>>> >>>>> text:
> >>>>> >>>>>>>>>>>>> "Never
> >>>>> >>>>>>>>>>> Never
> >>>>> >>>>>>>>>>>>>>
> >>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson
> >>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson>
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>> /1123863634;
> >>>>> >>>>>>>>>>>
> >>>>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> >>>>> >>>>>>>>>>>> atgap08?ean=
> >>>>> >>>>>>>>>>> 9780316433174>
> >>>>> >>>>>>>>>>>>>> "
> >>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> >>>>> -> covered
> >>>>> >>>>> text:
> >>>>> >>>>>>>>>>>>> "James
> >>>>> >>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> Patterson"
> >>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals
> "language"
> >> -
> >>>>> >> covered
> >>>>> >>>>>>>>>>>>>> text:
> >>>>> >>>>>>>>>>>>>> "English"
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> I need to respect this schema but i have this
> >>>> question:
> >>>>> >>>>>>>>>>>>>> It is possible to create and annotation over a
> book
> >>>>> for a
> >>>>> >> given
> >>>>> >>>>>>>>>>>>> author
> >>>>> >>>>>>>>>>> name
> >>>>> >>>>>>>>>>>>>> and a given title name?
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>> Thank's in advance
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>>>>>>>>>>>>>
> >>>>> >>
> >>>>>
> >>>>>
> >>
>
>
Re: Using RUTA
Posted by Peter Klügl <pe...@averbis.com>.
Hi,
Am 15.03.2017 um 10:24 schrieb Jos� Vicente Moyano Murillo:
> Great explanation Peter, we see all your comments.
> Maybe we are doing something wrong to accomplish our pourpouse.
>
> But regarding labels. Can we discuss this example?
>
> Document{ -> ADD(list, w1), ADD(list, w2), ADD(list, w3), ADD(list, w4),
> CREATE(Detection, "anchors" = list)} <- {
> w1:CW{w1.ct=="A" }
> %
> w2:CW{w2.ct=="B" }
> %
> w3:CW{w3.ct=="B" }
> %
> w4:CW{w4.ct=="A" };
> };
>
> In our mind conjuntion rules are aplyed using something like this pattern:
>
> FOR (PERMUTATION(w1, w2, w3, w4))
> IF(CONJUNCTION) -> THEN
>
>
> In other words we spect some kind of "interruption" to execute the THEN
> statement
There is not explicit interruption. The execution is much more
"brute-force" using the usual ruta rule behavior.
I just summarize my interpretation a bit although you probably know all
of that already:
There are two special language constructs: an inlined rule as condition
and a conjunct rule element. For validating the condition of the main
rule element (Document), the inlined rules need to be validated, meaning
one of the inlined rules sto match. So, Ruta starts by trying to apply
the first rule, which is the only rule in this example. The rule
consists of some conjunct rule elements. Therefore, the rule element
starts to apply each conjunct rule element separately and all rule
element matches are remembered/stored. If at least one rule element
match for each of the conjunct rule elements matched successfully, then
the actions of all successful rule element matches are executed. If the
inlined rule was able to match, then the actual rule element matched
successfully, and the rule matched successfully, and the actions of the
actual rule are executed.
> But it seems that right now, all the permutations are inspected and then
> the necessary annotations are created and, obviously, w1, w2, w3, w4 have
> the values of the last iteration.
Yes, since the matching conditions of the conjuncted rule elements are
equal, the successful rule element matches should build all
permutations. The variables of the labels (w1,w2...) have the value of
the last match of the rule element even if it was not successful, the X.
> What do you think?
>
>
I am still wondering about what should/can be done to improve this
situation/use case. If I override the value of the label variables with
null for an unsuccessful match, it would not solve the problem in this
current example. Resetting the value to the last valid one makes only
sense for the conjunct rule, but will be very problematic in all other
cases.
What I previously did in such cases, was to introduce a new language
construct that supports the current need, e.g., the conjunct rules.
Right now, the expressiveness of ruta is high enough that this should
not happen too often. On the other hand, maybe stepping back a bit and
looking at the problem to be solved from a different perspective is a
better approach. Maybe this should not be solved with labels and
conjunct rules, but maybe rather with something else like
ONLYONCE/ONLYFIRST, a boolean variable, or a new inlined rule....
Best,
Peter
>
>
>
>
>
>
> 2017-03-13 18:05 GMT+01:00 Peter Kl�gl <pe...@averbis.com>:
>
>> Hi,
>>
>>
>> Am 13.03.2017 um 17:41 schrieb Jos� Vicente Moyano Murillo:
>>> From our point of view we would expect the same result using # or %
>> Yes, I thought the same, but after investigating the problem I changed
>> my mind a bit.
>> Even if we ignore the label expression overriding the values with 'X's,
>> there is still a difference. The wildcard # introduces a sequential
>> constraint, and the conjunction % does not. The former implies a match
>> only for the next occureence of a valid annotation. And the latter? I
>> would initially say that the match should not be restricted to the first
>> one, meaning the first rule element for example will match twice as does
>> the fourth rule element. This would result in four 'A's in the list
>> compared to the two for the wildcard.
>>
>> And there is also the difference that the execution of the action is
>> decoupled from the specific rule elements in the conjunct element
>> (causing the initial problem with the label expression)
>>
>>> In any case it is our idea and the truth is that we do not know how to
>>> predict the impact.
>> I can totally understand that. I had to debug the implementation myself
>> quite a bit in order to get to know what is going on. That does not
>> happen too often to me concerning ruta.
>>
>> I am open to suggestions how this situation can be improved. I am not
>> sure yet what should/can be done.
>>
>> Best,
>>
>> Peter
>>
>>> regards
>>>
>>> 2017-03-13 10:56 GMT+01:00 Peter Kl�gl <pe...@averbis.com>:
>>>
>>>> Hi,
>>>>
>>>>
>>>> there is a conceptual problem when using label expressions in those
>>>> conjunct rules. The label expression stores the value of the matched
>>>> annotations even if the rule element does not match. It has to since the
>>>> matched annotation may be used to validate the conditions as you do.
>>>>
>>>> Maybe the value should be reset if the rule element does not match
>>>> correctly, but I have to investigate the consequences furhter before I
>>>> implement this change. Are there opinions?
>>>>
>>>>
>>>> If you change the rule to not use the label expression in the action,
>>>> there still seems to be a problem with the conjunct rules. e.g. like:
>>>>
>>>> Document{ -> CREATE(Detection, "anchors" = list)} <- {
>>>> w1:CW{w1.ct=="A" -> ADD(list, CW)}
>>>> %
>>>> w2:CW{w2.ct=="B" -> ADD(list, CW)}
>>>> %
>>>> w3:CW{w3.ct=="B" -> ADD(list, CW)}
>>>> %
>>>> w4:CW{w4.ct=="A" -> ADD(list, CW)};
>>>> };
>>>>
>>>>
>>>> This looks like a bug when validating the match itself depednent on the
>>>> element matches. I need to investigate that further...
>>>>
>>>>
>>>> I'll create a jira ticket for both.
>>>>
>>>>
>>>> Best,
>>>>
>>>>
>>>> Peter
>>>>
>>>>
>>>>
>>>> Am 09.03.2017 um 11:23 schrieb Jos� Vicente Moyano Murillo:
>>>>> Hi Peter
>>>>>
>>>>> We have prepared a short test with 2 methods.
>>>>> The first one is using #, the second one is using %
>>>>>
>>>>> We expect the same behaviour. But as you will see there are diferences.
>>>>>
>>>>> Regards
>>>>>
>>>>> 2017-02-28 16:00 GMT+01:00 Peter Kl�gl <peter.kluegl@averbis.com
>>>>> <ma...@averbis.com>>:
>>>>>
>>>>> hmmm ok, maybe my example for testing the rule was too simple.
>>>>>
>>>>> I will create a more complex example and check the results
>>>>>
>>>>>
>>>>> Peter
>>>>>
>>>>>
>>>>> Am 28.02.2017 um 15:38 schrieb Jos� Vicente Moyano Murillo:
>>>>> > Hi Peter,
>>>>> >
>>>>> > I'm sorry but this example does not work properly. It seems that
>>>>> it is a
>>>>> > problem regarding conjunction rules (%)
>>>>> >
>>>>> > This is our test case and result.
>>>>> >
>>>>> > We have a book with 5 attributes
>>>>> > - name
>>>>> > - author
>>>>> > - pages
>>>>> > - ISBN
>>>>> > - Category
>>>>> >
>>>>> > The rule is validatin name and author.
>>>>> >
>>>>> > RUTA creates the annotation with the list but the list contains
>>>>> 20 times
>>>>> > the las attribute (Category).
>>>>> >
>>>>> > If we use # it works perfectly. But in general we must use %
>>>>> >
>>>>> > May be this information will help you.
>>>>> >
>>>>> > Many thanks
>>>>> >
>>>>> >
>>>>> >
>>>>> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
>>>>> <ma...@gmail.com>>:
>>>>> >
>>>>> >> Hi,
>>>>> >>
>>>>> >>
>>>>> >> operations directly on lists and arrays are on my todo list but
>>>>> not yet
>>>>> >> implemented.
>>>>> >>
>>>>> >>
>>>>> >> Right now, there are still some options like a variable or
>>>>> restricted
>>>>> >> assignments.
>>>>> >>
>>>>> >>
>>>>> >> Here's an example with an ANNOTATIONLIST variable:
>>>>> >>
>>>>> >>
>>>>> >> ANNOTATIONLIST list;
>>>>> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
>>>>> >> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology" ->
>>>>> >> ADD(list,a1)}
>>>>> >> % a2:Attribute{a2.name <http://a2.name>=="author",
>>>>> a2.ct=="Neil Gaiman" ->
>>>>> >> ADD(list,a2)};
>>>>> >> };
>>>>> >>
>>>>> >>
>>>>> >> Variables are global, so you need to clear the list maybe
>>>>> somewhere,
>>>>> >> e.g. before the first ADD.
>>>>> >>
>>>>> >>
>>>>> >> In the current trunk, something like the following is also
>>>>> possible:
>>>>> >>
>>>>> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
>>>>> >> .name=="title", Attribute.name=="author")})}....
>>>>> >>
>>>>> >>
>>>>> >> Best,
>>>>> >>
>>>>> >>
>>>>> >> Peter
>>>>> >>
>>>>> >>
>>>>> >> Am 28.02.2017 um 14:06 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>> Hi Peter, we have another question regarding the same example.
>>>>> >>>
>>>>> >>> Right now all is working properly (many thanks) and it seems
>> that
>>>>> >>> 2.5.1-SNAPSHOT it's fine.
>>>>> >>>
>>>>> >>> Now we are planning to store some information in the created
>>>>> annotation.
>>>>> >> We
>>>>> >>> want to store all the attributes that matches the RUTA rule.
>>>>> >>>
>>>>> >>> It is possible to store a1 and a2 in a feature (attributes) of
>>>>> NeilsBook?
>>>>> >>>
>>>>> >>> The example:
>>>>> >>>
>>>>> >>> Book{-> NeilsBook}<-{
>>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>> %
>>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>>>> Gaiman"};
>>>>> >>> };
>>>>> >>>
>>>>> >>> We are using this aproach:
>>>>> >>>
>>>>> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
>>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>> %
>>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>>>> Gaiman"};
>>>>> >>> };
>>>>> >>>
>>>>> >>> This example works but it is storing all the annotations
>>>>> "Attribute"
>>>>> >>> covered by "Book" and we just want the attributes that matches
>>>>> the rule.
>>>>> >>>
>>>>> >>> Thanks in advance.
>>>>> >>>
>>>>> >>>
>>>>> >>>
>>>>> >>>
>>>>> >>> 2017-02-24 10:29 GMT+01:00 Jos� Vicente Moyano Murillo
>>>>> <moyanoj@aia.es <ma...@aia.es>>:
>>>>> >>>
>>>>> >>>> Many thanks Peter ���
>>>>> >>>>
>>>>> >>>> 2017-02-24 9:46 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>
>>>>> >>>>> Hi,
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> the repo:
>>>>> >>>>>
>>>>> >>>>> <repository>
>>>>> >>>>> <id>apache.snapshots</id>
>>>>> >>>>> <name>Apache Snapshot Repository</name>
>>>>> >>>>> <url>http://repository.apache.org/snapshots
>>>>> <http://repository.apache.org/snapshots></url>
>>>>> >>>>> <releases>
>>>>> >>>>> <enabled>false</enabled>
>>>>> >>>>> </releases>
>>>>> >>>>> </repository>
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> the folder:
>>>>> >>>>>
>>>>> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
>>>>> <https://repository.apache.org/content/groups/snapshots/org/a>
>>>>> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> Best,
>>>>> >>>>>
>>>>> >>>>> Peter
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> Am 23.02.2017 um 13:47 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>>>>> Hi,
>>>>> >>>>>>
>>>>> >>>>>> ruta-core.jar it's enough.
>>>>> >>>>>>
>>>>> >>>>>> It will be fantastic if i could access the snapshot
>>>> repository.
>>>>> >>>>>>
>>>>> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>>>
>>>>> >>>>>>> Hi,
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
>>>>> >> plugins/update
>>>>> >>>>>>> site?
>>>>> >>>>>>>
>>>>> >>>>>>> I will prepare a new RC for the next release soon.
>>>>> >>>>>>>
>>>>> >>>>>>> There should be snapshot artifacts built by jenkins in the
>>>>> snapshot
>>>>> >>>>>>> repository. I am out-of-office today so do not have the
>>>>> link right
>>>>> >>>>> now. (If
>>>>> >>>>>>> you want to build it yourself, the svn source repo can be
>>>>> accessed by
>>>>> >>>>>>> anyone)
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Best,
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Peter
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Am 23.02.2017 um 08:06 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>>>>>>
>>>>> >>>>>>>> Hi Peter, good morning.
>>>>> >>>>>>>>
>>>>> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
>>>>> snapshot or
>>>>> >>>>> an
>>>>> >>>>>>>> access to the repo.
>>>>> >>>>>>>>
>>>>> >>>>>>>> Regards
>>>>> >>>>>>>>
>>>>> >>>>>>>> 2017-02-22 10:38 GMT+01:00 Jos� Vicente Moyano Murillo <
>>>>> >>>>> moyanoj@aia.es <ma...@aia.es>>:
>>>>> >>>>>>>> you're right
>>>>> >>>>>>>>> % is performing some kind of "or".
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> So we will wait for the new release.
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> Many thanks
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> I actually wonder why your rules work. I am quite sure
>>>>> that they
>>>>> >>>>> match
>>>>> >>>>>>>>>> too often, i. e. they match also if only one of the
>>>>> conjunct rule
>>>>> >>>>>>>>>> elements match.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> You can simply try that by using a wrong string in the
>>>>> check like
>>>>> >>>>> "NG"
>>>>> >>>>>>>>>> instead of "Neil Gaiman"
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
>>>>> will be
>>>>> >>>>> part of
>>>>> >>>>>>>>>> the next release.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Best,
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Peter
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Kl�gl:
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
>>>>> I'll
>>>>> >>>>> investigate
>>>>> >>>>>>>>>> it.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb Jos� Vicente Moyano
>>>>> Murillo:
>>>>> >>>>>>>>>>>
>>>>> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
>>>>> you said
>>>>> >> it
>>>>> >>>>> does
>>>>> >>>>>>>>>>> not
>>>>> >>>>>>>>>>> work with version 2.5.0. But we change a little your
>>>>> example and
>>>>> >> it
>>>>> >>>>>>>>>>> works
>>>>> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
>>>>> >>>>>>>>>>>> We use theses examples with success:
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>>>> Attribute.ct=="Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology"}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="author",
>>>>> >>>>>>>>>>>> Attribute.ct=="Neil
>>>>> >>>>>>>>>>>> Gaiman"};"
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
>>>>> FEATURE("ct", "Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology")}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>>>> >> FEATURE("ct",
>>>>> >>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>>> Gaiman")};
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>>>> Attribute.ct=="Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology"}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>>>> >> FEATURE("ct",
>>>>> >>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>>> Gaiman")};
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
>>>>> >>>>>>>>>>>> a1:Attribute and a2:Attribute
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> In any case thank you very much for your help.
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Kl�gl <
>>>>> >> peter.kluegl@averbis.com <ma...@averbis.com>
>>>>> >>>>>> :
>>>>> >>>>>>>>>>>> Hi,
>>>>> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
>>>>> construct to
>>>>> >>>>> specify
>>>>> >>>>>>>>>>>> an
>>>>> >>>>>>>>>>> AND between two rule element independent of the
>> position:
>>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>>>>>>>>>>>> % a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>>>> >>>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> However, I just noted that there is a problem with
>>>>> conjunct
>>>>> >>>>> rules. I
>>>>> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
>>>>> much lower
>>>>> >>>>> than
>>>>> >>>>>>>>>>>> the
>>>>> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix
>> it.
>>>>> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
>>>>> variables for
>>>>> >>>>> cheking
>>>>> >>>>>>>>>>>> the
>>>>> >>>>>>>>>>> AND, which looks all but declarative:
>>>>> >>>>>>>>>>>>> BOOLEAN ft, fa;
>>>>> >>>>>>>>>>>>> FOREACH(book) Book{}{
>>>>> >>>>>>>>>>>>> book{-> ft = false, fa = false};
>>>>> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
>>>>> <http://a1.name>=="title", a1.ct=="Norse
>>>>> >>>>>>>>>>>>> Mythology"->
>>>>> >>>>>>>>>>>>> ft=true};};
>>>>> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil
>>>>> >>>>> Gaiman"->
>>>>> >>>>>>>>>>>>> fa=true};};
>>>>> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
>>>>> >>>>>>>>>>>>> }
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> ... or with a BLOCK...
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> BLOCK(book) Book{}{
>>>>> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"->
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>> ft=true};
>>>>> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
>>>>> a2.ct=="Neil Gaiman"->
>>>>> >>>>> fa=true};
>>>>> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
>>>>> >>>>>>>>>>>>> }
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> If the order of the attributes is known, you can
>>>>> avoid the AND
>>>>> >>>>> check
>>>>> >>>>>>>>>>>> and
>>>>> >>>>>>>>>>> just specify a sequential constraint:
>>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>>>>>>>>>>>> # a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>>>> >>>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> If you need to check on the complete title with the
>>>>> URL, you
>>>>> >> can
>>>>> >>>>>>>>>>>> replace
>>>>> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
>>>>> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Best,
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Peter
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb Jos� Vicente Moyano
>>>>> Murillo:
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Hello everyone
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
>>>>> annotations. But i'm
>>>>> >> not
>>>>> >>>>>>>>>>>>> able to
>>>>> >>>>>>>>>>> accomplish my objective.
>>>>> >>>>>>>>>>>>>> This is my case right now:
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I have a text annotated with some annotations
>>>> "*Book*".
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
>>>>> >> "*Attribute*"
>>>>> >>>>>>>>>>>>>> that
>>>>> >>>>>>>>>>>>>> stores some information about the book. Each
>>>>> "*Attribute*"
>>>>> >> has a
>>>>> >>>>>>>>>>>>> feature
>>>>> >>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
>>>>> "*Book*"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> annotation).
>>>>> >>>>>>>>>>> And example could be a text with 2 "*Book*"
>> annotations:
>>>>> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested
>> attributes
>>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>>>> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Norse
>>>>> >>>>>>>>>>> Mythology
>>>>> >>>>>>>>>>>>>>
>>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
>>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil->
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
>>>>> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>>>> -> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>> Gaiman"
>>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
>> -
>>>>> >> covered
>>>>> >>>>>>>>>>>>>> text:
>>>>> >>>>>>>>>>>>>> "English"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested
>> attributes
>>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>>>> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Never
>>>>> >>>>>>>>>>> Never
>>>>> >>>>>>>>>>>>>>
>>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson
>>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson>
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> /1123863634;
>>>>> >>>>>>>>>>>
>>>>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
>>>>> >>>>>>>>>>>> atgap08?ean=
>>>>> >>>>>>>>>>> 9780316433174>
>>>>> >>>>>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>>>> -> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "James
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Patterson"
>>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
>> -
>>>>> >> covered
>>>>> >>>>>>>>>>>>>> text:
>>>>> >>>>>>>>>>>>>> "English"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I need to respect this schema but i have this
>>>> question:
>>>>> >>>>>>>>>>>>>> It is possible to create and annotation over a book
>>>>> for a
>>>>> >> given
>>>>> >>>>>>>>>>>>> author
>>>>> >>>>>>>>>>> name
>>>>> >>>>>>>>>>>>>> and a given title name?
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Thank's in advance
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>>
>>>>> >>
>>>>>
>>>>>
>>
Re: Using RUTA
Posted by Peter Klügl <pe...@averbis.com>.
Hi,
sorry, I am quite busy these days. Could be that it will take some more
days until I can reply to your mail.
Best,
Peter
Am 15.03.2017 um 10:24 schrieb Jos� Vicente Moyano Murillo:
> Great explanation Peter, we see all your comments.
> Maybe we are doing something wrong to accomplish our pourpouse.
>
> But regarding labels. Can we discuss this example?
>
> Document{ -> ADD(list, w1), ADD(list, w2), ADD(list, w3), ADD(list, w4),
> CREATE(Detection, "anchors" = list)} <- {
> w1:CW{w1.ct=="A" }
> %
> w2:CW{w2.ct=="B" }
> %
> w3:CW{w3.ct=="B" }
> %
> w4:CW{w4.ct=="A" };
> };
>
> In our mind conjuntion rules are aplyed using something like this pattern:
>
> FOR (PERMUTATION(w1, w2, w3, w4))
> IF(CONJUNCTION) -> THEN
>
>
> In other words we spect some kind of "interruption" to execute the THEN
> statement
>
> But it seems that right now, all the permutations are inspected and then
> the necessary annotations are created and, obviously, w1, w2, w3, w4 have
> the values of the last iteration.
>
> What do you think?
>
>
>
>
>
>
>
>
>
> 2017-03-13 18:05 GMT+01:00 Peter Kl�gl <pe...@averbis.com>:
>
>> Hi,
>>
>>
>> Am 13.03.2017 um 17:41 schrieb Jos� Vicente Moyano Murillo:
>>> From our point of view we would expect the same result using # or %
>> Yes, I thought the same, but after investigating the problem I changed
>> my mind a bit.
>> Even if we ignore the label expression overriding the values with 'X's,
>> there is still a difference. The wildcard # introduces a sequential
>> constraint, and the conjunction % does not. The former implies a match
>> only for the next occureence of a valid annotation. And the latter? I
>> would initially say that the match should not be restricted to the first
>> one, meaning the first rule element for example will match twice as does
>> the fourth rule element. This would result in four 'A's in the list
>> compared to the two for the wildcard.
>>
>> And there is also the difference that the execution of the action is
>> decoupled from the specific rule elements in the conjunct element
>> (causing the initial problem with the label expression)
>>
>>> In any case it is our idea and the truth is that we do not know how to
>>> predict the impact.
>> I can totally understand that. I had to debug the implementation myself
>> quite a bit in order to get to know what is going on. That does not
>> happen too often to me concerning ruta.
>>
>> I am open to suggestions how this situation can be improved. I am not
>> sure yet what should/can be done.
>>
>> Best,
>>
>> Peter
>>
>>> regards
>>>
>>> 2017-03-13 10:56 GMT+01:00 Peter Kl�gl <pe...@averbis.com>:
>>>
>>>> Hi,
>>>>
>>>>
>>>> there is a conceptual problem when using label expressions in those
>>>> conjunct rules. The label expression stores the value of the matched
>>>> annotations even if the rule element does not match. It has to since the
>>>> matched annotation may be used to validate the conditions as you do.
>>>>
>>>> Maybe the value should be reset if the rule element does not match
>>>> correctly, but I have to investigate the consequences furhter before I
>>>> implement this change. Are there opinions?
>>>>
>>>>
>>>> If you change the rule to not use the label expression in the action,
>>>> there still seems to be a problem with the conjunct rules. e.g. like:
>>>>
>>>> Document{ -> CREATE(Detection, "anchors" = list)} <- {
>>>> w1:CW{w1.ct=="A" -> ADD(list, CW)}
>>>> %
>>>> w2:CW{w2.ct=="B" -> ADD(list, CW)}
>>>> %
>>>> w3:CW{w3.ct=="B" -> ADD(list, CW)}
>>>> %
>>>> w4:CW{w4.ct=="A" -> ADD(list, CW)};
>>>> };
>>>>
>>>>
>>>> This looks like a bug when validating the match itself depednent on the
>>>> element matches. I need to investigate that further...
>>>>
>>>>
>>>> I'll create a jira ticket for both.
>>>>
>>>>
>>>> Best,
>>>>
>>>>
>>>> Peter
>>>>
>>>>
>>>>
>>>> Am 09.03.2017 um 11:23 schrieb Jos� Vicente Moyano Murillo:
>>>>> Hi Peter
>>>>>
>>>>> We have prepared a short test with 2 methods.
>>>>> The first one is using #, the second one is using %
>>>>>
>>>>> We expect the same behaviour. But as you will see there are diferences.
>>>>>
>>>>> Regards
>>>>>
>>>>> 2017-02-28 16:00 GMT+01:00 Peter Kl�gl <peter.kluegl@averbis.com
>>>>> <ma...@averbis.com>>:
>>>>>
>>>>> hmmm ok, maybe my example for testing the rule was too simple.
>>>>>
>>>>> I will create a more complex example and check the results
>>>>>
>>>>>
>>>>> Peter
>>>>>
>>>>>
>>>>> Am 28.02.2017 um 15:38 schrieb Jos� Vicente Moyano Murillo:
>>>>> > Hi Peter,
>>>>> >
>>>>> > I'm sorry but this example does not work properly. It seems that
>>>>> it is a
>>>>> > problem regarding conjunction rules (%)
>>>>> >
>>>>> > This is our test case and result.
>>>>> >
>>>>> > We have a book with 5 attributes
>>>>> > - name
>>>>> > - author
>>>>> > - pages
>>>>> > - ISBN
>>>>> > - Category
>>>>> >
>>>>> > The rule is validatin name and author.
>>>>> >
>>>>> > RUTA creates the annotation with the list but the list contains
>>>>> 20 times
>>>>> > the las attribute (Category).
>>>>> >
>>>>> > If we use # it works perfectly. But in general we must use %
>>>>> >
>>>>> > May be this information will help you.
>>>>> >
>>>>> > Many thanks
>>>>> >
>>>>> >
>>>>> >
>>>>> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
>>>>> <ma...@gmail.com>>:
>>>>> >
>>>>> >> Hi,
>>>>> >>
>>>>> >>
>>>>> >> operations directly on lists and arrays are on my todo list but
>>>>> not yet
>>>>> >> implemented.
>>>>> >>
>>>>> >>
>>>>> >> Right now, there are still some options like a variable or
>>>>> restricted
>>>>> >> assignments.
>>>>> >>
>>>>> >>
>>>>> >> Here's an example with an ANNOTATIONLIST variable:
>>>>> >>
>>>>> >>
>>>>> >> ANNOTATIONLIST list;
>>>>> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
>>>>> >> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology" ->
>>>>> >> ADD(list,a1)}
>>>>> >> % a2:Attribute{a2.name <http://a2.name>=="author",
>>>>> a2.ct=="Neil Gaiman" ->
>>>>> >> ADD(list,a2)};
>>>>> >> };
>>>>> >>
>>>>> >>
>>>>> >> Variables are global, so you need to clear the list maybe
>>>>> somewhere,
>>>>> >> e.g. before the first ADD.
>>>>> >>
>>>>> >>
>>>>> >> In the current trunk, something like the following is also
>>>>> possible:
>>>>> >>
>>>>> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
>>>>> >> .name=="title", Attribute.name=="author")})}....
>>>>> >>
>>>>> >>
>>>>> >> Best,
>>>>> >>
>>>>> >>
>>>>> >> Peter
>>>>> >>
>>>>> >>
>>>>> >> Am 28.02.2017 um 14:06 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>> Hi Peter, we have another question regarding the same example.
>>>>> >>>
>>>>> >>> Right now all is working properly (many thanks) and it seems
>> that
>>>>> >>> 2.5.1-SNAPSHOT it's fine.
>>>>> >>>
>>>>> >>> Now we are planning to store some information in the created
>>>>> annotation.
>>>>> >> We
>>>>> >>> want to store all the attributes that matches the RUTA rule.
>>>>> >>>
>>>>> >>> It is possible to store a1 and a2 in a feature (attributes) of
>>>>> NeilsBook?
>>>>> >>>
>>>>> >>> The example:
>>>>> >>>
>>>>> >>> Book{-> NeilsBook}<-{
>>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>> %
>>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>>>> Gaiman"};
>>>>> >>> };
>>>>> >>>
>>>>> >>> We are using this aproach:
>>>>> >>>
>>>>> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
>>>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>> %
>>>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>>>> Gaiman"};
>>>>> >>> };
>>>>> >>>
>>>>> >>> This example works but it is storing all the annotations
>>>>> "Attribute"
>>>>> >>> covered by "Book" and we just want the attributes that matches
>>>>> the rule.
>>>>> >>>
>>>>> >>> Thanks in advance.
>>>>> >>>
>>>>> >>>
>>>>> >>>
>>>>> >>>
>>>>> >>> 2017-02-24 10:29 GMT+01:00 Jos� Vicente Moyano Murillo
>>>>> <moyanoj@aia.es <ma...@aia.es>>:
>>>>> >>>
>>>>> >>>> Many thanks Peter ���
>>>>> >>>>
>>>>> >>>> 2017-02-24 9:46 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>
>>>>> >>>>> Hi,
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> the repo:
>>>>> >>>>>
>>>>> >>>>> <repository>
>>>>> >>>>> <id>apache.snapshots</id>
>>>>> >>>>> <name>Apache Snapshot Repository</name>
>>>>> >>>>> <url>http://repository.apache.org/snapshots
>>>>> <http://repository.apache.org/snapshots></url>
>>>>> >>>>> <releases>
>>>>> >>>>> <enabled>false</enabled>
>>>>> >>>>> </releases>
>>>>> >>>>> </repository>
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> the folder:
>>>>> >>>>>
>>>>> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
>>>>> <https://repository.apache.org/content/groups/snapshots/org/a>
>>>>> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> Best,
>>>>> >>>>>
>>>>> >>>>> Peter
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>>
>>>>> >>>>> Am 23.02.2017 um 13:47 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>>>>> Hi,
>>>>> >>>>>>
>>>>> >>>>>> ruta-core.jar it's enough.
>>>>> >>>>>>
>>>>> >>>>>> It will be fantastic if i could access the snapshot
>>>> repository.
>>>>> >>>>>>
>>>>> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>>>
>>>>> >>>>>>> Hi,
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
>>>>> >> plugins/update
>>>>> >>>>>>> site?
>>>>> >>>>>>>
>>>>> >>>>>>> I will prepare a new RC for the next release soon.
>>>>> >>>>>>>
>>>>> >>>>>>> There should be snapshot artifacts built by jenkins in the
>>>>> snapshot
>>>>> >>>>>>> repository. I am out-of-office today so do not have the
>>>>> link right
>>>>> >>>>> now. (If
>>>>> >>>>>>> you want to build it yourself, the svn source repo can be
>>>>> accessed by
>>>>> >>>>>>> anyone)
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Best,
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Peter
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>>
>>>>> >>>>>>> Am 23.02.2017 um 08:06 schrieb Jos� Vicente Moyano Murillo:
>>>>> >>>>>>>
>>>>> >>>>>>>> Hi Peter, good morning.
>>>>> >>>>>>>>
>>>>> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
>>>>> snapshot or
>>>>> >>>>> an
>>>>> >>>>>>>> access to the repo.
>>>>> >>>>>>>>
>>>>> >>>>>>>> Regards
>>>>> >>>>>>>>
>>>>> >>>>>>>> 2017-02-22 10:38 GMT+01:00 Jos� Vicente Moyano Murillo <
>>>>> >>>>> moyanoj@aia.es <ma...@aia.es>>:
>>>>> >>>>>>>> you're right
>>>>> >>>>>>>>> % is performing some kind of "or".
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> So we will wait for the new release.
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> Many thanks
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Kl�gl
>>>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>>>> >>>>>>>>>
>>>>> >>>>>>>>> I actually wonder why your rules work. I am quite sure
>>>>> that they
>>>>> >>>>> match
>>>>> >>>>>>>>>> too often, i. e. they match also if only one of the
>>>>> conjunct rule
>>>>> >>>>>>>>>> elements match.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> You can simply try that by using a wrong string in the
>>>>> check like
>>>>> >>>>> "NG"
>>>>> >>>>>>>>>> instead of "Neil Gaiman"
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
>>>>> will be
>>>>> >>>>> part of
>>>>> >>>>>>>>>> the next release.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Best,
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Peter
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Kl�gl:
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
>>>>> I'll
>>>>> >>>>> investigate
>>>>> >>>>>>>>>> it.
>>>>> >>>>>>>>>>
>>>>> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb Jos� Vicente Moyano
>>>>> Murillo:
>>>>> >>>>>>>>>>>
>>>>> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
>>>>> you said
>>>>> >> it
>>>>> >>>>> does
>>>>> >>>>>>>>>>> not
>>>>> >>>>>>>>>>> work with version 2.5.0. But we change a little your
>>>>> example and
>>>>> >> it
>>>>> >>>>>>>>>>> works
>>>>> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
>>>>> >>>>>>>>>>>> We use theses examples with success:
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>>>> Attribute.ct=="Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology"}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="author",
>>>>> >>>>>>>>>>>> Attribute.ct=="Neil
>>>>> >>>>>>>>>>>> Gaiman"};"
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
>>>>> FEATURE("ct", "Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology")}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>>>> >> FEATURE("ct",
>>>>> >>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>>> Gaiman")};
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>>>> Attribute.ct=="Norse
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>> Mythology"}"
>>>>> >>>>>>>>>>> %
>>>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>>>> >> FEATURE("ct",
>>>>> >>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>>> Gaiman")};
>>>>> >>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
>>>>> >>>>>>>>>>>> a1:Attribute and a2:Attribute
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> In any case thank you very much for your help.
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>>
>>>>> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Kl�gl <
>>>>> >> peter.kluegl@averbis.com <ma...@averbis.com>
>>>>> >>>>>> :
>>>>> >>>>>>>>>>>> Hi,
>>>>> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
>>>>> construct to
>>>>> >>>>> specify
>>>>> >>>>>>>>>>>> an
>>>>> >>>>>>>>>>> AND between two rule element independent of the
>> position:
>>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>>>>>>>>>>>> % a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>>>> >>>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> However, I just noted that there is a problem with
>>>>> conjunct
>>>>> >>>>> rules. I
>>>>> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
>>>>> much lower
>>>>> >>>>> than
>>>>> >>>>>>>>>>>> the
>>>>> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix
>> it.
>>>>> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
>>>>> variables for
>>>>> >>>>> cheking
>>>>> >>>>>>>>>>>> the
>>>>> >>>>>>>>>>> AND, which looks all but declarative:
>>>>> >>>>>>>>>>>>> BOOLEAN ft, fa;
>>>>> >>>>>>>>>>>>> FOREACH(book) Book{}{
>>>>> >>>>>>>>>>>>> book{-> ft = false, fa = false};
>>>>> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
>>>>> <http://a1.name>=="title", a1.ct=="Norse
>>>>> >>>>>>>>>>>>> Mythology"->
>>>>> >>>>>>>>>>>>> ft=true};};
>>>>> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil
>>>>> >>>>> Gaiman"->
>>>>> >>>>>>>>>>>>> fa=true};};
>>>>> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
>>>>> >>>>>>>>>>>>> }
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> ... or with a BLOCK...
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> BLOCK(book) Book{}{
>>>>> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"->
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>> ft=true};
>>>>> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
>>>>> a2.ct=="Neil Gaiman"->
>>>>> >>>>> fa=true};
>>>>> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
>>>>> >>>>>>>>>>>>> }
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> If the order of the attributes is known, you can
>>>>> avoid the AND
>>>>> >>>>> check
>>>>> >>>>>>>>>>>> and
>>>>> >>>>>>>>>>> just specify a sequential constraint:
>>>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>>>> a1.ct=="Norse Mythology"}
>>>>> >>>>>>>>>>>>> # a2:Attribute{a2.name
>>>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>>>> >>>>>>>>>>>>> };
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> If you need to check on the complete title with the
>>>>> URL, you
>>>>> >> can
>>>>> >>>>>>>>>>>> replace
>>>>> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
>>>>> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Best,
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Peter
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb Jos� Vicente Moyano
>>>>> Murillo:
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Hello everyone
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
>>>>> annotations. But i'm
>>>>> >> not
>>>>> >>>>>>>>>>>>> able to
>>>>> >>>>>>>>>>> accomplish my objective.
>>>>> >>>>>>>>>>>>>> This is my case right now:
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I have a text annotated with some annotations
>>>> "*Book*".
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
>>>>> >> "*Attribute*"
>>>>> >>>>>>>>>>>>>> that
>>>>> >>>>>>>>>>>>>> stores some information about the book. Each
>>>>> "*Attribute*"
>>>>> >> has a
>>>>> >>>>>>>>>>>>> feature
>>>>> >>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
>>>>> "*Book*"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> annotation).
>>>>> >>>>>>>>>>> And example could be a text with 2 "*Book*"
>> annotations:
>>>>> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested
>> attributes
>>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>>>> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Norse
>>>>> >>>>>>>>>>> Mythology
>>>>> >>>>>>>>>>>>>>
>>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
>>>>> <http://www.barnesandnoble.com/w/norse-mythology-neil->
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>
>>>>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
>>>>> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>>>> -> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Neil
>>>>> >>>>>>>>>>> Gaiman"
>>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
>> -
>>>>> >> covered
>>>>> >>>>>>>>>>>>>> text:
>>>>> >>>>>>>>>>>>>> "English"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested
>> attributes
>>>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>>>> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "Never
>>>>> >>>>>>>>>>> Never
>>>>> >>>>>>>>>>>>>>
>>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson
>>>>> <http://www.barnesandnoble.com/w/never-never-james-patterson>
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>> /1123863634;
>>>>> >>>>>>>>>>>
>>>>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
>>>>> >>>>>>>>>>>> atgap08?ean=
>>>>> >>>>>>>>>>> 9780316433174>
>>>>> >>>>>>>>>>>>>> "
>>>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>>>> -> covered
>>>>> >>>>> text:
>>>>> >>>>>>>>>>>>> "James
>>>>> >>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Patterson"
>>>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
>> -
>>>>> >> covered
>>>>> >>>>>>>>>>>>>> text:
>>>>> >>>>>>>>>>>>>> "English"
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> I need to respect this schema but i have this
>>>> question:
>>>>> >>>>>>>>>>>>>> It is possible to create and annotation over a book
>>>>> for a
>>>>> >> given
>>>>> >>>>>>>>>>>>> author
>>>>> >>>>>>>>>>> name
>>>>> >>>>>>>>>>>>>> and a given title name?
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>> Thank's in advance
>>>>> >>>>>>>>>>>>>>
>>>>> >>>>>>>>>>>>>>
>>>>> >>
>>>>>
>>>>>
>>
Re: Using RUTA
Posted by José Vicente Moyano Murillo <mo...@aia.es>.
Great explanation Peter, we see all your comments.
Maybe we are doing something wrong to accomplish our pourpouse.
But regarding labels. Can we discuss this example?
Document{ -> ADD(list, w1), ADD(list, w2), ADD(list, w3), ADD(list, w4),
CREATE(Detection, "anchors" = list)} <- {
w1:CW{w1.ct=="A" }
%
w2:CW{w2.ct=="B" }
%
w3:CW{w3.ct=="B" }
%
w4:CW{w4.ct=="A" };
};
In our mind conjuntion rules are aplyed using something like this pattern:
FOR (PERMUTATION(w1, w2, w3, w4))
IF(CONJUNCTION) -> THEN
In other words we spect some kind of "interruption" to execute the THEN
statement
But it seems that right now, all the permutations are inspected and then
the necessary annotations are created and, obviously, w1, w2, w3, w4 have
the values of the last iteration.
What do you think?
2017-03-13 18:05 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> Hi,
>
>
> Am 13.03.2017 um 17:41 schrieb José Vicente Moyano Murillo:
> > From our point of view we would expect the same result using # or %
>
> Yes, I thought the same, but after investigating the problem I changed
> my mind a bit.
> Even if we ignore the label expression overriding the values with 'X's,
> there is still a difference. The wildcard # introduces a sequential
> constraint, and the conjunction % does not. The former implies a match
> only for the next occureence of a valid annotation. And the latter? I
> would initially say that the match should not be restricted to the first
> one, meaning the first rule element for example will match twice as does
> the fourth rule element. This would result in four 'A's in the list
> compared to the two for the wildcard.
>
> And there is also the difference that the execution of the action is
> decoupled from the specific rule elements in the conjunct element
> (causing the initial problem with the label expression)
>
> > In any case it is our idea and the truth is that we do not know how to
> > predict the impact.
>
> I can totally understand that. I had to debug the implementation myself
> quite a bit in order to get to know what is going on. That does not
> happen too often to me concerning ruta.
>
> I am open to suggestions how this situation can be improved. I am not
> sure yet what should/can be done.
>
> Best,
>
> Peter
>
> >
> > regards
> >
> > 2017-03-13 10:56 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> >
> >> Hi,
> >>
> >>
> >> there is a conceptual problem when using label expressions in those
> >> conjunct rules. The label expression stores the value of the matched
> >> annotations even if the rule element does not match. It has to since the
> >> matched annotation may be used to validate the conditions as you do.
> >>
> >> Maybe the value should be reset if the rule element does not match
> >> correctly, but I have to investigate the consequences furhter before I
> >> implement this change. Are there opinions?
> >>
> >>
> >> If you change the rule to not use the label expression in the action,
> >> there still seems to be a problem with the conjunct rules. e.g. like:
> >>
> >> Document{ -> CREATE(Detection, "anchors" = list)} <- {
> >> w1:CW{w1.ct=="A" -> ADD(list, CW)}
> >> %
> >> w2:CW{w2.ct=="B" -> ADD(list, CW)}
> >> %
> >> w3:CW{w3.ct=="B" -> ADD(list, CW)}
> >> %
> >> w4:CW{w4.ct=="A" -> ADD(list, CW)};
> >> };
> >>
> >>
> >> This looks like a bug when validating the match itself depednent on the
> >> element matches. I need to investigate that further...
> >>
> >>
> >> I'll create a jira ticket for both.
> >>
> >>
> >> Best,
> >>
> >>
> >> Peter
> >>
> >>
> >>
> >> Am 09.03.2017 um 11:23 schrieb José Vicente Moyano Murillo:
> >>> Hi Peter
> >>>
> >>> We have prepared a short test with 2 methods.
> >>> The first one is using #, the second one is using %
> >>>
> >>> We expect the same behaviour. But as you will see there are diferences.
> >>>
> >>> Regards
> >>>
> >>> 2017-02-28 16:00 GMT+01:00 Peter Klügl <peter.kluegl@averbis.com
> >>> <ma...@averbis.com>>:
> >>>
> >>> hmmm ok, maybe my example for testing the rule was too simple.
> >>>
> >>> I will create a more complex example and check the results
> >>>
> >>>
> >>> Peter
> >>>
> >>>
> >>> Am 28.02.2017 um 15:38 schrieb José Vicente Moyano Murillo:
> >>> > Hi Peter,
> >>> >
> >>> > I'm sorry but this example does not work properly. It seems that
> >>> it is a
> >>> > problem regarding conjunction rules (%)
> >>> >
> >>> > This is our test case and result.
> >>> >
> >>> > We have a book with 5 attributes
> >>> > - name
> >>> > - author
> >>> > - pages
> >>> > - ISBN
> >>> > - Category
> >>> >
> >>> > The rule is validatin name and author.
> >>> >
> >>> > RUTA creates the annotation with the list but the list contains
> >>> 20 times
> >>> > the las attribute (Category).
> >>> >
> >>> > If we use # it works perfectly. But in general we must use %
> >>> >
> >>> > May be this information will help you.
> >>> >
> >>> > Many thanks
> >>> >
> >>> >
> >>> >
> >>> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
> >>> <ma...@gmail.com>>:
> >>> >
> >>> >> Hi,
> >>> >>
> >>> >>
> >>> >> operations directly on lists and arrays are on my todo list but
> >>> not yet
> >>> >> implemented.
> >>> >>
> >>> >>
> >>> >> Right now, there are still some options like a variable or
> >>> restricted
> >>> >> assignments.
> >>> >>
> >>> >>
> >>> >> Here's an example with an ANNOTATIONLIST variable:
> >>> >>
> >>> >>
> >>> >> ANNOTATIONLIST list;
> >>> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> >>> >> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology" ->
> >>> >> ADD(list,a1)}
> >>> >> % a2:Attribute{a2.name <http://a2.name>=="author",
> >>> a2.ct=="Neil Gaiman" ->
> >>> >> ADD(list,a2)};
> >>> >> };
> >>> >>
> >>> >>
> >>> >> Variables are global, so you need to clear the list maybe
> >>> somewhere,
> >>> >> e.g. before the first ADD.
> >>> >>
> >>> >>
> >>> >> In the current trunk, something like the following is also
> >>> possible:
> >>> >>
> >>> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> >>> >> .name=="title", Attribute.name=="author")})}....
> >>> >>
> >>> >>
> >>> >> Best,
> >>> >>
> >>> >>
> >>> >> Peter
> >>> >>
> >>> >>
> >>> >> Am 28.02.2017 um 14:06 schrieb José Vicente Moyano Murillo:
> >>> >>> Hi Peter, we have another question regarding the same example.
> >>> >>>
> >>> >>> Right now all is working properly (many thanks) and it seems
> that
> >>> >>> 2.5.1-SNAPSHOT it's fine.
> >>> >>>
> >>> >>> Now we are planning to store some information in the created
> >>> annotation.
> >>> >> We
> >>> >>> want to store all the attributes that matches the RUTA rule.
> >>> >>>
> >>> >>> It is possible to store a1 and a2 in a feature (attributes) of
> >>> NeilsBook?
> >>> >>>
> >>> >>> The example:
> >>> >>>
> >>> >>> Book{-> NeilsBook}<-{
> >>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology"}
> >>> >>> %
> >>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> >>> Gaiman"};
> >>> >>> };
> >>> >>>
> >>> >>> We are using this aproach:
> >>> >>>
> >>> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> >>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology"}
> >>> >>> %
> >>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> >>> Gaiman"};
> >>> >>> };
> >>> >>>
> >>> >>> This example works but it is storing all the annotations
> >>> "Attribute"
> >>> >>> covered by "Book" and we just want the attributes that matches
> >>> the rule.
> >>> >>>
> >>> >>> Thanks in advance.
> >>> >>>
> >>> >>>
> >>> >>>
> >>> >>>
> >>> >>> 2017-02-24 10:29 GMT+01:00 José Vicente Moyano Murillo
> >>> <moyanoj@aia.es <ma...@aia.es>>:
> >>> >>>
> >>> >>>> Many thanks Peter ¡¡¡
> >>> >>>>
> >>> >>>> 2017-02-24 9:46 GMT+01:00 Peter Klügl
> >>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>> >>>>
> >>> >>>>> Hi,
> >>> >>>>>
> >>> >>>>>
> >>> >>>>> the repo:
> >>> >>>>>
> >>> >>>>> <repository>
> >>> >>>>> <id>apache.snapshots</id>
> >>> >>>>> <name>Apache Snapshot Repository</name>
> >>> >>>>> <url>http://repository.apache.org/snapshots
> >>> <http://repository.apache.org/snapshots></url>
> >>> >>>>> <releases>
> >>> >>>>> <enabled>false</enabled>
> >>> >>>>> </releases>
> >>> >>>>> </repository>
> >>> >>>>>
> >>> >>>>>
> >>> >>>>> the folder:
> >>> >>>>>
> >>> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
> >>> <https://repository.apache.org/content/groups/snapshots/org/a>
> >>> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> >>> >>>>>
> >>> >>>>>
> >>> >>>>> Best,
> >>> >>>>>
> >>> >>>>> Peter
> >>> >>>>>
> >>> >>>>>
> >>> >>>>>
> >>> >>>>> Am 23.02.2017 um 13:47 schrieb José Vicente Moyano Murillo:
> >>> >>>>>> Hi,
> >>> >>>>>>
> >>> >>>>>> ruta-core.jar it's enough.
> >>> >>>>>>
> >>> >>>>>> It will be fantastic if i could access the snapshot
> >> repository.
> >>> >>>>>>
> >>> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klügl
> >>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>> >>>>>>
> >>> >>>>>>> Hi,
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> >>> >> plugins/update
> >>> >>>>>>> site?
> >>> >>>>>>>
> >>> >>>>>>> I will prepare a new RC for the next release soon.
> >>> >>>>>>>
> >>> >>>>>>> There should be snapshot artifacts built by jenkins in the
> >>> snapshot
> >>> >>>>>>> repository. I am out-of-office today so do not have the
> >>> link right
> >>> >>>>> now. (If
> >>> >>>>>>> you want to build it yourself, the svn source repo can be
> >>> accessed by
> >>> >>>>>>> anyone)
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>> Best,
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>> Peter
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>>
> >>> >>>>>>> Am 23.02.2017 um 08:06 schrieb José Vicente Moyano Murillo:
> >>> >>>>>>>
> >>> >>>>>>>> Hi Peter, good morning.
> >>> >>>>>>>>
> >>> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
> >>> snapshot or
> >>> >>>>> an
> >>> >>>>>>>> access to the repo.
> >>> >>>>>>>>
> >>> >>>>>>>> Regards
> >>> >>>>>>>>
> >>> >>>>>>>> 2017-02-22 10:38 GMT+01:00 José Vicente Moyano Murillo <
> >>> >>>>> moyanoj@aia.es <ma...@aia.es>>:
> >>> >>>>>>>> you're right
> >>> >>>>>>>>> % is performing some kind of "or".
> >>> >>>>>>>>>
> >>> >>>>>>>>> So we will wait for the new release.
> >>> >>>>>>>>>
> >>> >>>>>>>>> Many thanks
> >>> >>>>>>>>>
> >>> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klügl
> >>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>> >>>>>>>>>
> >>> >>>>>>>>> I actually wonder why your rules work. I am quite sure
> >>> that they
> >>> >>>>> match
> >>> >>>>>>>>>> too often, i. e. they match also if only one of the
> >>> conjunct rule
> >>> >>>>>>>>>> elements match.
> >>> >>>>>>>>>>
> >>> >>>>>>>>>> You can simply try that by using a wrong string in the
> >>> check like
> >>> >>>>> "NG"
> >>> >>>>>>>>>> instead of "Neil Gaiman"
> >>> >>>>>>>>>>
> >>> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
> >>> will be
> >>> >>>>> part of
> >>> >>>>>>>>>> the next release.
> >>> >>>>>>>>>>
> >>> >>>>>>>>>>
> >>> >>>>>>>>>> Best,
> >>> >>>>>>>>>>
> >>> >>>>>>>>>>
> >>> >>>>>>>>>> Peter
> >>> >>>>>>>>>>
> >>> >>>>>>>>>>
> >>> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klügl:
> >>> >>>>>>>>>>
> >>> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
> >>> I'll
> >>> >>>>> investigate
> >>> >>>>>>>>>> it.
> >>> >>>>>>>>>>
> >>> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb José Vicente Moyano
> >>> Murillo:
> >>> >>>>>>>>>>>
> >>> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
> >>> you said
> >>> >> it
> >>> >>>>> does
> >>> >>>>>>>>>>> not
> >>> >>>>>>>>>>> work with version 2.5.0. But we change a little your
> >>> example and
> >>> >> it
> >>> >>>>>>>>>>> works
> >>> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> >>> >>>>>>>>>>>> We use theses examples with success:
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> >>> Attribute.ct=="Norse
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>> Mythology"}"
> >>> >>>>>>>>>>> %
> >>> >>>>>>>>>>>> Attribute{Attribute.name=="author",
> >>> >>>>>>>>>>>> Attribute.ct=="Neil
> >>> >>>>>>>>>>>> Gaiman"};"
> >>> >>>>>>>>>>>> };
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
> >>> FEATURE("ct", "Norse
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>> Mythology")}"
> >>> >>>>>>>>>>> %
> >>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >>> >> FEATURE("ct",
> >>> >>>>>>>>>>>> "Neil
> >>> >>>>>>>>>>>> Gaiman")};
> >>> >>>>>>>>>>>> };
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> >>> Attribute.ct=="Norse
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>> Mythology"}"
> >>> >>>>>>>>>>> %
> >>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >>> >> FEATURE("ct",
> >>> >>>>>>>>>>>> "Neil
> >>> >>>>>>>>>>>> Gaiman")};
> >>> >>>>>>>>>>>> };
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> >>> >>>>>>>>>>>> a1:Attribute and a2:Attribute
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> In any case thank you very much for your help.
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>>
> >>> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klügl <
> >>> >> peter.kluegl@averbis.com <ma...@averbis.com>
> >>> >>>>>> :
> >>> >>>>>>>>>>>> Hi,
> >>> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
> >>> construct to
> >>> >>>>> specify
> >>> >>>>>>>>>>>> an
> >>> >>>>>>>>>>> AND between two rule element independent of the
> position:
> >>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology"}
> >>> >>>>>>>>>>>>> % a2:Attribute{a2.name
> >>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>> >>>>>>>>>>>>> };
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> However, I just noted that there is a problem with
> >>> conjunct
> >>> >>>>> rules. I
> >>> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
> >>> much lower
> >>> >>>>> than
> >>> >>>>>>>>>>>> the
> >>> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix
> it.
> >>> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
> >>> variables for
> >>> >>>>> cheking
> >>> >>>>>>>>>>>> the
> >>> >>>>>>>>>>> AND, which looks all but declarative:
> >>> >>>>>>>>>>>>> BOOLEAN ft, fa;
> >>> >>>>>>>>>>>>> FOREACH(book) Book{}{
> >>> >>>>>>>>>>>>> book{-> ft = false, fa = false};
> >>> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
> >>> <http://a1.name>=="title", a1.ct=="Norse
> >>> >>>>>>>>>>>>> Mythology"->
> >>> >>>>>>>>>>>>> ft=true};};
> >>> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
> >>> <http://a2.name>=="author", a2.ct=="Neil
> >>> >>>>> Gaiman"->
> >>> >>>>>>>>>>>>> fa=true};};
> >>> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> >>> >>>>>>>>>>>>> }
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> ... or with a BLOCK...
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> BLOCK(book) Book{}{
> >>> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> >>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology"->
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>> ft=true};
> >>> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
> >>> a2.ct=="Neil Gaiman"->
> >>> >>>>> fa=true};
> >>> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> >>> >>>>>>>>>>>>> }
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> If the order of the attributes is known, you can
> >>> avoid the AND
> >>> >>>>> check
> >>> >>>>>>>>>>>> and
> >>> >>>>>>>>>>> just specify a sequential constraint:
> >>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> >>> a1.ct=="Norse Mythology"}
> >>> >>>>>>>>>>>>> # a2:Attribute{a2.name
> >>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>> >>>>>>>>>>>>> };
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> If you need to check on the complete title with the
> >>> URL, you
> >>> >> can
> >>> >>>>>>>>>>>> replace
> >>> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> >>> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> Best,
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> Peter
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb José Vicente Moyano
> >>> Murillo:
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> Hello everyone
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
> >>> annotations. But i'm
> >>> >> not
> >>> >>>>>>>>>>>>> able to
> >>> >>>>>>>>>>> accomplish my objective.
> >>> >>>>>>>>>>>>>> This is my case right now:
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> I have a text annotated with some annotations
> >> "*Book*".
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> >>> >> "*Attribute*"
> >>> >>>>>>>>>>>>>> that
> >>> >>>>>>>>>>>>>> stores some information about the book. Each
> >>> "*Attribute*"
> >>> >> has a
> >>> >>>>>>>>>>>>> feature
> >>> >>>>>>>>>>> "
> >>> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
> >>> "*Book*"
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> annotation).
> >>> >>>>>>>>>>> And example could be a text with 2 "*Book*"
> annotations:
> >>> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested
> attributes
> >>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> >>> covered
> >>> >>>>> text:
> >>> >>>>>>>>>>>>> "Norse
> >>> >>>>>>>>>>> Mythology
> >>> >>>>>>>>>>>>>>
> >>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
> >>> <http://www.barnesandnoble.com/w/norse-mythology-neil->
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>
> >>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> >>> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> "
> >>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> >>> -> covered
> >>> >>>>> text:
> >>> >>>>>>>>>>>>> "Neil
> >>> >>>>>>>>>>> Gaiman"
> >>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
> -
> >>>
> >>> >> covered
> >>> >>>>>>>>>>>>>> text:
> >>> >>>>>>>>>>>>>> "English"
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested
> attributes
> >>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> >>> covered
> >>> >>>>> text:
> >>> >>>>>>>>>>>>> "Never
> >>> >>>>>>>>>>> Never
> >>> >>>>>>>>>>>>>>
> >>> <http://www.barnesandnoble.com/w/never-never-james-patterson
> >>> <http://www.barnesandnoble.com/w/never-never-james-patterson>
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>> /1123863634;
> >>> >>>>>>>>>>>
> >>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> >>> >>>>>>>>>>>> atgap08?ean=
> >>> >>>>>>>>>>> 9780316433174>
> >>> >>>>>>>>>>>>>> "
> >>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> >>> -> covered
> >>> >>>>> text:
> >>> >>>>>>>>>>>>> "James
> >>> >>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> Patterson"
> >>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language"
> -
> >>>
> >>> >> covered
> >>> >>>>>>>>>>>>>> text:
> >>> >>>>>>>>>>>>>> "English"
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> I need to respect this schema but i have this
> >> question:
> >>> >>>>>>>>>>>>>> It is possible to create and annotation over a book
> >>> for a
> >>> >> given
> >>> >>>>>>>>>>>>> author
> >>> >>>>>>>>>>> name
> >>> >>>>>>>>>>>>>> and a given title name?
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>> Thank's in advance
> >>> >>>>>>>>>>>>>>
> >>> >>>>>>>>>>>>>>
> >>> >>
> >>>
> >>>
> >>
>
>
Re: Using RUTA
Posted by Peter Klügl <pe...@averbis.com>.
Hi,
Am 13.03.2017 um 17:41 schrieb Jos� Vicente Moyano Murillo:
> From our point of view we would expect the same result using # or %
Yes, I thought the same, but after investigating the problem I changed
my mind a bit.
Even if we ignore the label expression overriding the values with 'X's,
there is still a difference. The wildcard # introduces a sequential
constraint, and the conjunction % does not. The former implies a match
only for the next occureence of a valid annotation. And the latter? I
would initially say that the match should not be restricted to the first
one, meaning the first rule element for example will match twice as does
the fourth rule element. This would result in four 'A's in the list
compared to the two for the wildcard.
And there is also the difference that the execution of the action is
decoupled from the specific rule elements in the conjunct element
(causing the initial problem with the label expression)
> In any case it is our idea and the truth is that we do not know how to
> predict the impact.
I can totally understand that. I had to debug the implementation myself
quite a bit in order to get to know what is going on. That does not
happen too often to me concerning ruta.
I am open to suggestions how this situation can be improved. I am not
sure yet what should/can be done.
Best,
Peter
>
> regards
>
> 2017-03-13 10:56 GMT+01:00 Peter Kl�gl <pe...@averbis.com>:
>
>> Hi,
>>
>>
>> there is a conceptual problem when using label expressions in those
>> conjunct rules. The label expression stores the value of the matched
>> annotations even if the rule element does not match. It has to since the
>> matched annotation may be used to validate the conditions as you do.
>>
>> Maybe the value should be reset if the rule element does not match
>> correctly, but I have to investigate the consequences furhter before I
>> implement this change. Are there opinions?
>>
>>
>> If you change the rule to not use the label expression in the action,
>> there still seems to be a problem with the conjunct rules. e.g. like:
>>
>> Document{ -> CREATE(Detection, "anchors" = list)} <- {
>> w1:CW{w1.ct=="A" -> ADD(list, CW)}
>> %
>> w2:CW{w2.ct=="B" -> ADD(list, CW)}
>> %
>> w3:CW{w3.ct=="B" -> ADD(list, CW)}
>> %
>> w4:CW{w4.ct=="A" -> ADD(list, CW)};
>> };
>>
>>
>> This looks like a bug when validating the match itself depednent on the
>> element matches. I need to investigate that further...
>>
>>
>> I'll create a jira ticket for both.
>>
>>
>> Best,
>>
>>
>> Peter
>>
>>
>>
>> Am 09.03.2017 um 11:23 schrieb Jos� Vicente Moyano Murillo:
>>> Hi Peter
>>>
>>> We have prepared a short test with 2 methods.
>>> The first one is using #, the second one is using %
>>>
>>> We expect the same behaviour. But as you will see there are diferences.
>>>
>>> Regards
>>>
>>> 2017-02-28 16:00 GMT+01:00 Peter Kl�gl <peter.kluegl@averbis.com
>>> <ma...@averbis.com>>:
>>>
>>> hmmm ok, maybe my example for testing the rule was too simple.
>>>
>>> I will create a more complex example and check the results
>>>
>>>
>>> Peter
>>>
>>>
>>> Am 28.02.2017 um 15:38 schrieb Jos� Vicente Moyano Murillo:
>>> > Hi Peter,
>>> >
>>> > I'm sorry but this example does not work properly. It seems that
>>> it is a
>>> > problem regarding conjunction rules (%)
>>> >
>>> > This is our test case and result.
>>> >
>>> > We have a book with 5 attributes
>>> > - name
>>> > - author
>>> > - pages
>>> > - ISBN
>>> > - Category
>>> >
>>> > The rule is validatin name and author.
>>> >
>>> > RUTA creates the annotation with the list but the list contains
>>> 20 times
>>> > the las attribute (Category).
>>> >
>>> > If we use # it works perfectly. But in general we must use %
>>> >
>>> > May be this information will help you.
>>> >
>>> > Many thanks
>>> >
>>> >
>>> >
>>> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
>>> <ma...@gmail.com>>:
>>> >
>>> >> Hi,
>>> >>
>>> >>
>>> >> operations directly on lists and arrays are on my todo list but
>>> not yet
>>> >> implemented.
>>> >>
>>> >>
>>> >> Right now, there are still some options like a variable or
>>> restricted
>>> >> assignments.
>>> >>
>>> >>
>>> >> Here's an example with an ANNOTATIONLIST variable:
>>> >>
>>> >>
>>> >> ANNOTATIONLIST list;
>>> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
>>> >> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology" ->
>>> >> ADD(list,a1)}
>>> >> % a2:Attribute{a2.name <http://a2.name>=="author",
>>> a2.ct=="Neil Gaiman" ->
>>> >> ADD(list,a2)};
>>> >> };
>>> >>
>>> >>
>>> >> Variables are global, so you need to clear the list maybe
>>> somewhere,
>>> >> e.g. before the first ADD.
>>> >>
>>> >>
>>> >> In the current trunk, something like the following is also
>>> possible:
>>> >>
>>> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
>>> >> .name=="title", Attribute.name=="author")})}....
>>> >>
>>> >>
>>> >> Best,
>>> >>
>>> >>
>>> >> Peter
>>> >>
>>> >>
>>> >> Am 28.02.2017 um 14:06 schrieb Jos� Vicente Moyano Murillo:
>>> >>> Hi Peter, we have another question regarding the same example.
>>> >>>
>>> >>> Right now all is working properly (many thanks) and it seems that
>>> >>> 2.5.1-SNAPSHOT it's fine.
>>> >>>
>>> >>> Now we are planning to store some information in the created
>>> annotation.
>>> >> We
>>> >>> want to store all the attributes that matches the RUTA rule.
>>> >>>
>>> >>> It is possible to store a1 and a2 in a feature (attributes) of
>>> NeilsBook?
>>> >>>
>>> >>> The example:
>>> >>>
>>> >>> Book{-> NeilsBook}<-{
>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology"}
>>> >>> %
>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>> Gaiman"};
>>> >>> };
>>> >>>
>>> >>> We are using this aproach:
>>> >>>
>>> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
>>> >>> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology"}
>>> >>> %
>>> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
>>> Gaiman"};
>>> >>> };
>>> >>>
>>> >>> This example works but it is storing all the annotations
>>> "Attribute"
>>> >>> covered by "Book" and we just want the attributes that matches
>>> the rule.
>>> >>>
>>> >>> Thanks in advance.
>>> >>>
>>> >>>
>>> >>>
>>> >>>
>>> >>> 2017-02-24 10:29 GMT+01:00 Jos� Vicente Moyano Murillo
>>> <moyanoj@aia.es <ma...@aia.es>>:
>>> >>>
>>> >>>> Many thanks Peter ���
>>> >>>>
>>> >>>> 2017-02-24 9:46 GMT+01:00 Peter Kl�gl
>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>> >>>>
>>> >>>>> Hi,
>>> >>>>>
>>> >>>>>
>>> >>>>> the repo:
>>> >>>>>
>>> >>>>> <repository>
>>> >>>>> <id>apache.snapshots</id>
>>> >>>>> <name>Apache Snapshot Repository</name>
>>> >>>>> <url>http://repository.apache.org/snapshots
>>> <http://repository.apache.org/snapshots></url>
>>> >>>>> <releases>
>>> >>>>> <enabled>false</enabled>
>>> >>>>> </releases>
>>> >>>>> </repository>
>>> >>>>>
>>> >>>>>
>>> >>>>> the folder:
>>> >>>>>
>>> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
>>> <https://repository.apache.org/content/groups/snapshots/org/a>
>>> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
>>> >>>>>
>>> >>>>>
>>> >>>>> Best,
>>> >>>>>
>>> >>>>> Peter
>>> >>>>>
>>> >>>>>
>>> >>>>>
>>> >>>>> Am 23.02.2017 um 13:47 schrieb Jos� Vicente Moyano Murillo:
>>> >>>>>> Hi,
>>> >>>>>>
>>> >>>>>> ruta-core.jar it's enough.
>>> >>>>>>
>>> >>>>>> It will be fantastic if i could access the snapshot
>> repository.
>>> >>>>>>
>>> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Kl�gl
>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>> >>>>>>
>>> >>>>>>> Hi,
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
>>> >> plugins/update
>>> >>>>>>> site?
>>> >>>>>>>
>>> >>>>>>> I will prepare a new RC for the next release soon.
>>> >>>>>>>
>>> >>>>>>> There should be snapshot artifacts built by jenkins in the
>>> snapshot
>>> >>>>>>> repository. I am out-of-office today so do not have the
>>> link right
>>> >>>>> now. (If
>>> >>>>>>> you want to build it yourself, the svn source repo can be
>>> accessed by
>>> >>>>>>> anyone)
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>> Best,
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>> Peter
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>>
>>> >>>>>>> Am 23.02.2017 um 08:06 schrieb Jos� Vicente Moyano Murillo:
>>> >>>>>>>
>>> >>>>>>>> Hi Peter, good morning.
>>> >>>>>>>>
>>> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
>>> snapshot or
>>> >>>>> an
>>> >>>>>>>> access to the repo.
>>> >>>>>>>>
>>> >>>>>>>> Regards
>>> >>>>>>>>
>>> >>>>>>>> 2017-02-22 10:38 GMT+01:00 Jos� Vicente Moyano Murillo <
>>> >>>>> moyanoj@aia.es <ma...@aia.es>>:
>>> >>>>>>>> you're right
>>> >>>>>>>>> % is performing some kind of "or".
>>> >>>>>>>>>
>>> >>>>>>>>> So we will wait for the new release.
>>> >>>>>>>>>
>>> >>>>>>>>> Many thanks
>>> >>>>>>>>>
>>> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Kl�gl
>>> <peter.kluegl@averbis.com <ma...@averbis.com>>:
>>> >>>>>>>>>
>>> >>>>>>>>> I actually wonder why your rules work. I am quite sure
>>> that they
>>> >>>>> match
>>> >>>>>>>>>> too often, i. e. they match also if only one of the
>>> conjunct rule
>>> >>>>>>>>>> elements match.
>>> >>>>>>>>>>
>>> >>>>>>>>>> You can simply try that by using a wrong string in the
>>> check like
>>> >>>>> "NG"
>>> >>>>>>>>>> instead of "Neil Gaiman"
>>> >>>>>>>>>>
>>> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
>>> will be
>>> >>>>> part of
>>> >>>>>>>>>> the next release.
>>> >>>>>>>>>>
>>> >>>>>>>>>>
>>> >>>>>>>>>> Best,
>>> >>>>>>>>>>
>>> >>>>>>>>>>
>>> >>>>>>>>>> Peter
>>> >>>>>>>>>>
>>> >>>>>>>>>>
>>> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Kl�gl:
>>> >>>>>>>>>>
>>> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
>>> I'll
>>> >>>>> investigate
>>> >>>>>>>>>> it.
>>> >>>>>>>>>>
>>> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb Jos� Vicente Moyano
>>> Murillo:
>>> >>>>>>>>>>>
>>> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
>>> you said
>>> >> it
>>> >>>>> does
>>> >>>>>>>>>>> not
>>> >>>>>>>>>>> work with version 2.5.0. But we change a little your
>>> example and
>>> >> it
>>> >>>>>>>>>>> works
>>> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
>>> >>>>>>>>>>>> We use theses examples with success:
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>> Attribute.ct=="Norse
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>> Mythology"}"
>>> >>>>>>>>>>> %
>>> >>>>>>>>>>>> Attribute{Attribute.name=="author",
>>> >>>>>>>>>>>> Attribute.ct=="Neil
>>> >>>>>>>>>>>> Gaiman"};"
>>> >>>>>>>>>>>> };
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
>>> FEATURE("ct", "Norse
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>> Mythology")}"
>>> >>>>>>>>>>> %
>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>> >> FEATURE("ct",
>>> >>>>>>>>>>>> "Neil
>>> >>>>>>>>>>>> Gaiman")};
>>> >>>>>>>>>>>> };
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
>>> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
>>> >>>>>>>>>>>> Attribute{Attribute.name=="title",
>>> Attribute.ct=="Norse
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>> Mythology"}"
>>> >>>>>>>>>>> %
>>> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
>>> >> FEATURE("ct",
>>> >>>>>>>>>>>> "Neil
>>> >>>>>>>>>>>> Gaiman")};
>>> >>>>>>>>>>>> };
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
>>> >>>>>>>>>>>> a1:Attribute and a2:Attribute
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> In any case thank you very much for your help.
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>>
>>> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Kl�gl <
>>> >> peter.kluegl@averbis.com <ma...@averbis.com>
>>> >>>>>> :
>>> >>>>>>>>>>>> Hi,
>>> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
>>> construct to
>>> >>>>> specify
>>> >>>>>>>>>>>> an
>>> >>>>>>>>>>> AND between two rule element independent of the position:
>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology"}
>>> >>>>>>>>>>>>> % a2:Attribute{a2.name
>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>> >>>>>>>>>>>>> };
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> However, I just noted that there is a problem with
>>> conjunct
>>> >>>>> rules. I
>>> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
>>> much lower
>>> >>>>> than
>>> >>>>>>>>>>>> the
>>> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix it.
>>> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
>>> variables for
>>> >>>>> cheking
>>> >>>>>>>>>>>> the
>>> >>>>>>>>>>> AND, which looks all but declarative:
>>> >>>>>>>>>>>>> BOOLEAN ft, fa;
>>> >>>>>>>>>>>>> FOREACH(book) Book{}{
>>> >>>>>>>>>>>>> book{-> ft = false, fa = false};
>>> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
>>> <http://a1.name>=="title", a1.ct=="Norse
>>> >>>>>>>>>>>>> Mythology"->
>>> >>>>>>>>>>>>> ft=true};};
>>> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
>>> <http://a2.name>=="author", a2.ct=="Neil
>>> >>>>> Gaiman"->
>>> >>>>>>>>>>>>> fa=true};};
>>> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
>>> >>>>>>>>>>>>> }
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> ... or with a BLOCK...
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> BLOCK(book) Book{}{
>>> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology"->
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>> ft=true};
>>> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
>>> a2.ct=="Neil Gaiman"->
>>> >>>>> fa=true};
>>> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
>>> >>>>>>>>>>>>> }
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> If the order of the attributes is known, you can
>>> avoid the AND
>>> >>>>> check
>>> >>>>>>>>>>>> and
>>> >>>>>>>>>>> just specify a sequential constraint:
>>> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
>>> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
>>> a1.ct=="Norse Mythology"}
>>> >>>>>>>>>>>>> # a2:Attribute{a2.name
>>> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
>>> >>>>>>>>>>>>> };
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> If you need to check on the complete title with the
>>> URL, you
>>> >> can
>>> >>>>>>>>>>>> replace
>>> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
>>> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> Best,
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> Peter
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb Jos� Vicente Moyano
>>> Murillo:
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> Hello everyone
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
>>> annotations. But i'm
>>> >> not
>>> >>>>>>>>>>>>> able to
>>> >>>>>>>>>>> accomplish my objective.
>>> >>>>>>>>>>>>>> This is my case right now:
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> I have a text annotated with some annotations
>> "*Book*".
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
>>> >> "*Attribute*"
>>> >>>>>>>>>>>>>> that
>>> >>>>>>>>>>>>>> stores some information about the book. Each
>>> "*Attribute*"
>>> >> has a
>>> >>>>>>>>>>>>> feature
>>> >>>>>>>>>>> "
>>> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
>>> "*Book*"
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>> annotation).
>>> >>>>>>>>>>> And example could be a text with 2 "*Book*" annotations:
>>> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested attributes
>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>> covered
>>> >>>>> text:
>>> >>>>>>>>>>>>> "Norse
>>> >>>>>>>>>>> Mythology
>>> >>>>>>>>>>>>>>
>>> <http://www.barnesandnoble.com/w/norse-mythology-neil-
>>> <http://www.barnesandnoble.com/w/norse-mythology-neil->
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>
>>> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
>>> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> "
>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>> -> covered
>>> >>>>> text:
>>> >>>>>>>>>>>>> "Neil
>>> >>>>>>>>>>> Gaiman"
>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" -
>>>
>>> >> covered
>>> >>>>>>>>>>>>>> text:
>>> >>>>>>>>>>>>>> "English"
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested attributes
>>> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
>>> covered
>>> >>>>> text:
>>> >>>>>>>>>>>>> "Never
>>> >>>>>>>>>>> Never
>>> >>>>>>>>>>>>>>
>>> <http://www.barnesandnoble.com/w/never-never-james-patterson
>>> <http://www.barnesandnoble.com/w/never-never-james-patterson>
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>> /1123863634;
>>> >>>>>>>>>>>
>>> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
>>> >>>>>>>>>>>> atgap08?ean=
>>> >>>>>>>>>>> 9780316433174>
>>> >>>>>>>>>>>>>> "
>>> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
>>> -> covered
>>> >>>>> text:
>>> >>>>>>>>>>>>> "James
>>> >>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> Patterson"
>>> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" -
>>>
>>> >> covered
>>> >>>>>>>>>>>>>> text:
>>> >>>>>>>>>>>>>> "English"
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> I need to respect this schema but i have this
>> question:
>>> >>>>>>>>>>>>>> It is possible to create and annotation over a book
>>> for a
>>> >> given
>>> >>>>>>>>>>>>> author
>>> >>>>>>>>>>> name
>>> >>>>>>>>>>>>>> and a given title name?
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>> Thank's in advance
>>> >>>>>>>>>>>>>>
>>> >>>>>>>>>>>>>>
>>> >>
>>>
>>>
>>
Re: Using RUTA
Posted by José Vicente Moyano Murillo <mo...@aia.es>.
From our point of view we would expect the same result using # or %
In any case it is our idea and the truth is that we do not know how to
predict the impact.
regards
2017-03-13 10:56 GMT+01:00 Peter Klügl <pe...@averbis.com>:
> Hi,
>
>
> there is a conceptual problem when using label expressions in those
> conjunct rules. The label expression stores the value of the matched
> annotations even if the rule element does not match. It has to since the
> matched annotation may be used to validate the conditions as you do.
>
> Maybe the value should be reset if the rule element does not match
> correctly, but I have to investigate the consequences furhter before I
> implement this change. Are there opinions?
>
>
> If you change the rule to not use the label expression in the action,
> there still seems to be a problem with the conjunct rules. e.g. like:
>
> Document{ -> CREATE(Detection, "anchors" = list)} <- {
> w1:CW{w1.ct=="A" -> ADD(list, CW)}
> %
> w2:CW{w2.ct=="B" -> ADD(list, CW)}
> %
> w3:CW{w3.ct=="B" -> ADD(list, CW)}
> %
> w4:CW{w4.ct=="A" -> ADD(list, CW)};
> };
>
>
> This looks like a bug when validating the match itself depednent on the
> element matches. I need to investigate that further...
>
>
> I'll create a jira ticket for both.
>
>
> Best,
>
>
> Peter
>
>
>
> Am 09.03.2017 um 11:23 schrieb José Vicente Moyano Murillo:
> > Hi Peter
> >
> > We have prepared a short test with 2 methods.
> > The first one is using #, the second one is using %
> >
> > We expect the same behaviour. But as you will see there are diferences.
> >
> > Regards
> >
> > 2017-02-28 16:00 GMT+01:00 Peter Klügl <peter.kluegl@averbis.com
> > <ma...@averbis.com>>:
> >
> > hmmm ok, maybe my example for testing the rule was too simple.
> >
> > I will create a more complex example and check the results
> >
> >
> > Peter
> >
> >
> > Am 28.02.2017 um 15:38 schrieb José Vicente Moyano Murillo:
> > > Hi Peter,
> > >
> > > I'm sorry but this example does not work properly. It seems that
> > it is a
> > > problem regarding conjunction rules (%)
> > >
> > > This is our test case and result.
> > >
> > > We have a book with 5 attributes
> > > - name
> > > - author
> > > - pages
> > > - ISBN
> > > - Category
> > >
> > > The rule is validatin name and author.
> > >
> > > RUTA creates the annotation with the list but the list contains
> > 20 times
> > > the las attribute (Category).
> > >
> > > If we use # it works perfectly. But in general we must use %
> > >
> > > May be this information will help you.
> > >
> > > Many thanks
> > >
> > >
> > >
> > > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
> > <ma...@gmail.com>>:
> > >
> > >> Hi,
> > >>
> > >>
> > >> operations directly on lists and arrays are on my todo list but
> > not yet
> > >> implemented.
> > >>
> > >>
> > >> Right now, there are still some options like a variable or
> > restricted
> > >> assignments.
> > >>
> > >>
> > >> Here's an example with an ANNOTATIONLIST variable:
> > >>
> > >>
> > >> ANNOTATIONLIST list;
> > >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> > >> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology" ->
> > >> ADD(list,a1)}
> > >> % a2:Attribute{a2.name <http://a2.name>=="author",
> > a2.ct=="Neil Gaiman" ->
> > >> ADD(list,a2)};
> > >> };
> > >>
> > >>
> > >> Variables are global, so you need to clear the list maybe
> > somewhere,
> > >> e.g. before the first ADD.
> > >>
> > >>
> > >> In the current trunk, something like the following is also
> > possible:
> > >>
> > >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> > >> .name=="title", Attribute.name=="author")})}....
> > >>
> > >>
> > >> Best,
> > >>
> > >>
> > >> Peter
> > >>
> > >>
> > >> Am 28.02.2017 um 14:06 schrieb José Vicente Moyano Murillo:
> > >>> Hi Peter, we have another question regarding the same example.
> > >>>
> > >>> Right now all is working properly (many thanks) and it seems that
> > >>> 2.5.1-SNAPSHOT it's fine.
> > >>>
> > >>> Now we are planning to store some information in the created
> > annotation.
> > >> We
> > >>> want to store all the attributes that matches the RUTA rule.
> > >>>
> > >>> It is possible to store a1 and a2 in a feature (attributes) of
> > NeilsBook?
> > >>>
> > >>> The example:
> > >>>
> > >>> Book{-> NeilsBook}<-{
> > >>> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology"}
> > >>> %
> > >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> > Gaiman"};
> > >>> };
> > >>>
> > >>> We are using this aproach:
> > >>>
> > >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> > >>> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology"}
> > >>> %
> > >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> > Gaiman"};
> > >>> };
> > >>>
> > >>> This example works but it is storing all the annotations
> > "Attribute"
> > >>> covered by "Book" and we just want the attributes that matches
> > the rule.
> > >>>
> > >>> Thanks in advance.
> > >>>
> > >>>
> > >>>
> > >>>
> > >>> 2017-02-24 10:29 GMT+01:00 José Vicente Moyano Murillo
> > <moyanoj@aia.es <ma...@aia.es>>:
> > >>>
> > >>>> Many thanks Peter ¡¡¡
> > >>>>
> > >>>> 2017-02-24 9:46 GMT+01:00 Peter Klügl
> > <peter.kluegl@averbis.com <ma...@averbis.com>>:
> > >>>>
> > >>>>> Hi,
> > >>>>>
> > >>>>>
> > >>>>> the repo:
> > >>>>>
> > >>>>> <repository>
> > >>>>> <id>apache.snapshots</id>
> > >>>>> <name>Apache Snapshot Repository</name>
> > >>>>> <url>http://repository.apache.org/snapshots
> > <http://repository.apache.org/snapshots></url>
> > >>>>> <releases>
> > >>>>> <enabled>false</enabled>
> > >>>>> </releases>
> > >>>>> </repository>
> > >>>>>
> > >>>>>
> > >>>>> the folder:
> > >>>>>
> > >>>>> https://repository.apache.org/content/groups/snapshots/org/a
> > <https://repository.apache.org/content/groups/snapshots/org/a>
> > >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> > >>>>>
> > >>>>>
> > >>>>> Best,
> > >>>>>
> > >>>>> Peter
> > >>>>>
> > >>>>>
> > >>>>>
> > >>>>> Am 23.02.2017 um 13:47 schrieb José Vicente Moyano Murillo:
> > >>>>>> Hi,
> > >>>>>>
> > >>>>>> ruta-core.jar it's enough.
> > >>>>>>
> > >>>>>> It will be fantastic if i could access the snapshot
> repository.
> > >>>>>>
> > >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klügl
> > <peter.kluegl@averbis.com <ma...@averbis.com>>:
> > >>>>>>
> > >>>>>>> Hi,
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> > >> plugins/update
> > >>>>>>> site?
> > >>>>>>>
> > >>>>>>> I will prepare a new RC for the next release soon.
> > >>>>>>>
> > >>>>>>> There should be snapshot artifacts built by jenkins in the
> > snapshot
> > >>>>>>> repository. I am out-of-office today so do not have the
> > link right
> > >>>>> now. (If
> > >>>>>>> you want to build it yourself, the svn source repo can be
> > accessed by
> > >>>>>>> anyone)
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> Best,
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> Peter
> > >>>>>>>
> > >>>>>>>
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> Am 23.02.2017 um 08:06 schrieb José Vicente Moyano Murillo:
> > >>>>>>>
> > >>>>>>>> Hi Peter, good morning.
> > >>>>>>>>
> > >>>>>>>> Have we any opportunity to get a fixed version? I mean a
> > snapshot or
> > >>>>> an
> > >>>>>>>> access to the repo.
> > >>>>>>>>
> > >>>>>>>> Regards
> > >>>>>>>>
> > >>>>>>>> 2017-02-22 10:38 GMT+01:00 José Vicente Moyano Murillo <
> > >>>>> moyanoj@aia.es <ma...@aia.es>>:
> > >>>>>>>> you're right
> > >>>>>>>>> % is performing some kind of "or".
> > >>>>>>>>>
> > >>>>>>>>> So we will wait for the new release.
> > >>>>>>>>>
> > >>>>>>>>> Many thanks
> > >>>>>>>>>
> > >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klügl
> > <peter.kluegl@averbis.com <ma...@averbis.com>>:
> > >>>>>>>>>
> > >>>>>>>>> I actually wonder why your rules work. I am quite sure
> > that they
> > >>>>> match
> > >>>>>>>>>> too often, i. e. they match also if only one of the
> > conjunct rule
> > >>>>>>>>>> elements match.
> > >>>>>>>>>>
> > >>>>>>>>>> You can simply try that by using a wrong string in the
> > check like
> > >>>>> "NG"
> > >>>>>>>>>> instead of "Neil Gaiman"
> > >>>>>>>>>>
> > >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
> > will be
> > >>>>> part of
> > >>>>>>>>>> the next release.
> > >>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Best,
> > >>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Peter
> > >>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klügl:
> > >>>>>>>>>>
> > >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
> > I'll
> > >>>>> investigate
> > >>>>>>>>>> it.
> > >>>>>>>>>>
> > >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb José Vicente Moyano
> > Murillo:
> > >>>>>>>>>>>
> > >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> We tried the first option using Conjunct rules and as
> > you said
> > >> it
> > >>>>> does
> > >>>>>>>>>>> not
> > >>>>>>>>>>> work with version 2.5.0. But we change a little your
> > example and
> > >> it
> > >>>>>>>>>>> works
> > >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> > >>>>>>>>>>>> We use theses examples with success:
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> > >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> > >>>>>>>>>>>> Attribute{Attribute.name=="title",
> > Attribute.ct=="Norse
> > >>>>>>>>>>>>
> > >>>>>>>>>>> Mythology"}"
> > >>>>>>>>>>> %
> > >>>>>>>>>>>> Attribute{Attribute.name=="author",
> > >>>>>>>>>>>> Attribute.ct=="Neil
> > >>>>>>>>>>>> Gaiman"};"
> > >>>>>>>>>>>> };
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> > >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> > >>>>>>>>>>>> Attribute{FEATURE("name","title"),
> > FEATURE("ct", "Norse
> > >>>>>>>>>>>>
> > >>>>>>>>>>> Mythology")}"
> > >>>>>>>>>>> %
> > >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> > >> FEATURE("ct",
> > >>>>>>>>>>>> "Neil
> > >>>>>>>>>>>> Gaiman")};
> > >>>>>>>>>>>> };
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> > >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> > >>>>>>>>>>>> Attribute{Attribute.name=="title",
> > Attribute.ct=="Norse
> > >>>>>>>>>>>>
> > >>>>>>>>>>> Mythology"}"
> > >>>>>>>>>>> %
> > >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> > >> FEATURE("ct",
> > >>>>>>>>>>>> "Neil
> > >>>>>>>>>>>> Gaiman")};
> > >>>>>>>>>>>> };
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> > >>>>>>>>>>>> a1:Attribute and a2:Attribute
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> In any case thank you very much for your help.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klügl <
> > >> peter.kluegl@averbis.com <ma...@averbis.com>
> > >>>>>> :
> > >>>>>>>>>>>> Hi,
> > >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
> > construct to
> > >>>>> specify
> > >>>>>>>>>>>> an
> > >>>>>>>>>>> AND between two rule element independent of the position:
> > >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> > >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology"}
> > >>>>>>>>>>>>> % a2:Attribute{a2.name
> > <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> > >>>>>>>>>>>>> };
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> However, I just noted that there is a problem with
> > conjunct
> > >>>>> rules. I
> > >>>>>>>>>>>>> haven't used it in a long time and the test coverage
> > much lower
> > >>>>> than
> > >>>>>>>>>>>> the
> > >>>>>>>>>>> other constructs. I'll create a ticket for it and fix it.
> > >>>>>>>>>>>>> Without conjunct rules, you need some boolean
> > variables for
> > >>>>> cheking
> > >>>>>>>>>>>> the
> > >>>>>>>>>>> AND, which looks all but declarative:
> > >>>>>>>>>>>>> BOOLEAN ft, fa;
> > >>>>>>>>>>>>> FOREACH(book) Book{}{
> > >>>>>>>>>>>>> book{-> ft = false, fa = false};
> > >>>>>>>>>>>>> book->{a1:Attribute{a1.name
> > <http://a1.name>=="title", a1.ct=="Norse
> > >>>>>>>>>>>>> Mythology"->
> > >>>>>>>>>>>>> ft=true};};
> > >>>>>>>>>>>>> book->{a2:Attribute{a2.name
> > <http://a2.name>=="author", a2.ct=="Neil
> > >>>>> Gaiman"->
> > >>>>>>>>>>>>> fa=true};};
> > >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> > >>>>>>>>>>>>> }
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> ... or with a BLOCK...
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> BLOCK(book) Book{}{
> > >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> > >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology"->
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>> ft=true};
> > >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
> > a2.ct=="Neil Gaiman"->
> > >>>>> fa=true};
> > >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> > >>>>>>>>>>>>> }
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> If the order of the attributes is known, you can
> > avoid the AND
> > >>>>> check
> > >>>>>>>>>>>> and
> > >>>>>>>>>>> just specify a sequential constraint:
> > >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> > >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> > a1.ct=="Norse Mythology"}
> > >>>>>>>>>>>>> # a2:Attribute{a2.name
> > <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> > >>>>>>>>>>>>> };
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> If you need to check on the complete title with the
> > URL, you
> > >> can
> > >>>>>>>>>>>> replace
> > >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> > >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Peter
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb José Vicente Moyano
> > Murillo:
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Hello everyone
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I'm planning to use RUTA to create some
> > annotations. But i'm
> > >> not
> > >>>>>>>>>>>>> able to
> > >>>>>>>>>>> accomplish my objective.
> > >>>>>>>>>>>>>> This is my case right now:
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I have a text annotated with some annotations
> "*Book*".
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> > >> "*Attribute*"
> > >>>>>>>>>>>>>> that
> > >>>>>>>>>>>>>> stores some information about the book. Each
> > "*Attribute*"
> > >> has a
> > >>>>>>>>>>>>> feature
> > >>>>>>>>>>> "
> > >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
> > "*Book*"
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>> annotation).
> > >>>>>>>>>>> And example could be a text with 2 "*Book*" annotations:
> > >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested attributes
> > >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> > covered
> > >>>>> text:
> > >>>>>>>>>>>>> "Norse
> > >>>>>>>>>>> Mythology
> > >>>>>>>>>>>>>>
> > <http://www.barnesandnoble.com/w/norse-mythology-neil-
> > <http://www.barnesandnoble.com/w/norse-mythology-neil->
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> > >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> "
> > >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> > -> covered
> > >>>>> text:
> > >>>>>>>>>>>>> "Neil
> > >>>>>>>>>>> Gaiman"
> > >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" -
> >
> > >> covered
> > >>>>>>>>>>>>>> text:
> > >>>>>>>>>>>>>> "English"
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested attributes
> > >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> > covered
> > >>>>> text:
> > >>>>>>>>>>>>> "Never
> > >>>>>>>>>>> Never
> > >>>>>>>>>>>>>>
> > <http://www.barnesandnoble.com/w/never-never-james-patterson
> > <http://www.barnesandnoble.com/w/never-never-james-patterson>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>> /1123863634;
> > >>>>>>>>>>>
> > jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> > >>>>>>>>>>>> atgap08?ean=
> > >>>>>>>>>>> 9780316433174>
> > >>>>>>>>>>>>>> "
> > >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> > -> covered
> > >>>>> text:
> > >>>>>>>>>>>>> "James
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Patterson"
> > >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" -
> >
> > >> covered
> > >>>>>>>>>>>>>> text:
> > >>>>>>>>>>>>>> "English"
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I need to respect this schema but i have this
> question:
> > >>>>>>>>>>>>>> It is possible to create and annotation over a book
> > for a
> > >> given
> > >>>>>>>>>>>>> author
> > >>>>>>>>>>> name
> > >>>>>>>>>>>>>> and a given title name?
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Thank's in advance
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>
> >
> >
>
>
Re: Using RUTA
Posted by Peter Klügl <pe...@averbis.com>.
Hi,
there is a conceptual problem when using label expressions in those
conjunct rules. The label expression stores the value of the matched
annotations even if the rule element does not match. It has to since the
matched annotation may be used to validate the conditions as you do.
Maybe the value should be reset if the rule element does not match
correctly, but I have to investigate the consequences furhter before I
implement this change. Are there opinions?
If you change the rule to not use the label expression in the action,
there still seems to be a problem with the conjunct rules. e.g. like:
Document{ -> CREATE(Detection, "anchors" = list)} <- {
w1:CW{w1.ct=="A" -> ADD(list, CW)}
%
w2:CW{w2.ct=="B" -> ADD(list, CW)}
%
w3:CW{w3.ct=="B" -> ADD(list, CW)}
%
w4:CW{w4.ct=="A" -> ADD(list, CW)};
};
This looks like a bug when validating the match itself depednent on the
element matches. I need to investigate that further...
I'll create a jira ticket for both.
Best,
Peter
Am 09.03.2017 um 11:23 schrieb Jos Vicente Moyano Murillo:
> Hi Peter
>
> We have prepared a short test with 2 methods.
> The first one is using #, the second one is using %
>
> We expect the same behaviour. But as you will see there are diferences.
>
> Regards
>
> 2017-02-28 16:00 GMT+01:00 Peter Klgl <peter.kluegl@averbis.com
> <ma...@averbis.com>>:
>
> hmmm ok, maybe my example for testing the rule was too simple.
>
> I will create a more complex example and check the results
>
>
> Peter
>
>
> Am 28.02.2017 um 15:38 schrieb Jos Vicente Moyano Murillo:
> > Hi Peter,
> >
> > I'm sorry but this example does not work properly. It seems that
> it is a
> > problem regarding conjunction rules (%)
> >
> > This is our test case and result.
> >
> > We have a book with 5 attributes
> > - name
> > - author
> > - pages
> > - ISBN
> > - Category
> >
> > The rule is validatin name and author.
> >
> > RUTA creates the annotation with the list but the list contains
> 20 times
> > the las attribute (Category).
> >
> > If we use # it works perfectly. But in general we must use %
> >
> > May be this information will help you.
> >
> > Many thanks
> >
> >
> >
> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
> <ma...@gmail.com>>:
> >
> >> Hi,
> >>
> >>
> >> operations directly on lists and arrays are on my todo list but
> not yet
> >> implemented.
> >>
> >>
> >> Right now, there are still some options like a variable or
> restricted
> >> assignments.
> >>
> >>
> >> Here's an example with an ANNOTATIONLIST variable:
> >>
> >>
> >> ANNOTATIONLIST list;
> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> >> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology" ->
> >> ADD(list,a1)}
> >> % a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil Gaiman" ->
> >> ADD(list,a2)};
> >> };
> >>
> >>
> >> Variables are global, so you need to clear the list maybe
> somewhere,
> >> e.g. before the first ADD.
> >>
> >>
> >> In the current trunk, something like the following is also
> possible:
> >>
> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> >> .name=="title", Attribute.name=="author")})}....
> >>
> >>
> >> Best,
> >>
> >>
> >> Peter
> >>
> >>
> >> Am 28.02.2017 um 14:06 schrieb Jos Vicente Moyano Murillo:
> >>> Hi Peter, we have another question regarding the same example.
> >>>
> >>> Right now all is working properly (many thanks) and it seems that
> >>> 2.5.1-SNAPSHOT it's fine.
> >>>
> >>> Now we are planning to store some information in the created
> annotation.
> >> We
> >>> want to store all the attributes that matches the RUTA rule.
> >>>
> >>> It is possible to store a1 and a2 in a feature (attributes) of
> NeilsBook?
> >>>
> >>> The example:
> >>>
> >>> Book{-> NeilsBook}<-{
> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> Gaiman"};
> >>> };
> >>>
> >>> We are using this aproach:
> >>>
> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> Gaiman"};
> >>> };
> >>>
> >>> This example works but it is storing all the annotations
> "Attribute"
> >>> covered by "Book" and we just want the attributes that matches
> the rule.
> >>>
> >>> Thanks in advance.
> >>>
> >>>
> >>>
> >>>
> >>> 2017-02-24 10:29 GMT+01:00 Jos Vicente Moyano Murillo
> <moyanoj@aia.es <ma...@aia.es>>:
> >>>
> >>>> Many thanks Peter
> >>>>
> >>>> 2017-02-24 9:46 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>
> >>>>> Hi,
> >>>>>
> >>>>>
> >>>>> the repo:
> >>>>>
> >>>>> <repository>
> >>>>> <id>apache.snapshots</id>
> >>>>> <name>Apache Snapshot Repository</name>
> >>>>> <url>http://repository.apache.org/snapshots
> <http://repository.apache.org/snapshots></url>
> >>>>> <releases>
> >>>>> <enabled>false</enabled>
> >>>>> </releases>
> >>>>> </repository>
> >>>>>
> >>>>>
> >>>>> the folder:
> >>>>>
> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
> <https://repository.apache.org/content/groups/snapshots/org/a>
> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> >>>>>
> >>>>>
> >>>>> Best,
> >>>>>
> >>>>> Peter
> >>>>>
> >>>>>
> >>>>>
> >>>>> Am 23.02.2017 um 13:47 schrieb Jos Vicente Moyano Murillo:
> >>>>>> Hi,
> >>>>>>
> >>>>>> ruta-core.jar it's enough.
> >>>>>>
> >>>>>> It will be fantastic if i could access the snapshot repository.
> >>>>>>
> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>>>
> >>>>>>> Hi,
> >>>>>>>
> >>>>>>>
> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> >> plugins/update
> >>>>>>> site?
> >>>>>>>
> >>>>>>> I will prepare a new RC for the next release soon.
> >>>>>>>
> >>>>>>> There should be snapshot artifacts built by jenkins in the
> snapshot
> >>>>>>> repository. I am out-of-office today so do not have the
> link right
> >>>>> now. (If
> >>>>>>> you want to build it yourself, the svn source repo can be
> accessed by
> >>>>>>> anyone)
> >>>>>>>
> >>>>>>>
> >>>>>>> Best,
> >>>>>>>
> >>>>>>>
> >>>>>>> Peter
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>> Am 23.02.2017 um 08:06 schrieb Jos Vicente Moyano Murillo:
> >>>>>>>
> >>>>>>>> Hi Peter, good morning.
> >>>>>>>>
> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
> snapshot or
> >>>>> an
> >>>>>>>> access to the repo.
> >>>>>>>>
> >>>>>>>> Regards
> >>>>>>>>
> >>>>>>>> 2017-02-22 10:38 GMT+01:00 Jos Vicente Moyano Murillo <
> >>>>> moyanoj@aia.es <ma...@aia.es>>:
> >>>>>>>> you're right
> >>>>>>>>> % is performing some kind of "or".
> >>>>>>>>>
> >>>>>>>>> So we will wait for the new release.
> >>>>>>>>>
> >>>>>>>>> Many thanks
> >>>>>>>>>
> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>>>>>>
> >>>>>>>>> I actually wonder why your rules work. I am quite sure
> that they
> >>>>> match
> >>>>>>>>>> too often, i. e. they match also if only one of the
> conjunct rule
> >>>>>>>>>> elements match.
> >>>>>>>>>>
> >>>>>>>>>> You can simply try that by using a wrong string in the
> check like
> >>>>> "NG"
> >>>>>>>>>> instead of "Neil Gaiman"
> >>>>>>>>>>
> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
> will be
> >>>>> part of
> >>>>>>>>>> the next release.
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Best,
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Peter
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klgl:
> >>>>>>>>>>
> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
> I'll
> >>>>> investigate
> >>>>>>>>>> it.
> >>>>>>>>>>
> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb Jos Vicente Moyano
> Murillo:
> >>>>>>>>>>>
> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> >>>>>>>>>>>>
> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
> you said
> >> it
> >>>>> does
> >>>>>>>>>>> not
> >>>>>>>>>>> work with version 2.5.0. But we change a little your
> example and
> >> it
> >>>>>>>>>>> works
> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> >>>>>>>>>>>> We use theses examples with success:
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{Attribute.name=="author",
> >>>>>>>>>>>> Attribute.ct=="Neil
> >>>>>>>>>>>> Gaiman"};"
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
> FEATURE("ct", "Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology")}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> >>>>>>>>>>>> a1:Attribute and a2:Attribute
> >>>>>>>>>>>>
> >>>>>>>>>>>> In any case thank you very much for your help.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klgl <
> >> peter.kluegl@averbis.com <ma...@averbis.com>
> >>>>>> :
> >>>>>>>>>>>> Hi,
> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
> construct to
> >>>>> specify
> >>>>>>>>>>>> an
> >>>>>>>>>>> AND between two rule element independent of the position:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>>>>>>>>>>>> % a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> However, I just noted that there is a problem with
> conjunct
> >>>>> rules. I
> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
> much lower
> >>>>> than
> >>>>>>>>>>>> the
> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix it.
> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
> variables for
> >>>>> cheking
> >>>>>>>>>>>> the
> >>>>>>>>>>> AND, which looks all but declarative:
> >>>>>>>>>>>>> BOOLEAN ft, fa;
> >>>>>>>>>>>>> FOREACH(book) Book{}{
> >>>>>>>>>>>>> book{-> ft = false, fa = false};
> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
> <http://a1.name>=="title", a1.ct=="Norse
> >>>>>>>>>>>>> Mythology"->
> >>>>>>>>>>>>> ft=true};};
> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil
> >>>>> Gaiman"->
> >>>>>>>>>>>>> fa=true};};
> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ... or with a BLOCK...
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> BLOCK(book) Book{}{
> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"->
> >>>>>>>>>>>>>
> >>>>>>>>>>>> ft=true};
> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil Gaiman"->
> >>>>> fa=true};
> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If the order of the attributes is known, you can
> avoid the AND
> >>>>> check
> >>>>>>>>>>>> and
> >>>>>>>>>>> just specify a sequential constraint:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>>>>>>>>>>>> # a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you need to check on the complete title with the
> URL, you
> >> can
> >>>>>>>>>>>> replace
> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Best,
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Peter
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb Jos Vicente Moyano
> Murillo:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Hello everyone
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
> annotations. But i'm
> >> not
> >>>>>>>>>>>>> able to
> >>>>>>>>>>> accomplish my objective.
> >>>>>>>>>>>>>> This is my case right now:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have a text annotated with some annotations "*Book*".
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> >> "*Attribute*"
> >>>>>>>>>>>>>> that
> >>>>>>>>>>>>>> stores some information about the book. Each
> "*Attribute*"
> >> has a
> >>>>>>>>>>>>> feature
> >>>>>>>>>>> "
> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
> "*Book*"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> annotation).
> >>>>>>>>>>> And example could be a text with 2 "*Book*" annotations:
> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "Norse
> >>>>>>>>>>> Mythology
> >>>>>>>>>>>>>>
> <http://www.barnesandnoble.com/w/norse-mythology-neil-
> <http://www.barnesandnoble.com/w/norse-mythology-neil->
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> -> covered
> >>>>> text:
> >>>>>>>>>>>>> "Neil
> >>>>>>>>>>> Gaiman"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "Never
> >>>>>>>>>>> Never
> >>>>>>>>>>>>>>
> <http://www.barnesandnoble.com/w/never-never-james-patterson
> <http://www.barnesandnoble.com/w/never-never-james-patterson>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> /1123863634;
> >>>>>>>>>>>
> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> >>>>>>>>>>>> atgap08?ean=
> >>>>>>>>>>> 9780316433174>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> -> covered
> >>>>> text:
> >>>>>>>>>>>>> "James
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Patterson"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I need to respect this schema but i have this question:
> >>>>>>>>>>>>>> It is possible to create and annotation over a book
> for a
> >> given
> >>>>>>>>>>>>> author
> >>>>>>>>>>> name
> >>>>>>>>>>>>>> and a given title name?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Thank's in advance
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>
>
>
Re: Using RUTA
Posted by Peter Klügl <pe...@averbis.com>.
Hi,
I am sorry that I did not find the time for this before the rc/release.
I had it on my TODO list.
Thanks for the test. I wont make it today but I will take a closer look
at it next week.
Best,
Peter
Am 09.03.2017 um 11:23 schrieb Jos Vicente Moyano Murillo:
> Hi Peter
>
> We have prepared a short test with 2 methods.
> The first one is using #, the second one is using %
>
> We expect the same behaviour. But as you will see there are diferences.
>
> Regards
>
> 2017-02-28 16:00 GMT+01:00 Peter Klgl <peter.kluegl@averbis.com
> <ma...@averbis.com>>:
>
> hmmm ok, maybe my example for testing the rule was too simple.
>
> I will create a more complex example and check the results
>
>
> Peter
>
>
> Am 28.02.2017 um 15:38 schrieb Jos Vicente Moyano Murillo:
> > Hi Peter,
> >
> > I'm sorry but this example does not work properly. It seems that
> it is a
> > problem regarding conjunction rules (%)
> >
> > This is our test case and result.
> >
> > We have a book with 5 attributes
> > - name
> > - author
> > - pages
> > - ISBN
> > - Category
> >
> > The rule is validatin name and author.
> >
> > RUTA creates the annotation with the list but the list contains
> 20 times
> > the las attribute (Category).
> >
> > If we use # it works perfectly. But in general we must use %
> >
> > May be this information will help you.
> >
> > Many thanks
> >
> >
> >
> > 2017-02-28 14:23 GMT+01:00 Peter Kluegl <pkluegl@gmail.com
> <ma...@gmail.com>>:
> >
> >> Hi,
> >>
> >>
> >> operations directly on lists and arrays are on my todo list but
> not yet
> >> implemented.
> >>
> >>
> >> Right now, there are still some options like a variable or
> restricted
> >> assignments.
> >>
> >>
> >> Here's an example with an ANNOTATIONLIST variable:
> >>
> >>
> >> ANNOTATIONLIST list;
> >> Book{-> CREATE(NeilsBook, "attributes" = list)}<-{
> >> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology" ->
> >> ADD(list,a1)}
> >> % a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil Gaiman" ->
> >> ADD(list,a2)};
> >> };
> >>
> >>
> >> Variables are global, so you need to clear the list maybe
> somewhere,
> >> e.g. before the first ADD.
> >>
> >>
> >> In the current trunk, something like the following is also
> possible:
> >>
> >> Book{-> NeilsBook("attributes" = Attribute{OR(Attribute
> >> .name=="title", Attribute.name=="author")})}....
> >>
> >>
> >> Best,
> >>
> >>
> >> Peter
> >>
> >>
> >> Am 28.02.2017 um 14:06 schrieb Jos Vicente Moyano Murillo:
> >>> Hi Peter, we have another question regarding the same example.
> >>>
> >>> Right now all is working properly (many thanks) and it seems that
> >>> 2.5.1-SNAPSHOT it's fine.
> >>>
> >>> Now we are planning to store some information in the created
> annotation.
> >> We
> >>> want to store all the attributes that matches the RUTA rule.
> >>>
> >>> It is possible to store a1 and a2 in a feature (attributes) of
> NeilsBook?
> >>>
> >>> The example:
> >>>
> >>> Book{-> NeilsBook}<-{
> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> Gaiman"};
> >>> };
> >>>
> >>> We are using this aproach:
> >>>
> >>> Book{-> NeilsBook("attributes" = Attribute )}<-{
> >>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>> %
> >>> a2:Attribute{a2.name <http://a2.name>=="author", a2.ct=="Neil
> Gaiman"};
> >>> };
> >>>
> >>> This example works but it is storing all the annotations
> "Attribute"
> >>> covered by "Book" and we just want the attributes that matches
> the rule.
> >>>
> >>> Thanks in advance.
> >>>
> >>>
> >>>
> >>>
> >>> 2017-02-24 10:29 GMT+01:00 Jos Vicente Moyano Murillo
> <moyanoj@aia.es <ma...@aia.es>>:
> >>>
> >>>> Many thanks Peter
> >>>>
> >>>> 2017-02-24 9:46 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>
> >>>>> Hi,
> >>>>>
> >>>>>
> >>>>> the repo:
> >>>>>
> >>>>> <repository>
> >>>>> <id>apache.snapshots</id>
> >>>>> <name>Apache Snapshot Repository</name>
> >>>>> <url>http://repository.apache.org/snapshots
> <http://repository.apache.org/snapshots></url>
> >>>>> <releases>
> >>>>> <enabled>false</enabled>
> >>>>> </releases>
> >>>>> </repository>
> >>>>>
> >>>>>
> >>>>> the folder:
> >>>>>
> >>>>> https://repository.apache.org/content/groups/snapshots/org/a
> <https://repository.apache.org/content/groups/snapshots/org/a>
> >>>>> pache/uima/ruta-core/2.5.1-SNAPSHOT/
> >>>>>
> >>>>>
> >>>>> Best,
> >>>>>
> >>>>> Peter
> >>>>>
> >>>>>
> >>>>>
> >>>>> Am 23.02.2017 um 13:47 schrieb Jos Vicente Moyano Murillo:
> >>>>>> Hi,
> >>>>>>
> >>>>>> ruta-core.jar it's enough.
> >>>>>>
> >>>>>> It will be fantastic if i could access the snapshot repository.
> >>>>>>
> >>>>>> 2017-02-23 13:03 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>>>
> >>>>>>> Hi,
> >>>>>>>
> >>>>>>>
> >>>>>>> what do you need? Only ruta-core.jar or also the Eclipse
> >> plugins/update
> >>>>>>> site?
> >>>>>>>
> >>>>>>> I will prepare a new RC for the next release soon.
> >>>>>>>
> >>>>>>> There should be snapshot artifacts built by jenkins in the
> snapshot
> >>>>>>> repository. I am out-of-office today so do not have the
> link right
> >>>>> now. (If
> >>>>>>> you want to build it yourself, the svn source repo can be
> accessed by
> >>>>>>> anyone)
> >>>>>>>
> >>>>>>>
> >>>>>>> Best,
> >>>>>>>
> >>>>>>>
> >>>>>>> Peter
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>> Am 23.02.2017 um 08:06 schrieb Jos Vicente Moyano Murillo:
> >>>>>>>
> >>>>>>>> Hi Peter, good morning.
> >>>>>>>>
> >>>>>>>> Have we any opportunity to get a fixed version? I mean a
> snapshot or
> >>>>> an
> >>>>>>>> access to the repo.
> >>>>>>>>
> >>>>>>>> Regards
> >>>>>>>>
> >>>>>>>> 2017-02-22 10:38 GMT+01:00 Jos Vicente Moyano Murillo <
> >>>>> moyanoj@aia.es <ma...@aia.es>>:
> >>>>>>>> you're right
> >>>>>>>>> % is performing some kind of "or".
> >>>>>>>>>
> >>>>>>>>> So we will wait for the new release.
> >>>>>>>>>
> >>>>>>>>> Many thanks
> >>>>>>>>>
> >>>>>>>>> 2017-02-22 9:54 GMT+01:00 Peter Klgl
> <peter.kluegl@averbis.com <ma...@averbis.com>>:
> >>>>>>>>>
> >>>>>>>>> I actually wonder why your rules work. I am quite sure
> that they
> >>>>> match
> >>>>>>>>>> too often, i. e. they match also if only one of the
> conjunct rule
> >>>>>>>>>> elements match.
> >>>>>>>>>>
> >>>>>>>>>> You can simply try that by using a wrong string in the
> check like
> >>>>> "NG"
> >>>>>>>>>> instead of "Neil Gaiman"
> >>>>>>>>>>
> >>>>>>>>>> Anyways, the problem will be fixed in a few minutes and
> will be
> >>>>> part of
> >>>>>>>>>> the next release.
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Best,
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Peter
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Am 22.02.2017 um 09:38 schrieb Peter Klgl:
> >>>>>>>>>>
> >>>>>>>>>>> Thanks. Maybe its just a bug in 2.5.0 I already fixed.
> I'll
> >>>>> investigate
> >>>>>>>>>> it.
> >>>>>>>>>>
> >>>>>>>>>>> Am 22.02.2017 um 09:24 schrieb Jos Vicente Moyano
> Murillo:
> >>>>>>>>>>>
> >>>>>>>>>>>> Thank you very much Peter. Your advice was amazing.
> >>>>>>>>>>>>
> >>>>>>>>>>>> We tried the first option using Conjunct rules and as
> you said
> >> it
> >>>>> does
> >>>>>>>>>>> not
> >>>>>>>>>>> work with version 2.5.0. But we change a little your
> example and
> >> it
> >>>>>>>>>>> works
> >>>>>>>>>>> perfectly witn 2.4.0 and 2.5.0
> >>>>>>>>>>>> We use theses examples with success:
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{Attribute.name=="author",
> >>>>>>>>>>>> Attribute.ct=="Neil
> >>>>>>>>>>>> Gaiman"};"
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{FEATURE("name","title"),
> FEATURE("ct", "Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology")}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>> DECLARE Annotation RuleDetection;
> >>>>>>>>>>>> Book{ -> CREATE(NeilsBook) } <- {
> >>>>>>>>>>>> Attribute{Attribute.name=="title",
> Attribute.ct=="Norse
> >>>>>>>>>>>>
> >>>>>>>>>>> Mythology"}"
> >>>>>>>>>>> %
> >>>>>>>>>>>> Attribute{FEATURE("name","author"),
> >> FEATURE("ct",
> >>>>>>>>>>>> "Neil
> >>>>>>>>>>>> Gaiman")};
> >>>>>>>>>>>> };
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> May be the problem is with when we use Identifiers:
> >>>>>>>>>>>> a1:Attribute and a2:Attribute
> >>>>>>>>>>>>
> >>>>>>>>>>>> In any case thank you very much for your help.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> 2017-02-21 17:46 GMT+01:00 Peter Klgl <
> >> peter.kluegl@averbis.com <ma...@averbis.com>
> >>>>>> :
> >>>>>>>>>>>> Hi,
> >>>>>>>>>>>>> I'd normally say that you need the conjunt rules
> construct to
> >>>>> specify
> >>>>>>>>>>>> an
> >>>>>>>>>>> AND between two rule element independent of the position:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>>>>>>>>>>>> % a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> However, I just noted that there is a problem with
> conjunct
> >>>>> rules. I
> >>>>>>>>>>>>> haven't used it in a long time and the test coverage
> much lower
> >>>>> than
> >>>>>>>>>>>> the
> >>>>>>>>>>> other constructs. I'll create a ticket for it and fix it.
> >>>>>>>>>>>>> Without conjunct rules, you need some boolean
> variables for
> >>>>> cheking
> >>>>>>>>>>>> the
> >>>>>>>>>>> AND, which looks all but declarative:
> >>>>>>>>>>>>> BOOLEAN ft, fa;
> >>>>>>>>>>>>> FOREACH(book) Book{}{
> >>>>>>>>>>>>> book{-> ft = false, fa = false};
> >>>>>>>>>>>>> book->{a1:Attribute{a1.name
> <http://a1.name>=="title", a1.ct=="Norse
> >>>>>>>>>>>>> Mythology"->
> >>>>>>>>>>>>> ft=true};};
> >>>>>>>>>>>>> book->{a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil
> >>>>> Gaiman"->
> >>>>>>>>>>>>> fa=true};};
> >>>>>>>>>>>>> book{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ... or with a BLOCK...
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> BLOCK(book) Book{}{
> >>>>>>>>>>>>> Document{-> ft = false, fa = false};
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"->
> >>>>>>>>>>>>>
> >>>>>>>>>>>> ft=true};
> >>>>>>>>>>> a2:Attribute{a2.name <http://a2.name>=="author",
> a2.ct=="Neil Gaiman"->
> >>>>> fa=true};
> >>>>>>>>>>>>> Document{ft,fa -> NeilsBook};
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If the order of the attributes is known, you can
> avoid the AND
> >>>>> check
> >>>>>>>>>>>> and
> >>>>>>>>>>> just specify a sequential constraint:
> >>>>>>>>>>>>> Book{-> NeilsBook}<-{
> >>>>>>>>>>>>> a1:Attribute{a1.name <http://a1.name>=="title",
> a1.ct=="Norse Mythology"}
> >>>>>>>>>>>>> # a2:Attribute{a2.name
> <http://a2.name>=="author", a2.ct=="Neil Gaiman"};
> >>>>>>>>>>>>> };
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you need to check on the complete title with the
> URL, you
> >> can
> >>>>>>>>>>>> replace
> >>>>>>>>>>> the coveredText comparison with a REGEXP condition.
> >>>>>>>>>>>>> (tested with UIMA Ruta 2.5.0)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Best,
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Peter
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Am 21.02.2017 um 13:58 schrieb Jos Vicente Moyano
> Murillo:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Hello everyone
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I'm planning to use RUTA to create some
> annotations. But i'm
> >> not
> >>>>>>>>>>>>> able to
> >>>>>>>>>>> accomplish my objective.
> >>>>>>>>>>>>>> This is my case right now:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have a text annotated with some annotations "*Book*".
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Under "*Book*" annotation i have a few annotations
> >> "*Attribute*"
> >>>>>>>>>>>>>> that
> >>>>>>>>>>>>>> stores some information about the book. Each
> "*Attribute*"
> >> has a
> >>>>>>>>>>>>> feature
> >>>>>>>>>>> "
> >>>>>>>>>>>>>> *name*" and a feature "*parent*" to its parent (one
> "*Book*"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> annotation).
> >>>>>>>>>>> And example could be a text with 2 "*Book*" annotations:
> >>>>>>>>>>>>>> "*Book*" annotation number 1 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "Norse
> >>>>>>>>>>> Mythology
> >>>>>>>>>>>>>>
> <http://www.barnesandnoble.com/w/norse-mythology-neil-
> <http://www.barnesandnoble.com/w/norse-mythology-neil->
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> gaiman/1124023596;jsessionid=FD1D8F9690602616CA59B38CFE9290
> >>>>>>>>>>>>> 06.prodny_store02-atgap08?ean=9780393609097>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> -> covered
> >>>>> text:
> >>>>>>>>>>>>> "Neil
> >>>>>>>>>>> Gaiman"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> "*Book*" annotation number 2 with 3 nested attributes
> >>>>>>>>>>>>>> 1.- *Attribute* with name feature equals "title" ->
> covered
> >>>>> text:
> >>>>>>>>>>>>> "Never
> >>>>>>>>>>> Never
> >>>>>>>>>>>>>>
> <http://www.barnesandnoble.com/w/never-never-james-patterson
> <http://www.barnesandnoble.com/w/never-never-james-patterson>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> /1123863634;
> >>>>>>>>>>>
> jsessionid=FD1D8F9690602616CA59B38CFE929006.prodny_store02-
> >>>>>>>>>>>> atgap08?ean=
> >>>>>>>>>>> 9780316433174>
> >>>>>>>>>>>>>> "
> >>>>>>>>>>>>>> 2.- *Attribute* with name feature equals "author"
> -> covered
> >>>>> text:
> >>>>>>>>>>>>> "James
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Patterson"
> >>>>>>>>>>>>>> 3.- *Attribute* with name feature equals "language" - >
> >> covered
> >>>>>>>>>>>>>> text:
> >>>>>>>>>>>>>> "English"
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I need to respect this schema but i have this question:
> >>>>>>>>>>>>>> It is possible to create and annotation over a book
> for a
> >> given
> >>>>>>>>>>>>> author
> >>>>>>>>>>> name
> >>>>>>>>>>>>>> and a given title name?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Thank's in advance
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>
>
>