Repository navigation
Expand file tree
/
Copy pathtrainer_code.py
More file actions
109 lines (97 loc) · 4.28 KB
/
Copy pathtrainer_code.py
File metadata and controls
109 lines (97 loc) · 4.28 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
# Use machiraj_attks conda environment
import wandb
import sys
import argparse
import torch
from torch.optim.lr_scheduler import StepLR
# fix torch seed
torch.manual_seed(42)
# fix cuda seed
torch.cuda.manual_seed(42)
# fix cudnn seed for reproducibility
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
torch.cuda.empty_cache()
# sys.path.pop()
# wandb.login()
sys.path.insert(0, "..")
sys.path.append("../")
from misc.utils import *
from data.data import *
from models.model_loader import *
from eval.classic_eval import Evaluator
from eval.attack_eval import AttackEvaluator
class Trainer():
def __init__(self, model, params, trainloader, testloader, device):
self.device = device
self.params = params
self.trainloader = trainloader
self.testloader = testloader
self.model = model
# self.optimizer = torch.optim.SGD(model.parameters(), self.params['lr'], momentum=self.params['momentum'], weight_decay=self.params['weight_decay'])
# self.scheduler = StepLR(self.optimizer, step_size=30, gamma=0.1)
# option 2 :
# self.optimizer = torch.optim.Adam([{'params':model.parameters(), 'lr':self.params['lr']}])
# self.scheduler = torch.optim.lr_scheduler.MultiStepLR(self.optimizer, milestones=[30, 60], gamma=0.1)
# option 3 : sgd + one cycle policy
self.optimizer = torch.optim.SGD(model.parameters(), self.params['lr'], momentum=0.9, weight_decay=5e-4)
self.scheduler = torch.optim.lr_scheduler.OneCycleLR(self.optimizer, max_lr=self.params['lr'], steps_per_epoch=len(self.trainloader), epochs=self.params['total_epochs'])
self.total_epochs = self.params['total_epochs']
self.logger = self.params['logger']
self.ce_loss = nn.CrossEntropyLoss()
self.save_path = self.params['save_path']
def train_one_epoch(self, epoch):
self.model.train()
correct = 0
for batch_idx, (data, target) in enumerate(self.trainloader):
print("Train Batch: ", batch_idx)
data, target = data.to(self.device), target.to(self.device)
self.optimizer.zero_grad()
output = self.model(data)
curr_loss = self.ce_loss(output, target)
curr_loss.backward()
self.optimizer.step()
# for option 3 ..one cycle policy
self.scheduler.step()
self.logger.log({'Epoch': epoch, 'Train batch Loss': curr_loss.item(), 'Learning Rate': self.scheduler.get_last_lr()})
# get train accuracy
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
# self.scheduler.step()
self.logger.log({'Epoch': epoch, 'Train Accuracy': 100. * correct / len(self.trainloader.dataset)})
return
def test_one_epoch(self, epoch):
self.model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for batch_idx, (data, target) in enumerate(self.testloader):
print("Test Batch: ", batch_idx)
data, target = data.to(self.device), target.to(self.device)
output = self.model(data)
test_loss += self.ce_loss(output, target).item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(self.testloader.dataset)
self.logger.log({'Epoch': epoch, 'Test Loss': test_loss})
self.logger.log({'Epoch': epoch, 'Test Accuracy': 100. * correct / len(self.testloader.dataset)})
return
def save_model(self, epoch):
print("Saving model")
state = {
"net": self.model.state_dict(),
"epoch": epoch,
}
ckpt_name = self.save_path + "/epoch_" + str(epoch) + "_ckpt.pth"
torch.save(state, ckpt_name)
return
def run(self):
# for epoch in range(0, self.total_epochs + 2):
for epoch in range(0, self.total_epochs + 2):
print("Epoch: ", epoch)
self.logger.log({'Epoch': epoch})
self.train_one_epoch(epoch)
if epoch % 10 == 0 or epoch == self.total_epochs:
self.test_one_epoch(epoch)
self.save_model(epoch)
return