Nature Inspired Reasoning Applied in Semantic Web

Nature Inspired Reasoning Applied in Semantic
Web

Gabriel Rizuc and Elena B˘d˘r˘u
a aa

”Al. I. Cuza” University, Department of Computer Science,
Iasi 740083, Romania
{gabriel.rizuc,elena.badarau}@info.uaic.com

Abstract. The advent of the semantic web has once again brought into
attention a variety of older problems - data extraction from unformat-
ted text, data extraction from and labeling of multimedia resources - and
has also generated further problems of similar complexity: ontology align-
ment, matching online users with similar interests, assigning credibility
to users, etc. Past experience has shown us that methods of reasoning
inspired from nature - such as neural networks and genetic algorithms -
have been the most effective ways of dealing with such complex tasks.
In this article we analyze some of the ways in which these methods are
used in order to deal with issues related to the semantic web

Key words: neural networks, genetic algorithms, nature inspired rea-
soning, semantic web, ontology alignment

1 Introduction

People have always taken inspiration from nature’s way of getting things done:
engineering, medicine and architecture are only a few of the domains that come
to mind when thinking of nature’s influence in science. Computer science is no
stranger to this; it has several computation models inspired from natural phe-
nomena to show. The first to be considered and the most used up to date are
cellular automata, neural computation (emerged from the comparison between
the human nervous system and computing machines) and evolutionary com-
putation (inspired by the ”survival of the fittest” phenomenon in Darwinian
evolution), but some of the newer models are worth mentioning too: swarm in-
telligence (inspired by the behaviour of individual agents that comunicate and
work toward a common goal found, for example, in ant colonies), artificial im-
mune systems (based on the defining principles of natural immune systems of
biological organisms), membrane computing and amorphous computing.
Just as their counterparts in real life natural computing models demonstrated
high adaptability, scalability and the ability to discover hidden patterns and so-
lution value / computation time maximization. Due to these properties, nature
inspired algorithms have been succesful in domains ranging from numeric opti-
mization to machine learning and intelligent systems.

2 Nature Inspired Reasoning Applied in Semantic Web

One way to classify computer files is documents, which are intended for hu-
man readability, versus data, which is intended for application readability: e.g.
there exists some application that is able to read the format and extract mean-
ingfull information from it, which it can eventually present to the user. The
World Wide Web’s most resources are still documents and the Semantic Web
technologies ar meant to transform them into data, which promises to be a very
difficult, complex and time consuming task.
From the main problems the Semantic Web is confronted with we mention
data extraction, resource tagging, ontology development, populating and align-
ment. Common characteristics of these problems are the very large information
that needs to be processed and the fact that they do not generally require the
best solution, a ”good enough” one beeing usually acceptable if the running time
is significantly reduced compared to the classical algorithms. This makes nature
inspired reasoning a suitable choice of algorithms.
The rest of the paper is structured as follows: Section 2 describes the concepts
befind the most commonly used nature inspired methods, from the algorithm’s
point of view and Section 3 presents a few applications of these methods in
the Semantic Web context, together with a brief presentation of the problem it
resolves.

2 Nature Inspired Reasoning

2.1 Neural Networks

Artificial neural networks[1] (often simply called neural networks) are computa-
tional structures inspired by their biological counterparts. Despite having drawn
some heavy criticism and sparking numerous debates over their computational
power and their efficiency on present day computers, neural networks have been
successfully used in solving a variety of highly complex tasks such as driving a
car, preventing credit card fraud, natural language processing, recognition of vi-
sual features (such as face recognition and optical character recognition), speech
recognition and others.
Artificial neural networks consist of a number of interconnected nodes called
artificial neurons. Each such node has a number of inputs on which it performs
some simple mathematical function, producing an output. The output of any
artificial neuron may be connected to any number of inputs from other neurons
in the network, thus producing a complex computational structure. The topology
of this structure – the exact way in which the artificial neurons are interconnected
– is an important factor in determining the behavior of the neural network.
n
Each node will typically compute the weighted sum xi wi of its inputs,
i=0
and then apply an unary function (also called an activation function) to the
result, producing the output value. The behavior of a node may be altered by
modifying the weights wi . One of the most basic types of artificial neuron is called
a perceptron and has the activation function σ(x) = if x > 0 then 1 else 0, also

