HenryAI/KerasBERTv1-Data · Datasets at Hugging Face

text stringlengths 0 4.99k
layer = preprocessing.Normalization()
layer.adapt(data)
normalized_data = layer(data)

print("Features mean: %.2f" % (normalized_data.numpy().mean()))
print("Features std: %.2f" % (normalized_data.numpy().std()))
The adapt() method takes either a Numpy array or a tf.data.Dataset object. In the case of StringLookup and TextVectorization, you can also pass a list of strings:

data = [
"ξεῖν᾽, ἦ τοι μὲν ὄνειροι ἀμήχανοι ἀκριτόμυθοι",
"γίγνοντ᾽, οὐδέ τι πάντα τελείεται ἀνθρώποισι.",
"δοιαὶ γάρ τε πύλαι ἀμενηνῶν εἰσὶν ὀνείρων:",
"αἱ μὲν γὰρ κεράεσσι τετεύχαται, αἱ δ᾽ ἐλέφαντι:",
"τῶν οἳ μέν κ᾽ ἔλθωσι διὰ πριστοῦ ἐλέφαντος,",
"οἵ ῥ᾽ ἐλεφαίρονται, ἔπε᾽ ἀκράαντα φέροντες:",
"οἱ δὲ διὰ ξεστῶν κεράων ἔλθωσι θύραζε,",
"οἵ ῥ᾽ ἔτυμα κραίνουσι, βροτῶν ὅτε κέν τις ἴδηται.",
]
layer = preprocessing.TextVectorization()
layer.adapt(data)
vectorized_text = layer(data)
print(vectorized_text)
tf.Tensor(
[[37 12 25 5 9 20 21 0 0]
[51 34 27 33 29 18 0 0 0]
[49 52 30 31 19 46 10 0 0]
[ 7 5 50 43 28 7 47 17 0]
[24 35 39 40 3 6 32 16 0]
[ 4 2 15 14 22 23 0 0 0]
[36 48 6 38 42 3 45 0 0]
[ 4 2 13 41 53 8 44 26 11]], shape=(8, 9), dtype=int64)
In addition, adaptable layers always expose an option to directly set state via constructor arguments or weight assignment. If the intended state values are known at layer construction time, or are calculated outside of the adapt() call, they can be set without relying on the layer's internal computation. For instance, if external vocabulary files for the TextVectorization, StringLookup, or IntegerLookup layers already exist, those can be loaded directly into the lookup tables by passing a path to the vocabulary file in the layer's constructor arguments.

Here's an example where we instantiate a StringLookup layer with precomputed vocabulary:

vocab = ["a", "b", "c", "d"]
data = tf.constant([["a", "c", "d"], ["d", "z", "b"]])
layer = preprocessing.StringLookup(vocabulary=vocab)
vectorized_data = layer(data)
print(vectorized_data)
tf.Tensor(
[[2 4 5]
[5 1 3]], shape=(2, 3), dtype=int64)
Preprocessing data before the model or inside the model
There are two ways you could be using preprocessing layers:

Option 1: Make them part of the model, like this:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = rest_of_the_model(x)
model = keras.Model(inputs, outputs)
With this option, preprocessing will happen on device, synchronously with the rest of the model execution, meaning that it will benefit from GPU acceleration. If you're training on GPU, this is the best option for the Normalization layer, and for all image preprocessing and data augmentation layers.

Option 2: apply it to your tf.data.Dataset, so as to obtain a dataset that yields batches of preprocessed data, like this:

dataset = dataset.map(
lambda x, y: (preprocessing_layer(x), y))
With this option, your preprocessing will happen on CPU, asynchronously, and will be buffered before going into the model.

This is the best option for TextVectorization, and all structured data preprocessing layers. It can also be a good option if you're training on CPU and you use image preprocessing layers.

Benefits of doing preprocessing inside the model at inference time
Even if you go with option 2, you may later want to export an inference-only end-to-end model that will include the preprocessing layers. The key benefit to doing this is that it makes your model portable and it helps reduce the training/serving skew.

When all data preprocessing is part of the model, other people can load and use your model without having to be aware of how each feature is expected to be encoded & normalized. Your inference model will be able to process raw images or raw structured data, and will not require users of the model to be aware of the details of e.g. the tokenization scheme used for text, the indexing scheme used for categorical features, whether image pixel values are normalized to [-1, +1] or to [0, 1], etc. This is especially powerful if you're exporting your model to another runtime, such as TensorFlow.js: you won't have to reimplement your preprocessing pipeline in JavaScript.

If you initially put your preprocessing layers in your tf.data pipeline, you can export an inference model that packages the preprocessing. Simply instantiate a new model that chains your preprocessing layers and your training model:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = training_model(x)
inference_model = keras.Model(inputs, outputs)
Quick recipes
Image data augmentation (on-device)
Note that image data augmentation layers are only active during training (similarly to the Dropout layer).

from tensorflow import keras
from tensorflow.keras import layers

# Create a data augmentation stage with horizontal flipping, rotations, zooms
data_augmentation = keras.Sequential(
[
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomRotation(0.1),
preprocessing.RandomZoom(0.1),
]
)

