จำแนกข้อมูลที่มีโครงสร้างโดยใช้เลเยอร์การประมวลผลล่วงหน้าของ Keras

ดูบน TensorFlow.org

ทำงานใน Google Colab

ดูแหล่งที่มาบน GitHub

ดาวน์โหลดโน๊ตบุ๊ค

บทช่วยสอนนี้สาธิตวิธีจัดประเภทข้อมูลที่มีโครงสร้าง เช่น ข้อมูลแบบตาราง โดยใช้ ชุดข้อมูล PetFinder รุ่นที่เรียบง่ายจากการแข่งขัน Kaggle ที่ จัดเก็บไว้ในไฟล์ CSV

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

บทช่วยสอนนี้มีรหัสที่สมบูรณ์สำหรับ:

• กำลังโหลดไฟล์ CSV ลงใน DataFrame โดยใช้ pandas
• การสร้างไปป์ไลน์อินพุตเพื่อแบทช์และสับเปลี่ยนแถวโดยใช้ tf.data (ไป ที่ tf.data: สร้างไพพ์ไลน์อินพุต TensorFlow เพื่อดูรายละเอียดเพิ่มเติม)
• การแมปจากคอลัมน์ในไฟล์ CSV ไปยังคุณลักษณะที่ใช้ในการฝึกโมเดลด้วยเลเยอร์การประมวลผลล่วงหน้าของ Keras
• การสร้าง การฝึกอบรม และการประเมินแบบจำลองโดยใช้วิธีการในตัวของ Keras

ชุดข้อมูลขนาดเล็ก PetFinder.my

มีหลายพันแถวในไฟล์ชุดข้อมูล CSV ของ PetFinder.my mini โดยแต่ละแถวจะอธิบายถึงสัตว์เลี้ยง (สุนัขหรือแมว) และแต่ละคอลัมน์จะอธิบายถึงแอตทริบิวต์ เช่น อายุ สายพันธุ์ สี และอื่นๆ

ในชุดข้อมูลสรุปด้านล่าง สังเกตว่าส่วนใหญ่มีคอลัมน์ตัวเลขและหมวดหมู่ ในบทช่วยสอนนี้ คุณจะจัดการกับคุณลักษณะสองประเภทเท่านั้น โดยปล่อย Description (คุณสมบัติข้อความอิสระ) และ AdoptionSpeed (คุณสมบัติการจัดหมวดหมู่) ระหว่างการประมวลผลข้อมูลล่วงหน้า

นำเข้า TensorFlow และไลบรารีอื่นๆ

import numpy as np
import pandas as pd
import tensorflow as tf

from tensorflow.keras import layers

tf.__version__

'2.8.0-rc1'

โหลดชุดข้อมูลและอ่านลงใน DataFrame แพนด้า

pandas เป็นไลบรารี Python ที่มียูทิลิตี้ที่เป็นประโยชน์มากมายสำหรับการโหลดและทำงานกับข้อมูลที่มีโครงสร้าง ใช้ tf.keras.utils.get_file เพื่อดาวน์โหลดและแตกไฟล์ CSV ด้วยชุดข้อมูลขนาดเล็กของ PetFinder.my และโหลดลงใน DataFrame ด้วย pandas.read_csv :

dataset_url = 'http://storage.googleapis.com/download.tensorflow.org/data/petfinder-mini.zip'
csv_file = 'datasets/petfinder-mini/petfinder-mini.csv'

tf.keras.utils.get_file('petfinder_mini.zip', dataset_url,
                        extract=True, cache_dir='.')
dataframe = pd.read_csv(csv_file)

Downloading data from http://storage.googleapis.com/download.tensorflow.org/data/petfinder-mini.zip
1671168/1668792 [==============================] - 0s 0us/step
1679360/1668792 [==============================] - 0s 0us/step

ตรวจสอบชุดข้อมูลโดยตรวจสอบห้าแถวแรกของ DataFrame:

dataframe.head()

สร้างตัวแปรเป้าหมาย

งานเดิมใน การแข่งขัน PetFinder.my Adoption Prediction ของ Kaggle คือการคาดการณ์ความเร็วที่สัตว์เลี้ยงจะถูกรับเลี้ยง (เช่น ในสัปดาห์แรก เดือนแรก สามเดือนแรก เป็นต้น)

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

หลังจากแก้ไขคอลัมน์ AdoptionSpeed แล้ว 0 จะระบุว่าสัตว์เลี้ยงไม่ได้ถูกรับเลี้ยง และ 1 จะระบุว่าเป็นสัตว์เลี้ยง

# In the original dataset, `'AdoptionSpeed'` of `4` indicates
# a pet was not adopted.
dataframe['target'] = np.where(dataframe['AdoptionSpeed']==4, 0, 1)

# Drop unused features.
dataframe = dataframe.drop(columns=['AdoptionSpeed', 'Description'])

แบ่ง DataFrame ออกเป็นชุดการฝึก การตรวจสอบ และชุดทดสอบ

ชุดข้อมูลอยู่ใน DataFrame แพนด้าตัวเดียว แบ่งออกเป็นชุดการฝึก การตรวจสอบ และการทดสอบโดยใช้อัตราส่วน 80:10:10 ตามลำดับ:

train, val, test = np.split(dataframe.sample(frac=1), [int(0.8*len(dataframe)), int(0.9*len(dataframe))])

print(len(train), 'training examples')
print(len(val), 'validation examples')
print(len(test), 'test examples')

9229 training examples
1154 validation examples
1154 test examples

สร้างไพพ์ไลน์อินพุตโดยใช้ tf.data

ถัดไป สร้างฟังก์ชันยูทิลิตี้ที่แปลงชุดการฝึก การตรวจสอบ และการทดสอบแต่ละชุด DataFrame เป็น tf.data.Dataset จากนั้นสับเปลี่ยนและแบทช์ข้อมูล

def df_to_dataset(dataframe, shuffle=True, batch_size=32):
  df = dataframe.copy()
  labels = df.pop('target')
  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}
  ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(dataframe))
  ds = ds.batch(batch_size)
  ds = ds.prefetch(batch_size)
  return ds

ตอนนี้ ใช้ฟังก์ชันที่สร้างขึ้นใหม่ ( df_to_dataset ) เพื่อตรวจสอบรูปแบบของข้อมูลที่ฟังก์ชันตัวช่วยไปป์ไลน์อินพุตส่งคืนโดยเรียกใช้ในข้อมูลการฝึกอบรม และใช้ขนาดแบทช์ขนาดเล็กเพื่อให้เอาต์พุตสามารถอ่านได้:

batch_size = 5
train_ds = df_to_dataset(train, batch_size=batch_size)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.
  after removing the cwd from sys.path.

[(train_features, label_batch)] = train_ds.take(1)
print('Every feature:', list(train_features.keys()))
print('A batch of ages:', train_features['Age'])
print('A batch of targets:', label_batch )

Every feature: ['Type', 'Age', 'Breed1', 'Gender', 'Color1', 'Color2', 'MaturitySize', 'FurLength', 'Vaccinated', 'Sterilized', 'Health', 'Fee', 'PhotoAmt', 'target']
A batch of ages: tf.Tensor(
[[84]
 [ 1]
 [ 5]
 [ 1]
 [12]], shape=(5, 1), dtype=int64)
A batch of targets: tf.Tensor([1 1 0 1 0], shape=(5,), dtype=int64)

จากผลลัพธ์ที่ได้แสดงให้เห็น ชุดการฝึกจะส่งกลับพจนานุกรมของชื่อคอลัมน์ (จาก DataFrame) ที่จับคู่กับค่าของคอลัมน์จากแถว

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

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

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

• tf.keras.layers.Normalization : ดำเนินการทำให้เป็นมาตรฐานที่ชาญฉลาดของคุณลักษณะอินพุต
• tf.keras.layers.CategoryEncoding : เปลี่ยนคุณสมบัติการจัดหมวดหมู่จำนวนเต็มเป็นการแสดงความหนาแน่นแบบ one-hot, multi-hot หรือ tf-idf
• tf.keras.layers.StringLookup : เปลี่ยนค่าหมวดหมู่สตริงเป็นดัชนีจำนวนเต็ม
• tf.keras.layers.IntegerLookup : เปลี่ยนค่าตามหมวดหมู่จำนวนเต็มเป็นดัชนีจำนวนเต็ม

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับเลเยอร์ที่มีอยู่ในคู่มือ การทำงานกับเลเยอร์ก่อนการประมวลผล

• สำหรับ คุณสมบัติเชิงตัวเลข ของชุดข้อมูลขนาดเล็กของ PetFinder.my คุณจะใช้เลเยอร์ tf.keras.layers.Normalization เพื่อสร้างมาตรฐานการกระจายข้อมูล
• สำหรับ คุณสมบัติตามหมวดหมู่ เช่น pet Type s ( Dog and Cat ) คุณจะแปลงเป็นเทนเซอร์ที่เข้ารหัสแบบ multi-hot ด้วย tf.keras.layers.CategoryEncoding

คอลัมน์ตัวเลข