Nature Inspired Reasoning Applied in Semantic Web 3

called a threshold function. The perceptron is a linear classifier: it divides the
input space into two linearly separated classes. For purposes of training, however,
it is more convenient to use an artificial neuron with a continuous activation
function. For this reason, the most often used type of artificial neuron is the
1
sigmoid unit with the activation function σ(x) = 1+e− x , which approximates
the threshold function while maintaining continuity.
Artificial neurons can be assembled into networks of varying topology. The
simplest type of neural network is the feed-forward network. In this type of
neural network, nodes are organized into layers. The first layer, which receives
its input from an external source, is also called the input layer. The last layer,
the output of which is read by an external source is also called the output layer.
Between these layers, there are a number of hidden layers – typically only one.
The outputs of nodes from one layer are connected to the inputs of nodes on the
following layer; there are no other types of connections, such as between nodes
on non-consecutive layers or between the output of one node and the input of
another node on the previous layer. It has been shown that multi-layer feed-
forward artificial neural networks are capable of approximating any measurable
function to any desired degree of accuracy.
In order for a neural network to be useful, it must first be trained to perform a
certain task – compute a function, classify data, etc. Learning may be supervised
or unsupervised and is accomplished by systematically changing the values of the
input weights for each node, such that the behavior of the network more closely
matches the intended result. Supervised learning requires a priori knowledge of
a number of correct input-output pairs. The network is initialized with random
values, and used to evaluate known input sets. After the evaluation of an input
set, the output of the neural network is compared against the intended output,
and input weights throughout the network are adjusted accordingly. In unsuper-
vised learning, the intended output is unknown and a measure of the quality of
the actual output must be used instead in order to determine what adjustments
need to be made to the network’s weights. This is often less efficient, but requires
no a priori knowledge of the intended output, therefore having wider applicabil-
ity. It is worth noting that training a neural network beyond an arbitrary point
will lead to a phenomenon called overtraining or overfitting. Said arbitrary point
is the point at which further training the neural network will lead to performance
gains over the training set, but to a loss of performance for inputs that were not
part of the training set. In order to avoid overtraining the neural network, it is
necessary to also have a second set of data which is not used for training but is
instead used for testing the real performance of the neural network. If the error
rate for the test set starts to steadily increase, then overtraining has occurred
and the training process should stop.
Another noteworthy aspect with regards to the training of neural networks
is the fact that the training process can be very time-consuming. Aside from
that, it is also hard to guess the optimal configuration for a neural network
attempting to solve a specific problem, and often experimentation is required in
order to obtain both a good network configuration and good training parameters


