Information Technology Reference
In-Depth Information
(S2)
SalesOrderCRMItemSimpleByIDQueryResponse In
M
S
2
=
q
0
Φ
(
Sales Order
)
q
4
,q
4
Φ
(
Query Response
)
q
6
,q
6
Φ
(
In
)
q
1
,q
1
ε
{
−−−−−−−−−→
→
−−−−−−−−−−−→
−−−→
q
7
}
4 Automated Annotation Solution
In this section, we briefly describe the construction of automata and an accepting
algorithm used to detect concepts for the service annotation.
4.1 Automaton Construction
Automata, as defined in the previous section (cf. Def. 3), are generated from
a set of rules that represent naming conventions. As referred to in Section 2.1,
these rules consist of the following two parts. Firstly, there are non-terminal and
terminal elements, e.g.,
<BO>
and
SalesOrder
respectively, representing condi-
tions for automata transitions as shown in (N1) - (N3) in Section 2.1. Each rule
is transformed into a regular expression, which is abstractly defined using termi-
nological terms
t
T
,e.g.
/<BO>/
. Subsequently we replace the terminological
concepts with the respective set of factual concepts
f
∈
F
from the knowledge
base - for instance
/<BO>/
→
/(SalesOrder|PurchaseOrder|...)/
.
Secondly, concatenation instructions define the automaton's structure as
shown in (B1) in Section 2.1. These instructions specify the actual states. For
each of these states, we assign potential input transitions, from the just created
transition set, that need to be satisfied to enter this state. Furthermore, these
rules define the states that are subsequently reachable.
Based on these constructed automata, Enterprise Service signatures are re-
ceived as input to start the annotation procedure as described hereinafter.
∈
4.2 Annotation Procedure
The actual annotation of Enterprise Services is realized by Algorithm 1, which
accepts Enterprise Service signatures by detecting used concept. This accept-
ing algorithm works recursively, starting with state
q
0
. Each state checks its
incoming state transition, i.e. compares its own regular expression against the
input provided. If the input transition is satisfied (line 1), i.e. a valid concept was
found, the matched part is stored (line 2) and removed from the beginning of the
input and passed on to its subsequent states (line 5). In case of an empty-word
transition, obviously the same input is passed on to its subsequent states. When
the base case has been reached in form of an accepting state (line 3), it returns
its matched concept to its predecessors (line 13). For each of its preceding states,
a set of matched concepts, i.e. their own plus previously matched concepts (line
10), is returned to their predecessors and so forth. The choice on what match
results are returned depends on the quality of matched concepts. Therefore, the
result with the largest number of different concepts covering most of the input is
chosen (line 6 and 7). Eventually, the recursive algorithm terminates, detecting
a maximum number of concepts used to annotate Enterprise Services.
We implemented this algorithm in Java with roughly 2000 lines of code.
The knowledge base and generated annotations are stored as RDF triples. The
