2018年07月01日

言語処理100本ノックでPython入門 #56 - Stanford Core NLPの共参照解析



今日は、言語処理100本ノック 2015の第6章・問題56です。

Python言語を入門しようと思って始めた「言語処理100本ノック2015」ですが、もう完全にPython入門じゃなくて、言語処理入門の問題を解くって感じになってきました。
初めて目にする専門用語などもあって、これっていつか役に立つこともあるのかな?と疑問もでてきました。入門として選んだ題材を間違えた(笑)という気もしないではないですが、せっかくここまで来たのでもう少し続けようと思います。


■ 問題
56. 共参照解析
Stanford Core NLPの共参照解析の結果に基づき,文中の参照表現(mention)を代表参照表現(representative mention)に置換せよ.ただし,置換するときは,「代表参照表現(参照表現)」のように,元の参照表現が分かるように配慮せよ.

■ nlp.txt.xmlファイルの再作成


問題53で作成したnlp.txt.xmlファイルだと、情報量が少なかったので、以下のコマンドで再作成しています。

java -cp "/Users/hideyuki/Documents/Dev/corenlp/*" -Xmx3g edu.stanford.nlp.pipeline.StanfordCoreNLP -annotators tokenize,ssplit,pos,lemma,ner,parse,dcoref -file nlp.txt


これで、以下のような共参照解析の結果が、xmlに付加されます。
<coreference>
  <coreference>
    <mention representative="true">
      <sentence>3</sentence>
      <start>24</start>
      <end>25</end>
      <head>24</head>
      <text>computers</text>
    </mention>
    <mention>
      <sentence>5</sentence>
      <start>14</start>
      <end>15</end>
      <head>14</head>
      <text>computers</text>
    </mention>
  </coreference>
  ...
representative="true"の属性のあるのが「代表参照表現」で、この属性の無いのが「参照表現」です(たぶん)。 start, endは、tokenの番号です。

なので、この「参照表現」の指すtokenを、「代表参照表現」の指すtokenに置換すれば良いことになります。まあ、置換といっても、「代表参照表現(参照表現)」という形式にするということなので、どちらかというと挿入という感じですかね。

■ 置き換え処理を考える

</mention>要素の情報を使って置換処理を考えるわけですが、オリジナルのテキストファイルを元に置換処理を行うのはちょっと難しそうです。

そのため、XMLのDOMTreeを書き換え、それを元にtextファイルを復元するようにしました。

ただし、XMLでは、改行や空白などの情報が消えてしまっているので、それも含めての復元はできませんが、それなりの形になったと思います。

ちなみに、Stanford Core NLPの共参照解析の結果そのものが「これでいいのかな?」と疑問に思うようなものがあります。でもそれはもうどうしようもないです。


■ Pythonのコード

今回は、CoreferenceAnalyserというクラスを定義してみました。 いままでは関数主体のコードでしたが、C#erの僕には今回のようにclassを定義したほうがしっくりきますね。

from xml.etree import ElementTree

