In my last post, I doubted the accuracy of fingerprint based substructure search and pointed out sometimes fingerprint loosed hits. In fact, something went wrong in my code. As I was reading from SDF directly, while IteratingMDLReader does not percieve atom type or detect aromaticity automatically. This cause the incorrect matchings of UniversalIsomorphismTester, sorry for the incorrect post. I’ve run the test again, using the SMILES provided by Guha as input. The groovy script is also attached here.

#	Query	Subgraph Isomorphism	Entended CDK	Missing	Extra
1		20	24	0	4
2		7	103	0	96
3		69	100	0	31
4		6	10	0	4
5		31	41	0	10
6		23	23	0	0
7		7	75	0	68

Well, CDK fingerprint is OK.

Abstract: Doubting on the accuracy of fingerprint based molecule substructure search, I did a test between different fingerprints implemented in CDK and subgraph isomorphism. The result is very interesting, CDK fingerprints should never be used alone in substructure search, but combine CDK fingerprints and subgraph isomorphism, we can have a balance between speed and accuracy.

Backgournd

Guha wrote a post about benchmarking of different type of fingerprints with benchmarking strategies described by Bender & Glen and Godden et al. The benchmark is based on Tanimoto similarity, which is the foundation of most chemistry database’s similar structure search. Another impo

rtant feature of molecule structure search is substructure, currently, subgraph isomorphism and fingerprint are both used in substructure search. Adel Golovin and Kim Henrick’s article Chemical Substructure Search in SQL provides a pure SQL subgraph isomorphism strategies, Rich Apodaca’s post fingerprint based MySQL substructure search in MySQL also found a solution with limited binary operation in MySQL.

Fingerprint is obviously faster as it’s much less consuming than subgraph isomorphism. But the real question is, does the fingerprint method really find all the substructures? Are there any hits misjudged as substructure?

Method

Using DrugBank small molecule drugs as test dataset, several hand-draw structures of different types as queries, I performed substructure search using subgraph isomorphism and fingerprints implemented in CDK. If a hit in search results of fingerprint method is also found in search results of subgraph isomorphism method, I count this hit as a correct hit, other wise the hit will be counted as a incorrect hit.

All fingerprints implemented in CDK are tested, generated using Fingerprinter, ExtendedFingerprinter, GraphOnlyFingerprinter, SubstructureFingerprinter, MACCSFingerprinter and EStateFingerprinter. All parameters are kept default.

To test the accuracy of queries with different complexity, I drew several structures, as listed below.

Result

The result is listed below. The result is listed in the format of “A/B”. A represents current hits, i.e. hits also founded by subgraph isomorphism method. B represents incurrent hits. For example, 31/49 stands for 31 current hits and 49 incurrent hits are found. Higher A and lower B is better.

#	Query	Subgraph Isomorphism	EState	MACCS	Standard CDK	Entended CDK	Graphonly CDK FIngerpint	Substructure Fingerprint
1		31	0/0	0/43	31/49	31/54	31/574	0/0
2		54	0/0	0/1	21/95	18/84	54/1512	11/30
3		29	0/0	0/20	29/74	29/83	29/1793	0/5
4		3	0/0	0/85	3/6	3/3	3/36	0/4
5		31	0/0	29/93	31/14	31/13	31/1593	27/53
6		23	0/0	0/0	23/0	23/0	23/23	0/0
7		9	0/0	0/0	8/83	8/63	9/237	5/40

Conclusions & Questions

As we can see from the table, MACCS, Estate and Substructure Fingerprint  perform very bad, they found very little hit, sometimes no hit at all. They are not designed to do this task, it’s not amazing to see this result.

For standard and extended CDK fingerprint, sometimes standard one works better(Maybe I should use longer extended fingerprint rather than the default length, as discussed in Guha’s post). On queries of complex ring system, extended CDK fingerprint works better, but not a obvious advantage.

But I wonder why hashed fingerprint still miss some result, (see query 2 and query 7)? Why the superstructure doesn’t share the same bits with substructure? Is this because the structure is too simple?

As many incurrent hits are found, CDK fingerprints should never be used alone in substructure search. But please consider combine CDK fingerprints and subgraph isomorphism, do fingerprint search first, we can avoid performing the consuming subgraph isomorphism match on all targets, thus we can have a balance between speed and accuracy in that way.

OK. Let’s go and see how does this works.

NOTE: I choose MySQL as the development platform, SQL statements may need a little change to work on other RDBMSs. But I’m sure SQL statements for other platform will be included in the final release, as my goal is support all major RDBMSs including MySQL, PostgreSQL, Microsoft SQL Server, Oracle and IBM DB2(if possible).