for the neural network, such that training the network will yield optimal or near-
optimal results. However, once a network has been trained in solving a specific
task, processing one input set is computationally inexpensive.
Another type of neural network is the self-organizing map, also known as the
Kohonen network [2]. This type of neural network facilitates the visualization of
high-dimensional data, and also has applications in fields such as speech recogni-
tion. A self-organizing map is comprised of a number of artificial neurons with n
weighted inputs, where n is the dimensionality of the input data. These neurons
are part of a graph, and each neuron is characterized by the distance between
itself an every other neuron in the graph. Usually, the graph can be seen as a
one-, two- or three-dimensional grid. During the training of a Kohonen network,
each input is assigned to the node with the highest output value for that input
– the winning node. The weights of all nodes in the network are then adjusted
so that their output will be higher for that particular input, but the magnitude
of the adjustment is lower for nodes that are farther away in the graph from the
winning node. The desired end result is a graph shaped such that it captures
the essential characteristics of the input.
For example, let us assume that we are trying to intuitively visualize a data
set comprised of a number of n-dimensional vectors. We cannot directly display
n-dimensional data, so we will use a Kohonen network to map the n-dimensional
vectors into discrete 2D space: the graph of the Kohonen network is a 2D grid,
and each node is assigned the corresponding coordinates on a grid on the visu-
alization surface (computer screen, bitmap, etc); we then assign to each input
vector the visualization surface coordinates of the neuron that has the highest
output for said input. Let us assume that the input vectors are distributed uni-
formly across a rectangular region of an n-dimensional plane. The ideal result of
training a 2D Kohonen network would be to obtain a grid spread evenly along
the surface of the n-dimensional rectangle. Assuming that a subset of the data
consists of points belonging to a circle contained within the n-dimensional rect-
angle, the given subset would be mapped to a circle in discrete 2D space. We
would get similar results for a straight line or any other geometrical shape con-
tained within the given n-dimensional rectangle. The visualization is therefore
indeed intuitive. Similar results would be obtained in the ideal case for any other
distribution of points in the input space, as long as this distribution allows for
any possible view that is intuitive.

2.2 Genetic Algorithms
Genetic algorithms [3] are another example of nature-inspired reasoning. In na-
ture, complex life forms evolved from basic ones by means such as natural selec-
tion and randomly occurring mutations. Natural selection means that the best of
each species would be more likely to survive and mate, giving birth to offspring
that borrow genetic traits of both parents, while randomly occurring mutations
ensure that there is always progress, since the gene pool does not continually
shrink. These processes in a simplified form have been modeled and used in
computer science under the name of genetic algorithms.


Genetic algorithms have a few common traits. Firstly, a solution to the prob-
lem they are trying to solve is represented genetically through chromosomes.
Traditionally, a chromosome is a binary string, but any other encoding is pos-
sible – for example, a string of floating point numbers. The genetic algorithm
starts by generating a population of such chromosomes. This population then
goes through a series of transformations that seek to create ever-better indi-
viduals. The quality of each individual is assessed using a fitness function –
a function that takes as input a chromosome and outputs a real value that is
proportional to the quality of the given individual.
The population is transformed by means of a series of functions called ge-
netic operators. The genetic operators are typically a unary function called the
mutation operator, which randomly alters a small part of an individual’s genetic
code and a binary function called the crossover operator which takes as input
two distinct individuals and recombines their genetic code producing a new indi-
vidual that inherits characteristics of both parents. The precise implementation
of each operator is dependent on the problem being solved, with some operators
yielding better results than others.
Aside from the genetic operators, a genetic algorithm is also characterized by
a selection function, that determines which individuals will contribute their genes
to the next generation of the population. There are many selection schemes, but
the one principle they all have in common is that the genes of individuals with
a higher fitness sould be more likely to contribute in the next generation.
Segregative genetic algorithms are a variation on classical genetic algorithms.
In segregative genetic algorithms, there are several populations, each grouping
individuals with similar characteristics, and each evolving separately. Individuals
are occasionally exchanged between such populations as their characteristics
change, making them more suitable for one population or another.


3.1 Natural Language Processing

Natural language processing (NLP) has been an issue long before the advent of
the semantic web. However, NLP is an important part of many issues related
to the semantic web. For example, finding equivalent classes when aligning on-
tologies may rely greatly on the meaning of the names of the classes from each
ontology; the extraction of data from unstructured text – necessary if we want
to express the textual information contained by a web page in the form of RDF
triplets – also requires proper understanding of the facts expressed in the given
text, etc.
There are however, several known issues with natural language that make
computer processing of natural language text a difficult task. The same atom
may have several meanings, several syntactic values, and the task of determin-
ing what part of speech a word represents is often non-trivial. There is also the
issue of what we consider an atom. Usually, an atom would be a word. However,


