Samuel's Project Blog

I was a bit worried over the performance of the RDF facilities in Bioclipse, as a SPARQL query for doing NMR Spectrum similarity search, including a numerical comparison (against datasets which are attached) were quite unsatisfactory, being some 2 orders of magnitude worse than some Prolog code I wrote for doing the same task (But of course, this might not be the way Pellet is optimized to work).

Anyway, when testing the same SPARQL query with Jena, I got some quite different results, as seen in the graph to the right; Jena in fact outperformed the prolog code! Interesting..

Test results

Pellet/SPARQL vs SWI-Prolog

So, while Prolog far outperformed Pellet for the task (at least when Pellet was to do it using SPARQL) ...

Jena/SPARQL vs SWI-Prolog

... at the same time Jena outperforms Prolog, running the same SPARQL query above. Interesting!

In Tabular form

Code

SPARQL Query

PREFIX owl: <http://www.w3.org/2002/07/owl#> 
PREFIX afn: <http://jena.hpl.hp.com/ARQ/function#> 
PREFIX fn: <http://www.w3.org/2005/xpath-functions#> 
PREFIX nmr: <http://www.nmrshiftdb.org/onto#>  
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
SELECT ?s ?s1 ?s2 ?s3
WHERE {
  ?s nmr:hasPeak [ nmr:hasShift ?s1 ] , 
                 [ nmr:hasShift ?s2 ] , 
                 [ nmr:hasShift ?s3 ] . 
FILTER ( fn:abs(?s1 - 17.6) < 0.3 && 
         fn:abs(?s2 - 18.3) < 0.3 && 
         fn:abs(?s3 - 22.6) < 0.3 ) 
} LIMIT 1"

Prolog code

findMolWithPeakValsNear( SearchShiftVals, Mols ) :-    
  % Pick the Mols in 'Mol', that match the pattern:    
  %   listPeakShiftsOfMol( Mol, MolShiftVals ),
  %   containsListElemsNear( SearchShiftVals, MolShiftVals )    
  % and collect them in 'Mols'.
  setof( Mol,     
         ( listPeakShiftsOfMol( Mol, MolShiftVals ),         % A Mol's shift values are collected  
   containsListElemsNear( SearchShiftVals, MolShiftVals ) ), % ...and compared against the given SearchShiftVals
   [Mols|MolTail] ).                                         % In 'Mols', all 'Mol's, for which their shift     
                                                             % values match the SearchShiftVals, are collected. 
% Given a 'Mol', give it's shiftvalues in list form, in 'ListOfPeaks'
listPeakShiftsOfMol( Mol, ListOfPeaks ) :-
  hasSpectrum( Mol, Spectrum ),
  findall( ShiftVal,     
           ( hasPeak( Spectrum, Peak ),
             hasShiftVal( Peak, ShiftVal ) ),     
             ListOfPeaks ).    
 
% Compare two lists to see if list2 has near-matches for each of the values in list1
containsListElemsNear( [ElemHead|ElemTail], List ) :-    
  memberCloseTo( ElemHead, List ),
  ( containsListElemsNear( ElemTail, List );    
    ElemTail == [] ).  
 
%%%%%%%%%%%%%%%%%%%%%%%%
% Recursive construct: %
%%%%%%%%%%%%%%%%%%%%%%%%
% Test first the end criterion:
memberCloseTo( X, [ Y | Tail ] ) :-    
  closeTo( X, Y ).
% but if the above doesn't validate, then recursively continue with the tail of List2:
memberCloseTo( X, [ Y | Tail ] ) :-    
  memberCloseTo( X, Tail ).    
 
% Numerical near-match    
closeTo( Val1, Val2 ) :-
  abs(Val1 - Val2) =< 0.3.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Convenience accessory methods %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hasShiftVal( Peak, ShiftVal ) :-  
rdf_db:rdf( Peak, 'http://www.nmrshiftdb.org/onto#hasShift',
literal(type('http://www.w3.org/2001/XMLSchema#decimal',
ShiftValLiteral))),
  atom_number_create( ShiftValLiteral, ShiftVal ).        
hasSpectrum( Subject, Predicate ) :-    
  rdf_db:rdf( Subject, 'http://www.nmrshiftdb.org/onto#hasSpectrum', Predicate). 
hasPeak( Subject, Predicate ) :-
  rdf_db:rdf( Subject, 'http://www.nmrshiftdb.org/onto#hasPeak', Predicate).

% Wrapper method for the atom_number/2 method which converts atoms (string constants) to number.    
% The wrapper methods avoids exceptions on empty atoms, instead converting into a zero.    
atom_number_create( Atom, Number ) :-     
  atom_length( Atom, AtomLength ), AtomLength > 0 -> % IF atom is not empty 
  atom_number( Atom, Number );                       % THEN Convert the atom to a numerical value     
  atom_number( '0', Number ).                        % ELSE Convert to a zero

Attached files

Attached are the datasets (nmrshiftdata10...100.rdf.xml) for the different number of spectra, and the Bioclipse JavaScript files for the tests (NMR.Pellet.js, NMR.Jena.js and NMR.Swipl.js, as well as NMR.Pellet.Init, which I used for preparing the RDF stores for both Jena and Pellet).

It just struck me a very simple way of storing prolog code inside Bioclipse scripts, avoiding the need for a separate file containing the Prolog code. This might be very useful when using prolog as a kind of "query language" somewhat analogous to how SPARQL is used.
(Update: Prolog in fact turns out to be more powerful than SPARQL in this regard, as shown by the observation in this blog post, that SPARQL doesn't support backtracking).

The idea would be to simply store the prolog code in Bioclipse JS variable, and create a special manager method that can write such prolog query-code containing variables to a temporary file in the workspace and then just telling Prolog to "consult" that file, thereby "feeding the prolog engine" with the logic to use, from inside Bioclipse scripts.

I started with some initial performance testing for RDF data, between pellet an prolog, which are now both available integrated in Bioclipse.

A strategy for how to work with the Bioclipse/JPL/Prolog/Blipkit combination I'm setting up, is becoming clear.

The main idea with Bioclipse, as well as with having a prolog engine available in it, is for flexible and "interactive" knitting together of knowledge. One of the main questions regarding how to use a Bioclipse/JPL/Prolog/Blipkit combination, has been where to put the bulk of knowledge integration/reasoning code? There would in principle be three options for that:

1. Bioclipse (Javascript environment)
2. The Blipkit-Prolog/Bioclipse integration plugin (Java code, a.k.a. "Manager methods")
3. The prolog engine (As a prolog file)

Using SWI-Prolog's semweb package, I had extracted all predicates in a RDF source, containing some 1 million triples, into the following list: