التشفير التلقائي في TensorFlow مع مثال

ما هو التشفير التلقائي في التعلم العميق؟

An ترميز تلقائي هي أداة لتعلم ترميز البيانات بكفاءة وبطريقة غير خاضعة للرقابة. إنها نوع من الشبكات العصبية الاصطناعية التي تساعدك على تعلم تمثيل مجموعات البيانات لتقليل الأبعاد من خلال تدريب الشبكة العصبية على تجاهل ضوضاء الإشارة. إنها أداة رائعة لإعادة إنشاء المدخلات.

بكلمات بسيطة، تلتقط الآلة صورة، على سبيل المثال، ويمكنها إنتاج صورة وثيقة الصلة بها. المدخلات في هذا النوع من الشبكات العصبية غير موسومة، مما يعني أن الشبكة قادرة على التعلم دون إشراف. وبشكل أكثر دقة، يتم تشفير الإدخال بواسطة الشبكة للتركيز فقط على الميزة الأكثر أهمية. وهذا هو أحد الأسباب التي تجعل جهاز التشفير التلقائي شائعًا لتقليل الأبعاد. علاوة على ذلك، يمكن استخدام أجهزة التشفير التلقائي في الإنتاج نماذج التعلم التوليدية. على سبيل المثال، يمكن تدريب الشبكة العصبية باستخدام مجموعة من الوجوه ومن ثم يمكنها إنتاج وجوه جديدة.

كيف يعمل جهاز التشفير التلقائي TensorFlow؟

الغرض من جهاز التشفير التلقائي هو إنتاج تقدير تقريبي للمدخلات من خلال التركيز فقط على الميزات الأساسية. قد تتساءل لماذا لا تتعلم فقط كيفية نسخ ولصق المدخلات لإنتاج المخرجات. في الواقع، جهاز التشفير التلقائي عبارة عن مجموعة من القيود التي تجبر الشبكة على تعلم طرق جديدة لتمثيل البيانات، تختلف عن مجرد نسخ المخرجات.

يتم تعريف جهاز التشفير التلقائي النموذجي بمدخل وتمثيل داخلي ومخرج (تقريب للمدخلات). يحدث التعلم في الطبقات المرتبطة بالتمثيل الداخلي. في الواقع، هناك كتلتان رئيسيتان من الطبقات التي تشبه الشبكة العصبية التقليدية. الاختلاف الطفيف هو أن الطبقة التي تحتوي على الإخراج يجب أن تكون مساوية للإدخال. في الصورة أدناه، ينتقل الإدخال الأصلي إلى الكتلة الأولى التي تسمى التشفير. يعمل هذا التمثيل الداخلي على ضغط (تقليل) حجم الإدخال. في الكتلة الثانية يحدث إعادة بناء المدخلات. هذه هي مرحلة فك التشفير.

سيقوم النموذج بتحديث الأوزان عن طريق تقليل وظيفة الخسارة. تتم معاقبة النموذج إذا كان ناتج إعادة الإعمار مختلفًا عن المدخلات.

بشكل ملموس، تخيل صورة بحجم 50 × 50 (أي 250 بكسل) وشبكة عصبية تحتوي على طبقة مخفية واحدة فقط مكونة من مائة خلية عصبية. يتم التعلم على خريطة الميزات التي تكون أصغر بمرتين من المدخلات. وهذا يعني أن الشبكة بحاجة إلى إيجاد طريقة لإعادة بناء 250 بكسل باستخدام ناقل من الخلايا العصبية يساوي 100 فقط.

مثال على وحدة التشفير التلقائي المكدسة

في هذا البرنامج التعليمي الخاص بـ Autoencoder، ستتعلم كيفية استخدام Autoencoder المكدس. تشبه البنية الأساسية الشبكة العصبية التقليدية. تنتقل المدخلات إلى طبقة مخفية من أجل ضغطها أو تقليل حجمها، ثم تصل إلى طبقات إعادة البناء. الهدف هو إنتاج صورة مخرجات قريبة من الصورة الأصلية. يجب أن يتعلم النموذج طريقة لتحقيق مهمته في ظل مجموعة من القيود، أي بأبعاد أقل.

في الوقت الحاضر، أجهزة الترميز التلقائي في تعلم عميق تستخدم بشكل أساسي لتقليل تشويش الصورة. تخيل صورة بها خدوش؛ لا يزال الإنسان قادرًا على التعرف على المحتوى. تتمثل فكرة تقليل الضوضاء في جهاز التشفير التلقائي في إضافة ضوضاء إلى الصورة لإجبار الشبكة على التعرف على النمط الكامن وراء البيانات.

