def evaluate_model(args: argparse.ArgumentParser, learner: Learner):
"""Evaluate the model on the test set."""
learner.load()
test_outputs, test_labels, test_loss = learner.evaluate(
learner.container.test_loader)
test_accuracy = get_accuracy(test_outputs, test_labels)
print(f"test_accuracy: {test_accuracy:.3f}")
def setup_learner(args: argparse.ArgumentParser) -> Learner:
"""Setup the learner with a given net and container."""
# Load and process datasets
container = Container(
rootdir=args.rootdir,
batch_size=args.batch_size,
reduction_rate=args.data_rate,
augmentation=args.data_augmentation,
)
dataset_name = args.dataset
if dataset_name == "cifar_scratch":
container.load_scratch_dataset()
elif dataset_name == "cifar_imagenet":
container.load_imagenet_dataset()
else:
raise ValueError(f"Dataset: {dataset_name} is not known")
# Initialize the model
model_type = args.model
if model_type == "naive_convnet":
net = NaiveConvNet(n_classes=container.n_classes)
elif model_type == "densenet":
net = DenseNet(n_classes=container.n_classes)
elif model_type == "preact_resnet":
net = PreActResNet(n_classes=container.n_classes, r=args.param_rate)
elif model_type == "small_preact_resnet":
net = SmallPreActResNet(n_classes=container.n_classes,
r=args.param_rate)
elif model_type == "pretrained_resnet18":
net = ResNet18(n_classes=container.n_classes)
else:
raise ValueError(f"Model: {model_type} is not known")
quantizer_name = args.quantizer
if quantizer_name == "half":
net = HalfQuantizer(net)
if quantizer_name == "binary":
net = BinaryQuantizer(net)
net_params = {
"learning_rate": args.learning_rate,
"momentum": args.momentum,
"weight_decay": args.weight_decay,
"model_name": args.model_name,
"logs": args.logs,
}
learner = Learner(container, net, **net_params)
assert not ((learner.device == "cuda:0") and (quantizer_name != "half")
), "Half quantizer cannot be used without CUDA"
print("\n")
learner.get_model_summary()
print("\n")
return learner
def fit_model(args: argparse.ArgumentParser, learner: Learner):
# Fit the model
history = learner.fit(n_epochs=args.epochs)
# Plot training curves
log_dir = f"{learner.container.rootdir}/logs/{learner.model_name}"
plot_training_curves(
"loss",
history,
f"{log_dir}/training_curves/loss.png",
)
plot_training_curves(
"accuracy",
history,
f"{log_dir}/training_curves/accuracy.png",
)
train_outputs, train_labels, train_loss = learner.evaluate(
learner.container.train_loader)
train_accuracy = get_accuracy(train_outputs, train_labels)
print(f"train_accuracy: {train_accuracy:.3f}")
def lr_find(start_lr=1e-7,
end_lr=10,
num_it: int = 49,
stop_div: bool = True,
wd: float = None,
annealing_func=annealing_exp):
"Explore lr from `start_lr` to `end_lr` over `num_it` iterations in `learn`. If `stop_div`, stops when loss diverges."
opt = BasicOptim(simple_net.parameters(), start_lr)
cb = LRFinder(start_lr,
end_lr,
num_it,
stop_div,
annealing_func=annealing_func)
learner = Learner(simple_net,
mnist_loss,
opt,
dl,
valid_dl,
cb=CallbackHandler([cb]))
epochs = int(np.ceil(num_it / len(learner.train_dl)))
fit(epochs, learn=learner)
PROCESSING_MODE = 'gpu' # {'cpu', 'gpu'}
if PROCESSING_MODE == 'gpu':
GPU_LIMIT = 1
utilities.set_gpu(GPU_LIMIT)
# Read in settings
settings_df = utilities.read_settings('settings.csv')
# Iterate through session settings
for iter_session in range(settings_df.shape[0]):
session_settings = settings_df.values[iter_session, :]
lrn = Learner(
params={
'dataset_dir': DATASET_DIR,
'model': session_settings[0],
'variant': session_settings[1],
'level': session_settings[2],
'dataset_type': session_settings[3],
'micron_res': session_settings[4],
'downsampling_method': session_settings[5],
'should_clr': session_settings[6],
'should_colour_augment': session_settings[7],
'number_of_epochs': session_settings[8]
})
lrn.train()
lrn.test()
if PROCESSING_MODE == 'gpu':
utilities.clear_model(lrn.model)
a = 1
from config.cfg import Config
from src.models import get_encoder_decoder
from src.datasets import get_dataloaders
from src.learner import Learner
cudnn.benchmark = True
cfg = Config()
encoder, decoder = get_encoder_decoder(cfg)
train_loader, val_loader, test_loader = get_dataloaders(cfg)
test_loader = None
if __name__ == '__main__':
# cmd arguments
parser = argparse.ArgumentParser()
parser.add_argument('--save_dir', type = str, default = cfg.save_dir)
parser.add_argument('--confidence_c', type = float, default = cfg.confidence_c)
args = parser.parse_args()
cfg.save_dir = args.save_dir
cfg.confidence_c = args.confidence_c
# init save_dir and save config.json
os.makedirs(cfg.save_dir, exist_ok = True)
save_cfg_path = os.path.join(cfg.save_dir, 'config.json')
cfg.save_config(save_cfg_path)
# init and start training
learner = Learner(encoder, decoder, train_loader, val_loader, test_loader, cfg)
learner.main_run()
container = Container(
rootdir=args.rootdir,
batch_size=32,
reduction_rate=1,
)
container.load_scratch_dataset()
pruned_model_name = args.model_name + "_pruned"
model_path = args.rootdir + "/models/" + args.model_name + ".pth"
log_file = open(
args.rootdir + f"/logs/sensitivity_pruning_logs_{args.model_name}.txt",
"w+",
)
net = SmallPreActResNet(n_classes=container.n_classes)
learner = Learner(container, net, model_name=pruned_model_name)
# learner.get_model_summary()
if args.pruner == "unstructured":
Pruner = UnstructuredPruner
if args.pruner == "structured":
Pruner = StructuredPruner
no_retrain_res = defaultdict(list)
retrain_res = defaultdict(list)
# Load the model
learner.load(model_path)
# Evaluate without retraining
outputs, labels, loss = learner.evaluate(learner.container.test_loader)
accuracy = get_accuracy(outputs, labels)
from torch.utils.data import DataLoader
from pathlib import Path
from src.callback import CallbackHandler, BatchCounter, TimeCheck, PrintLoss, GetValAcc
from src.data import get_dsets
from src.fit import fit
from src.learner import Learner
from src.measure import mnist_loss
from src.optim import BasicOptim
if __name__ == '__main__':
path = Path('data')
train_dset, valid_dset = get_dsets(path)
dl = DataLoader(train_dset, batch_size=256)
valid_dl = DataLoader(valid_dset, batch_size=256)
simple_net = nn.Sequential(
nn.Linear(28 * 28, 30),
nn.ReLU(),
nn.Linear(30, 1))
lr = 1e-3
opt = BasicOptim(simple_net.parameters(), lr)
learner = Learner(simple_net, mnist_loss, opt, dl, valid_dl,
cb=CallbackHandler([BatchCounter(), TimeCheck(), PrintLoss(), GetValAcc()]))
fit(10, learn=learner)
from argparse import Namespace
from src.learner import Learner
args = Namespace(
# Data and Path information
surname_csv="data/surnames/surnames_with_splits.csv",
vectorizer_file="vectorizer.json",
model_state_file="model.pth",
save_dir="model_storage/ch4/cnn",
# Model hyper parameters
hidden_dim=100,
num_channels=256,
# Training hyper parameters
seed=1337,
learning_rate=0.001,
batch_size=128,
num_epochs=100,
early_stopping_criteria=5,
dropout_p=0.1,
# Runtime options
cuda=False,
reload_from_files=False,
expand_filepaths_to_save_dir=True,
catch_keyboard_interrupt=True)
learner = Learner.learner_from_args(args)
learner.train(learning_rate=1)
import os
from src.config import Config as config
from src.learner import Learner
from src.models.autoencoder import LSTMAutoEncoder
from src.data.dataloaders import get_dataloaders
lstm_autoencoder = LSTMAutoEncoder(
input_size = config.INPUT_SIZE,
hidden_size = config.HIDDEN_SIZE,
num_layers = config.NUM_LAYERS,
dropout_p = config.DROPOUT_P
)
train_loader, val_loader, test_loader = get_dataloaders()
learner = Learner(lstm_autoencoder, train_loader, val_loader, config)
learner.train()