การทำงานกับเลเยอร์ก่อนการประมวลผล

ดูใน TensorFlow.org เรียกใช้ใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดสมุดบันทึก

Keras ก่อนการประมวลผลเลเยอร์

API ของเลเยอร์ก่อนการประมวลผล Keras ช่วยให้นักพัฒนาสามารถสร้างไปป์ไลน์การประมวลผลอินพุต Keras-native ไปป์ไลน์การประมวลผลอินพุตเหล่านี้สามารถใช้เป็นรหัสก่อนการประมวลผลที่เป็นอิสระในเวิร์กโฟลว์ที่ไม่ใช่ Keras รวมโดยตรงกับโมเดล Keras และส่งออกเป็นส่วนหนึ่งของ Keras SavedModel

ด้วยเลเยอร์ก่อนการประมวลผล Keras คุณสามารถสร้างและส่งออกโมเดลที่เป็นแบบ end-to-end อย่างแท้จริง: โมเดลที่ยอมรับภาพดิบหรือข้อมูลที่มีโครงสร้างดิบเป็นอินพุต แบบจำลองที่จัดการคุณลักษณะการทำให้เป็นมาตรฐานหรือการจัดทำดัชนีค่าคุณลักษณะด้วยตัวเอง

ชั้นเตรียมการประมวลผลที่พร้อมใช้งาน

ชั้นเตรียมการประมวลผลหลัก

  • เลเยอร์ TextVectorization : เปลี่ยนสตริงดิบเป็นการแสดงที่เข้ารหัสซึ่งสามารถอ่านได้โดยเลเยอร์ Embedding หรือเลเยอร์ Dense
  • Normalization Layer: ดำเนินการปรับคุณสมบัติอินพุตให้เป็นมาตรฐานอย่างชาญฉลาด

ชั้นการประมวลผลข้อมูลที่มีโครงสร้างล่วงหน้า

เลเยอร์เหล่านี้มีไว้สำหรับการเข้ารหัสข้อมูลที่มีโครงสร้างและวิศวกรรมคุณลักษณะ

  • CategoryEncoding Layer: เปลี่ยนคุณสมบัติทางหมวดหมู่จำนวนเต็มเป็นการแสดงแบบหนาแน่นแบบหนึ่งร้อนหลายร้อนหรือ TF-IDF
  • Hashing เลเยอร์: ทำการแฮชคุณลักษณะตามหมวดหมู่หรือที่เรียกว่า "แฮชเคล็ดลับ"
  • Discretization Layer: เปลี่ยนคุณสมบัติตัวเลขที่ต่อเนื่องเป็นคุณสมบัติเชิงหมวดหมู่จำนวนเต็ม
  • ชั้น StringLookup : เปลี่ยนค่าหมวดหมู่สตริงเป็นดัชนีจำนวนเต็ม
  • ชั้น IntegerLookup : เปลี่ยนค่าหมวดหมู่จำนวนเต็มเป็นดัชนีจำนวนเต็ม
  • CategoryCrossing Layer: รวมคุณสมบัติที่เป็นหมวดหมู่เป็นคุณลักษณะที่เกิดร่วมกัน เช่นหากคุณมีค่าคุณลักษณะ "a" และ "b" ก็สามารถให้คุณลักษณะการรวมกัน "a และ b แสดงพร้อมกัน"

เลเยอร์ก่อนการประมวลผลรูปภาพ