some composite words (especially in some languages such as German) may have
to be treated as a group of atoms, while some groups of words may sometimes
form a single part of speech and should be treated as a single atom; idioms
raise a similar issue. The bottom line is that most fragments of text have a
meaning that can only be determined from context, and algorithms needed to
determine the precise meaning of such fragments of text are difficult or impos-
sible to formulate. Lacking such algorithms, the best solution is often to resort
to approximations, and such approximations can be conveniently provided by
nature inspired concepts, such as neural networks.
[4] describes a method for tagging words contained in a text with their part
of speech, and compares this method with the best available algorithms, showing
that it is as efficient as the best known algorithms for part-of-speech tagging. This
method is based on a neural network that has one output for each part-of-speech
tag that may be assigned to a word; the output with the highest value is used to
determine what tag the word should receive. There are (p + f + 1) ∗ n inputs for
the neural network. Of these, for the current word, each of b previous words, and
f following words there are n inputs corresponding to the n output tags. Each
input for a given word is set with the a priori probability that the word should be
tagged with the respective part-of-speech tag. A lexicon containing precomputed
data is used to determine, without regard to context, the probability that each
word has of being each part of speech, and this data is then fed to the neural
network to produce the final tag for each word. The accuracy for this method
has been shown to be 96.22% after training the neural network for 4 million
cycles and on 2 million words, with p = 3, f = 2.
[5] covers the issue of automatic word sense discrimination: the problem of
telling whether two occurrences of the same word have the same meaning. This
is potentially useful in tasks such as ontology alignment. The proposed algorithm
for this task is named context group discrimination, and uses a clustering method
to group together context vectors for the occurrences of an ambiguous word.
These context vectors are built based on second order co-occurrence. First order
co-occurrence is based on the context in which the ambiguous word appears;
second order co-occurrence is based on the words that appear in the context
of those words that co-occur with the ambiguous word. The vectors used to
represent context are generated using a number of the most frequent words in
the training data as base vectors; the number of occurrences of these frequent
words in the context of each word gives its coordinates.
Yet another proposed application of neural networks in the context of the
semantic web is the semantic routing of text messages[6]. For example, the clas-
sification of a book based on its title can be achieved using a recursive neural
network. A representation of each word in the title is fed as input to the neural
network, and passed through a hidden layer, then stored in a context layer. The
context layer is also used as input to the hidden layer, which in turn also outputs
its results to the output layer. After each word in the title is fed as input to the
network, the highest output value determines the tag that the document should
receive – Art, Computer Science, Theology, etc.


3.2 Semantic Annotations of Resources

The declared purpose of the semantic web is to make the huge amounts of data
available online, whether it is text, image or multimedia, machine readable and
understandable so that applications could take on more of the tedious work
of searching, combining, sharing and comparing of knowledge. With this goal in
mind, various resources are semantically annotated in a way that make machines
capable to extract the relevant information. This annotation is done either man-
ually, based on the expert user’s input, or in an automated fashion, based on
the previous annotations (previous knowledge) and on the relations between the
resource to be annotated and the ones who are already semantically enhanced.
While automated text annotating works by exploiting various NLP tech-
niques, images have to be decomposed in some smaller units, pretty much the
same way a longer text is decomposed into words. This process, called image
segmentation, decomposes the image into objects (regions of contiguous pixels
similar with respect to some properties -color, intensity, texture etc; adjiacent
regions differ greatly with respect to the same property). A distance measure
between segment sets is also necessary - there must be a method to compute a
level of similarity between two images as close as possible to the level of sim-
ilarity a human observer would perceive. Then the identified objects are to be
tagged with relevant info, based on some a-priori knowledge.
In [7] such an automated image annotation system is presented. It uses on-
tologies as the source for the a-priory knowledge. It does not define a proper
distance function between segments, using instead the knowledge of spacial re-
lations(such as above, right, below-left) possible between concepts of the domain
(this info is requiered to be present in the known ontologies). After the image
has been decomposed in objects, fuzzy spacial relations between every pair is
computed and this information is fed to a genetic algorithm, together with a
number of random candidate taggings.
[8] deals with semantic annotations of multimedia content. Segments ex-
tracted from the video content are naturally involved in spacial relationships
(the view is different from [7]: the spacial operators used in the described sys-
tem are adjacency, inclusion and below ) but the temporal aspect must also be
taken into consideration (such as the moving of camera or of the object, which
could lead to it changing location, shape, size or some other characteristicc).
The authors chose a prototypical aproach to describing domain concepts, which
means they manually annotate some of the most descriptive segments of video
content with the coresponding concepts. These segments will become prototypes
of the given concepts. Multiple prototypes are allowed to cover for the diver-
sity in shape, location, color etc. possible in the instances of those concepts. A
neural network is then trained with the prototypes, thus becoming the system’s
distance function between the segments to be tagged and the prototypes. As in
[7], a genetic algorithm is used the explore the space of hypotheses.
The use of genetic algorithms in the before mentioned papers is justified by
the need to find the optimal solution in a very large search space and, since


