অটোএনকোডারের ভূমিকা

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালটি তিনটি উদাহরণ সহ অটোএনকোডারের সাথে পরিচয় করিয়ে দেয়: বেসিক, ইমেজ ডিনোইসিং এবং অসঙ্গতি সনাক্তকরণ।

একটি অটোএনকোডার হল একটি বিশেষ ধরনের নিউরাল নেটওয়ার্ক যা তার ইনপুটকে তার আউটপুটে অনুলিপি করার জন্য প্রশিক্ষিত। উদাহরণস্বরূপ, একটি হস্তলিখিত অঙ্কের একটি চিত্র দেওয়া হলে, একটি অটোএনকোডার প্রথমে চিত্রটিকে একটি নিম্ন মাত্রিক সুপ্ত প্রতিনিধিত্বে এনকোড করে, তারপরে সুপ্ত উপস্থাপনাটিকে একটি চিত্রে ডিকোড করে। একটি অটোএনকোডার পুনর্গঠন ত্রুটি কমিয়ে ডেটা সংকুচিত করতে শেখে।

অটোএনকোডার সম্পর্কে আরও জানতে, অনুগ্রহ করে ইয়ান গুডফেলো, ইয়োশুয়া বেঙ্গিও এবং অ্যারন কোরভিলের ডিপ লার্নিং থেকে অধ্যায় 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

ডেটাসেট লোড করুন

শুরু করতে, আপনি ফ্যাশন 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 , যা সুপ্ত স্থান থেকে আসল চিত্রটিকে পুনর্গঠন করে৷

আপনার মডেল সংজ্ঞায়িত করতে, কেরাস মডেল সাবক্লাসিং 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()

দ্বিতীয় উদাহরণ: ইমেজ denoising

একটি অটোএনকোডারকে ছবি থেকে শব্দ অপসারণ করতেও প্রশিক্ষণ দেওয়া যেতে পারে। নিম্নলিখিত বিভাগে, আপনি প্রতিটি ছবিতে এলোমেলো শব্দ প্রয়োগ করে ফ্যাশন 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()

একটি কনভোলিউশনাল অটোএনকোডার সংজ্ঞায়িত করুন

এই উদাহরণে, আপনি encoder Conv2D স্তরগুলি এবং decoder Conv2DT ট্রান্সপোজ স্তরগুলি ব্যবহার করে একটি রূপান্তরমূলক অটোএনকোডারকে প্রশিক্ষণ দেবেন৷

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

লক্ষ্য করুন যে অটোএনকোডারকে শুধুমাত্র সাধারণ ইসিজি ব্যবহার করে প্রশিক্ষিত করা হয়, তবে সম্পূর্ণ পরীক্ষার সেট ব্যবহার করে মূল্যায়ন করা হয়।

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 কে অস্বাভাবিক হিসাবে শ্রেণীবদ্ধ করবেন যদি পুনর্গঠনের ত্রুটি স্বাভাবিক প্রশিক্ষণের উদাহরণ থেকে একটি আদর্শ বিচ্যুতির চেয়ে বেশি হয়। প্রথমে, আসুন ট্রেনিং সেট থেকে একটি সাধারণ ইসিজি, অটোএনকোডার দ্বারা এনকোড এবং ডিকোড করার পরে পুনর্গঠন এবং পুনর্গঠন ত্রুটির প্লট করা যাক।

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

পুনর্গঠন ত্রুটি থ্রেশহোল্ডের চেয়ে বেশি হলে একটি অসঙ্গতি হিসাবে একটি 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 এর সাথে নির্মিত এই দুর্দান্ত ইন্টারেক্টিভ উদাহরণটি দেখুন। বাস্তব-বিশ্ব ব্যবহারের ক্ষেত্রে, আপনি শিখতে পারেন যে কীভাবে এয়ারবাস টেনসরফ্লো ব্যবহার করে আইএসএস টেলিমেট্রি ডেটাতে অসঙ্গতি সনাক্ত করে। বেসিক সম্পর্কে আরও জানতে, ফ্রাঁসোয়া চোলেটের এই ব্লগ পোস্টটি পড়ার কথা বিবেচনা করুন। আরও বিশদ বিবরণের জন্য, ইয়ান গুডফেলো, ইয়োশুয়া বেঙ্গিও এবং অ্যারন কোরভিলের ডিপ লার্নিং থেকে অধ্যায় 14 দেখুন।