แนะนำตัวเข้ารหัสอัตโนมัติ

ดูบน TensorFlow.org

ทำงานใน Google Colab

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

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

บทช่วยสอนนี้จะแนะนำตัวเข้ารหัสอัตโนมัติพร้อมตัวอย่างสามตัวอย่าง: พื้นฐาน การลบภาพ และการตรวจจับความผิดปกติ

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับตัวเข้ารหัสอัตโนมัติ โปรดลองอ่านบทที่ 14 จาก Deep Learning โดย Ian Goodfellow, Yoshua Bengio และ Aaron Courville

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

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf

from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.model_selection import train_test_split
from tensorflow.keras import layers, losses
from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras.models import Model

โหลดชุดข้อมูล

ในการเริ่มต้น คุณจะต้องฝึกตัวเข้ารหัสอัตโนมัติพื้นฐานโดยใช้ชุดข้อมูล Fashion MNIST รูปภาพแต่ละรูปในชุดข้อมูลนี้มีขนาด 28x28 พิกเซล

(x_train, _), (x_test, _) = fashion_mnist.load_data()

x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.

print (x_train.shape)
print (x_test.shape)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
40960/29515 [=========================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
26435584/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
16384/5148 [===============================================================================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step
4431872/4422102 [==============================] - 0s 0us/step
(60000, 28, 28)
(10000, 28, 28)

ตัวอย่างแรก: โปรแกรมเข้ารหัสอัตโนมัติขั้นพื้นฐาน

กำหนดตัวเข้ารหัสอัตโนมัติด้วยเลเยอร์หนาแน่นสองชั้น: encoder ซึ่งบีบอัดภาพให้เป็นเวกเตอร์แฝง 64 มิติ และ decoder ที่สร้างภาพต้นฉบับขึ้นใหม่จากพื้นที่แฝง

ในการกำหนดโมเดลของคุณ ให้ใช้ Keras Model Subclassing API

latent_dim = 64 

class Autoencoder(Model):
  def __init__(self, latent_dim):
    super(Autoencoder, self).__init__()
    self.latent_dim = latent_dim   
    self.encoder = tf.keras.Sequential([
      layers.Flatten(),
      layers.Dense(latent_dim, activation='relu'),
    ])
    self.decoder = tf.keras.Sequential([
      layers.Dense(784, activation='sigmoid'),
      layers.Reshape((28, 28))
    ])

  def call(self, x):
    encoded = self.encoder(x)
    decoded = self.decoder(encoded)
    return decoded

autoencoder = Autoencoder(latent_dim)

autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())

ฝึกโมเดลโดยใช้ x_train เป็นทั้งอินพุตและเป้าหมาย โปรแกรมเปลี่ยน encoder จะเรียนรู้วิธีบีบอัดชุดข้อมูลจาก 784 มิติไปยังพื้นที่แฝง และ decoder จะเรียนรู้การสร้างภาพต้นฉบับขึ้นใหม่ .

autoencoder.fit(x_train, x_train,
                epochs=10,
                shuffle=True,
                validation_data=(x_test, x_test))

Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0243 - val_loss: 0.0140
Epoch 2/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0116 - val_loss: 0.0106
Epoch 3/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0100 - val_loss: 0.0098
Epoch 4/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0094 - val_loss: 0.0094
Epoch 5/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0092 - val_loss: 0.0092
Epoch 6/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0090 - val_loss: 0.0091
Epoch 7/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0090 - val_loss: 0.0090
Epoch 8/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0089 - val_loss: 0.0090
Epoch 9/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0088 - val_loss: 0.0089
Epoch 10/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0088 - val_loss: 0.0089
<keras.callbacks.History at 0x7ff1d35df550>

เมื่อโมเดลได้รับการฝึกอบรมแล้ว เรามาทดสอบโดยการเข้ารหัสและถอดรหัสรูปภาพจากชุดทดสอบ

encoded_imgs = autoencoder.encoder(x_test).numpy()
decoded_imgs = autoencoder.decoder(encoded_imgs).numpy()

n = 10
plt.figure(figsize=(20, 4))
for i in range(n):
  # display original
  ax = plt.subplot(2, n, i + 1)
  plt.imshow(x_test[i])
  plt.title("original")
  plt.gray()
  ax.get_xaxis().set_visible(False)
  ax.get_yaxis().set_visible(False)

  # display reconstruction
  ax = plt.subplot(2, n, i + 1 + n)
  plt.imshow(decoded_imgs[i])
  plt.title("reconstructed")
  plt.gray()
  ax.get_xaxis().set_visible(False)
  ax.get_yaxis().set_visible(False)
plt.show()

ตัวอย่างที่สอง: Image denoising

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

มานำเข้าชุดข้อมูลอีกครั้งเพื่อละเว้นการแก้ไขที่ทำไว้ก่อนหน้านี้

(x_train, _), (x_test, _) = fashion_mnist.load_data()

x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.

x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]

