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()