العائلة المفيدة الأخرى لـ Autoencoder Deep Learning هي أداة التشفير التلقائي المتغيرة. يمكن لهذا النوع من الشبكات إنشاء صور جديدة. تخيل أنك تدرب شبكة بصورة رجل؛ مثل هذه الشبكة يمكن أن تنتج وجوهًا جديدة.

كيفية بناء جهاز تشفير تلقائي باستخدام TensorFlow

في هذا البرنامج التعليمي، سوف تتعلم كيفية إنشاء جهاز تشفير تلقائي مكدس لإعادة بناء الصورة.

سوف تستخدم ملف مجموعة بيانات CIFAR-10 والذي يحتوي على 60000 صورة ملونة مقاس 32×32. تم تقسيم مجموعة بيانات Autoencoder بالفعل بين 50000 صورة للتدريب و10000 صورة للاختبار. هناك ما يصل إلى عشرة فصول:

• طائرة
• لاستخدام السيارة
• طائر
• قط
• أيل
• كلب
• ضفدع
• خيل
• شحن
• شاحنة

تحتاج إلى تنزيل الصور الموجودة في عنوان URL هذا https://www.cs.toronto.edu/~kriz/cifar.html وفك ضغطها. يحتوي المجلد for-10-batches-py على خمس دفعات من البيانات تحتوي كل منها على 10000 صورة بترتيب عشوائي.

قبل إنشاء نموذجك وتدريبه، تحتاج إلى تطبيق بعض عمليات معالجة البيانات. سوف تتصرف على النحو التالي:

1. استيراد البيانات
2. تحويل البيانات إلى تنسيق أبيض وأسود
3. إلحاق كافة الدفعات
4. بناء مجموعة بيانات التدريب
5. بناء متخيل الصورة

معالجة الصور

الخطوة 1) استيراد البيانات

وفقًا للموقع الرسمي، يمكنك تحميل البيانات باستخدام الكود التالي. سيقوم كود Autoencoder بتحميل البيانات في قاموس باستخدام البيانات و مبادئ السلوك ملصق. لاحظ أن الكود عبارة عن دالة.

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

الخطوة 2) تحويل البيانات إلى تنسيق أبيض وأسود

للتبسيط، سوف تقوم بتحويل البيانات إلى تدرج رمادي. أي ببعد واحد فقط مقابل ثلاثة لألوان الصورة. تعمل معظم الشبكات العصبية بإدخال بُعد واحد فقط.

def grayscale(im):
    return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

الخطوة 3) إلحاق جميع الدُفعات

الآن بعد أن تم إنشاء كلتا الوظيفتين وتحميل مجموعة البيانات، يمكنك كتابة حلقة لإلحاق البيانات في الذاكرة. إذا قمت بالتحقق بعناية، فسيتم تسمية ملف فك الضغط الذي يحتوي على البيانات باسم data_batch_ برقم من 1 إلى 5. يمكنك تكرار الملفات وإلحاقها بالبيانات.

عند الانتهاء من هذه الخطوة، يمكنك تحويل بيانات الألوان إلى تنسيق التدرج الرمادي. كما ترون، شكل البيانات هو 50000 و1024. تم الآن تسوية البكسلات مقاس 32*32 حتى عام 2014.

# Load the data into memory
data, labels = [], []
## Loop over the b
for i in range(1, 6):
    filename = './cifar-10-batches-py/data_batch_' + str(i)
    open_data = unpickle(filename)
    if len(data) > 0:
        data = np.vstack((data, open_data['data']))
        labels = np.hstack((labels, open_data['labels']))
    else:
        data = open_data['data']
        labels = open_data['labels']

data = grayscale(data)
x = np.matrix(data)
y = np.array(labels)
print(x.shape)
(50000, 1024)

ملحوظة: قم بتغيير './cifar-10-batches-py/data_batch_' إلى الموقع الفعلي لملفك. على سبيل المثال ل Windows الجهاز، يمكن أن يكون المسار filename = 'E:\cifar-10-batches-py\data_batch_' + str(i)

الخطوة 4) إنشاء مجموعة بيانات التدريب

لجعل التدريب أسرع وأسهل، سوف تقوم بتدريب نموذج على صور الحصان فقط. والخيول هي الدرجة السابعة في بيانات التسمية. كما هو مذكور في وثائق مجموعة بيانات CIFAR-10، تحتوي كل فئة على 5000 صورة. يمكنك طباعة شكل البيانات للتأكد من وجود 5.000 صورة مع 1024 عمود كما هو موضح أدناه TensorFlow خطوة مثال التشفير التلقائي.

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x)) 
(5000, 1024)

