Giter Club home page Giter Club logo

cbaziotis / ekphrasis Goto Github PK

View Code? Open in Web Editor NEW
658.0 18.0 92.0 675 KB

Ekphrasis is a text processing tool, geared towards text from social networks, such as Twitter or Facebook. Ekphrasis performs tokenization, word normalization, word segmentation (for splitting hashtags) and spell correction, using word statistics from 2 big corpora (english Wikipedia, twitter - 330mil english tweets).

License: MIT License

Python 98.70% Jupyter Notebook 1.14% Shell 0.16%
nlp text-processing nlp-library spelling-correction tokenizer tokenization word-segmentation word-normalization spell-corrector text-segmentation semeval

ekphrasis's Introduction

Collection of lightweight text tools, geared towards text from social networks, such as Twitter or Facebook, for tokenization, word normalization, word segmentation (for splitting hashtags) and spell correction, using word statistics from 2 big corpora (english Wikipedia, twitter - 330mil english tweets).

ekphrasis was developed as part of the text processing pipeline for DataStories team's submission for SemEval-2017 Task 4 (English), Sentiment Analysis in Twitter.

If you use the library in you research project, please cite the paper "DataStories at SemEval-2017 Task 4: Deep LSTM with Attention for Message-level and Topic-based Sentiment Analysis".

Citation:

@InProceedings{baziotis-pelekis-doulkeridis:2017:SemEval2,
  author    = {Baziotis, Christos  and  Pelekis, Nikos  and  Doulkeridis, Christos},
  title     = {DataStories at SemEval-2017 Task 4: Deep LSTM with Attention for Message-level and Topic-based Sentiment Analysis},
  booktitle = {Proceedings of the 11th International Workshop on Semantic Evaluation (SemEval-2017)},
  month     = {August},
  year      = {2017},
  address   = {Vancouver, Canada},
  publisher = {Association for Computational Linguistics},
  pages     = {747--754}
}

Disclaimer: The library is no longer actively developed. I will try to resolve important issues, but I can't make any promises.

Installation

build from source

pip install git+git://github.com/cbaziotis/ekphrasis.git

or install from pypi

pip install ekphrasis -U

Overview

ekphrasis offers the following functionality:

  1. Social Tokenizer. A text tokenizer geared towards social networks (Facebook, Twitter...), which understands complex emoticons, emojis and other unstructured expressions like dates, times and more.

  2. Word Segmentation. You can split a long string to its constituent words. Suitable for hashtag segmentation.

  3. Spell Correction. You can replace a misspelled word, with the most probable candidate word.

  4. Customization. Taylor the word-segmentation, spell-correction and term identification, to suit your needs.

    Word Segmentation and Spell Correction mechanisms, operate on top of word statistics, collected from a given corpus. We provide word statistics from 2 big corpora (from Wikipedia and Twitter), but you can also generate word statistics from your own corpus. You may need to do that if you are working with domain-specific texts, like biomedical documents. For example a word describing a technique or a chemical compound may be treated as a misspelled word, using the word statistics from a general purposed corpus.

    ekphrasis tokenizes the text based on a list of regular expressions. You can easily enable ekphrasis to identify new entities, by simply adding a new entry to the dictionary of regular expressions (ekphrasis/regexes/expressions.txt).

  5. Pre-Processing Pipeline. You can combine all the above steps in an easy way, in order to prepare the text files in your dataset for some kind of analysis or for machine learning. In addition, to the aforementioned actions, you can perform text normalization, word annotation (labeling) and more.

Text Pre-Processing pipeline

You can easily define a preprocessing pipeline, by using the TextPreProcessor.

from ekphrasis.classes.preprocessor import TextPreProcessor
from ekphrasis.classes.tokenizer import SocialTokenizer
from ekphrasis.dicts.emoticons import emoticons