class CoreferenceAnalyser:
    def __init__(self, filepath):
        xdoc = ElementTree.parse(filepath)
        root = xdoc.getroot()
        self.sentences = root.find('document/sentences')
        self.coreference = root.find('document/coreference')

    def enumCoreference(self):
        for e in self.coreference:
            yield e

    # mentionのtext内容をrepresentativeMentionの内容に置き換える
    def replaceMention(self, mention, representativeMention):
        sentenceid = mention.find('sentence').text
        startid = mention.find('start').text
        endid = str(int(mention.find('end').text) - 1)
        targetSentence = self.sentences.find("sentence[@id='" + sentenceid  + "']")
        startToken = targetSentence.find("tokens/token[@id='" + startid + "']")
        endToken = targetSentence.find("tokens/token[@id='" + endid + "']")

        text = representativeMention.find('text').text

        startword = startToken.find('word')
        startword.text = '「{}({}'.format(text, startword.text)
        endword = endToken.find('word')
        endword.text = endword.text + ')」'

    def replaceAll(self):
        for cf in self.enumCoreference():
            rm = cf.find("mention[@representative='true']")
            for m in cf.findall('mention'):
                if 'representative' in m.attrib:
                    continue
                self.replaceMention(m, rm)

    def writeText(self):
        with open('result56.txt', 'w', encoding='utf8') as w:
            prev = ''
            for e in self.sentences.findall('sentence/tokens/token'):
                word = e.find('word').text
                if word == '-LRB-':
                    word = '('
                elif word == '-RRB-':
                    word = ')'
                if word == '.':
                    w.write(word + '\n')
                elif word == ',' or word == '?' or word == '\'' or word == ')':
                    w.write(word)
                elif word == '(':
                    prev = word
                else:
                    if prev == '(':
                        w.write(' (' + word)
                    else:
                        w.write(' ' + word)
                    prev = ''

def main():
    ca = CoreferenceAnalyser('nlp.txt.xml')
    ca.replaceAll()
    ca.writeText()

if __name__ == '__main__':
    main()

