हिंटन और सलाखुद्दीनोव द्वारा 2006 के विज्ञान पत्र के प्रमुख चित्र इस प्रकार हैं:
यह मूल 784 आयामों से दो तक MNIST डेटासेट ( एकल अंकों की 28 \ _ 2828×28 काली और सफेद छवियों) की गतिशीलता में कमी को दर्शाता है ।
आइए इसे पुन: पेश करने का प्रयास करें। मैं सीधे Tensorflow का उपयोग नहीं करूँगा, क्योंकि इस तरह के सरल गहन शिक्षण कार्यों के लिए Keras (Tensorflow के शीर्ष पर चल रहा एक उच्च-स्तरीय पुस्तकालय) का उपयोग करना बहुत आसान है। H & S ने उपयोग आर्किटेक्चर लॉजिस्टिक यूनिट्स के साथ पूर्व-प्रशिक्षित प्रतिबंधित बोल्ट्जमैन मशीनों के ढेर के साथ प्रशिक्षित किया। दस साल बाद, यह बहुत पुराना स्कूल लगता है । मैं बिना किसी पूर्व-प्रशिक्षण के घातीय रेखीय इकाइयों के साथ वास्तुकला का उपयोग करूँगा । मैं एडम ऑप्टिमाइज़र (गति के साथ अनुकूली स्टोचस्टिक ढाल वंश का एक विशेष कार्यान्वयन) का उपयोग करूंगा।
784→1000→500→250→2→250→500→1000→784
784→512→128→2→128→512→784
कोड ज्यूपिटर नोटबुक से कॉपी-पेस्ट किया जाता है। Python 3.6 में आपको matplotlib (pylab के लिए), NumPy, seaborn, TensorFlow और Keras स्थापित करने की आवश्यकता है। पायथन शेल में दौड़ते समय, आपको plt.show()प्लॉट दिखाने के लिए जोड़ना पड़ सकता है ।
प्रारंभ
%matplotlib notebook
import pylab as plt
import numpy as np
import seaborn as sns; sns.set()
import keras
from keras.datasets import mnist
from keras.models import Sequential, Model
from keras.layers import Dense
from keras.optimizers import Adam
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784) / 255
x_test = x_test.reshape(10000, 784) / 255
पीसीए
mu = x_train.mean(axis=0)
U,s,V = np.linalg.svd(x_train - mu, full_matrices=False)
Zpca = np.dot(x_train - mu, V.transpose())
Rpca = np.dot(Zpca[:,:2], V[:2,:]) + mu # reconstruction
err = np.sum((x_train-Rpca)**2)/Rpca.shape[0]/Rpca.shape[1]
print('PCA reconstruction error with 2 PCs: ' + str(round(err,3)));
यह आउटपुट:
PCA reconstruction error with 2 PCs: 0.056
ऑटोएन्कोडर का प्रशिक्षण
m = Sequential()
m.add(Dense(512, activation='elu', input_shape=(784,)))
m.add(Dense(128, activation='elu'))
m.add(Dense(2, activation='linear', name="bottleneck"))
m.add(Dense(128, activation='elu'))
m.add(Dense(512, activation='elu'))
m.add(Dense(784, activation='sigmoid'))
m.compile(loss='mean_squared_error', optimizer = Adam())
history = m.fit(x_train, x_train, batch_size=128, epochs=5, verbose=1,
validation_data=(x_test, x_test))
encoder = Model(m.input, m.get_layer('bottleneck').output)
Zenc = encoder.predict(x_train) # bottleneck representation
Renc = m.predict(x_train) # reconstruction
यह मेरे काम के डेस्कटॉप और आउटपुट पर ~ 35 सेकंड लेता है:
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 7s - loss: 0.0577 - val_loss: 0.0482
Epoch 2/5
60000/60000 [==============================] - 7s - loss: 0.0464 - val_loss: 0.0448
Epoch 3/5
60000/60000 [==============================] - 7s - loss: 0.0438 - val_loss: 0.0430
Epoch 4/5
60000/60000 [==============================] - 7s - loss: 0.0423 - val_loss: 0.0416
Epoch 5/5
60000/60000 [==============================] - 7s - loss: 0.0412 - val_loss: 0.0407
इसलिए आप पहले से ही देख सकते हैं कि हमने केवल दो प्रशिक्षण युगों के बाद पीसीए नुकसान को पार कर लिया है।
(वैसे, यह सभी सक्रियण कार्यों को बदलने और यह देखने के लिए निर्देश है activation='linear'कि नुकसान पीसीए हानि में कैसे परिवर्तित होता है। ऐसा इसलिए है क्योंकि रैखिक ऑटोएन्कोडर पीसीए के बराबर है।)
टोंटी प्रतिनिधित्व के साथ पीसीए प्रक्षेपण पक्ष की ओर से प्लॉटिंग
plt.figure(figsize=(8,4))
plt.subplot(121)
plt.title('PCA')
plt.scatter(Zpca[:5000,0], Zpca[:5000,1], c=y_train[:5000], s=8, cmap='tab10')
plt.gca().get_xaxis().set_ticklabels([])
plt.gca().get_yaxis().set_ticklabels([])
plt.subplot(122)
plt.title('Autoencoder')
plt.scatter(Zenc[:5000,0], Zenc[:5000,1], c=y_train[:5000], s=8, cmap='tab10')
plt.gca().get_xaxis().set_ticklabels([])
plt.gca().get_yaxis().set_ticklabels([])
plt.tight_layout()
पुनर्निर्माण
और अब आइए पुनर्निर्माण को देखें (पहली पंक्ति - मूल चित्र, दूसरी पंक्ति - पीसीए, तीसरी पंक्ति - ऑटोएन्कोडर):
plt.figure(figsize=(9,3))
toPlot = (x_train, Rpca, Renc)
for i in range(10):
for j in range(3):
ax = plt.subplot(3, 10, 10*j+i+1)
plt.imshow(toPlot[j][i,:].reshape(28,28), interpolation="nearest",
vmin=0, vmax=1)
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.tight_layout()
गहरा नेटवर्क, कुछ नियमितीकरण और लंबे समय तक प्रशिक्षण के साथ बेहतर परिणाम प्राप्त कर सकते हैं। प्रयोग। दीप सीखना आसान है!
