ตัวเข้ารหัสอัตโนมัติใน TensorFlow พร้อมตัวอย่าง

Autoencoder ใน Deep Learning คืออะไร?

An ตัวเข้ารหัสอัตโนมัติ เป็นเครื่องมือสำหรับการเรียนรู้การเข้ารหัสข้อมูลอย่างมีประสิทธิภาพในลักษณะที่ไม่มีผู้ดูแล เป็นโครงข่ายประสาทเทียมประเภทหนึ่งที่ช่วยให้คุณเรียนรู้การแทนชุดข้อมูลสำหรับการลดขนาดโดยการฝึกโครงข่ายประสาทเทียมให้เพิกเฉยต่อสัญญาณรบกวน มันเป็นเครื่องมือที่ยอดเยี่ยมสำหรับการสร้างอินพุตใหม่

พูดง่ายๆ ก็คือ เครื่องจักรจะถ่ายภาพ และสามารถสร้างภาพที่เกี่ยวข้องกันอย่างใกล้ชิดได้ อินพุตในโครงข่ายประสาทเทียมชนิดนี้ไม่มีป้ายกำกับ หมายความว่าเครือข่ายสามารถเรียนรู้ได้โดยไม่ต้องมีการควบคุมดูแล แม่นยำยิ่งขึ้น อินพุตจะถูกเข้ารหัสโดยเครือข่ายเพื่อเน้นเฉพาะคุณลักษณะที่สำคัญที่สุดเท่านั้น นี่เป็นหนึ่งในเหตุผลที่โปรแกรมเข้ารหัสอัตโนมัติได้รับความนิยมในการลดขนาด นอกจากนี้ยังสามารถใช้ตัวเข้ารหัสอัตโนมัติเพื่อสร้างได้ รูปแบบการเรียนรู้เชิงกำเนิด- ตัวอย่างเช่น โครงข่ายประสาทเทียมสามารถฝึกด้วยชุดใบหน้า จากนั้นจึงสร้างใบหน้าใหม่ได้

โปรแกรมเข้ารหัสอัตโนมัติ TensorFlow ทำงานอย่างไร

วัตถุประสงค์ของโปรแกรมเข้ารหัสอัตโนมัติคือเพื่อสร้างการประมาณอินพุตโดยเน้นไปที่คุณสมบัติที่จำเป็นเท่านั้น คุณอาจคิดว่าทำไมไม่เพียงแค่เรียนรู้วิธีคัดลอกและวางอินพุตเพื่อสร้างเอาต์พุตเท่านั้น ที่จริงแล้ว โปรแกรมเข้ารหัสอัตโนมัติคือชุดของข้อจำกัดที่บังคับให้เครือข่ายเรียนรู้วิธีใหม่ๆ ในการแสดงข้อมูล แตกต่างจากการคัดลอกเอาต์พุตเพียงอย่างเดียว

ตัวเข้ารหัสอัตโนมัติทั่วไปถูกกำหนดด้วยอินพุต การแสดงภายใน และเอาต์พุต (การประมาณอินพุต) การเรียนรู้เกิดขึ้นในชั้นที่แนบไปกับการเป็นตัวแทนภายใน ในความเป็นจริง มีเลเยอร์สองบล็อกหลักซึ่งดูเหมือนโครงข่ายประสาทเทียมแบบดั้งเดิม ความแตกต่างเล็กน้อยคือเลเยอร์ที่มีเอาต์พุตจะต้องเท่ากับอินพุต ในภาพด้านล่าง อินพุตดั้งเดิมจะเข้าสู่บล็อกแรกที่เรียกว่า encoder- การแสดงภายในนี้จะบีบอัด (ลด) ขนาดของอินพุต ในบล็อกที่สองจะมีการสร้างอินพุตขึ้นมาใหม่ นี่คือขั้นตอนการถอดรหัส

แบบจำลองจะอัปเดตน้ำหนักโดยลดฟังก์ชันการสูญเสียให้เหลือน้อยที่สุด โมเดลจะถูกลงโทษหากเอาต์พุตของการสร้างใหม่แตกต่างจากอินพุต

โดยเป็นรูปธรรม ลองจินตนาการถึงรูปภาพที่มีขนาด 50×50 (เช่น 250 พิกเซล) และโครงข่ายประสาทเทียมที่มีเลเยอร์ที่ซ่อนอยู่เพียงเลเยอร์เดียวที่ประกอบด้วยเซลล์ประสาทหนึ่งร้อยเซลล์ การเรียนรู้เสร็จสิ้นบนแผนผังคุณลักษณะซึ่งเล็กกว่าอินพุตสองเท่า หมายความว่าเครือข่ายจำเป็นต้องหาวิธีสร้างพิกเซล 250 ขึ้นมาใหม่โดยมีเพียงเวกเตอร์ของเซลล์ประสาทเท่ากับ 100

ตัวอย่างการเข้ารหัสอัตโนมัติแบบซ้อน

ในบทช่วยสอน Autoencoder นี้ คุณจะได้เรียนรู้วิธีใช้ autoencoder แบบซ้อน โครงสร้างจะคล้ายกับเครือข่ายประสาทเทียมแบบเดิม อินพุตจะถูกส่งไปยังเลเยอร์ที่ซ่อนอยู่เพื่อบีบอัดหรือลดขนาด จากนั้นจึงไปถึงเลเยอร์ที่สร้างขึ้นใหม่ เป้าหมายคือสร้างภาพเอาต์พุตที่ใกล้เคียงกับต้นฉบับมากที่สุด โมเดลจะต้องเรียนรู้วิธีที่จะบรรลุภารกิจภายใต้ข้อจำกัดชุดหนึ่ง นั่นคือ ด้วยมิติที่ต่ำกว่า

ในปัจจุบัน Autoencoders เข้ามา การเรียนรู้ลึก ๆ ส่วนใหญ่จะใช้เพื่อลบล้างภาพ ลองนึกภาพภาพที่มีรอยขีดข่วน มนุษย์ยังสามารถจดจำเนื้อหาได้ แนวคิดในการลดสัญญาณรบกวนอัตโนมัติคือการเพิ่มจุดรบกวนให้กับภาพเพื่อบังคับให้เครือข่ายเรียนรู้รูปแบบเบื้องหลังข้อมูล

กลุ่มที่มีประโยชน์อื่นๆ ของ Autoencoder Deep Learning คือตัวเข้ารหัสอัตโนมัติแบบแปรผัน เครือข่ายประเภทนี้สามารถสร้างภาพใหม่ได้ ลองนึกภาพคุณฝึกเครือข่ายด้วยภาพลักษณ์ของผู้ชาย เครือข่ายดังกล่าวสามารถสร้างใบหน้าใหม่ได้

วิธีสร้างตัวเข้ารหัสอัตโนมัติด้วย TensorFlow

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีสร้างตัวเข้ารหัสอัตโนมัติแบบเรียงซ้อนเพื่อสร้างรูปภาพขึ้นมาใหม่

คุณจะใช้ ชุดข้อมูล CIFAR-10 ซึ่งมีภาพสีขนาด 60000×32 จำนวน 32 ภาพ ชุดข้อมูลตัวเข้ารหัสอัตโนมัติถูกแบ่งระหว่างรูปภาพ 50000 รูปสำหรับการฝึกและ 10000 รูปสำหรับการทดสอบ มีมากถึงสิบคลาส:

เครื่องบิน
Automobile
นก
แคท
กวาง
สุนัข
กบ
ม้า
เรือ
รถบรรทุก

คุณต้องดาวน์โหลดภาพใน URL นี้ https://www.cs.toronto.edu/~kriz/cifar.html แล้วแตกไฟล์ออก โฟลเดอร์ for-10-batches-py มีข้อมูลห้าชุด โดยแต่ละชุดมีรูปภาพ 10000 รูปตามลำดับแบบสุ่ม

ก่อนที่คุณจะสร้างและฝึกโมเดลของคุณ คุณต้องใช้การประมวลผลข้อมูลบางอย่างก่อน คุณจะดำเนินการดังต่อไปนี้:

นำเข้าข้อมูล
แปลงข้อมูลเป็นรูปแบบขาวดำ
ผนวกแบทช์ทั้งหมด
สร้างชุดข้อมูลการฝึกอบรม
สร้างโปรแกรมสร้างภาพ

การประมวลผลภาพล่วงหน้า

ขั้นตอนที่ 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) สร้างชุดข้อมูลการฝึกอบรม

เพื่อให้การฝึกทำได้เร็วและง่ายขึ้น คุณจะต้องฝึกโมเดลที่มีรูปม้าเท่านั้น ม้าเป็นชั้นที่ 10 ในข้อมูลฉลาก ตามที่กล่าวไว้ในเอกสารประกอบของชุดข้อมูล CIFAR-5000 แต่ละคลาสจะมีอิมเมจ 5.000 รูป คุณสามารถพิมพ์รูปร่างของข้อมูลเพื่อยืนยันว่ามีรูปภาพ 1024 ภาพ จำนวน XNUMX คอลัมน์ ดังแสดงด้านล่าง 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 เพื่อฟื้นฟูจิตใจของคุณ คุณต้องใช้:

จาก_tensor_slices
ทำซ้ำ
ชุด

รหัสเต็มในการสร้างชุดข้อมูลคือ:

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

สังเกตว่า x คือตัวแทนที่มีรูปร่างดังต่อไปนี้:

[ไม่มี,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 เซลล์ บล็อกตัวถอดรหัสมีความสมมาตรกับตัวเข้ารหัส คุณสามารถเห็นภาพเครือข่ายได้ในภาพด้านล่าง โปรดทราบว่าคุณสามารถเปลี่ยนค่าของเลเยอร์ที่ซ่อนอยู่และเลเยอร์กลางได้

การสร้างโปรแกรมเข้ารหัสอัตโนมัตินั้นคล้ายคลึงกับโมเดลการเรียนรู้เชิงลึกอื่นๆ มาก

คุณจะสร้างแบบจำลองโดยทำตามขั้นตอนเหล่านี้:

กำหนดพารามิเตอร์
กำหนดเลเยอร์
กำหนดสถาปัตยกรรม
กำหนดการเพิ่มประสิทธิภาพ
เรียกใช้โมเดล
ประเมินแบบจำลอง

ในส่วนก่อนหน้านี้ คุณได้เรียนรู้วิธีสร้างไปป์ไลน์เพื่อป้อนโมเดลแล้ว ดังนั้นจึงไม่จำเป็นต้องสร้างชุดข้อมูลอีกครั้ง คุณจะสร้างตัวเข้ารหัสอัตโนมัติที่มีสี่เลเยอร์ คุณใช้การกำหนดค่าเริ่มต้นของซาเวียร์ นี่เป็นเทคนิคในการตั้งค่าน้ำหนักเริ่มต้นให้เท่ากับความแปรปรวนของทั้งอินพุตและเอาต์พุต สุดท้าย คุณใช้ฟังก์ชันการเปิดใช้งาน elu คุณทำให้ฟังก์ชันการสูญเสียเป็นปกติด้วย L2 Regularizer

ขั้นตอน 1) กำหนดพารามิเตอร์

ขั้นตอนแรกหมายถึงการกำหนดจำนวนเซลล์ประสาทในแต่ละชั้น อัตราการเรียนรู้ และไฮเปอร์พารามิเตอร์ของเรกูลาร์ไลเซอร์

ก่อนหน้านั้น คุณต้องนำเข้าฟังก์ชันบางส่วน วิธีนี้เป็นวิธีที่ดีกว่าในการกำหนดพารามิเตอร์ของเลเยอร์ที่หนาแน่น โค้ดด้านล่างนี้จะกำหนดค่าของสถาปัตยกรรม autoencoder ดังที่ได้ระบุไว้ก่อนหน้านี้ autoencoder มีสองชั้น โดยมีนิวรอน 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 จากตัวประมาณค่า ในเครื่องมือประมาณค่าเดียวกัน คุณสามารถเพิ่ม Regularizer ด้วย 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) กำหนดเลเยอร์

ตั้งค่าพารามิเตอร์ทั้งหมดของชั้นหนาแน่นแล้ว คุณสามารถแพ็คทุกอย่างในตัวแปรหนาแน่น_ชั้นได้โดยใช้วัตถุบางส่วน Dens_layer ซึ่งใช้การเปิดใช้งาน 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 เป็นต้น การคูณเมทริกซ์จะเหมือนกันสำหรับแต่ละเลเยอร์เนื่องจากคุณใช้ฟังก์ชันการเปิดใช้งานเดียวกัน โปรดทราบว่าเลเยอร์สุดท้าย ซึ่งคือเอาต์พุต ไม่ได้ใช้ฟังก์ชันการเปิดใช้งาน ซึ่งสมเหตุสมผลเพราะนี่คืออินพุตที่สร้างขึ้นใหม่

## 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) กำหนดการเพิ่มประสิทธิภาพ

ขั้นตอนสุดท้ายคือการสร้างเครื่องมือเพิ่มประสิทธิภาพ คุณใช้ Mean Square Error เป็นฟังก์ชันการสูญเสีย หากคุณจำบทช่วยสอนเกี่ยวกับการถดถอยเชิงเส้นได้ คุณจะรู้ว่า MSE ได้รับการคำนวณด้วยความแตกต่างระหว่างผลลัพธ์ที่คาดการณ์ไว้กับป้ายกำกับจริง ในที่นี้ ป้ายกำกับคือคุณลักษณะเนื่องจากโมเดลพยายามสร้างอินพุตใหม่ ดังนั้น คุณจึงต้องการค่าเฉลี่ยผลรวมของผลต่างของกำลังสองระหว่างผลลัพธ์ที่คาดการณ์ไว้กับข้อมูลเข้า ด้วย TensorFlow คุณสามารถเขียนโค้ดฟังก์ชันการสูญเสียได้ดังนี้:

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

จากนั้นคุณจะต้องปรับฟังก์ชันการสูญเสียให้เหมาะสม คุณใช้ Adam Optimizer เพื่อคำนวณการไล่ระดับสี หน้าที่วัตถุประสงค์คือการลดการสูญเสียให้เหลือน้อยที่สุด

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

การตั้งค่าอื่นก่อนการฝึกโมเดล คุณต้องการใช้ขนาดแบตช์ 150 ซึ่งก็คือป้อนไปป์ไลน์ด้วยรูปภาพ 150 รูปในแต่ละการวนซ้ำ คุณต้องคำนวณจำนวนการวนซ้ำด้วยตนเอง นี่เป็นเรื่องเล็กน้อยที่ต้องทำ:

หากคุณต้องการส่งภาพ 150 ภาพในแต่ละครั้งและคุณทราบว่ามีภาพ 5000 ภาพในชุดข้อมูล จำนวนการวนซ้ำจะเท่ากับ ใน Python คุณสามารถรันโค้ดต่อไปนี้และตรวจสอบให้แน่ใจว่าผลลัพธ์คือ 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) ประเมินแบบจำลอง

เมื่อคุณได้ฝึกฝนโมเดลของคุณแล้ว ก็ถึงเวลาประเมินโมเดล คุณต้องนำเข้าการทดสอบ sert จากไฟล์ /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: นำเข้าข้อมูลการทดสอบ
รูปภาพ_หมายเลข: ระบุรูปภาพที่จะนำเข้า

ฟังก์ชั่นแบ่งออกเป็นสามส่วน:

ปรับรูปร่างรูปภาพให้เป็นมิติที่ถูกต้อง เช่น 1, 1024
ป้อนโมเดลด้วยภาพที่มองไม่เห็น เข้ารหัส/ถอดรหัสรูปภาพ
พิมพ์ภาพจริงและสร้างใหม่

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

เมื่อกำหนดฟังก์ชันการประเมินแล้ว คุณสามารถดูรูปภาพที่สร้างขึ้นใหม่หมายเลข 13 ได้

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)

เรียกใช้เซสชันครั้งล่าสุดเพื่อฝึกโมเดล

ที่คุณอาจชอบ: