Incubator Project
type: Class
class template: project
creation label: Projects
subclass of: Project

AskNow
type: Incubator Project
publication tag: asknow
template option: minimal
hookline: AskNow is a Question Answering (QA) system for RDF datasets.
content: The aim of AskNow is to..
abstract: The underlying idea of the project is to convert a natural language expression to a SPARQL query, which can then retrieve the answer of a question from a given triple store.
browse: AutoSPARQL
bug-database: issues
download-page: downloads
maintainer: MohnishDubey

aksw.org
type: Incubator Project
hookline: a linked data driven web page rendered by OntoWiki site extension
related project: OntoWiki
abstract: The semantic data wiki OntoWiki can be used as a content management system to render web pages based on the RDF triples. According to 'eat you own dog food', the aksw.org web page is an example for this approach.
browse: aksw.org
bug-database: issues
maintainer: NatanaelArndt

ALOE
type: Incubator Project
hookline: Assisted Linked Data Consumption Engine
content: # Background The Linked Open Data (LOD) Cloud contains more than 31 billion triples. This wealth of knowledge is expressed by using a large number of vocabularies (e.g., FOAF, VCard, SKOS), leading to a schema mismatch between the different knowledge bases that express knowledge about the same types of entities (e.g., persons). Mismatches at instance level are similarly common, including the use of different units of measure (e.g., cm vs. inch for heights) or data types (e.g., strings instead of doubles for geographical coordinates of locations). The integration of this data is yet central for tasks such as large-scale inference, cross-ontology question answering, graph traversal and especially business applications that require all data to be available from their local servers in a particular format. # Aim The aim of the ALOE (Assisted Linked data cOnsumption Engine) project is to provide an engine for the semi-automatic generation of consumption configurations. For this purpose, ALOE can automatically discover class and property mappings across endpoints even when no schema information is available. In addition, ALOE can generate initial specifications for the consumption of Linked Data. For this purpose, it provides several functions for transforming the data from the source knowledge base into a format that corresponds to that of the target knowledge base. Therewith, ALOE enables lay and experienced users to consume Linked Data with great ease. The ALOE process can be controlled via the interface shown below. Please note that the demo only consumes 1000 triples.
screenshot: http://wiki.aksw.org/Projects/ALOE/files
abstract: The consumption of Linked Data is a task of increasing complexity on the Web of Data. This complexity is due to several factors, including the sheer size of the Web of Data, the diversity of vocabularies used to describe this data and the lack of schema information in knowledge bases. ALOE provide a semi-automatic solution to address this problem.
feed: feed
maintainer: AxelNgonga

ASSESS
type: Incubator Project
hookline: Automatic Self Assessment
publication tag: assess
programming-language: Java
content: The Linked Open Data Cloud is a goldmine for educational applications: First, it contains knowledge of encyclopedic nature on a large number of real-world entities. Moreover, the data being structured ensures that the meaning of the data can be understood by both humans and machines. Finally, the openness of the data and the use of RDF as standard format facilitate the development of applications that can be ported across different domains with ease. However, RDF is still unknown to most members of the target audience of educational applications. Thus, Linked Data has commonly been used for the description or annotation of educational data. Yet, Linked Data has (to the best of our knowledge) never been used as direct source of educational material. With ASSESS, we demonstrate that we can use Linked Data as source for the automatic generation of educational material. By using innovative RDF verbalization and entity summarization technology, we bridge between natural language and RDF. We then use RDF data directly to generate quizzes which encompass questions of different types on user-defined domains of interest. By these means, we enable learners to generate self-assessment tests on domains of interest. Teachers are supported through the automatic generation and evaluation of tests. Our evaluation shows that ASSESS scales on very large knowledge bases such as DBpedia.
abstract: The Linked Open Data Cloud is a goldmine for educational applications: First, it contains knowledge of encyclopedic nature on a large number of real-world entities. Moreover, the data being structured ensures that the meaning of the data can be understood by both humans and machines. Finally, the openness of the data and the use of RDF as standard format facilitate the development of applications that can be ported across different domains with ease. However, RDF is still unknown to most members of the target audience of educational applications. Thus, Linked Data has commonly been used for the description or annotation of educational data. Yet, Linked Data has (to the best of our knowledge) never been used as direct source of educational material. With ASSESS, we demonstrate that we can use Linked Data as source for the automatic generation of educational material. By using innovative RDF verbalization and entity summarization technology, we bridge between natural language and RDF. We then use RDF data directly to generate quizzes which encompass questions of different types on user-defined domains of interest. By these means, we enable learners to generate self-assessment tests on domains of interest. Teachers are supported through the automatic generation and evaluation of tests. Our evaluation shows that ASSESS scales on very large knowledge bases such as DBpedia.
download-page: ASSESS
maintainer: AxelNgonga
maintainer: LorenzBuehmann
maintainer: RicardoUsbeck

AgriNepalData
type: Incubator Project
hookline: Ontology Based Data Access and Integration for Improving the Effectiveness of Farming in Nepal
abstract: Different factors like geographical location, soil type, weather condition and crop information affect the productivity of agricultural crops. By integrating such information, semantic technologies plays a central role to boot up a farmers’ living standard. In Nepal, it is difficult to improve profit and agriculture related planning for farmers and decision makers respectively due to the lack of required information or relationships to other relevant data. To address this problem, semantic technology is used to integrate agricultural data from different sources. In this project, we convert and publish various farming-related datasets in Nepal.
download-page: agrinepaldump.nt
maintainer: http://aksw.org/Jenslehmann
maintainer: http://aksw.org/MohamedSherif

AskNow
type: Incubator Project
publication tag: autosparql
template option: minimal
hookline: AskNow is a Question Answering (QA) system for RDF datasets.
related project: DLLearner
content: The aim of AskNow is to..
abstract: The underlying idea of the project is to convert a natural language expression to a SPARQL query, which can then retrieve the answer of a question from a given triple store.
browse: AutoSPARQL
bug-database: issues
download-page: downloads
maintainer: JensLehmann

AutoSPARQL
type: Incubator Project
publication tag: autosparql
template option: minimal
hookline: Convert a natural language expression to a SPARQL query
related project: DLLearner
content: The aim of AutoSPARQL is to provide robust question answering over RDF data by combining methods from several research areas, such as: - natural language processing for creating sophisticated semantic representations of questions - inductive active learning for incorporating user feedback - results of the BOA project The underlying idea is to convert a natural language expression to a SPARQL query, which can then retrieve the answer of a question from a given triple store. ### Papers - [ESWC 2011 AutoSPARQL Paper](http://jens-lehmann.org/files/2011/autosparql_eswc.pdf) - [WWW 2012 TBSL Paper](http://dl.acm.org/citation.cfm?doid=2187836.2187923) - [KESW 2013 AutoSPARQL TBSL Demo Paper](http://svn.aksw.org/papers/2013/KESW_AutoSparqlTbsl_Demo/public.pdf) ### Sourcecode - [main](https://github.com/AKSW/AutoSPARQL) (is not actively maintained anymore) - machine learning algorithms in [DL-Learner](http://dl-learner.org) - natural language patterns in BOA
abstract: The underlying idea of the project is to convert a natural language expression to a SPARQL query, which can then retrieve the answer of a question from a given triple store.
browse: AutoSPARQL
bug-database: issues
download-page: downloads
maintainer: JensLehmann