genetic algorithms are very scalable, given that suitable encodings, crossover
and mutation operations are used.

3.3 Ontology Enrichment

The Semantic Web vision requires complete and corect ontologies for every do-
main, but developing ontologies are still a complex task that demands a high
level of human supervision and guidance. Such an aproach is obviously time
consuming; an automated unsupervised process would significantly reduce the
amount of work a human expert needs to do.
When one talks about ontology enrichment, it is assumed that there is some
backbone hierarchy of concepts, properties and relationships. That is: the most
important concepts of the considered domain are already defined (by human
experts) and all that is left to do is to mine the domain text corpus for other
concepts and insert them in the hierarchy.
The former action is to be taken by employing the appropriate NLP tech-
niques (such as determining noun phrases), while the later can be achieved, as
shown in [9], by using an enhanced form of self organizing maps. The SOM’s
descriptive power is increased by allowing the network to grow, adding a hierar-
chical dimension and allowing it to start with an initial tree-like structure. This
enhancements intuitively allow the SOM to fill any given space, without the
nodes being too distanced from each other (which would translate as insufficient
discreminating power) and also to discover eventual hierarchical structures of
the search space.
The Growing Hierarchical Self Organizing Maps (GHSOM) used in [9] consist
in a set of SOMs (specifically bidimensional grids) organized as nodes in a hier-
archy. The training algorithm must take into account the newly added features,
but it still is a natural derivation of the basic SOM training idea:

– the horizontal growth takes place by adding one row and/or column to the
SOM which contains de best node; the growth takes place only as long as the
average data deviation in the said SOM stays above some given threshold
– the vertical growth takes place by adding one node as a successor of the
current node, but only if the data deviation for the best node is above some
other threshold

The GHSOM is initialized with a hierarchy mirroring the one in the tax-
onomy, and concepts are mapped to some nodes in the corresponding SOM by
initializing the node’s weights with the vector description of the concept; all
other unmapped nodes are initilized randomly. Finnaly, a top down approach
of the training is used, growing the tree as necessary. In the end, each candi-
date concept extracted from the domain corpus is maped to a specific node in
the GHSOM, and the taxonomy can be improved by mapping parent-successor
relationship in the GHSOM to a is-a relationship in the ontology.