text_processor = TextPreProcessor(
    # terms that will be normalized
    normalize=['url', 'email', 'percent', 'money', 'phone', 'user',
        'time', 'url', 'date', 'number'],
    # terms that will be annotated
    annotate={"hashtag", "allcaps", "elongated", "repeated",
        'emphasis', 'censored'},
    fix_html=True,  # fix HTML tokens
    
    # corpus from which the word statistics are going to be used 
    # for word segmentation 
    segmenter="twitter", 
    
    # corpus from which the word statistics are going to be used 
    # for spell correction
    corrector="twitter", 
    
    unpack_hashtags=True,  # perform word segmentation on hashtags
    unpack_contractions=True,  # Unpack contractions (can't -> can not)
    spell_correct_elong=False,  # spell correction for elongated words
    
    # select a tokenizer. You can use SocialTokenizer, or pass your own
    # the tokenizer, should take as input a string and return a list of tokens
    tokenizer=SocialTokenizer(lowercase=True).tokenize,
    
    # list of dictionaries, for replacing tokens extracted from the text,
    # with other expressions. You can pass more than one dictionaries.
    dicts=[emoticons]
)

sentences = [
    "CANT WAIT for the new season of #TwinPeaks \(^o^)/!!! #davidlynch #tvseries :)))",
    "I saw the new #johndoe movie and it suuuuucks!!! WAISTED $10... #badmovies :/",
    "@SentimentSymp:  can't wait for the Nov 9 #Sentiment talks!  YAAAAAAY !!! :-D http://sentimentsymposium.com/."
]

for s in sentences:
    print(" ".join(text_processor.pre_process_doc(s)))

Output:

cant <allcaps> wait <allcaps> for the new season of <hashtag> twin peaks </hashtag> \(^o^)/ ! <repeated> <hashtag> david lynch </hashtag> <hashtag> tv series </hashtag> <happy>

i saw the new <hashtag> john doe </hashtag> movie and it sucks <elongated> ! <repeated> waisted <allcaps> <money> . <repeated> <hashtag> bad movies </hashtag> <annoyed>

<user> : can not wait for the <date> <hashtag> sentiment </hashtag> talks ! yay <allcaps> <elongated> ! <repeated> <laugh> <url>

Notes:

  • elongated words are automatically normalized.
  • Spell correction affects performance.

Word Statistics

ekphrasis provides word statistics (unigrams and bigrams) from 2 big corpora:

  • the english Wikipedia
  • a collection of 330 million english Twitter messages

