Complete List of Matchers

IMatcher Javadoc / Source Code

Generic matcher interface which just implements one method called match. It gets a source and a target ontology / knowledge graph, an input alignment and additional parameters.

Keywords: I Matcher

MatcherURL Javadoc / Source Code

RawMatcher which implements the minimal interface for being executed under the SEALS platform. The only method which should be implemented is the align(URL, URL, URL) method.

Keywords: MatcherURL

MatcherString Javadoc / Source Code

Keywords: Matcher String

IMatcherCaller Javadoc / Source Code

A matcher interface which allows the matcher to call other matchers as well.

Keywords: I Matcher Caller

MatcherFile Javadoc / Source Code

For this matcher the results file that shall be written can be specified.

Keywords: Matcher File

MatcherPipelineSequential Javadoc / Source Code

Executes all matchers one after the other.

Keywords: Matcher Pipeline Sequential

MatcherCombination Javadoc / Source Code

Combines multiple matchers. This can be very inefficient because the alignment has to be serialized after each matcher. Better use a more specialized MatcherCombination like: TODO

Keywords: Matcher Combination

SealsWrapper Javadoc / Source Code

This class implements the SEALS interface (via MatcherURL) and calls the provided matcher class (the matcher class is provided via a file in the SEALS package in folder /conf/extenal/main_class.txt ). If this class is renamed or moved, then the name needs to be adjusted in matching assembly project in file SealsDescriptorHandler.java (method finalizeArchiveCreation - line 45).

Keywords: Seals Wrapper

MatcherDockerFile Javadoc / Source Code

This matcher creates a docker container based on a given docker image name. Within this container a matcher server should be started. Therefore it will use the MatcherHTTPCall internally to run the matcher. For this Matcher to work you have to add the following dependency to YOUR pom:

 
<dependency>
    <groupId>com.github.docker-java</groupId>
    <artifactId>docker-java-core</artifactId>
    <version>3.2.7</version><!--maybe update version-->
</dependency>
<dependency>
    <groupId>com.github.docker-java</groupId>
    <artifactId>docker-java-transport-httpclient5</artifactId>
    <version>3.2.7</version><!--maybe update version-->
</dependency>
 

With this in place everything should work.

Keywords: Matcher Docker File

MatcherSeals Javadoc / Source Code

This matcher wraps the SEALS client such that a SEALS zip file or folder can be executed. If multiple matcher should be instantiated, have a look at MatcherSealsBuilder buildFromFolder.

Keywords: Matcher Seals

MatcherCLI Javadoc / Source Code

Matcher for running external matchers (require the subclass to create a command to execute).

Keywords: MatcherCLI

MatcherCLIFromFile Javadoc / Source Code

Read the file “external/external_command.txt” and start an external process. The whole content of the file is used and newlines are ignored. For replacements in this string have a look at MatcherCLI#getCommand()

Keywords: MatcherCLI From File

MatcherHTTPCall Javadoc / Source Code

This class wraps a matcher service.

Keywords: MatcherHTTP Call

ReferenceMatcher Javadoc / Source Code

A matcher which tries to detect the testcase and return the reference alignment. This matcher is only for testing purposes.

Keywords: Reference Matcher

AddPositivesWithReference Javadoc / Source Code

This matcher will detect the test case given in the input and use the reference (gold standard) to sample from it with the given rate which is added to the input alignment. This matcher is contained in the eval package because it uses the information from the reference. This matcher should not be included in real matching systems.

Keywords: Add Positives With Reference

MatcherYAAA Javadoc / Source Code

A matcher template for matchers that are based on the YAAA Framework.

Keywords: MatcherYAAA

MatcherPipelineYAAA Javadoc / Source Code

A matcher template for matchers that are based on YAAA.

Keywords: Matcher PipelineYAAA

MatcherPipelineYAAAJena Javadoc / Source Code

Better use MatcherYAAAPipeline because it can combine matchers which use different APIS like Jena and OWLAPI etc

Keywords: Matcher PipelineYAAA Jena

MatcherPipelineYAAAJenaConstructor Javadoc / Source Code

Better use MatcherPipelineYAAA because it can combine matchers which use different APIS like Jena and OWLAPI etc.

Keywords: Matcher PipelineYAAA Jena Constructor

MatcherYAAAJena Javadoc / Source Code

A matcher template for matchers that are based on Apache Jena.

Keywords: MatcherYAAA Jena

AddNegativesRandomly Javadoc / Source Code

Abstract class which is the base class for all AddNegatives which are based on random sampling.

Keywords: Add Negatives Randomly

AddNegativesRandomlyOneOneAssumption Javadoc / Source Code

This component adds negative samples to the alignment. For each positive correspondences a configurable number of negative correspondences are added.

Keywords: Add Negatives Randomly One One Assumption

AddNegativesRandomlyAbsolute Javadoc / Source Code

This component adds negative samples to the alignment. The number of negative samples is defined by an absolute number.

Keywords: Add Negatives Randomly Absolute

AddNegativesViaAlignment Javadoc / Source Code

This component adds negative correspondences to the input alignment via an alignment (generated by a recall optimized matcher). This matcher is only suitable if the whole matching system is executed only for one test case. Why? Because the alignment (which is test case specific) need to be passed in the constructor. Thus it will only give useful results if only used for the correct test case.

The input alignment should contain positive correspondences. The negatives are generated by looking at the provided alignment in the constructor. All correspondences which are contained in the input alignment (ground truth) and in the given alignment (which has a high recall - meaning many correspondences) are assumned to be positives and all others correspondences which maps a concept of the positive correspondence to another concept are assumed to be negatives.

The returned alignment consists of positives (= relation) and negatives (% incompat relation) which can be used to train supervised matchers.

Keywords: Add Negatives Via Alignment

AddNegativesViaMatcher Javadoc / Source Code

This component adds negative correspondences to the input alignment via a recall optimized matcher. This also means that the input alignment should contain positive correspondences. After applying the recallMatcher given in the constructor, a new alignment is returned which contains positive (equivalence relation) and negative(incompat relation) correspondences. With the help of this alignment, supervised matchers can be trained.

Keywords: Add Negatives Via Matcher

AddNegativesRandomlyShare Javadoc / Source Code

This component adds negative samples to the alignment. Negatives are added as long as the share of negatives is not fullfilled.

Keywords: Add Negatives Randomly Share

UriInterfaceWrapper Javadoc / Source Code

This matcher implements the URL interface and wrapps a MatcherYAAA. This is useful for ParisMatcher if the input is already a NT file.

Keywords: Uri Interface Wrapper

ParisMatcher Javadoc / Source Code

This is a wrapper for PARIS matching system by Fabian Suchanek et al. The corresponding paper is called PARIS: Probabilistic Alignment of Relations, Instances, and Schema. It will download the matcher if not already done and execute it as an external process. The equivalence files of the last iteration are then read into a YAAA aligment. It is tested to run with java 1.7 and 1.8.

Keywords: Paris Matcher

MatchPropBasedOnInstances Javadoc / Source Code

Matches properties based on same subject and object and the distribution.

Keywords: Match Prop Based On Instances

MatchClassBasedOnInstances Javadoc / Source Code

A matcher which matches classes based on already instance matches.

Keywords: Match Class Based On Instances

MatchPropBasedOnClass Javadoc / Source Code

Graph-based Matcher: Checks all matched classes and matches also properties between them (domain and range) with mean value of both classes. Example:

 foo  ---already matched with c=0.5---  foo
  |                                      |
 blub  --new with c=(0.5+0.4)/2=0.45--  bla 
  |                                      |
  v                                      v
 bar  ----already matched with c=0.4--- bar

In the example blub and bla are properties.

Keywords: Match Prop Based On Class

BoundedPathMatching Javadoc / Source Code

Structure based matcher which allows to find matches in hierarchies which are between two already matched entities. Example:

 SourceSuperClass  ---already matched with c=0.8---  TargetSuperClass
  ^                                                         ^
  |                                                         |
