"sleep","sli:p","v.i","a condition of body and mind ..."
"wake","weik","intrans","cease to sleep"
Now we can express this query as shown here:
>>> import csv
>>> lexicon = csv.reader(open('dict.csv'))
>>> pairs = [(lexeme, defn) for (lexeme, _, _, defn) in lexicon]
>>> lexemes, defns = zip(*pairs)
>>> defn_words = set(w for defn in defns for w in defn.split())
>>> sorted(defn_words.difference(lexemes))
This information would then guide the ongoing work to enrich the lexicon, work that
updates the content of the relational database.
Converting Data Formats
Annotated linguistic data rarely arrives in the most convenient format, and it is often
necessary to perform various kinds of format conversion. Converting between character
encodings has already been discussed (see Section 3.3). Here we focus on the structure
of the data.
In the simplest case, the input and output formats are isomorphic. For instance, we
might be converting lexical data from Toolbox format to XML, and it is straightforward
to transliterate the entries one at a time (Section 11.4). The structure of the data is
reflected in the structure of the required program: a 
for
loop whose body takes care of
a single entry.
In another common case, the output is a digested form of the input, such as an inverted
file index. Here it is necessary to build an index structure in memory (see Example 4.8),
then write it to a file in the desired format. The following example constructs an index
that maps the words of a dictionary definition to the corresponding lexeme 
for each
lexical entry 
, having tokenized the definition text 
, and discarded short words 
.
Once the index has been constructed, we open a file and then iterate over the index
entries, to write out the lines in the required format 
.
>>> idx = nltk.Index((defn_word, lexeme) 
...                  for (lexeme, defn) in pairs 
...                  for defn_word in nltk.word_tokenize(defn) 
...                  if len(defn_word) > 3) 
>>> idx_file = open("dict.idx", "w")
>>> for word in sorted(idx):
...     idx_words = ', '.join(idx[word])
...     idx_line = "%s: %s\n" % (word, idx_words) 
...     idx_file.write(idx_line)
>>> idx_file.close()
The resulting file dict.idx contains the following lines. (With a larger dictionary, we
would expect to find multiple lexemes listed for each index entry.)
11.3  Acquiring Data a | | 419
Pdf split and merge - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
break pdf into multiple files; pdf merge files
Pdf split and merge - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
pdf merge documents; c# merge pdf
body: sleep
cease: wake
condition: sleep
down: walk
each: walk
foot: walk
lifting: walk
mind: sleep
progress: walk
setting: walk
sleep: wake
In some cases, the input and output data both consist of two or more dimensions. For
instance, the input might be a set of files, each containing a single column of word
frequency data. The required output might be a two-dimensional table in which the
original columns appear as rows. In such cases we populate an internal data structure
by filling up one column at a time, then read off the data one row at a time as we write
data to the output file.
In the most vexing cases, the source and target formats have slightly different coverage
of the domain, and information is unavoidably lost when translating between them.
For example, we could combine multiple Toolbox files to create a single CSV file con-
taining a comparative wordlist, losing all but the 
\lx
field of the input files. If the CSV
file was later modified, it would be a labor-intensive process to inject the changes into
the original Toolbox files. A partial solution to this “round-tripping” problem is to
associate explicit identifiers with each linguistic object, and to propagate the identifiers
with the objects.
Deciding Which Layers of Annotation to Include
Published corpora vary greatly in the richness of the information they contain. At a
minimum, a corpus will typically contain at least a sequence of sound or orthographic
symbols. At the other end of the spectrum, a corpus could contain a large amount of
information about the syntactic structure, morphology, prosody, and semantic content
of every sentence, plus annotation of discourse relations or dialogue acts. These extra
layers of annotation may be just what someone needs for performing a particular data
analysis task. For example, it may be much easier to find a given linguistic pattern if
we can search for specific syntactic structures; and it may be easier to categorize a
linguistic pattern if every word has been tagged with its sense. Here are some commonly
provided annotation layers:
Word tokenization
The orthographic form of text does not unambiguously identify its tokens. A to-
kenized and normalized version, in addition to the conventional orthographic ver-
sion, may be a very convenient resource.
Sentence segmentation
As we saw in Chapter 3, sentence segmentation can be more difficult than it seems.
Some corpora therefore use explicit annotations to mark sentence segmentation.
420 | | Chapter 11: Managing Linguistic Data
C# PDF File Split Library: Split, seperate PDF into multiple files
PDF ›› C# PDF: Split PDF. C# PDF - Split PDF Document in C#.NET. Explain How to Split PDF Document in Visual C#.NET Application. C# DLLs: Split PDF Document.
pdf combine; reader merge pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
File: Split PDF Document. |. Home ›› XDoc.PDF ›› VB.NET PDF: Split PDF. VB.NET PDF - Split PDF Document Using VB.NET. VB.NET
all jpg to one pdf converter; batch merge pdf
Paragraph segmentation
Paragraphs and other structural elements (headings, chapters, etc.) may be explic-
itly annotated.
Part-of-speech
The syntactic category of each word in a document.
Syntactic structure
A tree structure showing the constituent structure of a sentence.
Shallow semantics
Named entity and coreference annotations, and semantic role labels.
Dialogue and discourse
Dialogue act tags and rhetorical structure.
Unfortunately, there is not much consistency between existing corpora in how they
represent their annotations. However, two general classes of annotation representation
should be distinguished. Inline annotation modifies the original document by insert-
ing special symbols or control sequences that carry the annotated information. For
example, when part-of-speech tagging a document, the string 
"fly"
might be replaced
with the string 
"fly/NN"
, to indicate that the word fly is a noun in this context. In
contrast, standoff annotation does not modify the original document, but instead
creates a new file that adds annotation information using pointers that reference the
original document. For example, this new document might contain the string 
"<token
id=8 pos='NN'/>"
, to indicate that token 8 is a noun.
Standards and Tools
For a corpus to be widely useful, it needs to be available in a widely supported format.
However, the cutting edge of NLP research depends on new kinds of annotations,
which by definition are not widely supported. In general, adequate tools for creation,
publication, and use of linguistic data are not widely available. Most projects must
develop their own set of tools for internal use, which is no help to others who lack the
necessary resources. Furthermore, we do not have adequate, generally accepted stand-
ards for expressing the structure and content of corpora. Without such standards, gen-
eral-purpose tools are impossible—though at the same time, without available tools,
adequate standards are unlikely to be developed, used, and accepted.
One response to this situation has been to forge ahead with developing a generic format
that is sufficiently expressive to capture a wide variety of annotation types (see Sec-
tion 11.8 for examples). The challenge for NLP is to write programs that cope with the
generality of such formats. For example, if the programming task involves tree data,
and the file format permits arbitrary directed graphs, then input data must be validated
to check for tree properties such as rootedness, connectedness, and acyclicity. If the
input files contain other layers of annotation, the program would need to know how
to ignore them when the data was loaded, but not invalidate or obliterate those layers
when the tree data was saved back to the file.
11.3  Acquiring Data a | | 421
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
C# PDF - Merge or Split PDF File in C#.NET. C#.NET Code Demos to Combine or Divide Source PDF Document File. Visual C#. VB.NET. Home
attach pdf to mail merge in word; batch pdf merger online
VB.NET PDF: Use VB.NET Code to Merge and Split PDF Documents
VB.NET PDF - How to Merge and Split PDF. How to Merge and Split PDF Documents by Using VB.NET Code. Visual C#. VB.NET. Home > .NET Imaging
append pdf; merge pdf online
Another response has been to write one-off scripts to manipulate corpus formats; such
scripts litter the filespaces of many NLP researchers. NLTK’s corpus readers are a more
systematic approach, founded on the premise that the work of parsing a corpus format
should be done only once (per programming language).
Instead of focusing on a common format, we believe it is more promising to develop a
common interface (see 
nltk.corpus
). Consider the case of treebanks, an important
corpus type for work in NLP. There are many ways to store a phrase structure tree in
a file. We can use nested parentheses, or nested XML elements, or a dependency no-
tation with a (child-idparent-id) pair on each line, or an XML version of the dependency
notation, etc. However, in each case the logical structure is almost the same. It is much
easier to devise a common interface that allows application programmers to write code
to access tree data using methods such as 
children()
leaves()
depth()
, and so forth.
Note that this approach follows accepted practice within computer science, viz. ab-
stract data types, object-oriented design, and the three-layer architecture (Fig-
ure 11-6). The last of these—from the world of relational databases—allows end-user
applications to use a common model (the “relational model”) and a common language
(SQL) to abstract away from the idiosyncrasies of file storage. It also allows innovations
in filesystem technologies to occur without disturbing end-user applications. In the
same way, a common corpus interface insulates application programs from data
formats.
Figure 11-6. A common format versus a common interface.
In this context, when creating a new corpus for dissemination, it is expedient to use a
widely used format wherever possible. When this is not possible, the corpus could be
accompanied with software—such as an 
nltk.corpus
module—that supports existing
interface methods.
Special Considerations When Working with Endangered Languages
The importance of language to science and the arts is matched in significance by the
cultural treasure embodied in language. Each of the world’s ~7,000 human languages
422 | | Chapter 11: Managing Linguistic Data
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
Merge certain pages from different TIFF documents and create a &ltsummary> ''' Split a TIFF provide powerful & profession imaging controls, PDF document, tiff
pdf combine files online; pdf combine two pages into one
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Tell VB.NET users how to: create a new PDF file and load PDF from other file formats; merge, append, and split PDF files; insert, delete, move, rotate, copy
attach pdf to mail merge; pdf merger online
is rich in unique respects, in its oral histories and creation legends, down to its gram-
matical constructions and its very words and their nuances of meaning. Threatened
remnant cultures have words to distinguish plant subspecies according to therapeutic
uses that are unknown to science. Languages evolve over time as they come into contact
with each other, and each one provides a unique window onto human pre-history. In
many parts of the world, small linguistic variations from one town to the next add up
to a completely different language in the space of a half-hour drive. For its breathtaking
complexity and diversity, human language is as a colorful tapestry stretching through
time and space.
However, most of the world’s languages face extinction. In response to this, many
linguists are hard at work documenting the languages, constructing rich records of this
important facet of the world’s linguistic heritage. What can the field of NLP offer to
help with this effort? Developing taggers, parsers, named entity recognizers, etc., is not
an early priority, and there is usually insufficient data for developing such tools in any
case. Instead, the most frequently voiced need is to have better tools for collecting and
curating data, with a focus on texts and lexicons.
On the face of things, it should be a straightforward matter to start collecting texts in
an endangered language. Even if we ignore vexed issues such as who owns the texts,
and sensitivities surrounding cultural knowledge contained in the texts, there is the
obvious practical issue of transcription. Most languages lack a standard orthography.
When a language has no literary tradition, the conventions of spelling and punctuation
are not well established. Therefore it is common practice to create a lexicon in tandem
with a text collection, continually updating the lexicon as new words appear in the
texts. This work could be done using a text processor (for the texts) and a spreadsheet
(for the lexicon). Better still, SIL’s free linguistic software Toolbox and Fieldworks
provide sophisticated support for integrated creation of texts and lexicons.
When speakers of the language in question are trained to enter texts themselves, a
common obstacle is an overriding concern for correct spelling. Having a lexicon greatly
helps this process, but we need to have lookup methods that do not assume someone
can determine the citation form of an arbitrary word. The problem may be acute for
languages having a complex morphology that includes prefixes. In such cases it helps
to tag lexical items with semantic domains, and to permit lookup by semantic domain
or by gloss.
Permitting lookup by pronunciation similarity is also a big help. Here’s a simple dem-
onstration of how to do this. The first step is to identify confusible letter sequences,
and map complex versions to simpler versions. We might also notice that the relative
order of letters within a cluster of consonants is a source of spelling errors, and so we
normalize the order of consonants.
11.3  Acquiring Data a | | 423
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
functions. Able to create, load, merge, and split PDF document using C#.NET code, without depending on any product from Adobe. Compatible
scan multiple pages into one pdf; c# merge pdf pages
C# PDF Page Insert Library: insert pages into PDF file in C#.net
for each of those page processing functions, such as how to merge PDF document files NET, how to reorganize PDF document pages and how to split PDF document in
adding pdf pages together; batch combine pdf
>>> def signature(word):
...     for patt, repl in mappings:
...         word = re.sub(patt, repl, word)
...     pieces = re.findall('[^aeiou]+', word)
>>> signature('illefent')
'lfnt'
>>> signature('ebsekwieous')
'bskws'
>>> signature('nuculerr')
'nclr'
Next, we create a mapping from signatures to words, for all the words in our lexicon.
We can use this to get candidate corrections for a given input word (but we must first
compute that word’s signature).
>>> signatures[signature('nuculerr')]
Finally, we should rank the results in terms of similarity with the original word. This
is done by the function 
rank()
. The only remaining function provides a simple interface
to the user:
>>> def rank(word, wordlist):
...     return [word for (_, word) in ranked]
>>> def fuzzy_spell(word):
...     sig = signature(word)
...     if sig in signatures:
...         return rank(word, signatures[sig])
...     else:
...         return []
>>> fuzzy_spell('illefent')
>>> fuzzy_spell('ebsekwieous')
['obsequious']
>>> fuzzy_spell('nucular')
This is just one illustration where a simple program can facilitate access to lexical data
in a context where the writing system of a language may not be standardized, or where
users of the language may not have a good command of spellings. Other simple appli-
cations of NLP in this area include building indexes to facilitate access to data, gleaning
wordlists from texts, locating examples of word usage in constructing a lexicon, de-
tecting prevalent or exceptional patterns in poorly understood data, and performing
specialized validation on data created using various linguistic software tools. We will
return to the last of these in Section 11.5.
424 | | Chapter 11: Managing Linguistic Data
11.4  Working with XML
The Extensible Markup Language (XML) provides a framework for designing domain-
specific markup languages. It is sometimes used for representing annotated text and
for lexical resources. Unlike HTML with its predefined tags, XML permits us to make
up our own tags. Unlike a database, XML permits us to create data without first spec-
ifying its structure, and it permits us to have optional and repeatable elements. In this
section, we briefly review some features of XML that are relevant for representing lin-
guistic data, and show how to access data stored in XML files using Python programs.
Using XML for Linguistic Structures
Thanks to its flexibility and extensibility, XML is a natural choice for representing
linguistic structures. Here’s an example of a simple lexical entry.
(2)
<entry>
<headword>whale</headword>
<pos>noun</pos>
<gloss>any of the larger cetacean mammals having a streamlined
body and breathing through a blowhole on the head</gloss>
</entry>
It consists of a series of XML tags enclosed in angle brackets. Each opening tag, such
as 
<gloss>
, is matched with a closing tag, 
</gloss>
; together they constitute an XML
element. The preceding example has been laid out nicely using whitespace, but it could
equally have been put on a single long line. Our approach to processing XML will
usually not be sensitive to whitespace. In order for XML to be well formed, all opening
tags must have corresponding closing tags, at the same level of nesting (i.e., the XML
document must be a well-formed tree).
XML permits us to repeat elements, e.g., to add another gloss field, as we see next. We
will use different whitespace to underscore the point that layout does not matter.
(3)
<entry><headword>whale</headword><pos>noun</pos><gloss>any of the
larger cetacean mammals having a streamlined body and breathing
through a blowhole on the head</gloss><gloss>a very large person;
impressive in size or qualities</gloss></entry>
A further step might be to link our lexicon to some external resource, such as WordNet,
using external identifiers. In (4) we group the gloss and a synset identifier inside a new
element, which we have called “sense.”
(4)
<entry>
<headword>whale</headword>
<pos>noun</pos>
<sense>
<gloss>any of the larger cetacean mammals having a streamlined
body and breathing through a blowhole on the head</gloss>
<synset>whale.n.02</synset>
11.4  Working with XML L | | 425
</sense>
<gloss>a very large person; impressive in size or qualities</gloss>
<synset>giant.n.04</synset>
</sense>
</entry>
Alternatively, we could have represented the synset identifier using an XML
attribute, without the need for any nested structure, as in (5).
(5)
<entry>
<headword>whale</headword>
<pos>noun</pos>
<gloss synset="whale.n.02">any of the larger cetacean mammals having
<gloss synset="giant.n.04">a very large person; impressive in size or
qualities</gloss>
</entry>
This illustrates some of the flexibility of XML. If it seems somewhat arbitrary, that’s
because it is! Following the rules of XML, we can invent new attribute names, and nest
them as deeply as we like. We can repeat elements, leave them out, and put them in a
different order each time. We can have fields whose presence depends on the value of
some other field; e.g., if the part of speech is 
verb
, then the entry can have a
past_tense
element to hold the past tense of the verb, but if the part of speech is 
noun
,
no 
past_tense
element is permitted. To impose some order over all this freedom, we
can constrain the structure of an XML file using a “schema,” which is a declaration
akin to a context-free grammar. Tools exist for testing the validity of an XML file with
respect to a schema.
The Role of XML
We can use XML to represent many kinds of linguistic information. However, the
flexibility comes at a price. Each time we introduce a complication, such as by permit-
ting an element to be optional or repeated, we make more work for any program that
accesses the data. We also make it more difficult to check the validity of the data, or to
interrogate the data using one of the XML query languages.
Thus, using XML to represent linguistic structures does not magically solve the data
modeling problem. We still have to work out how to structure the data, then define
that structure with a schema, and then write programs to read and write the format
and convert it to other formats. Similarly, we still need to follow some standard prin-
ciples concerning data normalization. It is wise to avoid making duplicate copies of the
same information, so that we don’t end up with inconsistent data when only one copy
is changed. For example, a cross-reference that was represented as 
<xref>headword</
xref>
would duplicate the storage of the headword of some other lexical entry, and the
link would break if the copy of the string at the other location was modified. Existential
dependencies between information types need to be modeled, so that we can’t create
elements without a home. For example, if sense definitions cannot exist independently
426 | | Chapter 11: Managing Linguistic Data
of a lexical entry, the 
sense
element can be nested inside the 
entry
element. Many-to-
many relations need to be abstracted out of hierarchical structures. For example, if a
word can have many corresponding senses, and a sense can have several corresponding
words, then both words and senses must be enumerated separately, as must the list of
(wordsense) pairings. This complex structure might even be split across three separate
XML files.
As we can see, although XML provides us with a convenient format accompanied by
an extensive collection of tools, it offers no panacea.
The ElementTree Interface
Python’s 
ElementTree
module provides a convenient way to access data stored in XML
files. 
ElementTree
is part of Python’s standard library (since Python 2.5), and is also
provided as part of NLTK in case you are using Python 2.4.
We will illustrate the use of 
ElementTree
using a collection of Shakespeare plays that
have been formatted using XML. Let’s load the XML file and inspect the raw data, first
at the top of the file 
, where we see some XML headers and the name of a schema
called 
play.dtd
, followed by the root element 
PLAY
. We pick it up again at the start of
Act 1 
. (Some blank lines have been omitted from the output.)
>>> raw = open(merchant_file).read()
>>> print raw[0:168] 
<?xml version="1.0"?>
<?xml-stylesheet type="text/css" href="shakes.css"?>
<!-- <!DOCTYPE PLAY SYSTEM "play.dtd"> -->
<PLAY>
<TITLE>The Merchant of Venice</TITLE>
>>> print raw[1850:2075] 
<TITLE>ACT I</TITLE>
<SCENE><TITLE>SCENE I.  Venice. A street.</TITLE>
<STAGEDIR>Enter ANTONIO, SALARINO, and SALANIO</STAGEDIR>
<SPEECH>
<SPEAKER>ANTONIO</SPEAKER>
<LINE>In sooth, I know not why I am so sad:</LINE>
We have just accessed the XML data as a string. As we can see, the string at the start
of Act 1 contains XML tags for title, scene, stage directions, and so forth.
The next step is to process the file contents as structured XML data, using 
Element
Tree
. We are processing a file (a multiline string) and building a tree, so it’s not sur-
prising that the method name is 
parse
. The variable 
merchant
contains an XML ele-
ment 
PLAY
. This element has internal structure; we can use an index to get its first
child, a 
TITLE
element 
. We can also see the text content of this element, the title of
the play 
. To get a list of all the child elements, we use the 
getchildren()
method 
.
>>> from nltk.etree.ElementTree import ElementTree
>>> merchant = ElementTree().parse(merchant_file) 
>>> merchant
11.4  Working with XML L | | 427
<Element PLAY at 22fa800> 
>>> merchant[0]
<Element TITLE at 22fa828> 
>>> merchant[0].text
'The Merchant of Venice' 
>>> merchant.getchildren() 
The play consists of a title, the personae, a scene description, a subtitle, and five acts.
Each act has a title and some scenes, and each scene consists of speeches which are
made up of lines, a structure with four levels of nesting. Let’s dig down into Act IV:
>>> merchant[-2][0].text
'ACT IV'
>>> merchant[-2][1]
<Element SCENE at 224cf80>
>>> merchant[-2][1][0].text
'SCENE I.  Venice. A court of justice.'
>>> merchant[-2][1][54]
<Element SPEECH at 226ee40>
>>> merchant[-2][1][54][0]
<Element SPEAKER at 226ee90>
>>> merchant[-2][1][54][0].text
'PORTIA'
>>> merchant[-2][1][54][1]
<Element LINE at 226eee0>
>>> merchant[-2][1][54][1].text
"The quality of mercy is not strain'd,"
Your Turn: Repeat some of the methods just shown, for one of the
other Shakespeare plays included in the corpus, such as Romeo and Ju-
liet or Macbeth. For a list, see 
nltk.corpus.shakespeare.fileids()
.
Although we can access the entire tree this way, it is more convenient to search for sub-
elements with particular names. Recall that the elements at the top level have several
types. We can iterate over just the types we are interested in (such as the acts), using
merchant.findall('ACT')
. Here’s an example of doing such tag-specific searches at ev-
ery level of nesting:
>>> for i, act in enumerate(merchant.findall('ACT')):
...     for j, scene in enumerate(act.findall('SCENE')):
...             for line in speech.findall('LINE'):
...                 if 'music' in str(line.text):
Act 3 Scene 2 Speech 9: Let music sound while he doth make his choice;
Act 3 Scene 2 Speech 9: Fading in music: that the comparison
Act 3 Scene 2 Speech 9: And what is music then? Then music is
Act 5 Scene 1 Speech 23: And bring your music forth into the air.
Act 5 Scene 1 Speech 23: Here will we sit and let the sounds of music
428 | | Chapter 11: Managing Linguistic Data
Documents you may be interested
Documents you may be interested