chapter05.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "! cat data/neko.txt | cabocha -f3 > data/neko.txt.cabocha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 40. 係り受け解析結果の読み込み（形態素）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Morph:\n",
    "    def __init__(self, token):\n",
    "        self.surface = token.text\n",
    "        feature = token.attrib['feature'].split(',')\n",
    "        self.base = feature[6]\n",
    "        self.pos = feature[0]\n",
    "        self.pos1 = feature[1]\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return self.surface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xml.etree.ElementTree as ET\n",
    "\n",
    "with open(\"data/neko.txt.cabocha\") as f:\n",
    "    root = ET.fromstring(\"<sentences>\" + f.read() + \"</sentences>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "neko = []\n",
    "for sent in root:\n",
    "    sent = [chunk for chunk in sent]\n",
    "    sent = [Morph(token) for chunk in sent for token in chunk]\n",
    "    neko.append(sent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　\n",
      "吾輩\n",
      "は\n",
      "猫\n",
      "で\n",
      "ある\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "for x in neko[2]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 41. 係り受け解析結果の読み込み（文節・係り受け）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Chunk(list):\n",
    "    def __init__(self, chunk):\n",
    "        self.morphs = [Morph(morph) for morph in chunk]\n",
    "        super().__init__(self.morphs)\n",
    "        self.dst = int(chunk.attrib['link'])\n",
    "        self.srcs = []\n",
    "    \n",
    "    def __repr__(self): # 問42で使う\n",
    "        return re.sub(r'[、。]', '', ''.join(map(str, self)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "文のクラスも作ってみます"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence(list):\n",
    "    def __init__(self, sent):\n",
    "        self.chunks = [Chunk(chunk) for chunk in sent]\n",
    "        super().__init__(self.chunks)\n",
    "        for i, chunk in enumerate(self.chunks):\n",
    "            if chunk.dst != -1:\n",
    "                self.chunks[chunk.dst].srcs.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "neko = [Sentence(sent) for sent in root]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tabulate import tabulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  番号</th><th>文節      </th><th style=\"text-align: right;\">  係り先</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">     0</td><td>吾輩は    </td><td style=\"text-align: right;\">       5</td></tr>\n",
       "<tr><td style=\"text-align: right;\">     1</td><td>ここで    </td><td style=\"text-align: right;\">       2</td></tr>\n",
       "<tr><td style=\"text-align: right;\">     2</td><td>始めて    </td><td style=\"text-align: right;\">       3</td></tr>\n",
       "<tr><td style=\"text-align: right;\">     3</td><td>人間という</td><td style=\"text-align: right;\">       4</td></tr>\n",
       "<tr><td style=\"text-align: right;\">     4</td><td>ものを    </td><td style=\"text-align: right;\">       5</td></tr>\n",
       "<tr><td style=\"text-align: right;\">     5</td><td>見た。    </td><td style=\"text-align: right;\">      -1</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "'<table>\\n<thead>\\n<tr><th style=\"text-align: right;\">  番号</th><th>文節      </th><th style=\"text-align: right;\">  係り先</th></tr>\\n</thead>\\n<tbody>\\n<tr><td style=\"text-align: right;\">     0</td><td>吾輩は    </td><td style=\"text-align: right;\">       5</td></tr>\\n<tr><td style=\"text-align: right;\">     1</td><td>ここで    </td><td style=\"text-align: right;\">       2</td></tr>\\n<tr><td style=\"text-align: right;\">     2</td><td>始めて    </td><td style=\"text-align: right;\">       3</td></tr>\\n<tr><td style=\"text-align: right;\">     3</td><td>人間という</td><td style=\"text-align: right;\">       4</td></tr>\\n<tr><td style=\"text-align: right;\">     4</td><td>ものを    </td><td style=\"text-align: right;\">       5</td></tr>\\n<tr><td style=\"text-align: right;\">     5</td><td>見た。    </td><td style=\"text-align: right;\">      -1</td></tr>\\n</tbody>\\n</table>'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table = [\n",
    "    [''.join([morph.surface for morph in chunk]), chunk.dst]\n",
    "    for chunk in neko[7]\n",
    "]\n",
    "tabulate(table, tablefmt = 'html', headers = ['番号', '文節', '係り先'], showindex = 'always')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 42. 係り元と係り先の文節の表示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "吾輩は\t見た\n",
      "ここで\t始めて\n",
      "始めて\t人間という\n",
      "人間という\tものを\n",
      "ものを\t見た\n"
     ]
    }
   ],
   "source": [
    "sent = neko[7]\n",
    "for chunk in sent:\n",
    "    if chunk.dst != -1:\n",
    "        src = chunk\n",
    "        dst = sent[chunk.dst]\n",
    "        print(f'{src}\\t{dst}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 43. 名詞を含む文節が動詞を含む文節に係るものを抽出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_noun(chunk):\n",
    "    return any(morph.pos == '名詞' for morph in chunk)\n",
    "\n",
    "def has_verb(chunk):\n",
    "    return any(morph.pos == '動詞' for morph in chunk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "吾輩は\t見た\n",
      "ここで\t始めて\n",
      "ものを\t見た\n"
     ]
    }
   ],
   "source": [
    "sent = neko[7]\n",
    "for chunk in sent:\n",
    "    if chunk.dst != -1 and has_noun(chunk) and has_verb(sent[chunk.dst]):\n",
    "        src = chunk\n",
    "        dst = sent[chunk.dst]\n",
    "        print(f'{src}\\t{dst}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 44. 係り受け木の可視化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydot import Dot, Edge, Node\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=265x443 at 0x7F3173FE9AF0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent = neko[7]\n",
    "\n",
    "graph = Dot(graph_type = 'digraph')\n",
    "\n",
    "# 節を作る\n",
    "for i, chunk in enumerate(sent):\n",
    "    node = Node(i, label = chunk)\n",
    "    graph.add_node(node)\n",
    "    \n",
    "# 枝を作る\n",
    "for i, chunk in enumerate(sent):\n",
    "    if chunk.dst != -1:\n",
    "        edge = Edge(i, chunk.dst)\n",
    "        graph.add_edge(edge)\n",
    "        \n",
    "graph.write_png('sent.png')\n",
    "Image.open('sent.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 45. 動詞の格パターンの抽出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_first_verb(chunk):\n",
    "    for morph in chunk:\n",
    "        if morph.pos == '動詞':\n",
    "            return morph.base\n",
    "\n",
    "def get_last_case(chunk):\n",
    "    for morph in chunk[::-1]:\n",
    "        if morph.pos == '助詞':\n",
    "            return morph.surface\n",
    "        \n",
    "def extract_cases(srcs):\n",
    "    xs = [get_last_case(src) for src in srcs]\n",
    "    xs = [x for x in xs if x]\n",
    "    xs.sort()\n",
    "    return xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('result/case_pattern.txt', 'w') as f:\n",
    "    for sent in neko:\n",
    "        for chunk in sent:\n",
    "            if verb := get_first_verb(chunk): # 動詞から始まる\n",
    "                srcs = [sent[src] for src in chunk.srcs]\n",
    "                if cases := extract_cases(srcs): # 助詞がある\n",
    "                    line = '{}\\t{}'.format(verb, ' '.join(cases))\n",
    "                    print(line, file=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   2645 ある\tが\r\n",
      "   1559 つく\tか が\r\n",
      "    840 云う\tは\r\n",
      "    553 する\tが で と\r\n",
      "    380 つかむ\tを\r\n",
      "    364 思う\tと\r\n",
      "    334 見る\tの\r\n",
      "    257 かく\tたり を\r\n",
      "    253 かかる\tが て\r\n",
      "    205 ある\tまで\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/case_pattern.txt | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1239 する\tが\r\n",
      "    806 する\tて は\r\n",
      "    313 する\tが で と\r\n",
      "    140 する\tでも に\r\n",
      "    102 する\tまで\r\n",
      "     84 する\tと は は は\r\n",
      "     59 する\tから が で\r\n",
      "     32 する\tから て て を\r\n",
      "     32 する\tを んで\r\n",
      "     24 する\tとして\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/case_pattern.txt | grep 'する' | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    334 見る\tの\r\n",
      "    121 見る\tは を\r\n",
      "     40 見る\tて て は\r\n",
      "     25 見る\tたり て\r\n",
      "     23 見る\tから\r\n",
      "     12 見る\tから て て\r\n",
      "      8 見る\tて に は を\r\n",
      "      7 見る\tが ので\r\n",
      "      3 見る\tて ばかり\r\n",
      "      3 見る\tが て んで\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/case_pattern.txt | grep '見る' | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      7 与える\tに を\r\n",
      "      4 与える\tで に を\r\n",
      "      3 与える\tて と は を\r\n",
      "      1 与える\tけれども は を\r\n",
      "      1 与える\tか として\r\n",
      "      1 与える\tが て と に は は を\r\n",
      "      1 与える\tて に に は を\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/case_pattern.txt | grep '与える' | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 46. 動詞の格フレーム情報の抽出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_args(srcs):\n",
    "    xs = [src for src in srcs if get_last_case(src)]\n",
    "    xs.sort(key = lambda src : get_last_case(src))\n",
    "    xs = [str(src) for src in xs]\n",
    "    return xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "生れる\tで\t　どこで\n",
      "つく\tか が\t生れたか 見当が\n",
      "泣く\tで\t所で\n",
      "する\tて は\t泣いて いた事だけは\n",
      "始める\tで\tここで\n",
      "見る\tは を\t吾輩は ものを\n",
      "聞く\tで\tあとで\n",
      "捕える\tを\t我々を\n",
      "煮る\tて\t捕えて\n",
      "食う\tて\t煮て\n"
     ]
    }
   ],
   "source": [
    "for sent in neko[:10]:\n",
    "    for chunk in sent:\n",
    "        if verb := get_first_verb(chunk): # 動詞で始まる\n",
    "            srcs = [sent[src] for src in chunk.srcs]\n",
    "            if cases := extract_cases(srcs): # 助詞がある\n",
    "                args = extract_args(srcs)\n",
    "                line = '{}\\t{}\\t{}'.format(verb, ' '.join(cases), ' '.join(args))\n",
    "                print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 47. 機能動詞構文のマイニング"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_sahen(chunk):\n",
    "    return len(chunk) == 2 and chunk[0].pos1 == 'サ変接続' and chunk[1].surface == 'を'\n",
    "\n",
    "def split_sahen(srcs):\n",
    "    for i in range(len(srcs)):\n",
    "        if is_sahen(srcs[i]):\n",
    "            return str(srcs[i]), srcs[:i] + srcs[i+1:]\n",
    "    return None, srcs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('result/sahen_pattern.txt', 'w') as f:\n",
    "    for sent in neko:\n",
    "        for chunk in sent:\n",
    "            if verb := get_first_verb(chunk):\n",
    "                srcs = [sent[src] for src in chunk.srcs]\n",
    "                sahen, rest = split_sahen(srcs)\n",
    "                if sahen and (cases := extract_cases(rest)):\n",
    "                    args = extract_args(rest)\n",
    "                    line = '{}\\t{}\\t{}'.format(sahen + verb, ' '.join(cases), ' '.join(args))\n",
    "                    print(line, file=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     25 返事をする\r\n",
      "     19 挨拶をする\r\n",
      "     11 話をする\r\n",
      "      9 質問をする\r\n",
      "      7 真似をする\r\n",
      "      7 喧嘩をする\r\n",
      "      5 質問をかける\r\n",
      "      5 相談をする\r\n",
      "      5 昼寝をする\r\n",
      "      4 演説をする\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/sahen_pattern.txt | cut -f 1 | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     10 返事をする\tと\r\n",
      "      7 返事をする\tと は\r\n",
      "      7 挨拶をする\tで\r\n",
      "      5 質問をかける\tと は\r\n",
      "      5 喧嘩をする\tで\r\n",
      "      4 質問をえる\tで\r\n",
      "      4 話をする\tに\r\n",
      "      4 挨拶をする\tから\r\n",
      "      3 返事をする\tから と\r\n",
      "      3 談話を聞く\tが\r\n"
     ]
    }
   ],
   "source": [
    "! cat result/sahen_pattern.txt | cut -f 1,2 | sort | uniq -c | sort -nr 2> /dev/null | head -n 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 48. 名詞から根へのパスの抽出 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace(n, sent):\n",
    "    path = []\n",
    "    while n != -1:\n",
    "        path.append(n)\n",
    "        n = sent[n].dst\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "吾輩は -> 見た\n",
      "ここで -> 始めて -> 人間という -> ものを -> 見た\n",
      "人間という -> ものを -> 見た\n",
      "ものを -> 見た\n"
     ]
    }
   ],
   "source": [
    "sent = neko[7]\n",
    "heads = [n for n in range(len(sent)) if has_noun(sent[n])]\n",
    "for head in heads:\n",
    "    path = trace(head, sent)\n",
    "    path = ' -> '.join([str(sent[n]) for n in path])\n",
    "    print(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 49. 名詞間の係り受けパスの抽出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_path(x, y, sent):\n",
    "    xs = []\n",
    "    ys = []\n",
    "    while x != y:\n",
    "        if x < y:\n",
    "            xs.append(x)\n",
    "            x = sent[x].dst\n",
    "        else:\n",
    "            ys.append(y)\n",
    "            y = sent[y].dst\n",
    "    return xs, ys, x\n",
    "\n",
    "def remove_initial_nouns(chunk):\n",
    "    for i, morph in enumerate(chunk):\n",
    "        if morph.pos != '名詞':\n",
    "            break\n",
    "    return ''.join([str(morph) for morph in chunk[i:]]).strip()\n",
    "\n",
    "def path_to_str(xs, ys, last, sent):\n",
    "    xs = [sent[x] for x in xs]\n",
    "    ys = [sent[y] for y in ys]\n",
    "    last = sent[last]\n",
    "    if xs and ys:\n",
    "        xs = ['X' + remove_initial_nouns(xs[0])] + [str(x) for x in xs[1:]]\n",
    "        ys = ['Y' + remove_initial_nouns(ys[0])] + [str(y) for y in ys[1:]]\n",
    "        last = str(last)\n",
    "        return ' -> '.join(xs) + ' | ' + ' -> '.join(ys) + ' | ' + last\n",
    "    else:\n",
    "        xs = xs + ys\n",
    "        xs = ['X' + remove_initial_nouns(xs[0])] + [str(x) for x in xs[1:]]\n",
    "        last = 'Y' + remove_initial_nouns(last)\n",
    "        return ' -> '.join(xs + [last])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "パスの先頭: [0, 1, 3, 4]\n",
      "パスの先頭のペア:  [(0, 1), (0, 3), (0, 4), (1, 3), (1, 4), (3, 4)]\n",
      "係り受けのパス:\n",
      "Xは | Yで -> 始めて -> 人間という -> ものを | 見た\n",
      "Xは | Yという -> ものを | 見た\n",
      "Xは | Yを | 見た\n",
      "Xで -> 始めて -> Yという\n",
      "Xで -> 始めて -> 人間という -> Yを\n",
      "Xという -> Yを\n"
     ]
    }
   ],
   "source": [
    "sent = neko[7]\n",
    "\n",
    "heads = [n for n in range(len(sent)) if has_noun(sent[n])]\n",
    "print('パスの先頭:', heads)\n",
    "\n",
    "pairs = [\n",
    "    (heads[n], second)\n",
    "    for n in range(len(heads))\n",
    "    for second in heads[n + 1:]\n",
    "]\n",
    "print('パスの先頭のペア: ', pairs)\n",
    "\n",
    "print('係り受けのパス:')\n",
    "for x, y in pairs:\n",
    "    x_path, y_path, last = extract_path(x, y, sent)\n",
    "    path = path_to_str(x_path, y_path, last, sent)\n",
    "    print(path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}