3.4 Ontology Alignment
Ontologies aim to formally represent some particular part of the world, the con-
cepts, their properties and the relationships that one can identify in the specified
domain. Altough the reality is the same for everyone, different organizations and
individuals can have very different view points regardind the same subject.It
comes as no surprise then that there are domains modeled in various ways by
several ontologies, which could speak enterily different languages in terms of
naming convencions, abstraction level or properties considered relevant. Such
ontologies would obviously not understand each other. Ontology matching is
thus fundamental to the exchange of knowledge: organizations would be able to
model their information without adhering to a standard, which might be difficult
to agree upon or might not satisfy the specific needs of the participants.
An ontology matching (or alignment) consists of a set of mappings between
entities belonging to the two ontologies taken into consideration, together with
a numeric value that represents the probability that the two entities are sim-
ilar. Different matchers have different ideas about what ”similar” means, and
they can exploit information from many sources, ranging from ontology charac-
teristics (such as concept names, property data types or concept relationships)
and characteristics of data instances to external knowledge (such as relevant
ontologies, dictionaries or thesauri).
Due to the very high level of heterogenity and ambiguity of data there is no
single matcher that performs best in every possible situation, thus arising the
need for composite matchers. These combine the similarity values returned by
a number of different matchers into a single value by means of an aggregation
function. One function commonly used is the weighted similarity measure which
assigns a real value between 0 and 1 to every matching algorithm, according to
its relevance, which leads to a difficult optimization problem because the search
space is a continuous real interval that houses an infinite number of solution
candidates.
While manual adjustment of the weights by an expert is still an option,
algorithms for automatically adjusting the said weights in search of the optimal
value have started to emerge. They have the advantage of being automated but
they need some a-priori knowledge to correctly optimize the weights. The so
called meta matchers employ mostly one of two techniques:
– Heuristic based alghorithms (greedy algorithms, genetic algorithms)
– Machine Learning based algorithms (relevance feedback, neural networks)
Several papers have discussed meta matchers based on nature inspired rea-
soning.
[10], [11] describe an elitist genetic algorithm which works under the paradigm
of a single goal programming strategy. Genetics for ontology alignments (GOAL)
aims to optimize a given combination of matching algorithms, using the knowl-
edge from cases previously solved by experts. The authors mantain that GOAL
is designed for scalability in the sense that any number of matchers can be com-
bined to get the final similarity value: if any of the matchers would get a weight


close to 0, it would mean that it is irelevant; if, on the contrary, the weight
would be close to 1, we could say that it is the most important similarity mea-
sure. Regarding the fitness function, it can be chosen to optimize any of the four
performance measures for ontology alignments:

– maximizing the precision
– maximizing the recall
– maximizing the fmeasure
– minimizing the number of false positives (fallout)

These parameters are concepts used in Information Retrieval for measuring
the quality of a retrieval task. In the context of ontology alignment they are
defined as:
|{relevant mappings}| |{retrieved mappings}|
precision =
|{relevant mappings}|

|{relevant mappings}| |{retrieved mappings}|
recall =
|{retrieved mappings}|
2 · precision · recall
fmeasure =
precision + recall
|{non relevant mappings}| |{retrieved mappings}|
fallout =
|{non relevant mappings}|
Altough GOAL is meant to optimize a single target, otpimizing the fmeasure
is equivalent to optimizing both precision and recall.
The genetic algorithm was tested on a group of previously aligned ontolo-
gies that included ontologies with diferent naming conventions, ontologies whose
labels are synonymous, ontologies whose labels are in diferent languages and a
pair between a regular ontology and another with a expanded hierarchy. The
algorithm achieved high performance (better or comparable results with those
of other popular matching tools of the time) with a surprisingly small population
(100 individuals) and few generations (only 5). The authors speculate that this
might be caused by the relatively low difficulty of the pairs of ontologies used
to verify the tool: ”Some of test cases are solved in the first generation, this is
because our application is not very difficult, maybe the problem is, but these
specific instances are not.” ([11]).
The same idea of combining different similarity measures with real-valued
weights to achieve a more accurate result appears in [12]. Instead of using any
matcher available, the authors define their own, in accordance with the view
they have about the main aspects that afect the semantics of a concept:

– the name of the concept
– the properties of the concept
– the relationships of the concept


Every aspect mentioned is represented by a similarity measure that tries to
encompass its view of the ontology. The overall similarity between concepts is
then computed as the weighted sum of these three similarity values, where the
weights are to be trained by a simple 2 layer, 3 input, 1 output neural network.
The ideea between the trainning algorithm is as follows:

