Giới thiệu về Transfer learning và Fine-tuning (Phần 2)

Tiếp nối bài xích trước về Transfer Learning, thời điểm ngày hôm nay tất cả chúng ta nằm trong mò mẫm hiểu về Fine Tuning.

Bạn đang xem: fine-tuning là gì

Mở đầu

Fine tuning : Thuật ngữ này rất có thể được dịch là “Tinh chỉnh” – là 1 trong những quy trình dùng một quy mô mạng và được đào tạo và huấn luyện cho 1 trách nhiệm chắc chắn nhằm triển khai một trách nhiệm tương tự động. Sở dĩ cơ hội giải thích này còn có phần như thể Transfer Learning – bởi vì Fine Tuning là 1 trong những chuyên môn Transfer Learning nhưng mà ! Hãy nằm trong mò mẫm hiểu coi rõ ràng nó là thế nào là nhé.

Khi quy mô của công ty đang được quy tụ bên trên tài liệu mới mẻ, bạn cũng có thể nỗ lực hóa giải toàn cỗ hoặc một trong những phần của quy mô hạ tầng và huấn luyện và giảng dạy lại toàn cỗ quy mô từ trên đầu cho tới cuối với tỷ trọng tiếp thu kiến thức cực kỳ thấp.

Đây là bước sau cuối tùy lựa chọn rất có thể đưa đến cho mình những nâng cấp tăng thêm. Nó cũng rất có thể dẫn theo hiện tượng overfitting – hãy suy xét vấn đề này.

Điều cần thiết là chỉ triển khai công đoạn này sau khoản thời gian quy mô với những lớp ướp lạnh và được đào tạo và huấn luyện nhằm quy tụ. Nếu các bạn trộn những lớp trainable được khởi tạo nên tình cờ với những lớp trainable chứa chấp những tác dụng và được đào tạo và huấn luyện trước, những lớp được khởi tạo nên tình cờ sẽ gây ra đi ra những update gradient rất rộng lớn nhập quy trình đào tạo và huấn luyện, điều này tiếp tục huỷ diệt những tác dụng và được đào tạo và huấn luyện trước của công ty.

Một yếu tố cần thiết nữa tà tà dùng tỷ trọng tiếp thu kiến thức cực kỳ thấp ở tiến độ này, cũng chính vì các bạn đang được huấn luyện và giảng dạy một quy mô to hơn nhiều đối với trong tầm huấn luyện và giảng dạy thứ nhất, bên trên một tập luyện tài liệu thông thường cực kỳ nhỏ. Do cơ, các bạn với nguy cơ tiềm ẩn bị overfitting cực kỳ thời gian nhanh nếu như vận dụng những phương án update trọng lượng rộng lớn. Tại trên đây, các bạn chỉ ham muốn phát âm những trọng số được đào tạo và huấn luyện trước Theo phong cách tăng dần dần.

Đây là cơ hội implement fine-tuning toàn cỗ quy mô cơ sở:

# Hủy ngừng hoạt động quy mô cơ sở base_model.trainable = True # Quan trọng là cần biên dịch lại quy mô của công ty sau khoản thời gian triển khai ngẫu nhiên thay cho thay đổi nào là so với tính chất `trainable` của ngẫu nhiên lớp trong nào # Để những thay cho thay đổi của công ty được xem đến model.compile(optimizer=keras.optimizers.Adam(1e-5), # Tỉ lệ học tập cực kỳ thấp loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.BinaryAccuracy()]) # Train. Cẩn thận nhằm tạm dừng trước lúc bị overfit model.fit(new_dataset, epochs=10, callbacks=..., validation_data=...)

Lưu ý cần thiết về compile() và trainable

Việc gọi compile() bên trên một quy mô tức là "đóng băng" hành động của quy mô cơ. Như vậy ý niệm rằng những độ quý hiếm tính chất trainable bên trên thời khắc quy mô được biên dịch nên được bảo toàn nhập xuyên suốt thời hạn tồn bên trên của quy mô cơ, cho tới Khi quy trình biên dịch được gọi lại. Do cơ, nếu khách hàng thay cho thay đổi ngẫu nhiên độ quý hiếm rất có thể huấn luyện và giảng dạy nào là, hãy đáp ứng gọi lại compile () bên trên quy mô của công ty nhằm những thay cho thay đổi của công ty được xem cho tới.

Lưu ý cần thiết về lớp BatchNormalization

Nhiều quy mô hình hình họa chứa chấp những lớp BatchNormalization. Lớp cơ là 1 trong những tình huống quan trọng bên trên từng con số rất có thể tưởng tượng được. Dưới đấy là một số trong những vấn đề cần ghi ghi nhớ.

BatchNormalization chứa chấp 2 trọng lượng ko thể huấn luyện và giảng dạy được update nhập quy trình huấn luyện và giảng dạy. Đây là những biến hóa theo dõi dõi độ quý hiếm khoảng và phương sai của những nguyên tố nguồn vào.
Khi các bạn đặt điều bn_layer.trainable = False, lớp BatchNormalization tiếp tục chạy ở cơ chế tư duy và sẽ không còn update đo đếm khoảng & phương sai của chính nó. Điều này sẽ không trúng với những lớp không giống trình bày công cộng, vì như thế tài năng tập luyện tạ & cơ chế tư duy / đào tạo và huấn luyện là nhì định nghĩa trực kí thác. Nhưng cả nhì được gắn kèm với nhau nhập tình huống của lớp BatchNormalization.
Khi các bạn hóa giải một quy mô với chứa chấp những lớp BatchNormalization nhằm triển khai tinh ma chỉnh, chúng ta nên lưu giữ những lớp BatchNormalization ở cơ chế tư duy bằng phương pháp trả training = False Khi gọi quy mô hạ tầng. Nếu ko, những bạn dạng update được vận dụng cho những trọng lượng ko thể huấn luyện và giảng dạy tiếp tục đột ngột huỷ diệt những gì nhưng mà quy mô đang được học tập được.

Bạn tiếp tục thấy hình mẫu này hoạt động và sinh hoạt nhập ví dụ end-to-end ở cuối chỉ dẫn này.

Transfer learning & fine-tuning với cùng một vòng lặp huấn luyện và giảng dạy tùy chỉnh

Nếu thay cho fit(), các bạn đang được dùng vòng lặp huấn luyện và giảng dạy thấp cấp của riêng rẽ bản thân, thì tiến độ thao tác làm việc về cơ bạn dạng vẫn không thay đổi. quý khách hàng nên cảnh giác chỉ tính cho tới list model.trainable_weights Khi vận dụng update gradient:

# Khởi tạo nên quy mô cơ sở base_model = keras.applications.Xception( weights='imagenet', input_shape=(150, 150, 3), include_top=False) # Đóng băng quy mô cơ sở base_model.trainable = False # Khởi tạo nên một quy mô mới mẻ on top. inputs = keras.Input(shape=(150, 150, 3)) x = base_model(inputs, training=False) x = keras.layers.GlobalAveragePooling2D()(x) outputs = keras.layers.Dense(1)(x) model = keras.Model(inputs, outputs) loss_fn = keras.losses.BinaryCrossentropy(from_logits=True) optimizer = keras.optimizers.Adam() # Lặp lại những lô của tập luyện tài liệu. for inputs, targets in new_dataset: # Mở GradientTape. with tf.GradientTape() as tape: # Chuyển tiếp predictions = model(inputs) # Tính toán độ quý hiếm tổn thất mang đến lô này. loss_value = loss_fn(targets, predictions) # Lấy gradients với chừng rời của trọng số *trainable*. gradients = tape.gradient(loss_value, model.trainable_weights) # Cập nhật trọng số của tế bào hình optimizer.apply_gradients(zip(gradients, model.trainable_weights))

Một ví dụ từ trên đầu cho tới cuối: tinh ma chỉnh quy mô phân mô hình hình họa bên trên tập luyện tài liệu mèo và chó

Để gia tăng những định nghĩa này, hãy chỉ dẫn các bạn qua loa một ví dụ rõ ràng về tiếp thu kiến thức và tinh ma chỉnh trả kí thác từ trên đầu cho tới cuối. Chúng tôi tiếp tục vận tải quy mô Xception, được huấn luyện và giảng dạy trước bên trên ImageNet và dùng nó bên trên tập luyện tài liệu phân loại Kaggle "mèo đối với chó".

Lấy dữ liệu

Đầu tiên, hãy mò mẫm hấp thụ tập luyện tài liệu mèo và chó bởi vì TFDS. Nếu các bạn với tập luyện tài liệu của riêng rẽ bản thân, rất có thể các bạn sẽ ham muốn dùng tiện nghi tf.keras.preprocessing.image_dataset_from_directory sẽ tạo những đối tượng người tiêu dùng tập luyện tài liệu với nhãn tương tự động từ là một giao hội những hình hình họa bên trên đĩa được tàng trữ nhập những folder thích hợp mang đến lớp.

Học trả kí thác hữu ích nhất lúc thao tác làm việc với những tập luyện tài liệu cực kỳ nhỏ. Để lưu giữ mang đến tập luyện tài liệu của Shop chúng tôi nhỏ, Shop chúng tôi tiếp tục dùng 40% tài liệu huấn luyện và giảng dạy thuở đầu (25.000 hình ảnh) nhằm huấn luyện và giảng dạy, 10% nhằm xác thực và 10% nhằm đánh giá.

import tensorflow_datasets as tfds tfds.disable_progress_bar() train_ds, validation_ds, test_ds = tfds.load( "cats_vs_dogs", # Reserve 10% for validation and 10% for test split=["train[:40%]", "train[40%:50%]", "train[50%:60%]"], as_supervised=True, # Include labels ) print("Number of training samples: %d" % tf.data.experimental.cardinality(train_ds)) print("Number of validation samples: %d" % tf.data.experimental.cardinality(validation_ds)) print("Number of test samples: %d" % tf.data.experimental.cardinality(test_ds))

Number of training samples: 9305 Number of validation samples: 2326 Number of test samples: 2326

Đây là 9 hình hình họa thứ nhất nhập tập luyện tài liệu huấn luyện và giảng dạy – như bạn cũng có thể thấy, bọn chúng đều sở hữu độ dài rộng không giống nhau.

import matplotlib.pyplot as plt plt.figure(figsize=(10, 10)) for i, (image, label) in enumerate(train_ds.take(9)): ax = plt.subplot(3, 3, i + 1) plt.imshow(image) plt.title(int(label)) plt.axis("off")

Chúng tao cũng rất có thể thấy rằng nhãn một là "chó" và nhãn 0 là "mèo".

Xem thêm: trong công nghiệp n2 được tạo ra bằng cách nào sau đây

Chuẩn hóa dữ liệu

Hình hình họa thô của có rất nhiều size không giống nhau. Dường như, từng px bao hàm 3 độ quý hiếm integer 0 cho tới 255 (giá trị RGB). Đây ko cần là 1 trong những sự tương thích tuyệt hảo mang đến mạng nơ-ron. Chúng tao cần thiết thực hiện 2 việc:

Chuẩn hóa trở thành độ dài rộng hình hình họa cố định và thắt chặt. Chúng tao lựa chọn 150×150.
Chuẩn hóa những độ quý hiếm px kể từ -1 cho tới 1. Chúng tôi tiếp tục triển khai việc này bằng phương pháp dùng lớp Chuẩn hóa như một trong những phần của chủ yếu quy mô.

Nói công cộng, chúng ta nên cải tiến và phát triển những quy mô lấy tài liệu thô thực hiện nguồn vào, trái khoáy ngược với những quy mô lấy tài liệu và được xử lý trước. Lý vì thế là, nếu như quy mô của công ty đòi hỏi tài liệu được xử lý trước, ngẫu nhiên lúc nào các bạn xuất quy mô của tớ nhằm dùng ở điểm không giống (trong trình duyệt trang web, nhập phần mềm dành riêng cho tranh bị di động), các bạn sẽ rất cần phải triển khai lại và một tiến độ xử lý trước. Như vậy trở thành cực kỳ phức tạp cực kỳ nhanh gọn lẹ. Vì vậy, tất cả chúng ta nên triển khai không nhiều chi phí xử lý nhất rất có thể trước lúc đi vào quy mô.

Ở trên đây, tất cả chúng ta tiếp tục triển khai thay cho thay đổi độ dài rộng hình hình họa nhập ống dẫn tài liệu (vì mạng nơ-ron sâu sắc chỉ rất có thể xử lý những lô tài liệu ngay tắp lự kề) và Shop chúng tôi tiếp tục triển khai kiểm soát và điều chỉnh tỷ trọng độ quý hiếm nguồn vào như một trong những phần của quy mô, Khi Shop chúng tôi tạo nên nó.

Hãy thay cho thay đổi độ dài rộng hình hình họa trở thành 150×150:

size = (150, 150) train_ds = train_ds.map(lambda x, y: (tf.image.resize(x, size), y)) validation_ds = validation_ds.map(lambda x, y: (tf.image.resize(x, size), y)) test_ds = test_ds.map(lambda x, y: (tf.image.resize(x, size), y))

Bên cạnh cơ, hãy giao hội tài liệu và dùng bộ lưu trữ đệm & mò mẫm hấp thụ trước nhằm tối ưu hóa vận tốc vận tải.

batch_size = 32 train_ds = train_ds.cache().batch(batch_size).prefetch(buffer_size=10) validation_ds = validation_ds.cache().batch(batch_size).prefetch(buffer_size=10) test_ds = test_ds.cache().batch(batch_size).prefetch(buffer_size=10)

Sử dụng tăng tài liệu ngẫu nhiên

Khi các bạn không tồn tại tập luyện tài liệu hình hình họa rộng lớn, chúng ta nên trả tính phong phú và đa dạng hình mẫu vào một trong những cơ hội fake tạo nên bằng phương pháp vận dụng những luật lệ biến hóa tình cờ tuy nhiên thực tiễn mang đến hình hình họa đào tạo và huấn luyện, ví dụ như lật ngang tình cờ hoặc xoay tình cờ nhỏ. Như vậy canh ty quy mô hiển thị những hướng nhìn không giống nhau của tài liệu huấn luyện và giảng dạy trong những lúc thực hiện chậm rãi quy trình overfitting.

from tensorflow import keras from tensorflow.keras import layers data_augmentation = keras.Sequential( [layers.RandomFlip("horizontal"), layers.RandomRotation(0.1),] )

Hãy tưởng tượng hình hình họa thứ nhất của lô thứ nhất nhìn thế nào sau rất nhiều lần biến hóa ngẫu nhiên:

import numpy as np for images, labels in train_ds.take(1): plt.figure(figsize=(10, 10)) first_image = images[0] for i in range(9): ax = plt.subplot(3, 3, i + 1) augmented_image = data_augmentation( tf.expand_dims(first_image, 0), training=True ) plt.imshow(augmented_image[0].numpy().astype("int32")) plt.title(int(labels[0])) plt.axis("off")

Xây dựng một tế bào hình

Bây giờ tất cả chúng ta hãy kiến tạo một quy mô theo dõi plan cụ thể đang được lý giải trước cơ.

Lưu ý rằng:

Thêm một tấm Rescaling nhằm phân chia tỷ trọng những độ quý hiếm nguồn vào (ban đầu nhập phạm vi [0, 255]) trở thành phạm vi [-1, 1].
Thêm một tấm Dropout trước lớp phân loại, nhằm chủ yếu quy hóa.
Đảm bảo training = False Khi gọi quy mô hạ tầng, nhằm nó chạy ở cơ chế tư duy, bởi vậy đo đếm batchnorm ko được update trong cả sau khoản thời gian Shop chúng tôi hóa giải quy mô hạ tầng nhằm fine-tuning.

base_model = keras.applications.Xception( weights="imagenet", # Load weights pre-trained on ImageNet. input_shape=(150, 150, 3), include_top=False, ) # Do not include the ImageNet classifier at the top. # Freeze the base_model base_model.trainable = False # Create new model on top inputs = keras.Input(shape=(150, 150, 3)) x = data_augmentation(inputs) # Apply random data augmentation # Pre-trained Xception weights requires that input be scaled # from (0, 255) to tát a range of (-1., +1.), the rescaling layer # outputs: `(inputs * scale) + offset` scale_layer = keras.layers.Rescaling(scale=1 / 127.5, offset=-1) x = scale_layer(x) # The base model contains batchnorm layers. We want to tát keep them in inference mode # when we unfreeze the base model for fine-tuning, sánh we make sure that the # base_model is running in inference mode here. x = base_model(x, training=False) x = keras.layers.GlobalAveragePooling2D()(x) x = keras.layers.Dropout(0.2)(x) # Regularize with dropout outputs = keras.layers.Dense(1)(x) model = keras.Model(inputs, outputs) model.summary()

Đào tạo nên lớp bên trên cùng

model.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.BinaryAccuracy()], ) epochs = 20 model.fit(train_ds, epochs=epochs, validation_data=validation_ds)