These word statistics are required for the word segmentation and spell correction. Moreover, you can generate word statistics from your own corpus. You can use ekphrasis/tools/generate_stats.py and generate statistics from a text file, or a directory that contains a collection of text files. For example, in order generate word statistics for text8 (http://mattmahoney.net/dc/text8.zip), you can do:

python generate_stats.py --input text8.txt --name text8 --ngrams 2 --mincount 70 30
  • input: path to file or directory containing the files for calculating the statistics.
  • name: the name of the corpus.
  • ngrams: up-to how many ngrams to calculate statistics.
  • mincount: the minimum count of each ngram, in order to be included. In this case, the mincount for unigrams is 70 and for bigrams is 30.

After you run the script, you will see a new directory inside ekphrasis/stats/ with the statistics of your corpus. In the case of the example above, ekphrasis/stats/text8/.

Word Segmentation

The word segmentation implementation uses the Viterbi algorithm and is based on CH14 from the book Beautiful Data (Segaran and Hammerbacher, 2009). The implementation requires word statistics in order to identify and separating the words in a string. You can use the word statistics from one of the 2 provided corpora, or from your own corpus.

Example: In order to perform word segmentation, first you have to instantiate a segmenter with a given corpus, and then just use the segment() method:

from ekphrasis.classes.segmenter import Segmenter
seg = Segmenter(corpus="mycorpus") 
print(seg.segment("smallandinsignificant"))

Output:

> small and insignificant

You can test the output using statistics from the different corpora:

from ekphrasis.classes.segmenter import Segmenter

# segmenter using the word statistics from english Wikipedia
seg_eng = Segmenter(corpus="english") 

# segmenter using the word statistics from Twitter
seg_tw = Segmenter(corpus="twitter")

words = ["exponentialbackoff", "gamedev", "retrogaming", "thewatercooler", "panpsychism"]
for w in words:
    print(w)
    print("(eng):", seg_eng.segment(w))
    print("(tw):", seg_tw.segment(w))
    print()

Output:

exponentialbackoff
(eng): exponential backoff
(tw): exponential back off

gamedev
(eng): gamedev
(tw): game dev

retrogaming
(eng): retrogaming
(tw): retro gaming

thewatercooler
(eng): the water cooler
(tw): the watercooler

panpsychism
(eng): panpsychism
(tw): pan psych is m

Finally, if the word is camelCased or PascalCased, then the algorithm splits the words based on the case of the characters.

from ekphrasis.classes.segmenter import Segmenter
seg = Segmenter() 
print(seg.segment("camelCased"))
print(seg.segment("PascalCased"))

Output:

> camel cased
> pascal cased

Spell Correction

The Spell Corrector is based on Peter Norvig's spell-corrector. Just like the segmentation algorithm, we utilize word statistics in order to find the most probable candidate. Besides the provided statistics, you can use your own.

Example:

You can perform the spell correction, just like the word segmentation. First you have to instantiate a SpellCorrector object, that uses the statistics from the corpus of your choice and then use on of the available methods.

from ekphrasis.classes.spellcorrect import SpellCorrector
sp = SpellCorrector(corpus="english") 
print(sp.correct("korrect"))

Output:

> correct

Social Tokenizer

The difficulty in tokenization is to avoid splitting expressions or words that should be kept intact (as one token). This is more important in texts from social networks, with "creative" writing and expressions like emoticons, hashtags and so on. Although there are some tokenizers geared towards Twitter [1],[2], that recognize the Twitter markup and some basic sentiment expressions or simple emoticons, our tokenizer is able to identify almost all emoticons, emojis and many complex expressions.

Especially for tasks such as sentiment analysis, there are many expressions that play a decisive role in identifying the sentiment expressed in text. Expressions like these are:

  • Censored words, such as f**k, s**t.
  • Words with emphasis, such as a *great* time, I don't *think* I ....
  • Emoticons, such as >:(, :)), \o/.
  • Dash-separated words, such as over-consumption, anti-american, mind-blowing.

Moreover, ekphrasis can identify information-bearing expressions. Depending on the task, you may want to keep preserve / extract them as one token (IR) and then normalize them since this information may be irrelevant for the task (sentiment analysis). Expressions like these are:

  • Dates, such as Feb 18th, December 2, 2016, December 2-2016, 10/17/94, 3 December 2016, April 25, 1995, 11.15.16, November 24th 2016, January 21st.
  • Times, such as 5:45pm, 11:36 AM, 2:45 pm, 5:30.
  • Currencies, such as $220M, $2B, $65.000, €10, $50K.
  • Phone numbers.
  • URLs, such as http://www.cs.unipi.gr, https://t.co/Wfw5Z1iSEt.

Example:

import nltk
from ekphrasis.classes.tokenizer import SocialTokenizer


def wsp_tokenizer(text):
    return text.split(" ")

puncttok = nltk.WordPunctTokenizer().tokenize

social_tokenizer = SocialTokenizer(lowercase=False).tokenize

sents = [
    "CANT WAIT for the new season of #TwinPeaks \(^o^)/ yaaaay!!! #davidlynch #tvseries :)))",
    "I saw the new #johndoe movie and it suuuuucks!!! WAISTED $10... #badmovies >3:/",
    "@SentimentSymp:  can't wait for the Nov 9 #Sentiment talks!  YAAAAAAY !!! >:-D http://sentimentsymposium.com/.",
]

for s in sents:
    print()
    print("ORG: ", s)  # original sentence
    print("WSP : ", wsp_tokenizer(s))  # whitespace tokenizer
    print("WPU : ", puncttok(s))  # WordPunct tokenizer
    print("SC : ", social_tokenizer(s))  # social tokenizer

Output:

ORG:  CANT WAIT for the new season of #TwinPeaks \(^o^)/ yaaaay!!! #davidlynch #tvseries :)))
WSP :  ['CANT', 'WAIT', 'for', 'the', 'new', 'season', 'of', '#TwinPeaks', '\(^o^)/', 'yaaaay!!!', '#davidlynch', '#tvseries', ':)))']
WPU :  ['CANT', 'WAIT', 'for', 'the', 'new', 'season', 'of', '#', 'TwinPeaks', '\(^', 'o', '^)/', 'yaaaay', '!!!', '#', 'davidlynch', '#', 'tvseries', ':)))']
SC :  ['CANT', 'WAIT', 'for', 'the', 'new', 'season', 'of', '#TwinPeaks', '\(^o^)/', 'yaaaay', '!', '!', '!', '#davidlynch', '#tvseries', ':)))']

ORG:  I saw the new #johndoe movie and it suuuuucks!!! WAISTED $10... #badmovies >3:/
WSP :  ['I', 'saw', 'the', 'new', '#johndoe', 'movie', 'and', 'it', 'suuuuucks!!!', 'WAISTED', '$10...', '#badmovies', '>3:/']
WPU :  ['I', 'saw', 'the', 'new', '#', 'johndoe', 'movie', 'and', 'it', 'suuuuucks', '!!!', 'WAISTED', '$', '10', '...', '#', 'badmovies', '>', '3', ':/']
SC :  ['I', 'saw', 'the', 'new', '#johndoe', 'movie', 'and', 'it', 'suuuuucks', '!', '!', '!', 'WAISTED', '$10', '.', '.', '.', '#badmovies', '>', '3:/']

References

[1] K. Gimpel et al., “Part-of-speech tagging for twitter: Annotation, features, and experiments,” in Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies: short papers-Volume 2, 2011, pp. 42–47.

[2] C. Potts, “Sentiment Symposium Tutorial: Tokenizing,” Sentiment Symposium Tutorial, 2011. [Online]. Available: http://sentiment.christopherpotts.net/tokenizing.html.

ekphrasis's People

Contributors

azharsultan avatar cbaziotis avatar mobiuscreek avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

ekphrasis's Issues

MUISTI!

ne-am chinuit ca ultimii prosti ca nu vad cue pe voi capu
🤬

Failed during generate_stats.py

computing statistics for file: text8.txt
100%|███████████████████████████████████████████████████████████████████| 1/1 [12:41<00:00, 761.71s/it]

Writing 1-grams...
entries:250,982 - tokens:16,996,178
writing stats to file /home/jj301440/ekphrasis-master/ekphrasis/tools/../stats/text8/counts_1grams.txt
Writing 2-grams...
entries:4,136,483 - tokens:16,996,178
writing stats to file /home/jj301440/ekphrasis-master/ekphrasis/tools/../stats/text8/counts_2grams.txt
Writing 3-grams...
entries:10,327,876 - tokens:16,996,178
writing stats to file /home/jj301440/ekphrasis-master/ekphrasis/tools/../stats/text8/counts_3grams.txt
Traceback (most recent call last):
File "generate_stats.py", line 191, in
write_stats(stats)
File "generate_stats.py", line 147, in write_stats
write_stats_to_file(filename, counter, args.mincount[int(k) - 1])
IndexError: list index out of range

Can you please tell me where the problem is?

urllib.error.HTTPError: HTTP Error 429: Too Many Requests

I am implementing Segmenter and SpellCorrector using corpus generated by me, and when ever I instantiate corpus for Segmenter or SpellCorrector it return me with the error as
429
Corpus was generated as mention using script provided at site-package/ekphrasis/tools/

I am running these in docker container and instantiate corpus is implement at init.py
any resolution to it
I also thought that something is wrong with my corpus so i also ran it with corpus="english" and still same problem

she's --> she ' s

Running the text_processor example in the README with the input "she's" returns ["she", "'", "s"].
Is this expected behavior? I'd have taught "she" "is".

spelling correction mostly is not working

Came to this project for spelling in twitter text, but it doesn't quite work most of the time.

  1. spell correction seems to only work when annotate is set as in the example. Now
    take the same example and set annotate={} and spell correction is gone:
i saw the new john doe movie and it suuuuucks ! ! ! waisted <money> . . . bad movies <annoyed>

