การเสริมข้อมูลรูปภาพเพื่อการเรียนรู้เชิงลึก

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

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

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

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

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

ประเภทของการเสริมข้อมูลรูปภาพ

การเพิ่มรูปภาพมีหลายรูปแบบ ต่อไปนี้เป็นรูปแบบทั่วไปบางส่วน ได้แก่ การเลื่อนแนวตั้ง การเลื่อนแนวนอน การพลิกแนวตั้ง การพลิกแนวนอน การหมุน การปรับความสว่าง และการซูมเข้า/ออก

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

เมื่อติดตั้ง Anaconda และ TensorFlow แล้ว ให้สร้าง Jupyter Notebook ใหม่

กะแนวตั้ง

เทคนิคเสริมภาพแรกที่อยากนำเสนอคือ กะแนวตั้ง. กะแนวตั้ง เลื่อนภาพในแนวตั้งขึ้นหรือลงแบบสุ่ม สำหรับตัวอย่างนี้ ฉันจะใช้รูปภาพชื่อ 747.jpgซึ่งอยู่ในโฟลเดอร์เดียวกับ Jupyter Notebook ของฉัน

ข้อมูลโค้ดต่อไปนี้ใช้ ImageDataGenerator class ใน Keras เพื่อเลื่อนภาพในแนวตั้ง

พื้นที่ ImageDataGenerator คลาสจาก Keras สร้างชุดข้อมูลรูปภาพพร้อมการเพิ่มข้อมูลตามเวลาจริง

#---นำเข้าโมดูล---
นำเข้า numpy เป็น np
นำเข้า matplotlib.pyplot เป็น pltจาก tensorflow.keras.preprocessing.image นำเข้า load_img
จาก tensorflow.keras.preprocessing.image นำเข้า img_to_array
จาก tensorflow.keras.preprocessing.image นำเข้า ImageDataGenerator#---โหลดภาพ---
image_filename = '747.jpg'
img = load_img (ชื่อไฟล์ภาพ)#---แปลงภาพเป็นอาร์เรย์ 3 มิติ---
image_data = img_to_array(img)#--- แปลงเป็นอาร์เรย์ 4 มิติของ 1 องค์ประกอบของอาร์เรย์ 3 มิติที่เป็นตัวแทน
# รูปภาพ---
images_data = np.expand_dims(image_data, แกน=0)#---สร้างเครื่องมือสร้างข้อมูลรูปภาพ---
ดาต้าเจน = ImageDataGenerator(width_shift_range=0.2)#---เตรียมตัววนซ้ำ flow() ใช้ในอาร์เรย์ 4D และส่งคืน 
# iterator ที่มีชุดของภาพ ---
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 5
คอลัมน์ = 4#---พล็อต 5 แถว 4 คอลัมน์---
รูป, แกน = plt.subplots (แถว, คอลัมน์)สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
#--- รับภาพถัดไปในชุด (หนึ่งภาพตั้งแต่ชุด 
# ขนาดคือ 1)---
image_batch = train_generator.next ()
#---แปลงเป็นจำนวนเต็มที่ไม่ได้ลงนามสำหรับการดู---
รูปภาพ = image_batch[0].astype('uint8')        #---แสดงภาพ---
แกน[r,c].imshow(ภาพ)#---กำหนดขนาดของรูป---
รูป.set_size_inches(15,10)

ข้อมูลโค้ดด้านบนสร้างผลลัพธ์ต่อไปนี้:

ดังที่คุณเห็นจากผลลัพธ์ด้านบน ทุกครั้งที่คุณเรียกใช้ next() วิธีการจาก train_generator วัตถุ คุณจะได้ภาพที่มีการเปลี่ยนแปลงเล็กน้อย ในข้อมูลโค้ดด้านบน รูปภาพใหม่ที่เลื่อนไป 20% ตามความสูงของรูปภาพเดิมจะถูกส่งกลับทุกครั้งที่คุณเรียกใช้ next() วิธี:

ดาต้าเจน = ImageDataGenerator(width_shift_range=0.2)

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

โปรดทราบว่า next() เมธอดจะส่งคืนรูปภาพที่เติมหลายครั้งเท่าที่คุณต้องการ ในข้อมูลโค้ดด้านบน เราเรียกว่า 20 ครั้ง (5 แถวคูณ 4 คอลัมน์)

กะแนวนอน

ตอนนี้คุณสามารถลองเลื่อนภาพในแนวนอนโดยใช้ปุ่ม height_shift_range พารามิเตอร์:

ดาต้าเจน = ImageDataGenerator(ความสูง_กะระยะ_ช่วง=0.2)
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 5
คอลัมน์ = 4รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

ข้อมูลโค้ดด้านบนสร้างผลลัพธ์ต่อไปนี้:

พลิกแนวนอน

บางครั้งก็สมเหตุสมผลที่จะพลิกภาพในแนวนอน ในกรณีของเครื่องบิน ด้านหน้าของเครื่องบินอาจหันไปทางซ้ายหรือขวา:

ดาต้าเจน = ImageDataGenerator(แนวนอน_พลิก=จริง)
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 2
คอลัมน์ = 2รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):        
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

สำหรับข้อมูลโค้ดด้านบน การสร้างภาพสี่ภาพก็เพียงพอแล้ว เนื่องจากด้านหน้าของเครื่องบินอาจหันไปทางซ้ายหรือขวา:

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

พลิกแนวตั้ง

เช่นเดียวกับการพลิกแนวนอน คุณอาจทำการพลิกแนวตั้งได้เช่นกัน:

ดาต้าเจน = ImageDataGenerator(vertical_flip=จริง)
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 2
คอลัมน์ = 2รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

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

การหมุน

การหมุนตามชื่อหมายถึงการหมุนภาพของคุณ ซึ่งจะเป็นประโยชน์อย่างมากสำหรับภาพเครื่องบินของเรา ข้อมูลโค้ดต่อไปนี้จะสุ่มหมุนภาพได้ถึง 50 องศา:

ดาต้าเจน = ImageDataGenerator(การหมุน_ช่วง=50)
train_generator = datagen.flow (ภาพ_ข้อมูล)แถว = 5
คอลัมน์ = 4รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

ด้วยการหมุน เอาต์พุตจะแสดงเครื่องบินในตำแหน่งต่างๆ — จำลองตำแหน่งการบินขึ้นและลง:

ความสว่าง

เทคนิคเสริมอีกอย่างคือการปรับความสว่างของภาพ ข้อมูลโค้ดต่อไปนี้ตั้งค่าช่วงของค่าการเลื่อนความสว่าง:

ดาต้าเจน = ImageDataGenerator(ความสว่าง_ช่วง=[0.15,2.0])
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 5
คอลัมน์ = 4รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

เอาต์พุตประกอบด้วยชุดรูปภาพที่มีความสว่างต่างกัน:

ซูม

คุณยังสามารถซูมภาพเข้าหรือออก:

ดาต้าเจน = ImageDataGenerator(ซูม_ช่วง=[5,0.5])
train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 5
คอลัมน์ = 4รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

ผลลัพธ์จะแสดงภาพในอัตราส่วนการซูมต่างๆ:

โปรดทราบว่าการซูมภาพจะเปลี่ยนอัตราส่วนของภาพ

รวมทุกการเสริมดวง

แน่นอน เทคนิคการเสริมต่าง ๆ ทั้งหมดที่ฉันได้พูดถึงไปสามารถรวมกันได้:

ดาต้าเจน = ImageDataGenerator(width_shift_range=0.2,
height_shift_range=0.2,
แนวนอน_พลิก=จริง
การหมุน_ช่วง=50,
ความสว่าง_ช่วง=[0.15,2.0],
ซูม_ช่วง=[5,0.5])train_generator = datagen.flow (รูปภาพ_ข้อมูล, ชุด_ขนาด = 1)แถว = 8
คอลัมน์ = 8รูป, แกน = plt.subplots (แถว, คอลัมน์)
สำหรับ r ในช่วง (แถว):
สำหรับ c ในช่วง (คอลัมน์):
image_batch = train_generator.next ()
รูปภาพ = image_batch[0].astype('uint8')
แกน[r,c].imshow(ภาพ)รูป.set_size_inches(15,10)

โปรดทราบว่าฉันได้ละเว้นการพลิกแนวตั้งเนื่องจากไม่สมเหตุสมผลสำหรับตัวอย่างของเรา

ตอนนี้ผลลัพธ์จะแสดงภาพที่มีการใช้การเสริมต่างๆ:

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

ผลไม้
|__กล้วย
|__กล้วย1.jpg
|__กล้วย2.jpg
|__กล้วย3.jpg
-
|__ทุเรียน
|__ทุเรียน1.jpg
|__ทุเรียน2.jpg
|__ทุเรียน3.jpg
-
|__ส้ม
|__orange1.jpg
|__orange2.jpg
|__orange3.jpg
-
|__สตรอเบอรี่
|__สตรอเบอร์รี่1.jpg
|__สตรอเบอร์รี่2.jpg
|__สตรอเบอร์รี่3.jpg
-