สำหรับคุณลักษณะตัวเลขแต่ละรายการในชุดข้อมูลขนาดเล็กของ PetFinder.my คุณจะใช้เลเยอร์ tf.keras.layers.Normalization เพื่อสร้างมาตรฐานการกระจายข้อมูล

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

def get_normalization_layer(name, dataset):
  # Create a Normalization layer for the feature.
  normalizer = layers.Normalization(axis=None)

  # Prepare a Dataset that only yields the feature.
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the statistics of the data.
  normalizer.adapt(feature_ds)

  return normalizer

ต่อไป ทดสอบฟังก์ชั่นใหม่โดยเรียกใช้บนคุณสมบัติภาพถ่ายสัตว์เลี้ยงที่อัพโหลดทั้งหมดเพื่อทำให้ 'PhotoAmt' เป็นปกติ:

photo_count_col = train_features['PhotoAmt']
layer = get_normalization_layer('PhotoAmt', train_ds)
layer(photo_count_col)

<tf.Tensor: shape=(5, 1), dtype=float32, numpy=
array([[-0.8272058 ],
       [-0.19125296],
       [ 1.3986291 ],
       [-0.19125296],
       [-0.50922936]], dtype=float32)>

คอลัมน์หมวดหมู่

Pet Type s ในชุดข้อมูลจะแสดงเป็น string — Dog s and Cat s— ซึ่งจำเป็นต้องเข้ารหัส multi-hot ก่อนจึงจะป้อนเข้าสู่โมเดล คุณสมบัติ Age

กำหนดฟังก์ชันยูทิลิตี้ใหม่อื่นที่ส่งคืนเลเยอร์ซึ่งจับคู่ค่าจากคำศัพท์เป็นดัชนีจำนวนเต็มและ multi-hot เข้ารหัสคุณสมบัติโดยใช้ tf.keras.layers.StringLookup , tf.keras.layers.IntegerLookup และ tf.keras.CategoryEncoding ก่อนการประมวลผล ชั้น:

def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
  # Create a layer that turns strings into integer indices.
  if dtype == 'string':
    index = layers.StringLookup(max_tokens=max_tokens)
  # Otherwise, create a layer that turns integer values into integer indices.
  else:
    index = layers.IntegerLookup(max_tokens=max_tokens)

  # Prepare a `tf.data.Dataset` that only yields the feature.
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the set of possible values and assign them a fixed integer index.
  index.adapt(feature_ds)

  # Encode the integer indices.
  encoder = layers.CategoryEncoding(num_tokens=index.vocabulary_size())

  # Apply multi-hot encoding to the indices. The lambda function captures the
  # layer, so you can use them, or include them in the Keras Functional model later.
  return lambda feature: encoder(index(feature))

ทดสอบฟังก์ชัน get_category_encoding_layer โดยเรียกใช้ฟีเจอร์ 'Type' สัตว์เลี้ยงเพื่อเปลี่ยนให้เป็นเมตริกซ์ที่เข้ารหัสแบบ multi-hot:

test_type_col = train_features['Type']
test_type_layer = get_category_encoding_layer(name='Type',
                                              dataset=train_ds,
                                              dtype='string')
test_type_layer(test_type_col)

<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.]], dtype=float32)>

ทำซ้ำขั้นตอนในคุณสมบัติ 'Age' สัตว์เลี้ยง:

test_age_col = train_features['Age']
test_age_layer = get_category_encoding_layer(name='Age',
                                             dataset=train_ds,
                                             dtype='int64',
                                             max_tokens=5)
test_age_layer(test_age_col)

<tf.Tensor: shape=(5, 5), dtype=float32, numpy=
array([[1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.]], dtype=float32)>

ประมวลผลคุณสมบัติที่เลือกไว้ล่วงหน้าเพื่อฝึกโมเดลบน

คุณได้เรียนรู้วิธีใช้เลเยอร์การประมวลผลล่วงหน้าของ Keras หลายประเภทแล้ว ถัดไป คุณจะ:

• ใช้ฟังก์ชันยูทิลิตี้การประมวลผลล่วงหน้าที่กำหนดไว้ก่อนหน้านี้ในคุณสมบัติเชิงตัวเลขและหมวดหมู่ 13 รายการจากชุดข้อมูลขนาดเล็กของ PetFinder.my
• เพิ่มอินพุตคุณสมบัติทั้งหมดลงในรายการ