الخطوة 5) إنشاء متخيل الصورة

وأخيرًا، يمكنك إنشاء دالة لرسم الصور. ستحتاج إلى هذه الوظيفة لطباعة الصورة المعاد بناؤها من جهاز التشفير التلقائي.

إحدى الطرق السهلة لطباعة الصور هي استخدام الكائن imshow من مكتبة matplotlib. لاحظ أنك تحتاج إلى تحويل شكل البيانات من 1024 إلى 32*32 (أي تنسيق الصورة).

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

تأخذ الدالة 3 وسيطات:

• صورة: المدخل
• الشكل : القائمة، البعد من الصورة
• كماب:اختر خريطة الألوان. افتراضيا، الرمادي

يمكنك محاولة رسم الصورة الأولى في مجموعة البيانات. يجب أن ترى رجلاً على حصان.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

تعيين مقدر مجموعة البيانات

حسنًا، الآن بعد أن أصبحت مجموعة البيانات جاهزة للاستخدام، يمكنك البدء في استخدام Tensorflow. قبل إنشاء النموذج، دعونا نستخدم مقدر مجموعة البيانات الخاص بـ Tensorflow لتغذية الشبكة.

ستقوم بإنشاء مجموعة بيانات باستخدام مقدر TensorFlow. لتحديث عقلك، عليك استخدام:

• from_tensor_slices
• كرر
• دفعة

الكود الكامل لبناء مجموعة البيانات هو:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

لاحظ أن x هو عنصر نائب بالشكل التالي:

• [None,n_inputs]: اضبط على لا شيء لأن عدد تغذية الصور إلى الشبكة يساوي حجم الدُفعة.

للحصول على التفاصيل، يرجى الرجوع إلى البرنامج التعليمي على الانحدارالخطي.

بعد ذلك، تحتاج إلى إنشاء المكرر. بدون هذا السطر من التعليمات البرمجية، لن تمر أي بيانات عبر المسار.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

الآن وبعد أن أصبح خط الأنابيب جاهزًا، يمكنك التحقق مما إذا كانت الصورة الأولى هي نفسها التي كانت عليها من قبل (أي رجل على حصان).

لقد قمت بتعيين حجم الدفعة إلى 1 لأنك تريد تغذية مجموعة البيانات بصورة واحدة فقط. يمكنك رؤية أبعاد البيانات باستخدام print(sess.run(features).shape). وهو يساوي (1, 1024). 1 يعني أنه سيتم تغذية صورة واحدة فقط بحجم 1024 لكل منها. إذا تم تعيين حجم الدفعة إلى اثنين، فستمر صورتان عبر خط الأنابيب. (لا تغير حجم الدفعة. وإلا، فسيؤدي ذلك إلى حدوث خطأ. لا يمكن نقل سوى صورة واحدة في كل مرة إلى الدالة plot_image().

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                         batch_size: BATCH_SIZE}) 
    print(sess.run(features).shape) 
    plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")
(1, 1024)

بناء الشبكة

لقد حان الوقت لبناء الشبكة. سوف تقوم بتدريب أداة التشفير التلقائي المكدسة، وهي شبكة ذات طبقات مخفية متعددة.

ستحتوي شبكتك على طبقة إدخال واحدة تحتوي على 1024 نقطة، أي 32×32، شكل الصورة.

ستحتوي كتلة التشفير على طبقة علوية مخفية بها 300 خلية عصبية، وطبقة مركزية بها 150 خلية عصبية. كتلة وحدة فك التشفير متماثلة مع جهاز التشفير. يمكنك تصور الشبكة في الصورة أدناه. لاحظ أنه يمكنك تغيير قيم الطبقات المخفية والمركزية.

إن بناء جهاز التشفير التلقائي يشبه إلى حد كبير أي نموذج آخر للتعلم العميق.

سوف تقوم ببناء النموذج باتباع الخطوات التالية:

1. تحديد المعلمات
2. تحديد الطبقات
3. تحديد الهندسة المعمارية
4. تحديد التحسين
5. قم بتشغيل النموذج
6. قيم النموذج

في القسم السابق، تعلمت كيفية إنشاء مسار لتغذية النموذج، لذلك ليست هناك حاجة لإنشاء مجموعة البيانات مرة أخرى. سوف تقوم بإنشاء جهاز تشفير تلقائي بأربع طبقات. يمكنك استخدام تهيئة Xavier. هذه تقنية لتعيين الأوزان الأولية مساوية لتباين المدخلات والمخرجات. وأخيرا، يمكنك استخدام وظيفة التنشيط elu. يمكنك تنظيم وظيفة الخسارة باستخدام منظم L2.

