As I know nearly nothing of at least two of the languages above (Arabic and Chinese), I had to keep rechecking the content provided to ensure the right text ends up in the right place on a page. Google Translate helped with that by back-translating from another language back into English and making sure I got right sentence boundaries, etc.

However, even with content in the right place, I still needed to visually verify that things are correct. Also, some of the late arriving changes needed to be implemented for all 6 sets of files. For example, some of the URLs changed, some classes for javascript enhancements were added or removed, and so on.

Initially, I tried to check things in the editor by using regular expressions. This worked for basic things, but as the project progressed and markup (and javascript enhancements) became more complex, the regular expressions became not sufficient. I needed something that understood HTML structure and could easy to run interactively.

I already was using jQuery for progressive enhancement and my Firefox always has Firebug setup. And I have been poking at random web-pages with jQuerify bookmarklet for ages. But with this project, jQuery+Firebug combination of tools has now graduated to a 1st class development and troubleshooting toolkit specifically for multi-lingual content.

Here is a couple of basic queries I run in Firebug console window:

• I had most of the links going to a new window and needed to check I did not miss a target attribute: $(”a[target != '_blank']“)
• When comparing languages side-by-side, I needed to see whether URL links were the same. The easiest way to do that was by looking at where those links were actually pointing out. I could of course select an element with Firebug to see all of its content, but it was easier to print a particular attribute automatically, when I hovered over it with a mouse: $(”a”).mouseenter(function(){console.log( $(this).attr(’href’));})
• If I quickly needed to check which elements were affected by a particular class, I would just highlight them: $(”.NYOnly”).css(”background-color”, “red”)

None of these are hidden secrets, however it may not always be obvious what can be done and how far a couple of lines of jQuery code can go. Here is an example that gets pasted right into Firebug window. It uses jQuery-translate extension to hook into Google Translate API and prints out translated content of a table cell that is clicked on:

$.getScript('http://jquery-translate.googlecode.com/files/jquery.translate-1.3.9.min.js');

$(”td”).click(function(){
$(this).translate(’ar’, ‘en’, {
replace: false,
each: function(i){console.log( this.translation[i] ) }
})
});

But, every time I put this particular tool aside, I know that picking it back up will be like making up after a bad break up. Things feel familiar, but you are still so uncomfortable you cannot get anything working. Only knowing how great the tool is underneath, makes me go through the effort of re-familiarization.

I just downloaded ANTLR 3.1.2 bundled with its own GUI ANTLRWorks that offers visual diagrams, debugger and templates. You would think that would make for an easy out-of-box experience. You would be wrong.

You start the GUI and end up facing a blank screen. Lots of options and tabs for sure, but the only easy start one seems to be ‘Insert rule from template’.

Ok, so here is a couple of rules from templates trying to parse “Hello World!” string:

ID    :    LETTER (LETTER | DIGIT)*
;
LETTER
:    ‘a’..’z’ | ‘A’..’Z’
;

DIGIT    :    ‘0′..’9′
;

WS    :    (’ ‘ | ‘\t’ | ‘\n’ | ‘\r’) { $setType(Token.SKIP); }
;

Not good. We are missing a start state apparently. Ok, let’s add one:

hello    :    ID ID ‘!’
;

Still no good. Start looking at examples, trying to see what bits are compulsory. Ok, the word grammar is missing at the top of the file. Of course, I have both grammar and lexer elements now in one file (ANTLR 3 feature, I believe), but let’s not worry about deep meaning here.

grammar test;

Now, suddenly, syntax diagram starts showing up. Let’s try saving (as test.g) and compiling. No good:

The following token definitions can never be matched because prior tokens match the same input: LETTER

So much for following a template. More digging in examples. Memory really starts to bring back the Dragon Book’s lessons. What’s the problem with LETTER and who is the prior token here. Ah, we don’t want the lexer to return LETTER (or DIGIT), only ID. So, LETTER and DIGIT are both token fragments, not tokens. Add fragment in front of both definitions. All good?

Nope! Now we have a problem with:

attribute is not a token, parameter, or return value: setType

But I did not write setType, the template provided it! Back to the examples! Apparently, somewhere along the way Skip tokens have gone away and we now have hidden channels instead. Swap that bit with one from an example and try again.

SUCCESS. Switch to interpreter, enter “Hello World!” in input box and run hello rule. Beauty, we have a parse diagram.

The final running grammar example is here:

grammar test;

hello    :    ID ID ‘!’
;

ID    :    LETTER (LETTER | DIGIT)*
;
fragment LETTER
:    ‘a’..’z’ | ‘A’..’Z’
;

fragment DIGIT    :    ‘0′..’9′
;

WS    :    (’ ‘ | ‘\t’ | ‘\n’ | ‘\r’) {  $channel = HIDDEN;  }
;

Hello World! Now, on to the real grammar and (if things really, really work) GATE integration…..