print(x_train.shape)

(60000, 28, 28, 1)

การเพิ่มนอยส์แบบสุ่มให้กับภาพ

noise_factor = 0.2
x_train_noisy = x_train + noise_factor * tf.random.normal(shape=x_train.shape) 
x_test_noisy = x_test + noise_factor * tf.random.normal(shape=x_test.shape) 

x_train_noisy = tf.clip_by_value(x_train_noisy, clip_value_min=0., clip_value_max=1.)
x_test_noisy = tf.clip_by_value(x_test_noisy, clip_value_min=0., clip_value_max=1.)

พล็อตภาพที่มีเสียงดัง

n = 10
plt.figure(figsize=(20, 2))
for i in range(n):
    ax = plt.subplot(1, n, i + 1)
    plt.title("original + noise")
    plt.imshow(tf.squeeze(x_test_noisy[i]))
    plt.gray()
plt.show()

กำหนดตัวเข้ารหัสอัตโนมัติแบบ Convolutional

ในตัวอย่างนี้ คุณจะฝึกตัวเข้ารหัสอัตโนมัติแบบ Convolutional โดยใช้เลเยอร์ Conv2D ใน encoder และเลเยอร์ Conv2DTranspose ใน decoder

class Denoise(Model):
  def __init__(self):
    super(Denoise, self).__init__()
    self.encoder = tf.keras.Sequential([
      layers.Input(shape=(28, 28, 1)),
      layers.Conv2D(16, (3, 3), activation='relu', padding='same', strides=2),
      layers.Conv2D(8, (3, 3), activation='relu', padding='same', strides=2)])

    self.decoder = tf.keras.Sequential([
      layers.Conv2DTranspose(8, kernel_size=3, strides=2, activation='relu', padding='same'),
      layers.Conv2DTranspose(16, kernel_size=3, strides=2, activation='relu', padding='same'),
      layers.Conv2D(1, kernel_size=(3, 3), activation='sigmoid', padding='same')])

  def call(self, x):
    encoded = self.encoder(x)
    decoded = self.decoder(encoded)
    return decoded

autoencoder = Denoise()

autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())

autoencoder.fit(x_train_noisy, x_train,
                epochs=10,
                shuffle=True,
                validation_data=(x_test_noisy, x_test))

Epoch 1/10
1875/1875 [==============================] - 8s 3ms/step - loss: 0.0169 - val_loss: 0.0107
Epoch 2/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0095 - val_loss: 0.0086
Epoch 3/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0082 - val_loss: 0.0080
Epoch 4/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0078 - val_loss: 0.0077
Epoch 5/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0076 - val_loss: 0.0075
Epoch 6/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0074 - val_loss: 0.0074
Epoch 7/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0073 - val_loss: 0.0073
Epoch 8/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0072 - val_loss: 0.0072
Epoch 9/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0071 - val_loss: 0.0071
Epoch 10/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0070 - val_loss: 0.0071
<keras.callbacks.History at 0x7ff1c45a31d0>