If we had a database named “a_chemical_database” and a table named “molecules”.

mysql> use a_chemical_database;
mysql> SELECT * FROM molecules;
+----+-----------+-----------+-----------+
| id | smiles    | property1 | property2 |
+----+-----------+-----------+-----------+
|  1 | Cc1ccccc1 | 84        | liquid    |
|  2 | CCC       | 36        | gas       |
+----+-----------+-----------+-----------+
2 rows in set (0.00 sec)

In the table “molecules” structure information, the “smiles” column, and other properties exist. There’s nothing different between this table and common SQL tables, i.e. you don’t need to specially design your SQL tables to do structure search.

We want our search engine to know where the modification occurs if someone changed the data. It’s possible to monitor the “molecules” data directly intermittently, but this will be a very consuming task if you have a really big table. With triggers, we can know which kind of modification(INSERT, UPDATE or DELETE) is performed on which row exactly. Before we can create triggers, a table to log the modifications needs to be created.

mysql> CREATE TABLE `syncs` (
    ->   `id` int(11) NOT NULL auto_increment,
    ->   `mod_action` varchar(10) default NULL,
    ->   `prim_key` int(11) default NULL,
    ->   PRIMARY KEY  (`id`)
    -> );

In the table “syncs”, we can store which the type of modification(column “mod_action”) and the row (column “prim_key”).

If data in the “molecules” table is changed, we expect a new record inserted into the “syncs” table, for example,

mysql> SELECT * FROM syncs ;
+----+------------+----------+
| id | mod_action | prim_key |
+----+------------+----------+
|  1 | INSERT     |        2 |
|  2 | UPDATE     |        2 |
|  3 | DELETE     |        1 |
+----+------------+----------+

Now we create triggers.

CREATE TRIGGER molecules_insert AFTER INSERT ON molecules
FOR EACH ROW INSERT INTO syncs(mod_action,prim_key) VALUES('INSERT',NEW.id);
CREATE TRIGGER molecules_update AFTER UPDATE ON molecules
FOR EACH ROW
BEGIN
IF  NOT(OLD.smiles LIKE NEW.smiles)  THEN
INSERT INTO syncs(mod_action,prim_key) VALUES('UPDATE',NEW.id));
END IF;
END;
CREATE TRIGGER molecules_delete AFTER DELETE ON molecules
FOR EACH ROW INSERT INTO syncs(mod_action,prim_key) VALUES('DELETE', OLD.id);

Here we’ve done. Let’s do something on the “molecules” table and see what happens.

mysql> INSERT INTO molecules(smiles) VALUES("CC=CCN");
mysql> UPDATE molecules SET smiles='CC1CCC1' WHERE id=2;
mysql> DELETE FROM molecules WHERE id=3;

mysql> SELECT * FROM syncs;
+----+------------+----------+
| id | mod_action | prim_key |
+----+------------+----------+
|  6 | DELETE     |        3 |
|  5 | UPDATE     |        2 |
|  4 | INSERT     |        3 |
+----+------------+----------+
3 rows in set (0.00 sec)

The trigger successfully monitored the modifications.

Many methods of doing substructure search directly in SQL has been reported recently, Adel Golovin and Kim Henrick’s Chemical Substructure in SQL, Rich Apodaca’s fingerprint based MySQL substructure search in MySQL, and Charlie Zhu’s Microsoft SQL Server based substructure search with SMARTS support.

Doing this in RDBMSs do have a number of advantages, “including platform independency, simplicity, flexibility, integrity, robustness and single point of failure”, as Adel and Kim describes. But some light weight RDBMSs such as MySQL and PostgreSQL, the most widely used open source ones, provide very limited SQL programming function, a pure SQL based solution may be impossible.

Plugins are developed to enhance the functionality. For MySQL, there’s an open source project called mychem. For PostgreSQL, there’s pgchem:tigress which is also open source. Both of them is based on OpenBabel, a C++ chemoinformatics library.

On Oracle platform, there’re CambridgeSoft Oracle Cartridge, Symyx Direct, JChem Cartridge(may be free for academic or non-commercial use), etc.. As Oracle is a commercial platform, not of these above is free.

When I was developing chemsoso.com, a Chinese chemical supplier database, structure search feature is an important problem to be solved. The database contains 90,000 different chemicals in total and still growing, performance needs to be carefully dealt with.

In consideration of speed, fingerprint is obviously the best choice. It takes time to generate fingerprints, but in the search stage, bit operation are much less consuming than graph matching. My initial idea is to generate fingerprint in Java and do bit operation in MySQL. Unfortunately, MySQL has restrictions on bit operation, it limit the maximum range to 64 bits. In Rich’s solution, fingerprint is separated into multi fileds to satisfy MySQL’s requirement. Substructure search is possible in this method. But similar search where Tanimoto coefficient needs to be calculated is still impossible, as more bit operation function is missing in MySQL.

In my final solution, a in-memory fingerprint index outside MySQL is created. Molecule structure information(SMILES or mol file) is stored in MySQL, my search engine synchronize data between the in-memory index and MySQL table. Structure searching is performed directly on the in-memory index, this guarantee the performance. On a MacBook with 1.83GHz CPU, it only takes about 50ms to do substructure search on chemsoso.com’s 90,000 structures. For similar structure search, it takes about 300ms, for full structure search, the time is less than 10ms. If search boundary if set according to similarity requirement, we can have another 4X to 100X performance improvement depends on the complexity of the query molecule structure.

Several days ago, Charlie Zhu talked to me, wondering how chemsoso.com’s structure search engine works. As the structure was mainly built from open source libraries, I decide to make the search engine open source to ease the work of building chemistry related database. With the search engine released, developers can focus the database’s own functionality, instead of dealing with structure search.

Before I can release the search engine, I have to find a way to cut in users’ system in the form of plugin. Including source code directly into users’ project may be the fastest way to add structure search functionality, but my code is in Java does not means everyone’s project is in Java. I want the search engine works not only with all major RDBMSs, but also all major OSs and all major programming languages. Besides Java API, command-line API and HTTP API will also be provided to make sure the search engine works with multi programming language and network environment where server clusters exists.

很多人都说Apple很封闭。但是看看apple的很多重要系统都和开源世界有精密联系。而看看微软，其实在这一点上远不如apple。

其实封闭和开放应该从不同的角度去看待。微软对底层核心技术很封闭，但是对第三方合作伙伴看起来就比较开放。Apple的封闭似乎更体现在对最终用户体验的严格掌控上。用jobs的话说：如果不明确所有的最终细节，我不知道该怎么保证优秀的用户体验。

这世界就是这样，各取所需就好了。

感谢bitcowboy的精彩言论

jsMolEditor is different from all the normal input plugins. It’s in pure JavaScript, you don’t need any runtime installed. It simply works on all modern web browsers, including Firefox, Safari, Chrome, Opera and Internet Explorer(workable though slow).

Online demo and download is at http://chemhack.com/jsmoleditor/

So, have a look.

Today, I got something to show you.

Have a look at renderer and editor demo here.

You can click the first two buttons to load a demo structure with different sizes, and you can read a demo molecule. You can move your mouse on atoms, drag the editor on atoms and in white space to see what happened. If you’re using IE, especially IE6, the dragging process may not be so smooth, as IE is famous for its super slow JavaScript engine.

OK, what happened after you clicked the buttons. The buttons for loading editor have a onClick attribute with JavaScript below.
initEditor('editor1',500,300);
And behind this function is:
function initEditor(divID,width, height){
if(window.__initEditor){
document.getElementById(divID).innerHTML="";
__initEditor(divID,width, height);
}else{
document.getElementById(divID).style.width=width+"px";
document.getElementById(divID).style.height=height+"px";
document.getElementById(divID).innerHTML="Loading...";
setTimeout(function(){initEditor(divID,width, height);}, 1000);
}
}

And this in GWT Java code:

private static native void injectJSMethods()/*-{
$wnd.__readMolFile =function(divID,fileContent){
@com.chemhack.jsMolEditor.client.Editor::readMolFile(Ljava/lang/String;Ljava/lang/String;)(divID,fileContent);
};

I think Rich’s problem has been partly solved as this proves how we can cross the boundary between hand-written JavaScript and GWT generated JavaScript. If you’d like to make the whole library exposed to JavaScript world, just write a wrapper for each Java method you’d like to call. GWT code generator may be a good helper.

I call this molecule editor jsMolEditor, and I plan to release its first fully functional Alpha version in two or three weeks. jsMolEditor will be released under GPL license as its code mainly came from MX-GWT and JChemPaint.

So how about JMol in javascript? This demo shows that it’s not a mission impossible, but we have a long way to go.

I promise to release the first Alpha in two or three weeks and also keep you informed how is the work going with at least two posts per week.