แต่ละโฟลเดอร์ย่อยประกอบด้วยชุดของรูปภาพ ตัวอย่างเช่น, กล้วย โฟลเดอร์มีรูปภาพจำนวนหนึ่งชื่อ กล้วย1.jpg, กล้วย2.jpgและอื่น ๆ ชื่อของโฟลเดอร์ย่อยจะทำหน้าที่เป็นป้ายกำกับสำหรับรูปภาพต่างๆ ซึ่งหมายความว่าไฟล์ทั้งหมดภายใต้ กล้วย โฟลเดอร์มีรูปภาพของกล้วยและอื่นๆ

ในการโหลดชุดรูปภาพจากดิสก์ ตอนนี้คุณเรียก flow_from_directory() วิธีการของ ImageDataGenerator ตัวอย่างแทนการ flow() วิธี (สำหรับการโหลดภาพจากหน่วยความจำ):

train_datagen = ImageDataGenerator(
แนวนอน_พลิก=จริง
vertical_flip=จริง
การหมุน_ช่วง=50,
)batch_size=8รถไฟ_เครื่องกำเนิดไฟฟ้า = train_datagen.flow_from_directory(
'./ผลไม้',
target_size=(224,224) 
color_mode='rgb', 
ชุด_ขนาด=ชุด_ขนาด, 
class_mode='หมวดหมู่' 
สุ่ม=จริง)

สังเกตว่าตอนนี้ฉันตั้งค่า batch_size ถึง 8 คุณจะเห็นการใช้ขนาดแบทช์ในไม่ช้า

การใช้ iterator ที่ส่งคืน ฉันสามารถหาฉลากของผลไม้ต่างๆ (กล้วย ทุเรียน ส้ม และสตรอเบอร์รี่):

class_dictionary = train_generator.class_indices#---สร้างพจนานุกรมของป้ายกำกับ---
class_dictionary = { ค่า:คีย์สำหรับคีย์,ค่าใน
class_dictionary.items()}#---แปลงพจนานุกรมเป็นรายการ---
class_list = [ค่าสำหรับ _ ค่าใน class_dictionary.items()]
พิมพ์ (class_list)

คุณจะเห็นผลลัพธ์ต่อไปนี้:

พบ 54 ภาพ จาก 4 คลาส
['กล้วย' 'ทุเรียน' 'ส้ม' 'สตรอเบอร์รี่']

รวมแล้วมีทั้งหมด 54 ภาพใน 4 โฟลเดอร์ อีกทั้ง class_list ตัวแปรประกอบด้วยรายการผลไม้

ตอนนี้ฉันจะพิมพ์ชุดภาพเสริมที่สร้างขึ้นโดย ImageDataGenerator ระดับ. ฉันจะตั้งค่าแถวเป็น 10 โดยพลการ และสำหรับแต่ละแถว ฉันต้องการพิมพ์ชุดภาพที่ส่งคืน (ซึ่งในตัวอย่างนี้คือ 8):

แถว = 10มะเดื่อ แกน = plt.subplots(แถว,batch_size)สำหรับ r ในช่วง (แถว):    
#---รับภาพชุดเสริม---
image_batch = train_generator.next ()        #---รับจำนวนภาพคืน---
images_count = image_batch[0].รูปร่าง[0]
สำหรับ c ในช่วง (images_count):
#---แปลงเป็นจำนวนเต็มที่ไม่ได้ลงนามสำหรับการดู---
รูปภาพ = image_batch[0][c].astype('uint8')
#---แสดงภาพ---
แกน[r,c].imshow(ภาพ)        #---แสดงป้ายกำกับของรูปภาพ---
แกน[r,c].title.set_text(
class_list[np.argmax(รูปภาพ_ชุด[1] [c])])        #---ซ่อนเครื่องหมาย x และ y---
แกน[r,c].set_xticks([])
แกน[r,c].set_yticks([])รูป.set_size_inches(15,18)

ตั้งแต่ batch_size ตอนนี้ตั้งค่าเป็น 8 (และไม่ใช่ 1 อีกต่อไป), the train_generator.next() เมธอดจะคืนค่าให้คุณ ชุด แปดภาพที่เพิ่มขึ้นทุกครั้งที่คุณเรียกใช้ จำนวนภาพที่ส่งคืนขึ้นอยู่กับ batch_size ที่คุณตั้งไว้ก่อนหน้าใน flow_from_directory() วิธี:

train_generator = train_datagen.flow_from_directory (
'./ผลไม้',
target_size=(224,224) 
color_mode='rgb', 
    ชุด_ขนาด=ชุด_ขนาด,        #batch_size = 8
class_mode='หมวดหมู่' 
สุ่ม=จริง)

ค่าของ image_batch ตัวแปร (ส่งคืนโดย next() method) เป็น tuple ของสององค์ประกอบ:

• องค์ประกอบแรก (image_batch[0]) เป็นอาร์เรย์ของ ชุด_ขนาด ภาพ (อาร์เรย์ 4D)
• องค์ประกอบที่สอง (image_batch[1]) มีป้ายกำกับสำหรับรูปภาพ