มาดูบทสรุปของตัวเข้ารหัสกัน สังเกตว่ารูปภาพถูกลดขนาดตัวอย่างจาก 28x28 เป็น 7x7 อย่างไร

autoencoder.encoder.summary()

Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 14, 14, 16)        160       
                                                                 
 conv2d_1 (Conv2D)           (None, 7, 7, 8)           1160      
                                                                 
=================================================================
Total params: 1,320
Trainable params: 1,320
Non-trainable params: 0
_________________________________________________________________

ตัวถอดรหัสจะสุ่มตัวอย่างรูปภาพกลับจาก 7x7 เป็น 28x28

autoencoder.decoder.summary()

Model: "sequential_3"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_transpose (Conv2DTra  (None, 14, 14, 8)        584       
 nspose)                                                         
                                                                 
 conv2d_transpose_1 (Conv2DT  (None, 28, 28, 16)       1168      
 ranspose)                                                       
                                                                 
 conv2d_2 (Conv2D)           (None, 28, 28, 1)         145       
                                                                 
=================================================================
Total params: 1,897
Trainable params: 1,897
Non-trainable params: 0
_________________________________________________________________

การพล็อตทั้งภาพที่มีสัญญาณรบกวนและภาพที่ถูกตัดออกจากตัวเข้ารหัสอัตโนมัติ

encoded_imgs = autoencoder.encoder(x_test).numpy()
decoded_imgs = autoencoder.decoder(encoded_imgs).numpy()

n = 10
plt.figure(figsize=(20, 4))
for i in range(n):

    # display original + noise
    ax = plt.subplot(2, n, i + 1)
    plt.title("original + noise")
    plt.imshow(tf.squeeze(x_test_noisy[i]))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    # display reconstruction
    bx = plt.subplot(2, n, i + n + 1)
    plt.title("reconstructed")
    plt.imshow(tf.squeeze(decoded_imgs[i]))
    plt.gray()
    bx.get_xaxis().set_visible(False)
    bx.get_yaxis().set_visible(False)
plt.show()

ตัวอย่างที่สาม: การตรวจจับความผิดปกติ

ภาพรวม

ในตัวอย่างนี้ คุณจะฝึกตัวเข้ารหัสอัตโนมัติเพื่อตรวจหาความผิดปกติใน ชุดข้อมูล ECG5000 ชุดข้อมูลนี้มีการตรวจ คลื่นไฟฟ้าหัวใจ 5,000 ครั้ง โดยแต่ละรายการมีจุดข้อมูล 140 จุด คุณจะใช้ชุดข้อมูลเวอร์ชันที่เรียบง่าย โดยที่แต่ละตัวอย่างจะมีป้ายกำกับว่า 0 (ซึ่งสัมพันธ์กับจังหวะที่ผิดปกติ) หรือ 1 (ซึ่งสัมพันธ์กับจังหวะปกติ) คุณสนใจที่จะระบุจังหวะที่ผิดปกติ

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

โหลดข้อมูล ECG

ชุดข้อมูลที่คุณจะใช้อ้างอิงจาก timeseriesclassification.com

# Download the dataset
dataframe = pd.read_csv('http://storage.googleapis.com/download.tensorflow.org/data/ecg.csv', header=None)
raw_data = dataframe.values
dataframe.head()

# The last element contains the labels
labels = raw_data[:, -1]

# The other data points are the electrocadriogram data
data = raw_data[:, 0:-1]

train_data, test_data, train_labels, test_labels = train_test_split(
    data, labels, test_size=0.2, random_state=21
)

ทำให้ข้อมูลเป็นปกติเป็น [0,1]

min_val = tf.reduce_min(train_data)
max_val = tf.reduce_max(train_data)

train_data = (train_data - min_val) / (max_val - min_val)
test_data = (test_data - min_val) / (max_val - min_val)

train_data = tf.cast(train_data, tf.float32)
test_data = tf.cast(test_data, tf.float32)

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

train_labels = train_labels.astype(bool)
test_labels = test_labels.astype(bool)