BOA
type: Incubator Project
hookline: BOotstrapping linked datA
publication tag: boa
template option: minimal
programming-language: Java
related project: DeFacto
related project: LIMES
content: # General Overview Most knowledge sources on the Data Web were extracted from structured or semi-structured data. Thus, they encompass solely a small fraction of the information available on the document-oriented Web. In this paper, we present BOA, an iterative bootstrapping strategy for extracting RDF from unstructured data. The idea behind BOA is to use the Data Web as background knowledge for the extraction of natural language patterns that represent predicates found on the Data Web. These patterns are used to extract instance knowledge from natural language text. This knowledge is finally fed back into the Data Web, therewith closing the loop. We evaluate our approach on two data sets using DBpedia as background knowledge. Our results show that we can extract several thousand new facts in one iteration with very high accuracy. Moreover, we provide the first repository of natural language representations of predicates found on the Data Web. # Presentation The following presentation was held at EKAW 2012 in Galway: Extracting Multilingual Natural-Language Patterns for RDF Predicates from Daniel Gerber The following presentation was held at We~KEx at ISWC 2011 in Bonn: BOA - Bootstrapping Linked Data from Daniel Gerber # Generated Knowledge The generated knowledge can be accessed at the [BOA dydra repository][boadydra]. # Library of Natural-Language Representations of Formal Relations The results of the BOA approach can be downloaded in form of an Lucene Index. The pattern in this index were derived from applying DBpedia background knowledge on the English Wikipedia. The index was created as follows: Document doc = new Document(); doc.add(new Field("uri", mapping.getProperty().getUri(), Field.Store.YES, Field.Index.NOT_ANALYZED)); doc.add(new Field("nlr", pattern.getNaturalLanguageRepresentationWithoutVariables().trim(), Field.Store.YES, Field.Index.ANALYZED)); doc.add(new NumericField("confidence", Field.Store.YES, true).setDoubleValue(pattern.getConfidence())); w…
screenshot: http://wiki.aksw.org//Projects/BOA/files
abstract: Most knowledge sources on the Data Web were extracted from structured or semi-structured data. Thus, they encompass solely a small fraction of the information available on the document-oriented Web. BOA is an iterative bootstrapping strategy for extracting RDF from unstructured data.
feed: http://blog.aksw.org/feed/
browse: checkout
bug-database: list
download-page: list
maintainer: DanielGerber
wiki: General

