├── .gitignore
├── LICENSE
├── README.md
├── __init__.py
├── notebooks
    ├── HowTo.ipynb
    └── __init__.py
├── setup.py
├── tests
    ├── __init__.py
    └── test_textsplit.py
└── textsplit
    ├── __init__.py
    ├── algorithm.py
    └── tools.py


/.gitignore:
--------------------------------------------------------------------------------
1 | wvtool.egg-info/
2 | **/*.pyc
3 | **/.ipynb_checkpoints/
4 | **/data
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Introduction
  2 | This library contains simple functionality to tackle the problem of segmenting
  3 | documents into coherent parts. Imagine you don't have a good paragraph
  4 | annotation in your documents, as it is often the case for scraped pdfs or html
  5 | documents. For NLP tasks you want to split them at points where the topic
  6 | changes. Good results have been achieved using topic representations, but they
  7 | involve a further step of topic modeling which is quite domain dependent. This
  8 | approach uses only word embeddings which are assumed to be less domain specific.
  9 | See [https://arxiv.org/pdf/1503.05543.pdf] for an overview and an approach very
 10 | similar to the one presented here.
 11 | 
 12 | 
 13 | The algorithm uses word embeddings to find a segmentation where the splits are
 14 | chosen such that the segments are coherent. This coherence can be described as
 15 | accumulated weighted cosine similarity of the words of a segment to the mean
 16 | vector of that segment.  More formally segments are chosen as to maximize the
 17 | quantity |v|, where v is a segment vector and |.| denotes the l2-norm. The
 18 | accumulated weighted cosine similarity turns up by a simple transformation:
 19 | |v| = 1/|v| <v, v> = <v, v/|v|> = \sum_i <w_i, v/|v|> = \sum_i |w_i| <w_i/|w_i|, v/|v|>,
 20 | where v = \sum_i w_i is the definition of the segment vector from word vectors
 21 | w_i. The expansion gives a good intuition of what we try to achieve. As we
 22 | usually compare word embeddings with cosine similarity, the last scalar product
 23 | <w_i/|w_i|, v/|v|> is just the cosine similarity of a word w_i to the segment
 24 | vector v. The weighting with the length of w_i suppresses frequent noise words,
 25 | that typically have a shorter length.
 26 | 
 27 | This leads to the interpretation that coherence corresponds to segment vector
 28 | length, in the sense that two segment vectors of same length contain the same
 29 | amount of information. This interpretation is of course only capturing
 30 | information that we are given as input by means of the word embeddings, but it
 31 | serves as an abstraction.
 32 | 
 33 | # Formalization
 34 | 
 35 | To optimize for segment vector length |v|, we look for a sequence of split
 36 | positions such that the sum of l2-norms of the segment vectors formed by summing
 37 | the words between the splits is maximal. Given this objective without
 38 | constraints, the optimal solution is to split the document between every two
 39 | subsequent words (triangle inequality). We have to impose some limit on the
 40 | granularity of the segmentation to get useful results. This is done by a penalty
 41 | for every split made, that counts against the vector norms, i.e. is subtracted
 42 | from the sum of vector norms.
 43 | 
 44 | Let Seg := {(0 = t_0 < t_i < ... < t_n = L) | s_i natural number} where L is a
 45 | documents length. A segment [a, b[ comprises the words at positions a, a+1, ...,
 46 | b-1. Let l(j, k) := |\sum_i=j^{k-1} w_i| denote the vector of segment [i, j[. We
 47 | optimize the function f mapping elements of Seg to the real numbers with
 48 | f: (t_0, ..., t_n) \mapsto \sum_{i=0}^{n-1} (l(t_{i-1}, t_i) + l(t_i, t_{i+1}) - penalty).
 49 | 
 50 | # Algorithms
 51 | 
 52 | There are two variants, a greedy that is fast and a dynamic programming approach
 53 | that computes the optimal segmentation. Both depend on a penalty hyperparameter,
 54 | that defined the granularity of the split.
 55 | 
 56 | ## Greedy
 57 | Split the text iteratively at the position where the gain is highest until this
 58 | gain would be below a given penalty threshold. The gain is the sum of norms of
 59 | the left and right segments minus the norm of the segment that is to be split.
 60 | 
 61 | ## Optimal (Dynamic Programming)
 62 | Iteratively construct a data structure storing the results of optimally
 63 | splitting a prefix of the document. This results in a matrix storing a score
 64 | for making a segment from position i to j, given a optimal segmentation up to i.
 65 | 
 66 | # Tools
 67 | 
 68 | ## Penalty hyperparameter choice
 69 | The greedy implementation does not need the penalty parameter, but can also be
 70 | run by limiting the number of segments. This is leveraged by the `get_penalty`
 71 | function to approximately determine a penalty parameter for a desired average
 72 | segment length computed over a set of documents.
 73 | 
 74 | ## Measure accuracy of segmentation against reference
 75 | To measure the accuracy of an algorithm against a given reference segmentation
 76 | `P_k` is a commonly used metric described e.g. in above paper.
 77 | 
 78 | ## Apply segmentation definition to document
 79 | The function `get_segments` simply applies a segmentation determined by one of
 80 | the algorithms to e.g. the sentences of a text used when generating the
 81 | segmentation.
 82 | 
 83 | # Usage
 84 | 
 85 | ## Input
 86 | The algorithms are fed a matrix `docmat` containing vectors representing the
 87 | content of a text. These vectors are supposed to have cosine similarity as a
 88 | natural similarity measure and length roughly corresponding to the content
 89 | length of a text particle. Particles could be words in which case word2vec
 90 | embeddings are a good choice as vectors. The width of `docmat` is the embedding
 91 | dimension and the height the number of particles.
 92 | 
 93 | ## Split along sentence borders
 94 | If you want to split text into paragraphs, you most likely already have a good
 95 | idea of what potential sentence borders are. It makes sense not to give the word
 96 | vectors as input but sentence vectors formed by e.g. the sum of word vectors, as
 97 | it is usual practice.
 98 | 
 99 | # Getting Started
100 | 
101 | ```
102 | pip install textsplit
103 | ```
104 | 
105 | In the Jupyter notebook HowTo.ipynb you find code that demonstrates the use of
106 | the module. It downloads a corpus to trains word2vec vectors on and an example
107 | text for segmentation. You achieve better results if you compute word vectors on
108 | a larger corpus.
109 | 


--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chschock/textsplit/27eff3f0a6d32e591db435910caf7fc2145cc6c7/__init__.py


--------------------------------------------------------------------------------
/notebooks/HowTo.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [
  8 |     {
  9 |      "name": "stderr",
 10 |      "output_type": "stream",
 11 |      "text": [
 12 |       "/home/chris/.pyenv/versions/3.7.5/envs/work/lib/python3.7/site-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
 13 |       "  warnings.warn(msg, category=DeprecationWarning)\n"
 14 |      ]
 15 |     }
 16 |    ],
 17 |    "source": [
 18 |     "import os\n",
 19 |     "import word2vec\n",
 20 |     "import pandas as pd\n",
 21 |     "import numpy as np\n",
 22 |     "from sklearn.feature_extraction.text import CountVectorizer"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "markdown",
 27 |    "metadata": {},
 28 |    "source": [
 29 |     "## Download toy corpus for wordvector training and example text"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 2,
 35 |    "metadata": {},
 36 |    "outputs": [],
 37 |    "source": [
 38 |     "corpus_path = './text8'  # be sure your corpus is cleaned from punctuation and lowercased\n",
 39 |     "if not os.path.exists(corpus_path):\n",
 40 |     "    !wget http://mattmahoney.net/dc/text8.zip\n",
 41 |     "    !unzip {corpus_path}\n",
 42 |     "\n",
 43 |     "links = {'tale2cities': 'https://www.gutenberg.org/files/98/98-0.txt',  # a tale of two cities\n",
 44 |     "         'siddartha': 'http://www.gutenberg.org/cache/epub/2500/pg2500.txt'}  # siddartha\n",
 45 |     "\n",
 46 |     "for link in links.values():\n",
 47 |     "    text_path = os.path.basename(link)\n",
 48 |     "    if not os.path.exists(text_path):\n",
 49 |     "        !wget {link}"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "markdown",
 54 |    "metadata": {},
 55 |    "source": [
 56 |     "## Train wordvectors"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "code",
 61 |    "execution_count": 3,
 62 |    "metadata": {},
 63 |    "outputs": [],
 64 |    "source": [
 65 |     "wrdvec_path = 'wrdvecs.bin'\n",
 66 |     "if not os.path.exists(wrdvec_path):\n",
 67 |     "    %time word2vec.word2vec(corpus_path, wrdvec_path, cbow=1, iter_=5, hs=1, threads=8, sample='1e-5', window=15, size=200, binary=1)"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "code",
 72 |    "execution_count": 4,
 73 |    "metadata": {},
 74 |    "outputs": [
 75 |     {
 76 |      "name": "stdout",
 77 |      "output_type": "stream",
 78 |      "text": [
 79 |       "(71291, 200)\n"
 80 |      ]
 81 |     }
 82 |    ],
 83 |    "source": [
 84 |     "model = word2vec.load(wrdvec_path)\n",
 85 |     "wrdvecs = pd.DataFrame(model.vectors, index=model.vocab)\n",
 86 |     "del model\n",
 87 |     "print(wrdvecs.shape)"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "markdown",
 92 |    "metadata": {},
 93 |    "source": [
 94 |     "## get sentence tokenizer"
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": 5,
100 |    "metadata": {},
101 |    "outputs": [],
102 |    "source": [
103 |     "from textsplit.tools import SimpleSentenceTokenizer\n",
104 |     "sentence_tokenizer = SimpleSentenceTokenizer()"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "markdown",
109 |    "metadata": {},
110 |    "source": [
111 |     "## run get_penalty and split_optimal"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "code",
116 |    "execution_count": 6,
117 |    "metadata": {},
118 |    "outputs": [],
119 |    "source": [
120 |     "%matplotlib inline\n",
121 |     "from textsplit.tools import get_penalty, get_segments\n",
122 |     "from textsplit.algorithm import split_optimal, split_greedy, get_total"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 7,
128 |    "metadata": {},
129 |    "outputs": [
130 |     {
131 |      "name": "stdout",
132 |      "output_type": "stream",
133 |      "text": [
134 |       "penalty 3.02\n",
135 |       "8591 sentences, 391 segments, avg 21.97 sentences per segment\n",
136 |       "optimal score 51703.94, greedy score 51615.21\n",
137 |       "ratio of scores 1.0017\n"
138 |      ]
139 |     },
140 |     {
141 |      "data": {
142 |       "image/png": "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\n",
143 |       "text/plain": [
144 |        "<Figure size 1296x216 with 1 Axes>"
145 |       ]
146 |      },
147 |      "metadata": {
148 |       "needs_background": "light"
149 |      },
150 |      "output_type": "display_data"
151 |     },
152 |     {
153 |      "data": {
154 |       "image/png": "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\n",
155 |       "text/plain": [
156 |        "<Figure size 720x216 with 1 Axes>"
157 |       ]
158 |      },
159 |      "metadata": {
160 |       "needs_background": "light"
161 |      },
162 |      "output_type": "display_data"
163 |     }
164 |    ],
165 |    "source": [
166 |     "# link = links['siddartha']\n",
167 |     "link = links['tale2cities']\n",
168 |     "segment_len = 30  # segment target length in sentences\n",
169 |     "book_path = os.path.basename(link)\n",
170 |     "\n",
171 |     "with open(book_path, 'rt') as f:\n",
172 |     "    text = f.read()  #.replace('\\n', ' ')  # punkt tokenizer handles newlines not so nice\n",
173 |     "\n",
174 |     "sentenced_text = sentence_tokenizer(text)\n",
175 |     "vecr = CountVectorizer(vocabulary=wrdvecs.index)\n",
176 |     "\n",
177 |     "sentence_vectors = vecr.transform(sentenced_text).dot(wrdvecs)\n",
178 |     "\n",
179 |     "penalty = get_penalty([sentence_vectors], segment_len)\n",
180 |     "print('penalty %4.2f' % penalty)\n",
181 |     "\n",
182 |     "optimal_segmentation = split_optimal(sentence_vectors, penalty, seg_limit=250)\n",
183 |     "segmented_text = get_segments(sentenced_text, optimal_segmentation)\n",
184 |     "\n",
185 |     "print('%d sentences, %d segments, avg %4.2f sentences per segment' % (\n",
186 |     "    len(sentenced_text), len(segmented_text), len(sentenced_text) / len(segmented_text)))\n",
187 |     "\n",
188 |     "with open(book_path + '.seg', 'wt') as f:\n",
189 |     "    for i, segment_sentences in enumerate(segmented_text):\n",
190 |     "        segment_str = ' // '.join(segment_sentences)\n",
191 |     "        gain = optimal_segmentation.gains[i] if i < len(segmented_text) - 1 else 0\n",
192 |     "        segment_info = ' [%d sentences, %4.3f] ' % (len(segment_sentences), gain) \n",
193 |     "        print(segment_str + '\\n8<' + '=' * 30 + segment_info + \"=\" * 30, file=f)\n",
194 |     "\n",
195 |     "greedy_segmentation = split_greedy(sentence_vectors, max_splits=len(optimal_segmentation.splits))\n",
196 |     "greedy_segmented_text = get_segments(sentenced_text, greedy_segmentation)\n",
197 |     "lengths_optimal = [len(segment) for segment in segmented_text for sentence in segment]\n",
198 |     "lengths_greedy = [len(segment) for segment in greedy_segmented_text for sentence in segment]\n",
199 |     "df = pd.DataFrame({'greedy':lengths_greedy, 'optimal': lengths_optimal})\n",
200 |     "df.plot.line(figsize=(18, 3), title='Segment lenghts over text')\n",
201 |     "df.plot.hist(bins=30, alpha=0.5, figsize=(10, 3), title='Histogram of segment lengths')\n",
202 |     "\n",
203 |     "totals = [get_total(sentence_vectors, seg.splits, penalty) \n",
204 |     "          for seg in [optimal_segmentation, greedy_segmentation]]\n",
205 |     "print('optimal score %4.2f, greedy score %4.2f' % tuple(totals))\n",
206 |     "print('ratio of scores %5.4f' % (totals[0] / totals[1]))"
207 |    ]
208 |   },
209 |   {
210 |    "cell_type": "markdown",
211 |    "metadata": {},
212 |    "source": [
213 |     "## Evaluation"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "markdown",
218 |    "metadata": {},
219 |    "source": [
220 |     "If you look into the written file `book_path`.seg, the snippet line is often at the boundary of a paragraph.  The word embeddings computed above are neither very good nor adapted to the text. Every unknown word has a zero vector. Choosing some more or less random vector for unknown words might improve the accuracy given those unknown terms appear repeatedly within a section."
221 |    ]
222 |   }
223 |  ],
224 |  "metadata": {
225 |   "kernelspec": {
226 |    "display_name": "Python 3",
227 |    "language": "python",
228 |    "name": "python3"
229 |   },
230 |   "language_info": {
231 |    "codemirror_mode": {
232 |     "name": "ipython",
233 |     "version": 3
234 |    },
235 |    "file_extension": ".py",
236 |    "mimetype": "text/x-python",
237 |    "name": "python",
238 |    "nbconvert_exporter": "python",
239 |    "pygments_lexer": "ipython3",
240 |    "version": "3.7.5"
241 |   }
242 |  },
243 |  "nbformat": 4,
244 |  "nbformat_minor": 4
245 | }
246 | 


--------------------------------------------------------------------------------
/notebooks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chschock/textsplit/27eff3f0a6d32e591db435910caf7fc2145cc6c7/notebooks/__init__.py


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | setup(
 4 |     name='textsplit',
 5 |     version=0.5,
 6 |     description='Segment documents into coherent parts using wordembeddings.',
 7 |     url='https://github.com/chschock/textsplit',
 8 |     long_description=open('README.md', 'r').read(),
 9 |     long_description_content_type='text/markdown',
10 |     author='Christoph Schock',
11 |     author_email='chschock@gmail.com',
12 |     license='MIT',
13 |     packages=find_packages(),
14 |     zip_safe=False,
15 |     install_requires=[
16 |         'nose>=1.3.7',
17 |         'numpy>=1.13.1',
18 |     ],
19 |     classifiers=(
20 |         'Programming Language :: Python :: 3.6',
21 |         'License :: OSI Approved :: MIT License',
22 |         'Operating System :: OS Independent',
23 |         'Topic :: Scientific/Engineering :: Artificial Intelligence',
24 |     ),
25 |     keywords='nlp text segmentation paragraph embeddings',
26 | )
27 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chschock/textsplit/27eff3f0a6d32e591db435910caf7fc2145cc6c7/tests/__init__.py


--------------------------------------------------------------------------------
/tests/test_textsplit.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | import numpy as np
 3 | from ..textsplit.algorithm import split_greedy, split_optimal, get_total, get_gains
 4 | from ..textsplit.tools import get_penalty, P_k
 5 | 
 6 | DIM = 20
 7 | 
 8 | def getDoc(segment_len, n_seg):
 9 |     return np.vstack([np.tile(w, (segment_len, 1))
10 |                       for w in np.random.random((n_seg, DIM))])
11 | 
12 | 
13 | docA = getDoc(20, 10)
14 | penaltyA = get_penalty([docA], 20)  # get_penalty is deterministic here
15 | 
16 | class TestTextSplit(unittest.TestCase):
17 | 
18 |     def test_get_penalty(self):
19 |         seg = split_greedy(docA, penalty=penaltyA)
20 |         self.assertEqual(len(seg.splits), 9)
21 | 
22 |     def test_split_greedy_penalty(self):
23 |         seg = split_greedy(docA, penalty=penaltyA)
24 |         self.assertEqual(len(seg.splits), len(seg.gains))
25 |         self.assertGreater(np.percentile(seg.gains, 25), penaltyA)
26 |         gains2 = get_gains(docA, seg.splits)
27 |         self.assertTrue(all(np.isclose(seg.gains, gains2)))
28 | 
29 |     def test_split_greedy_max_splits(self):
30 |         seg = split_greedy(docA, max_splits=5)
31 |         self.assertEqual(len(seg.splits), len(seg.gains))
32 |         self.assertTrue(len(seg.splits) == len(seg.gains) == 5)
33 | 
34 |     def test_split_greedy_penalty_max_splits(self):
35 |         seg = split_greedy(docA, penalty=penaltyA, max_splits=5)
36 |         self.assertEqual(len(seg.splits), len(seg.gains))
37 |         self.assertEqual(len(seg.splits), 5)
38 |         self.assertGreater(np.percentile(seg.gains, 25), penaltyA)
39 | 
40 |     def test_split_optimal(self):
41 |         seg = split_optimal(docA, penalty=penaltyA)
42 |         self.assertEqual(len(seg.splits), len(seg.gains))
43 |         print(len(seg.splits))
44 |         self.assertGreater(np.min(seg.gains) + 0.00001, penaltyA)
45 | 
46 |     def test_split_optimal_vs_greedy(self):
47 |         docs = [np.random.random((100, DIM)) for _ in range(100)]
48 |         penalty = get_penalty(docs, 10)
49 |         for i, doc in enumerate(docs):
50 |             seg_o = split_optimal(doc, penalty=penalty)
51 |             seg_g = split_greedy(doc, penalty=penalty)
52 |             self.assertAlmostEqual(seg_o.total, get_total(doc, seg_o.splits, penalty), places=3)
53 |             self.assertAlmostEqual(seg_g.total, get_total(doc, seg_g.splits, penalty), places=3)
54 |             self.assertGreaterEqual(seg_o.total + 0.001, seg_g.total)
55 | 
56 |     def test_split_optimal_with_seg_limit(self):
57 |         docs = [np.random.random((100, DIM)) for _ in range(10)]
58 |         penalty = get_penalty(docs, 20)
59 |         for i, doc in enumerate(docs):
60 |             seg = split_optimal(doc, penalty=penalty)
61 |             cuts = [0] + seg.splits + [100]
62 |             seg2 = split_optimal(
63 |                 doc, penalty=penalty, seg_limit=np.diff(cuts).max()+1)
64 |             self.assertTrue(seg2.optimal)
65 |             self.assertEqual(seg.splits, seg2.splits)
66 |             self.assertAlmostEqual(seg.total, seg2.total)
67 | 
68 |     def test_P_k(self):
69 |         docs = [np.random.random((100, DIM)) for _ in range(10)]
70 |         penalty = get_penalty(docs, 10)
71 |         for i, doc in enumerate(docs):
72 |             seg_o = split_optimal(doc, penalty=penalty)
73 |             seg_g = split_greedy(doc, penalty=penalty)
74 |             pk = P_k(seg_o.splits, seg_g.splits, len(doc))
75 |             self.assertGreaterEqual(pk, 0)
76 |             self.assertGreaterEqual(1, pk)
77 | 


--------------------------------------------------------------------------------
/textsplit/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chschock/textsplit/27eff3f0a6d32e591db435910caf7fc2145cc6c7/textsplit/__init__.py


--------------------------------------------------------------------------------
/textsplit/algorithm.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from numpy.linalg import norm
  3 | 
  4 | from collections import namedtuple
  5 | Segmentation = namedtuple('Segmentation',
  6 |                           'total splits gains min_gain optimal')
  7 | 
  8 | def split_greedy(docmat, penalty=None, max_splits=None):
  9 |     """
 10 |     Iteratively segment a document into segments being greedy about the
 11 |     next choice. This gives very accurate results on crafted documents, i.e.
 12 |     artificial concatenations of random documents.
 13 | 
 14 |     `penalty` is the minimum quantity a split has to improve the score to be
 15 |     made. If not given `total` is not computed.
 16 |     `max_splits` is a limit on the number of splits.
 17 |     Either `penalty` or `max_splits` have to be given.
 18 | 
 19 |     Whenever the iteration reaches the while block the following holds:
 20 |     `cuts` == splits + [L] where splits are the segment start indices
 21 |     `segscore` maps all segment start indices to segment vector lengths
 22 |     `score_l[i]` is the cumulated vector length from the cut left of i to i
 23 |     `score_r[i]` is the cumulated vector length from i to the cut right of i
 24 |     `score_out[i]` is the sum of all segscores not including the segment at i
 25 |     `scores[i]` is the sum of all segment vector lengths if we split at i
 26 | 
 27 |     These quantities are repaired after determining a next split from `scores`.
 28 | 
 29 |     Returns `total`, `splits`, `gains` where
 30 |     - `total` is the score diminished by len(splits) * penalty to make it
 31 |       continuous in the input. It is comparable to the output of split_optimal.
 32 |     - `splits` is the list of splits
 33 |     - `gains` is a list of uplift each split contributes vs. leaving it out
 34 | 
 35 |     Note: The splitting strategy suggests all resulting splits will have gain at
 36 |     least `penalty`. This is not the case as new splits can decrease the gain
 37 |     of others. This can be repaired by blocking positions where a split would
 38 |     decrease the gain of an existing one to less than `penalty` but is not
 39 |     implemented here.
 40 |     """
 41 |     L, dim = docmat.shape
 42 | 
 43 |     assert max_splits is not None or (penalty is not None and penalty > 0)
 44 | 
 45 |     # norm(cumvecs[j] - cumvecs[i]) == norm(w_i + ... + w_{j-1})
 46 |     cumvecs = np.cumsum(np.vstack((np.zeros((1, dim)), docmat)), axis=0)
 47 | 
 48 |     # cut[0] seg[0] cut[1] seg[1] ... seg[L-1] cut[L]
 49 |     cuts = [0, L]
 50 |     segscore = dict()
 51 |     segscore[0] = norm(cumvecs[L, :] - cumvecs[0, :], ord=2)
 52 |     segscore[L] = 0     # corner case, always 0
 53 |     score_l = norm(cumvecs[:L, :] - cumvecs[0, :], axis=1, ord=2)
 54 |     score_r = norm(cumvecs[L, :] - cumvecs[:L, :], axis=1, ord=2)
 55 |     score_out = np.zeros(L)
 56 |     score_out[0] = -np.inf  # forbidden split position
 57 |     score = score_out + score_l + score_r
 58 | 
 59 |     min_gain = np.inf
 60 |     while True:
 61 |         split = np.argmax(score)
 62 | 
 63 |         if score[split] == - np.inf:
 64 |             break
 65 | 
 66 |         cut_l = max([c for c in cuts if c < split])
 67 |         cut_r = min([c for c in cuts if split < c])
 68 |         split_gain = score_l[split] + score_r[split] - segscore[cut_l]
 69 |         if penalty is not None:
 70 |             if split_gain < penalty:
 71 |                 break
 72 | 
 73 |         min_gain = min(min_gain, split_gain)
 74 | 
 75 |         segscore[cut_l] = score_l[split]
 76 |         segscore[split] = score_r[split]
 77 | 
 78 |         cuts.append(split)
 79 |         cuts = sorted(cuts)
 80 | 
 81 |         if max_splits is not None:
 82 |             if len(cuts) >= max_splits + 2:
 83 |                 break
 84 | 
 85 |         # differential changes to score arrays
 86 |         score_l[split:cut_r] = norm(
 87 |             cumvecs[split:cut_r, :] - cumvecs[split, :], axis=1, ord=2)
 88 |         score_r[cut_l:split] = norm(
 89 |             cumvecs[split, :] - cumvecs[cut_l:split, :], axis=1, ord=2)
 90 | 
 91 |         # adding following constant not necessary, only for score semantics
 92 |         score_out += split_gain
 93 |         score_out[cut_l:split] += segscore[split] - split_gain
 94 |         score_out[split:cut_r] += segscore[cut_l] - split_gain
 95 |         score_out[split] = -np.inf
 96 | 
 97 |         # update score
 98 |         score = score_out + score_l + score_r
 99 | 
100 |     cuts = sorted(cuts)
101 |     splits = cuts[1:-1]
102 |     if penalty is None:
103 |         total = None
104 |     else:
105 |         total = sum(
106 |             norm(cumvecs[l, :] - cumvecs[r, :], ord=2)
107 |             for l, r in zip(cuts[: -1], cuts[1:])) - len(splits) * penalty
108 |     gains = []
109 |     for beg, cen, end in zip(cuts[:-2], cuts[1:-1], cuts[2:]):
110 |         no_split_score = norm(cumvecs[end, :] - cumvecs[beg, :], ord=2)
111 |         gains.append(segscore[beg] + segscore[cen] - no_split_score)
112 | 
113 |     return Segmentation(total, splits, gains,
114 |                         min_gain=min_gain, optimal=None)
115 | 
116 | 
117 | def split_optimal(docmat, penalty, seg_limit=None):
118 |     """
119 |     Determine the configuration of splits with the highest score, given that
120 |     splitting has a cost of `penalty`. `seg_limit` is a limitation on the length
121 |     of a segment that saves memory and computation, but gives poor results
122 |     should there be no split withing the range.
123 |     The algorithm is built upon the idea that there is a accumulated score
124 |     matrix containing the maximal score of creating a segment (i, j), containing
125 |     all words [w_i, ..., w_j] at position i, j. The matrix `acc` is indexed to
126 |     contain the first `seg_limit` elements of each row of the score matrix.
127 |     `colmax` contains the column maxima of the score matrix.
128 |     `ptr` is a backtracking pointer to determine the splits made while
129 |     forward accumulating the highest score in the score matrix.
130 |     """
131 |     L, dim = docmat.shape
132 |     lim = L if seg_limit is None else seg_limit
133 |     assert lim > 0
134 |     assert penalty > 0
135 | 
136 |     acc = np.full((L, lim), -np.inf, dtype=np.float32)
137 |     colmax = np.full((L,), -np.inf, dtype=np.float32)
138 |     ptr = np.zeros(L, dtype=np.int32)
139 | 
140 |     for i in range(L):
141 |         score_so_far = colmax[i-1] if i > 0 else 0.
142 | 
143 |         ctxvecs = np.cumsum(docmat[i:i+lim, :], axis=0)
144 |         winsz = ctxvecs.shape[0]
145 |         score = norm(ctxvecs, axis=1, ord=2)
146 |         acc[i, :winsz] = score_so_far - penalty + score
147 | 
148 |         deltas = np.where(acc[i, :winsz] > colmax[i:i+lim])[0]
149 |         js = i + deltas
150 |         colmax[js] = acc[i, deltas]
151 |         ptr[js] = i
152 | 
153 |     path = [ptr[-1]]
154 |     while path[0] != 0:
155 |         path.insert(0, ptr[path[0] - 1])
156 | 
157 |     splits = path[1:]
158 |     gains = get_gains(docmat, path[1:])
159 |     optimal = all(np.diff([0] + splits + [L]) < lim)
160 | 
161 |     total = colmax[-1] + penalty
162 | 
163 |     return Segmentation(total, splits, gains,
164 |                         min_gain=None, optimal=optimal)
165 | 
166 | 
167 | def get_total(docmat, splits, penalty):
168 |     """
169 |     Compute the total score of a split configuration with given penalty.
170 |     """
171 |     L, dim = docmat.shape
172 |     cuts = [0] + list(splits) + [L]
173 |     cumvecs = np.cumsum(np.vstack((np.zeros((1, dim)), docmat)), axis=0)
174 |     return sum(
175 |         norm(cumvecs[l, :] - cumvecs[r, :], ord=2)
176 |         for l, r in zip(cuts[:-1], cuts[1:])) - len(splits) * penalty
177 | 
178 | 
179 | def get_gains(docmat, splits, width=None):
180 |     """
181 |     Calculate gains of the splits towards the left and right neighbouring
182 |     split.
183 |     If `width` is given, calculate gains of the splits towards a centered window
184 |     of length 2 * `width`.
185 |     """
186 |     gains = []
187 |     L = docmat.shape[0]
188 |     for beg, cen, end in zip([0] + splits[:-1], splits, splits[1:] + [L]):
189 |         if width is not None and width > 0:
190 |             beg, end = max(cen - width, 0), min(cen + width, L)
191 | 
192 |         slice_l, slice_r, slice_t = [slice(beg, cen),  # left context
193 |                                      slice(cen, end),  # right context
194 |                                      slice(beg, end)]  # total context
195 | 
196 |         gains.append(norm(docmat[slice_l, :].sum(axis=0), ord=2) +
197 |                      norm(docmat[slice_r, :].sum(axis=0), ord=2) -
198 |                      norm(docmat[slice_t, :].sum(axis=0), ord=2))
199 |     return gains
200 | 


--------------------------------------------------------------------------------
/textsplit/tools.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import re
 3 | import random
 4 | from .algorithm import split_greedy
 5 | 
 6 | def get_segments(text_particles, segmentation):
 7 |     """
 8 |     Reorganize text particles by aggregating them to arrays described by the
 9 |     provided `segmentation`.
10 |     """
11 |     segmented_text = []
12 |     L = len(text_particles)
13 |     for beg, end in zip([0] + segmentation.splits, segmentation.splits + [L]):
14 |         segmented_text.append(text_particles[beg:end])
15 |     return segmented_text
16 | 
17 | def get_penalty(docmats, segment_len):
18 |     """
19 |     Determine penalty for segments having length `segment_len` on average.
20 |     This is achieved by stochastically rounding the expected number
21 |     of splits per document `max_splits` and taking the minimal split_gain that
22 |     occurs in split_greedy given `max_splits`.
23 |     """
24 |     penalties = []
25 |     for docmat in docmats:
26 |         avg_n_seg = docmat.shape[0] / segment_len
27 |         max_splits = int(avg_n_seg) + (random.random() < avg_n_seg % 1) - 1
28 |         if max_splits >= 1:
29 |             seg = split_greedy(docmat, max_splits=max_splits)
30 |             if seg.min_gain < np.inf:
31 |                 penalties.append(seg.min_gain)
32 |     if len(penalties) > 0:
33 |         return np.mean(penalties)
34 |     raise ValueError('All documents too short for given segment_len.')
35 | 
36 | 
37 | def P_k(splits_ref, splits_hyp, N):
38 |     """
39 |     Metric to evaluate reference splits against hypothesised splits.
40 |     Lower is better.
41 |     `N` is the text length.
42 |     """
43 |     k = round(N / (len(splits_ref) + 1) / 2 - 1)
44 |     ref = np.array(splits_ref, dtype=np.int32)
45 |     hyp = np.array(splits_hyp, dtype=np.int32)
46 | 
47 |     def is_split_between(splits, l, r):
48 |         return np.sometrue(np.logical_and(splits - l >= 0, splits - r < 0))
49 | 
50 |     acc = 0
51 |     for i in range(N-k):
52 |         acc += is_split_between(ref, i, i+k) != is_split_between(hyp, i, i+k)
53 | 
54 |     return acc / (N-k)
55 | 
56 | 
57 | class SimpleSentenceTokenizer:
58 | 
59 |     def __init__(self, breaking_chars='.!?'):
60 |         assert len(breaking_chars) > 0
61 |         self.breaking_chars = breaking_chars
62 |         self.prog = re.compile(r".+?[{}]\W+".format(breaking_chars), re.DOTALL)
63 | 
64 |     def __call__(self, text):
65 |         return self.prog.findall(text)
66 | 


--------------------------------------------------------------------------------