ข้อมูลโค้ดด้านบนสร้างผลลัพธ์ต่อไปนี้:

โปรดสังเกตว่าในแถวที่เจ็ด มีแผนภูมิว่างสองแผนภูมิที่ไม่มีรูปภาพ จำได้ว่ามีทั้งหมด 54 ภาพในชุดภาพ และเนื่องจากแต่ละชุดส่งคืน 8 ภาพ (ต่อแถว) เจ็ดแถวแรกจะแสดงภาพทั้งหมด 54 ภาพ (8×6 + 6) รูปต่อไปนี้ทำให้ชัดเจน:

โปรดทราบว่าคุณสามารถตั้งค่า rows ไปที่หมายเลขใด ๆ และ ImageDataGenerator ชั้นเรียนจะสร้างภาพเพิ่มเติมใหม่ให้คุณต่อไป

การสร้างแบบจำลองโดยใช้การเรียนรู้แบบถ่ายโอน

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

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

จาก tensorflow.keras.models นำเข้าโมเดล
จาก tensorflow.keras.applications นำเข้า VGG16
จาก tensorflow.keras.layers นำเข้า Dense, GlobalAveragePooling2D#---จำนวนผลไม้---
NO_CLASSES = สูงสุด (train_generator.class_indices.values ​​()) + 1#---โหลดโมเดล VGG16 เป็นโมเดลพื้นฐานสำหรับการฝึก---
base_model = VGG16(include_top=False, input_shape=(224, 224, 3))#---เพิ่มเลเยอร์ของเราเอง---
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024,activation='relu')(x) # เพิ่มเลเยอร์ที่หนาแน่น ดังนั้น
#ที่นางแบบทำได้ 
# เรียนรู้ที่ซับซ้อนมากขึ้น 
#ฟังก์ชั่นและ 
#จำแนกให้ดียิ่งขึ้น 
# ผลลัพธ์.
x = หนาแน่น (1024, การเปิดใช้งาน = 'relu') (x) # ชั้นหนาแน่น 2
x = หนาแน่น (512, การเปิดใช้งาน = 'relu') (x) # ชั้นหนาแน่น 3preds = หนาแน่น (NO_CLASSES,
activation='softmax')(x) # ชั้นสุดท้ายด้วย 
#การเปิดใช้งานซอฟต์แม็กซ์#---สร้างโมเดลใหม่ด้วยต้นฉบับของโมเดลพื้นฐาน 
# อินพุตและเอาต์พุตของโมเดลใหม่ ---
model = Model(อินพุต = base_model.input, เอาท์พุต = preds)#---ไม่ฝึก 19 เลเยอร์แรก - 0..18---
สำหรับเลเยอร์ใน model.layers[:19]:
layer.trainable=เท็จ#---ฝึกเลเยอร์ที่เหลือ - 19 เป็นต้นไป---
สำหรับเลเยอร์ใน model.layers[19:]:
layer.trainable=จริง
#---ประกอบโมเดล---    
model.compile(เครื่องมือเพิ่มประสิทธิภาพ='อดัม'
การสูญเสีย = 'categorical_crossentropy',
เมตริก=['ความแม่นยำ'])

การอธิบายว่าการเรียนรู้แบบถ่ายโอนทำงานอย่างไรนั้นอยู่นอกเหนือขอบเขตของบทความนี้ ฉันจะทิ้งไว้สำหรับบทความอื่น

การใช้ภาพที่สร้างขึ้นสำหรับการฝึกอบรม

หากต้องการใช้รูปภาพเสริมสำหรับการฝึกอบรม ให้ผ่าน train_generator เข้าไปใน fit() วิธีการของแบบจำลอง:

#---ฝึกโมเดล---
step_size_train = train_generator.n // train_generator.batch_sizeรุ่น.พอดี(รถไฟ_เครื่องกำเนิดไฟฟ้า,
          step_per_epoch=step_size_train
ยุค=15)

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

จำนวนภาพ / ขนาดแบทช์

ในตัวอย่างของเรา เรามีทั้งหมด 54 ภาพ และในแต่ละยุคนั้น ImageDataGenerator คลาสจะเปลี่ยนภาพทั้งหมด 54 ภาพสำหรับการฝึกอบรม ในแต่ละยุคโมเดลจะได้รูปแบบที่แตกต่างกันของภาพ หากคุณมี 15 ยุค รูปภาพทั้งหมด 15x54 รูปแบบจะถูกสร้างขึ้นและป้อนเข้าสู่โมเดลการฝึก

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

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

การเพิ่มข้อมูลภาพสำหรับการเรียนรู้เชิงลึกเผยแพร่ซ้ำจากแหล่งที่มา

<!–

->