rdfs:subClassOf                                         rdfs:subClassOf
  |                                                         |   SourceIntermediateClass  --new with c=(0.8+0.9)/2=0.85-- TargetIntermediateClass 
  ^                                                         ^
  |                                                         |
rdfs:subClassOf                                         rdfs:subClassOf
  |                                                         |
 SourceSubclass  ----already matched with c=0.9---    TargetSubclass

Per default it only matches the class hierarchy but it can be customized for further hierarchies like properties via the configurations object within this class.

Keywords: Bounded Path Matching

MachineLearningWEKAFilter Javadoc / Source Code

Non functional code.

Keywords: Machine LearningWEKA Filter

AlignmentSaveMatcher Javadoc / Source Code

Just saves the ontologies in a specific format.

Keywords: Alignment Save Matcher

NoOpMatcher Javadoc / Source Code

Matcher which does nothing but returning a valid empty alignment.

Keywords: No Op Matcher

AddAlignmentExtensions Javadoc / Source Code

Adds the provided extensions to the alignment when the matcher is executed.

Keywords: Add Alignment Extensions

AdditionalConfidenceByFunction Javadoc / Source Code

Adds an additional confidence by a user chosen function which gets a ontResource and has to return a double. The value will be computed for source and target. If you want to add confidences for a correspondence then implement your own matcher and iterate over the alignment.

Keywords: Additional Confidence By Function

ForwardAlwaysMatcher Javadoc / Source Code

This is a simple matcher that forwards a given alignment always (even if the input alignment is available). In case the input alignment should be used when availabel, use ForwardMatcher .

Keywords: Forward Always Matcher

AddAlignmentMatcher Javadoc / Source Code

This is a simple matcher that adds a given alignment to the inputAlignment. The given alignemnt has advantage.

Keywords: Add Alignment Matcher

ForwardMatcher Javadoc / Source Code

This is a simple matcher that forwards a given alignment if the input alignment is not available. In case you want to always use the given alignemnt even if the input alignment is available, then use ForwardAlwaysMatcher.

Keywords: Forward Matcher

TrainingAlignmentGenerator Javadoc / Source Code

This matcher assumes that the input alignment is a kind of reference alignment. After applying the recallMatcher given in the constructor, a new alignment is returned which contains positive (equivalence relation) and negative(incompat relation) correspondences. With the help of this alignment, supervised matchers can be trained.

Keywords: Training Alignment Generator

FileSaveMatcher Javadoc / Source Code

Just saves the ontologies in a specific format.

Keywords: File Save Matcher

BackgroundMatcherStandAlone Javadoc / Source Code

Matcher which applies String matching and matches then with the provided background knowledge source and strategy.

Keywords: Background Matcher Stand Alone

BackgroundMatcher Javadoc / Source Code

Template matcher where the background knowledge and the exploitation strategy (represented as ImplementedBackgroundMatchingStrategies) can be plugged-in. This matcher can be used as matching component. It is sensible to use a simple string matcher before running this matcher to increase the performance by filtering out simple matches. If you want a pre-packaged stand-alone background-based matching system, you can try out BackgroundMatcherStandAlone.
This matcher relies on a similarity metric that is implemented within the background source and used in BackgroundMatcher#compare(String, String).

Keywords: Background Matcher

SimpleStringMatcher Javadoc / Source Code

A relatively simple matcher that can be used before running BackgroundMatcher to filter out simple matches.

Keywords: Simple String Matcher

StopwordExtraction Javadoc / Source Code

Extracts corpus dependent stopwords from instances, classes and properties.

Keywords: Stopword Extraction

BaselineStringMatcher Javadoc / Source Code

A very basic string matcher that can be used as baseline for matchers.

Keywords: Baseline String Matcher

StringMatcher Javadoc / Source Code

Keywords: String Matcher

SynonymTextMatcher Javadoc / Source Code

Matches resource A (source) to B (target) iff they have at least one label in the same synset. The text used for the resources can be defined (e.g. rdfs:label etc). The processing can also be adjusted by subclassing this class and override method processString.

Keywords: Synonym Text Matcher