เลเยอร์เหล่านี้มีไว้สำหรับสร้างมาตรฐานอินพุตของโมเดลรูปภาพ

  • Resizing เลเยอร์: ปรับขนาดชุดรูปภาพเป็นขนาดเป้าหมาย
  • Rescaling เลเยอร์: ปรับขนาดและชดเชยค่าของชุดภาพ (เช่นเปลี่ยนจากอินพุตในช่วง [0, 255] เป็นอินพุตในช่วง [0, 1]
  • เลเยอร์ CenterCrop : ส่งคืนการครอบตัดตรงกลางของชุดรูปภาพ

เลเยอร์การเพิ่มข้อมูลรูปภาพ

เลเยอร์เหล่านี้ใช้การแปลงการเสริมแบบสุ่มกับรูปภาพจำนวนมาก พวกเขาจะใช้งานในระหว่างการฝึกอบรมเท่านั้น

  • เลเยอร์ RandomCrop
  • เลเยอร์ RandomFlip
  • เลเยอร์ RandomTranslation
  • เลเยอร์ RandomRotation
  • เลเยอร์ RandomZoom
  • RandomHeight
  • ชั้น RandomWidth

วิธี adapt()

ชั้นก่อนการประมวลผลบางชั้นมีสถานะภายในที่ต้องคำนวณตามตัวอย่างของข้อมูลการฝึกอบรม รายการของเลเยอร์ก่อนการประมวลผลแบบ stateful คือ:

  • TextVectorization : มีการจับคู่ระหว่างโทเค็นสตริงและดัชนีจำนวนเต็ม
  • Normalization : ถือค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานของคุณลักษณะ
  • StringLookup และ IntegerLookup : ทำการจับคู่ระหว่างค่าอินพุตและดัชนีเอาต์พุต
  • CategoryEncoding : เก็บดัชนีของค่าอินพุต
  • Discretization : เก็บข้อมูลเกี่ยวกับขอบเขตที่เก็บข้อมูลมูลค่า

ที่สำคัญเลเยอร์เหล่านี้ ไม่สามารถฝึก ได้ สถานะของพวกเขาไม่ได้ถูกกำหนดไว้ในระหว่างการฝึก จะต้องมีการตั้งค่า ก่อนการฝึก ขั้นตอนที่เรียกว่า "การปรับตัว"

คุณตั้งค่าสถานะของเลเยอร์ก่อนการประมวลผลโดยเปิดเผยไปยังข้อมูลการฝึกอบรมโดยใช้วิธี adapt() :

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers.experimental import preprocessing

data = np.array([[0.1, 0.2, 0.3], [0.8, 0.9, 1.0], [1.5, 1.6, 1.7],])
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()))
Features mean: 0.00
Features std: 1.00

วิธีการtf.data.Dataset adapt() ใช้อาร์เรย์ Numpy หรือออบเจ็กต์tf.data.Dataset ในกรณีของ StringLookup และ TextVectorization คุณสามารถส่งผ่านรายการสตริง:

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)

นอกจากนี้เลเยอร์ที่ปรับเปลี่ยนได้จะแสดงตัวเลือกในการตั้งค่าสถานะโดยตรงผ่านอาร์กิวเมนต์ตัวสร้างหรือการกำหนดน้ำหนัก หากทราบค่าสถานะที่ต้องการในเวลาสร้างเลเยอร์หรือคำนวณนอกการเรียก adapt() สามารถตั้งค่าได้โดยไม่ต้องอาศัยการคำนวณภายในของเลเยอร์ ตัวอย่างเช่นหากมีไฟล์คำศัพท์ภายนอกสำหรับ TextVectorization , StringLookup หรือ IntegerLookup อยู่แล้วสามารถโหลดลงในตารางการค้นหาได้โดยตรงโดยส่งเส้นทางไปยังไฟล์คำศัพท์ในอาร์กิวเมนต์ตัวสร้างของเลเยอร์

นี่คือตัวอย่างที่เราสร้างอินสแตนซ์ของเลเยอร์ StringLookup ด้วยคำศัพท์ที่คำนวณไว้ล่วงหน้า:

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)

การประมวลผลข้อมูลก่อนโมเดลหรือภายในโมเดล

มีสองวิธีที่คุณสามารถใช้เลเยอร์ก่อนการประมวลผล:

ตัวเลือกที่ 1: กำหนด ให้เป็นส่วนหนึ่งของโมเดลดังนี้:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = rest_of_the_model(x)
model = keras.Model(inputs, outputs)

ด้วยตัวเลือกนี้การประมวลผลล่วงหน้าจะเกิดขึ้นบนอุปกรณ์พร้อมกันกับส่วนที่เหลือของการเรียกใช้โมเดลซึ่งหมายความว่าจะได้รับประโยชน์จากการเร่งความเร็วของ GPU หากคุณกำลังฝึกอบรม GPU นี่เป็นตัวเลือกที่ดีที่สุดสำหรับเลเยอร์ Normalization และสำหรับเลเยอร์การประมวลผลล่วงหน้าและข้อมูลทั้งหมด

ตัวเลือกที่ 2: นำไปใช้กับtf.data.Dataset ของคุณเพื่อรับชุดข้อมูลที่ให้ชุดข้อมูลที่ประมวลผลล่วงหน้าดังนี้:

dataset = dataset.map(
  lambda x, y: (preprocessing_layer(x), y))

ด้วยตัวเลือกนี้การประมวลผลล่วงหน้าของคุณจะเกิดขึ้นบน CPU แบบอะซิงโครนัสและจะถูกบัฟเฟอร์ก่อนเข้าสู่โมเดล