normal_train_data = train_data[train_labels]
normal_test_data = test_data[test_labels]

anomalous_train_data = train_data[~train_labels]
anomalous_test_data = test_data[~test_labels]

พล็อต ECG ปกติ

plt.grid()
plt.plot(np.arange(140), normal_train_data[0])
plt.title("A Normal ECG")
plt.show()

พล็อต ECG ผิดปกติ

plt.grid()
plt.plot(np.arange(140), anomalous_train_data[0])
plt.title("An Anomalous ECG")
plt.show()

สร้างแบบจำลอง

class AnomalyDetector(Model):
  def __init__(self):
    super(AnomalyDetector, self).__init__()
    self.encoder = tf.keras.Sequential([
      layers.Dense(32, activation="relu"),
      layers.Dense(16, activation="relu"),
      layers.Dense(8, activation="relu")])

    self.decoder = tf.keras.Sequential([
      layers.Dense(16, activation="relu"),
      layers.Dense(32, activation="relu"),
      layers.Dense(140, activation="sigmoid")])

  def call(self, x):
    encoded = self.encoder(x)
    decoded = self.decoder(encoded)
    return decoded

autoencoder = AnomalyDetector()

autoencoder.compile(optimizer='adam', loss='mae')

ขอให้สังเกตว่าตัวเข้ารหัสอัตโนมัติได้รับการฝึกฝนโดยใช้ ECG ปกติเท่านั้น แต่ได้รับการประเมินโดยใช้ชุดการทดสอบทั้งหมด

history = autoencoder.fit(normal_train_data, normal_train_data, 
          epochs=20, 
          batch_size=512,
          validation_data=(test_data, test_data),
          shuffle=True)

Epoch 1/20
5/5 [==============================] - 1s 33ms/step - loss: 0.0576 - val_loss: 0.0531
Epoch 2/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0552 - val_loss: 0.0514
Epoch 3/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0519 - val_loss: 0.0499
Epoch 4/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0483 - val_loss: 0.0475
Epoch 5/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0445 - val_loss: 0.0451
Epoch 6/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0409 - val_loss: 0.0432
Epoch 7/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0377 - val_loss: 0.0415
Epoch 8/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0348 - val_loss: 0.0401
Epoch 9/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0319 - val_loss: 0.0388
Epoch 10/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0293 - val_loss: 0.0378
Epoch 11/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0273 - val_loss: 0.0369
Epoch 12/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0259 - val_loss: 0.0361
Epoch 13/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0249 - val_loss: 0.0354
Epoch 14/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0239 - val_loss: 0.0346
Epoch 15/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0230 - val_loss: 0.0340
Epoch 16/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0222 - val_loss: 0.0335
Epoch 17/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0215 - val_loss: 0.0331
Epoch 18/20
5/5 [==============================] - 0s 9ms/step - loss: 0.0211 - val_loss: 0.0331
Epoch 19/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0208 - val_loss: 0.0329
Epoch 20/20
5/5 [==============================] - 0s 8ms/step - loss: 0.0206 - val_loss: 0.0327

plt.plot(history.history["loss"], label="Training Loss")
plt.plot(history.history["val_loss"], label="Validation Loss")
plt.legend()

<matplotlib.legend.Legend at 0x7ff1d339b790>

ในไม่ช้า คุณจะจัดประเภท ECG ว่าผิดปกติ หากข้อผิดพลาดในการสร้างใหม่มีค่าเบี่ยงเบนมาตรฐานมากกว่าหนึ่งค่าจากตัวอย่างการฝึกปกติ อันดับแรก เรามาพลอต ECG ปกติจากชุดการฝึก การสร้างใหม่หลังจากที่เข้ารหัสและถอดรหัสโดย autoencoder และข้อผิดพลาดในการสร้างใหม่

encoded_data = autoencoder.encoder(normal_test_data).numpy()
decoded_data = autoencoder.decoder(encoded_data).numpy()

