Repository navigation
Expand file tree
/
Copy pathmain.py
More file actions
116 lines (95 loc) · 5.53 KB
/
Copy pathmain.py
File metadata and controls
116 lines (95 loc) · 5.53 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
"""Efficient Graph-Based Metric Learning for Medical Image Classification.
David Aparco-Cardenas and Alexandre X. Falcão (SIPAIM 2026).
Trains an OPFNet with a two-stage loss (triplet loss -> OPF loss) and
evaluates it with single-model OPF inference.
"""
import argparse
import os
from datetime import datetime
import torch
from torch.nn import TripletMarginLoss
from torch.utils.tensorboard import SummaryWriter
from opfnet.data import NUM_CLASSES, ImageDataset, build_loaders
from opfnet.evaluate import evaluate_opfnet
from opfnet.losses import OPFLoss
from opfnet.model import OPFNet
from opfnet.trainer import train_epoch_opf, train_epoch_triplet
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description='OPFNet Training')
parser.add_argument('--gpu-id', default=0, type=int, help='CUDA device id')
parser.add_argument('--dataset', required=True, choices=list(NUM_CLASSES),
help='dataset name; uses data/<dataset>/<dataset>.{train,test}.csv')
parser.add_argument('--tensorboard-root', default='runs', help='tensorboard folder')
parser.add_argument('--batch-size', default=32, type=int,
help='batch size (triplet stage and data loading)')
parser.add_argument('--batch-size-opf', default=128, type=int,
help='number of samples per OPF-loss step')
parser.add_argument('--embedding-size', default=128, type=int, help='embedding size')
parser.add_argument('--num-workers', default=4, type=int, help='number of data loader workers')
parser.add_argument('--lr-tri', '--lr-cont', dest='lr_tri', default=3e-4, type=float,
help='learning rate of the triplet-loss stage')
parser.add_argument('--lr', default=3e-3, type=float,
help='learning rate of the OPF-loss stage')
parser.add_argument('--num-epochs', default=100, type=int, help='total number of epochs')
parser.add_argument('--transition', default=30, type=int,
help='last epoch of the triplet-loss stage')
parser.add_argument('--test-interval', default=0, type=int,
help='epochs between extra test evaluations (0: only after the last epoch)')
parser.add_argument('--progress', action=argparse.BooleanOptionalAction, default=True,
dest='show_progress', help='show the progress bar (--no-progress to hide it)')
return parser.parse_args()
def print_summary(args: argparse.Namespace, model: torch.nn.Module,
train_dataset: ImageDataset, test_dataset: ImageDataset) -> None:
"""Print the experiment setup (data, model and training schedule)."""
n_params = sum(p.numel() for p in model.parameters())
print(f'dataset: {args.dataset}')
print(f'train / test: {len(train_dataset)} / {len(test_dataset)} images')
print(f'# of params: {n_params / 1e6:.2f}M parameters')
print(f'embedding size: {args.embedding_size}')
print(f'device: {args.device}')
print(f'epochs: {args.num_epochs} epoch')
print(f'transition: at epoch {args.transition}')
print(f'learning rate: {args.lr_tri} (triplet) -> {args.lr} (OPF)')
print(f'batch size: {args.batch_size} (triplet), {args.batch_size_opf} (OPF)')
def main() -> None:
args = parse_args()
print('Efficient Graph-Based Metric Learning for Medical Image Classification\n')
args.num_classes = NUM_CLASSES[args.dataset]
args.train_file = f'data/{args.dataset}/{args.dataset}.train.csv'
args.test_file = f'data/{args.dataset}/{args.dataset}.test.csv'
args.device = torch.device(f'cuda:{args.gpu_id}' if torch.cuda.is_available() else 'cpu')
experiment = datetime.now().strftime(
f'%B%d_%H-%M-%S_opfnet_{args.dataset}_d{args.embedding_size}'
f'_b{args.batch_size_opf}_{args.lr}')
writer = SummaryWriter(os.path.join(args.tensorboard_root, experiment))
train_dataset, train_loader, test_loader = build_loaders(args)
model = OPFNet(embedding_size=args.embedding_size).to(args.device)
print_summary(args, model, train_loader.dataset, test_loader.dataset)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr_tri)
triplet_loss_fn = TripletMarginLoss(margin=1.0, p=2)
opf_loss_fn = OPFLoss(args.num_classes, args.device)
# Two-stage loss (paper Sec. II-E): triplet loss up to `transition`, OPF loss after
step_id = 0
for epoch in range(1, args.num_epochs + 1):
args.epoch = epoch
model.train()
if epoch <= args.transition:
if epoch == 1:
print(f'\n=== Stage 1/2: triplet loss (metric learning), '
f'epochs 1-{min(args.transition, args.num_epochs)}, lr={args.lr_tri} ===')
step_id = train_epoch_triplet(
args, model, optimizer, triplet_loss_fn, train_loader, writer, step_id)
else:
if epoch == args.transition + 1:
# Same optimizer, higher learning rate for the OPF stage
optimizer.param_groups[0]['lr'] = args.lr
print(f'\n=== Stage 2/2: OPF loss (connectivity-based), '
f'epochs {epoch}-{args.num_epochs}, lr={args.lr} ===')
step_id = train_epoch_opf(
args, model, optimizer, opf_loss_fn, train_dataset, writer, step_id)
is_last = epoch == args.num_epochs
if is_last or (args.test_interval > 0 and epoch % args.test_interval == 0):
evaluate_opfnet(args, model, train_loader, test_loader, writer)
writer.close()
if __name__ == '__main__':
main()