מבוא למקודדים אוטומטיים

הדרכה זו מציגה מקודדים אוטומטיים עם שלוש דוגמאות: היסודות, צביעת תמונה וזיהוי אנומליות.

מקודד אוטומטי הוא סוג מיוחד של רשת עצבית שמאומנת להעתיק את הקלט שלה לפלט שלה. לדוגמה, בהינתן תמונה של ספרה בכתב יד, מקודד אוטומטי מקודד תחילה את התמונה לייצוג סמוי ממדי נמוך יותר, ואז מפענח את הייצוג הסמוי בחזרה לתמונה. מקודד אוטומטי לומד לדחוס את הנתונים תוך מזעור שגיאת השחזור.

כדי ללמוד עוד על מקודדים אוטומטיים, אנא שקול לקרוא את פרק 14 מתוך למידה עמוקה מאת איאן גודפלו, יושע בנג'יו ואהרון קורוויל.

ייבוא ​​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()

דוגמה שנייה: דנוי תמונה

ניתן גם לאמן מקודד אוטומטי להסיר רעש מתמונות. בסעיף הבא, תיצור גרסה רועשת של מערך הנתונים של 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()

הגדר מקודד אוטומטי קונבולוציוני

בדוגמה זו, תאמן מקודד אוטומטי קונבולוציוני באמצעות שכבות 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 (המתאים לקצב רגיל). אתה מעוניין לזהות את המקצבים החריגים.

הערה: זהו מערך נתונים שכותרתו, אז אתה יכול לנסח זאת כבעיית למידה מפוקחת. המטרה של דוגמה זו היא להמחיש מושגי זיהוי אנומליות שניתן ליישם על מערכי נתונים גדולים יותר, שבהם אין לך תוויות זמינות (לדוגמה, אם היו לך אלפים רבים של מקצבים נורמליים, ורק מספר קטן של מקצבים חריגים).

כיצד תזהה חריגות באמצעות מקודד אוטומטי? זכור שמקודד אוטומטי מאומן כדי למזער שגיאות שחזור. אתה תאמן מקודד אוטומטי על המקצבים הרגילים בלבד, ולאחר מכן תשתמש בו כדי לשחזר את כל הנתונים. ההשערה שלנו היא שלמקצבים החריגים תהיה שגיאת שחזור גבוהה יותר. לאחר מכן תסווג קצב כאנומליה אם שגיאת השחזור עוברת סף קבוע.

טען נתוני א.ק.ג

מערך הנתונים שבו תשתמש מבוסס על אחד מ- 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]

תכנן א.ק.ג. רגיל.

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

תכנן א.ק.ג. חריג.

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>

בקרוב תסווג א.ק.ג כחריגה אם שגיאת השחזור גדולה מסטיית תקן אחת מדוגמאות האימון הרגילות. ראשית, בואו נשרטט א.ק.ג. רגיל ממערכת האימון, השחזור לאחר קידוד ופענוח על ידי המקודד האוטומטי, ושגיאת השחזור.

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

זיהוי חריגות

זיהוי חריגות על ידי חישוב האם אובדן השחזור גדול מסף קבוע. במדריך זה, תחשב את השגיאה הממוצעת הממוצעת עבור דוגמאות רגילות ממערך האימונים, ולאחר מכן תסווג דוגמאות עתידיות כחריגות אם שגיאת השחזור גבוהה מסטיית תקן אחת ממערך האימונים.

צייר את שגיאת השחזור על א.ק.ג רגילים ממערכת האימון

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

סווגו א.ק.ג כאנומליה אם שגיאת השחזור גדולה מהסף.

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. למקרה שימוש בעולם האמיתי, אתה יכול ללמוד כיצד איירבוס מזהה חריגות בנתוני טלמטריה של ISS באמצעות TensorFlow. כדי ללמוד עוד על היסודות, שקול לקרוא את הפוסט הזה בבלוג מאת פרנסואה צ'ולט. לפרטים נוספים, עיין בפרק 14 מתוך למידה עמוקה מאת איאן גודפלו, יושע בנג'יו ואהרון קורוויל.