One of my customer’s team member had destroy the Hyper-V Cluster by mistake. He formatted the cluster nodes without evict them before doing that . The nodes of the clsuter used to be  part of old cluster that was destroyed by mistake.

I tried to build the nodes again from the scratch and Create new cluster, When I run the validation wizard I got this error:

Cluster disk with identifier (identifier) has a persistent reservation on it ,the disk might be part of other cluster. removing the disk from other validation set.

My SAN is HP EVA. The Cluster is not able to see any of my LUNS although I can see them from disk management and can’t create the cluster.

This error due to the fact that the LUNs still keeping the old identifiers from the old cluster, You have to use Cluster command line to clear the reservation by that command:

cluster.exe node %nodename% /clear:disknumber

Now everything should work fine and you can pass the validation wizard

Filter terms in NextBio offer a fast way to know the expertise of an author at a glance.

Tags size are proportional to relevance of keywords…

For e.g.:

http://www.nextbio.com/b/search/author/A%20Yonath

A. Yonath is one of the 3 latest Nobel (Chemistry) for mapping
the ribosome at the atomic level.

P.S.: NextBio clustering features are also used in ScienceDirect…

http://www.info.sciencedirect.com/using/searching-linking/nextbio/

This distributed computing project aims to develop a distributed machine learning approach. In machine learning, there are two types of learning, supervised and unsupervised. In supervised learning, we attach labels to the data and try to attach labels or class to newcoming data. Classification is such a problem. Unsupervised learning is trying to understand your data and provide valuable information about it. Clustering is one of the examples of unsupervised learning where you don’t attach any label about your data points.

K-Means Clustering approach first selects K data points as clusters and attachs the closest data point to this class according to a distance measure such as Euclidean distance. Then we calculate the centroid of each cluster and reapply the procedure to calculate the cluster. At the end the clusters will converge and centroids will not change. We will use the last snapshot as our clusters and assign colours to each data point according to its cluster where it is closest to.

Map-Reduce version of clustering algorithm will be based on Map and Reduce algorithm style. In Hadoop there is tasktracker and under his control, nodes of processing map and reduce operations. By this way, calculating clusters and centroid will be done by Map operations and combining these will be based on Reduce operations. After running this clustering approach successfully on a standalone Hadoop, we will extend it to a three VM cluster. Then after having this successful on a dataset such as wikipedia, if possible we will try to make this work on the 100-node cluster at the department in a two-three week time.

]]> http://chemoton.wordpress.com/2009/11/24/1366/ Mon, 23 Nov 2009 23:04:59 +0000 Vitorino Ramos http://chemoton.wordpress.com/2009/11/24/1366/

Figure – Book cover of Toby Segaran’s, “Programming Collective Intelligence – Building Smart Web 2.0 Applications“, O’Reilly Media, 368 pp., August 2007.

{scopus online description} Want to tap the power behind search rankings, product recommendations, social bookmarking, and online matchmaking? This fascinating book demonstrates how you can build Web 2.0 applications to mine the enormous amount of data created by people on the Internet. With the sophisticated algorithms in this book, you can write smart programs to access interesting data-sets from other web sites, collect data from users of your own applications, and analyze and understand the data once you’ve found it. Programming Collective Intelligence takes you into the world of machine learning and statistics, and explains how to draw conclusions about user experience, marketing, personal tastes, and human behavior in general — all from information that you and others collect every day. Each algorithm is described clearly and concisely with code that can immediately be used on your web site, blog, Wiki, or specialized application.

{even if I don’t totally agree, here’s a “over-rated” description – specially on the scientific side, by someone “dwa” – link above} Programming Collective Intelligence is a new book from O’Reilly, which was written by Toby Segaran. The author graduated from MIT and is currently working at Metaweb Technologies. He develops ways to put large public data-sets into Freebase, a free online semantic database. You can find more information about him on his blog:  http://blog.kiwitobes.com/. Web 2.0 cannot exist without Collective Intelligence. The “giants” use it everywhere, YouTube recommends similar movies, Last.fm knows what would you like to listen and Flickr which photos are your favorites etc. This technology empowers intelligent search, clustering, building price models and ranking on the web. I cannot imagine modern service without data analysis. That is the reason why it is worth to start read about it. There are many titles about collective intelligence but recently I have read two, this one and “Collective Intelligence in Action“. Both are very pragmatic, but the O’Reilly’s one is more focused on the merit of the CI. The code listings are much shorter (but examples are written in Python, so that was easy). In general these books comparison is like Java vs. Python. If you would like to build recommendation engine “in Action”/Java way, you would have to read whole book, attach extra jar-s and design dozens of classes. The rapid Python way requires reading only 15 pages and voila, you have got the first recommendations. It is awesome!