In the United Nations corpus, things can get even more interesting. Let’s look at a relatively easy example: draft resolution A/56/L.28 and Add.1.

Is this a one document (one draft resolution) or two? And if two, then which two? The first one is obviously A/56/L.28. But Add.1 is not a valid document symbol, it is actually an (additive?) coreference to the first one and resolves to A/56/L.28/Add.1?

The answer (as good as I can make it so far) could lie in FRBR distinction between Expression and Manifestation. A resolution is an expression of Member States’s proposals and negotiations. To some degree, it evolves over several meetings. However between the discussions, the latest version or changes need to be reported to make sure they are formally registered and also to ensure the next round of discussions could have latest documents to work from.

In our case, the first time the draft resolution had to be presented it was published under A/56/L.28 (which incidentally means a limited distribution document 28 of the General Assembly’s 56th regular session). So, the initial Manifestation of the draft resolution became this physical document with a distinct symbol assigned.

But apart from its text, draft resolution has a list of sponsoring Member States. That list can change as draft resolution gains sponsors. These additional sponsors were in the Addendum A/56/L.28/Add.1. But the addendum does not make sense without the original document, so actually both physical documents represent one logical draft resolution, which is reflected in the grammar of the text (draft resolution, not resolutions).

What this means for named entity annotations and for recognition algorithms is hard to say and is something I am looking at with my PhD research.

One of such tools is Exhibit, one of graduates from SIMILE project. It allows to do a very interactive webpage driven by just HTML+Javascript, with no server-side component required. I really like SIMILE’s tools, even though it feels like development slowed somewhat recently.

There is an example of how to import and display bibtext within Exhibit. It is not difficult, just a couple of steps. It must have been a popular section, as there is now a dedicated new tool for it.

Citeline Exhibit Builder allows to load in bibtext and presents editing interface to customize Exhibit’s presentation of the publications. It looks great and seem to work well. A nice aspect is that it allows to chose which bibtext fields to expose as filter facets. With original tutorial that would require html editing and understanding Exhibit mindset. Citeline nicely hides user from it.

There was a couple of small problems. Apparently, there is a way to login and ‘claim’ your presentation. I couldn’t test that as OpenID authentication failed (something about a nonce). Also, there is jsMath library but, once the generated Exhibit is downloaded, it fails with cross-server issues. Finally, as with most end-to-end solutions, it does not do data preprocessing/normalization to allow me, for example, to combine author/editor fields for sorting purposes.

Citeline is a very promising tool and I am certainly going to keep it in mind for publishing my bibliographies.

Nice as CiteULike is, it is fairly difficult to get an overall picture of one’s own collection. It is especially difficult to see quickly if there are people who serve as hubs by collaborating with multiple different groups. The information is there, but it requires a lot of clicks to find it out.

My usual solution is to export information out, massage it into Graphviz format and use graph segmentation and layout algorithms to get a better overview. I have talked about Graphviz a number of times on this blog before. This is yet another time it proved useful.

I started by exporting CiteULike’s content of my library. I found Endnote export format to be more structured and therefore easier to parse. I then run it through a custom Python program that basically spat out graph with titles pointing at authors. That produced a very large graph and was not particularly useful.

The next step was to discover disjointed clusters of titles/authors. I used ccomps with -v and -x flags (e.g. ccomps.exe -v -x -o comp.dot output.dot).

ccomps gave me partitioned graphs as well as statistics on number of nodes/edges in each graph. I could then choose a graph with large number of nodes/edges (eventually, all of them) and run it through neato with overlap=scale and splines=true (e.g. neato.exe -Tgif -o neato_1.gif -Goverlap=scale -Gsplines=true comp_1.dot).

The resulting graph was still not perfect, but it was a good start. I also tried fdp instead of neato, but that seemed to produce giraffe versions of the graph with graph edges being overly long.

You can see an example of neato output for one of my clusters. Warning: if it causes problems due to its size, try it with IrfanView; that program can display even improbably large graphs (e.g. unpartitioned ones).

I have run into some problems as well that would either cause partitions combine together or produce duplicate nodes and edges.

The first problem was that sometimes a person was an author and sometimes an editor. I was interested in both, so collapsed those fields together. That caused some non-people to then show up on the graph and connect clusters in unexpected ways. For my library the specific value was ‘European’, so I filtered it out in the code.

The second problem was to do with CiteULike’s parsing. Sometimes, it would split a first+last name into separate names, probably due to incorrect manual entry at some point. I had to fix those at the source by editing corresponding CiteULike entry. Probably a good thing to do anyway.

The other problem is right out of the co-reference resolution domain. Sometimes names would include full first names, sometimes only a first name initial. I have worked around that by normalizing all first names to the initials. Obviously, this could collapse entries belonging to multiple real people into one.

Further on name problems, in cases of non English names (e.g. Spanish names with multiple surnames), CiteULike would get confused which part is which and not display or export it correctly. Additionally, sometimes characters such as ñ would be entered as plain n. Those also needed to be corrected manually.

