Python Untokenize une phrase

Vous pouvez utiliser "treebank detokenizer" - TreebankWordDetokenizer:

from nltk.tokenize.treebank import TreebankWordDetokenizer
TreebankWordDetokenizer().detokenize(['the', 'quick', 'brown'])
# 'The quick brown'

Il est également MosesDetokenizer qui était dans nltk mais est supprimé en raison de la les questions de licences, mais il est disponible en tant que Sacremoses package autonome.

utilisation token_utils.untokenize de ici

import re
def untokenize(words):
    """
    Untokenizing a text undoes the tokenizing operation, restoring
    punctuation and spaces to the places that people expect them to be.
    Ideally, `untokenize(tokenize(text))` should be identical to `text`,
    except for line breaks.
    """
    text = ' '.join(words)
    step1 = text.replace("`` ", '"').replace(" ''", '"').replace('. . .',  '...')
    step2 = step1.replace(" ( ", " (").replace(" ) ", ") ")
    step3 = re.sub(r' ([.,:;?!%]+)([ \'"`])', r"", step2)
    step4 = re.sub(r' ([.,:;?!%]+)$', r"", step3)
    step5 = step4.replace(" '", "'").replace(" n't", "n't").replace(
         "can not", "cannot")
    step6 = step5.replace(" ` ", " '")
    return step6.strip()

 tokenized = ['I', "'ve", 'found', 'a', 'medicine', 'for', 'my','disease', '.']
 untokenize(tokenized)
 "I've found a medicine for my disease."

Pour moi, cela a fonctionné quand j'ai installé python nltk 3.2.5,

pip install -U nltk

puis,

import nltk
nltk.download('perluniprops')

from nltk.tokenize.moses import MosesDetokenizer

Si vous utilisez l'intérieur des pandas dataframe, puis

df['detoken']=df['token_column'].apply(lambda x: detokenizer.detokenize(x, return_str=True))

Je propose de garder des décalages dans la segmentation: (jeton, offset).
Je pense que, cette information est utile pour le traitement au cours de la phrase originale.

import re
from nltk.tokenize import word_tokenize

def offset_tokenize(text):
    tail = text
    accum = 0
    tokens = self.tokenize(text)
    info_tokens = []
    for tok in tokens:
        scaped_tok = re.escape(tok)
        m = re.search(scaped_tok, tail)
        start, end = m.span()
        # global offsets
        gs = accum + start
        ge = accum + end
        accum += end
        # keep searching in the rest
        tail = tail[end:]
        info_tokens.append((tok, (gs, ge)))
    return info_token

sent = '''I've found a medicine for my disease.

This is line:3.'''

toks_offsets = offset_tokenize(sent)

for t in toks_offsets:
(tok, offset) = t
print (tok == sent[offset[0]:offset[1]]), tok, sent[offset[0]:offset[1]]

Donne:

True I I
True 've 've
True found found
True a a
True medicine medicine
True for for
True my my
True disease disease
True . .
True This This
True is is
True line:3 line:3
True . .

La raison, il n'existe pas de réponse simple est que vous avez réellement besoin de la durée de lieux de l'original de jetons dans la chaîne. Si vous n'avez pas cela, et vous n'êtes pas d'ingénierie inverse de l'original de votre tokenisation, votre remonté la chaîne est basée sur des suppositions à propos de la segmentation des règles qui ont été utilisés. Si votre générateur de jetons de ne pas donner à vous couvre, vous pouvez toujours le faire si vous avez trois choses:

1) l'original de La chaîne

2) L'original de jetons

3) La modification de jetons (je suis en supposant que vous avez changé les jetons d'une certaine façon, parce que c'est la seule application pour ça, je pense que si vous avez déjà #1)

Utiliser l'original jeton de jeu pour identifier les travées (ne serait-il pas agréable si le tokenizer fait ça?) et modifier la chaîne de l'arrière vers l'avant de sorte que le couvre ne changent pas, comme vous allez.

Ici, je suis en utilisant TweetTokenizer mais il ne devrait pas d'importance aussi longtemps que le générateur de jetons que vous utilisez ne permet pas de modifier les valeurs de vos jetons de sorte qu'ils ne sont pas réellement dans la chaîne d'origine.

tokenizer=nltk.tokenize.casual.TweetTokenizer()
string="One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible vermin."
tokens=tokenizer.tokenize(string)
replacement_tokens=list(tokens)
replacement_tokens[-3]="cute"

def detokenize(string,tokens,replacement_tokens):
    spans=[]
    cursor=0
    for token in tokens:
        while not string[cursor:cursor+len(token)]==token and cursor<len(string):
            cursor+=1        
        if cursor==len(string):break
        newcursor=cursor+len(token)
        spans.append((cursor,newcursor))
        cursor=newcursor
    i=len(tokens)-1
    for start,end in spans[::-1]:
        string=string[:start]+replacement_tokens[i]+string[end:]
        i-=1
    return string

>>> detokenize(string,tokens,replacement_tokens)
'One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a cute vermin.'