CSVImport
type: Incubator Project
programming-language: php JavaScript
hookline: Representing multi-dimensional statistical data as RDF using the RDF Data Cube Vocabulary
related project: CubeViz
related project: GHO
related project: OntoWiki
content: Statistical data on the web is often published as Excel sheets. Although they have the advantage of being easily readable by humans, they cannot be queried efficiently. Also it is difficult to integrate with other datasets, which may be in different formats. Our approach is to convert the data into a single data model – RDF. But in these datasets, a single statistical value is described in several dimensions. Thus a simple row-based transformation is not possible. Therefore, we use [The RDF Data Cube vocabulary](http://publishing-statistical-data.googlecode.com/svn/trunk/specs/src/main/html/cube.html "The RDF Data Cube vocabulary") for the conversion as it is designed particularly to represent multidimensional statistical data using RDF. Transforming CSV to RDF in a fully automated way is not feasible as there may be dimensions encoded in the heading or label of a sheet. Therefore, we introduce a semi-automated approach as a plugin in [OntoWiki](http://aksw.org/Projects/OntoWiki "OntoWiki").
abstract: This project is about the representation of multi-dimensional statistical data as RDF using the RDF Data Cube vocabulary by importing spreadsheets into the OntoWiki plugin.
bug-database: https://github.com/AKSW/csvimport.ontowiki/issues
maintainer: AmrapaliZaveri
wiki: https://github.com/AKSW/csvimport.ontowiki/wiki

Analyzing Cognitive Evolution using Linked Data
type: Incubator Project
publication tag: cogevo
template option: minimal
hookline: Towards Biomedical Data Integration for Analyzing the Evolution of Cognition
abstract: Cognition is determined by the function and interplay of several hundreds, if not thousands, of genes with a considerable overlap in the disease phenotypes they can cause if mutated. We argue that, in order to understand the biological basis of cognition, these genes have to be investigated together with their evolutionary history and the diseases they are implicated in. This requires the integration of data from different research disciplines. To allow researchers to answer complicated questions related to cognition, a task that is usually very time-consuming, we propose to use Linked Data publication. Such data integration and querying methods have already been successfully used in other life science domains. In our initial effort presented here, we converted and integrated 11 different datasets and provide a first demonstration of the added value of Linked Data by showing how a set of relevant queries over the integrated data can be answered.

DBpediaDQ
type: Incubator Project
publication tag: dbpediadq
hookline: User-driven quality evaluation of DBpedia
related project: TripleCheckMate
content: As we all know, DBpedia is an important dataset in Linked Data as it is not only connected to and from numerous other datasets, but it also is relied upon for useful information. However, quality problems are inherent in DBpedia be it in terms of incorrectly extracted values or datatype problems since it contains information extracted from crowd-sourced content. However, not all the data quality problems are automatically detectable. Thus, we aim at crowd-sourcing the quality assessment of the dataset. In order to perform this assessment, we developed a tool whereby a user can evaluate a random resource by analyzing each triple individually and store the results. Here is the link to the tool: [http://nl.dbpedia.org:8080/TripleCheckMate/](http://nl.dbpedia.org:8080/TripleCheckMate/ "http://nl.dbpedia.org:8080/TripleCheckMate/"). If you have any questions or comments, please do not hesitate to contact us at dbpedia-data-quality@googlegroups.com. Results ================== - Results : [http://goo.gl/lIKK7](http://goo.gl/lIKK7 "http://goo.gl/lIKK7") - Total no. of users : 58 - Total no. of distinct resources evaluated : 521 - Total no. of resources evaluated : 792 - Total no. of distinct resources without problems : 86 - Total no. of distinct resources with problems : 435 - Total no. of distinct incorrect triples : 2928 - Total no. of distinct incorrect triples in the dbprop namespace : 1745 - Total no. of inter-evaluations : 268 - No. of resources with evaluators having different opinions : 89 - Resource-based inter-rater agreement (Cohen’s Kappa) : 0.34 - Triple-based inter-rater agreement (Cohen’s Kappa) : 0.38 - No. of triples evaluated for correctness : 700 - No. of triples evaluated to be correct : 567 - No. of triples evaluated incorrectly : 133 - % of triples correctly evaluated : 81 - Average no. of problems per resource : 5.69 - Average no. of problems per resource in the dbprop namespace : 3.45 - Average no. of triples per resource : 47.19 - % of triples affe…
abstract: With the myriad of data sets and use cases available in the LOD cloud, data quality is one of the important concepts to be considered. The DBpedia Data Quality Curation project is aimed at evaluating the quality of the resources present in DBpedia.
feed: feed
maintainer: AmrapaliZaveri

DBpediaDQCrowd
type: Incubator Project
publication tag: dbpediadqcrowd
template option: minimal
hookline: Crowdsourcing DBpedia Quality Assessment
related project: DBpedia
related project: DBpediaDQ
related project: TripleCheckMate
abstract: In this work we look into the use of crowdsourcing as a means to handle Linked Data quality problems that are challenging to be solved automatically. We analyzed the most common errors encountered in Linked Data sources and classified them according to the extent to which they are likely to be amenable to a specific crowdsourcing approach. Based on this analysis, we implemented a quality assessment methodology for Linked Data that leverage the wisdom of the crowds in different ways: (i) a contest format targeting an expert crowd of researchers and Linked Data enthusiasts; and (ii) paid microtasks published on Amazon Mechanical Turk. We empirically evaluated the the capacity of crowdsourcing approaches to spot quality issues in DBpedia and investigated how the contributions of the two crowds could be optimally integrated into Linked Data curation processes. The results showed that the two styles of crowdsourcing are complementary, and that crowdsourcing-enabled quality assessment is a promising and affordable way to enhance the quality of Linked Data sets.
feed: feed
maintainer: AmrapaliZaveri

DEER
type: Incubator Project
publication tag: deer
programming-language: Java
hookline: RDF Data Extraction and Enrichment Framework
related project: FOX
related project: GeoKnow
related project: GeoLift
related project: LIMES
content: Enrichment functions and operators. ------------------ Enrichment functions implement functionality for processing the content of a dataset (e.g., applying named entity recognition to a particular property). Thus, they take a dataset as input and return a dataset as output. Enrichment operators work at a higher level of granularity and combine datasets. Thus, they take sets of datasets as input and return sets of datasets. RDF specification paradigm ------------------ In the current version of DEER we introduce our new RDF based specification paradigm. The main idea behind this new paradigm is to enable the processing execution of specifications in an efficient way. To this end, we first decided to use RDF as language for the specification. This has the main advantage of allowing for creating specification repositories which can be queried easily with the aim of retrieving accurate specifications for the use cases at hand. Moreover, extensions of the specification language do not require a change of the specification language due to the intrinsic extensibility of ontologies. The third reason for choosing RDF as language for specifications is that we can easily check the specification for correctness by using a reasoner, as the specification ontology allows for specifying the restrictions that specifications must abide by.
abstract: Over the last years, the Linked Data principles have been used across academia and industry to publish and consume structured data. Thanks to the fourth Linked Data principle, many of the RDF datasets used within these applications contain implicit and explicit references to more data. For example, music datasets such as Jamendo include references to locations of record labels, places where artists were born or have been, etc. Datasets such as Drugbank contain references to drugs from DBpedia, were verbal description of the drugs and their usage is explicitly available. The goal of mapping component, dubbed DEER, is to retrieve this information, make it explicit and integrate it into data sources according to the specifications of the user. To this end, DEER relies on a simple yet powerful pipeline system that consists of two main components: enrichment functions and operators.
bug-database: issues
download-page: DEER
license: https://creativecommons.org/licenses/by-sa/3.0/
maintainer: MohamedSherif
type: OpenSourceProject
comment: RDF Data Extraction and Enrichment Framework

DEQA
type: Incubator Project
demonstrates: autosparql-tbsl.dl-learner.org
hookline: Deep Web Extraction for Question Answering
related project: AutoSPARQL
related project: LIMES
content: AutoSPARQL prototype user interface: [http://autosparql-tbsl.dl-learner.org](http://autosparql-tbsl.dl-learner.org "http://autosparql-tbsl.dl-learner.org") # General Approach DEQA provides a conceptual framework for enhancing classic information retrieval and search techniques using recent advances in web extraction, data integration and question answering. The overall approach is illustrated in the figure above: Given a particular domain, such as real estate, the first step consists of identifying relevant websites and extracting data from those. This previously tedious task can now be reduced to the rapid creation of [OXPath](https://github.com/diadem/OXPath "OXPath") wrappers. In DEQA, data integration is performed through a triple store using a common base ontology. Hence, the first phase may be a combination of the extraction of unstructured and structured data. For instance, websites may already expose data as RDFa, which can then be transformed to the target schema, e.g.using [R2R](http://www4.wiwiss.fu-berlin.de/bizer/r2r/ "R2R"), if necessary. This basic RDF data is enriched, e.g. via linking, schema enrichment, geo-coding or post-processing steps on the extracted data. This is particularly interesting, since the LOD cloud contains a wealth of information across different domains which allows users to formulate queries in a more natural way (e.g., using landmarks rather than postcodes or coordinates). For instance, in our analysis of the real estate domain, over 100k triples for 2,400 properties were extracted and enriched by over 100k links to the LOD cloud. Finally, question answering or semantic search systems can be deployed on top of the created knowledge. One of the most promising research areas in question answering in the past years is the conversion of natural language to SPARQL queries, which allows a direct deployment of such systems on top of a triple store. Finally, DEQA first attempts to convert a natural language query to SPARQL, yet can fall…
abstract: Despite decades of effort, intelligent object search remains elusive. Neither search engine nor semantic web technologies alone have managed to provide usable systems for simple questions such as “Find me a flat with a garden and more than two bedrooms near a supermarket.” We introduce DEQA, a conceptual framework that achieves this elusive goal through combining state-of-the-art semantic technologies with effective data extraction. To that end, we apply DEQA to the UK real estate domain and show that it can answer the majority of such questions correctly. DEQA achieves this by mapping natural language questions to SPARQL patterns. These patterns are then evaluated on an RDF database of current real estate offers. The offers are obtained using OXPATH, a state-of-the-art data extraction system, on the major agencies in the Oxford area and linked through LIMES to background knowledge such as the location of supermarkets.
maintainer: JensLehmann

Dockerizing Linked Data
type: Incubator Project
publication tag: docker
programming-language: Python
hookline: Knowledge Base Shipping to the Linked Open Data Cloud
related project: CatalogusProfessorum
related project: DBpedia
related project: Pfarrerbuch
abstract: Popular knowledge bases that provide SPARQL endpoints for the web are usually experiencing a high number of requests, which often results in low availability of their interfaces. A common approach to counter the availability issue is to run a local mirror of the knowledge base. Running a SPARQL endpoint is currently a complex task which requires a lot of effort and technical support for domain experts who just want to use the SPARQL interface. With our approach of containerised knowledge base shipping we are introducing a simple to setup methodology for running a local mirror of an RDF knowledge base and SPARQL endpoint with interchangeable exploration components. The flexibility of the presented approach further helps maintaining the publication infrastructure for dataset projects. Popular knowledge bases that provide SPARQL endpoints for the web are usually experiencing a high number of requests, which often results in low availability of their interfaces. A common approach to counter the availability issue is to run a local mirror of the knowledge base. Running a SPARQL endpoint is currently a complex task which requires a lot of effort and technical support for domain experts who just want to use the SPARQL interface. With our approach of containerised knowledge base shipping we are introducing a simple to setup methodology for running a local mirror of an RDF knowledge base and SPARQL endpoint with interchangeable exploration components. The flexibility of the presented approach further helps maintaining the publication infrastructure for dataset projects.
browse: Dockerizing
maintainer: NatanaelArndt

Linked Data Quality Survey
type: Incubator Project
publication tag: dataquality
hookline: Quality Assessment for Linked Data: A Survey
related project: DBpediaDQ
related project: DBpediaDQCrowd
abstract: The survey covers 30 core papers, which focus on providing quality assessment methodologies for Linked Data specifically. A total of 18 data quality dimensions along with their definitions and 69 metrics are provided. Additionally, the survey contributes a comparison of 12 tools, which perform quality assessment of Linked Data.
description: Linked Data Quality | Create infographics
maintainer: AmrapaliZaveri

DSSN
type: Incubator Project
publication tag: seebiproject_FederatedSocialWeb
hookline: towards a global Distributed Semantic Social Network
related project: MobileSocialSemanticWeb
related project: Semantic Pingback
related project: xOperator
content: # content * The Paper "An Architecture of a Distributed Semantic Social Network" * The Vocabulary (http://purl.org/net/dssn/) * A library for PHP @ github * A PHP implementation @ github * A practical course in the winter semester 2012/13 at University of Leipzig (@ github) * A practical course in the winter semester 2014/15 at University of Leipzig (@ github) # presentation
abstract: Online social networking has become one of the most popular services on the Web. However, current social networks are like walled gardens in which users do not have full control over their data, are bound to specific usage terms of the social network operator and suffer from a lock-in effect due to the lack of interoperability and standards compliance between social networks. A Distributed Semantic Social Network architecture combines vocabularies and protocols such as WebID, FOAF, Semantic Pingback and PubSubHubbub into a coherent distributed semantic social network, which is capable to provide all crucial functionalities known from centralized social networks.
maintainer: SebastianTramp

DeFacto
type: Incubator Project
hookline: Deep Fact Validation
publication tag: defacto
template option: minimal
content: # Introduction DeFacto (Deep Fact Validation) is an algorithm for validating statements by finding confirming sources for it on the web. It takes a statement (such as "Jamaica Inn was directed by Alfred Hitchcock") as input and then tries to find evidence for the truth of that statement by searching for information in the web. In contrast to typical search engines, it does not just search for textual occurences of parts of the statement, but tries to find web pages, which contain the statement phrased in natural language. It presents the user with a confidence score for the input statement as well as a set of excerpts of relevant web pages, which allows the user to manually look at the evidence. The project has two use cases: * given a statement it can be used to find provenance information for the statement * it can directly try to check whether a statement is likely to be true # Architecture and Approach The DeFacto system consists of the components depicted above. The system takes an RDF triple as input and returns a confidence value for this triple as well as possible evidence for the fact. The evidence consists of a set of webpages, textual excerpts from those pages and meta-information on the pages. The text excerpts and the associated meta information allow the user to quickly get an overview over possible credible sources for the input statement: Instead of having to use search engines, browsing several webpages and looking for relevant pieces of information, the user can more efficiently review the presented information. Moreover, the system uses techniques which are adapted specifically for fact validation instead of only having to rely on generic information retrieval techniques of search engines. **Retrieving Webpages:** The first task of the DeFacto system is to retrieve webpages which are relevant for the given task. The retrieval is carried out by issuing several queries to a regular search engine. These queries are computed by verbalizing the RDF tri…
abstract: DeFacto (Deep Fact Validation) is an algorithm for validating statements by finding confirming sources for it on the web. It takes a statement (such as “Jamaica Inn was directed by Alfred Hitchcock”) as input and then tries to find evidence for the truth of that statement by searching for information in the web.
browse: DeFacto
download-page: downloads
maintainer: JensLehmann

Erfurt
type: Incubator Project
programming-language: PHP
hookline: PHP5 / Zend based Semantic Web API for Social Semantic Software
partner: Eccenca
related project: Query Cache
content: * Triple Storage: storage abstraction layer to access third party RDF stores as well as its own Zend DB based RDF store * Storage Abstraction: two different interfaces for the storage abstraction: Zend DB and Virtuoso * Erfurt RDF Store: SPARQL to SQL rewriter and a corrsponding relational table layout * Caching: based on analysing the graph patterns of cached SPARQL queries in order to obtain information which updates will change the query result * More: Access Control, Versioning, SPARQL Query & Update, Plugins & Trigger, Datagathering & Data Wrapper
abstract: Comprises the API underneath OntoWiki, which can be used to build sophisticated Semantic Web applications
browse: Erfurt
bug-database: issues
maintainer: PhilippFrischmuth
wiki: wiki

Facete
type: Incubator Project
publication tag: facete
hookline: JavaScript SPARQL-based Faceted Search Library and Browsing Widgets
partner: Eccenca
related project: RDFauthor
content: # Aim The goal of this project is to ease the navigation of RDF data in SPARQL endpoints using advanced faceted search techniques and the provision of corresponding visualization widgets. # Features * Works for large datasets: If a region contains too many items, the user is required to zoom in. * Pure Java Script code base for enabling easier integration into other websites * Server component only needs to be a SPARQL endpoint * Pivoting
abstract: The Facete project is comprised of a JavaScript library for faceted browsing of RDF data and (at the moment) an application for browsing geo-related RDF data. The application thereby offers filtering by facets, pivoting, and display of the data on a map.
browse: Facete
bug-database: issues
download-page: downloads
maintainer: ClausStadler
wiki: wiki

Relation Annotation in GENIA
type: Incubator Project
abstract: The aim of the GENIA relation ontology is to provide a set of relations which define a detailed and broadly applicable set of relation types based on accepted domain standard concepts for use in corpus annotation and domain information extraction approaches. To ensure that the meaning of the relationships is explicit, the relations are specified in OWL (see download section). We integrate categories and relations from several domain ontologies including IAO, OBI, GO and the GENIA ontology for maximal compatibility.
maintainer: AxelNgonga

GERBIL
type: Incubator Project
publication tag: gerbil
programming-language: Java
hookline: General Entity Annotation Benchmark Framework
related project: AGDISTIS
content: The need to bridge between the unstructured data on the document Web and the structured data on the Data Web has led to the development of a considerable number of annotation tools. Those tools are hard to compare since published results are calculated on diverse datasets and measured in different units. A first approach to structure the parameter- and tool-space of semantic entity annotation systems was published by [Cornolti et al.](http://static.googleusercontent.com/media/research.google.com/de//pubs/archive/40749.pdf ""). However, the BAT-framework is hard to setup and does not allow for an easy comparison of tools and datasets. We present GERBIL, a general entity annotation system based on the BAT-Framework. GERBIL offers an easy-to-use web-based platform for the agile comparison of annotators using multiple datasets and uniform measuring approaches. To add a tool to GERBIL, all the end user has to do is to provide a URL to a REST interface to its tool which abides by a given specification. The integration and benchmarking of the tool against user-specified datasets is then carried out automatically by the GERBIL platform. Currently, our platform provides results for **9 annotators** and **11 datasets** with more coming. Internally, GERBIL is based on the Natural Language Programming Interchange Format (NIF) and provide Java classes for implementing APIs for datasets and annotators to NIF. The following table lists the annotators supported in different version of the BAT-Framework and GERBIL. Annotators BAT-Framework Gerbil 1.0.0 Gerbil 1.2.2 Wikipedia Miner ✔ ✔ ✔ Illionois Wikifier ✔ Spotlight ✔ ✔ ✔ TagMe 2 ✔ ✔ ✔ KEA ✔ ✔ WAT ✔ ✔ AGDISTIS (✔) ✔ ✔ Babelfy ✔ ✔ NERD-ML ✔ ✔ NIF-based Annotator ✔ ✔ AIDA ✔ ✔ entityclassifier.eu (✔) ✔ FREME e-Entity ✔ CETUS ✔ FRED ✔ The following table lists the annotators that are currently available and the experiment types they support. Note that some of the A2KB annotators support the D2KB experiment by offering an own API method…
abstract: GERBIL is a general entity annotation system based on the BAT-Framework.
browse: gerbil
bug-database: issues
maintainer: RicardoUsbeck
wiki: wiki

GeoLift
type: Incubator Project
programming-language: Java
hookline: Spatial mapping framework for enriching RDF datasets with Geo-spatial information
related project: DEER
related project: FOX
related project: GeoKnow
related project: LIMES
content: The GeoLift project is upgraded to [DEER](http://aksw.org/Projects/DEER "DEER - RDF Data Extraction and Enrichment Framework")
bug-database: issues
download-page: GeoLift
maintainer: MohamedSherif
comment: Spatial mapping framework for enriching RDF datasets with Geo-spatial information.

HERObservatory
type: Incubator Project
publication tag: lodsem
template option: minimal
hookline: Using Linked Data to Build an Observatory of Societal Progress Leveraging on Data Quality
related project: ReDD-Observatory
content: The Linked Data paradigm recently emerged as a simple mechanism, based on the Web, to integrate data and knowledge, permitting an interoperable publication and exchange of information. Linked Data is increasingly used in different fields because it allows us not only to interlink data from different sources but also to uncover meaningful relationships among them. However, a crucial issue in this context is the underlying data quality. Incomplete, inconsistent or inaccurate data may strongly affect the results leading to unreliable conclusions. The aim of this paper is to show the usefulness of Linked Data to build an observatory of societal progress as well as the importance of data quality in building such use cases. Finally, Structural Equation Modeling (SEM) is applied in building the HER Observatory (Health, Economic, Research), which assesses the impact of Research and Development (R&D) on a countries’ economic performance and healthcare.
maintainer: AmrapaliZaveri

IGUANA
type: AlumniProject
template option: minimal
hookline: Intelligent Suite for Benchmarking SPARQL with Updates
related project: DBPSB
related project: DBpedia
content: ##What is it? IGUANA is a Benchmark execution Framework. IGUANA can test SPARQL Endpoints, as well as Federated SPARQL Systems with a Stress test, which means it can handle several users which request the endpoint with SPARQL Queries (ASK, CONSTRUCT, DESCRIBE, SELECT) while several update users will update (inserts and deletes) the triplestore. IGUANA can also analyze log files and get queries to test out of it. You can define several benchmark suites which work seperated of each other. In each suite you can define several testcases. IGUANA gives you also the oppertunity to write own testcases and log analyzer without changing the code itself. IGUANA can be configured over one single config file. ---------- It should be... -..easy to use -..easy to configure -..easy to install -..understandable -..well documented ##Architecture ###User ###Developer ##The latest version - The latest version can always be found [here](https://github.com/AKSW/IGUANA/tree/master). - The simple jar file will be the iguana-x.y.z.jar file. - The whole benchmark will be the iguana-x.y.z-distribution.zip file. ##Documentation The Manuals can be found [here](https://github.com/AKSW/IGUANA/blob/master/release/) ##Examples Example Configurations (v.0.3.0.2) are provided [here](https://github.com/AKSW/IGUANA/tree/master/examples). ##Installation Please see the file called [INSTALL](https://github.com/AKSW/IGUANA/blob/master/INSTALL). ##Licensing IGUANA is licensed under the LGPL License Please see the file called [LICENSE](https://github.com/AKSW/IGUANA/blob/master/LICENSE) General Information ================== Source: [https://github.com/AKSW/IGUANA](https://github.com/AKSW/IGUANA "https://github.com/AKSW/IGUANA") Issue Tracker: [https://github.com/AKSW/IGUANA/issues](https://github.com/AKSW/IGUANA/issues ) Forum: [https://groups.google.com/d/forum/iguana-aksw](https://groups.google.com/d/forum/iguana-aksw) Mailing List: [iguana-aksw@googlegroups.com](mail-to:iguana-aksw@googlegroups.com) Manu…
abstract: A SPARQL benchmark.
abstract: IGUANA is a Benchmark execution Framework. IGUANA can test SPARQL Endpoints, as well as Federated SPARQL Systems with a Stress test, which means it can handle several users which request the endpoint with SPARQL Queries (ASK, CONSTRUCT, DESCRIBE, SELECT) while several update users will update (inserts and deletes) the triplestore.
browse: IGUANA
maintainer: FelixConrads
type: Incubator Project

KeyNode.js
type: Incubator Project
hookline: Next level web presentations
programming-language: JavaScript
abstract: KeyNode.js tries to upgrade existing web-standards based slide show tools (as Slidy or slidedown) with presenter console like features such as personal notes on a different screen/browser, next slide preview and slide overview.
feed: presenter.atom
feed: server.atom
feed: watcher.atom
browse: KeyNode.js
bug-database: issues
maintainer: SebastianTramp
wiki: wiki

LDWPO
type: Incubator Project
hookline: the Linked Data Workflow Project ontology
description: Maintaining Linked Data datasets is a time-consuming and resource-intensive activity. The cost for maintaining Linked Data can, however, be reduced by using a workflow framework, which provides methods to systematically support the lifecycle of RDF datasets. We present the main component of such a framework, an ontology for orchestrating Linked Data processing workflows dubbed the Linked Data Workflow Project ontology. We introduce the Plan, Method, and Execution classes, which allow describing important maintenance tasks. We show that our ontology facilitates the description of the complete production workflow for RDF datasets, the explication of the methods and tools utilized in such a workflow and the execution of these workflows in a (semi-)automatized fashion. Hence, our approach enables the reproducibility and repeatability of Linked Data processing steps.
bug-database: issues
maintainer: SandroRautenberg

LODStats
type: Incubator Project
publication tag: lodstats
template option: minimal
hookline: a statement-stream-based approach for gathering comprehensive statistics about RDF datasets
abstract: LODStats is a statement-stream-based approach for gathering comprehensive statistics about datasets adhering to the Resource Description Framework (RDF). LODStats is based on the declarative description of statistical dataset characteristics. Its main advantages over other approaches are a smaller memory footprint and significantly better performance and scalability. We integrated LODStats into the CKAN dataset metadata registry and obtained a comprehensive picture of the current state of the Data Web.
browse: LODStats
bug-database: issues
download-page: downloads
maintainer: IvanErmilov
wiki: wiki
logo: http://wiki.aksw.org/Projects/LODStats/files

Mosquito
type: Incubator Project
hookline: SPARQL benchmark
abstract: A SPARQL benchmark.

N3 - Collection
type: Incubator Project
publication tag: n3
hookline: N3 - A Collection of Datasets for Named Entity Recognition and Disambiguation in the NLP Interchange Format
related project: NLP Interchange Format (NIF)
abstract: Extracting Linked Data following the Semantic Web paradigm from unstructured sources has become a key driver for scientific research as well as new business models. Named Entity Recognition and Disambiguation are two basic steps in this extraction process. One key driver to realize the vision of the Semantic Web and develop highly accurate tools is the availability of data for performance validation. In this article, we present three novel, manually curated and annotated corpora, N3. Furthermore, we based them on a free licence and stored in the NLP Interchange Format for interoperability reasons.
download-page: n3-collection
download-page: QRTool
maintainer: Andreas Both
maintainer: http://aksw.org/SebastianHellmann

NLP Interchange Format (NIF)
type: Incubator Project
publication tag: nif
template option: minimal
hookline: an RDF/OWL-based format that allows to combine and chain several NLP tools in a flexible, light-weight way
related project: FOX
abstract: The core of NIF consists of a vocabulary, which can represent Strings as RDF resources. A special URI Design is used to pinpoint annotations to a part of a document. These URIs can then be used to attach arbitrary annotations to the respective character sequence. Based on these URIs, annotations can be interchanged between different NLP tools.
feed: feed
maintainer: SebastianHellmann
wiki: wiki.nlp2rdf.org

NIF4OGGD
type: Incubator Project
publication tag: nif4oggd
demonstrates: nif4oggd
hookline: Natural Language Interchange Format for Open German Governmental Data
related project: LinkedGeoData
related project: NLP Interchange Format (NIF)
abstract: In the last couple of years the amount of structured open government data has increased significantly. Already now, citizens are able to leverage the advantages of open data through increased transparency and better opportunities to take part in governmental decision making processes. Our approach increases the interoperability of existing but distributed open governmental datasets by converting them to the RDF-based NLP Interchange Format (NIF). Furthermore, we integrate the converted data into a geodata store and present a user interface for querying this data via a keyword-based search. The language resource generated in this project is publicly available for download and via a dedicated SPARQL endpoint.
bug-database: issues
download-page: NIF4OGGD
maintainer: Andreas Both
maintainer: Sandro Coelho
maintainer: MohamedSherif

OpenResearch
type: Incubator Project
hookline: Semantic Wiki for the Sciences
abstract: A semantic Wiki for collecting and sharing scientific meta-data such as CfPs, tool descriptions, research profiles, conference statistics etc.
maintainer: SoerenAuer

QualisBrasil
type: Incubator Project
hookline: Linked Open Data for supporting scientometric studies
related project: LDWPO
maintainer: SandroRautenberg

Query Cache
type: Incubator Project
hookline: Adaptive SPARQL Query Cache
abstract: In order to get closer to the performance of relational database-backed Web applications, we developed an approach for improving the performance of triple stores by caching query results and even complete application objects. The selective invalidation of cache objects, following updates of the underlying knowledge bases, is based on analysing the graph patterns of cached SPARQL queries in order to obtain information about what kind of updates will change the query result.
maintainer: MichaelMartin
programming-language: Java
programming-language: PHP

RDFSlice
type: Incubator Project
hookline: Large-scale RDF Dataset Slicing
programming-language: Java
content: RDFSlicing focuses on the selection and extraction. It devises a fragment of SPARQL dubbed SliceSPARQL, which enables the selection of well-defined slices of datasets fulfilling typical information needs. SliceSPARQL supports graph patterns for which each connected subgraph pattern involves a maximum of one variable or IRI in its join conditions. This restriction guarantees the efficient processing of the query against a sequential dataset dump stream. As a result dataset slices can be generated an order of magnitude faster than by using the conventional approach of loading the whole dataset into a triple store and retrieving the slice by executing the query against the triple store's SPARQL endpoint.
abstract: In the last years an increasing number of structured data was published on the Web as Linked Open Data (LOD).Despite recent advances, consuming and using Linked Open Data within an organization is still a substantial challenge. Many of the LOD datasets are quite large and despite progress in RDF data management their loading and querying within a triple store is extremely time-consuming and resource-demanding. To overcome this consumption obstacle, we propose a process inspired by the classical Extract-Transform-Load (ETL) paradigm, RDF dataset slicing.
browse: src
download-page: downloads
maintainer: EdgardMarx

RDFUnit
type: Incubator Project
hookline: an RDF Unit-Testing suite
publication tag: rdfunit
browse: https://github.com/AKSW/RDFUnit/
programming-language: java
wiki: https://github.com/AKSW/RDFUnit/wiki
demonstrates: demo
content: For more information on our methodology please refer to our report: > [Test-driven evaluation of linked data quality](http://svn.aksw.org/papers/2014/WWW_Databugger/public.pdf). Dimitris Kontokostas, Patrick Westphal, Sören Auer, Sebastian Hellmann, Jens Lehmann, Roland Cornelissen, and Amrapali J. Zaveri in Proceedings of the 23rd International Conference on World Wide Web. ### RDFUnit in a Nutshell - **Test case**: a data constraint that involves one or more triples. We use SPARQL as a test definition language. - **Test suite**: a set of test cases for testing a dataset - **Status**: Success, Fail, Timeout (complexity) or Error (e.g. network). A **Fail** can be an actual error, a warning or a notice - **Data Quality Test Pattern** (DQTP): Abstract test cases that can be intantiated into concrete _test cases_ using _pattern bindings_ - **Pattern Bindings**: valid replacements for a _DQTP_ variable - **Test Auto Generators** (TAGs): Converts RDFS/OWL axioms into concrete _test cases_ As shown in the figure, there are two major sources for creating test cases. One source is stakeholder feedback from everyone involved in the usage of a dataset and the other source is the already existing RDFS/OWL schema of a dataset. Based on this, there are several ways in which test cases can be created: - **Using RDFS/OWL constraints directly**: Test cases can be automatically created via TAGs in this case. - **Enriching the RDFS/OWL constraints:** Since many datasets provide only limited schema information, we perform automatic schema enrichment. These schema enrichment methods can take an RDF/OWL dataset or a SPARQL endpoint as input and automatically suggest schema axioms with a certain confidence value by analysing the dataset. In our methodology, this is used to create further test cases via TAGs. It should be noted that test cases are explicitly labelled, such that the engineer knows that they are less reliable than manual test cases. - **Re-using tests based on common vocabu…
abstract: RDFUnit is a test driven data-debugging framework that can run automatically generated (based on a schema) and manually generated test cases against an endpoint. All test cases are executed as SPARQL queries using a pattern-based transformation approach.
bug-database: issues
download-page: releases
maintainer: DimitrisKontokostas

RDFaCE
type: Incubator Project
hookline: RDFa Content Editor
publication tag: rdface
template option: minimal
programming-language: JavaScript
promoted: 1
related project: FOX
related project: NLP Interchange Format (NIF)
content: About ===== RDFaCE is an online RDFa content editor based on [TinyMCE](http://tinymce.moxiecode.com/ "http://tinymce.moxiecode.com/"). It supports different views for semantic content authoring and uses existing semantic Web APIs to facilitate annotating and editing of RDFa contents. As depicted in the following picture, the RDFaCE system architecture consists of three layers: Rich Text Editor, RDFaCE plugin and External Services layer. **RDFaCE** supports four different views for semantic text authoring: - WYSIWYG View. What-You-See-Is-What-You-Get - WYSIWYM View. What-You-See-Is-What-You-Mean - RDF Triple View. - Source Code View. The views are synchronized such that changes made in one of the views automatically update the others. Furthermore, RDFaCE employs [Sindice](http://sindice.com/developers/api "http://sindice.com/developers/api"), [Swoogle](http://swoogle.umbc.edu/ "http://swoogle.umbc.edu/") and [Prefix.cc](http://prefix.cc/ "http://prefix.cc/") APIs for resource suggestion (providing appropriate URIs for subjects, properties and namespaces). Another feature supported by RDFaCE is _combining the results of multiple NLP APIs_. Using this approach, we can harness synergies arising from the combination of different approaches for automatic text annotation. Currently, RDFaCE supports 7 NLP APIs namely [Alchemy](http://www.alchemyapi.com/api/ "http://www.alchemyapi.com/api/"),[Extractiv](http://wiki.extractiv.com/w/page/29179775/Entity-Extraction "http://wiki.extractiv.com/w/page/29179775/Entity-Extraction"), [Open Calais](http://www.opencalais.com/APIkey "http://www.opencalais.com/APIkey"), [Ontos](http://www.ontos.com/ "http://www.ontos.com/"),[Evri](http://www.evri.com/developer/api-registration "http://www.evri.com/developer/api-registration"), [Saplo](http://saplo.com/ "http://saplo.com/"),[Lupedia](http://lupedia.ontotext.com/ "http://lupedia.ontotext.com/") and [DBpedia spotlight](http://dbpedia.org/spotlight "http://dbpedia.org/spotlight"). The RDFaCE…
abstract: RDFaCE is an RDFa Content Editor based on TinyMCE. It supports different views for semantic content authoring and uses existing Semantic Web APIs to facilitate the annotation and editing of RDFa contents.
feed: feed
maintainer: AliKhalili

RDFauthor
type: Incubator Project
programming-language: JavaScript
hookline: is an editing solution for distributed and syndicated structured content on the World Wide Web
abstract: The system is able to extract structured information from RDFa-enhanced websites and to create an edit form based on this data. To this end, we make use of semantics-aware editing widgets that hide most of the RDF data model from the user, thus allowing more people to author semantic content. If the embedded data does not suffice to create a rich user-supporting editing view, the underlying Semantic Web infrastructure is used to retrieve additional schema-related information about the elements used.
browse: RDFauthor
bug-database: issues
download-page: tags
maintainer: ClemensHoffmann
wiki: pages

ReDD-Observatory
type: Incubator Project
publication tag: redd
template option: minimal
hookline: Using the Web of Data for Evaluating the Research-Disease Disparity
related project: OntoWiki
content: # Background It is widely accepted that there is a large disparity between the availability of treatment options and the prevalence of diseases in the world, thus placing individuals in danger. This disparity is partially caused by the restricted access to information that would allow health- care and research policy makers to formulate more appropriate measures to mitigate this disparity. Specifically, this shortage of information is caused by the difficulty in reliably obtaining and integrating data regarding the disease burden for a given nation and the respective research investments. In response to these challenges, the Linked Data paradigm provides a simple mechanism for publishing and interlinking structured information on the Web. In conjunction with the ever increasing data on diseases and healthcare research available as Linked Data, an opportunity is created to reduce this information gap that would allow for better policy in response to these disparities. We present the ReDD-Observatory, an approach for evaluating the *Re*search-*D*isease *D*isparity based on the interlinking and integrating of various biomedical data sources. # Methodology The figure below provides a birds eye-view of the methodology involved in the ReDD-Observatory. We first identified relevant datasets to be included that provided relevant information to evaluate the disparity. We not only consider the datasets already present as RDF but also those that are present in unstructured formats. These datasets are: 1. [LinkedCT](http://linkedct.org) - the RDF representation of [ClinicalTrials.gov](http://clinicaltrials.gov/), which is the database of all clinical trials around the world. 2. [Bio2RDF's PubMed](http://pubmed.bio2rdf.org/sparql) - the RDF representation of [PubMed](http://www.ncbi.nlm.nih.gov/pubmed/), which is a service of the US National Library of Medicine that includes bibliographic information and abstracts of over 19 million publications from MEDLINE and other life scien…
abstract: The ReDD-Observatory is a project to evaluate the disparity between active areas of biomedical research and the global burden of disease using Linked Data and data-driven discovery.
maintainer: AmrapaliZaveri

SAIM
type: Incubator Project
hookline: (Semi-)Automatic Instance Matcher
demonstrates: saim.aksw.org
content: Articles ================== - [ISWC 2011 Ontology Matching Workshop Paper about RAVEN](http://jens-lehmann.org/files/2011/raven.pdf "ISWC 2011 Ontology Matching Workshop Paper about RAVEN") - [ESWC 2012 Paper on EAGLE](http://www.springerlink.com/content/nwr4w44078602350/?MUD=MP "ESWC 2012 Paper on EAGLE") User Interface ================== A pre-alpha version of the SAIM user interface is available [here](http://139.18.2.136:8080/SAIM "here"). SAIM is localized (the screenshot shows it in a german browser) with english and german localization existing. If you want to provide an additional language just let us know and we can provide you with a resource file template. [Veri Links](http://wiki.aksw.org/Projects/VeriLinks?v=aat "Veri Links") (Game Based Link Verification) ================== As a module of SAIM, we developed an interlinking game with a prupose (GWAP). By verifying links, you earn points, which you can use in the main game to defend against invadors (and save world - as usual). If you disagree with many other users, then you can also get penalties. In the admin console, arbitrary linksets can be uploaded. Depending on the data, facts about resources are displayed in lists or on a map. Try it: [http://verilinks.aksw.org](http://verilinks.aksw.org "http://verilinks.aksw.org") Developing SAIM using Eclipse ================== 1. Make sure you have Java 6, Maven 2 and Eclipse (preferably JEE) installed. 2. Install the [Subclipse plugin](http://subclipse.tigris.org/ "Subclipse plugin") for Subversion support. 3. Install the [Eclipse m2e Maven plugin](http://m2eclipse.sonatype.org/sites/m2e "Eclipse m2e Maven plugin") for Maven support and [m2e extras](http://m2eclipse.sonatype.org/sites/m2e-extras "m2e extras") "Maven SCM handler for Subclipse". 4. "File >> New >> Other..." >> "Checkout Maven Projects from SCM" 5. Set SCM URL type to "svn" and enter [https://saim.svn.sourceforge.net/svnroot/saim/trunk](https://saim.svn.sourceforge.net/svnroot/saim/trunk "https…
abstract: The original intention behind SAIM (pronounced like “same”) was to provide an interface desgined to support instance matching on RDF data. Its main apllication was then intended to support the discovery of links between knowledge bases across the Linked Data Web with semi-automic approaches. In addition to providing achieving this goal by provinding interfaces that allow users either manually or semi-automatically generating class matchings, property matchings and link specifications, SAIM has been paired with LIMES and now provides an extended range of functionality. For example, it now includes interfaces the fully unsupervised learning of link specifications. In addition, LIMES' machine learning algorithms such as RAVEN (RApid actiVE liNking) and EAGLE (Efficient Active Learning of Link Specifications Using Genetic Programming) can be utilized in SAIM.
maintainer: AxelNgonga
maintainer: JensLehmann

SCRS
type: Incubator Project
publication tag: scrs
hookline: Semantic Clinical Registry System for Rare Diseases
partner: Eccenca
content: #Features: * semantic web technologies in a clinical registry (RDF,OWL, LOD,...) * uses knowlegde from other ontologies which are in the linked open data cloud (LOD) * user input will automatically generate RDF * all communications over HTTPS possible * SPARQL endpoint protection by eLDS-Backend * implements TMF's generic data protection concept * uses Mainzelliste for PID generation (pseudonymisation)
abstract: The SCRS for Rare Diseases project is a generic framework to set up a clinical registry which takes advantage of semantic web technologies. Patient's data will be stored graph based as RDF triples in a triplestore.
maintainer: ClemensHoffmann

SINA
type: Incubator Project
publication tag: sina
template option: minimal
wiki: http://wiki.aksw.org/Projects/lodquery
demonstrates: sina-linkeddata.aksw.org
hookline: Semantically INterpreting user query towards question-Answering
content: [Here](http://www.youtube.com/watch?v=37IcIF6X0Kg&feature=youtu.be "") is a screencast explaining the functionality and usage of SINA.
abstract: Knowledge bases published on the Web of Data can be used to answer challenging questions about a wide range of topics. They usually offer a SPARQL endpoint, which can be queried by the user. However, a novice user needs to acquire both knowledge about the underlying ontology and proficiency in formulating SPARQL queries in order to actually formulate a SPARQL query. In this project, we are working on constructing SPARQL queries based on user-supplied keywords. As a result ordinary users are empowered to formulate relatively expressive queries without knowledge of SPARQL and the underlying ontology structure.
maintainer: SaeedehShekarpour

SPARQL2NL
type: Incubator Project
demonstrates: demo
hookline: converting SPARQL queries to natural language
content: Survey (not active anymore): [http://blog.aksw.org/2012/sparql2nl-survey/](http://blog.aksw.org/2012/sparql2nl-survey/) Survey Winners (those who agreed that we can publish their names): Ben Companjen, Thimo Thoeye, Luke Opperman, Jeffrey Putnam, Tobbe Sjogren, Ghalem Ouadjed [AutoSPARQL TBSL Demo User Interface (using SPARQL2NL)](http://autosparql-tbsl.dl-learner.org) **Involved CITEC members:** [Dr. Christina Unger](http://www.sc.cit-ec.uni-bielefeld.de/people/cunger)
abstract: Over the last years, Semantic Web and Linked Data technologies have reached the backend of a considerable number of applications. While experts can easily access the data stored in these backends via the W3C standard SPARQL, most lay users do not understand this query language. Thus, they mostly have to rely on forms and query builders. We address this drawback by presenting a framework that allows converting virtually any SPARQL 1.0 query into natural language. Our framework implements a bottom-up approach that consists of normalizing the input query, converting it to natural language and reducing the query to make easily understandable. As our approach is generic, it not only allows transforming queries but also to represent the answers to queries in natural language. Therewith, our approach can be used to enable users accessing triple stores without even having to deal with SPARQL or RDF.
browse: SPARQL2NL
maintainer: AxelNgonga

Semantic Pingback
type: Incubator Project
publication tag: seebiproject_semanticpingback
hookline: Adding a social dimension to the Linked Data Web
content: Semantic Pingback tackles the quality, timeliness and coherence as well as direct end user benefits of the emerging Linked Data Web. Semantic Pingback extends the well-known Pingback method, which is technological cornerstone of the blogosphere. It is based on the advertising of an RPC service for propagating typed RDF links between Data Web resources. It is downwards compatible with conventional Pingback implementations, thus allowing to connect and interlink resources on the Social Web with resources on the Data Web.
abstract: The Semantic Pingback mechanism is an extension of the well-known Pingback method, a technological cornerstone of the blogosphere, thus supporting the interlinking within the Data Web.
maintainer: SebastianTramp

SparqlAnalytics
type: Incubator Project
hookline: I Know What You Did Last Query
template option: minimal
demonstrates: fp7-pp.publicdata.eu
promoted: 1
content: Live Query Usage Stats ====================== Although the goal of this project is more amibitious than "just" providing a live chart of SPARQL endpoint activity, this is still a pretty neat "by-product", which we intend to develop further.
abstract: This project aims to develop a java based middleware/proxy framework for live analysis of SPARQL queries. Publish live SPARQL endpoint metrics using embeddable HTML/JavaScript widgets.
browse: SparqlAnalytics
bug-database: issues
download-page: downloads
maintainer: ClausStadler

SparqlMap
type: Incubator Project
hookline: is a SPARQL-to-SQL rewriter
publication tag: sparqlmap
template option: minimal
partner: Eccenca
promoted: 1
related project: Sparqlify
abstract: SparqlMap allows the execution of a SPARQL query fully inside a relational database and does not require dumping the data first. The translation is a light weight process with low requirements on processing power. The mapping of the relational database is expressed using R2RML, the mapping language being currently standardized by a W3C working group.
feed: master.atom
bug-database: issues
download-page: releases
maintainer: JoergUnbehauen

Sparqlify
type: Incubator Project
hookline: a SPARQL-SQL rewriter
publication tag: sparqlify
template option: minimal
programming-language: Java
promoted: 1
content: # Key Features * A novel syntax for view definitions inspired by SQL's CREATE VIEW statement. We believe this to lower the learning curve for defining RDB-RDF mappings. * A query is rewritten into a single SQL statement, giving all control over query planning to the underlying database system. * Support of geo-spatial functions: In general, Sparqlify supports mapping custom SPARQL functions to relational ones. Some mappings for PostGIS are already provided (e.g. intersection with polygons). # Limitations Please be aware that Sparqlify is currently in alpha state and the following limitations hold: * For the moment, only the PostgreSQL database system is supported. * Only a subset of SPARQL 1.0 + Sub-Queries is supported: For instance, the implementation of aggregate functions including COUNT is still pending. * Support for Sparql 1.1 property paths is very unlikely in the near future.
abstract: Sparqlify is a SPARQL-SQL rewriter that enables one to define RDF views on relational databases and query them with SPARQL. It is currently in alpha state and powers the Linked-Data Interface of the LinkedGeoData Server – i.e. it provides access to billions of virtual triples from the OpenStreetMap database.
browse: Sparqlify
bug-database: issues
download-page: downloads
maintainer: ClausStadler

TripleCheckMate
type: Incubator Project
browse: https://github.com/AKSW/TripleCheckMate
hookline: Crowdsourcing the evaluation of Linked Data
related project: DBpediaDQ
abstract: TripleCheckMate is a tool for crowdsourcing the assessment of Linked Open Data. It was developed under the DBpediaDQ project as an application for evaluating the correctness of DBpedia. TripleCheckMate provides an easy-to-use user interface with multiple resource assignment methods and a ready to use error classification scheme. It is released under Apache 2.0 Licence.
feed: feed
bug-database: issues
download-page: master.zip
maintainer: DimitrisKontokostas

VeriLinks
type: Incubator Project
hookline: verifying links in an arbitrary linkset
related project: SAIM
content: Experiment 2012: Can we create better links by playing games? ================================================================== In 2012, we officially released Veri Links and started a survey, which we distributed on Linked Data and Semantic Web mailing lists. We recorded in-game statistics and survey answers to obtain a clearer picture on the usefulness of games, in particular VeriLinks, for interlinking. The results and accompanying material for the experiments are available here: - [Experiment Report](http://svn.aksw.org/papers/2013/ESWC_VeriLinks/public.pdf "Experiment Report") - Survey: - [announcement blog post](http://blog.aksw.org/2012/verilinks/ "") - [survey on VeriLinks](http://surveys.aksw.org/survey/verilinks "") [can still be used for feedback, but will be offline eventually] - [all questions and results as PDF](http://aksw.org/files/verilinks/Survey_VeriLinks_Results.pdf "") - [raw survey results as CSV](http://aksw.org/files/verilinks/Survey_VeriLinks_Raw_Results.csv "") (with questions) - Data: - [used link specifications](http://aksw.org/files/verilinks/specs/ "") - [generated links](http://aksw.org/files/verilinks/links/ "") - [manually created GOLD standard](http://aksw.org/files/verilinks/gold_standard.csv "") - [templates used for displaying questions for the above link tasks](http://aksw.org/files/verilinks/Templates.xml "") - In-Game Statistics (see report for explanations): - [raw link validation statistics in CSV format](http://aksw.org/files/verilinks/stats/link_validation_raw_data%20.csv ""), columns: ID, subject, predicate, object, link task, link specification confidence value (as computed by the above link specifications), game confidence value (explained in the report), GOLD standard (1=correct,0=incorrect), number of times the link has been played, number of times the link has been judged as correct in the game, number of times the link has been judged as incorrect in the game - [Weka machine learning toolkit training data file](htt…
abstract: VeriLinks is a light-weight platform for creating games to verify links in an arbitrary linkset. Agreement among players on the validity of a link is rewarded by coins or points. Depending on the specific game, those are then used to fight against enemy invadors in a tower defense style game or to battle using space ships. VeriLinks automatically balances the game such that the questions match the user's strength and the rewards match the difficulty of questions. VeriLinks features an admin console, which allows to create new games from a linkset by specifying the respective SPARQL endpoints, a template (for visual presentation) and the linkset itself.
browse: saim
maintainer: JensLehmann

Xodx
type: Incubator Project
hookline: A basic DSSN node implementation
publication tag: xodx
demonstrates: xodx.comiles.eu
related project: DSSN
related project: Erfurt
related project: Semantic Pingback
abstract: Xodx is an implementation of the basic functionality of a DSSN node with profile provider and browser. It can be used both for a single-user setup (e.g. on a Freedom Box) and a multi-user setup. The software is written in PHP and based on the Erfurt-Framework and lib-dssn-php.
feed: develop.atom
browse: xodx
bug-database: issues
maintainer: NatanaelArndt

Xturtle
type: Incubator Project
programming-language: Java
hookline: an eclipse / Xtext2 based editor for RDF/Turtle files
partner: Eccenca
partner: Itemis
content: # Installation Starting from an existing eclipse installation, you first have to install Xtext, which is a dependency for Xturtle, from this update site: `http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/` After that, install Xturtle from this update site: `http://xturtle.aksw.org/site.xml` During the installation, you will get a warning that the package is unsigned. You'll know that the editor is working, when you open a `.ttl` file and you are asked if you want to add the Xtext-Nature to the project. Further, on invoking code completion (ctrl-space) in the first line, something should happen... For more information on features, usage notes and technical background, have a look at the [wiki](https://github.com/AKSW/Xturtle/wiki).
abstract: Xturtle is turtle editor solution based on eclipse / Xtext2. It features syntax highlighting, code completion (resource qnames, datatypes, language tags, literals, prefixe and namespaces URIs from prefix.cc), templates, syntax validation, internal linking to descriptions, preview of resources, navigation in outline and quick outline, folding (prefixes, subject blocks, multiline literals) and multiple customization options including syntax highlighting.
feed: feed
browse: Xturtle
bug-database: issues
license: Eclipse Public License
maintainer: SebastianTramp
wiki: wiki

conTEXT
type: Incubator Project
publication tag: context
hookline: Lightweight Text Analytics using Linked Data
partner: Eccenca
related project: FOX
abstract: conTEXT allows to semantically analyze text corpora (such as blogs, RSS/Atom feeds, Twitter or SlideWiki.org decks) and to visualize the results.
maintainer: AliKhalili

jena-sparql-api
type: Incubator Project
hookline: A Java library featuring tools for transparently boosting SPARQL query execution.
abstract: A java library that offers several Jena-compatible ways to transparently add delays, caching, pagination, retry and even query transformations before sending off your original SPARQL query. Also, the server module bundles Jena with the Atmosphere framework, giving you a kickstart for REST and websocket implementations.
browse: jena-sparql-api
bug-database: issues
download-page: downloads
maintainer: ClausStadler
wiki: wiki

openQA
type: Demo
hookline: Open Question Answering Framework
publication tag: openqa
programming-language: Poliglot
abstract: The use of Semantic Web technologies led to an increasing number of structured data published on the Web. Despite the advances on question answering systems retrieving the desired information from structured sources is still a substantial challenge. Users and researchers still face difficulties to integrate and compare their results. openQA is an open source question answering framework that unifies approaches from several domain experts. The aim of openQA is to provide a common platform that can be used to promote advances by easy integration and measuring different approaches.
browse: openqa
maintainer: EdgardMarx
type: Incubator Project
type: OpenSourceProject

SMART
type: Incubator Project
hookline: A Semantic Search Engine
publication tag: SMART
programming-language: Smart is poliglot
related project: openQA
abstract: Smart is a semantic search engine that unifies concepts from ordinary search as well as question answering systems. Moreover, smart also bring new concepts of interactions as well as search.
maintainer: EdgardMarx
comment: Project under development seeking for investors.