 TensorFlow.org पर देखें |  Google Colab में चलाएं |  गिटहब पर देखें |  नोटबुक डाउनलोड करें |  TF हब मॉडल देखें |
अवलोकन
टोकनाइजेशन एक स्ट्रिंग को टोकन में तोड़ने की प्रक्रिया है। आमतौर पर, ये टोकन शब्द, संख्याएं और/या विराम चिह्न होते हैं। tensorflow_text पैकेज पाठ preprocessing के लिए उपलब्ध tokenizers के एक नंबर अपने पाठ आधारित मॉडल के लिए आवश्यक प्रदान करता है। TensorFlow ग्राफ़ में टोकननाइज़ेशन करने से, आपको प्रशिक्षण और अनुमान वर्कफ़्लोज़ और प्रीप्रोसेसिंग स्क्रिप्ट के प्रबंधन के बीच अंतर के बारे में चिंता करने की आवश्यकता नहीं होगी।
यह मार्गदर्शिका TensorFlow टेक्स्ट द्वारा प्रदान किए गए कई टोकन विकल्पों पर चर्चा करती है, जब आप एक विकल्प को दूसरे पर उपयोग करना चाहते हैं, और आपके मॉडल के भीतर से इन टोकननाइज़र को कैसे बुलाया जाता है।
सेट अप
pip install -q tensorflow-text
import requests
import tensorflow as tf
import tensorflow_text as tf_text
स्प्लिटर एपीआई
मुख्य इंटरफेस हैं Splitter और SplitterWithOffsets जो एकल तरीकों split और split_with_offsets । SplitterWithOffsets संस्करण (जो फैली Splitter ) बाइट ऑफसेट प्राप्त करने के लिए एक विकल्प भी शामिल है। यह कॉलर को यह जानने की अनुमति देता है कि बनाए गए टोकन को मूल स्ट्रिंग में कौन से बाइट्स से बनाया गया था।
Tokenizer और TokenizerWithOffsets के विशेष संस्करण हैं Splitter कि सुविधा विधियां उपलब्ध करा tokenize और tokenize_with_offsets क्रमशः।
आम तौर पर, किसी भी एन आयामी इनपुट के लिए, लौटे टोकन एक एन 1 आयामी में हैं RaggedTensor मूल व्यक्ति तार से मैप टोकन के भीतर सबसे आयाम के साथ।
class Splitter {
@abstractmethod
def split(self, input)
}
class SplitterWithOffsets(Splitter) {
@abstractmethod
def split_with_offsets(self, input)
}
वहाँ भी एक है Detokenizer इंटरफ़ेस। इस इंटरफ़ेस को लागू करने वाला कोई भी टोकननाइज़र टोकन के एन-आयामी रैग्ड टेंसर को स्वीकार कर सकता है, और आम तौर पर एक एन-1-आयामी टेंसर या रैग्ड टेंसर देता है जिसमें दिए गए टोकन एक साथ इकट्ठे होते हैं।
class Detokenizer {
@abstractmethod
def detokenize(self, input)
}
टोकनीज़र
नीचे TensorFlow Text द्वारा प्रदान किए गए टोकनों का सूट है। स्ट्रिंग इनपुट को UTF-8 माना जाता है। समीक्षा करें यूनिकोड गाइड UTF-8 में तार बदलने के लिए।
संपूर्ण शब्द टोकनाइज़र
ये टोकनर एक स्ट्रिंग को शब्दों से विभाजित करने का प्रयास करते हैं, और टेक्स्ट को विभाजित करने का सबसे सहज तरीका है।
व्हाईटस्पेसटोकनाइज़र
text.WhitespaceTokenizer सबसे बुनियादी tokenizer जो (जैसे। अंतरिक्ष, टैब, नई लाइन) आईसीयू परिभाषित खाली स्थान के पात्रों पर तार विभाजन है। प्रोटोटाइप मॉडल को जल्दी से बनाने के लिए यह अक्सर अच्छा होता है।
tokenizer = tf_text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/util/dispatch.py:206: batch_gather (from tensorflow.python.ops.array_ops) is deprecated and will be removed after 2017-10-25. Instructions for updating: `tf.batch_gather` is deprecated, please use `tf.gather` with `batch_dims=-1` instead. [[b'What', b'you', b'know', b'you', b"can't", b'explain,', b'but', b'you', b'feel', b'it.']]
आप देख सकते हैं कि इस टोकननाइज़र की एक कमी यह है कि एक टोकन बनाने के लिए शब्द के साथ विराम चिह्न शामिल है। शब्द और अलग टोकन में विराम चिह्न विभाजित करने के लिए, UnicodeScriptTokenizer इस्तेमाल किया जाना चाहिए।
यूनिकोडस्क्रिप्टटोकनाइज़र
UnicodeScriptTokenizer यूनिकोड स्क्रिप्ट सीमाओं के आधार पर तार बांट देता है। उपयोग किए गए स्क्रिप्ट कोड इंटरनेशनल कंपोनेंट्स फॉर यूनिकोड (ICU) UScriptCode मानों के अनुरूप हैं। देखें: http://icu-project.org/apiref/icu4c/uscript_8h.html
व्यवहार में, इस के समान है WhitespaceTokenizer सबसे स्पष्ट अंतर किया जा रहा है के साथ है कि यह भाषा के ग्रंथों (जैसे। USCRIPT_LATIN, USCRIPT_CYRILLIC, आदि) करते हुए भी एक दूसरे से भाषा के ग्रंथों को अलग करने से विराम चिह्न (USCRIPT_COMMON) विभाजित कर देगा। ध्यान दें कि यह संकुचन शब्दों को अलग टोकन में भी विभाजित करेगा।
tokenizer = tf_text.UnicodeScriptTokenizer()
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
[[b'What', b'you', b'know', b'you', b'can', b"'", b't', b'explain', b',', b'but', b'you', b'feel', b'it', b'.']]
सबवर्ड टोकनाइज़र
सबवर्ड टोकन का उपयोग छोटी शब्दावली के साथ किया जा सकता है, और मॉडल को इसे बनाने वाले उपशब्दों से उपन्यास शब्दों के बारे में कुछ जानकारी रखने की अनुमति देता है।
हम संक्षेप में नीचे subword tokenization विकल्पों पर चर्चा, लेकिन subword tokenization ट्यूटोरियल गहराई में और अधिक हो जाता है और यह भी बताते हैं कि कैसे vocab फ़ाइलें उत्पन्न करने के लिए।
वर्डपीसटोकनाइज़र
वर्डपीस टोकनाइजेशन एक डेटा-संचालित टोकनाइजेशन योजना है जो उप-टोकन का एक सेट उत्पन्न करती है। ये उप टोकन भाषाई मर्फीम के अनुरूप हो सकते हैं, लेकिन अक्सर ऐसा नहीं होता है।
WordpieceTokenizer उम्मीद करता है कि इनपुट पहले से ही टोकन में विभाजित हो जाएगा। इस शर्त के कारण, आप अक्सर उपयोग करते हुए विभाजित करना चाहते हैं जाएगा WhitespaceTokenizer या UnicodeScriptTokenizer पहले से।
tokenizer = tf_text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
[[b'What', b'you', b'know', b'you', b"can't", b'explain,', b'but', b'you', b'feel', b'it.']]
बाद स्ट्रिंग टोकन में विभाजित है, WordpieceTokenizer subtokens में विभाजित किया जा सकता है।
url = "https://github.com/tensorflow/text/blob/master/tensorflow_text/python/ops/test_data/test_wp_en_vocab.txt?raw=true"
r = requests.get(url)
filepath = "vocab.txt"
open(filepath, 'wb').write(r.content)
52382
subtokenizer = tf_text.UnicodeScriptTokenizer(filepath)
subtokens = tokenizer.tokenize(tokens)
print(subtokens.to_list())
[[[b'What'], [b'you'], [b'know'], [b'you'], [b"can't"], [b'explain,'], [b'but'], [b'you'], [b'feel'], [b'it.']]]
बर्टटोकनाइज़र
BertTokenizer BERT पेपर से टोकननाइज़ेशन के मूल कार्यान्वयन को दर्शाता है। यह WordpieceTokenizer द्वारा समर्थित है, लेकिन पहले शब्दों को सामान्यीकरण और टोकनिंग जैसे अतिरिक्त कार्य भी करता है।
tokenizer = tf_text.BertTokenizer(filepath, token_out_type=tf.string, lower_case=True)
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
[[[b'what'], [b'you'], [b'know'], [b'you'], [b'can'], [b"'"], [b't'], [b'explain'], [b','], [b'but'], [b'you'], [b'feel'], [b'it'], [b'.']]]
सेंटेंसपीसटोकनाइज़र
SentencepieceTokenizer एक उप-टोकन टोकननाइज़र है जो अत्यधिक विन्यास योग्य है। यह सेंटेंसपीस लाइब्रेरी द्वारा समर्थित है। BertTokenizer की तरह, इसमें उप-टोकन में विभाजित करने से पहले सामान्यीकरण और टोकन विभाजन शामिल हो सकते हैं।
url = "https://github.com/tensorflow/text/blob/master/tensorflow_text/python/ops/test_data/test_oss_model.model?raw=true"
sp_model = requests.get(url).content
tokenizer = tf_text.SentencepieceTokenizer(sp_model, out_type=tf.string)
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
[[b'\xe2\x96\x81What', b'\xe2\x96\x81you', b'\xe2\x96\x81know', b'\xe2\x96\x81you', b'\xe2\x96\x81can', b"'", b't', b'\xe2\x96\x81explain', b',', b'\xe2\x96\x81but', b'\xe2\x96\x81you', b'\xe2\x96\x81feel', b'\xe2\x96\x81it', b'.']]
अन्य स्प्लिटर्स
यूनिकोडचारटोकनाइज़र
यह एक स्ट्रिंग को UTF-8 वर्णों में विभाजित करता है। यह उन CJK भाषाओं के लिए उपयोगी है जिनमें शब्दों के बीच रिक्त स्थान नहीं है।
tokenizer = tf_text.UnicodeCharTokenizer()
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
[[87, 104, 97, 116, 32, 121, 111, 117, 32, 107, 110, 111, 119, 32, 121, 111, 117, 32, 99, 97, 110, 39, 116, 32, 101, 120, 112, 108, 97, 105, 110, 44, 32, 98, 117, 116, 32, 121, 111, 117, 32, 102, 101, 101, 108, 32, 105, 116, 46]]
आउटपुट यूनिकोड कोडपॉइंट है। यह चरित्र एनग्राम बनाने के लिए भी उपयोगी हो सकता है, जैसे कि बिग्राम। वापस UTF-8 अक्षरों में बदलने के लिए।
characters = tf.strings.unicode_encode(tf.expand_dims(tokens, -1), "UTF-8")
bigrams = tf_text.ngrams(characters, 2, reduction_type=tf_text.Reduction.STRING_JOIN, string_separator='')
print(bigrams.to_list())
[[b'Wh', b'ha', b'at', b't ', b' y', b'yo', b'ou', b'u ', b' k', b'kn', b'no', b'ow', b'w ', b' y', b'yo', b'ou', b'u ', b' c', b'ca', b'an', b"n'", b"'t", b't ', b' e', b'ex', b'xp', b'pl', b'la', b'ai', b'in', b'n,', b', ', b' b', b'bu', b'ut', b't ', b' y', b'yo', b'ou', b'u ', b' f', b'fe', b'ee', b'el', b'l ', b' i', b'it', b't.']]
हबमॉड्यूलटोकनाइज़र
यह कॉल को आसान बनाने के लिए TF हब में तैनात मॉडल के चारों ओर एक आवरण है क्योंकि TF हब वर्तमान में रैग्ड टेंसर का समर्थन नहीं करता है। जब आप शब्दों में विभाजित करना चाहते हैं, लेकिन अनुमानी मार्गदर्शिका प्रदान करने के लिए रिक्त स्थान नहीं होते हैं, तो एक मॉडल का प्रदर्शन टोकनीकरण सीजेके भाषाओं के लिए विशेष रूप से उपयोगी होता है। इस समय, हमारे पास चीनी के लिए एकल सेगमेंटेशन मॉडल है।
MODEL_HANDLE = "https://tfhub.dev/google/zh_segmentation/1"
segmenter = tf_text.HubModuleTokenizer(MODEL_HANDLE)
tokens = segmenter.tokenize(["新华社北京"])
print(tokens.to_list())
[[b'\xe6\x96\xb0\xe5\x8d\x8e\xe7\xa4\xbe', b'\xe5\x8c\x97\xe4\xba\xac']]
UTF-8 एन्कोडेड बाइट स्ट्रिंग्स के परिणामों को देखना मुश्किल हो सकता है। देखने को आसान बनाने के लिए सूची मानों को डिकोड करें।
def decode_list(x):
if type(x) is list:
return list(map(decode_list, x))
return x.decode("UTF-8")
def decode_utf8_tensor(x):
return list(map(decode_list, x.to_list()))
print(decode_utf8_tensor(tokens))
[['新华社', '北京']]
स्प्लिटमर्जटोकनाइज़र
SplitMergeTokenizer और SplitMergeFromLogitsTokenizer प्रदान की मानों से संकेत मिलता है जहां स्ट्रिंग विभाजन होना चाहिए के आधार पर बंटवारे की एक लक्षित उद्देश्य एक स्ट्रिंग है। पिछले सेगमेंटेशन उदाहरण की तरह अपना खुद का सेगमेंटेशन मॉडल बनाते समय यह उपयोगी होता है।
के लिए SplitMergeTokenizer , 0 मान एक नया स्ट्रिंग की शुरुआत का संकेत करने के लिए किया जाता है, और 1 के मूल्य इंगित करता है चरित्र वर्तमान स्ट्रिंग का हिस्सा है।
strings = ["新华社北京"]
labels = [[0, 1, 1, 0, 1]]
tokenizer = tf_text.SplitMergeTokenizer()
tokens = tokenizer.tokenize(strings, labels)
print(decode_utf8_tensor(tokens))
[['新华社', '北京']]
SplitMergeFromLogitsTokenizer समान है, लेकिन यह बजाय एक तंत्रिका नेटवर्क का अनुमान है कि अगर हर किरदार के लिए एक नया स्ट्रिंग में विभाजित किया जाना चाहिए या वर्तमान एक में मिला दिया से logit मान युग्म स्वीकार करता है।
strings = [["新华社北京"]]
labels = [[[5.0, -3.2], [0.2, 12.0], [0.0, 11.0], [2.2, -1.0], [-3.0, 3.0]]]
tokenizer = tf_text.SplitMergeFromLogitsTokenizer()
tokenizer.tokenize(strings, labels)
print(decode_utf8_tensor(tokens))
[['新华社', '北京']]
रेगेक्सस्प्लिटर
RegexSplitter एक प्रदान की नियमित अभिव्यक्ति द्वारा परिभाषित मनमाना breakpoints पर खंड तार करने में सक्षम है।
splitter = tf_text.RegexSplitter("\s")
tokens = splitter.split(["What you know you can't explain, but you feel it."], )
print(tokens.to_list())
[[b'What', b'you', b'know', b'you', b"can't", b'explain,', b'but', b'you', b'feel', b'it.']]
ऑफसेट
स्ट्रिंग्स को टोकन करते समय, अक्सर यह जानना वांछित होता है कि मूल स्ट्रिंग में टोकन की उत्पत्ति कहाँ से हुई है। इस कारण से, प्रत्येक tokenizer जो औजार के लिए TokenizerWithOffsets एक tokenize_with_offsets विधि है कि टोकन के साथ बाइट ऑफसेट वापस आ जाएगी है। start_offsets प्रत्येक टोकन से शुरू होने वाली मूल स्ट्रिंग में बाइट्स को सूचीबद्ध करता है, और end_offsets उस बिंदु के तुरंत बाद बाइट्स को सूचीबद्ध करता है जहां प्रत्येक टोकन समाप्त होता है। रीफ़्रेज़ करने के लिए, प्रारंभ ऑफ़सेट समावेशी होते हैं और अंतिम ऑफ़सेट अनन्य होते हैं।
tokenizer = tf_text.UnicodeScriptTokenizer()
(tokens, start_offsets, end_offsets) = tokenizer.tokenize_with_offsets(['Everything not saved will be lost.'])
print(tokens.to_list())
print(start_offsets.to_list())
print(end_offsets.to_list())
[[b'Everything', b'not', b'saved', b'will', b'be', b'lost', b'.']] [[0, 11, 15, 21, 26, 29, 33]] [[10, 14, 20, 25, 28, 33, 34]]
डिटोकेनाइजेशन
Tokenizers जो लागू Detokenizer एक प्रदान detokenize तरीका है जिसके तार गठबंधन करने के लिए प्रयास करता है। इसमें हानिपूर्ण होने की संभावना है, इसलिए डिटोकनाइज्ड स्ट्रिंग हमेशा मूल, पूर्व-टोकनयुक्त स्ट्रिंग से मेल नहीं खा सकती है।
tokenizer = tf_text.UnicodeCharTokenizer()
tokens = tokenizer.tokenize(["What you know you can't explain, but you feel it."])
print(tokens.to_list())
strings = tokenizer.detokenize(tokens)
print(strings.numpy())
[[87, 104, 97, 116, 32, 121, 111, 117, 32, 107, 110, 111, 119, 32, 121, 111, 117, 32, 99, 97, 110, 39, 116, 32, 101, 120, 112, 108, 97, 105, 110, 44, 32, 98, 117, 116, 32, 121, 111, 117, 32, 102, 101, 101, 108, 32, 105, 116, 46]] [b"What you know you can't explain, but you feel it."]
टीएफ डेटा
टीएफ डेटा प्रशिक्षण मॉडल के लिए इनपुट पाइपलाइन बनाने के लिए एक शक्तिशाली एपीआई है। टोकनाइज़र एपीआई के साथ अपेक्षा के अनुरूप काम करते हैं।
docs = tf.data.Dataset.from_tensor_slices([['Never tell me the odds.'], ["It's a trap!"]])
tokenizer = tf_text.WhitespaceTokenizer()
tokenized_docs = docs.map(lambda x: tokenizer.tokenize(x))
iterator = iter(tokenized_docs)
print(next(iterator).to_list())
print(next(iterator).to_list())
[[b'Never', b'tell', b'me', b'the', b'odds.']] [[b"It's", b'a', b'trap!']]