นี่เป็นตัวเลือกที่ดีที่สุดสำหรับ TextVectorization และข้อมูลที่มีโครงสร้างก่อนการประมวลผลเลเยอร์ทั้งหมด นอกจากนี้ยังสามารถเป็นตัวเลือกที่ดีหากคุณกำลังฝึกอบรมเกี่ยวกับ CPU และคุณใช้เลเยอร์ก่อนการประมวลผลรูปภาพ

ประโยชน์ของการประมวลผลล่วงหน้าภายในโมเดลในเวลาอนุมาน

แม้ว่าคุณจะใช้ตัวเลือก 2 แต่ในภายหลังคุณอาจต้องการส่งออกโมเดล end-to-end แบบอนุมานเท่านั้นซึ่งจะรวมเลเยอร์ก่อนการประมวลผลไว้ด้วย ประโยชน์หลักของการทำเช่นนี้คือ ทำให้โมเดลของคุณพกพาได้ และ ช่วยลดความ เบ้ ใน การฝึก / เสิร์ฟ

เมื่อการประมวลผลข้อมูลทั้งหมดเป็นส่วนหนึ่งของโมเดลผู้อื่นสามารถโหลดและใช้โมเดลของคุณได้โดยไม่ต้องระวังว่าคุณลักษณะแต่ละอย่างจะถูกเข้ารหัสและทำให้เป็นมาตรฐานอย่างไร แบบจำลองการอนุมานของคุณจะสามารถประมวลผลรูปภาพดิบหรือข้อมูลที่มีโครงสร้างดิบได้และไม่ต้องการให้ผู้ใช้โมเดลรับทราบรายละเอียดเช่นโครงร่างโทเค็นที่ใช้สำหรับข้อความรูปแบบการจัดทำดัชนีที่ใช้สำหรับคุณลักษณะเชิงหมวดหมู่ไม่ว่าจะเป็นค่าพิกเซลของรูปภาพ ถูกทำให้เป็นมาตรฐาน [-1, +1] หรือเป็น [0, 1] เป็นต้นซึ่งจะมีประสิทธิภาพมากโดยเฉพาะอย่างยิ่งหากคุณส่งออกโมเดลของคุณไปยังรันไทม์อื่นเช่น TensorFlow.js: คุณจะไม่ต้องนำกระบวนการก่อนดำเนินการอีกครั้ง ไปป์ไลน์ใน JavaScript

หากคุณใส่เลเยอร์ก่อนการประมวลผลไว้ในไปป์ไลน์ tf.data ในขั้นต้นคุณสามารถส่งออกรูปแบบการอนุมานที่บรรจุการประมวลผลล่วงหน้าได้ เพียงสร้างโมเดลใหม่ที่เชื่อมโยงกับเลเยอร์ก่อนการประมวลผลและรูปแบบการฝึกอบรมของคุณ:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = training_model(x)
inference_model = keras.Model(inputs, outputs)

สูตรอาหารด่วน

การเพิ่มข้อมูลรูปภาพ (บนอุปกรณ์)

โปรดทราบว่าเลเยอร์การเพิ่มข้อมูลรูปภาพจะใช้งานได้เฉพาะในระหว่างการฝึกอบรมเท่านั้น (เช่นเดียวกับเลเยอร์ Dropout )

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
)(x)
model = keras.Model(inputs, outputs)

คุณสามารถดูการตั้งค่าที่คล้ายกันในการ จัดประเภทรูปภาพ ตัวอย่าง ตั้งแต่เริ่มต้น

การปรับคุณสมบัติตัวเลขให้เป็นมาตรฐาน

# Load some data
(x_train, y_train), _ = keras.datasets.cifar10.load_data()
x_train = x_train.reshape((len(x_train), -1))
input_shape = x_train.shape[1:]
classes = 10

# Create a Normalization layer and set its internal state using the training data
normalizer = preprocessing.Normalization()
normalizer.adapt(x_train)

# Create a model that include the normalization layer
inputs = keras.Input(shape=input_shape)
x = normalizer(inputs)
outputs = layers.Dense(classes, activation="softmax")(x)
model = keras.Model(inputs, outputs)

# Train the model
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(x_train, y_train)
Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170500096/170498071 [==============================] - 11s 0us/step
1563/1563 [==============================] - 3s 1ms/step - loss: 2.1776
<tensorflow.python.keras.callbacks.History at 0x7f58c5f44208>

การเข้ารหัสคุณลักษณะหมวดหมู่ของสตริงผ่านการเข้ารหัสแบบร้อนเดียว

# Define some toy data
data = tf.constant(["a", "b", "c", "b", "c", "a"])

# Use StringLookup to build an index of the feature values
indexer = preprocessing.StringLookup()
indexer.adapt(data)