ตามที่กล่าวไว้ในตอนต้น ในการฝึกโมเดล คุณจะต้องใช้ตัวเลขของ PetFinder.my mini dataset ( 'PhotoAmt' , 'Fee' ) และการจัดหมวดหมู่ ( 'Age' , 'Type' , 'Color1' , 'Color2' , 'Gender' 'MaturitySize' 'FurLength' 'Vaccinated' 'Sterilized' 'Health' 'Breed1' )

ก่อนหน้านี้ คุณใช้ขนาดแบทช์ขนาดเล็กเพื่อสาธิตไปป์ไลน์อินพุต มาสร้างไพพ์ไลน์อินพุตใหม่ที่มีขนาดแบทช์ที่ใหญ่กว่า 256:

batch_size = 256
train_ds = df_to_dataset(train, batch_size=batch_size)
val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)
test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.
  after removing the cwd from sys.path.

ทำให้คุณสมบัติตัวเลขเป็นปกติ (จำนวนภาพถ่ายสัตว์เลี้ยงและค่าธรรมเนียมการรับเลี้ยงบุตรบุญธรรม) และเพิ่มลงในรายการอินพุตที่เรียกว่า encoded_features :

all_inputs = []
encoded_features = []

# Numerical features.
for header in ['PhotoAmt', 'Fee']:
  numeric_col = tf.keras.Input(shape=(1,), name=header)
  normalization_layer = get_normalization_layer(header, train_ds)
  encoded_numeric_col = normalization_layer(numeric_col)
  all_inputs.append(numeric_col)
  encoded_features.append(encoded_numeric_col)

เปลี่ยนค่าหมวดหมู่จำนวนเต็มจากชุดข้อมูล (อายุสัตว์เลี้ยง) เป็นดัชนีจำนวนเต็ม ทำการเข้ารหัสแบบหลายจุด และเพิ่มอินพุตคุณสมบัติที่เป็นผลลัพธ์ให้กับ encoded_features :

age_col = tf.keras.Input(shape=(1,), name='Age', dtype='int64')

encoding_layer = get_category_encoding_layer(name='Age',
                                             dataset=train_ds,
                                             dtype='int64',
                                             max_tokens=5)
encoded_age_col = encoding_layer(age_col)
all_inputs.append(age_col)
encoded_features.append(encoded_age_col)

ทำซ้ำขั้นตอนเดียวกันสำหรับค่าหมวดหมู่สตริง:

categorical_cols = ['Type', 'Color1', 'Color2', 'Gender', 'MaturitySize',
                    'FurLength', 'Vaccinated', 'Sterilized', 'Health', 'Breed1']

for header in categorical_cols:
  categorical_col = tf.keras.Input(shape=(1,), name=header, dtype='string')
  encoding_layer = get_category_encoding_layer(name=header,
                                               dataset=train_ds,
                                               dtype='string',
                                               max_tokens=5)
  encoded_categorical_col = encoding_layer(categorical_col)
  all_inputs.append(categorical_col)
  encoded_features.append(encoded_categorical_col)

สร้าง รวบรวม และฝึกโมเดล

ขั้นตอนต่อไปคือการสร้างโมเดลโดยใช้ Keras Functional API สำหรับเลเยอร์แรกในโมเดลของคุณ ให้รวมรายการอินพุตของฟีเจอร์— encoded_features — เป็นเวกเตอร์เดียวผ่านการต่อ tf.keras.layers.concatenate encoded_features

all_features = tf.keras.layers.concatenate(encoded_features)
x = tf.keras.layers.Dense(32, activation="relu")(all_features)
x = tf.keras.layers.Dropout(0.5)(x)
output = tf.keras.layers.Dense(1)(x)

model = tf.keras.Model(all_inputs, output)

กำหนดค่าโมเดลด้วย Keras Model.compile :

model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=["accuracy"])

มาดูกราฟการเชื่อมต่อกัน:

# Use `rankdir='LR'` to make the graph horizontal.
tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")

ต่อไป ฝึกและทดสอบโมเดล:

model.fit(train_ds, epochs=10, validation_data=val_ds)

Epoch 1/10
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/engine/functional.py:559: UserWarning: Input dict contained keys ['target'] which did not match any model input. They will be ignored by the model.
  inputs = self._flatten_to_reference_inputs(inputs)