So how about rest of the book, there are still 319 pages! Further chapters say about: discovering groups, searching, ranking, optimization, document filtering, decision trees, price models or genetic algorithms. The book explains how to implement Simulated Annealing, k-Nearest Neighbors, Bayesian Classifier and many more. Take a look at the table of contents (here: http://oreilly.com/catalog/9780596529321/preview.html), it does not list all the algorithms but you can find more information there. Each chapter has about 20-30 pages. You do not have to read them all, you can choose the most important and still know what is going on. Every chapter contains minimum amount of theoretical introduction, for total beginners it might be not enough. I recommend this book for students who had statistics course (not only IT or computing science), this book will show you how to use your knowledge in practice _ there are many inspiring examples. For those who do not know Python - do not be afraid _ at the beginning you will find short introduction to language syntax. All listings are very short and well described by the author _ sometimes line by line. The book also contains necessary information about basic standard libraries responsible for xml processing or web pages downloading. If you would like to start learn about collective intelligence I would strongly recommend reading “Programming Collective Intelligence” first, then “Collective Intelligence in Action”. The first one shows how easy it is to implement basic algorithms, the second one would show you how to use existing open source projects related to machine learning.

I’m updating my CV, and that reminded me that I meant to promote this cool clustering technique that I was a little bit involved in, Clustering With Shallow Trees.

This goes way back to about half-way through my post-doc at MSR, when statistical physicist Riccardo Zecchina was visiting for a semester, and was teaching me about all of the “intractable” optimization problems that he can solve using his panoply of propagation algorithms. In particular, he was working on algorithms for certain types of steiner tree optimization, and he had discovered that adding an extra constraint on the depth of the tree didn’t make the problem harder. (All variants of the problem he considers are NP-hard, but some are NP-harder than others.)

On the bus to work the next day, this depth constraint clicked with some complaints I had heard recently about the failures of single-linkage clustering in practice, that the algorithm produces long, stringy clusters, which are very sensitive to noise. Could having  a knob to tune the depth of the spanning tree could be a way to address this? Riccardo worked hard on it for a long time, and brought a bunch of collaborators into the mix, and eventually they figured out how to make it work really well. They also proved that this approach interpolates between single-linkage (when the depth is unbounded) and the popular new affinity propagation technique (when the depth bound is 2.

It turns out that something between SL and AP is the thing to do in many instances. Here is the home-run example from the paper, clustering people based on their SNPs:

Compare with the results of single linkage and affinity prop:

(What use is clustering people based on their genetic information? It’s important and scary to think about that…)

I got them to try applying it to a public health dataset as well, and the results are promising, but it needs more careful attention to be useful.

That reminds me: Riccardo and Team Survey Propagation, is the code for this available? We need to let other researchers try it on their own data if we want to give the technique a chance to take off.

For the upcoming release of CloverETL 2.9, we are working on improvements in CloverETL Server which will allow run transformations in parallel on multiple cluster nodes.

CloverETL Server already supports clustering, so more instances may cooperate to each other. Current stable version already implements common cluster features: fail-over/high-availability and scalability of lots of requests which are load-balanced on available cluster nodes. These features are actually implemented since version 1.3.

The basic concept of new parallelism
Transformation may be automatically executed in parallel on more cluster nodes according to configuration and each of these “worker” transformations processes just its part of data. Because there is one “master” transformation, which manages the other transformations and which gathers tracking data from “worker” transformations, the parallelism is transparent for CloverETL Server client. Client by default “sees” just one (master) execution and aggregated tracking data. However there are still logs and tracking data for each of “worker” transformations, so it’s still possible to inspect details of this parallel execution. “Worker” transformations outputs are gathered to the “master”, thus client has one single transformation output which may be processed further.

So how to get parts of input data?
Basically, transformation can process data which is already partitioned, which is the best case and there is no overhead with partitioning of data, or CloverETL Server itself can partition input data from one single source and distribute data on the fly (during the transformation) to several cluster nodes using the network connection. Overhead of this operation depends on the speed of network communication and other conditions.

Design changes in the graph
We aim to keep the transformation graph almost the same as it would be for “standalone” execution. Thus there will be just a couple of extra components in the graph which is intended to run in parallel. These components will handle partitioning/departitioning of data in case it’s not already partitioned.

Scalability
The new parallelism in CloverETL Server is a giant leap for scalability of the transformations. Ever since the graph is designed for paraller run, the number of computers which run this transformation depends just on cluster configuration. Graph itself is still the same. Configuration of the parallelism includes:

• working CloverETL Server cluster, thus standalone server instances won’t be able to handle such execution
• “partitioned” sandbox(see below) with list of locations

New sandbox types
On server side, graphs and related files are organized in so-called sandboxes. Until version 2.8, there was just one type: “shared” sandbox. It means that it contains the same files and directory structure on all cluster nodes. Since version 2.9 there will be two more types:

• “local” sandbox – is (locally) accessible on just one cluster node. It’s intended for huge input/output data which is not intended to be shared/replicated among multiple cluster nodes.
• “partitioned” sandbox – each of its physical location contains just part of data. It’s intended as a storage for partitioned input/output data of transformations which are supposed to run in parallel. List of physical locations actually specifies nodes which will run “worker” transformations.

Master – worker responsibilities
Master observes all related workers and when some transformation phase is finished on all workers, it’s master’s responsibility to allow the workers to process next phase. When any of the workers fails from any reason, it’s master’s responsibility to abort all the other workers and select whole execution as failed. Master/worker – These terms have meaning only in the scope of one transformation. Since 2.9 there is no privileged node configured as “master” in the cluster, but it doesn’t mean that all the nodes are equal. There may be differences between nodes in accessibility to physical sources. Configuration of sandboxes should reflect it.

Hosseini, M., Abolhassani, H., and Harikandeh, 2007

Författarna försöker klustra sökloggar från AOL med hjälp av en bipartit graf mellan söksträngar och adresser och K-meansklustring i de resulterande komponenterna.

Metod

Metoden innehåller fyra steg:

1. Bygg en bipartit med söksträngar och adresser, där en kant finns om ensökning har föranlett ett klick till adressen.
2. Elimination av skräpkanter, för att kunna få ut komponenter.
3. Dimensionreducering av grannmatrisern i komponentenerna.
4. Klustring med K-means i komponenterna.

Resultat

Testdata är framtagen genom att plocka 40 k slumpvisa sökningar. Dessa klassificeras manuellt till 7 olika kategorier.

Efter de första stegen med den bipartita grafen finns det bara en komponent som är så stor att den är intressant att gå vidare med, och den innehåller 55 % av datan. Den komponenten klustras till fyra delar med K-means.

Resultaten utvärderas genom att precisionen för olika ämnen kontrolleras i varje kluster. Tre av fyra kluster hade något ämne som med betydligt högre precision än de andra.

Relevans för oss

Att klustra i AOL-loggarna är ju precis vad vi håller på med, så det är intressant att se hur de lyckas med. De har dock nöjt sig med att försöka passa in några få jättekluster i förutbestämda kategorier, något som vi bedömmer som ointressant. Något som däremot är intressant är att de har lagt ner ett stort arbete på att manuellt klassificera 40 k sökningar i sju kategorier, vilket ger oss en bild av hur proportionerna mellan dessa borde vara i våra kluster, det är möjligtvis något vi skulle kunna använda för utvärdering.

Att deras initiala steg med komponenter i en bipartit graf bara gav en stor komponent stämmer väl med våra erfarenheter av loggarna,  att det är skräpiga data som är svåra att slå isär.

At the risk of sounding like a public service announcement, this week’s post comes with a health warning: read the small print when choosing your virtual availability provider.

Finding a fault tolerant virtualization solution to guarantee availability of your critical applications can be rather like choosing whether to die by the knife or by the sword.

Of course, at Stratus, we’d prefer that you did not choose to die at all. We’d prefer that you choose to live. This post aims to help you do just that.

So what’s the deal?

Every availability solution has its strengths and limitations. In the case of virtualized availability the considerations are

1.    Actual fault tolerance Vs claimed fault tolerance
2.    Operational simplicity
3.    Performance and financial advantages

Here are some key questions for vendors:

• How scalable is the solution?
• Is it restricted to one core?
• If so, how many systems need to be available to ensure continuous availability?
• What impact does this have on costs?
• What impact does this have on latency?

It’s also worth investigating the benefits of fault tolerance versus clustering. Clustering solutions, such as VMware HA, can scale but introduce additional complexity and do not protect against data loss.

As VMware states when describing its VMware FT:

“This is different from HA, which restarts any virtual machines that fail. Such a restart requires the virtual machines to complete the process of rebooting, and information about the state of the virtual machine, such as applications or unsaved user-entered information, might be lost”

VMware FT may be different from VMware HA but it is still a clustering solution. It still requires separate physical servers. It still does not scale beyond a single core. It still incurs additional overhead as a function of its architecture

Sure, there is no “best”, “one size fits all”  solution for virtualized availability and there are situations where one virtualized availability solution is better suited than another, yet Stratus FT Server is always worth considering. It guarantees:

• Industry leading fault tolerance
• Operational simplicity
• Absolute security
• Total scalability
• No hidden costs

• Always use quality server & networking hardware for fault-tolerant systems.
• Use RAID to create disk subsystem redundancy.
• Don’t run MSCS and NLB on the same computer, as it’s not supported by Microsoft.
• When possible, try to use cluster-aware applications, so you can use cluster service to monitor the application. If you use cluster-unaware application, it can run on a cluster, but the application is not monitored by cluster service.
• Use active/passive clustering mode, when performance is not critical. It is easier to administrate and licensing costs are lower.
• If you got TCP/IP-based services such as Terminal Services, Web sites, VPN services or streaming media services, use NLB.
• For mission critical applications (enterprise messaging, databases, file and print services) use Windows Server 2003 Cluster Services to provide server failover functionality.
• Disable power management on each of the cluster nodes. IN BIOS and in operating system’s control panel to avoid unwanted failovers.
• Choose carefully whether you should use nonshared or shared disk approcah to clustering.
• When you plan to use MSN cluster, always purchase 1 additional node.
• Be sure that MS and software manufacturer certify that 3rd party software for Cluster Service works on Windows Server 2003 cluster or you might be faced with limited support when troubleshooting is needed.
• In each node use multiple network cards. For example one card can be dedicated to private network (internal cluster communications), other can be used for public network (client connectivity) or both can be used for mixed network (public and private communication) 
• Configure failback schedule to allow failback only during non-peak times or after hours to reduce the chance of having a group failing back to a node during regular business hours after a failure.
• Test failover and failback mechanism thoroughly.
• If you are logged in with Cluster Service account, don’t use AD Users & Computers or Windows security box to change the password.
• If you’re removing a node from MNS cluster, make sure that majority of the nodes remain running to keep the cluster in a working state.
• Carefully consider how to backup and restore a cluster.
• Perform ASR backups periodically and immediately after any hardware changes to a cluster node including changes on a shared storage device or local disk configuration.
• Before deciding which clustering technology to use, make sure you understand the application that will be used thoroughly.
• Create a rule that allows only specific ports to the clustered IP address and block all others.
• Use tools like robocopy.exe to replicate data between NLB nodes.

-Eric

Big banks cluster...so do we

The Economist  magazine recently expounded on the phenomenon whereby firms from the same industry gather together in close proximity.  “Clustering” is also one of the Top Ten reasons listed by Expansion Management  magazine for company relocations.

Companies cluster mainly because they enjoy the expertise and camaraderie of their industry colleagues, not to mention the competitive vibe.  Banks have long clustered in London or the Cayman Islands for that reason.  

There is also the factor of service support.  Providers come to these areas precisely to serve these companies, and thus a boon is born.  The adage: “fish where the fish are”  is an apt one here.

 Here in Nogales, AZ, we have clustering a-plenty in the produce industry.  Approximately 130 fresh produce distributors, shippers, brokers or affiliated businesses call Santa Cruz County headquarters.  Most are located on the Hwy I-19 corridor that connects Tucson to the Mexico border…and beyond, but they can also be found in mini-clusters throughout the entire area.

These companies are here because the Port of Mariposa (slated for a huge government expansion program – more on that soon!) is responsible for crossing over 200,000 trucks of fresh produce per year from Mexico.

These Mexican trucks typically unload their winter produce at these distributors’ warehouses, which are then reloaded onto U.S trucks that criss-cross the nation.  All told, fresh produce imports from Mexico is an $8B concern, of which Nogales represents about half.

Another fine example of clustering is right across the U.S. border in Nogales, Sonora, home to over 500,000. There, manufacturers like Motorola, Ford, Intel, etc. have parts factory (maquiladoras) which employ thousands in a business worth double-digit billions.

Either country, on both sides of the border, minutes from each other: this is arguably the only place in North America where you will see such an extensive and dynamic example of clustering.

Here is my quick steps on setting up a WASCE cluster using WADI. I am using IBM WebSphere CE 2.1.1.2 to be specific; my impression was WASCE by default would use wadi and wadi would use uni cast; and I will have to make very few changes to get this to work. Well it was not that simple, nor were my assumptions true. IBM WebSphere CE 2.1.1.2 does not yet support wadi with unicast that is planned for a future release. Some of the key points that I noticed is wadi uses the ports 4000 and above to automatically select an available port for multicast communication. There seems to be no way to reconfigure this port and the multicast ip used by wadi. The multicast communication between two wadi nodes is not secure so the communication is in clear text.

Here are the setup steps:

Step 1: Create two WAS CE instances – App1Node1Server and App1Node2Server; and ensure both servers are shutdown. with assumption that the base port I start with for node1 is 21371 and for node2 21471; I am using a secure port so my script configures the server to listen at 21374 and 21474 respectively. The rmi ports are 21372 and 21472 respectively.

Step 2: Update config-substitutions.properties with clusterNodeName on both  server; under <server>/var/config folder and set the names to node1 and node2 respectively. I set the RemoteDeployHostname to localhost in my test. But this would probably change when I need to test across multiple VMs/Machines.

Step 3: Update config.xml for App1Node1Server as below, by adding the wadi modules (tomcat6-clustering-wadi, wadi-clustering, farming) and the gbean configuration for farming; it is important to put the NodeInfo and ClusterInfo gbeans as well. In the farming gbean you will need to put the username/password, and host/port, urlPath information for the other node (node2 in this case) that will be part of the cluster

 <module name="org.apache.geronimo.configs/tomcat6-clustering-wadi/2.1.4/car"
   load="true"/>
 <module name="org.apache.geronimo.configs/wadi-clustering/2.1.4/car" load="true"/>
 <module name="org.apache.geronimo.configs/farming/2.1.4/car" load="true">
   <gbean name="NodeInfo">
     <attribute name="name">${clusterNodeName}</attribute> 
   </gbean> 
   <gbean name="ClusterInfo">    
     <attribute name="name">${clusterName}</attribute> 
   </gbean> 
   <gbean name="org.apache.geronimo.configs/farming/2.1.4/car?ServiceModule=
       org.apache.geronimo.configs/farming/2.1.4/car,
       j2eeType=NodeInfo,name=NodeInfo2"
     gbeanInfo="org.apache.geronimo.farm.config.BasicNodeInfo">
     <attribute name="name">node2</attribute>
     <attribute
       propertyEditor="org.apache.geronimo.farm.config.BasicExtendedJMXConnectorInfoEditor"
       name="extendedJMXConnectorInfo">          
       <ns:javabean
          xmlns=""
          xmlns:ns4="http://geronimo.apache.org/xml/ns/attributes-1.2"
          xmlns:ns="http://geronimo.apache.org/xml/ns/deployment/javabean-1.0">            
            <ns:property name="username">node2User</ns:property>
            <ns:property name="password">node2Passwd</ns:property>
            <ns:property name="protocol">rmi</ns:property>
            <ns:property name="host">localhost</ns:property>
            <ns:property name="port">21474</ns:property>
            <ns:property name="urlPath">/jndi/rmi://localhost:21472</ns:property>
            <ns:property name="local">true</ns:property>
       </ns:javabean>    
     </attribute> 
   </gbean>
 </module>

Step 4: Update config.xml for App1Node2Server as below, by adding the wadi modules and the gbean for farming, we the the same as above but change the username/password, and host/port, urlPath information for the other node (node1) that will be part of the cluster

 <module name="org.apache.geronimo.configs/tomcat6-clustering-wadi/2.1.4/car"
   load="true"/>
 <module name="org.apache.geronimo.configs/wadi-clustering/2.1.4/car" load="true"/>
 <module name="org.apache.geronimo.configs/farming/2.1.4/car" load="true">
   <gbean name="NodeInfo">
     <attribute name="name">${clusterNodeName}</attribute> 
   </gbean> 
   <gbean name="ClusterInfo">    
     <attribute name="name">${clusterName}</attribute> 
   </gbean> 
   <gbean name="org.apache.geronimo.configs/farming/2.1.4/car?ServiceModule=
     org.apache.geronimo.configs/farming/2.1.4/car,j2eeType=NodeInfo,name=NodeInfo1"
     gbeanInfo="org.apache.geronimo.farm.config.BasicNodeInfo">
     <attribute name="name">node1</attribute>
     <attribute
       propertyEditor="org.apache.geronimo.farm.config.BasicExtendedJMXConnectorInfoEditor"
       name="extendedJMXConnectorInfo">          
       <ns:javabean
          xmlns=""
          xmlns:ns4="http://geronimo.apache.org/xml/ns/attributes-1.2"
          xmlns:ns="http://geronimo.apache.org/xml/ns/deployment/javabean-1.0">            
            <ns:property name="username">node1User</ns:property>
            <ns:property name="password">node1Passwd</ns:property>
            <ns:property name="protocol">rmi</ns:property>
            <ns:property name="host">localhost</ns:property>
            <ns:property name="port">21374</ns:property>
            <ns:property name="urlPath">/jndi/rmi://localhost:21372</ns:property>
            <ns:property name="local">true</ns:property>
       </ns:javabean>    
     </attribute> 
   </gbean>
 </module>

Step 5: If you restart the servers now – you will notice that the servers are looking for some specific folders that do not exist; Create the <server>/master-repository & <server>/cluster-repository folders under the App1Node1Server and App1Node2Server folders (these folder must be created at the same level as the var folder which holds the config, logs etc.., ); (Since I was setting this up as root and the actual instances where running with another id, I had to ensure the ownership and permissions on the new folders was setup properly to be accessible by the other id with read/write permissions for the user)

Step 6: Now restart both the server instances; and you will notice that one node is added as cluster member on the other node.

PhotoSketch is a system created by Chinese students. It automatically composes simple freehand sketches into realistic pictures.

PhotoSketch pipeline (Source: Tsinghua University)

How it works:

Step 1: The user draws simple items on the screen. Every item can be drawn as a shape contour or an ellipse, which is the default. All items and the background must be annotated with text labels, so that the system knows how to interpret the figures.

Step 2: The system searches the Internet (currently flickr, google and yahoo) for pictures applicable to the given text labels and downloads a lot of them.

Step 3: Now the system tries to exclude false discoveries and chooses the most fitting pictures:

Choosing appropriate background pictures:
The first approach is to cluster all pictures by its L*, u*, v* histograms. All pictures in the biggest cluster will be used for the next step. Example: If the user did annotate the background as “beach”, then the pictures should mostly consist of yellow and blue colors. Therefore these pictures should be all together in the biggest cluster. All pictures with much red or green will be divided into smaller clusters and thus they will be excluded. The next approach ensures that the horizon lines in the pictures are aligned well. Finally a segmentation algorithm tests how many segments of the background pictures are covered by the items. The lesser the better.

Choosing appropriate item pictures:
The first approach is to discard all pictures with complicated backgrounds, because in these pictures the separation of the figure from the background is hard to accomplish. Next the items will be segmented. This will be done by iteratively applying dilation and a grabcut algorithm until the result or the computation limit is reached. The segmented pictures will then be compared with the item shapes drawn by the user to get all pictures that match the shape best. Finally the pictures will be clustered to get only the consistent ones.

Step 4: The images are composed seamlessly into several compositions by a novel self-made blending method. The user can then choose the best one and refine the composition.

In the experiments (“two PCs with 2.66 GHz Quad core CPUs and 6 GB RAM”) the total computation took about 15*n+5 minutes (n = number of items). To compute a full scene with e.g. 6 items it takes about 95 minutes beginning with downloading of the pictures till the composition arrives. With a slow Internet connection it would probably take much longer to download all the pictures. But I think it pays off. Can’t wait to try it out.

More info and the paper can be found here.