AskNow is a Question Answering (QA) system for RDF datasets.
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.
a linked data driven web page rendered by OntoWiki site extension
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.
# 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.
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.
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.
Ontology Based Data Access and Integration for Improving the Effectiveness of Farming in Nepal
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.
Convert a natural language expression to a SPARQL query
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
# 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())); writer.addDocument(doc);%% You can query the index like this: Query query1 = new TermQuery(new Term("nlr", searchPhrase)); Query query2 = NumericRangeQuery.newDoubleRange("confidence", confidenceThreshold, 1D, true, true); BooleanQuery booleanQuery = new BooleanQuery(); booleanQuery.add(query1, BooleanClause.Occur.MUST); booleanQuery.add(query2, BooleanClause.Occur.MUST); ScoreDoc[] hits = indexSearcher.search(booleanQuery, 100).scoreDocs; for (int i = 0; i < hits.length && i < 5; i++) { System.out.println(indexSearcher.doc(hits[i].doc).get("uri")); System.out.println(indexSearcher.doc(hits[i].doc).get("nlr")); System.out.println(indexSearcher.doc(hits[i].doc).get("confidence")); } You can download this index [here][patlibrary]. Keep in mind that you need Lucene in at least Version 3.0. We applied very strict rules during pattern filtering, so very few patterns were actually generated. Also there are no score constrains applied to the patterns contained, leading to very weak patterns inside the index. [boadydra]: http://dydra.com/daniel-gerber/boa "BOA dydra repository" [patlibrary]: http://aksw.org/Projects/BOA/files?get=pattern_library_en_dbpedia_wikipedia.tar
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.
Representing multi-dimensional statistical data as RDF using the RDF Data Cube Vocabulary
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").
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.
Towards Biomedical Data Integration for Analyzing the Evolution of Cognition
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.
Analyzing Cognitive Evolution using Linked Data
User-driven quality evaluation of DBpedia
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 affected : 11.93 - % of triples affected in the dbprop namespace : 7.11 Manuscript ================== - [Link to presentation](http://www.slideshare.net/amrapalijz/i-semantics-d-bpediadq "Link to presentation") presented at [I-Semantics 2013](i-semantics.tugraz.at "I-Semantics 2013") - [Link to manuscript](svn.aksw.org/papers/2013/ISemantics_DBpediaDQ/public.pdf "Link to manuscript") accepted at[I-Semantics 2013](i-semantics.tugraz.at "I-Semantics 2013")
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.
Crowdsourcing DBpedia Quality Assessment
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.
RDF Data Extraction and Enrichment Framework
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.
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.
Deep Web Extraction for Question Answering
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 back to standard information retrieval, where this fails. # Use Case: Application to the Real Estate Domain he domain-specific implementation of the conceptual framework, which we used for the real estate domain, is depicted in the figure above. It covers the above described steps by employing state-of-the-art tools in the respective areas, OXPath for data extraction to RDF, LIMES for linking to the linked data cloud, and TBSL for translating natural language questions to SPARQL queries. Below are the configuration files necessary to set up the system and a pointer to a user interface for testing it: * prototype user interface: [http://autosparql-tbsl.dl-learner.org](http://autosparql-tbsl.dl-learner.org "http://autosparql-tbsl.dl-learner.org") * [evaluation queries](http://aksw.org/files/DEQA/evaluation.txt "evaluation queries") * [OXPath wrappers](http://aksw.org/files/DEQA/wrappers.zip "OXPath wrappers") * [LIMES specs](http://aksw.org/files/DEQA/limes_specs.zip "LIMES specs") # Members ## DIADEM - Dr. Tim Furche, http://furche.net - Dr. Giovanni Grasso, http://www.giovannigrasso.it/ - Dr. Christian Schallhart, http://www.cs.ox.ac.uk/people/christian.schallhart/ - Dr. Andrew Sellers, http://www.cs.ox.ac.uk/people/andrew.sellers/ - David Liu ## CITEC - Dr. Christina Unger, http://www.sc.cit-ec.uni-bielefeld.de/people/cunger/
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.
Knowledge Base Shipping to the Linked Open Data Cloud
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.
Quality Assessment for Linked Data: A Survey
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.
Linked Data Quality | Create infographics
towards a global Distributed Semantic Social Network
# 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
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.
# 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 triple using natural-language patterns extracted by the BOA framework. As a next step, the highest ranked webpages for each query are retrieved. Those webpages are candidates for being sources for the input fact. Both the search engine queries as well as the retrieval of webpages are executed in parallel to keep the response time for users within a reasonable limit. Note that usually this does not put a high load on particular web servers as webpages are usually derived from several domains. **Evaluating Webpages:** Once all webpages have been retrieved, they undergo several further processing steps. First, plain text is extracted from each webpage by removing most HTML markup. We can then apply our fact confirmation approach on this text. In essence, the algorithm decides whether the web page contains a natural language formulation of the input fact. This step distinguishes DeFacto from information retrieval methods. If no webpage confirms a fact according to DeFacto, then the system falls back on light-weight NLP techniques and computes whether the webpage does at least provide useful evidence. In addition to fact confirmation checking, the system computes different indicators for the trustworthiness of a webpage. These indicators are of central importance because a single trustworthy webpage confirming a fact may be a more useful source than several webpages with low trustworthiness. The fact confirmation and the trustworthiness indicators of the most relevant webpages are presented to the user. **Confidence Measurement:** In addition to finding and displaying useful sources, DeFacto also outputs a general confidence value for the input fact. This confidence value ranges between 0% and 100% and serves as an indicator for the user: Higher values indicate that the found sources appear to confirm the fact and can be trusted. Low values mean that not much evidence for the fact could be found on the Web and that the websites that do confirm the fact (if such exist) only display low trustworthiness. The training data for this step is available ((https://github.com/AKSW/DeFacto/blob/master/core/resources/training/data.zip?raw=true here)). Naturally, DeFacto is a (semi-)automatic approach: We do assume that users will not blindly trust the system, but additionally analyze the provided evidence.
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.
PHP5 / Zend based Semantic Web API for Social Semantic Software
* 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
Comprises the API underneath OntoWiki, which can be used to build sophisticated Semantic Web applications
JavaScript SPARQL-based Faceted Search Library and Browsing Widgets
# 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
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.
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.
General Entity Annotation Benchmark Framework
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. Other A2KB annotators can be chosen for a D2KB experiment as well as described in the wiki. However, since the comparison might not be fair, we marked these annotators with (✔) in the table. The same is done for Entity Typing. A2KB, C2KB, Entity Recognition D2KB Entity Typing OKE Task 1 OKE Task 2 AIDA ✔ (✔) AGDISTIS ✔ Babelfy ✔ ✔ CETUS ✔ CETUS (FOX) ✔ Dexter ✔ (✔) entityclassifier.eu ✔ (✔) FRED ✔ (✔) (✔) ✔ FREME e-Entity ✔ ✔ ✔ ✔ FOX ✔ (✔) (✔) ✔ KEA ✔ ✔ NERD-ML ✔ (✔) Spotlight ✔ ✔ ✔ ✔ TagMe 2 ✔ (✔) WAT ✔ ✔ xLisa ✔ (✔) The following table lists the datasets that are currently available and the experiment types they support. A2KB, C2KB, D2KB, Entity Recognition Entity Typing OKE Task 1 OKE Task 2 AIDA/CoNLL-Complete ✔ AIDA/CoNLL-Test A ✔ AIDA/CoNLL-Test B ✔ AIDA/CoNLL-Training ✔ AQUAINT ✔ DBpediaSpotlight ✔ IITB ✔ KORE50 ✔ MSNBC ✔ Microposts 2014-Test ✔ Microposts 2014-Train ✔ N3-RSS-500 ✔ N3-Reuters-128 ✔ OKE 2015 Task 1 evaluation dataset ✔ ✔ ✔ OKE 2015 Task 1 example set ✔ ✔ ✔ OKE 2015 Task 1 gold standard sample ✔ ✔ ✔ OKE 2015 Task 2 evaluation dataset ✔ OKE 2015 Task 2 example set ✔ OKE 2015 Task 2 gold standard sample ✔ #### Long term stability The idea of GERBIL emerged in September 2014 when a couple of articles released at the same time claimed to be state-of-the-art. Especially, those approaches were not easily comparable due to their heterogeneous set-up, dataset use and evaluation metrics. Thus, we decided to build GERBIL and extend the [BAT-Framework](https://github.com/marcocor/bat-framework "BAT-framework") to break the barriers for people not able to write source code. GERBIL is still a young project and thus we are trying to explore the borders of our endeavour. As GERBIL has been launched within two PhD projects funded by European Social Fund we are confident that it will be a long lasting web service. The fallback is our working group AKSW which currently already hosts more than 30 open source projects. Finally, GERBIL is open source software which can be maintained and hosted by anybody. Furthermore, the research and developement unit of the University Leipzig Computation Center keeps daily backups to ensure long-term quotability. With this project we aim at establishing a highly available, easy quotable and liable focal point for NER and NED evaluations. Additionally, we build our framework to be rapidly extensible and adaptable for future uses. The survey data from our paper can be found at GERBIL's [GitHub repository.](https://github.com/AKSW/gerbil/blob/master/documentation/survey.csv "GitHub repository") #### Contributors - Ciro Baron (University Leipzig, Germany) - Andreas Both (R&D, Unister GmbH, Germany) - Martin Brümmer (University Leipzig, Germany) - Diego Ceccarelli (Unversity Pisa, Italy) - Marco Cornolti (University of Pisa, Italy) - Didier Cherix (R&D, Unister GmbH, Germany) - Bernd Eickmann (R&D, Unister GmbH, Germany) - Paolo Ferragina (University of Pisa, Italy) - Christiane Lemke (R&D, Unister GmbH, Germany) - Andrea Moro (Sapienza University of Rome, Italy) - Roberto Navigli (Sapienza University of Rome, Italy) - Francesco Piccinno (University of Pisa, Italy) - Giuseppe Rizzo (EURECOM, France) - Harald Sack (HPI Potsdam, Germany) - René Speck (Institute for Applied Informatics, Germany) - Raphaël Troncy (EURECOM, France) - Jörg Waitelonis (HPI Potsdam, Germany) - Lars Wesemann (R&D, Unister GmbH, Germany)
GERBIL is a general entity annotation system based on the BAT-Framework.
Spatial mapping framework for enriching RDF datasets with Geo-spatial information
The GeoLift project is upgraded to [DEER](http://aksw.org/Projects/DEER "DEER - RDF Data Extraction and Enrichment Framework")
Using Linked Data to Build an Observatory of Societal Progress Leveraging on Data Quality
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.
Intelligent Suite for Benchmarking SPARQL with Updates
##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) Manual: [https://github.com/AKSW/IGUANA/blob/develop/release/MANUAL%20(overhaul%20needed).pdf](https://github.com/AKSW/IGUANA/blob/develop/release/MANUAL%20(overhaul%20needed).pdf) Release: [https://github.com/AKSW/IGUANA/tree/develop/release](https://github.com/AKSW/IGUANA/tree/develop/release) Contact: [conrads@informatik.uni-leipzig.de](mail-to:conrads@informatik.uni-leipzig.de) Benchmark Results: [https://figshare.com/projects/IGUANA_2016/13276](https://figshare.com/projects/IGUANA_2016/13276)
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.
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.
the Linked Data Workflow Project ontology
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.
a statement-stream-based approach for gathering comprehensive statistics about RDF datasets
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.
N3 - A Collection of Datasets for Named Entity Recognition and Disambiguation in the NLP Interchange Format
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.
an RDF/OWL-based format that allows to combine and chain several NLP tools in a flexible, light-weight way
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.
Natural Language Interchange Format for Open German Governmental Data
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.
A semantic Wiki for collecting and sharing scientific meta-data such as CfPs, tool descriptions, research profiles, conference statistics etc.
Linked Open Data for supporting scientometric studies
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.
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.
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.
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 vocabularies:** Naturally, a major goal in the Semantic Web is to re-use existing vocabularies instead of creating them from scratch for each dataset. We detect the used vocabularies in a dataset, which allows to re-use test cases from a test case pattern library. - **Instantiate existing DQTPs:** The aim of DQTPs is to be generic, such that they can be applied to different datasets. While this requires a high initial effort of compiling a pattern library, it is beneficial in the long run, since they can be re-used. Instead of writing SPARQL templates themselves, an engineer can select and instantiate the correct DQTP. This does not necessarily require SPARQL knowledge, but can also be achieved via a textual description of a DQTP, examples and its intended usage. - **Write own DQTPs:** In some cases, test cases cannot be generated by any of the automatic and semi-automatic methods above and have to be written from scratch by an engineer. These DQTPs can then become part of a central library to facilitate later re-use.
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.
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 approach is very versatile and can be applied in a vast number of use cases. [rNews](http://dev.iptc.org/rNews "http://dev.iptc.org/rNews"), [Ontowiki](http://ontowiki.net/ "http://ontowiki.net/") and [Wordpress](http://wordpress.org/ "http://wordpress.org/") are three use cases of RDFaCE. RDFaCE-Lite =========== RDFaCE-Lite is a lite version of RDFaCE which is specifically developed to support the [rNews](http://dev.iptc.org/rNews "http://dev.iptc.org/rNews") standard for annotating news and blog posts. It supports user-friendly editing of entities by only one click. It also provides support for [Microdata](http://www.w3.org/TR/microdata/ "http://www.w3.org/TR/microdata/") (according to [Schema.org](http://schema.org/ "http://schema.org/")) as an alternative annotation format. The demo is available at [http://rdface.aksw.org/lite/](http://rdface.aksw.org/lite/ "http://rdface.aksw.org/lite/"). How to Use ========== The normal annotation process in RDFaCE consists of four steps: 1. Defining appropriate namespaces by clicking button. 1. Selecting a fragment of the text. 1. Assigning the subject (and type) to be used for the selected fragment by clicking button. 1. Inserting triples by assigning properties using button. Triples can be seen by launching the triple browser ( button). You can go to setting and select one or multiple NLP APIs plus your combination strategy to automatically annotate your content by clicking To see a report on the entities found by each API, you can press after determining your desired combination. To instantly add a triple using [rNews](http://dev.iptc.org/rNews "http://dev.iptc.org/rNews") vocabulary, just select a part of the text and then on the context menu (which appears on mouse right click) select your desired type or property. Download ======== You can download the beta version of RDFaCE from [here](https://bitbucket.org/ali1k/rdface/ "https://bitbucket.org/ali1k/rdface/"). RDFaCE is also available as a [Wordpress Plugin](http://wordpress.org/extend/plugins/rdface/ "http://wordpress.org/extend/plugins/rdface/"). Configuration ============= To configure RDFaCE plugin you need to follow the normal procedure of adding a plugin in Tiny MCE ([More info...](http://tinymce.moxiecode.com/wiki.php "http://tinymce.moxiecode.com/wiki.php")). To enable automatic annotation, you need to register for each API and get an API key for it. Then go to RDFaCE\php folder and open proxy.php file. In this file you can set API keys for your desirable enrichment APIs. You can register for current five available APIs at: - [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/signup/free "http://saplo.com/signup/free") - [Lupedia](http://lupedia.ontotext.com/ "http://lupedia.ontotext.com/") - [DBpedia spotlight](http://dbpedia.org/spotlight "http://dbpedia.org/spotlight") Then you need to go to rdface/js/util/config.php and set the path of your proxy file. Related Projects ================ - NIF ([http://aksw.org/Projects/NIF](http://aksw.org/Projects/NIF "http://aksw.org/Projects/NIF")) - FOX ([http://aksw.org/Projects/FOX)](http://aksw.org/Projects/FOX "http://aksw.org/Projects/FOX")
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.
is an editing solution for distributed and syndicated structured content on the World Wide Web
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.
Using the Web of Data for Evaluating the Research-Disease Disparity
# 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 science journals. 3. WHO's [Global Health Observatory](http://apps.who.int/ghodata/) (GHO), which contains statistical information regarding the mortality and burden of disease classified according to the death and DALY (disability-adjusted life year) estimates grouped by countries and regions. However, since GHO is not available as Linked Data, as the next step we devised a method for representing unstructured data as RDF. We devised a plug-in in [OntoWiki](http://aksw.org/Projects/OntoWiki) to represent statistical data from GHO as RDF. We used the Data Cube Vocabulary for this conversion. More information is present [here](http://aksw.org/Projects/Stats2RDF). In order to ensure the completeness, conciseness and consistency for the selected datasets our next step is to assess the data quality of the datasets. The next challenging step is to interlink the datasets for a number of concepts such as (a) countries, (b) diseases and (c) publications. The assessment of the disparity is then performed with a number of parametrized SPARQL queries. We evaluate the results wrt. information quality and interlinking precision. As a consequence, we are, for the first time, able to provide reliable indicators for the extent of the research-disease disparity around the world in an semi- automated fashion, thus enabling healthcare professionals and policy makers to make more informed decisions. # Further Information * [ReDD Observatory](http://redd.aksw.org/) - a user interface, which allows users to visualize the disparity for particular diseases and regions as well as drill-down to the underlying data such as trials and publications. * [SPARQL Endpoint](http://db0.aksw.org:8895/sparql) - query the integrated datasets. * [Sample SPARQL queries](http://redd.aksw.org/queries/) * [Interlinks between the three core datasets](http://redd.aksw.org/interlinks/) * [paper](http://svn.aksw.org/papers/2011/WWW_ReDD/public.pdf Accepted paper) at the [WI-2011](http://liris.cnrs.fr/~wi-iat11/WI_2011/) * [Poster presented at the ESWC 2011 Summer School](http://summerschool.eswc2011.org/sites/default/files/ReDD_Poster_ESWC2011.pdf) * [Presentation given at the WI-IAT 2011 conference held in Lyon](http://www.slideshare.net/amrapalijz/reddobservatory)
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.
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://saim.svn.sourceforge.net/svnroot/saim/trunk ") as URL 6. Choose "Finish"
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.
Semantic Clinical Registry System for Rare Diseases
#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)
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.
Semantically INterpreting user query towards question-Answering
[Here](http://www.youtube.com/watch?v=37IcIF6X0Kg&feature=youtu.be "") is a screencast explaining the functionality and usage of SINA.
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.
converting SPARQL queries to natural language
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)
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.
Adding a social dimension to the Linked Data Web
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.
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.
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.
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.
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.
# 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.
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.
Crowdsourcing the evaluation of Linked Data
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.
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](http://aksw.org/files/verilinks/stats/weka_features.arff "") Remark: Since people participated in the survey and played the game outside of the 3-day experiment phase, the raw data above are updated versions of those in the report. Survey Winners (those who agreed that we can publish their names): Gianluca Demartini, Kingsley Idehen, Joe Montibello, Michael Röder, Jakub Kotowski, Thomas Efer, Virginia Knight, Ruby, Florent Jochaud
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.
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.
an eclipse / Xtext2 based editor for RDF/Turtle files
# 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).
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.
Lightweight Text Analytics using Linked Data
conTEXT allows to semantically analyze text corpora (such as blogs, RSS/Atom feeds, Twitter or SlideWiki.org decks) and to visualize the results.
A Java library featuring tools for transparently boosting SPARQL query execution.
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.
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.
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.
Project under development seeking for investors.