DINOv2 cho Phân Loại Ảnh: So Sánh Fine-Tuning và Transfer Learning
DINOv2 là một trong những mô hình thị giác tự giám sát nổi tiếng nhất hiện nay. Backbone (mạng xương sống) đã được huấn luyện trước của nó có thể được sử dụng cho nhiều tác vụ khác nhau, bao gồm:
- Phân loại ảnh
- Tìm kiếm embedding ảnh
- Phân vùng ngữ nghĩa
- Ước tính độ sâu
- Phát hiện đối tượng
Trong bài viết này, chúng ta sẽ tập trung vào tác vụ phân loại ảnh bằng DINOv2. Đây là một trong những chủ đề cơ bản nhất trong thị giác máy tính dựa trên học sâu, nền tảng của hầu hết các tác vụ hạ nguồn. Hơn nữa, chúng ta sẽ so sánh kết quả giữa việc fine-tuning (tinh chỉnh) toàn bộ mô hình và transfer learning (học chuyển giao).
Nhảy đến phần Tải Code
Hình 1: So sánh Loss và Accuracy giữa transfer learning và fine-tuning khi sử dụng DINOv2 cho phân loại ảnh.
Trong bài viết này, chúng ta sẽ trả lời các câu hỏi sau:
- Tại sao cần so sánh kết quả fine-tuning và transfer learning với DINOv2 cho phân loại ảnh?
- Chúng ta tiếp cận bài toán này như thế nào?
- Chúng ta thiết lập dự án và sử dụng bộ dữ liệu nào?
- Chúng ta có thể mong đợi những kết quả nào từ thử nghiệm này?
Tại sao sử dụng DINOv2 cho Phân Loại Ảnh và So sánh Fine-Tuning và Transfer Learning?
Một trong những điểm nổi bật của bài báo DINOv2 là khả năng hoạt động đặc biệt tốt trong các tác vụ hạ nguồn mà không cần fine-tuning backbone. Mô hình DINOv2, dựa trên backbone Vision Transformer đã được sửa đổi, được huấn luyện trên hơn 142 triệu hình ảnh theo phương pháp tự giám sát. Điều này tạo ra một backbone mạnh mẽ có thể được sử dụng cho nhiều tác vụ hạ nguồn chỉ bằng cách thêm và huấn luyện một “task head” (đầu tác vụ).
Đây chính xác là những gì chúng ta sẽ kiểm tra trong các thử nghiệm của bài viết này.
Trong bài viết trước, chúng ta đã đề cập đến những kiến thức cơ bản về DINOv2. Chúng ta đã đề cập đến các tác vụ, kết quả và so sánh với các mô hình và framework tương tự khác trong lĩnh vực tự giám sát.
Các tác giả đã tập trung rõ ràng vào linear probing (thăm dò tuyến tính) cho phân loại ảnh, trong đó họ huấn luyện một linear classifier (bộ phân loại tuyến tính) trên ImageNet dựa trên các đặc trưng cố định.
Hình 2: Kết quả Linear Probing của DINOv2 trên một số bộ dữ liệu ImageNet.
Trong bài viết này, chúng ta sẽ thử nghiệm điều này trên một bộ dữ liệu nhỏ hơn và cố gắng khẳng định tính phù hợp của nó.
Chúng ta tiếp cận bài toán này như thế nào?
Chúng ta sẽ tải xuống các trọng số backbone chính thức từ Torchhub và thực hiện hai thử nghiệm riêng biệt:
- Thử nghiệm 1: Chúng ta sẽ làm cho cả backbone (DINOv2 đã được huấn luyện trước) và linear classifier có thể huấn luyện được.
- Thử nghiệm 2: Chúng ta sẽ đóng băng backbone và chỉ làm cho linear classifier có thể huấn luyện được.
Đến cuối các thử nghiệm này, chúng ta sẽ có một kết quả rõ ràng.
Bộ Dữ Liệu Phân Loại Bệnh Bông Vải
Không còn nghi ngờ gì nữa, bộ dữ liệu LVD-142M mà mô hình DINOv2 đã được huấn luyện chắc chắn có gần như mọi loại hình ảnh mà chúng ta có thể nghĩ đến. Tuy nhiên, để so sánh và đối chiếu kết quả, chúng ta cố gắng chọn một bộ dữ liệu độc đáo.
Đối với các thử nghiệm của mình, chúng ta chọn Customized Cotton Disease Dataset (Bộ dữ liệu bệnh bông vải tùy chỉnh) từ Kaggle. Bộ dữ liệu này chứa hình ảnh về sâu bệnh trên cây bông và bệnh trên lá bông.
Nếu bạn muốn sao chép kết quả huấn luyện, tôi khuyên bạn nên tải xuống bộ dữ liệu. Sau khi tải xuống và giải nén, bạn sẽ thấy cấu trúc thư mục sau:
├── Cotton-Disease-Training
│ └── trainning
│ └── Cotton leaves - Training
├── Cotton-Disease-Validation
│ └── validation
│ └── Cotton plant disease-Validation
└── Customized Cotton Dataset-Complete
└── content
├── trainning
└── validation
content_copy download Use code with caution.
Mặc dù có một số thư mục con, chúng ta sẽ tập trung vào các thư mục Cotton-Disease-Training và Cotton-Disease-Validation. Chúng lần lượt chứa dữ liệu huấn luyện và xác thực.
Có tổng cộng 6628 mẫu huấn luyện và 356 mẫu xác thực trên 8 lớp. Các lớp là:
['Aphids', 'Army worm', 'Bacterial blight', 'Cotton Boll Rot',
'Green Cotton Boll', 'Healthy', 'Powdery mildew', 'Target spot']
content_copy download Use code with caution.
Sau đây là một vài hình ảnh từ bộ dữ liệu.
Hình 3: Hình ảnh ground truth từ bộ dữ liệu bệnh bông vải.
Nếu bạn quan tâm, hãy xem bài viết huấn luyện mô hình Vision Transformer trên bộ dữ liệu phân loại bệnh bông vải. Bài viết cũng đề cập đến việc trực quan hóa các activation map (bản đồ kích hoạt) sau khi fine-tuning mô hình.
Cấu trúc thư mục dự án
Sau đây là cấu trúc thư mục dự án.
├── input
│ ├── Cotton-Disease-Training
│ ├── Cotton-Disease-Validation
│ ├── Customized Cotton Dataset-Complete
│ ├── inference_data
│ └── customized-cotton-disease-dataset.zip
├── outputs
│ └── transfer_learning
└── src
├── datasets.py
├── inference.py
├── model.py
├── train.py
└── utils.py
content_copy download Use code with caution.
- Thư mục input chứa bộ dữ liệu đã tải xuống mà chúng ta đã thấy trong phần trước.
- Thư mục outputs sẽ chứa tất cả các kết quả huấn luyện và suy luận.
- Tất cả các file code Python có trong thư mục src.
Tất cả các file code và mô hình đã huấn luyện đều có sẵn thông qua phần tải code. Để tự huấn luyện mô hình, bạn cần tải xuống bộ dữ liệu và sắp xếp nó theo cấu trúc thư mục trên.
Tải Code
Bạn có thể tải source code cho hướng dẫn này [tại đây](Liên kết tải xuống).
Huấn Luyện DINOv2 cho Phân Loại Ảnh – So Sánh Fine-Tuning và Transfer Learning
Hãy bắt đầu với các thử nghiệm và kết quả huấn luyện mà không chậm trễ thêm. Mặc dù chúng ta sẽ không thảo luận chi tiết về tất cả các file code Python, nhưng chúng ta sẽ làm như vậy đối với một số file quan trọng.
Tải Mô Hình DINOv2 Đã Huấn Luyện Trước
Việc tải mô hình DINOv2 đã được huấn luyện trước rất đơn giản. Chúng ta có thể làm điều đó dễ dàng với TorchHub. Cần lưu ý rằng kho lưu trữ DINOv2 chính thức cũng cung cấp các mô hình đã được fine-tuning trên ImageNet-1k. Tuy nhiên, chúng ta sẽ chỉ tải backbone đã được huấn luyện trước và thêm classifier head của riêng mình lên trên đó.
Code để chuẩn bị mô hình có trong file src/model.py.
# model.py
import torch
from collections import OrderedDict
def build_model(num_classes=10, fine_tune=False):
backobone_model = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14')
model = torch.nn.Sequential(OrderedDict([
('backbone', backobone_model),
('head', torch.nn.Linear(
in_features=384, out_features=num_classes, bias=True
))
]))
if not fine_tune:
for params in model.backbone.parameters():
params.requires_grad = False
return model
if __name__ == '__main__':
model = build_model()
print(model)
# Total parameters and trainable parameters.
total_params = sum(p.numel() for p in model.parameters())
print(f"{total_params:,} total parameters.")
total_trainable_params = sum(
p.numel() for p in model.parameters() if p.requires_grad)
print(f"{total_trainable_params:,} training parameters.")
content_copy download Use code with caution.Python
Chúng ta đang sử dụng mô hình DINOv2 nhỏ nhất cho trường hợp sử dụng của mình, DINOv2 VIT-Small14. Backbone đã được huấn luyện trước chứa chính xác 22.059.656 tham số. Chúng ta sẽ fine-tune hoặc đóng băng (trong quá trình transfer learning) backbone tùy theo tham số fine_tune trong hàm build_model.
Đầu tiên, chúng ta tải mô hình từ torch.hub. In mô hình backbone DINOv2 cho chúng ta kiến trúc sau.
Hình 4: Kiến trúc DINOv2 ViT-S14.
Như chúng ta có thể thấy, lớp cuối cùng của backbone chứa 384 đặc trưng đầu ra. Vì vậy, việc áp dụng một linear classifier lên trên nó sẽ yêu cầu 384 đặc trưng đầu vào.
Sau khi tải backbone, chúng ta tạo một Sequential Model với OrderDict được đặt tên. Điều này giúp chúng ta tách backbone và head. Sau đó, tùy theo tham số fine_tune, chúng ta đóng băng hoặc bỏ đóng băng backbone.
Các Dataset Transform
Chúng ta sử dụng khá nhiều dataset transform và augmentation trong quá trình chuẩn bị bộ dữ liệu huấn luyện. Sau đây là đoạn code từ src/datasets.py.
# Training transforms
def get_train_transform(image_size):
train_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.RandomResizedCrop((224, 224)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
])
return train_transform
# Validation transforms
def get_valid_transform(image_size):
valid_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.CenterCrop((224, 224)),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
])
return valid_transform
content_copy download Use code with caution.Python
Đối với huấn luyện:
- Đầu tiên, chúng ta thay đổi kích thước hình ảnh thành độ phân giải 256×256.
- Thứ hai, chúng ta áp dụng RandomResizedCrop với độ phân giải 224×224.
- Thứ ba, chúng ta áp dụng lật ngang với xác suất 50%.
Đối với bộ dữ liệu xác thực, chúng ta thay đổi kích thước hình ảnh thành độ phân giải 256×256 và sử dụng center cropping 224×224. Điều này tuân theo quy tắc chính xác mà các tác giả tuân theo để fine-tuning trên bộ dữ liệu ImageNet-1k.
Tôi không thể tìm thấy các thống kê chuẩn hóa LVD-142M cho mục đích fine-tuning. Vì vậy, chúng ta đang sử dụng các giá trị chuẩn hóa ImageNet-1K thay thế.
Đối Số và Siêu Tham Số Huấn Luyện
File train.py trong thư mục src là script huấn luyện có thể thực thi được. Nó cho phép chúng ta truyền các đối số dòng lệnh sau trong khi huấn luyện.
parser.add_argument(
'-e', '--epochs',
type=int,
default=10,
help='Number of epochs to train our network for'
)
parser.add_argument(
'-lr', '--learning-rate',
type=float,
dest='learning_rate',
default=0.001,
help='Learning rate for training the model'
)
parser.add_argument(
'-b', '--batch-size',
dest='batch_size',
default=32,
type=int
)
parser.add_argument(
'--save-name',
dest='save_name',
default='model',
help='file name of the final model to save'
)
parser.add_argument(
'--fine-tune',
dest='fine_tune',
action='store_true',
help='whether to fine-tune the model or train the classifier layer only'
)
parser.add_argument(
'--out-dir',
dest='out_dir',
default='results',
help='output sub-directory path inside the `outputs` directory'
)
parser.add_argument(
'--scheduler',
type=int,
nargs='+',
default=[1000],
help='number of epochs after which learning rate scheduler is applied'
)
content_copy download Use code with caution.Python
Đối với mỗi thử nghiệm huấn luyện, chúng ta sẽ sử dụng một learning rate khác nhau. Vì trong quá trình transfer learning, chúng ta chỉ huấn luyện classifier head, nên learning rate có thể cao hơn so với giai đoạn fine-tuning. Hơn nữa, đối số –out-dir sẽ cho phép chúng ta lưu kết quả trong các thư mục con khác nhau trong thư mục outputs cho mỗi lần chạy huấn luyện.
Ngoài ra, chúng ta đang sử dụng SGD optimizer (thuật toán tối ưu hóa) như đã đề cập trong bài báo. Trong phần B Chi tiết triển khai của bài báo, trong phần B.3 Đánh giá thăm dò tuyến tính, các tác giả đề cập rằng họ sử dụng SGD optimizer cho linear probing. Tuy nhiên, đối với pretraining, AdamW được sử dụng.
Thử Nghiệm Fine-Tuning với DINOv2 cho Phân Loại Ảnh
Chúng ta sẽ bắt đầu với thử nghiệm fine-tuning. Lệnh sau có thể được thực thi trong thư mục src.
python train.py -lr 0.0001 --epochs 20 --batch 32 --out-dir fine_tuning --fine-tune
content_copy download Use code with caution.
Đối với fine-tuning, chúng ta đang sử dụng learning rate 0.0001 và batch size 32. Chúng ta không áp dụng bất kỳ learning rate scheduler nào ở đây vì learning rate cơ bản đã thấp. Chúng ta đang sử dụng batch size thấp hơn vì các lần chạy huấn luyện được thực hiện trên GPU RTX 3070 Ti laptop. Bằng cách này, chúng ta có thể giữ cùng batch size cho cả transfer learning và fine-tuning để so sánh công bằng. Trong quá trình fine-tuning, chúng ta cần nhiều VRAM hơn vì tất cả các tham số đang được điều chỉnh.
Chúng ta nhận được các kết quả sau sau khi huấn luyện (được cắt bớt để ngắn gọn).
Namespace(epochs=20, learning_rate=0.0001, batch_size=32, save_name='model', fine_tune=True, out_dir='fine_tuning', scheduler=[1000])
[INFO]: Number of training images: 6628
[INFO]: Number of validation images: 357
[INFO]: Classes: ['Aphids', 'Army worm', 'Bacterial blight', 'Cotton Boll Rot', 'Green Cotton Boll', 'Healthy', 'Powdery mildew', 'Target spot']
Computation device: cuda
Learning rate: 0.0001
Epochs to train for: 20
Using cache found in /home/sovit/.cache/torch/hub/facebookresearch_dinov2_main
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py:51: UserWarning: xFormers is not available (SwiGLU)
warnings.warn("xFormers is not available (SwiGLU)")
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/attention.py:33: UserWarning: xFormers is not available (Attention)
warnings.warn("xFormers is not available (Attention)")
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/block.py:40: UserWarning: xFormers is not available (Block)
warnings.warn("xFormers is not available (Block)")
Sequential(
(backbone): DinoVisionTransformer(
(patch_embed): PatchEmbed(
(proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))
(norm): Identity()
)
(blocks): ModuleList(
(0-11): 12 x NestedTensorBlock(
(norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(attn): MemEffAttention(
(qkv): Linear(in_features=384, out_features=1152, bias=True)
(attn_drop): Dropout(p=0.0, inplace=False)
(proj): Linear(in_features=384, out_features=384, bias=True)
(proj_drop): Dropout(p=0.0, inplace=False)
)
(ls1): LayerScale()
(drop_path1): Identity()
(norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(mlp): Mlp(
(fc1): Linear(in_features=384, out_features=1536, bias=True)
(act): GELU(approximate='none')
(fc2): Linear(in_features=1536, out_features=384, bias=True)
(drop): Dropout(p=0.0, inplace=False)
)
(ls2): LayerScale()
(drop_path2): Identity()
)
)
(norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(head): Identity()
)
(head): Linear(in_features=384, out_features=8, bias=True)
)
22,059,656 total parameters.
22,059,656 training parameters.
[INFO]: Epoch 1 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [00:57<00:00, 3.62it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 6.86it/s]
Training loss: 1.424, training acc: 48.899
Validation loss: 1.222, validation acc: 57.983
Best validation loss: 1.2215932880838711
Saving best model for epoch: 1
--------------------------------------------------
LR for next epoch: [0.0001]
[INFO]: Epoch 2 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [01:12<00:00, 2.86it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 6.75it/s]
Training loss: 0.736, training acc: 74.713
Validation loss: 1.199, validation acc: 62.745
Best validation loss: 1.1988442229727905
Saving best model for epoch: 2
--------------------------------------------------
LR for next epoch: [0.0001]
[INFO]: Epoch 3 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [01:15<00:00, 2.74it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 6.96it/s]
Training loss: 0.498, training acc: 82.891
Validation loss: 0.712, validation acc: 75.630
Best validation loss: 0.7115460994342963
Saving best model for epoch: 3
--------------------------------------------------
.
.
.
LR for next epoch: [0.0001]
[INFO]: Epoch 19 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [01:14<00:00, 2.77it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 6.68it/s]
Training loss: 0.107, training acc: 96.349
Validation loss: 0.359, validation acc: 89.916
--------------------------------------------------
LR for next epoch: [0.0001]
[INFO]: Epoch 20 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [01:17<00:00, 2.70it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 6.98it/s]
Training loss: 0.101, training acc: 96.334
Validation loss: 0.285, validation acc: 92.997
Best validation loss: 0.2845952277518033
Saving best model for epoch: 20
--------------------------------------------------
LR for next epoch: [0.0001]
TRAINING COMPLETE
content_copy download Use code with caution.
Chúng ta có validation loss thấp nhất là 0.284 và validation accuracy cao nhất là 92.99% ở epoch cuối cùng.
Sau đây là các đồ thị accuracy và loss từ lần chạy huấn luyện fine-tuning.
Hình 5: Đồ thị Accuracy sau khi fine-tuning DINOv2 cho phân loại ảnh.
Hình 6: Đồ thị Loss sau khi fine-tuning DINOv2 cho phân loại ảnh.
Có lẽ huấn luyện lâu hơn một chút sẽ dẫn đến validation loss thấp hơn và validation accuracy cao hơn một chút. Tuy nhiên, rất khó để nói một cách chắc chắn.
Thử Nghiệm Transfer Learning với DINOv2 cho Phân Loại Ảnh
Tiếp theo, hãy đến với thử nghiệm transfer learning.
python train.py -lr 0.0005 --epochs 20 --batch 32 --out-dir transfer_learning --scheduler 10
content_copy download Use code with caution.
Đối với transfer learning, chúng ta đang sử dụng learning rate 0.0005 và cùng batch size 32. Chúng ta đang áp dụng một learning rate scheduler sau 10 epoch để giảm learning rate đi 10 lần.
Sau đây là những kết quả mà chúng ta nhận được.
Namespace(epochs=20, learning_rate=0.0005, batch_size=32, save_name='model', fine_tune=False, out_dir='transfer_learning', scheduler=[10])
[INFO]: Number of training images: 6628
[INFO]: Number of validation images: 357
[INFO]: Classes: ['Aphids', 'Army worm', 'Bacterial blight', 'Cotton Boll Rot', 'Green Cotton Boll', 'Healthy', 'Powdery mildew', 'Target spot']
Computation device: cuda
Learning rate: 0.0005
Epochs to train for: 20
Using cache found in /home/sovit/.cache/torch/hub/facebookresearch_dinov2_main
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py:51: UserWarning: xFormers is not available (SwiGLU)
warnings.warn("xFormers is not available (SwiGLU)")
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/attention.py:33: UserWarning: xFormers is not available (Attention)
warnings.warn("xFormers is not available (Attention)")
/home/sovit/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/block.py:40: UserWarning: xFormers is not available (Block)
warnings.warn("xFormers is not available (Block)")
Sequential(
(backbone): DinoVisionTransformer(
(patch_embed): PatchEmbed(
(proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))
(norm): Identity()
)
(blocks): ModuleList(
(0-11): 12 x NestedTensorBlock(
(norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(attn): MemEffAttention(
(qkv): Linear(in_features=384, out_features=1152, bias=True)
(attn_drop): Dropout(p=0.0, inplace=False)
(proj): Linear(in_features=384, out_features=384, bias=True)
(proj_drop): Dropout(p=0.0, inplace=False)
)
(ls1): LayerScale()
(drop_path1): Identity()
(norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(mlp): Mlp(
(fc1): Linear(in_features=384, out_features=1536, bias=True)
(act): GELU(approximate='none')
(fc2): Linear(in_features=1536, out_features=384, bias=True)
(drop): Dropout(p=0.0, inplace=False)
)
(ls2): LayerScale()
(drop_path2): Identity()
)
)
(norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)
(head): Identity()
)
(head): Linear(in_features=384, out_features=8, bias=True)
)
22,059,656 total parameters.
3,080 training parameters.
[INFO]: Epoch 1 of 20
Training
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 208/208 [00:19<00:00, 10.88it/s]
Validation
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:01<00:00, 8.18it/s]
Training loss: 0.507, training acc: 82.830
Validation loss: 0.251, validation acc: 92.717
Best validation loss: 0.2513936141816278
Saving best model for epoch: 1
--------------------------------------------------
LR for next epoch: [0.0005]
[INFO
content_copy download Use code with caution.
