 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
डेटासेट लोड करें
शुरू करने के लिए, आप फैशन एमएनआईएसटी डेटासेट का उपयोग करके मूल ऑटोएन्कोडर को प्रशिक्षित करेंगे। इस डेटासेट की प्रत्येक छवि 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 , जो अव्यक्त स्थान से मूल छवि का पुनर्निर्माण करता है।
अपने मॉडल को परिभाषित करने के लिए, केरस मॉडल सबक्लासिंग एपीआई का उपयोग करें।
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()
दूसरा उदाहरण: छवि निरूपण
छवियों से शोर को दूर करने के लिए एक ऑटोएन्कोडर को भी प्रशिक्षित किया जा सकता है। निम्नलिखित अनुभाग में, आप प्रत्येक छवि पर यादृच्छिक शोर लागू करके फैशन एमएनआईएसटी डेटासेट का एक शोर संस्करण तैयार करेंगे। फिर आप शोर छवि का उपयोग इनपुट के रूप में और लक्ष्य के रूप में मूल छवि का उपयोग करके एक ऑटोएन्कोडर को प्रशिक्षित करेंगे।
आइए पहले किए गए संशोधनों को छोड़ने के लिए डेटासेट को फिर से आयात करें।
(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 में Conv2DTranspose परतों का उपयोग करेंगे।
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
_________________________________________________________________
प्लेसहोल्डर22ऑटोएन्कोडर द्वारा निर्मित शोर वाली छवियों और निरूपित छवियों दोनों को प्लॉट करना।
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>
यदि पुनर्निर्माण त्रुटि सामान्य प्रशिक्षण उदाहरणों से एक मानक विचलन से अधिक है, तो आप जल्द ही एक ईसीजी को विषम के रूप में वर्गीकृत करेंगे। सबसे पहले, आइए प्रशिक्षण सेट से एक सामान्य ईसीजी, ऑटोएन्कोडर द्वारा एन्कोड और डीकोड किए जाने के बाद पुनर्निर्माण, और पुनर्निर्माण त्रुटि की साजिश करें।
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 के साथ निर्मित इस उत्कृष्ट इंटरैक्टिव उदाहरण को देखें। वास्तविक दुनिया में उपयोग के मामले के लिए, आप सीख सकते हैं कि कैसे एयरबस TensorFlow का उपयोग करके ISS टेलीमेट्री डेटा में विसंगतियों का पता लगाता है । बुनियादी बातों के बारे में अधिक जानने के लिए, फ्रांकोइस चॉलेट द्वारा इस ब्लॉग पोस्ट को पढ़ने पर विचार करें। अधिक जानकारी के लिए, इयान गुडफेलो, योशुआ बेंगियो और आरोन कौरविल द्वारा डीप लर्निंग से अध्याय 14 देखें।