o i eXw@sdZddlZddlmmZddlmZddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZd Zd ZdZdZdZe jZe jZe jZe j Z dZ!eddgdGddde j"Z#dS)z-Keras text vectorization preprocessing layer.N)backend)base_preprocessing_layer)preprocessing_utils) string_lookup)layer_serialization)deserialize_keras_object) layer_utils)tf_utils) keras_exportlower_and_strip_punctuationstrip_punctuationlower whitespace characterz)[!"#$%&()\*\+,-\./:;<=>?@\[\\\]^_`{|}~\']zkeras.layers.TextVectorizationz9keras.layers.experimental.preprocessing.TextVectorization)v1cseZdZdZ            d/fdd Zd d Zd d Zd0fdd ZddZddZ ddZ d1ddZ ddZ fddZ eddZd2dd Zd!d"Zd#d$Zed%d&Zd'd(Zd)d*Zd+d,Zd-d.ZZS)3TextVectorizationa5)A preprocessing layer which maps text features to integer sequences. This layer has basic options for managing text in a Keras model. It transforms a batch of strings (one example = one string) into either a list of token indices (one example = 1D tensor of integer token indices) or a dense representation (one example = 1D tensor of float values representing data about the example's tokens). This layer is meant to handle natural language inputs. To handle simple string inputs (categorical strings or pre-tokenized strings) see `tf.keras.layers.StringLookup`. The vocabulary for the layer must be either supplied on construction or learned via `adapt()`. When this layer is adapted, it will analyze the dataset, determine the frequency of individual string values, and create a vocabulary from them. This vocabulary can have unlimited size or be capped, depending on the configuration options for this layer; if there are more unique values in the input than the maximum vocabulary size, the most frequent terms will be used to create the vocabulary. The processing of each example contains the following steps: 1. Standardize each example (usually lowercasing + punctuation stripping) 2. Split each example into substrings (usually words) 3. Recombine substrings into tokens (usually ngrams) 4. Index tokens (associate a unique int value with each token) 5. Transform each example using this index, either into a vector of ints or a dense float vector. Some notes on passing callables to customize splitting and normalization for this layer: 1. Any callable can be passed to this Layer, but if you want to serialize this object you should only pass functions that are registered Keras serializables (see `tf.keras.saving.register_keras_serializable` for more details). 2. When using a custom callable for `standardize`, the data received by the callable will be exactly as passed to this layer. The callable should return a tensor of the same shape as the input. 3. When using a custom callable for `split`, the data received by the callable will have the 1st dimension squeezed out - instead of `[["string to split"], ["another string to split"]]`, the Callable will see `["string to split", "another string to split"]`. The callable should return a Tensor with the first dimension containing the split tokens - in this example, we should see something like `[["string", "to", "split"], ["another", "string", "to", "split"]]`. This makes the callable site natively compatible with `tf.strings.split()`. For an overview and full list of preprocessing layers, see the preprocessing [guide](https://www.tensorflow.org/guide/keras/preprocessing_layers). Args: max_tokens: Maximum size of the vocabulary for this layer. This should only be specified when adapting a vocabulary or when setting `pad_to_max_tokens=True`. Note that this vocabulary contains 1 OOV token, so the effective number of tokens is `(max_tokens - 1 - (1 if output_mode == "int" else 0))`. standardize: Optional specification for standardization to apply to the input text. Values can be: - `None`: No standardization. - `"lower_and_strip_punctuation"`: Text will be lowercased and all punctuation removed. - `"lower"`: Text will be lowercased. - `"strip_punctuation"`: All punctuation will be removed. - Callable: Inputs will passed to the callable function, which should be standardized and returned. split: Optional specification for splitting the input text. Values can be: - `None`: No splitting. - `"whitespace"`: Split on whitespace. - `"character"`: Split on each unicode character. - Callable: Standardized inputs will passed to the callable function, which should be split and returned. ngrams: Optional specification for ngrams to create from the possibly-split input text. Values can be None, an integer or tuple of integers; passing an integer will create ngrams up to that integer, and passing a tuple of integers will create ngrams for the specified values in the tuple. Passing None means that no ngrams will be created. output_mode: Optional specification for the output of the layer. Values can be `"int"`, `"multi_hot"`, `"count"` or `"tf_idf"`, configuring the layer as follows: - `"int"`: Outputs integer indices, one integer index per split string token. When `output_mode == "int"`, 0 is reserved for masked locations; this reduces the vocab size to `max_tokens - 2` instead of `max_tokens - 1`. - `"multi_hot"`: Outputs a single int array per batch, of either vocab_size or max_tokens size, containing 1s in all elements where the token mapped to that index exists at least once in the batch item. - `"count"`: Like `"multi_hot"`, but the int array contains a count of the number of times the token at that index appeared in the batch item. - `"tf_idf"`: Like `"multi_hot"`, but the TF-IDF algorithm is applied to find the value in each token slot. For `"int"` output, any shape of input and output is supported. For all other output modes, currently only rank 1 inputs (and rank 2 outputs after splitting) are supported. output_sequence_length: Only valid in INT mode. If set, the output will have its time dimension padded or truncated to exactly `output_sequence_length` values, resulting in a tensor of shape `(batch_size, output_sequence_length)` regardless of how many tokens resulted from the splitting step. Defaults to `None`. pad_to_max_tokens: Only valid in `"multi_hot"`, `"count"`, and `"tf_idf"` modes. If True, the output will have its feature axis padded to `max_tokens` even if the number of unique tokens in the vocabulary is less than max_tokens, resulting in a tensor of shape `(batch_size, max_tokens)` regardless of vocabulary size. Defaults to `False`. vocabulary: Optional. Either an array of strings or a string path to a text file. If passing an array, can pass a tuple, list, 1D numpy array, or 1D tensor containing the string vocabulary terms. If passing a file path, the file should contain one line per term in the vocabulary. If this argument is set, there is no need to `adapt()` the layer. idf_weights: Only valid when `output_mode` is `"tf_idf"`. A tuple, list, 1D numpy array, or 1D tensor of the same length as the vocabulary, containing the floating point inverse document frequency weights, which will be multiplied by per sample term counts for the final `tf_idf` weight. If the `vocabulary` argument is set, and `output_mode` is `"tf_idf"`, this argument must be supplied. ragged: Boolean. Only applicable to `"int"` output mode. If True, returns a `RaggedTensor` instead of a dense `Tensor`, where each sequence may have a different length after string splitting. Defaults to `False`. sparse: Boolean. Only applicable to `"multi_hot"`, `"count"`, and `"tf_idf"` output modes. If True, returns a `SparseTensor` instead of a dense `Tensor`. Defaults to `False`. encoding: Optional. The text encoding to use to interpret the input strings. Defaults to `"utf-8"`. Example: This example instantiates a `TextVectorization` layer that lowercases text, splits on whitespace, strips punctuation, and outputs integer vocab indices. >>> text_dataset = tf.data.Dataset.from_tensor_slices(["foo", "bar", "baz"]) >>> max_features = 5000 # Maximum vocab size. >>> max_len = 4 # Sequence length to pad the outputs to. >>> >>> # Create the layer. >>> vectorize_layer = tf.keras.layers.TextVectorization( ... max_tokens=max_features, ... output_mode='int', ... output_sequence_length=max_len) >>> >>> # Now that the vocab layer has been created, call `adapt` on the >>> # text-only dataset to create the vocabulary. You don't have to batch, >>> # but for large datasets this means we're not keeping spare copies of >>> # the dataset. >>> vectorize_layer.adapt(text_dataset.batch(64)) >>> >>> # Create the model that uses the vectorize text layer >>> model = tf.keras.models.Sequential() >>> >>> # Start by creating an explicit input layer. It needs to have a shape of >>> # (1,) (because we need to guarantee that there is exactly one string >>> # input per batch), and the dtype needs to be 'string'. >>> model.add(tf.keras.Input(shape=(1,), dtype=tf.string)) >>> >>> # The first layer in our model is the vectorization layer. After this >>> # layer, we have a tensor of shape (batch_size, max_len) containing >>> # vocab indices. >>> model.add(vectorize_layer) >>> >>> # Now, the model can map strings to integers, and you can add an >>> # embedding layer to map these integers to learned embeddings. >>> input_data = [["foo qux bar"], ["qux baz"]] >>> model.predict(input_data) array([[2, 1, 4, 0], [1, 3, 0, 0]]) Example: This example instantiates a `TextVectorization` layer by passing a list of vocabulary terms to the layer's `__init__()` method. >>> vocab_data = ["earth", "wind", "and", "fire"] >>> max_len = 4 # Sequence length to pad the outputs to. >>> >>> # Create the layer, passing the vocab directly. You can also pass the >>> # vocabulary arg a path to a file containing one vocabulary word per >>> # line. >>> vectorize_layer = tf.keras.layers.TextVectorization( ... max_tokens=max_features, ... output_mode='int', ... output_sequence_length=max_len, ... vocabulary=vocab_data) >>> >>> # Because we've passed the vocabulary directly, we don't need to adapt >>> # the layer - the vocabulary is already set. The vocabulary contains the >>> # padding token ('') and OOV token ('[UNK]') as well as the passed >>> # tokens. >>> vectorize_layer.get_vocabulary() ['', '[UNK]', 'earth', 'wind', 'and', 'fire'] Nr rintFutf-8c  s6d| vr| dtjkrtd| ddd| vrtj| d<tj|tttfdddddtj|tt fddddd|d kr?t }|d krEt }tj|t t t t fdd dd |dusqt|tsqt|trjtd d|Dsqtd||t krt|ts|dustd||t kr|durtd|d| r|t krtd| d|| r|durtd| d|||_||_||_||_t|trttd|d|_n||_| |_||_||_| |_| d|du|_| dd}tjdi| t j!"d#dt$j%||| |d|dur|nt | |j| |d |_&dS)NdtypezE`TextVectorization` may only have a dtype of string. Received dtype: .r standardizeT)allowable_strings layer_namearg_name allow_noneallow_callablessplitbinaryztf-idf output_mode)rrrrcss|]}t|tVqdSN) isinstancer).0itemr#`/var/www/myenv/lib/python3.10/site-packages/keras/src/layers/preprocessing/text_vectorization.py @sz-TextVectorization.__init__..zL`ngrams` must be None, an integer, or a tuple of integers. Received: ngrams=zy`output_sequence_length` must be either None or an integer when `output_mode` is 'int'. Received: output_sequence_length=zh`output_sequence_length` must not be set if `output_mode` is not 'int'. Received output_sequence_length=zH`ragged` must not be true if `output_mode` is `'int'`. Received: ragged=z and output_mode=zM`output_sequence_length` must not be set if ragged is True. Received: ragged=z and output_sequence_length=has_input_vocabularyvocabulary_size) max_tokens vocabulary idf_weightspad_to_max_tokens mask_tokenrsparser'encodingr(r#)'tfstring ValueErrorrvalidate_string_argLOWER_AND_STRIP_PUNCTUATIONLOWERSTRIP_PUNCTUATION WHITESPACE CHARACTER MULTI_HOTTF_IDFINTCOUNTr rtupleall _max_tokens _standardize_split _ngrams_argrange_ngrams_ragged _output_mode_output_sequence_length _encodingpop_has_input_vocabularysuper__init__rkeras_kpl_gaugeget_cellsetr StringLookup _lookup_layer)selfr*rrngramsroutput_sequence_lengthr-r+r,r/raggedr0kwargsr( __class__r#r$rMs         zTextVectorization.__init__cCsZ|jtkrt|d|jgS|jdur!t|dkr t|d}nt|d}|j |S)Nrr&)r&r) rGr<r1 TensorShaperHrBlenr>rRcompute_output_shape)rS input_shaper#r#r$r\s       z&TextVectorization.compute_output_shapecCs6||j}|jtkrtjnt}tj ||dS)N)shaper) r\r^as_listrGr<r1int64rfloatx TensorSpec)rS input_spec output_shape output_dtyper#r#r$compute_output_signaturesz*TextVectorization.compute_output_signaturecstj|||ddS)a Computes a vocabulary of string terms from tokens in a dataset. Calling `adapt()` on a `TextVectorization` layer is an alternative to passing in a precomputed vocabulary on construction via the `vocabulary` argument. A `TextVectorization` layer should always be either adapted over a dataset or supplied with a vocabulary. During `adapt()`, the layer will build a vocabulary of all string tokens seen in the dataset, sorted by occurrence count, with ties broken by sort order of the tokens (high to low). At the end of `adapt()`, if `max_tokens` is set, the vocabulary wil be truncated to `max_tokens` size. For example, adapting a layer with `max_tokens=1000` will compute the 1000 most frequent tokens occurring in the input dataset. If `output_mode='tf-idf'`, `adapt()` will also learn the document frequencies of each token in the input dataset. In order to make `TextVectorization` efficient in any distribution context, the vocabulary is kept static with respect to any compiled `tf.Graph`s that call the layer. As a consequence, if the layer is adapted a second time, any models using the layer should be re-compiled. For more information see `tf.keras.layers.experimental.preprocessing.PreprocessingLayer.adapt`. `adapt()` is meant only as a single machine utility to compute layer state. To analyze a dataset that cannot fit on a single machine, see [Tensorflow Transform]( https://www.tensorflow.org/tfx/transform/get_started) for a multi-machine, map-reduce solution. Arguments: data: The data to train on. It can be passed either as a `tf.data.Dataset`, or as a numpy array. batch_size: Integer or `None`. Number of samples per state update. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of datasets, generators, or `keras.utils.Sequence` instances (since they generate batches). steps: Integer or `None`. Total number of steps (batches of samples) When training with input tensors such as TensorFlow data tensors, the default `None` is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and 'steps' is None, the epoch will run until the input dataset is exhausted. When passing an infinitely repeating dataset, you must specify the `steps` argument. This argument is not supported with array inputs. ) batch_sizestepsN)rLadapt)rSdatargrhrXr#r$ris2zTextVectorization.adaptcCs|j||dSr)rR update_state _preprocess)rSrjr#r#r$rkszTextVectorization.update_statecC|jdSr)rRfinalize_staterSr#r#r$rnz TextVectorization.finalize_statecCrmr)rR reset_stateror#r#r$rqrpzTextVectorization.reset_stateTcCs |j|S)a{Returns the current vocabulary of the layer. Args: include_special_tokens: If True, the returned vocabulary will include the padding and OOV tokens, and a term's index in the vocabulary will equal the term's index when calling the layer. If False, the returned vocabulary will not include any padding or OOV tokens. )rRget_vocabulary)rSinclude_special_tokensr#r#r$rrs z TextVectorization.get_vocabularycCs |jS)zGets the current size of the layer's vocabulary. Returns: The integer size of the vocabulary, including optional mask and OOV indices. )rRr(ror#r#r$r(s z!TextVectorization.vocabulary_sizecsx|jj|j|j|j|j|j|jj|jj|j t |jj t |jj |j|d }t}tt|t|S)N) r*rrrTrrUr-r/rVr+r,r0r()rRr*rArBrCrGrHr-r/rFutilslistify_tensorsinput_vocabularyinput_idf_weightsrIr(rL get_configdictlistitems)rSconfig base_configrXr#r$rxs( zTextVectorization.get_configcCsP|dtttfvrt|d|d<|dttfvr!t|d|d<|di|S)Nrrr#)r5r6r7rr8r9)clsr|r#r#r$ from_configszTextVectorization.from_configcCs|jj||ddS)aWSets vocabulary (and optionally document frequency) for this layer. This method sets the vocabulary and idf weights for this layer directly, instead of analyzing a dataset through 'adapt'. It should be used whenever the vocab (and optionally document frequency) information is already known. If vocabulary data is already present in the layer, this method will replace it. Args: vocabulary: Either an array or a string path to a text file. If passing an array, can pass a tuple, list, 1D numpy array, or 1D tensor containing the vocbulary terms. If passing a file path, the file should contain one line per term in the vocabulary. idf_weights: A tuple, list, 1D numpy array, or 1D tensor of inverse document frequency weights with equal length to vocabulary. Must be set if `output_mode` is `"tf_idf"`. Should not be set otherwise. Raises: ValueError: If there are too many inputs, the inputs do not match, or input data is missing. RuntimeError: If the vocabulary cannot be set when this function is called. This happens when `"multi_hot"`, `"count"`, and "tf_idf" modes, if `pad_to_max_tokens` is False and the layer itself has already been called. )r,N)rRset_vocabulary)rSr+r,r#r#r$rsz TextVectorization.set_vocabularycCs tj|tjd}|jttfvrtj|}|jt tfvr$tj |t d}t |jr.||}|j dur|jjdkrT|jddkrMtd|jd|jjtj|dd}|j tkr`tj|}n|j tkrmtj|d}nt |j rx| |}ntd |j |jdurtjj||jd d }|S) N)rr)r&zWhen using `TextVectorization` to tokenize strings, the input rank must be 1 or the last shape dimension must be 1. Received: inputs.shape=z with rank=)axiszUTF-8z%s is not a supported splitting.TextVectorization supports the following options for `split`: None, 'whitespace', or a Callable. ) ngram_width separator)rt ensure_tensorr1r2rAr6r5stringsr r7 regex_replaceDEFAULT_STRIP_REGEXcallablerBr^rankr3squeezer8rr9 unicode_splitrErT)rSinputsr#r#r$rl9sJ          zTextVectorization._preprocesscCst|tttjfrt|}||}|jdur|S| |}|jt kr&|S|j r+|St |rA|j}|j|d<|jd|dS|jdurp|dd|jf}t|}t|dd|jgfd}t||\}}t||S|S)Nrr) default_valuer^.)r rzr>npndarrayr1convert_to_tensorrlrGrRr<rFr is_raggedr^r_rH to_tensorconcat required_space_to_batch_paddingspad)rSr lookup_datar^ padded_shapepadding_r#r#r$callns2           zTextVectorization.callcCs t|Sr)rVocabularySavedModelSaverror#r#r$_trackable_saved_model_savers z.TextVectorization._trackable_saved_model_savercC|j|dSr)rRsave_own_variablesrSstorer#r#r$rz$TextVectorization.save_own_variablescCrr)rRload_own_variablesrr#r#r$rrz$TextVectorization.load_own_variablescCrr)rR save_assetsrSdir_pathr#r#r$rrzTextVectorization.save_assetscCrr)rR load_assetsrr#r#r$rrzTextVectorization.load_assets) Nr rNrNFNNFFr)NN)Tr)__name__ __module__ __qualname____doc__rMr\rfrirkrnrqrrr(rx classmethodrrrlrpropertyrrrrr __classcell__r#r#rXr$r3sJB 4    5/ r)$rnumpyrtensorflow.compat.v2compatv2r1 keras.srcrkeras.src.enginerkeras.src.layers.preprocessingrrtr#keras.src.saving.legacy.saved_modelr"keras.src.saving.serialization_librkeras.src.utilsrr tensorflow.python.util.tf_exportr r5r7r6r8r9r;r<r:r=rPreprocessingLayerrr#r#r#r$s8