แนวทางการเรียนรู้เชิงลึกหลายแบบจำลองสำหรับการทำความเข้าใจรูปภาพและข้อความ
ด้วยความก้าวหน้าของ "การเรียนรู้เชิงลึก" เช่น "เครือข่ายประสาทเทียม" (เช่น "ConvNet") [1] "คอมพิวเตอร์วิทัศน์" จึงกลายเป็นหัวข้อการวิจัยทางวิทยาศาสตร์ที่ร้อนแรงอีกครั้ง เป้าหมายหลักประการหนึ่งของคอมพิวเตอร์วิทัศน์ในปัจจุบันคือการใช้การเรียนรู้ของเครื่อง (โดยเฉพาะการเรียนรู้เชิงลึก) เพื่อฝึกคอมพิวเตอร์ให้ได้รับความเข้าใจในระดับมนุษย์จากภาพดิจิทัล ข้อความ หรือวิดีโอ
ด้วยการใช้งานอย่างแพร่หลาย ConvNet จึงกลายเป็นโมเดลสำหรับการจดจำรูปภาพโดยพฤตินัย ตามที่อธิบายไว้ใน [1] โดยทั่วไป มีสองวิธีในการใช้ ConvNet สำหรับคอมพิวเตอร์วิทัศน์:
- การฝึกอบรมโมเดล ConvNet ใหม่ตั้งแต่เริ่มต้น
- การใช้ การถ่ายโอนการเรียนรู้ นั่นคือการใช้โมเดล ConvNet ที่ได้รับการฝึกอบรมล่วงหน้า
ดังที่แสดงในแผนภาพต่อไปนี้ โมเดล ConvNet ประกอบด้วยสองส่วน: convolutional base และ ลักษณนาม ที่เชื่อมต่อโดยสมบูรณ์
รูปที่ 1:สถานการณ์ทั่วไปของการเรียนรู้การถ่ายโอน ConvNet
การเรียนรู้การถ่ายโอน ConvNet สามารถแบ่งย่อยเพิ่มเติมได้เป็นสามวิธี:
- วิธีที่ 1: การแยกคุณสมบัติโดยไม่มีข้อโต้แย้งเกี่ยวกับรูปภาพ [1]
วิธีการนี้ใช้ฐานการบิดที่ได้รับการฝึกอบรมมาล่วงหน้าเพื่อแปลงรูปภาพใหม่ให้เป็นอาร์เรย์ เช่น อาร์เรย์ Numpy (สามารถบันทึกเป็นไฟล์ได้หากจำเป็น) ) ก่อน จากนั้นจึงใช้การแทนค่าอาร์เรย์ของรูปภาพในหน่วยความจำเพื่อฝึกโมเดลการจัดหมวดหมู่ใหม่ที่แยกจากกันด้วยน้ำหนักเริ่มต้นแบบสุ่ม - วิธีที่ 2: การแยกคุณลักษณะด้วยการโต้แย้งรูปภาพ [1]
วิธีการนี้จะสร้างโมเดลใหม่ที่มีฐาน Convolutional ที่ได้รับการฝึกไว้ล่วงหน้าเป็นเลเยอร์อินพุต หยุดน้ำหนักของฐาน Convolutional และสุดท้าย เพิ่มลักษณนามเอาต์พุตใหม่พร้อมน้ำหนักเริ่มต้นแบบสุ่ม - วิธีที่ 3: การปรับแบบละเอียด [1]
วิธีนี้ไม่ใช้ฐานการบิดที่ฝึกไว้ล่วงหน้าแบบแช่แข็งทั้งหมด ช่วยให้คลายการแช่แข็งชั้นบนสุดของฐาน Convolutional ที่ผ่านการฝึกอบรมมาแล้วแบบแช่แข็งได้ เพื่อให้ชั้นบนสุดที่ไม่แช่แข็งเหล่านั้นสามารถฝึกร่วมกับตัวแยกประเภทที่เชื่อมต่ออย่างสมบูรณ์ตัวใหม่ได้
วิธีที่ 2 ใช้ในบทความนี้สำหรับการเรียนรู้การถ่ายโอนแบบจำลองหลายอินพุต
แนวคิดหลักเบื้องหลังการเรียนรู้แบบถ่ายโอนสามารถใช้ได้ไม่เพียงแต่กับ ConvNet ที่มีการดูแลเท่านั้น แต่ยังรวมถึงอัลกอริธึมการเรียนรู้เชิงลึกอื่นๆ ด้วย เช่น โมเดล การฝังคำ ที่ไม่มีผู้ดูแลสำหรับการประมวลผลภาษาธรรมชาติ ("NLP")[4]
มีโมเดลการฝังคำที่ได้รับการฝึกล่วงหน้ายอดนิยมอยู่สองโมเดล: word2vec และ GloVe [3] เช่นเดียวกับโมเดล word2vec-keras ที่ใช้ใน [4] โมเดลการฝังคำที่ได้รับการฝึกอบรมล่วงหน้าเหล่านี้มักจะรวมกับอัลกอริธึมการเรียนรู้เชิงลึกที่ได้รับการดูแลอื่นๆ เช่น "โครงข่ายประสาทเทียมที่เกิดซ้ำ" (RNN) "LSTM" สำหรับ "NLP" เช่น การจำแนกข้อความ [4]
โมเดล ConvNet หรือโมเดล NLP (เช่น การรวมกันของคำที่ฝังด้วย LSTM) สามารถใช้แยกกันเพื่อแก้ไขปัญหาที่น่าสนใจมากมายในคอมพิวเตอร์วิทัศน์และ NLP ตามที่แสดงไว้ในบทความนี้ โมเดลประเภทต่างๆ เหล่านี้ยังสามารถนำมารวมกันได้หลายวิธี [1] เพื่อสร้างโมเดลที่มีประสิทธิภาพยิ่งขึ้นเพื่อจัดการกับปัญหาที่ท้าทายมากขึ้น เช่น “ระบบอัตโนมัติกระบวนการเคลมประกัน” ที่ไม่เพียงต้องการความสามารถในการจดจำภาพเท่านั้น แต่ยังรวมถึงความเข้าใจภาษาธรรมชาติ (เช่น ข้อความ) ด้วย
บทความนี้ใช้ชุดข้อมูลที่น่าสนใจแต่ท้าทายใน Kaggle "ความท้าทายในการเรียนรู้การเป็นตัวแทน: การเรียนรู้แบบหลายรูปแบบ" [2] เพื่อนำเสนอโมเดลการเรียนรู้การถ่ายโอนหลายอินพุตใหม่ที่รวมเอาโมเดลอินพุตสองโมเดลเข้ากับชั้นการจำแนกประเภทที่เชื่อมต่อกันอย่างสมบูรณ์สำหรับทั้งสอง การจดจำรูปภาพและการจดจำแท็กคำในเวลาเดียวกัน (ดูรูปที่ 2)
แนวคิดหลักเบื้องหลังโมเดลอินพุตหลายตัวใหม่คือการแปลปัญหาการจดจำรูปภาพและแท็กคำให้กลายเป็นปัญหาการจำแนกการเรียนรู้ของเครื่อง กล่าวคือ การกำหนดว่ารูปภาพที่กำหนดตรงกับชุดแท็กคำที่กำหนดหรือไม่ (0-ไม่ใช่ 1-ใช่)
1. การเตรียมข้อมูล
หลังจากที่ชุดข้อมูล Kaggle ของไฟล์รูปภาพและไฟล์แท็กคำ [2] ได้รับการดาวน์โหลดลงในเครื่องท้องถิ่นแล้ว โค้ดด้านล่างสามารถใช้เพื่อสร้างและสับเปลี่ยนรายการชื่อไฟล์รูปภาพและชื่อไฟล์แท็กคำที่เกี่ยวข้องได้ มีไฟล์รูปภาพ 100,000 ไฟล์และไฟล์แท็กคำที่เกี่ยวข้อง 100,000 ไฟล์ในชุดข้อมูลเพื่อวัตถุประสงค์ในการฝึกอบรม
original_dataset_dir = './multi_task_learning/data/ESPGame100k' base_dataset_dir = './multi_task_learning/data/ESPGame100k_small' original_label_path = original_dataset_dir + '/labels' original_label_files = [f for f in listdir(original_label_path) if isfile(join(original_label_path, f))] original_image_path = original_dataset_dir + '/thumbnails' original_image_files = [f for f in listdir(original_image_path) if isfile(join(original_image_path, f))] original_image_files = np.array(original_image_files) original_label_files = np.array(original_label_files) dataset_size = original_label_files.shape[0] perm = np.arange(dataset_size) np.random.shuffle(perm) original_image_files = original_image_files[perm] original_label_files = original_label_files[perm]
เพื่อฝึกโมเดลที่มีอินพุตหลายอินพุตใหม่บนแล็ปท็อปภายในระยะเวลาที่เหมาะสม (ไม่กี่ชั่วโมง) ฉันจึงสุ่มเลือกรูปภาพ 2,000 ภาพและไฟล์แท็กคำ 2,000 คำที่เกี่ยวข้องสำหรับการฝึกโมเดลสำหรับบทความนี้:
if not os.path.isdir(base_dataset_dir):
os.mkdir(base_dataset_dir)
small_label_path = os.path.join(base_dataset_dir, 'labels')
small_image_path = os.path.join(base_dataset_dir, 'thumbnails')
if not os.path.isdir(small_label_path):
os.mkdir(small_label_path)
if not os.path.isdir(small_image_path):
os.mkdir(small_image_path)
for fname in original_label_files[:2000]:
src = os.path.join(original_label_path, fname)
dst = os.path.join(small_label_path, fname)
shutil.copyfile(src, dst)
for fname in original_label_files[:2000]:
img_fname = fname[:-5]
src = os.path.join(original_image_path, img_fname)
dst = os.path.join(small_image_path, img_fname)
shutil.copyfile(src, dst)
โค้ดด้านล่างนี้คือการโหลดชื่อไฟล์แท็กรูปภาพ 2,000 ชื่อและแท็กคำ 2,000 แท็กที่เกี่ยวข้องลงใน Pandas DataFrame:
label_map = {'label_file' : [], 'word_tags' : []}
for fname in listdir(small_label_path):
f = join(small_label_path, fname)
if isfile(f):
f = open(f)
label_map['label_file'].append(fname)
line = f.read().splitlines()
label_map['word_tags'].append(line)
label_df = pd.DataFrame(label_map)
label_df.head()
เช่นเดียวกับ [4] ขั้นตอนการประมวลผลข้อมูลล่วงหน้าที่เป็นข้อความจะรวมอยู่ในสมุดบันทึก Jupyter [5] เพื่อดำเนินการประมวลผลข้อมูลล่วงหน้าขั้นต่ำ เช่น ลบคำหยุดและตัวเลข ในกรณีที่สร้างความแตกต่างที่มีนัยสำคัญ:
ตามที่อธิบายไว้ใน [4] ผลกระทบของการประมวลผลข้อมูลล่วงหน้าที่เป็นข้อความไม่มีนัยสำคัญ ดังนั้นแท็กคำดิบที่ไม่มีการประมวลผลล่วงหน้าจึงถูกนำมาใช้สำหรับการฝึกโมเดลในบทความนี้
2. สถาปัตยกรรมของการเรียนรู้แบบถ่ายโอนแบบจำลองหลายอินพุต
ดังที่แสดงในแผนภาพด้านล่าง โมเดลการเรียนรู้การถ่ายโอนหลายอินพุตใหม่ใช้โมเดล ConvNet ที่ได้รับการฝึกล่วงหน้า VGG16 สำหรับการรับและจัดการรูปภาพและโมเดล NLP ใหม่ (การผสมผสานระหว่างโมเดลการฝังคำที่ผ่านการฝึกอบรมมาแล้ว GloVe และ Keras LSTM ) สำหรับการรับและจัดการแท็กคำ โมเดลอินพุตทั้งสองนี้จะถูกรวมเข้าด้วยกันก่อนแล้วจึงรวมกับโมเดลการจำแนกเอาท์พุตที่เชื่อมต่ออย่างสมบูรณ์ซึ่งใช้ทั้งเอาท์พุตของโมเดลการจดจำรูปภาพและเอาท์พุตของโมเดล NLP เพื่อพิจารณาว่าคู่อินพุตของรูปภาพและชุดของแท็กคำนั้นหรือไม่ การแข่งขัน (0-ไม่, 1-ใช่)
รูปที่ 2: สถาปัตยกรรมของโมเดลการเรียนรู้เชิงลึกใหม่สำหรับโมเดลการเรียนรู้แบบหลายอินพุต
3. ถ่ายทอดการเรียนรู้เพื่อการจดจำภาพ
ดังแสดงในรูปที่ 2 โมเดลการเรียนรู้การถ่ายโอนหลายอินพุตใหม่ใช้โมเดล ConvNet VGG16 ที่ได้รับการฝึกล่วงหน้าสำหรับการจดจำรูปภาพ โมเดล VGG16 ได้รวมอยู่ในไลบรารี Keras แล้ว รหัสต่อไปนี้จาก [1] ใช้เพื่อรวมฐานการหมุนวน VGG16 เข้ากับตัวแยกประเภทที่เชื่อมต่ออย่างสมบูรณ์ใหม่เพื่อสร้างรูปแบบอินพุตการรับรู้ภาพใหม่:
from keras.applications import VGG16
image_input = Input(shape=(150, 150, 3), name='image')
vgg16 = VGG16(weights='imagenet',
include_top=False,
input_shape=(150, 150, 3))(image_input)
x = layers.Flatten()(vgg16)
x = layers.Dense(256, activation='relu')(x)
4. ถ่ายทอดการเรียนรู้เพื่อการจำแนกข้อความ
ดังที่แสดงในรูปที่ 2 โมเดลการเรียนรู้การถ่ายโอนข้อมูลแบบหลายอินพุตใหม่ใช้โมเดลการฝังคำที่ได้รับการฝึกไว้ล่วงหน้า GloVe [3] สำหรับการแปลงแท็กคำให้เป็นเวกเตอร์ขนาดเล็ก เมื่อดาวน์โหลดชุดข้อมูล GloVe [3] ลงในเครื่องแล้ว สามารถใช้โค้ดต่อไปนี้จาก [1] เพื่อโหลดโมเดลคำที่ฝังลงในหน่วยความจำ:
glove_dir = './multi_task_learning/data/'
embeddings_index = {}
f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))
for line in f:
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
ดังที่เห็นในรูปที่ 2 การฝังคำของ GloVe จะถูกรวมเข้ากับ Keras LSTM เพื่อสร้างโมเดลอินพุต NLP ใหม่สำหรับการทำนาย/การรับรู้แท็กคำ:
tag_input = Input(shape=(None,), dtype='int32', name='tag') embedded_tag = layers.Embedding(max_words, embedding_dim)(tag_input) encoded_tag = layers.LSTM(512)(embedded_tag)
5. การรวมโมเดลหลายอินพุตเข้ากับลักษณนามที่เชื่อมต่ออย่างสมบูรณ์
เมื่อสร้างโมเดลอินพุตการจดจำรูปภาพใหม่และโมเดลอินพุต NLP ใหม่แล้ว โค้ดต่อไปนี้สามารถรวมเข้ากับตัวแยกประเภทเอาต์พุตใหม่ให้เป็นโมเดลการเรียนรู้การถ่ายโอนหลายอินพุตเดียว:
concatenated = layers.concatenate([x, encoded_tag], axis=-1) output = layers.Dense(1, activation='sigmoid')(concatenated)model = Model([image_input, tag_input], output) model.summary()
ตามที่อธิบายไว้ใน [1] ทั้งฐาน Convolutional VGG16 ที่ได้รับการฝึกล่วงหน้าและเลเยอร์การฝังคำ GloVe จะต้องถูกแช่แข็งเพื่อไม่ให้น้ำหนักที่ได้รับการฝึกล่วงหน้าของโมเดลเหล่านั้นจะไม่ได้รับการแก้ไขในระหว่างการฝึกโมเดลหลายอินพุตใหม่:
# model.layers[1].trainable = False # freeze VGG16 model.layers[4].set_weights([embedding_matrix]) model.layers[4].trainable = False # freeze GloVe word embedding
อย่างไรก็ตาม สำหรับฐานการหมุนวน VGG16 เป็นที่น่าสนใจที่จะทราบว่าฉันได้ลองทั้งสองวิธี (แช่แข็งหรือไม่แช่แข็ง) แต่ไม่เห็นความแตกต่างที่มีนัยสำคัญในแง่ของเวลาการฝึกโมเดลหรือผลการทำนายโมเดล
6. การฝึกอบรมแบบจำลองหลายอินพุต
ชุดข้อมูลการฝึกอบรม Kaggle ดั้งเดิมจะมีเพียงคู่รูปภาพที่ถูกต้องและแท็กคำที่เกี่ยวข้องเท่านั้น คู่ที่ถูกต้องแต่ละคู่จะมีป้ายกำกับเป็น 1 (ตรงกัน) ในบทความนี้ (ดูโค้ดด้านล่างด้วย) เพื่อสร้างชุดข้อมูลที่สมดุล โค้ดต่อไปนี้จะสร้างคู่รูปภาพและแท็กคำที่ไม่ถูกต้อง 2,000 คู่ นอกเหนือจากคู่รูปภาพและแท็กคำที่ถูกต้อง 2,000 คู่ที่มีอยู่ เพื่อความง่าย สามารถทำได้โดยการจับคู่แต่ละภาพ (เช่น รูปภาพ i) จากรูปภาพ 2,000 ภาพที่เลือก กับแท็กคำของไฟล์รูปภาพถัดไป (เช่น แท็กคำของรูปภาพ i+1)
import cv2
dim = (150, 150)
X_image_train = []
X_tag_train = tag_data
y_train = []
for fname in listdir(small_image_path):
fpath = os.path.join(small_image_path, fname)
im = cv2.imread(fpath)
im_resized = cv2.resize(im, dim, interpolation = cv2.INTER_AREA)
X_image_train.append(im_resized)
y_train.append(1)
# add incorrect image and tag pairs
num_negative_samples = len(y_train)
for i in range(num_negative_samples):
image = X_image_train[i]
X_image_train.append(image)
j = (i + 1) % num_negative_samples # get a different tag
tag = X_tag_train[j]
X_tag_train = np.append(X_tag_train, tag)
y_train.append(0)
มีรูปภาพและแท็กคำทั้งหมด 4,000 คู่ คู่ที่ถูก 2,000 คู่ และคู่ที่ไม่ถูกต้อง 2,000 คู่
แท็กคำรูปภาพแต่ละแท็กจะต้องเข้ารหัสเป็นจำนวนเต็ม และแต่ละรายการ/ลำดับของแท็กคำจะต้องแปลงเป็นลำดับของค่าจำนวนเต็มก่อนที่แท็กคำจะสามารถใช้งานได้โดยโมเดลการฝังคำ ซึ่งสามารถทำได้ดังต่อไปนี้โดยใช้และแก้ไขโค้ดใน [1]:
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
maxlen = 100
training_samples = num_of_samples
tag_vocabulary_size = 10000
max_words = tag_vocabulary_size
num_of_samples = label_df.shape[0]
tokenizer = Tokenizer(num_words=max_words)
texts = []
for tag_list in label_df_clean['word_tags']:
texts.append(' '.join(tag_list))
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
print('Found {} unique tokens'.format(len(word_index)))
tag_data = pad_sequences(sequences, maxlen=maxlen)
ชุดข้อมูลการฝึกแท็กรูปภาพและคำที่ได้จะถูกแปลงเป็นอาร์เรย์ Numpy และสับเปลี่ยนสำหรับการฝึกโมเดล:
X_image_train = np.array(X_image_train) X_tag_train = np.array(X_tag_train) y_train = np.array(y_train) perm = np.arange(y_train.shape[0]) np.random.shuffle(perm) X_image_train = X_image_train[perm] X_tag_train = X_tag_train[perm] y_train = y_train[perm]
โมเดลอินพุตหลายอินพุตใหม่ได้รับการรวบรวมและฝึกฝนดังต่อไปนี้โดยมีเพียง 30 ยุคและคู่รูปภาพและแท็กคำที่สมดุล 4,000 คู่:
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) model.fit([X_image_train, X_tag_train], y_train, epochs=30, batch_size=64)
7. การทำนายแบบจำลอง
ดังที่แสดงด้านล่าง ชุดข้อมูลการทดสอบส่วนตัวใน [2] ประกอบด้วยรูปภาพ 500 ภาพ และแต่ละภาพเชื่อมโยงกับแท็กคำสองชุด:
เมื่อพิจารณาจากรูปภาพในชุดข้อมูลการทดสอบ โมเดลการเรียนรู้การถ่ายโอนหลายอินพุตใหม่จะต้องสามารถคาดเดาได้ว่าแท็กคำใดจากสองชุดที่กำหนดให้ตรงกับรูปภาพ
รหัสต่อไปนี้คือการโหลดภาพทดสอบลงในหน่วยความจำ:
dim = (150, 150)
X_image_test = []
for fname in listdir(test_image_dir):
fpath = os.path.join(test_image_dir, fname)
im = cv2.imread(fpath)
im_resized = cv2.resize(im, dim, interpolation = cv2.INTER_AREA)
X_image_test.append(im_resized)
แท็กคำทดสอบจะถูกแปลงเป็นลำดับของค่าจำนวนเต็มที่เข้ารหัสดังต่อไปนี้:
tokenizer_test = Tokenizer(num_words=max_words)
texts_1 = []
texts_2 = []
texts_all = []
for tag_list in test_image_label_df['word_tags_1']:
texts_1.append(' '.join(tag_list))
for tag_list in test_image_label_df['word_tags_2']:
texts_2.append(' '.join(tag_list))
texts_all.extend(texts_1)
texts_all.extend(texts_2)
tokenizer_test.fit_on_texts(texts_all)
sequences_1 = tokenizer_test.texts_to_sequences(texts_1)
sequences_2 = tokenizer_test.texts_to_sequences(texts_2)
word_index_test = tokenizer_test.word_index
print('Found {} unique tokens in test'.format(len(word_index_test)))
tag_data_test_1 = pad_sequences(sequences_1, maxlen=maxlen)
tag_data_test_2 = pad_sequences(sequences_2, maxlen=maxlen)
จากนั้นผลลัพธ์อาร์เรย์ Python ของรูปภาพและแท็กคำจะถูกแปลงเป็นอาร์เรย์ Numpy และปรับให้เข้ากับโมเดลที่ได้รับการฝึกอบรมเพื่อการทำนาย:
X_image_test = np.array(X_image_test) X_tag_test_1 = np.array(tag_data_test_1) X_tag_test_2 = np.array(tag_data_test_2) y_predict_1 = loaded_model.predict([X_image_test, X_tag_test_1]) y_predict_2 = loaded_model.predict([X_image_test, X_tag_test_2])
ตารางต่อไปนี้แสดงผลการทำนาย 20 รายการแรก:
รูปภาพต่อไปนี้คือ Image 201.png ในชุดข้อมูลการทดสอบ:
แท็กคำที่เกี่ยวข้องสองชุดมีดังนี้:
word-tag-set-0: ['bloom', 'glow', 'overexposed', 'bright', 'white', 'face', 'woman', 'blonde'] word-tag-set-1: ['iron', 'nuggets', 'samples', 'metal', 'ore', 'shadow', 'white', 'grey', 'gray', 'rust', 'shiny']
แบบจำลองคาดการณ์:
word-tag-set-0: probability of 0.797 word-tag-set-1: probability of 0.999
คำตอบที่มีความน่าจะเป็นสูงกว่าคือ 0.999 คือ:
['เหล็ก', 'นักเก็ต', 'ตัวอย่าง', 'โลหะ', 'แร่', 'เงา', 'สีขาว', 'สีเทา', 'สีเทา', 'สนิม', 'แวววาว' ]
สำหรับตัวอย่างเชิงบวกอีกประการหนึ่ง ต่อไปนี้คือ Image 76.png ในชุดข้อมูลการทดสอบ:
ต่อไปนี้เป็นแท็กคำสองชุดที่เกี่ยวข้องกัน:
word-tag-set-0: ['person', 'man', 'shirt', 'pinstripe', 'smile', 'balding', 'grey', 'gray'] word-tag-set-1: ['country', 'music', 'man', 'instrument', 'guitar', 'musician', 'person', 'playing', 'watch', 'striped', 'shirt', 'red', 'glasses']
แบบจำลองคาดการณ์:
word-tag-set-0: probability of 0.997 word-tag-set-1: probability of 0.530
คำตอบที่มีความน่าจะเป็นสูงกว่าคือ 0.997 คือ:
['บุคคล', 'ผู้ชาย', 'เสื้อเชิ้ต', 'ลายทาง', 'ยิ้ม', 'หัวล้าน', 'สีเทา', 'สีเทา']
จากตัวอย่างผลบวกลวง ต่อไปนี้คือ Image 189.png ในชุดข้อมูลการทดสอบ:
ต่อไปนี้เป็นแท็กคำสองชุดที่เกี่ยวข้องกัน:
word-tag-set-0: ['necklace', 'woman', 'earring', 'jewelry', 'mouth', 'chin', 'closeup'] word-tag-set-1: ['circle', 'lines', 'round', 'window', 'porthole', 'man', 'face', 'beard', 'person', 'dark', 'shadow']
แบบจำลองคาดการณ์:
word-tag-set-0: probability of 0.016 word-tag-set-1: probability of 0.999
คำตอบเชิงบวกลวงที่มีความน่าจะเป็นสูงกว่าคือ 0.999 คือ:
['วงกลม', 'เส้น', 'กลม', 'หน้าต่าง', 'ช่องหน้าต่าง', 'ผู้ชาย', 'ใบหน้า', 'เครา', 'บุคคล', 'ความมืด', 'เงา']
ผลการทดสอบข้างต้นแสดงให้เห็นว่าแม้ว่าโมเดลการเรียนรู้การถ่ายโอนข้อมูลแบบหลายอินพุตใหม่จะได้รับการฝึกด้วยรูปภาพและแท็กคำเพียง 4,000 คู่และ 30 ยุค แต่โมเดลก็สามารถได้รับผลลัพธ์ที่สมเหตุสมผลในแง่ของความแม่นยำ
อย่างไรก็ตาม โมเดลยังสร้างผลบวกลวงค่อนข้างมากเนื่องจากโมเดลเกินพอดี
สรุป
บทความนี้นำเสนอโมเดลการเรียนรู้การถ่ายโอนข้อมูลเชิงลึกแบบหลายอินพุตใหม่ที่รวมโมเดลอินพุตที่ได้รับการฝึกล่วงหน้าสองโมเดล (VGG16 และ GloVe และ LSTM) เข้ากับเลเยอร์การจำแนกประเภทที่เชื่อมต่ออย่างสมบูรณ์ใหม่สำหรับการรับรู้รูปภาพและแท็กคำพร้อมกัน
จุดสำคัญของวิธีการเรียนรู้เชิงลึกแบบหลายอินพุตใหม่คือการแปลปัญหาการจดจำรูปภาพและแท็กคำให้กลายเป็นปัญหาการจำแนกประเภท นั่นคือ การกำหนดว่ารูปภาพที่กำหนดตรงกับชุดแท็กคำที่กำหนดหรือไม่ (0-ไม่ใช่ 1-ใช่)
ชุดข้อมูลสาธารณะที่ท้าทายใน Kaggle "ความท้าทายในการเรียนรู้การเป็นตัวแทน: การเรียนรู้แบบหลายรูปแบบ" [2] ถูกนำมาใช้ในการฝึกอบรมและประเมินโมเดลใหม่
ผลการคาดการณ์แบบจำลองแสดงให้เห็นว่าโมเดลใหม่ทำงานได้ดีพอสมควรด้วยการฝึกโมเดลที่จำกัด (เพียง 30 ยุคและ 4,000 คู่รูปภาพและแท็กคำ) เพื่อวัตถุประสงค์ในการสาธิต อย่างไรก็ตาม จึงไม่น่าแปลกใจเลยที่แบบจำลองยังสร้างผลบวกลวงค่อนข้างมากเนื่องจากโมเดลพอดีเกินไป ปัญหานี้สามารถแก้ไขได้ด้วยการฝึกโมเดลให้มียุคสมัยที่มากขึ้นและ/หรือคู่รูปภาพและแท็กคำมากขึ้น
เห็นได้ชัดว่าภาพการฝึกอบรม 2,000 ภาพที่ได้รับการสุ่มเลือกนั้นไม่เพียงพอในการเป็นตัวแทนของภาพการฝึกอบรมที่มีอยู่ทั้งหมด 100,000 ภาพ ควรปรับปรุงประสิทธิภาพของโมเดลอย่างมีนัยสำคัญโดยเพิ่มจำนวนอิมเมจการฝึกจาก 2,000 เป็นขนาดที่ใหญ่ขึ้น เช่น 10,000
สมุดบันทึก Jupyter พร้อมซอร์สโค้ดทั้งหมดมีอยู่ใน Github [5]
อ้างอิง
(1) F. Chollet, การเรียนรู้เชิงลึกกับ Python, Manning Publications Co., 2018
[2] ความท้าทายในการเรียนรู้การเป็นตัวแทน: การเรียนรู้แบบหลายรูปแบบ
[3] เจ. เพนนิงตัน, อาร์. โซเชอร์, ซีดี. แมนนิ่ง "GloVe: เวกเตอร์ระดับโลกสำหรับการแทนคำ"
[4] Y. Zhang, การเรียนรู้เชิงลึกสำหรับการประมวลผลภาษาธรรมชาติโดยใช้ word2vec-keras
[5] Y. Zhang, สมุดบันทึก Jupyter ใน "Github"
คำชี้แจงการเปิดเผยข้อมูล: © 2019 Capital One ความคิดเห็นเป็นของผู้เขียนแต่ละคน เว้นแต่จะระบุไว้เป็นอย่างอื่นในโพสต์นี้ Capital One ไม่มีส่วนเกี่ยวข้องหรือรับรองโดยบริษัทใด ๆ ที่กล่าวถึง เครื่องหมายการค้าและทรัพย์สินทางปัญญาอื่น ๆ ทั้งหมดที่ใช้หรือแสดงเป็นทรัพย์สินของเจ้าของที่เกี่ยวข้อง