■ 結果
 Natural language processing.
 From Wikipedia, the free encyclopedia.
 Natural language processing (NLP) is a field of computer science, artificial intelligence, and linguistics concerned with the interactions between computers and human (natural) languages.
 As such, NLP is related to the area of humani-computer interaction.
 Many challenges in NLP involve natural language understanding, that is, enabling 「computers(computers)」 to derive meaning from human or natural language input, and others involve natural language generation.
 History.
 The history of NLP generally starts in the 1950s, although work can be found from earlier periods.
 In 1950, Alan Turing published an article titled `` Computing Machinery and Intelligence '' which proposed what is now called the 「Alan Turing(Turing)」 test as a criterion of intelligence.
 The Georgetown experiment in 1954 involved fully automatic translation of more than sixty Russian sentences into English.
 The authors claimed that within three or five years, 「a solved problem(machine translation)」 would be a solved problem.
 However, real progress was much slower, and after the ALPAC report in 1966, which found that ten year long research had failed to fulfill the expectations, funding for machine translation was dramatically reduced.
 Little further research in 「a solved problem(machine translation)」 was conducted until the late 1980s, when the first statistical machine translation systems were developed.
 Some notably successful NLP systems developed in the 1960s were SHRDLU, 「SHRDLU(a natural language system working in restricted `` blocks worlds '' with restricted vocabularies)」, and ELIZA, a simulation of a Rogerian psychotherapist, written by Joseph Weizenbaum between 1964 to 1966.
 Using almost no information about human thought or emotion, ELIZA sometimes provided a startlingly human-like interaction.
 When the `` patient '' exceeded the very small knowledge base, 「ELIZA(ELIZA)」 might provide a generic response, for example, responding to `` 「the `` patient ''(My)」 head hurts '' with `` Why do you say 「you(「My head(your)」 head)」 hurts? ''.
 During the 1970s many programmers began to write ` conceptual ontologies', which structured real-world information into computer-understandable data.
 Examples are MARGIE (Schank, 1975), SAM (Cullingford, 1978), PAM (Wilensky, 「1978(1978)」), TaleSpin (Meehan, 1976), QUALM (Lehnert, 1977), Politics (Carbonell, 1979), and Plot Units (「Lehnert(Lehnert 1981)」).
 During this time, many chatterbots were written including PARRY, Racter, and Jabberwacky.
 Up to 「the late 1980s(the 1980s)」, most 「NLP(NLP)」 systems were based on complex sets of hand-written rules.
 Starting in 「the late 1980s(the late 1980s)」, however, there was a revolution in NLP with the introduction of machine learning algorithms for language processing.
 This was due to both the steady increase in computational power resulting from Moore 's Law and the gradual lessening of the dominance of Chomskyan theories of linguistics (e.g. transformational grammar), whose theoretical underpinnings discouraged the sort of corpus linguistics that underlies the machine-learning approach to 「language processing(language processing)」.
 Some of the earliest-used machine learning 「machine learning algorithms for language processing(algorithms)」, such as decision trees, produced systems of hard if-then rules similar to existing hand-written rules.
 However, Part of speech tagging introduced the use of Hidden Markov Models to 「NLP(NLP)」, and increasingly, research has focused on 「statistical models(statistical models, which make soft, probabilistic decisions based on attaching real-valued weights to the features making up the input data)」.
 The cache language models upon which many speech recognition systems now rely are 「The cache language models upon which many speech recognition systems now rely(examples of such statistical models)」.
 Such models are generally more robust when given unfamiliar input, especially 「as input(input that contains errors (as is very common for real-world data -RRB-)」, and produce more reliable results when integrated into a larger system comprising multiple subtasks.
 Many of the notable early successes occurred in the field of 「a solved problem(「a solved problem(machine translation)」, due especially to work at IBM Research, where successively more complicated statistical models were developed)」.
 「many speech recognition systems(These systems)」 were able to take 「the advantage(advantage of existing multilingual textual corpora that had been produced by the Parliament of Canada and the European Union as a result of laws calling for the translation of all governmental proceedings into all official languages of the corresponding systems of government)」.
 However, most other systems depended on corpora specifically developed for the tasks implemented by 「many speech recognition systems(these systems)」, which was (and often continues to be) a major limitation in the success of 「many speech recognition systems(these systems)」.
 As a result, a great deal of research has gone into methods of more effectively learning from limited amounts of data.
 Recent research has increasingly focused on unsupervised and semi-supervised learning algorithms.
 Such algorithms are able to learn from 「data(data that has not been hand-annotated with the desired answers)」, or using a combination of annotated and non-annotated data.
 Generally, this task is much more difficult than supervised learning, and typically produces less accurate results for a given amount of input data.
 However, there is an enormous amount of non-annotated data available (including, among other things, the entire content of the World Wide Web), which can often make up for the inferior results.
 NLP using machine learning.
 Modern NLP algorithms are based on 「machine learning(「machine learning(machine learning)」, especially statistical machine learning)」.
 The paradigm of 「machine learning(machine learning)」 is different from that of most prior attempts at 「language processing(language processing)」.
 Prior implementations of language-processing tasks typically involved the direct hand coding of large sets of 「hard if-then rules similar to existing hand-written rules(rules)」.
 The machine-learning paradigm calls instead for using general learning algorithms - often, although not always, grounded in statistical inference - to automatically learn such rules through the analysis of large corpora of typical real-world examples.
 A corpus (plural, 「existing multilingual textual corpora that had been produced by the Parliament of Canada and the European Union as a result of laws calling for the translation of all governmental proceedings into all official languages of the corresponding systems of government(`` corpora '')」) is 「A corpus -LRB- plural , `` corpora '' -RRB-(a set of documents (or sometimes, individual sentences) that have been hand-annotated with the correct values to be learned)」.
 Many different classes of 「machine learning algorithms for language processing(machine learning algorithms)」 have been applied to NLP tasks.
 「machine learning algorithms for language processing(These algorithms)」 take as input a large set of `` features '' that are generated from 「the input data(the input data)」.
 Some of the earliest-used algorithms, such as 「decision trees(decision trees)」, produced systems of hard if-then rules similar to the systems of 「hand-written rules(hand-written rules)」 that were then common.
 Increasingly, however, research has focused on 「statistical models(「statistical models(statistical models)」, which make 「soft , probabilistic decisions(soft, probabilistic decisions)」 based on attaching 「real-valued weights(real-valued weights)」 to each input feature)」.
 Such models have the advantage that 「Some of the earliest-used algorithms , such as decision trees(they)」 can express the relative certainty of many different possible answers rather than only one, producing more reliable results when such a model is included as a component of a larger system.
 Systems based on machine-learning algorithms have many advantages over hand-produced rules : The learning procedures used during 「machine learning(machine learning)」 automatically focus on the most common cases, whereas when writing 「hard if-then rules similar to existing hand-written rules(rules)」 by hand it is often not obvious at all where the effort should be directed.
 Automatic learning 「The learning procedures used during machine learning(procedures)」 can make use of statistical inference algorithms to produce models that are robust to unfamiliar input (e.g. containing words or structures that have not been seen before) and to erroneous input (e.g. with misspelled words or words accidentally omitted).
 Generally, handling such input gracefully with 「hand-written rules(hand-written rules)」 -- or more generally, creating systems of 「hand-written rules(hand-written rules)」 that make soft decisions -- extremely difficult, error-prone and time-consuming.
 Systems based on automatically learning the rules can be made more accurate simply by supplying more input data.
 However, 「the systems(systems based on 「hand-written rules(hand-written rules)」)」 can only be made more accurate by increasing the complexity of 「the rules(「the rules(the rules)」, which is a much more difficult task)」.
 In particular, there is a limit to the complexity of systems based on hand-crafted rules, beyond which the systems become more and more unmanageable.
 However, creating more data to input to 「Systems based on machine-learning algorithms(machine-learning systems)」 simply requires a corresponding increase in the number of man-hours worked, generally without significant increases in the complexity of the annotation process.
 The subfield of NLP devoted to learning approaches is known as Natural Language Learning (NLL) and 「Natural Language Learning -LRB- NLL -RRB-(its)」 conference CoNLL and peak body SIGNLL are sponsored by ACL, recognizing also their links with Computational Linguistics and Language Acquisition.
 When the aims of computational language learning research is to understand more about human language acquisition, or psycholinguistics, NLL overlaps into the related field of Computational Psycholinguistics.
  

Posted by gushwell at 22:30Comments(0)Python

2018年06月27日

言語処理100本ノックでPython入門 #55 - Stanford Core NLPの出力から人名を抜き出す



今日は、言語処理100本ノック 2015の第6章・問題55を解きます。

■ 問題
55. 固有表現抽出
入力文中の人名をすべて抜き出せ.

■ どうやって解くか

まず、Stanford Core NLPが出力した解析結果(xmlフィル)ファイルを見てみます。

人名の場合には、以下のようにNERタグが PERSON となっています。
これを抜き出せばOKですね。

<token id="4">
  <word>Alan</word>
  <lemma>Alan</lemma>
  <CharacterOffsetBegin>646</CharacterOffsetBegin>
  <CharacterOffsetEnd>650</CharacterOffsetEnd>
  <POS>NNP</POS>
  <NER>PERSON</NER>
  <Speaker>PER0</Speaker>
</token

■ Pythonのコード

from xml.etree import ElementTree

def getWords():
    xdoc = ElementTree.parse('nlp.txt.xml')
    root = xdoc.getroot()
    sentences = root.find('document/sentences')
    for e in sentences.findall('sentence/tokens/token'):
        if e.find('NER').text == 'PERSON':
            yield e.find('word')


def main():
    with open('result55.txt', 'w', encoding='utf8') as w:
        for word in getWords():
            w.write(f'{word.text}\n')


if __name__ == '__main__':
    main()


ソースコードは、GitHubで公開しています。

■ 結果

以下、結果です。
Alan
Turing
Joseph
Weizenbaum
MARGIE
Schank
Wilensky
Meehan
Lehnert
Carbonell
Lehnert
Racter
Jabberwacky
Moore
  
Posted by gushwell at 22:30Comments(0)Python

2018年06月24日

言語処理100本ノックでPython入門 #54 - Stanford Core NLPの出力を品詞タグ付け


今日は、言語処理100本ノック 2015の第6章・問題54を解きます。

■ 問題

54. 品詞タグ付け
Stanford Core NLPの解析結果XMLを読み込み,単語,レンマ,品詞をタブ区切り形式で出力せよ.


■ Pythonのコード
import re
from xml.etree import ElementTree

def getWords():
    xdoc = ElementTree.parse('nlp.txt.xml')
    root = xdoc.getroot()
    sentences = root.find('document/sentences')
    for e in sentences.findall('sentence/tokens/token'):
        yield e.find('word'), e.find('lemma'), e.find('POS')

def main():
    with open('result54.txt', 'w', encoding='utf8') as w:
        for word, lemma, pos in getWords():
            m = re.search(r'[A-Z]', pos.text)
            if m:
                w.write(f'{word.text}\t{lemma.text}\t{pos.text}\n')


if __name__ == '__main__':
    main()

ソースコードは、GitHubで公開しています。

■ すこし説明

問題53とほとんど変わらないです。
getWords関数で以下のように3つのタプルを返すようにして、
for e in sentences.findall('sentence/tokens/token'):
    yield e.find('word'), e.find('lemma'), e.find('POS')
main関数では、このタプルの word.text, lemma.text, pos.txtををタブ区切りで出力しています。

ただし、ピリオドやカンマなどの記号を除外するために、正規表現を使っています。 pos.textがどのような値を取りうるのかがわからないのですが、ここでは、アルファベット大文字が1文字でも含まれて入れば、記号ではない別の品詞だと判断しています。
    m = re.search(r'[A-Z]', pos.text)
    if m:
        w.write(f'{word.text}\t{lemma.text}\t{pos.text}\n')

■ 結果

先頭の30行ほどを掲載します。
Natural	natural	JJ
Natural	natural	JJ
language	language	NN
processing	processing	NN
From	from	IN
Wikipedia	Wikipedia	NNP
the	the	DT
free	free	JJ
encyclopedia	encyclopedia	NN
Natural	natural	JJ
language	language	NN
processing	processing	NN
-LRB-	-lrb-	-LRB-
NLP	nlp	NN
-RRB-	-rrb-	-RRB-
is	be	VBZ
a	a	DT
field	field	NN
of	of	IN
computer	computer	NN
science	science	NN
artificial	artificial	JJ
intelligence	intelligence	NN
and	and	CC
linguistics	linguistics	NNS
concerned	concern	VBN
with	with	IN
the	the	DT
interactions	interaction	NNS
between	between	IN
computers	computer	NNS
  
Posted by gushwell at 23:00Comments(0)Python

2018年06月21日

言語処理100本ノックでPython入門 #53 - Stanford Core NLPの出力から単語抽出


今日は、言語処理100本ノック 2015の第6章・問題53です。

■ 問題 
53. Tokenization
Stanford Core NLPを用い,入力テキストの解析結果をXML形式で得よ.また,このXMLファイルを読み込み,入力テキストを1行1単語の形式で出力せよ.

■ Stanford Core NLPをダウンロード


以下のURLからStanford Core NLPをダウンロードします。

https://stanfordnlp.github.io/CoreNLP/


これを、corenlpというフォルダに配置します。

■ Stanford Core NLPを実行

以下のようなコマンドを投入し、Stanford Core NLPを起動します。
java -cp "/Users/xxxxxxx/corenlp/*" -Xmx3g edu.stanford.nlp.pipeline.StanfordCoreNLP -annotators tokenize,ssplit,pos,lemma,ner -file nlp.txt

これで、nlp.txt.xmlファイルが作成されます。

ちなみに、Javaのバージョンは、java version "1.8.0_101" です。

でも、作成したnlp.txt.xml見ると文の判断が正しくないので、入力ファイルを手で修正。
入力ファイルは、基本1行1文なのだけれど、Stanford Core NLPは、ピリオドが行の単位と認識するようなので、タイトル行の最後にもピリオドを付加しています。4か所くらいあったかな。

得られたXMLファイルの先頭部分を載せておきます。
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="CoreNLP-to-HTML.xsl" type="text/xsl"?>
<root>
  <document>
    <docId>nlp.txt</docId>
    <sentences>
      <sentence id="1">
        <tokens>
          <token id="1">
            <word>Natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>0</CharacterOffsetBegin>
            <CharacterOffsetEnd>7</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>8</CharacterOffsetBegin>
            <CharacterOffsetEnd>16</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>processing</word>
            <lemma>processing</lemma>
            <CharacterOffsetBegin>17</CharacterOffsetBegin>
            <CharacterOffsetEnd>27</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>

■ XMLファイルを操作する

XMLファイルを読み込むには、xml.etreeライブラリを使います。
from xml.etree import ElementTree
次に、入力ファイルを指定し、nlp.txt.xmlをパースします。
xdoc = ElementTree.parse('nlp.txt.xml')
これで、読み込んだ結果がtree構造として返されます。

続いて、ルートを取得します。
root = xdoc.getroot()
このrootを使い、必要な要素を取り出していきます。
sentences = root.find('document/sentences')
で、rootの直下から、パスを指定してXML elementを取得。

さらに、
for e in sentences.findall('sentence/tokens/token/word'):
        yield e
で、word要素をすべて取り出します。 実際のテキストは、
e.text
で取得できます。


■ Pythonのコード

作成したPythonのコードです。
from xml.etree import ElementTree

def getWords():
    xdoc = ElementTree.parse('nlp.txt.xml')
    root = xdoc.getroot()
    sentences = root.find('document/sentences')
    for e in sentences.findall('sentence/tokens/token/word'):
        yield e


def main():
    with open('result53.txt', 'w', encoding='utf8') as w:
        for word in getWords():
            w.write(f'{word.text}\n')
       
if __name__ == '__main__':
    main()


ソースはGitHubでも公開しています。

■ 結果

結果の先頭部分を載せます。
ピリオドやカンマも抽出しています。本来は、これらは除外すべきかもしれませんが良しとします。
Natural
language
processing
.
From
Wikipedia
,
the
free
encyclopedia
.
Natural
language
processing
-LRB-
NLP
-RRB-
is
a
field
of
computer
science
,
artificial
intelligence
,
and
linguistics
concerned
  
Posted by gushwell at 07:40Comments(0)Python

2018年06月17日

言語処理100本ノックでPython入門 #52 - nltkでステミング


今日は、言語処理100本ノック 2015の第6章・問題52を解きます。

■ 問題
52. ステミング
51の出力を入力として受け取り,Porterのステミングアルゴリズムを適用し,単語と語幹をタブ区切り形式で出力せよ. Pythonでは,Porterのステミングアルゴリズムの実装としてstemmingモジュールを利用するとよい.

■ nltkライブラリのstemモジュールを使う


ステミングとは、単語の変化形の変化した部分を取り除く処理のことらしいです。

問題に、「stemmingモジュールを利用するとよい」とあるので、以下のようなコマンドを投入。
conda install stemming
でも、以下のエラーが出て見つかりません。
Solving environment: failed

PackagesNotFoundError: The following packages are not available from current channels:

  - stemming
そもそもこのstemmingライブラリは、python3.xに非対応らしいです。

python3.xで利用できるステミングモジュールはないかな、って調べたら、nltk というパッケージでstemmingができるらしいです。

僕が利用しているpythonのanacondaは、デフォルトでいろんなライブラリが入っているので、まずは、anacondaにあるかどうか調べます。
conda list
とやったら、
nltk                      3.2.2                    py36_0
と出てきました。これを使おうとおもいます。

from nltk import stem
で stem モジュールをimportします。

でも、pylintが以下のようなエラーを吐きます。
F0002:<class 'AttributeError'>: 'TreeRebuilder3k' object has no attribute 'visit_joinedstr'
どうも、pylintが古いみたいです。

無視してもいいのですが、せっかくなので、pylintを新しくします。
conda install -c anaconda pylint
無事、エラーが消えました。


では、stemを使って、Porterのステミングアルゴリズムで語幹を取り出します。
stemmer = stem.PorterStemmer()
stm = stemmer.stem(word)
とすれば、語幹が得られます。stemとは語幹という意味です。

ちなみに、
stemmer = stem.LancasterStemmer()
とすれば、LancasterStemmerという別のアルゴリズムも使えるみたいです。


■ Pythonのコード


以下、出来上がったPythonのコードを載せます。
from nltk import stem

def enumStem():
    stemmer = stem.PorterStemmer()
    #stemmer = stem.LancasterStemmer()
    with open('result51.txt', 'r', encoding='utf8') as fin:
        for line in fin:
            word = line.rstrip('\n')
            if word != '':
                yield word, stemmer.stem(word)

def main():
    with open('result52.txt', 'w', encoding='utf8') as w:
        for word, stm in enumStem():
            w.write(f'{word}\t{stm}\n')

if __name__ == '__main__':
    main()


ソースはGitHubでも公開しています。


そうだ、書き忘れていたけど、Pythonでも、C#の逐語的リテラル文字列のような書き方ができるようになったんですね。

f'{word}\t{stm}\n' 

便利になりました。


■ 結果
Natural	natur
language	languag
processing	process
From	from
Wikipedia	wikipedia
the	the
free	free
encyclopedia	encyclopedia
Natural	natur
language	languag
processing	process
NLP	nlp
is	is
a	a
field	field
of	of
computer	comput
science	scienc
artificial	artifici
intelligence	intellig
and	and
linguistics	linguist
concerned	concern
with	with
the	the
interactions	interact
between	between
computers	comput
and	and
human	human
... 以下省略
  
Posted by gushwell at 22:30Comments(0)Python

2018年06月12日

言語処理100本ノックでPython入門 #51 - 英文テキスト 単語の切り出し



今日は、言語処理100本ノック 2015の第6章・問題51を解きます。

■ 問題

51. 単語の切り出し
空白を単語の区切りとみなし,50の出力を入力として受け取り,1行1単語の形式で出力せよ.ただし,文の終端では空行を出力せよ.


■ Pythonのコード
import re

def enumWords():
    with open('result50.txt', 'r', encoding='utf8') as fin:
        for line in fin:
            words = re.split(r'[\s\.",:;()]+', line)
            for w in words:
                if re.match(r'^[a-zA-Z]', w):
                    yield w

def main():
    with open('result51.txt', 'w', encoding='utf8') as w:
        w.writelines([x + '\n' for x in enumWords()])

if __name__ == '__main__':
    main()


ソースコードは、GitHubで公開しています。


■ ちょっと説明

単純に空白を区切り文字としてプログラム書いて実行して結果をみると、出力ファイルの中に以下のような内容がありました。
In
1950,
Alan
Turing
published
an
article
titled
"Computing
Machinery
and
Intelligence"
which
...

なんか、常識的に考えておかしいです。
「空白を単語の区切り」とあるけど、, " ( ) ? などの記号をどうしたらよいかは、問題読んでもよくわからないんですよね。

ということで、単語の区切りとなりそうな空白以外の記号も区切り記号として書き直したのが上のコードです。

それと、今回初めて、writelinesメソッド使ってみました。これで一気に複数行をファイルに出力できます。 でも、引数の配列の各行の最後に改行入れないといけないのが面倒です。
with open('result51.txt', 'w', encoding='utf8') as w:
    w.writelines([x + '\n' for x in enumWords()])

■ 結果

先頭の30語だけ掲載します。
Natural
language
processing
From
Wikipedia
the
free
encyclopedia
Natural
language
processing
NLP
is
a
field
of
computer
science
artificial
intelligence
and
linguistics
concerned
with
the
interactions
between
computers
and
human
  
Posted by gushwell at 08:00Comments(0)Python