# Create a model that includes the augmentation stage
input_shape = (32, 32, 3)
classes = 10
inputs = keras.Input(shape=input_shape)
# Augment images
x = data_augmentation(inputs)
# Rescale image values to [0, 1]
x = preprocessing.Rescaling(1.0 / 255)(x)
# Add the rest of the model
outputs = keras.applications.ResNet50(
weights=None, input_shape=input_shape, classes=classes

layer = preprocessing.Normalization()

layer.adapt(data)

normalized_data = layer(data)

print("Features mean: %.2f" % (normalized_data.numpy().mean()))

print("Features std: %.2f" % (normalized_data.numpy().std()))

The adapt() method takes either a Numpy array or a tf.data.Dataset object. In the case of StringLookup and TextVectorization, you can also pass a list of strings:

data = [

"ξεῖν᾽, ἦ τοι μὲν ὄνειροι ἀμήχανοι ἀκριτόμυθοι",

"γίγνοντ᾽, οὐδέ τι πάντα τελείεται ἀνθρώποισι.",

"δοιαὶ γάρ τε πύλαι ἀμενηνῶν εἰσὶν ὀνείρων:",

"αἱ μὲν γὰρ κεράεσσι τετεύχαται, αἱ δ᾽ ἐλέφαντι:",

"τῶν οἳ μέν κ᾽ ἔλθωσι διὰ πριστοῦ ἐλέφαντος,",

"οἵ ῥ᾽ ἐλεφαίρονται, ἔπε᾽ ἀκράαντα φέροντες:",

"οἱ δὲ διὰ ξεστῶν κεράων ἔλθωσι θύραζε,",

"οἵ ῥ᾽ ἔτυμα κραίνουσι, βροτῶν ὅτε κέν τις ἴδηται.",

]

layer = preprocessing.TextVectorization()

layer.adapt(data)

vectorized_text = layer(data)

print(vectorized_text)

tf.Tensor(

[[37 12 25 5 9 20 21 0 0]

[51 34 27 33 29 18 0 0 0]

[49 52 30 31 19 46 10 0 0]

[ 7 5 50 43 28 7 47 17 0]

[24 35 39 40 3 6 32 16 0]

[ 4 2 15 14 22 23 0 0 0]

[36 48 6 38 42 3 45 0 0]

[ 4 2 13 41 53 8 44 26 11]], shape=(8, 9), dtype=int64)

In addition, adaptable layers always expose an option to directly set state via constructor arguments or weight assignment. If the intended state values are known at layer construction time, or are calculated outside of the adapt() call, they can be set without relying on the layer's internal computation. For instance, if external vocabulary files for the TextVectorization, StringLookup, or IntegerLookup layers already exist, those can be loaded directly into the lookup tables by passing a path to the vocabulary file in the layer's constructor arguments.

Here's an example where we instantiate a StringLookup layer with precomputed vocabulary:

vocab = ["a", "b", "c", "d"]

data = tf.constant([["a", "c", "d"], ["d", "z", "b"]])

layer = preprocessing.StringLookup(vocabulary=vocab)

vectorized_data = layer(data)

print(vectorized_data)

tf.Tensor(

[[2 4 5]

[5 1 3]], shape=(2, 3), dtype=int64)

Preprocessing data before the model or inside the model

There are two ways you could be using preprocessing layers:

Option 1: Make them part of the model, like this:

inputs = keras.Input(shape=input_shape)

x = preprocessing_layer(inputs)

outputs = rest_of_the_model(x)

model = keras.Model(inputs, outputs)

With this option, preprocessing will happen on device, synchronously with the rest of the model execution, meaning that it will benefit from GPU acceleration. If you're training on GPU, this is the best option for the Normalization layer, and for all image preprocessing and data augmentation layers.

Option 2: apply it to your tf.data.Dataset, so as to obtain a dataset that yields batches of preprocessed data, like this:

dataset = dataset.map(

lambda x, y: (preprocessing_layer(x), y))

With this option, your preprocessing will happen on CPU, asynchronously, and will be buffered before going into the model.

This is the best option for TextVectorization, and all structured data preprocessing layers. It can also be a good option if you're training on CPU and you use image preprocessing layers.

Benefits of doing preprocessing inside the model at inference time

Even if you go with option 2, you may later want to export an inference-only end-to-end model that will include the preprocessing layers. The key benefit to doing this is that it makes your model portable and it helps reduce the training/serving skew.

When all data preprocessing is part of the model, other people can load and use your model without having to be aware of how each feature is expected to be encoded & normalized. Your inference model will be able to process raw images or raw structured data, and will not require users of the model to be aware of the details of e.g. the tokenization scheme used for text, the indexing scheme used for categorical features, whether image pixel values are normalized to [-1, +1] or to [0, 1], etc. This is especially powerful if you're exporting your model to another runtime, such as TensorFlow.js: you won't have to reimplement your preprocessing pipeline in JavaScript.

If you initially put your preprocessing layers in your tf.data pipeline, you can export an inference model that packages the preprocessing. Simply instantiate a new model that chains your preprocessing layers and your training model:

inputs = keras.Input(shape=input_shape)

x = preprocessing_layer(inputs)

outputs = training_model(x)

inference_model = keras.Model(inputs, outputs)

Quick recipes

Image data augmentation (on-device)

Note that image data augmentation layers are only active during training (similarly to the Dropout layer).

from tensorflow import keras

from tensorflow.keras import layers

# Create a data augmentation stage with horizontal flipping, rotations, zooms

data_augmentation = keras.Sequential(

[

preprocessing.RandomFlip("horizontal"),

preprocessing.RandomRotation(0.1),

preprocessing.RandomZoom(0.1),

]

)

# Create a model that includes the augmentation stage

input_shape = (32, 32, 3)

classes = 10

inputs = keras.Input(shape=input_shape)

# Augment images

x = data_augmentation(inputs)

# Rescale image values to [0, 1]

x = preprocessing.Rescaling(1.0 / 255)(x)

# Add the rest of the model

outputs = keras.applications.ResNet50(

weights=None, input_shape=input_shape, classes=classes