# Use CategoryEncoding to encode the integer indices to a one-hot vector
encoder = preprocessing.CategoryEncoding(output_mode="binary")
encoder.adapt(indexer(data))

# Convert new test data (which includes unknown feature values)
test_data = tf.constant(["a", "b", "c", "d", "e", ""])
encoded_data = encoder(indexer(test_data))
print(encoded_data)
tf.Tensor(
[[0. 0. 0. 0. 1.]
 [0. 0. 0. 1. 0.]
 [0. 0. 1. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [1. 0. 0. 0. 0.]], shape=(6, 5), dtype=float32)

โปรดทราบว่าดัชนี 0 สงวนไว้สำหรับค่าที่ขาดหายไป (ซึ่งคุณควรระบุเป็นสตริงว่าง "" ) และดัชนี 1 สงวนไว้สำหรับค่าที่ไม่ตรงตามคำศัพท์ (ค่าที่ไม่เห็นระหว่างการ adapt() ) คุณสามารถกำหนดค่านี้โดยใช้ mask_token และ oov_token คอนสตรัคขัดแย้งของ StringLookup

คุณสามารถดูการทำงานของ StringLookup และ CategoryEncoding ในตัวอย่างการ จัดประเภทข้อมูลที่มีโครงสร้างตั้งแต่เริ่มต้น

การเข้ารหัสคุณลักษณะทางหมวดหมู่จำนวนเต็มผ่านการเข้ารหัสแบบร้อนเดียว

# Define some toy data
data = tf.constant([10, 20, 20, 10, 30, 0])

# Use IntegerLookup to build an index of the feature values
indexer = preprocessing.IntegerLookup()
indexer.adapt(data)

# Use CategoryEncoding to encode the integer indices to a one-hot vector
encoder = preprocessing.CategoryEncoding(output_mode="binary")
encoder.adapt(indexer(data))

# Convert new test data (which includes unknown feature values)
test_data = tf.constant([10, 10, 20, 50, 60, 0])
encoded_data = encoder(indexer(test_data))
print(encoded_data)
tf.Tensor(
[[0. 0. 0. 1. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 1. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [1. 0. 0. 0. 0.]], shape=(6, 5), dtype=float32)

โปรดทราบว่าดัชนี 0 สงวนไว้สำหรับค่าที่ขาดหายไป (ซึ่งคุณควรระบุเป็นค่า 0) และดัชนี 1 สงวนไว้สำหรับค่าที่ไม่ตรงตามคำศัพท์ (ค่าที่ไม่เห็นในระหว่างการ adapt() ) คุณสามารถกำหนดค่านี้โดยใช้ mask_value และ oov_value คอนสตรัคขัดแย้งของ IntegerLookup

คุณสามารถดูการทำงานของ IntegerLookup และ CategoryEncoding ในตัวอย่างการ จัดประเภทข้อมูลที่มีโครงสร้างตั้งแต่เริ่มต้น

การใช้เคล็ดลับการแฮชกับคุณลักษณะหมวดหมู่จำนวนเต็ม

หากคุณมีคุณลักษณะเชิงหมวดหมู่ที่สามารถรับค่าต่างๆได้หลายค่า (ตามลำดับ 10e3 หรือสูงกว่า) โดยที่แต่ละค่าจะปรากฏในข้อมูลเพียงไม่กี่ครั้งก็จะกลายเป็นดัชนีที่ใช้ไม่ได้ผลและไม่มีประสิทธิภาพในการจัดทำดัชนีและเข้ารหัสค่าคุณลักษณะแบบ one-hot เป็นความคิดที่ดีที่จะใช้ "แฮชเคล็ดลับ": แฮชค่ากับเวกเตอร์ที่มีขนาดคงที่ ซึ่งจะช่วยให้ขนาดของพื้นที่ฟีเจอร์สามารถจัดการได้และขจัดความจำเป็นในการจัดทำดัชนีที่ชัดเจน

# Sample data: 10,000 random integers with values between 0 and 100,000
data = np.random.randint(0, 100000, size=(10000, 1))

# Use the Hashing layer to hash the values to the range [0, 64]
hasher = preprocessing.Hashing(num_bins=64, salt=1337)

# Use the CategoryEncoding layer to one-hot encode the hashed values
encoder = preprocessing.CategoryEncoding(max_tokens=64, output_mode="binary")
encoded_data = encoder(hasher(data))
print(encoded_data.shape)
(10000, 64)

การเข้ารหัสข้อความเป็นลำดับของดัชนีโทเค็น

นี่คือวิธีที่คุณควรประมวลผลข้อความล่วงหน้าเพื่อส่งผ่านไปยังเลเยอร์ Embedding

# Define some text data to adapt the layer
data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)
# Instantiate TextVectorization with "int" output_mode
text_vectorizer = preprocessing.TextVectorization(output_mode="int")
# Index the vocabulary via `adapt()`
text_vectorizer.adapt(data)

# You can retrieve the vocabulary we indexed via get_vocabulary()
vocab = text_vectorizer.get_vocabulary()
print("Vocabulary:", vocab)

# Create an Embedding + LSTM model
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
x = layers.Embedding(input_dim=len(vocab), output_dim=64)(x)
outputs = layers.LSTM(1)(x)
model = keras.Model(inputs, outputs)

# Call the model on test data (which includes unknown tokens)
test_data = tf.constant(["The Brain is deeper than the sea"])
test_output = model(test_data)
Vocabulary: ['', '[UNK]', 'the', 'side', 'you', 'with', 'will', 'wider', 'them', 'than', 'sky', 'put', 'other', 'one', 'is', 'for', 'ease', 'contain', 'by', 'brain', 'beside', 'and']

คุณสามารถดูการ TextVectorization เลเยอร์ TextVectorization ร่วมกับโหมด Embedding ในตัวอย่างการ จัดประเภทข้อความตั้งแต่เริ่มต้น

โปรดทราบว่าเมื่อฝึกโมเดลดังกล่าวเพื่อประสิทธิภาพที่ดีที่สุดคุณควรใช้เลเยอร์ TextVectorization เป็นส่วนหนึ่งของไปป์ไลน์อินพุต (ซึ่งเป็นสิ่งที่เราทำในตัวอย่างการจัดประเภทข้อความด้านบน)

การเข้ารหัสข้อความเป็นเมทริกซ์หนาแน่นของ ngrams ด้วยการเข้ารหัสแบบหลายจุด

นี่คือวิธีที่คุณควรประมวลผลข้อความล่วงหน้าเพื่อส่งผ่านไปยังเลเยอร์ Dense

# Define some text data to adapt the layer
data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)
# Instantiate TextVectorization with "binary" output_mode (multi-hot)
# and ngrams=2 (index all bigrams)
text_vectorizer = preprocessing.TextVectorization(output_mode="binary", ngrams=2)
# Index the bigrams via `adapt()`
text_vectorizer.adapt(data)