Epoch 1/20 291/291 [==============================] - 133s 451ms/step - loss: 0.1670 - binary_accuracy: 0.9267 - val_loss: 0.0830 - val_binary_accuracy: 0.9716 Epoch 2/20 291/291 [==============================] - 135s 465ms/step - loss: 0.1208 - binary_accuracy: 0.9502 - val_loss: 0.0768 - val_binary_accuracy: 0.9716 Epoch 3/20 291/291 [==============================] - 135s 463ms/step - loss: 0.1062 - binary_accuracy: 0.9572 - val_loss: 0.0757 - val_binary_accuracy: 0.9716 Epoch 4/20 291/291 [==============================] - 137s 469ms/step - loss: 0.1024 - binary_accuracy: 0.9554 - val_loss: 0.0733 - val_binary_accuracy: 0.9725 Epoch 5/20 291/291 [==============================] - 137s 470ms/step - loss: 0.1004 - binary_accuracy: 0.9587 - val_loss: 0.0735 - val_binary_accuracy: 0.9729 Epoch 6/20 291/291 [==============================] - 136s 467ms/step - loss: 0.0979 - binary_accuracy: 0.9577 - val_loss: 0.0747 - val_binary_accuracy: 0.9708 Epoch 7/20 291/291 [==============================] - 134s 462ms/step - loss: 0.0998 - binary_accuracy: 0.9596 - val_loss: 0.0706 - val_binary_accuracy: 0.9725 Epoch 8/20 291/291 [==============================] - 133s 457ms/step - loss: 0.1029 - binary_accuracy: 0.9592 - val_loss: 0.0720 - val_binary_accuracy: 0.9733 Epoch 9/20 291/291 [==============================] - 135s 466ms/step - loss: 0.0937 - binary_accuracy: 0.9625 - val_loss: 0.0707 - val_binary_accuracy: 0.9721 Epoch 10/20 291/291 [==============================] - 137s 472ms/step - loss: 0.0967 - binary_accuracy: 0.9580 - val_loss: 0.0720 - val_binary_accuracy: 0.9712 Epoch 11/20 291/291 [==============================] - 135s 463ms/step - loss: 0.0961 - binary_accuracy: 0.9612 - val_loss: 0.0802 - val_binary_accuracy: 0.9699 Epoch 12/20 291/291 [==============================] - 134s 460ms/step - loss: 0.0963 - binary_accuracy: 0.9638 - val_loss: 0.0721 - val_binary_accuracy: 0.9716 Epoch 13/20 291/291 [==============================] - 136s 468ms/step - loss: 0.0925 - binary_accuracy: 0.9635 - val_loss: 0.0736 - val_binary_accuracy: 0.9686 Epoch 14/20 291/291 [==============================] - 138s 476ms/step - loss: 0.0909 - binary_accuracy: 0.9624 - val_loss: 0.0766 - val_binary_accuracy: 0.9703 Epoch 15/20 291/291 [==============================] - 136s 467ms/step - loss: 0.0949 - binary_accuracy: 0.9598 - val_loss: 0.0704 - val_binary_accuracy: 0.9725 Epoch 16/20 291/291 [==============================] - 133s 456ms/step - loss: 0.0969 - binary_accuracy: 0.9586 - val_loss: 0.0722 - val_binary_accuracy: 0.9708 Epoch 17/20 291/291 [==============================] - 135s 464ms/step - loss: 0.0913 - binary_accuracy: 0.9635 - val_loss: 0.0718 - val_binary_accuracy: 0.9716 Epoch 18/20 291/291 [==============================] - 137s 472ms/step - loss: 0.0915 - binary_accuracy: 0.9639 - val_loss: 0.0727 - val_binary_accuracy: 0.9725 Epoch 19/20 291/291 [==============================] - 134s 460ms/step - loss: 0.0938 - binary_accuracy: 0.9631 - val_loss: 0.0707 - val_binary_accuracy: 0.9733 Epoch 20/20 291/291 [==============================] - 134s 460ms/step - loss: 0.0971 - binary_accuracy: 0.9609 - val_loss: 0.0714 - val_binary_accuracy: 0.9716 <keras.callbacks.History at 0x7f4494e38f70>