– the three weights are randomly initialized
– a concept similarity matrix M for the two ontologies is computed, using the
initial weight values.
– some training examples from the two ontologies are picked; these will be
manually matched concepts
– the backpropagation algorithm is applied, minimizing a personalized error
function.
We recall that the usual error function for a neural network is
→ 2
E(w) = d∈D (td − od ) . In this case, we do not have a target value for the
similarity of the pair d, we just know it’s the best match possible for those
two concepts. When thinking in terms of the concept similarity matrix, that
means that the value in the cell coresponding to d should be greater than any
other value on the respective row and column. According to this intuition,
→ 2 2
the error function is set to E(w) = d∈D (tr − od ) + (tc − od ) , where tr
is the maximum value on the row and tc the maximum value on the column
that have d at their intersection.

Another way of using genetic algorithms in the context of ontology matching
is proposed in [13]. It proposes a simple matcher (that is a matcher that focuses
on a single aspect) that works on the problem of graph matching. Given that
matching two graphs in the general case is impossible in polynomial time, a ge-
netic algorithm is used hoping that it will provide a good enough aproximation
of the optimal alignment while keeping the running time manageable. The algo-
rithm doesn’t use a binary representation, it uses a more suitable encoding for
the problem it tries to resolve and the two crossover functions and the mutation
function are deﬁned accordingly.

References

1. Tom Mitchell: Machine Learning. McGraw Hill (1997)
2. Teuvo Kohonen: Self-organized formation of topologically correct feature maps. Bi-
ological Cybernetics 43, 59–69 (1982)
3. D.E.Goldberg: Genetic algorithms in search, optimization and machine learning,
Addison-Wesley (1989)
4. Hehnut Schmid: Part-of-Speech Tagging With Neural Networks
5. Hinrich Sch¨tze: Automatic Word Sense Discrimination
u
6. Stefan Wermter: Neural Network Agents for Learning Semantic Text Classiﬁcation
7. Panagi, P., Dasiopoulou, S., Papadopoulos, G.Th., Kompatsiarisy, I., Strintzis,
M.G.: A Genetic Algorithm Approach to Ontology-driven Semantic Image Anal-
ysis


8. Bloehdorn, S., Petridis, K., Saathoﬀ, C., Simou, N., Tzouvaras, V., Avrithis, Y.,
Handschuh, S., Kompatsiaris, Y., Staab, S., Strintzis, M.G.:Semantic Annotation of
Images and Videos for Multimedia Analysis
9. Chifu, E.S, Letia, I.A.: Text-Based Ontology Enrichment Using Hierarchical Self-
¸ ¸
organizing Maps
10. Martinez-Gil, J.,Aldana-Montes, J.F.: Evaluation of two Heuristic Approaches to
Solve the Ontology Meta-Matching Problem. Knowledge and Information Systems
(2009)
11. Martinez-Gil, J., Alba, E., Aldana-Montes, J.F.: Optimizing Ontology Alignments
by Using Genetic Algorithms. Knowledge and Information Systems (2009)
12. Huang, J., Dang, J., Vidal, J.M., Huhns, M.N.: Ontology Matching Using an Arti-
ﬁcial Neural Network to Learn Weights. In: IJCAI Workshop on Semantic Web for
Collaborative Knowledge Acquisition (2007)
13. Qazvinian, V., Abolhassani, H., Haeri (Hossein) S.H., Hariri B.B.: Evolutionary
Coincidence-based Ontology Mapping Extraction. Expert Systems

Nature Inspired Reasoning Applied in Semantic Web

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (9)

Similaire à Nature Inspired Reasoning Applied in Semantic Web

Similaire à Nature Inspired Reasoning Applied in Semantic Web (20)

Dernier

Dernier (20)

Nature Inspired Reasoning Applied in Semantic Web