How to turn plural words singular?

Question

I'm preparing some table names for an ORM, and I want to turn plural table names into single entity names. My only problem is finding an algorithm that does it reliably. Here's what I'm doing right now:

1. If a word ends with -ies, I replace the ending with -y
2. If a word ends with -es, I remove this ending. This doesn't always work however - for example, it replaces Types with Typ
3. Otherwise, I just remove the trailing -s

Does anyone know of a better algorithm?

Answer 1

I think you have to use a list to translate plural into singular for some special words (in your example Types->Type).

I think you could have a look at the sourcecode of CakePHP (you might start your search here). They are using such an algorithm for their tablenames and fieldnames to automagically join tables.

---

[Edit:] Here you have some scientific work to read about "Plural inflection in English"

Answer 2

The problem is that's based on the general rules, but English has (figuratively) a billion exceptions... What do you do with words like "fish", or "geese"?

Also, the rules are for how to turn singular nouns to plurals. The reverse mapping isn't necessarily possible (consider "freebies").

Answer 3

I'm sure you can google to find plenty of libs that do this.

But if you feel like coding, you could try the reverse process: start with singular words of dictionary (download free ones, used by aspell or whatever), use pluralization rule; collect mappings and switch the direction. For "type" you would pluralize to "types", and reverse mapping would work as expected. While there are exceptions here too it is slightly easier to reliably pluralize things. I did this a while back (in mid 90s... :-) ), for an online game (a MUD), where descriptions for multiple identical items were concatenatd, and automatic pluralization was needed.

Also: given that it's finite number of tables you could just use simplest algorithm, get raw output, eyeball it and fix error cases manually. :-)

Answer 4

Andrew Peters has a class called Inflector.NET which provides plural-to-singular and singular-to-plural methods. As Tal has pointed out no algorithm is infallible but this covers a decent number of irregular English nouns.

Answer 5

Those are all general rules (and good ones) but English is not a language for the faint of heart :-).

My own preference would be to have a transformation engine along with a set of transformations (surprisingly enough) for doing the actual work.

You would run through the transformations (from specific to general) and, when a match was found, apply the transformation to the word.

Regular expressions would be an ideal approach to this due to their expressiveness. An example rule set:

 1. If the word is fish, return fish.
 2. If the word is sheep, return sheep.
 3. If the word is "radii", return "radius".
 4. If the word is "types", return "type".
 3. If the word ends in "ii", replace that "ii" with "us" (octopii,virii).
    : : : : :
97. If a word ends with -ies, I replace the ending with -y
98. If a word ends with -es, I remove this ending.
99. Otherwise, I just remove the trailing -s.

Note that, when we found the problem with "types" at 98, we created a higher-priority transformation at 4. You'll basically need to keep this transformation table updated as you find all those wondrous exceptions that English has spawned.

The other possibility is to not waste your time with a general rule. Since the names of the tables will be relatively limited, just create another table (or some sort of data structure) called singulars which maps all the relevant plural table names (employees) to singular object names (employee).

Then every time a table is added, add an entry to the singulars "table" so you can singularize it.

Answer 6

Maybe take a look at source code of something like Rails Inflector

Answer 7

See also this answer, which recommends using Morpha (or studying the algorithm behind it).

If you know that the words that you want to lemmatize are plural nouns then you can tag them with NNS to get a more accurate output.

Input example:

$ cat test.txt 
Types_NNS
Pies_NNS
Trees_NNS
Buses_NNS
Radii_NNS
Communities_NNS
Sheep_NNS
Fish_NNS

Output example:

$ cat test.txt | ./morpha -c
Type
Pie
Tree
Bus
Radius
Community
Sheep
Fish

Answer 8

As an improvement, you could use rules that generate multiple possibilities and then look up the results in a dictionary to weed out impossible options.

For example replace -ies with -y and -ie. Pies becomes Py and Pie. Only one of those is in the dictionary, so choose that one.

Perhaps you can even find a dictionary with frequency information and select the most common word you generate.

If you combine this with an ordered list of rules that covers a few exceptions, you might get pretty good accuracy.

Answer 9

There's a nice implementation of an inflector in uNnAddIns project that even implements an experimental spanish inflector. The idea is caught from Rails Inflector module.

It can be used as well for other things like converting from CamelCase to normal text and other goodies and for example generating browser friendly URLs from titles.

Answer 10

I'm going to try this MorphAdorner: http://morphadorner.northwestern.edu/morphadorner/download/ (Java). It's a collection of different types of NLP processing tools, and you can test them through online examples. For your problem (that is also my problem) there's the Pluralizer tool: http://morphadorner.northwestern.edu/morphadorner/pluralizer/example/