if I restore annotate={"hashtag", "...}, then it corrects suuuuucks to sucks
I'm not sure what is the connection between annotations and spell correction.

  1. spelling-correction doesn't work in general. Again, going back to your pipeline example, change the first input sentence to inject some spelling errors: CANT WAIT for the neww seaason of #TwinPeaks , run it, you get:
    cant wait for the neww seaason of twin peaks - i.e. no spell correction.
    The spell_correct_elong doesn't seem to make a difference.

Yet, if I run:

from ekphrasis.classes.spellcorrect import SpellCorrector
sp = SpellCorrector(corpus="english") 
print([sp.correct(x) for x in "neww seaason".split()])

It corrects: ['new', 'season']

Memory usage

As i noticed there is no trivial way to free memory allocated in RAM after creating a TextPreProcessor object. I tried remove object reference with: preprocessor = None or del preprocessor but it does not seem to work. Is there something i am missing?

The TextPreProcessor class only supports segmenting text with hastags. Required support for normal text segmenter.

The TextPreProcessor class only supports word segmenting if hashtag symbol is there otherwise it fails.

Example:-

# With hashtag it works
s = " question kind infidelity passed sweety not feel sweet #savingyourmarriagebeforeitstarts"
print(" ".join(text_processor.pre_process_doc(s)))
'question kind infidelity passed sweety not feel sweet <hashtag> saving your marriage before it starts </hashtag>'

#without hashtag it fails
s = " question kind infidelity passed sweety not feel sweet savingyourmarriagebeforeitstarts"
print(" ".join(text_processor.pre_process_doc(s)))
" question kind infidelity passed sweety not feel sweet savingyourmarriagebeforeitstarts"

The TextPreProcessor class configuration is similar to what is defined in README.md file.

Kindly review it and if you find that correct, I can send a pull request.

Log messages print to stdout

First just wanted to say thanks for making this available, this has been very useful- I've been working with reddit and Twitter text and this has been instrumental.

This is altogether a pretty minor issue, but there are a few places where messages are printed. I use this in a script along with GNU parallel to process line delimited json, and merge the results back into one file. So the output is mixed with the messages about loading the models, etc.

I forked this and replaced the print statements with logging calls, so that they'll go to stderr and the user can control the verbosity by setting the logging level. Would you be interested in a pull request for that? I would just need to clean up a few changes I made to keep subreddit names together (just added a regex in the pipeline). I'd be happy to share that too.

Thanks!

Warning regarding using TextPreProcessor as a preprocessing for torchtext.data.Field()

As it can be seen in the code sample below, we get different results if

  • we pre-process a text with TextPreProcessor text_processor and then create an Example with a torchtext.data.Field() without a preprocessing Pipeline vs
  • creating an Example with the text as it is, with a torchtext.data.Field(preprocessing=data.Pipeline(lambda x : text_processor(x))

Using the Field preprocessing pipeline, the text_processor will be called on a token level, instead of on a sentence-level, and expressions like "October 10th" that will be converted to <date>, will not be correctly converted, as the text_processor will be called on two separate tokens "October" and "10th", and the last one will be break into "1 0 th" after that call.

from torchtext import data, vocab
import torch.optim as optim
import torch.nn.functional as F
import torch.nn as nn
from ekphrasis.classes.preprocessor import TextPreProcessor
from ekphrasis.classes.tokenizer import SocialTokenizer
from ekphrasis.dicts.emoticons import emoticons

text_processor = TextPreProcessor(
            # terms that will be normalized
            normalize=['url', 'email', 'percent', 'money', 'phone', 'user',
                'time', 'url', 'date', 'number'],
            # terms that will be annotated
            annotate={"hashtag", "allcaps", "elongated", "repeated",
                'emphasis', 'censored'},
            fix_html=True,  # fix HTML tokens

            # corpus from which the word statistics are going to be used
            # for word segmentation
            segmenter="twitter",

            # corpus from which the word statistics are going to be used
            # for spell correction
            corrector="twitter",

            unpack_hashtags=True,  # perform word segmentation on hashtags
            unpack_contractions=True,  # Unpack contractions (can't -> can not)
            spell_correct_elong=False,  # spell correction for elongated words

            # select a tokenizer. You can use SocialTokenizer, or pass your own
            # the tokenizer, should take as input a string and return a list of tokens
            tokenizer=SocialTokenizer(lowercase=True).tokenize,

            # list of dictionaries, for replacing tokens extracted from the text,
            # with other expressions. You can pass more than one dictionaries.
            dicts=[emoticons]
        )

Reading twitter - 1grams ...
Reading twitter - 2grams ...
Reading twitter - 1grams ...

>>> def custom_processing(x, text_processor):
...    text = " ".join(text_processor.pre_process_doc(x))
...    return text

>>> text = "That Mexico vs USA commercial with trump gets your blood boiling. Race war October 10th. Imagine that parking lot. Gaddamnnnnnn VIOLENCE!!!"
	
>>> text_to_process = data.Field(preprocessing=data.Pipeline(lambda x : custom_processing(x, text_processor) ) )
>>> Dataset_input = [data.Example.fromlist(data=[text],fields=[('text', text_to_process)])]
>>> Dataset_input[0]


<torchtext.data.example.Example object at 0x000001ACFA71A748>

>>> Dataset_input[0].text

['that', 'mexico', 'vs', '<allcaps> usa </allcaps>', 'commercial', 'with', 'trump', 'gets', 'your', 'blood', 'boiling .', 'race', 'war', 'october', '1 0 th .', 'imagine', 'that', 'parking', 'lot .', 'gaddamn <elongated>', '<allcaps> violence </allcaps> ! <repeated>']


>>> processed_text = " ".join(text_processor.pre_process_doc(text))
>>> processed_text


'that mexico vs <allcaps> usa </allcaps> commercial with trump gets your blood boiling . race war <date> . imagine that parking lot . gaddamn <elongated> <allcaps> violence </allcaps> ! <repeated>'


>>> print( " ".join(text_processor.pre_process_doc("10th")))

1 0 th

Word Statistics File not Found. | Receiving 404 error while dowloading the file.

While using the library, the word statistics file is again missing from its original source:

Please fix this as soon as possible and please make some more robust solutions for hosting this file. It looks like people faced this problem in the past as well.

Due to this issue, the production service is stopped. Please fix this asap!

Thanks in advance.!

"maximum recursion depth exceeded" Error

Hi,
I am running a segmenter on a big file and I am facing "maximum recursion depth exceeded" error. I am running on a big file. Is there any way to resolve this?

RecursionError Traceback (most recent call last)
in ()
1 message_p = []
2 for i in range(0,len(message), 1000):
----> 3 message_p.append(tweet2lang(message[i:i+1000]))

482 frames
in tweet2lang(message)
18 for w in msg_tokens:
19 if len(w) >3:
---> 20 temp_seg = seg_tw.segment(w)
21 # print(w,temp_seg)
22 message_seg.append(temp_seg)

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in segment(self, word)
133 def segment(self, word):
134 if word.islower():
--> 135 return " ".join(self.find_segment(word)[1])
136 else:
137 return self.case_split.sub(r' \1', word).lower()

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in (.0)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

/usr/local/lib/python3.6/dist-packages/ekphrasis/classes/segmenter.py in find_segment(self, text, prev)
126 return 0.0, []
127 candidates = [self.combine((log10(self.condProbWord(first, prev)), first), self.find_segment(rem, first))
--> 128 for first, rem in self.splits(text)]
129 return max(candidates)
130

RecursionError: maximum recursion depth exceeded

Segmentation: Preserve case?

The Segmentation tool you provide is excellent. One feature request:

Unless I am mistaken, the tool always provided the split words in 1. lower case, and 2. does not provide information for where spaces were inserted. Instead, a preserve_case or capitalize parameter would be helpful (for 1). The following code capitalizes the split string according to the capitalization used in the hashtag.


from ekphrasis.classes.segmenter import Segmenter
segmenter = Segmenter(corpus="twitter")


def word_segmentation(text, fix_case=True):
    words_string = segmenter.segment(text)
    if not fix_case:
        return words_string

    fixed = ""

    n_add = 0
    for i in range(len(words_string)):
        if words_string[i] == " " and text[i+n_add] != " ":
            n_add += 1
            fixed += " "
            continue

        is_capital = text[i-n_add].isupper()
        if is_capital:
            fixed += words_string[i].upper()
        else:
            fixed += words_string[i]
    return fixed

Of course, if the user is using camelCase or PascalCase, the capitalization may not be meaningful, but in other cases, this can be. For instance:

I #eatsomuch food --> I eat so much food.
I care so much. #IranProtests --> I care so much. Iran Protests

Arguably, the use of a stand-alone hashtag approximately refers to a proper noun, in which case the adopted capitalization is meaningful.

how to get the word statistics?

Excuse me, where can I get the word statistics?😢
In other Issue, they said
image
but I can't find the word statistics in such url...
Thanks in advance.!

Spell corrector in other languages

I understand that following Peter Norvig's approach for spelling correction it could be relatively easy to have the corrector work for any given language if a big (and reliable) corpus is available.

I know that you can set the corpus to either "english" or "twitter" and the function ekphrasis.utils.read_stats() will load the corresponding corpus file, I just don't know where do I have to store a new corpus file for it to be used for spelling corrections and what to set as corrector argument when instantiating a TextPreProcessor, for instance.

Getting URLError: <urlopen error [Errno 60] Operation timed out>

Hi Christos, I got this error when I ran the code TextPreProcessor.
Do you know how to fix it?
`Word statistics files not found!
Downloading...

TimeoutError Traceback (most recent call last)
~/anaconda3/lib/python3.6/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
1317 h.request(req.get_method(), req.selector, req.data, headers,
-> 1318 encode_chunked=req.has_header('Transfer-encoding'))
1319 except OSError as err: # timeout error

~/anaconda3/lib/python3.6/http/client.py in request(self, method, url, body, headers, encode_chunked)
1238 """Send a complete request to the server."""
-> 1239 self._send_request(method, url, body, headers, encode_chunked)
1240

~/anaconda3/lib/python3.6/http/client.py in _send_request(self, method, url, body, headers, encode_chunked)
1284 body = _encode(body, 'body')
-> 1285 self.endheaders(body, encode_chunked=encode_chunked)
1286

~/anaconda3/lib/python3.6/http/client.py in endheaders(self, message_body, encode_chunked)
1233 raise CannotSendHeader()
-> 1234 self._send_output(message_body, encode_chunked=encode_chunked)
1235

~/anaconda3/lib/python3.6/http/client.py in _send_output(self, message_body, encode_chunked)
1025 del self._buffer[:]
-> 1026 self.send(msg)
1027

~/anaconda3/lib/python3.6/http/client.py in send(self, data)
963 if self.auto_open:
--> 964 self.connect()
965 else:

~/anaconda3/lib/python3.6/http/client.py in connect(self)
1391
-> 1392 super().connect()
1393

~/anaconda3/lib/python3.6/http/client.py in connect(self)
935 self.sock = self._create_connection(
--> 936 (self.host,self.port), self.timeout, self.source_address)
937 self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

~/anaconda3/lib/python3.6/socket.py in create_connection(address, timeout, source_address)
721 if err is not None:
--> 722 raise err
723 else:

~/anaconda3/lib/python3.6/socket.py in create_connection(address, timeout, source_address)
712 sock.bind(source_address)
--> 713 sock.connect(sa)
714 return sock

TimeoutError: [Errno 60] Operation timed out

During handling of the above exception, another exception occurred:

URLError Traceback (most recent call last)
in
30 # list of dictionaries, for replacing tokens extracted from the text,
31 # with other expressions. You can pass more than one dictionaries.
---> 32 dicts=[emoticons]
33 )
34

~/anaconda3/lib/python3.6/site-packages/ekphrasis/classes/preprocessor.py in init(self, **kwargs)
90
91 if self.unpack_hashtags:
---> 92 self.segmenter = Segmenter(corpus=self.segmenter_corpus)
93 if self.mode != "fast":
94 self.spell_corrector = SpellCorrector(corpus=self.corrector_corpus)

~/anaconda3/lib/python3.6/site-packages/ekphrasis/classes/segmenter.py in init(self, corpus, max_split_length)
57 # self.unigrams = Counter(read_stats(corpus, 1))
58 # self.bigrams = Counter(read_stats(corpus, 2))
---> 59 self.unigrams = read_stats(corpus, 1)
60 self.bigrams = read_stats(corpus, 2)
61 self.N = sum(self.unigrams.values())

~/anaconda3/lib/python3.6/site-packages/ekphrasis/utils/helpers.py in read_stats(corpus, ngram)
45 def read_stats(corpus, ngram):
46 stats_dir = get_stats_dir()
---> 47 check_stats_files()
48 print("Reading " + "{} - {}grams ...".format(corpus, ngram))
49 text = path.join(*[stats_dir, corpus, "counts_{}grams.txt".format(ngram)])

~/anaconda3/lib/python3.6/site-packages/ekphrasis/utils/helpers.py in check_stats_files()
88 stats_dir = get_stats_dir()
89 if not os.path.exists(stats_dir) or len(listdir_nohidden(stats_dir)) == 0:
---> 90 download_statistics()
91
92

~/anaconda3/lib/python3.6/site-packages/ekphrasis/utils/helpers.py in download_statistics()
74 print("Word statistics files not found!\nDownloading...", end=" ")
75 url = "https://www.dropbox.com/s/a84otqrg6u1c5je/stats.zip?dl=1"
---> 76 urlretrieve(url, "stats.zip")
77 print("done!")
78

~/anaconda3/lib/python3.6/urllib/request.py in urlretrieve(url, filename, reporthook, data)
246 url_type, path = splittype(url)
247
--> 248 with contextlib.closing(urlopen(url, data)) as fp:
249 headers = fp.info()
250

~/anaconda3/lib/python3.6/urllib/request.py in urlopen(url, data, timeout, cafile, capath, cadefault, context)
221 else:
222 opener = _opener
--> 223 return opener.open(url, data, timeout)
224
225 def install_opener(opener):

~/anaconda3/lib/python3.6/urllib/request.py in open(self, fullurl, data, timeout)
524 req = meth(req)
525
--> 526 response = self._open(req, data)
527
528 # post-process response

~/anaconda3/lib/python3.6/urllib/request.py in _open(self, req, data)
542 protocol = req.type
543 result = self._call_chain(self.handle_open, protocol, protocol +
--> 544 '_open', req)
545 if result:
546 return result

~/anaconda3/lib/python3.6/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
502 for handler in handlers:
503 func = getattr(handler, meth_name)
--> 504 result = func(*args)
505 if result is not None:
506 return result

~/anaconda3/lib/python3.6/urllib/request.py in https_open(self, req)
1359 def https_open(self, req):
1360 return self.do_open(http.client.HTTPSConnection, req,
-> 1361 context=self._context, check_hostname=self.check_hostname)
1362
1363 https_request = AbstractHTTPHandler.do_request

~/anaconda3/lib/python3.6/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
1318 encode_chunked=req.has_header('Transfer-encoding'))
1319 except OSError as err: # timeout error
-> 1320 raise URLError(err)
1321 r = h.getresponse()
1322 except:

URLError: <urlopen error [Errno 60] Operation timed out>
`

Ekphrasis downloads statistics in /usr/local

If the user does not install ekphrasis using a virtualenv it downloads statistics in /usr/local and requires sudo permissions to run.

Statistics should be downloaded in /home//.ekphrasis to resolve this.

Installing from pypi doesn't pull in deps

Installing with the usual

pip install ekphrasis

doesn't install ftfy, termcolor, or colorama. I'm guessing it doesn't install any of the dependencies, but I already had the others installed.

Do you exposure your underlying language model for uni/bigrams?

This library is really superb.

One of the tools I wish I have had is a basic statistical language model (relative frequency) of various unigrams, bigrams, and trigrams. When extracting keywords from text, one of the failures of TF-IDF is that the relative scores are not calibrated so that unigram and bigram scores can be compared with one another. There also is the trouble of needing to have document and token frequencies. Instead, I normalize the TF/TF-IDF scores against the English corpus statistics, which you have within your models. Usually I use the unwieldy Google NGrams corpus, but yours is succinct and quite helpful. Is this easily accessed?

Thanks!

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.