Text::Ngrams - Flexible Ngram analysis (for characters, words, and more)
For default character n-gram analysis of string:
use Text::Ngrams;
my $ng3 = Text::Ngrams->new;
$ng3->process_text('abcdefg1235678hijklmnop');
print ng3->to_string;
One can also feed tokens manually:
use Text::Ngrams;
my $ng3 = Text::Ngrams->new;
$ng3->feed_tokens('a');
$ng3->feed_tokens('b');
$ng3->feed_tokens('c');
$ng3->feed_tokens('d');
$ng3->feed_tokens('e');
$ng3->feed_tokens('f');
$ng3->feed_tokens('g');
$ng3->feed_tokens('h');
We can choose n-grams of various sizes, e.g.:
my $ng = Text::Ngrams->new( windowsize => 6 );
or different types of n-grams, e.g.:
my $ng = Text::Ngrams->new( type => byte );
my $ng = Text::Ngrams->new( type => word );
or limit the total number of n-grams (less-frequent ones will be pruned):
my $ng = Text::Ngrams->new( limit => 10 );
This module implement text n-gram analysis, supporting several types of analysis, including character and word n-grams.
The module Text::Ngrams is very flexible. For example, it allows a user to manually feed a sequence of any tokens. It handles several types of tokens (character, word), and also allows a lot of flexibility in automatic recognition and feed of tokens and the way they are combined in an n-gram. It counts all n-gram frequencies up to the maximal specified length. The output format is meant to be pretty much human-readable, while also loadable by the module.
The module can be used from the command line through the script
ngrams.pl provided with the package.
The output looks like this (version number may be different):
BEGIN OUTPUT BY Text::Ngrams version 1.1
1-GRAMS (total count: 8)
------------------------
a 1
b 1
c 1
d 1
e 1
f 1
g 1
h 1
2-GRAMS (total count: 7)
------------------------
ab 1
bc 1
cd 1
de 1
ef 1
fg 1
gh 1
3-GRAMS (total count: 6)
------------------------
abc 1
bcd 1
cde 1
def 1
efg 1
fgh 1
END OUTPUT BY Text::Ngrams
N-grams are encoded using encode_S (www.cs.dal.ca/~vlado/srcperl/snip/encode_S), so that they can always be recognized as \S+. This encoding does not change strings ``too much'', e.g., letters, digits, and most punctuation characters will remail unchanged, and space is replaced by underscore (_). However, all bytes (even with code greater than 127) are encoded in unambiguous and relatively compact way. Two functions, encode_S and decode_S, are provided for translating arbitrary string into this form and vice versa.
An example of word n-grams containing space:
BEGIN OUTPUT BY Text::Ngrams version 1.1
1-GRAMS (total count: 8)
------------------------
The 1
brown 3
fox 3
quick 1
2-GRAMS (total count: 7)
------------------------
The_brown 1
brown_fox 2
brown_quick 1
fox_brown 2
quick_fox 1
END OUTPUT BY Text::Ngrams
Or, in case of byte type of processing:
BEGIN OUTPUT BY Text::Ngrams version 1.1
1-GRAMS (total count: 55)
-------------------------
\t 3
\n 3
_ 12
, 2
. 3
T 1
b 3
c 1
... etc
2-GRAMS (total count: 54)
-------------------------
\t_ 1
\tT 1
\tb 1
\n\t 2
__ 5
_. 1
_b 2
_f 3
_q 1
,\n 2
.\n 1
.. 2
Th 1
br 3
ck 1
e_ 1
... etc
END OUTPUT BY Text::Ngrams
my $ng = Text::Ngrams->new;
my $ng = Text::Ngrams->new( windowsize=>10 );
my $ng = Text::Ngrams->new( type=>'word' );
my $ng = Text::Ngrams->new( limit=>10000 );
and similar.
Creates a new Text::Ngrams object and returns it.
Parameters:
Beware: If a limit is set, the n-gram counts at the end may not be correct due to periodical pruning of n-grams.
One can also modify type, creating its own type, by fine-tuning several parameters (they can be undefined):
$o->{tokenseparator} - string used to be inserted between tokens in n-gram (for characters it is empty, and for words it is a space).
$o->{skiprex} - regular expression for ignoring stuff between tokens.
$o->{tokenrex} - regular expression for recognizing a token. If it is empty, it means chopping off one character.
$o->{processtoken} - routine for token preprocessing. Token is given and returned in $_.
For example, the types character, byte, and word are defined in the foolowing way:
if ($params{type} eq 'character') {
$self->{tokenseparator} = '';
$self->{skiprex} = '';
$self->{tokenrex} = qr/([a-zA-Z]|[^a-zA-Z]+)/;
$self->{processtoken} = sub { s/[^a-zA-Z]+/ /; $_ = uc $_ }
}
elsif ($params{type} eq 'byte') {
$self->{tokenseparator} = '';
$self->{skiprex} = '';
$self->{tokenrex} = '';
$self->{processtoken} = '';
}
elsif ($params{type} eq 'word') {
$self->{tokenseparator} = ' ';
$self->{skiprex} = qr/[^a-zA-Z0-9]+/;
$self->{tokenrex} = qr/([a-zA-Z]+|(\d+(\.\d+)?|\d*\.\d+)([eE][-+]?\d+)?)/;
$self->{processtoken} = sub { s/(\d+(\.\d+)?|\d*\.\d+)([eE][-+]?\d+)?/<NUMBER>/ }
}
$ng3->feed_tokens('a');
This function manually supplies tokens.
$ng3->process_text('abcdefg1235678hijklmnop');
$ng->process_text('The brown quick fox, brown fox, brown fox ...');
Process text, i.e., break each string into tokens and feed them.
$ng->process_files('somefile.txt');
Process files, similarly to text. The files are processed line by line, so there should not be any multi-line tokens.
print $ng3->to_string;
print $ng->to_string( orderby=>'frequency' );
print $ng->to_string( orderby=>'frequency', onlyfirst=>10000 );
print $ng->to_string( orderby=>'frequency', onlyfirst=>10000, normalize=>1 );
Produce string representation of the n-gram tables.
Parameters:
orderbyorderby
specifies the order of n-grams. The default
value is 'ngram'.
onlyfirstonlyfirst
causes printing only this many first n-grams
for each n. It is incompatible with orderby='none'>.
outto_string produces n-gram tables.
However, if those
tables are large and we know that we will write them to a file
right after processing, it may save memory and time to provide the
parameter out, which is a
filename or reference to a file handle.
(Experiments on my machine do not show significant improvement nor
degradation.)
Filename will be opened and closed, while the file handle will not.
normalize
$e = Text::Ngrams::encode_S( $s );
or simply
$e = encode_S($s);
if encode_S is imported. Encodes arbitrary string into an \S* form. See http://www.cs.dal.ca/~vlado/srcperl/snip/encode_S for detailed explanation.
$e = Text::Ngrams::decode_S( $s );
or simply
$e = decode_S($s);
if decode_S is imported. Decodes a string encoded in the \S* form. See http://www.cs.dal.ca/~vlado/srcperl/snip/encode_S for detailed explanation.
This code originated in my ``monkeys and rhinos'' project in 2000, and is related to authorship attribution project. Some of the similar projects are (URLs can be found at my site):
The preformance can vary a lot depending on the type of file, in particular on the content entropy. For example a file in English is processed faster than a file in Chinese, due to a larger number of distinct n-grams.
The following tests are preformed on a Pentium-III 550MHz, 512MB
memory, Linux Red Hat 6 platform. (See ngrams.pl - the
script is
included in this package.)
ngrams.pl --n=10 --type=byte 1Mfile
The 1Mfile is a 1MB file of Chinese text. The program spent consistently 20 sec per 100KB, giving 200 seconds (3min and 20sec) for the whole file. However, after 4 minutes I gave up on waiting for n-grams to be printed. The bottleneck seems to be encode_S function, so after:
ngrams.pl -n=10 --type=byte --orderby=frequency --onlyfirst=5000 1Mfile
it took about 3:24 + 5 =~ 9 minutes to print. After changing
ngrams.pl so that it provides parameter out to to_string in
module Ngrams.pm (see Text::Ngrams), it still took:
3:09+1:28+4:40=9:17.
If a user customizes a type, it is possible that a resulting n-gram will be ambiguous. In this way, to different n-grams may be counted as one. With predefined types of n-grams, this should not happen. For example, if a user chooses that a token can contain a space, and uses space as an n-gram separator, then a trigram like this ``x x x x'' is ambiguous.
Method process_file does not handle multi-line tokens by default. This can be fixed, but it does not seem to be worth the code complication. There are various ways around this if one really needs such tokens: One way is to preprocess them. Another way is to read as much text as necessary at a time then to use process_text, which does handle multi-line tokens.
I'd like to thank Jost Kriege and Shlomo Yona for bug reports, comments, and/or encouragement.
I will be grateful for comments, bug reports, or just letting me know that you used the module.
Copyright 2003-2004 Vlado Keselj www.cs.dal.ca/~vlado
This module is provided ``as is'' without expressed or implied warranty. This is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
The latest version can be found at http://www.cs.dal.ca/~vlado/srcperl/.
Ngram Statistics Package in Perl, by T. Pedersen at al., Waterloo Statistical N-Gram Language Modeling Toolkit in C++ by Fuchun Peng, Perl script ngram.pl by Jarkko Hietaniemi, Simon Cozen's Text::Ngram module in CPAN.
The links should be available at http://www.cs.dal.ca/~vlado/nlp.