plt.plot(normal_test_data[0], 'b')
plt.plot(decoded_data[0], 'r')
plt.fill_between(np.arange(140), decoded_data[0], normal_test_data[0], color='lightcoral')
plt.legend(labels=["Input", "Reconstruction", "Error"])
plt.show()

สร้างโครงเรื่องที่คล้ายกัน คราวนี้สำหรับตัวอย่างการทดสอบที่ผิดปกติ

encoded_data = autoencoder.encoder(anomalous_test_data).numpy()
decoded_data = autoencoder.decoder(encoded_data).numpy()

plt.plot(anomalous_test_data[0], 'b')
plt.plot(decoded_data[0], 'r')
plt.fill_between(np.arange(140), decoded_data[0], anomalous_test_data[0], color='lightcoral')
plt.legend(labels=["Input", "Reconstruction", "Error"])
plt.show()

ตรวจจับความผิดปกติ

ตรวจจับความผิดปกติด้วยการคำนวณว่าการสูญเสียการสร้างใหม่มีค่ามากกว่าเกณฑ์คงที่หรือไม่ ในบทช่วยสอนนี้ คุณจะคำนวณข้อผิดพลาดเฉลี่ยเฉลี่ยสำหรับตัวอย่างปกติจากชุดการฝึก จากนั้นจัดประเภทตัวอย่างในอนาคตว่าผิดปกติ หากข้อผิดพลาดในการสร้างใหม่สูงกว่าค่าเบี่ยงเบนมาตรฐานหนึ่งค่าจากชุดการฝึก

พล็อตข้อผิดพลาดในการสร้างใหม่บน ECG ปกติจากชุดการฝึก

reconstructions = autoencoder.predict(normal_train_data)
train_loss = tf.keras.losses.mae(reconstructions, normal_train_data)

plt.hist(train_loss[None,:], bins=50)
plt.xlabel("Train loss")
plt.ylabel("No of examples")
plt.show()

เลือกค่าเกณฑ์ที่เป็นค่าเบี่ยงเบนมาตรฐานหนึ่งค่าเหนือค่าเฉลี่ย

threshold = np.mean(train_loss) + np.std(train_loss)
print("Threshold: ", threshold)

Threshold:  0.03241627

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

reconstructions = autoencoder.predict(anomalous_test_data)
test_loss = tf.keras.losses.mae(reconstructions, anomalous_test_data)

plt.hist(test_loss[None, :], bins=50)
plt.xlabel("Test loss")
plt.ylabel("No of examples")
plt.show()

จำแนก ECG เป็นความผิดปกติหากข้อผิดพลาดในการสร้างใหม่มากกว่าเกณฑ์

def predict(model, data, threshold):
  reconstructions = model(data)
  loss = tf.keras.losses.mae(reconstructions, data)
  return tf.math.less(loss, threshold)

def print_stats(predictions, labels):
  print("Accuracy = {}".format(accuracy_score(labels, predictions)))
  print("Precision = {}".format(precision_score(labels, predictions)))
  print("Recall = {}".format(recall_score(labels, predictions)))

preds = predict(autoencoder, test_data, threshold)
print_stats(preds, test_labels)

Accuracy = 0.944
Precision = 0.9921875
Recall = 0.9071428571428571

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการตรวจจับความผิดปกติด้วยตัวเข้ารหัสอัตโนมัติ ลองดู ตัวอย่างเชิงโต้ตอบ ที่ยอดเยี่ยมซึ่งสร้างด้วย TensorFlow.js โดย Victor Dibia สำหรับกรณีการใช้งานจริง คุณสามารถเรียนรู้วิธีที่ Airbus ตรวจจับสิ่งผิดปกติใน ISS Telemetry Data โดยใช้ TensorFlow หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับพื้นฐาน ลองอ่าน โพสต์ในบล็อก นี้โดย François Chollet สำหรับรายละเอียดเพิ่มเติม โปรดดูบทที่ 14 จาก Deep Learning โดย Ian Goodfellow, Yoshua Bengio และ Aaron Courville