print(
    "Encoded text:\n",
    text_vectorizer(["The Brain is deeper than the sea"]).numpy(),
    "\n",
)

# Create a Dense model
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
outputs = layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

# Call the model on test data (which includes unknown tokens)
test_data = tf.constant(["The Brain is deeper than the sea"])
test_output = model(test_data)

print("Model output:", test_output)
Encoded text:
 [[1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 0. 0. 0. 0. 0.

  0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 0.]] 

Model output: tf.Tensor([[0.6381588]], shape=(1, 1), dtype=float32)

การเข้ารหัสข้อความเป็นเมทริกซ์หนาแน่นของ ngrams ด้วยการถ่วงน้ำหนัก TF-IDF

นี่เป็นอีกทางเลือกหนึ่งของการประมวลผลข้อความล่วงหน้าก่อนที่จะส่งไปยังเลเยอร์ Dense

# Define some text data to adapt the layer
data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)
# Instantiate TextVectorization with "tf-idf" output_mode
# (multi-hot with TF-IDF weighting) and ngrams=2 (index all bigrams)
text_vectorizer = preprocessing.TextVectorization(output_mode="tf-idf", ngrams=2)
# Index the bigrams and learn the TF-IDF weights via `adapt()`
text_vectorizer.adapt(data)

print(
    "Encoded text:\n",
    text_vectorizer(["The Brain is deeper than the sea"]).numpy(),
    "\n",
)

# Create a Dense model
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
outputs = layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

# Call the model on test data (which includes unknown tokens)
test_data = tf.constant(["The Brain is deeper than the sea"])
test_output = model(test_data)
print("Model output:", test_output)
Encoded text:
 [[8.04719   1.6945957 0.        0.        0.        0.        0.

  0.        0.        0.        0.        0.        0.        0.
  0.        0.        1.0986123 1.0986123 1.0986123 0.        0.
  0.        0.        0.        0.        0.        0.        0.
  1.0986123 0.        0.        0.        0.        0.        0.
  0.        1.0986123 1.0986123 0.        0.        0.       ]] 

Model output: tf.Tensor([[-1.2379041]], shape=(1, 1), dtype=float32)