ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

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

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดโน๊ตบุ๊ค

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

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

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

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

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

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

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

คอลัมน์ คำอธิบายสัตว์เลี้ยง ประเภทคุณสมบัติ ประเภทข้อมูล
Type ประเภทสัตว์ ( Dog , Cat ) หมวดหมู่ สตริง
Age อายุ ตัวเลข จำนวนเต็ม
Breed1 สายพันธุ์หลัก หมวดหมู่ สตริง
Color1 สี 1 หมวดหมู่ สตริง
Color2 สี2 หมวดหมู่ สตริง
MaturitySize ขนาดเมื่อครบกำหนด หมวดหมู่ สตริง
FurLength ความยาวขน หมวดหมู่ สตริง
Vaccinated สัตว์เลี้ยงได้รับการฉีดวัคซีน หมวดหมู่ สตริง
Sterilized สัตว์เลี้ยงได้รับการฆ่าเชื้อ หมวดหมู่ สตริง
Health เงื่อนไขสุขภาพ หมวดหมู่ สตริง
Fee ค่าธรรมเนียมการรับเลี้ยงบุตรบุญธรรม ตัวเลข จำนวนเต็ม
Description การเขียนโปรไฟล์ ข้อความ สตริง
PhotoAmt รูปภาพที่อัปโหลดทั้งหมด ตัวเลข จำนวนเต็ม
AdoptionSpeed ความเร็วในการรับเลี้ยงบุตรบุญธรรม การจัดหมวดหมู่ จำนวนเต็ม

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

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

from tensorflow.keras import layers
tf.__version__
'2.7.0'

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

หมีแพนด้า เป็นห้องสมุดหลามกับสาธารณูปโภคที่เป็นประโยชน์มากมายสำหรับการโหลดและการทำงานกับข้อมูลที่มีโครงสร้าง ใช้ 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()

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

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

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

หลังจากการปรับเปลี่ยน 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(
[[ 4]
 [ 1]
 [15]
 [ 3]
 [ 1]], shape=(5, 1), dtype=int64)
A batch of targets: tf.Tensor([0 1 1 0 1], shape=(5,), dtype=int64)

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

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

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

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

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

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

  • สำหรับคุณสมบัติเชิงตัวเลขของชุดข้อมูล PetFinder.my มินิ, คุณจะใช้ tf.keras.layers.Normalization ชั้นที่จะสร้างมาตรฐานการกระจายของข้อมูล
  • สำหรับคุณสมบัติเด็ดขาดเช่นสัตว์เลี้ยง Type s ( Dog และ Cat สตริง) คุณจะเปลี่ยนพวกเขาจะเทนเซอร์เข้ารหัสหลายร้อนกับ 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.8390221 ],
       [ 2.3774517 ],
       [ 0.12592004],
       [-0.5173747 ],
       [-0.19572733]], dtype=float32)>

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

สัตว์เลี้ยง Type ในชุดข้อมูลที่จะแสดงเป็น strings- Dog และ Cat s ซึ่งจะต้องมีหลายร้อนเข้ารหัสก่อนที่จะถูกป้อนเข้ารูปแบบ Age คุณลักษณะ

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

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' ให้บริการเพื่อเปิดให้เป็นเทนเซอร์เข้ารหัสหลายร้อน:

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., 0., 1.],
       [0., 1., 0.],
       [0., 0., 1.],
       [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([[0., 0., 0., 0., 1.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.]], dtype=float32)>

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

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

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

เป็นที่กล่าวถึงในการเริ่มต้นในการฝึกอบรมรูปแบบที่คุณจะใช้ตัวเลขชุด PetFinder.my มินิ ( '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 หน้าที่ API สำหรับชั้นแรกในรูปแบบของคุณผสานรายการคุณลักษณะ inputs- encoded_features -into หนึ่งเวกเตอร์ผ่านการเรียงต่อกันกับ tf.keras.layers.concatenate

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")

png

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

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 18ms/step - loss: 0.6231 - accuracy: 0.5496 - val_loss: 0.5638 - val_accuracy: 0.7409
Epoch 2/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5758 - accuracy: 0.6770 - val_loss: 0.5473 - val_accuracy: 0.7400
Epoch 3/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5544 - accuracy: 0.7043 - val_loss: 0.5377 - val_accuracy: 0.7383
Epoch 4/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5482 - accuracy: 0.7098 - val_loss: 0.5309 - val_accuracy: 0.7348
Epoch 5/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5424 - accuracy: 0.7100 - val_loss: 0.5268 - val_accuracy: 0.7253
Epoch 6/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5336 - accuracy: 0.7130 - val_loss: 0.5221 - val_accuracy: 0.7331
Epoch 7/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5289 - accuracy: 0.7258 - val_loss: 0.5189 - val_accuracy: 0.7357
Epoch 8/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5280 - accuracy: 0.7146 - val_loss: 0.5165 - val_accuracy: 0.7374
Epoch 9/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5221 - accuracy: 0.7264 - val_loss: 0.5142 - val_accuracy: 0.7331
Epoch 10/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5200 - accuracy: 0.7235 - val_loss: 0.5128 - val_accuracy: 0.7357
<keras.callbacks.History at 0x7f1667fe7790>
loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)
5/5 [==============================] - 0s 6ms/step - loss: 0.5032 - accuracy: 0.7513
Accuracy 0.7512997984886169

ทำการอนุมาน

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

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

model.save('my_pet_classifier')
reloaded_model = tf.keras.models.load_model('my_pet_classifier')
2021-11-06 01:29:25.921254: 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

ที่จะได้รับการคาดการณ์สำหรับตัวอย่างใหม่คุณก็สามารถเรียก Keras 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 74.4 percent probability of getting adopted.

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

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

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

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