The project only took a couple of hours including writing code and cleanup. It is already useful to me, as I found a new person who was in unexpectedly large number of papers and also found a chain of connections that might be interesting to follow more closely.

There is of course a lot more that could be done. Automatic co-reference of misspelt names, layout hints based on number of times authors appeared together, color coding of tags - these are just some of the easy ideas.

There might even be a small project/paper in doing co-reference resolution and cleaning up CiteULike data? After all, similar projects were done for Wikipedia. I don’t think CiteULike currently makes a full export available, but they do have some so might be amendable to exporting a special set for research purposes.

I am interested in both topics. I did 3 years as senior technical support at BEA and could see how applying NLP techniques on written notes in support cases could have improved quality of technical support. I did not get to do any of that, but some interest remains.

The second topic is even more interesting and important to me. It can build on current discussions currently held on blogs (see ‘The USES Issue‘ at Niels Ott’s blog) and in journals (see: ‘Empiricism Is Not a Matter of Faith‘ by Ted Pedersen). While some of the issues are discussed on mailing lists for individual pieces of software, a place to discuss cross-cutting concerns is very welcome.

I have joined the list and hope to see at least some of my readers there as well.

I have just gone through all of Jurix‘ proceedings as well as all of Artificial Intelligence and Law and all I got is between 2 and 4 articles worth following-up.

There must be somebody actually trying to parse real legal texts and figuring out to deal with complex organisation, people and group names. But all I can see is articles dealing with levels from ontology and up.

There might even be money in it!

One of the crazy business ideas I had was to parse all the web-based terms of use and privacy notices and annotate/crowd-vote them for how bad they are. So, before creating a web-based account, I could check it against database/parser and it would highlight and rate for me passages that I really should pay attention to (e.g. we sell your contact details to every spammer we know ). Since the language of those notices is often ritualistically formulaic, extracting interesting and useful summary would actually be simpler than it looks.

And the business model would center on providing automatic notification option if a notice from subscribed website sneakily changed and became much worse. That way one would pay money for peace of mind that there were no unexpected service rule changes.

I used to be a subscriber. But I got annoyed by a large number of ads, deliberate and unnecessary foul language and subscription inserts advertising $8 new subscriptions. So, I did not renew early.

Renewal notices starting arriving and that’s where things got weird. The first renewal notice was for $12, not $8 as I was expecting. I figured they may have pushed the prices up and that next magazine’s subscription insert would be $15 with renewal offer at $12. Nope! The next magazine still had 6 inserts with $8 offer.

The next renewal notice had a slightly panicked tone. It called me a valuable subscriber. But it was still $12. The third notice appealed to my need as a professional to know what Wired thinks is cool. It obviously thought I was too busy a professional to remember price point differences.

Finally, they got to me. I did not renew, but instead emailed their subscription support asking about the price difference. Tammi from Wired replied:

Thank you for contacting us concerning a lower subscription price that you have recently seen. We have many different offers to attract new subscribers.  These offers can also be available to you.  Please respond with your special offer information and we will be happy to enter your subscription.

That was so weird, I eventually got their Consumer Marketing Director reply:

Your recent email was routed to my office.  I regret that you were offended by seeing an $8 per year subscription offer on an insert card in your copy of Wired.  The explanation is that we periodically test different price points, both higher and lower,  and that is why your subscription copy carried that more discounted offer.  Let me assure you that had you requested the 12/$8 offer, we would have honored your renewal order at that rate rather than the higher priced offer you received with your renewal communication.   We do value our long term subscribers and as a courtesy, along with my apologies, I would be happy to offer you a complimentary year’s subscription.

I thought about it and figured I was really bothered by their version of valuing long term subscribers and refused to renew at any price. My complaint was never about price, just about being treated as captive audience and a stupid one.

That was 6 months ago. Yesterday I got another email from them. They want me back. At $12/year. The online price is $10. This is now SPAM. I made sure GMail knows that.

So it is always good to see people who can explain what POS tagger is and why it is important without having to throw around references to Norvig or Jurafsky.

Markus Dickinson has managed to do exactly such explanation in his non-linguistic primer to a serious research paper on Detecting Errors in Part-of-Speech Annotation. The writing is quite old (2003), but it reads well and still feels relevant. Of course, his research page contains more recent papers on the same topic too.

(via Hacklog)

I could not figure out where to even start troubleshooting this issue, until I noticed that the problem only happens while I am running on battery and not when I am connected to the mains. Once I notice that, the solution was simple - power management module must have been too eager and turning off wireless after 30 seconds of inactivity. Given that I was trying to read emails or webpages, that would occur fairly regularly.

The fix is to go to the power-management control panel and adjust on-battery behaviour to match the full-power one. I am putting this out because an hour of searching for this problem online did not bring any result. I hope the next person to be flummoxed by this repeated connection loss will find my blog entry fast.