37/37 [==============================] - 2s 19ms/step - loss: 0.6524 - accuracy: 0.5034 - val_loss: 0.5887 - val_accuracy: 0.6941
Epoch 2/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5906 - accuracy: 0.6648 - val_loss: 0.5627 - val_accuracy: 0.7218
Epoch 3/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5697 - accuracy: 0.6924 - val_loss: 0.5463 - val_accuracy: 0.7504
Epoch 4/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5558 - accuracy: 0.6978 - val_loss: 0.5346 - val_accuracy: 0.7504
Epoch 5/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5502 - accuracy: 0.7105 - val_loss: 0.5272 - val_accuracy: 0.7487
Epoch 6/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5415 - accuracy: 0.7123 - val_loss: 0.5210 - val_accuracy: 0.7608
Epoch 7/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5354 - accuracy: 0.7171 - val_loss: 0.5152 - val_accuracy: 0.7435
Epoch 8/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5301 - accuracy: 0.7214 - val_loss: 0.5113 - val_accuracy: 0.7513
Epoch 9/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5286 - accuracy: 0.7189 - val_loss: 0.5087 - val_accuracy: 0.7574
Epoch 10/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5252 - accuracy: 0.7260 - val_loss: 0.5058 - val_accuracy: 0.7539
<keras.callbacks.History at 0x7f5f9fa91c50>

loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)

5/5 [==============================] - 0s 6ms/step - loss: 0.5012 - accuracy: 0.7626
Accuracy 0.762565016746521

ทำการอนุมาน

โมเดลที่คุณพัฒนาสามารถจัดประเภทแถวจากไฟล์ CSV ได้โดยตรงหลังจากที่คุณได้รวมเลเยอร์การประมวลผลล่วงหน้าไว้ในตัวโมเดลแล้ว

ตอนนี้คุณสามารถ บันทึกและโหลดโมเดล Keras ใหม่ ด้วย Model.save และ Model.load_model ก่อนทำการอนุมานข้อมูลใหม่:

model.save('my_pet_classifier')
reloaded_model = tf.keras.models.load_model('my_pet_classifier')

2022-01-26 06:20:08.013613: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
WARNING:absl:Function `_wrapped_model` contains input name(s) PhotoAmt, Fee, Age, Type, Color1, Color2, Gender, MaturitySize, FurLength, Vaccinated, Sterilized, Health, Breed1 with unsupported characters which will be renamed to photoamt, fee, age, type, color1, color2, gender, maturitysize, furlength, vaccinated, sterilized, health, breed1 in the SavedModel.
INFO:tensorflow:Assets written to: my_pet_classifier/assets
INFO:tensorflow:Assets written to: my_pet_classifier/assets

ในการรับการทำนายสำหรับตัวอย่างใหม่ คุณสามารถเรียกเมธอด Model.predict มีเพียงสองสิ่งที่คุณต้องทำ:

1. รวมสเกลาร์ลงในรายการเพื่อให้มีมิติแบตช์ ( Model จะประมวลผลเฉพาะแบทช์ของข้อมูล ไม่ใช่ตัวอย่างเดียว)
2. โทร tf.convert_to_tensor ในแต่ละคุณสมบัติ

sample = {
    'Type': 'Cat',
    'Age': 3,
    'Breed1': 'Tabby',
    'Gender': 'Male',
    'Color1': 'Black',
    'Color2': 'White',
    'MaturitySize': 'Small',
    'FurLength': 'Short',
    'Vaccinated': 'No',
    'Sterilized': 'No',
    'Health': 'Healthy',
    'Fee': 100,
    'PhotoAmt': 2,
}

input_dict = {name: tf.convert_to_tensor([value]) for name, value in sample.items()}
predictions = reloaded_model.predict(input_dict)
prob = tf.nn.sigmoid(predictions[0])

print(
    "This particular pet had a %.1f percent probability "
    "of getting adopted." % (100 * prob)
)

This particular pet had a 77.7 percent probability of getting adopted.

ขั้นตอนถัดไป

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

ด้านล่างนี้คือคำแนะนำบางส่วนสำหรับชุดข้อมูล:

• ชุดข้อมูล TensorFlow: MovieLens : ชุดการให้คะแนนภาพยนตร์จากบริการแนะนำภาพยนตร์
• ชุดข้อมูล TensorFlow: คุณภาพไวน์ : ชุดข้อมูลสองชุดที่เกี่ยวข้องกับสายพันธุ์สีแดงและสีขาวของไวน์ "Vinho Verde" ของโปรตุเกส คุณยังค้นหาชุดข้อมูลคุณภาพไวน์แดงได้ที่ Kaggle
• Kaggle: arXiv ชุดข้อมูล : คลังบทความทางวิชาการ 1.7 ล้านบทความจาก arXiv ซึ่งครอบคลุมฟิสิกส์ วิทยาการคอมพิวเตอร์ คณิตศาสตร์ สถิติ วิศวกรรมไฟฟ้า ชีววิทยาเชิงปริมาณ และเศรษฐศาสตร์