HighPrecisionMatcher Javadoc / Source Code

A high precision matcher which focuses on URI fragment and label (only element based string comparison). It achives the following scores:

Track	PREC	REC	F1
anatomy	0.9905	0.6174	0.7607
conference (micro)	0.8046	0.4590	0.5845
largebio	0.9911	0.4233	0.5932

Keywords: High Precision Matcher

ExactStringMatcher Javadoc / Source Code

Matcher which creates correspondences based on exact string match.

Keywords: Exact String Matcher

ScalableStringProcessingMatcher Javadoc / Source Code

Matcher which uses different String Matching approaches (stored in PropertySpecificStringProcessing) with a specific confidence. Multiple normalization are possible as shown below. The highest confidence is taken at the end.

 Function<String, Object> equality = (text) -> text;
 Function<String, Object> lowercase = (text) -> text.toLowerCase();
 ScalableStringProcessingMatcher matcherOne = new ScalableStringProcessingMatcher(Arrays.asList(
              new PropertySpecificStringProcessing(equality, 1.0, RDFS.label),
              new PropertySpecificStringProcessing(lowercase, 0.9, RDFS.label)
              new PropertySpecificStringProcessing(equality, 0.7, SKOS.altLabel),
              new PropertySpecificStringProcessing(lowercase, 0.6, SKOS.altLabel)
 ));

Keywords: Scalable String Processing Matcher

Doc2vecModelMatcher Javadoc / Source Code

Updates the confidence of already matched resources. It writes a textual representation of each resource to a csv file (text generation can be modified by subclassing and overriding getResourceText method).

Keywords: Doc2vec Model Matcher

DocumentSimilarityBase Javadoc / Source Code

A base class for all matchers which write a csv file where every line represents a resource with with cell as identifier like URI and second cell the corresponding tokens (whitespace separated).

Keywords: Document Similarity Base

VectorSpaceModelMatcher Javadoc / Source Code

Updates the confidence of already matched resources. It writes a textual representation of each resource to a csv file (text generation can be modified by subclassing and overriding getResourceText method).

Keywords: Vector Space Model Matcher

SentenceTransformersMatcher Javadoc / Source Code

This matcher uses the Sentence Transformers library to build an embedding space for each resource given a textual representation of it. Thus this matcher does not filter anything but generates matching candidates based on the text.

Keywords: Sentence Transformers Matcher

SentenceTransformersFineTuner Javadoc / Source Code

This matcher uses the Sentence Transformers library to build an embedding space for each resource given a textual representation of it. Thus this matcher does not filter anything but generates matching candidates based on the text.

Keywords: Sentence Transformers Fine Tuner

TransformersBaseFineTuner Javadoc / Source Code

This is a base class for all Transformers fine tuners. It just contains some variables and getter and setters.

Keywords: Transformers Base Fine Tuner

TransformersBase Javadoc / Source Code

This is a base class for all Transformers. It just contains some variables and getter and setters.

Keywords: Transformers Base

OpenEAMatcher Javadoc / Source Code

This matching module uses the OpenEA library to match entities. It uses all correspondences which are provided through either the constructor or match method(inputalignment) with equivalence relation to train the approach. It only need positive correspondences and samples negative correspondences on its own.
If you apply your own configuration you can use the parameters from openEA and also the following additional parameters:

• predict_top_k - the number of matching entities which should at least retrived for one single entity
• predict_min_sim_value - the similarity measure which should be applied for every correspondence. All sim values are greater than the given one (not equal or greater).

Keywords: OpenEA Matcher

MatcherYAAA Javadoc / Source Code

A matcher template for matchers that are based on the YAAA Framework.

Keywords: MatcherYAAA

MatcherPipelineYAAAOwlApi Javadoc / Source Code

Better use MatcherYAAAPipeline because it can combine matchers which use different APIs like Jena and OWLAPI etc.

Keywords: Matcher PipelineYAAA Owl Api

MatcherYAAAOwlApi Javadoc / Source Code

Keywords: MatcherYAAA Owl Api

---

_{automatically generated on 2024-03-08 20:57}