الخطوة 1) تحديد المعلمات

تتضمن الخطوة الأولى تحديد عدد الخلايا العصبية في كل طبقة، ومعدل التعلم والمعلمة الفائقة للمنظم.

قبل ذلك، يمكنك استيراد الوظيفة جزئيًا. إنها طريقة أفضل لتحديد معلمات الطبقات الكثيفة. يحدد الكود أدناه قيم بنية المشفر التلقائي. كما هو مذكور من قبل، يحتوي المشفر التلقائي على طبقتين، مع 300 خلية عصبية في الطبقات الأولى و150 في الطبقات الثانية. يتم تخزين قيمها في n_hidden_1 وn_hidden_2.

تحتاج إلى تحديد معدل التعلم والمعلمة الفائقة L2. يتم تخزين القيم في Learning_rate وl2_reg

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

يتم استدعاء تقنية تهيئة Xavier باستخدام الكائن xavier_initializer من مساهمة المُقدِّر. في نفس المقدر، يمكنك إضافة المنظم باستخدام l2_regularizer

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

الخطوة 2) تحديد الطبقات

تم ضبط جميع معلمات الطبقات الكثيفة؛ يمكنك حزم كل شيء في الطبقة الكثيفة المتغيرة باستخدام الكائن جزئيًا. طبقة كثيفة تستخدم تنشيط ELU وتهيئة Xavier وتسوية L2.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
                         activation=tf.nn.elu,
                         kernel_initializer=xav_init,
                         kernel_regularizer=l2_regularizer)

الخطوة 3) تحديد الهندسة المعمارية

إذا نظرت إلى صورة الهندسة المعمارية، ستلاحظ أن الشبكة تكدس ثلاث طبقات مع طبقة إخراج. في الكود أدناه، تقوم بتوصيل الطبقات المناسبة. على سبيل المثال، تحسب الطبقة الأولى حاصل الضرب النقطي بين سمات مصفوفة المدخلات والمصفوفات التي تحتوي على 300 وزن. بعد حساب حاصل الضرب النقطي، ينتقل الإخراج إلى دالة تنشيط Elu. يصبح الإخراج مدخلاً للطبقة التالية، ولهذا السبب تستخدمه لحساب hidden_2 وما إلى ذلك. يكون ضرب المصفوفات هو نفسه لكل طبقة لأنك تستخدم نفس دالة التنشيط. لاحظ أن الطبقة الأخيرة، outputs، لا تطبق دالة تنشيط. هذا منطقي لأن هذا هو المدخل المعاد بناؤه

## Make the mat mul
hidden_1 = dense_layer(features, n_hidden_1)
hidden_2 = dense_layer(hidden_1, n_hidden_2)
hidden_3 = dense_layer(hidden_2, n_hidden_3)
outputs = dense_layer(hidden_3, n_outputs, activation=None)

الخطوة 4) تحديد التحسين

الخطوة الأخيرة هي بناء المحسن. يمكنك استخدام متوسط ​​الخطأ المربع كدالة خسارة. إذا كنت تتذكر البرنامج التعليمي حول الانحدار الخطي، فأنت تعلم أنه يتم حساب MSE مع الفرق بين الإخراج المتوقع والتسمية الحقيقية. هنا، التسمية هي الميزة لأن النموذج يحاول إعادة بناء الإدخال. ولذلك، فأنت تريد متوسط ​​مجموع فرق المربع بين المخرجات والإدخالات المتوقعة. باستخدام TensorFlow، يمكنك ترميز وظيفة الخسارة على النحو التالي:

loss = tf.reduce_mean(tf.square(outputs - features))

ثم، تحتاج إلى تحسين وظيفة الخسارة. يمكنك استخدام محسن آدم لحساب التدرجات. الوظيفة الموضوعية هي تقليل الخسارة.

## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

إعداد آخر قبل تدريب النموذج. تريد استخدام حجم دفعة يبلغ 150، أي تغذية التدفق بـ 150 صورة في كل تكرار. تحتاج إلى حساب عدد التكرارات يدويًا. وهذا أمر تافه للقيام به:

إذا كنت تريد تمرير 150 صورة في كل مرة وتعرف أن هناك 5000 صورة في مجموعة البيانات، فإن عدد التكرارات يساوي . في بايثون، يمكنك تشغيل التعليمات البرمجية التالية والتأكد من أن الناتج هو 33:

BATCH_SIZE = 150
### Number of batches :  length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

الخطوة 5) قم بتشغيل النموذج

وأخيرًا وليس آخرًا، قم بتدريب النموذج. أنت تقوم بتدريب النموذج بـ 100 عصر. أي أن النموذج سيرى الصور 100 مرة بالأوزان المحسنة.

أنت بالفعل على دراية برموز تدريب النموذج في Tensorflow. والفرق البسيط هو نقل البيانات قبل تشغيل التدريب. بهذه الطريقة، يتدرب النموذج بشكل أسرع.

أنت مهتم بطباعة الخسارة بعد عشر فترات لمعرفة ما إذا كان النموذج يتعلم شيئًا ما (أي أن الخسارة آخذة في التناقص). يستغرق التدريب من 2 إلى 5 دقائق، حسب مكونات جهازك.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                          batch_size: BATCH_SIZE})
    print('Training...')
    print(sess.run(features).shape) 
    for epoch in range(n_epochs):       
        for iteration in range(n_batches):
            sess.run(train)
        if epoch % 10 == 0:
            loss_train = loss.eval()   # not shown
            print("\r{}".format(epoch), "Train MSE:", loss_train) 
        #saver.save(sess, "./my_model_all_layers.ckpt") 
    save_path = saver.save(sess, "./model.ckpt")    
    print("Model saved in path: %s" % save_path)  
Training...
(150, 1024)
0 Train MSE: 2934.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

الخطوة 6) قيم النموذج

الآن بعد أن قمت بتدريب النموذج الخاص بك، فقد حان الوقت لتقييمه. تحتاج إلى استيراد سيرت الاختبار من الملف /cifar-10-batches-py/.

test_data = unpickle('./cifar-10-batches-py/test_batch')
test_x = grayscale(test_data['data'])
#test_labels = np.array(test_data['labels'])

نوت: للحصول على Windows الجهاز، يصبح الكود test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)

يمكنك محاولة طباعة الصور 13، وهو حصان

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

لتقييم النموذج، ستستخدم قيمة البكسل لهذه الصورة ومعرفة ما إذا كان بإمكان برنامج التشفير إعادة بناء نفس الصورة بعد تقليصها بمقدار 1024 بكسل. لاحظ أنه يمكنك تحديد دالة لتقييم النموذج على صور مختلفة. يجب أن يعمل النموذج بشكل أفضل فقط على الخيول.

تأخذ الدالة وسيطتين:

• df: استيراد بيانات الاختبار
• image_number: الإشارة إلى الصورة المراد استيرادها

تنقسم الوظيفة إلى ثلاثة أجزاء:

1. إعادة تشكيل الصورة إلى البعد الصحيح، أي 1، 1024
2. قم بتغذية النموذج بالصورة غير المرئية، وقم بتشفير/فك تشفير الصورة
3. طباعة الصورة الحقيقية والمعاد بناؤها

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_test = df[image_number]
    x_test_1 = x_test.reshape((1, 32*32))
    
    ## Part 2: Feed the model with the unseen image, encode/decode the image
    with tf.Session() as sess:     
        sess.run(tf.global_variables_initializer()) 
        sess.run(iter.initializer, feed_dict={x: x_test_1,
                                      batch_size: 1})
    ## Part 3:  Print the real and reconstructed image
      # Restore variables from disk.
        saver.restore(sess, "./model.ckpt")  
        print("Model restored.")
      # Reconstruct image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = fig.add_subplot(122)
        plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
        plt.tight_layout()
        fig = plt.gcf()

الآن بعد أن تم تعريف وظيفة التقييم، يمكنك إلقاء نظرة على الصورة رقم ثلاثة عشر المعاد بناؤها

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

ملخص

• الغرض الأساسي من جهاز التشفير التلقائي هو ضغط بيانات الإدخال، ثم فك ضغطها إلى مخرجات تشبه إلى حد كبير البيانات الأصلية.
• هندسة المشفر التلقائي متماثلة مع طبقة محورية تسمى الطبقة المركزية.
• يمكنك إنشاء برنامج التشفير التلقائي باستخدام:

جزئي: لإنشاء الطبقات الكثيفة بالإعداد النموذجي:

  	tf.layers.dense,                         
  	activation=tf.nn.elu,                         
  	kernel_initializer=xav_init,                         
  	kernel_regularizer=l2_regularizer

طبقة كثيفة ():لضرب المصفوفة

• يمكنك تحديد وظيفة الخسارة والتحسين باستخدام:

loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

• قم بتشغيل جلسة أخيرة لتدريب النموذج.