Thực hiện tại một vòng tinh ma chỉnh toàn cỗ tế bào hình

Cuối nằm trong, hãy hóa giải quy mô hạ tầng và huấn luyện và giảng dạy toàn cỗ quy mô từ trên đầu cho tới cuối với tỷ trọng tiếp thu kiến thức thấp.

Quan trọng là, tuy nhiên quy mô hạ tầng trở thành rất có thể đào tạo và huấn luyện được, tuy nhiên nó vẫn đang hoạt động ở cơ chế tư duy vì như thế tất cả chúng ta đang được đặt điều training=False Khi gọi nó Khi tất cả chúng ta kiến tạo quy mô. Như vậy tức là những lớp chuẩn chỉnh hóa một loạt bên phía trong sẽ không còn update đo đếm một loạt của bọn chúng. Nếu chúng ta thực hiện vậy, chúng ta tiếp tục huỷ diệt những thay mặt nhưng mà quy mô đang được học tập cho tới ni.

base_model.trainable = True model.summary() model.compile( optimizer=keras.optimizers.Adam(1e-5), # Low learning rate loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.BinaryAccuracy()], ) epochs = 10 model.fit(train_ds, epochs=epochs, validation_data=validation_ds)

Model: "model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_5 (InputLayer) [(None, 150, 150, 3)] 0 _________________________________________________________________ sequential_3 (Sequential) (None, 150, 150, 3) 0 _________________________________________________________________ rescaling (Rescaling) (None, 150, 150, 3) 0 _________________________________________________________________ xception (Functional) (None, 5, 5, 2048) 20861480 _________________________________________________________________ global_average_pooling2d (Gl (None, 2048) 0 _________________________________________________________________ dropout (Dropout) (None, 2048) 0 _________________________________________________________________ dense_7 (Dense) (None, 1) 2049 ================================================================= Total params: trăng tròn,863,529 Trainable params: trăng tròn,809,001 Non-trainable params: 54,528 _________________________________________________________________ Epoch 1/10 291/291 [==============================] - 567s 2s/step - loss: 0.0749 - binary_accuracy: 0.9689 - val_loss: 0.0605 - val_binary_accuracy: 0.9776 Epoch 2/10 291/291 [==============================] - 551s 2s/step - loss: 0.0559 - binary_accuracy: 0.9770 - val_loss: 0.0507 - val_binary_accuracy: 0.9798 Epoch 3/10 291/291 [==============================] - 545s 2s/step - loss: 0.0444 - binary_accuracy: 0.9832 - val_loss: 0.0502 - val_binary_accuracy: 0.9807 Epoch 4/10 291/291 [==============================] - 558s 2s/step - loss: 0.0365 - binary_accuracy: 0.9874 - val_loss: 0.0506 - val_binary_accuracy: 0.9807 Epoch 5/10 291/291 [==============================] - 550s 2s/step - loss: 0.0276 - binary_accuracy: 0.9890 - val_loss: 0.0477 - val_binary_accuracy: 0.9802 Epoch 6/10 291/291 [==============================] - 588s 2s/step - loss: 0.0206 - binary_accuracy: 0.9916 - val_loss: 0.0444 - val_binary_accuracy: 0.9832 Epoch 7/10 291/291 [==============================] - 542s 2s/step - loss: 0.0206 - binary_accuracy: 0.9923 - val_loss: 0.0502 - val_binary_accuracy: 0.9828 Epoch 8/10 291/291 [==============================] - 544s 2s/step - loss: 0.0153 - binary_accuracy: 0.9939 - val_loss: 0.0509 - val_binary_accuracy: 0.9819 Epoch 9/10 291/291 [==============================] - 548s 2s/step - loss: 0.0156 - binary_accuracy: 0.9934 - val_loss: 0.0610 - val_binary_accuracy: 0.9807 Epoch 10/10 291/291 [==============================] - 546s 2s/step - loss: 0.0176 - binary_accuracy: 0.9936 - val_loss: 0.0561 - val_binary_accuracy: 0.9789 <keras.callbacks.History at 0x7f4495056040>

Sau 10 epochs, fine-tuning đưa đến mang đến tất cả chúng ta một nâng cấp chất lượng đẹp nhất ở trên đây.