Ontology and schema matching is one of the most important tasks for data integration. We suggest to combine the different matchers with machine learning approach. The features are the outputs of lexical and semantic similarity functions. Naive Bayesian classifier, logistic regression and gradient tree boosting have been trained on these features. The proposed approach is tested on the OAEI 2017 benchmark “conference” with the various splits of the data on train and test sets. Experiments show that final combined model in element-level matching outperformed the single matchers. Results are compared with EditDistance matcher and WordNet matcher.
Data integration is now a very important problem, as the amount of data is growing very much. One of the most important steps in automatic data integration is the comparison of ontologies or schemas. This problem is traditionally solved manually or semi-automatically. Manual ontology or schema matching is very laborintensive, long in time and prone to errors. Therefore now the task is to maximally automate the process of comparing the circuit with the greatest accuracy.
For schema matching and ontology matching element-level and structure-level matchers are used. Element-level matchers use information of elements of schema (name of columns, description). Structure-level matchers use information of structure (type similarity, key properties, hierarchy of elements).
Recently, element-level matchers have been widely used lexical and semantic information. For getting semantic information WordNet and Word2vec are used. Word2vec allow us to get a meaning of the word and we can use this for improving ontology and schema matching. So we can combine many lexical and semantic information into one similarity matrix and train a machine learning model for trying to solve ontology and schema matching problems.
This work is performed as Master thesis. The main goal of this work is to propose a approach for solving ontology and schema matching problem with the greatest accuracy. To achieve this goal we need to perform the following tasks: review related work, create the architecture of solution, select of information for matching and create experiments. We compared our approach on OAEI 2017 “conference” ontologies with single matchers: edit distance and WordNet.
In Section 2 we reviewed related work and it's evolution. Section 3 describes the setup of the paper. In Section 4 presents our matching algorithm in detail. Section 5 shows the experiments and the analysis. We conclude this paper in Section 6.
Schema matching and ontology matching are very
similar. In this article, there is no difference for schema
matching and ontology matching because we only work
with the names of the entities. So we considered the
works about schema matching and ontology matching
together. In [
In [2] the ready-made solutions for automatic schema
matching are compared and the concept of pre-match
effort and post-match effort introduced. Pre-match effort
is learning of the matcher, configuration of thresholds
and weights. Post-match effort is correction and
improvement of the match output. In the same year, in
[3] the authors described their COMA system. The
authors introduced new methods of post-match effort:
reuse of matchings, aggregation of individual matchers.
In [4] the Target-based Integration Query System (TIQS)
are described. In [5] a new classification on matching
dimensions are presented. A natural issue is uncertainty,
In [
In [
In [
In [
In [
In [
In [
In [
In [
At the moment, the most promising option is the using of machine learning to create a hybrid model with lexical, semantic and structure information. In this article, we want to connect many different single matchers to one hybrid matcher using machine learning. One of the newest features we used is Word2vec. So far we only used the single element-level matchers.
All reviewed papers use widely the lexical information and WordNet distances. In this paper we used 29 similarity metrics from 17 various single element-level matchers.
An ontology O is by a 3-tuple (C, P, I). C is the classes, denoting the concepts. P is the relations within the ontology. I is the instances of classes. The task of ontology matching is to find the alignment between entities in a source ontology 1 and a target ontology 2.
An alignment is a set {( 1, 2, )| 1 ∈ 1, 2 ∈ 2}, where 1 is an entity in 1, 2 is an entity in 2, and is the confidence of the correspondence.
Our algorithm works only with names of entities without the structure information. The input of our algorithm is the two ontologies: source and target. The output of our algorithm is the alignment.
The effectiveness of ontology matching could measured by precision, recall and F-measure. = |∩| | |, (1)
= |∩| | |, (2) − = 2⋅ ⋅ , (3) + where A is a predict alignment and B is a true alignment.
As features for machine learning we used the similarity measures. We extract from ontology the names of entities. Further we need to create sets of words from names for computing some similarity measures.
Example. We have two names of entities: “early_paid_applicant” and “early-registeredparticipant”. The sets are [“early”, “paid”, “applicant”] and [“early”, “registered”, “participant”].
Metrics based on lexical information from names of
entities:
• N-gram [
( , ) = | ( (,| |),∩| |)−+1 ( , )| (4)
Dice coefficient [
( , ) = ||∩∪ || (6)
Jaro measure [
Soundex [
Token Sort. Fuzzy Wuzzy token sort ratio raw raw_score is a measure of the strings similarity as an int in the range [0, 100]. For two strings X and Y, the score is obtained by splitting the two strings into tokens and then sorting the tokens. The score is then the fuzzy wuzzy ratio raw score of the transformed strings.
( , ) = |∩ | |∩ |+ |− |+ |− | , (11) where , > 0.
( , ) =
|∩ |
(| |,| |)
(12)
Metrics based on semantic information from names
WordNet similarity. Best score of similarity between
synonyms of one word with synonyms of other
word. We use a sentence similarity algorithm from
[
Word2vec and Sentence2vec similarity. Word2vec is a model that are used to produce word embeddings. We used word2vec model trained by the texts of Google News. The dimensionality of these vectors is
300. We used sentence2vec
algorithm from [
of entities:
The input of the matching system is the two ontologies. For each ontology the system extracts the names of the entities. Further it generate all possible pairs of the names of the ontology with the names of the other ontology. For all pairs system computes the all similarity measures. All outputs of the similarity measures are concatenated into the one similarity matrix.
The computed features are used as input to a machine learning model.
Program 1 Element-level matching algorithm Input: Ontology1, Ontology2 - input ontologies or schemas, THRESHOLD - threshold for create matching between elements Output: alignment - output alignment for Ontology1 and Ontology2 for Entity1 ∈ Ontology1 do for Entity2 ∈ Ontology2 do
Name1 ← get_name(Entity1) Name2 ← get_name(Entity2) Features ← get_features(Name1, Name2) Match ← predict_match(Features) if Match > THRESHOLD then
alignment.append((Name1,Name2)) end if end for end for return alignment Program 2 Creating dataset and training a machine learning model Input: TrueAlignments - set of true alignments, TrainAlignments - set of train pairs Output: Model - trained model for predict matching for Ontology1, Ontology2 in TrueAlignments do for Entity1 ∈ Ontology1 do for Entity2 ∈ Ontology2 do if (Entity1, Entity2) ∈ TrainAlignments then
add_to_train(Entity1, Entity2, 1) else
add_to_train(Entity1, Entity2, 0) end if end for end for end for Model.train() return Model
For training a machine learning model we need the ontologies and the alignments. We split the alignments on the training alignments and testing alignments. Further we train a machine learning model on the features from train alignments. Then we can evaluate Fmeasure on testing alignment.
The experiments were conducted at the dataset “conference” from OAEI 2017. The dataset consists 16 ontologies from the same domain (conference organisation) and 21 true ontology matchings. This dataset is convenient for machine learning because all ontologies are from the same domain and this dataset has the several true matchings between ontologies.
We get entities from ontologies with parsing code on Python and get array of tuples: (entity1, entity2, match), where entity1, entity2 - string names of entities, match bool variable, 1 means that the entities are matched, 0 means that the entities are not matched. We generated 29 similarity measures from 3.3 with Python packages: py_stringmatching24, fuzzycomp25, gensim26.
The final dataset is very unbalanced: 391 572 negative samples and 305 positive samples. After generating features we split data randomly on train and test datasets in equal proportions. In Table 1 are described our split. 24 https://github.com/kvpradap/py_stringmatching 25 https://github.com/fuzzycode/fuzzycomp 26 https://github.com/RaRe-Technologies/gensim 27 http://scikitlearn.org/stable/modules/generated/sklearn.naive_bayes
We can see on Table 2 that XGBoost is the model with best F-measure 55.01%. The worst model is Naive Bayes Classifiers with F-measure 4.15%. EditDistance is better than WordNet by 27%. For getting more stable results we splitted the datasets randomly on training and testing pairs 20 times and averaged the results. The results are show on Table 3. We can see that XGBoost are remained the best model. .GaussianNB.html 28 http://scikitlearn.org/stable/modules/generated/sklearn.linear_mode l.LogisticRegression.html 29 https://github.com/dmlc/xgboost
In this paper, we combined the lexical and semantic similarity measures into one hybrid model. The experiments show that hybrid model is better than single matchers.
In future work we want to run our solution on other benchmarks. We must add the structure-level and instance-level features because in our dataset there are examples in which the names of entities are exactly the same but they are not matched.
Acknowledgments. This work is supervised by Sergey Stupnikov, Institute of Informatics Problems, Federal Research Center “Computer Science and Control“ of the Russian Academy of Sciences”.