def __init__(self, root: str, results_dir: str): """Creates the trainer class. Args: root: path to the MNIST data root. results_dir: Logging path to use. """ self.root = root self.train_data = MNIST(root, transform=ToTensor()) self.test_data = MNIST(root, train=False, transform=ToTensor()) self.result_dir = results_dir # Make sure results_dir exists if not exists(results_dir) or not isdir(results_dir): mkdir(results_dir)
def __init__(self, image_root, image_name, mean=[119.71304156, 119.71304156, 119.71304156], std=[27.5233033, 27.5233033, 27.5233033]): self.root = image_root self.file = [] self.transform = Compose([ToTensor()]) #Normalize(mean,std) for name in image_name: img_file = os.path.join(self.root, name) self.file.append({'img': img_file, 'name': name})
def __init__(self, image_dir): super(DataSetFromFolderForPix2Pix, self).__init__() self.photo_path = join(image_dir, "A") self.sketch_path = join(image_dir, "B") self.image_filenames = [ x for x in listdir(self.photo_path) if is_image_file(x) ] transform_list = [ ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] self.transform = Compose(transform_list)
def __init__(self, dataset_root="./dataset", train_batch_size=8, val_batch_size=8, num_workers=0): super().__init__() self.dataset_root = dataset_root self.train_batch_size = train_batch_size self.val_batch_size = val_batch_size self.num_workers = num_workers self.transform = Compose([ ToTensor(), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])
class IsicDataset(Dataset): """PyTorch Dataset for the ISIC 2018 dataset from 'Skin Lesion Analysis Toward Melanoma Detection 2018: A Challenge Hosted by the International Skin Imaging Collaboration (ISIC)',""" _pbar_col: ClassVar[str] = "#fac000" _rest_api_url: ClassVar[str] = "https://isic-archive.com/api/v1" def __init__( self, root: str | Path, download: bool = True, max_samples: int = 25_000, # default is the number of samples used for the NSLB paper sens_attr: IsicAttrs = IsicAttrs.histo, target_attr: IsicAttrs = IsicAttrs.malignant, transform: Transform | None = ToTensor(), target_transform: Transform | None = None, ) -> None: super().__init__() self.root = Path(root) self.download = download self._data_dir = self.root / "ISIC" self._processed_dir = self._data_dir / "processed" self._raw_dir = self._data_dir / "raw" if max_samples < 1: raise ValueError("max_samples must be a positive integer.") self.max_samples = max_samples if self.download: self._download_data() self._preprocess_data() elif not self._check_downloaded(): raise RuntimeError( f"Data don't exist at location {self._processed_dir.resolve()}. " "Have you downloaded it?") self.metadata = pd.read_csv(self._processed_dir / "labels.csv") # Divide up the dataframe into it's constituent arrays because indexing with pandas is # considerably slower than indexing with numpy/torch self.x = self.metadata["path"].values self.s = torch.as_tensor(self.metadata[sens_attr.name], dtype=torch.int32) self.y = torch.as_tensor(self.metadata[target_attr.name], dtype=torch.int32) self.transform = transform self.target_transform = target_transform
def evaluate_on_imagenet(model: NFNet, dataset_dir: Path, batch_size=50, device='cuda:0'): transforms = Compose([ #Pad32CenterCrop(model.test_imsize), ToTensor(), Resize((model.test_imsize, model.test_imsize), PIL.Image.BICUBIC), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) print(f"Starting evaluation from {dataset_dir}") dataset = get_dataset(dataset_dir, transforms=transforms) dataloader = DataLoader( dataset=dataset, batch_size=batch_size, # F0: 120, F1: 100, F2: 80 shuffle=False, pin_memory=False, num_workers=8) print(f"Validation set contains {len(dataset)} images.") model.to(device) model.eval() processed_imgs = 0 correct_labels = 0 for step, data in enumerate(dataloader): with torch.no_grad(): inputs = data[0].to(device) targets = data[1].to(device) output = model(inputs).type(torch.float32) processed_imgs += targets.size(0) _, predicted = torch.max(output, 1) correct_labels += (predicted == targets).sum().item() batch_padding = int(math.log10(len(dataloader.dataset)) + 1) print( f"\rProcessing {processed_imgs:{batch_padding}d}/{len(dataloader.dataset)}. Accuracy: {100.0*correct_labels/processed_imgs:6.4f}", sep=' ', end='', flush=True) print( f"\nFinished eval. Accuracy: {100.0*correct_labels/processed_imgs:6.4f}" )
def loader(path, mode='image'): if mode == 'image': image = Image.open(path).convert('RGB') image = np.array(image) image = ToTensor()(image) return image elif mode == 'cor': cor = pd.read_csv(path) cor = cor.to_numpy() cor = np.pad(cor, [(0, 1024 - cor.shape[0]), (0, 0)], mode='constant', constant_values=0) cor = torch.from_numpy(cor) cor = cor.type(torch.float32) return cor
def plot_dataset(self): """ Plot Dataset to tensorboard for verification of data """ # load random 30 images from dataset rows = 10 cols = 5 p = (Path(self.opt.dataroot) / self.opt.phase).glob('**/*') files = [x for x in p if x.is_file()] image_grid = torch.tensor([]) for i in range(rows): image_row = torch.tensor([]) for j in range(cols): idx = random.randint(0, len(files) - 1) image = ToTensor()(Image.open(files[idx]).resize((200, 100))) image_row = torch.cat((image_row, image), 1) image_grid = torch.cat((image_grid, image_row), 2) self.writer.add_image(f'Dataset/{self.opt.phase}', image_grid, 0)
from torch.utils.data import Dataset import numpy as np import torch from torch.utils.data.dataloader import DataLoader from torchvision.datasets import ImageFolder from torchvision.transforms.transforms import ToPILImage, ToTensor class OFDataset(Dataset): def __init__(self, root, transform, train=True): self.data = ImageFolder(root, transform=transform) self.train = train def __getitem__(self, idx): if self.train: images, _ = self.data[idx] labels = torch.tensor(np.loadtxt("data/train.txt"))[idx] return (images, labels) else: return self.data[idx] def __len__(self): return len(self.data) if __name__ == "__main__": trainset = OFDataset(root="data/of-train-images-color", transform=ToTensor()) loader = DataLoader(trainset, batch_size=3, shuffle=False) x, y = iter(loader).next() print(y)
def __init__(self, N: int, M: int, totensor=True): self.totensor = ToTensor() if totensor else None self.N = N self.M = M self.magnitude_controller = 1
def get_data(dataset="MITIndoor67", root=None, train_folder='train', val_folder='val', batch_size=64, ten_crops=False, with_attribute=False): assert root is not None train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), PowerPIL(), # transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0), # transforms.Resize((256, 256), interpolation=Image.BICUBIC), # transforms.CenterCrop((224, 224)), # transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), # RandomErasing(probability=0.5, mean=[0.0, 0.0, 0.0]), ]) if ten_crops: val_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.TenCrop((224, 224)), Lambda(lambda crops: torch.stack([ToTensor()(crop) for crop in crops])), # returns a 4D tensor Lambda(lambda crops: torch.stack( [Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])(crop) for crop in crops])), ]) else: val_transform = transforms.Compose([ # transforms.Resize((256, 256), interpolation=Image.BICUBIC), # transforms.CenterCrop((224, 224)), transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) if dataset == "ADE20K": train_set = ADE20KDataset(root, folder=train_folder, transform=train_transform, with_attribute=with_attribute) val_set = ADE20KDataset(root, folder=val_folder, transform=val_transform, with_attribute=with_attribute) assert len(train_set) == 20210 assert len(val_set) == 2000 assert len(train_set.classes) == 1055 elif dataset == "MITIndoor67": train_set = MITIndoor67Dataset(osp.join(root, train_folder), train_transform, with_attribute=with_attribute) val_set = MITIndoor67Dataset(osp.join(root, val_folder), val_transform, with_attribute=with_attribute) assert len(val_set) == 20 * 67 assert len(train_set) == 80 * 67 assert len(train_set.classes) == 67 elif dataset == "SUN397": train_set = SUN397Dataset(osp.join(root, train_folder), train_transform, with_attribute=with_attribute) val_set = SUN397Dataset(osp.join(root, val_folder), val_transform, with_attribute=with_attribute) assert (len(train_set) == 50 * 397) assert (len(val_set) == 50 * 397) assert len(train_set.classes) == 397 #weigths = get_attr_weight(train_set) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4) val_loader = torch.utils.data.DataLoader(val_set, batch_size=batch_size, shuffle=True, num_workers=4) assert len(train_set.classes) == len(val_set.classes) print('Dataset loaded!') print(f'Train set. Size {len(train_set.imgs)}') print(f'Validation set. Size {len(val_set.imgs)}') print('Train set number of scenes: {}'.format(len(train_set.classes))) print('Validation set number of scenes: {}'.format(len(val_set.classes))) return train_loader, val_loader, train_set.classes, train_set.attributes if with_attribute else []
def get_transform(self): tfms = [] tfms.append(ToTensor()) return Compose(tfms)
def main(args): def print2(parms, *aargs, **kwargs): redirect(parms, path=args.outfile, *aargs, **kwargs) start_time = time.time() # print args recap print2(args, end='\n\n') # Load the core50 data # TODO: check the symbolic links as for me no '../' prefix needed. if args.download: print2('cli switch download set to True so download will occur...') print2(' alternatively the batch script fetch_data_and_setup.sh can be used') print2('using directory for data_path path {}'.format(args.data_path)) core50 = Core50(args.data_path, train=True, download=args.download) core50_val = Core50(args.data_path, train=False, download=args.download) # A new classes scenario, using continuum scenario = ClassIncremental( core50, increment=5, initial_increment=10, # following values come from the the mean and std of ImageNet - the basis of resnet. transformations=[ ToTensor(), Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])] ) scenario_val = ClassIncremental( core50_val, increment=5, initial_increment=10, # following values come from the the mean and std of ImageNet - the basis of resnet. transformations=[ ToTensor(), Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])] ) print2(f"Number of classes: {scenario.nb_classes}.") print2(f"Number of tasks: {scenario.nb_tasks}.") # Define a model # model if args.classifier == 'resnet18': classifier = models.resnet18(pretrained=True) classifier.fc = torch.nn.Linear(512, args.n_classes) elif args.classifier == 'resnet101': classifier = models.resnet101(pretrained=True) classifier.fc = nn.Linear(2048, args.n_classes) elif args.classifier == 'resnet34': classifier = models.resnet34(pretrained=True) classifier.fc = nn.Linear(512, args.n_classes) else: raise Exception('no classifier picked') # Fix for RuntimeError: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same if torch.cuda.is_available(): classifier.cuda() # TODO: fix device specific cuda usage to we can parallel # TODO: right now probably due to marshalling parallel taking slightly longer # TODO: this parm is now default to false. if args.use_parallel and torch.cuda.device_count() > 1: print2(f"Let's use {torch.cuda.device_count()} GPUs!") classifier = nn.DataParallel(classifier) # Tune the model hyperparameters max_epochs = args.epochs # 8 convergence_criterion = args.convergence_criterion # 0.004 # End early if loss is less than this lr = args.lr # 0.00001 weight_decay = args.weight_decay # 0.000001 momentum = args.momentum # 0.9 # Define a loss function and criterion criterion = nn.CrossEntropyLoss() optimizer = optim.SGD( classifier.parameters(), lr=lr, weight_decay=weight_decay, momentum=momentum ) print2("Criterion: " + str(criterion)) print2("Optimizer: " + str(optimizer)) # Validation accuracies accuracies = [] # Iterate through our NC scenario for task_id, train_taskset in enumerate(scenario): print2(f"<-------------- Task {task_id + 1} ---------------->") # Use replay if it's specified if args.replay: # Add replay examples to current taskset replay_examples = taskset_with_replay(scenario, task_id, args.replay) train_taskset._x = np.append(train_taskset._x, replay_examples['x']) train_taskset._y = np.append(train_taskset._y, replay_examples['y']) train_taskset._t = np.append(train_taskset._t, replay_examples['t']) train_loader = DataLoader(train_taskset, batch_size=32, shuffle=True) unq_cls_train = np.unique(train_taskset._y) print2(f"This task contains {len(unq_cls_train)} unique classes") print2(f"Training classes: {unq_cls_train}") # Train the model classifier.train() if args.importance: # EWC if task_id == 0: train(classifier, task_id, train_loader, criterion, optimizer, max_epochs, convergence_criterion) else: old_tasks = [] for prev_id, prev_taskset in enumerate(scenario): if prev_id == task_id: break else: old_tasks = old_tasks + list(prev_taskset._x) train_ewc(classifier, task_id, train_loader, criterion, EWC(classifier, train_taskset, scenario, task_id), args.importance, optimizer, max_epochs, convergence_criterion) else: train(classifier, task_id, train_loader, criterion, optimizer, max_epochs, convergence_criterion) print2("=== Finished Training ===") classifier.eval() # Validate against separate validation data cum_accuracy = 0.0 for val_task_id, val_taskset in enumerate(scenario_val): # Validate on all previously trained tasks (but not future tasks) if val_task_id > task_id: break val_loader = DataLoader(val_taskset, batch_size=32, shuffle=True) # Make sure we're validating the correct classes unq_cls_validate = np.unique(val_taskset._y) print2(f"Validating classes: {unq_cls_validate} -- val_task_id:{val_task_id} task_id:{task_id}") total = 0.0 correct = 0.0 pred_classes = np.array([]) with torch.no_grad(): for x, y, t in val_loader: x, y = x.cuda(), y.cuda() outputs = classifier(x) _, predicted = torch.max(outputs.data, 1) pred_classes = np.unique(np.append(pred_classes, predicted.cpu())) total += y.size(0) correct += (predicted == y).sum().item() print2(f"Classes predicted: {pred_classes}") print2(f"=== Validation Accuracy: {100.0 * correct / total}%\n") cum_accuracy += (correct / total) avg_accuracy = cum_accuracy / 9 print2(f"Average Accuracy: {100.0 * avg_accuracy:.5f}% [{avg_accuracy:.5f}]") accuracies.append((cum_accuracy / 9)) # print2(f"Average Accuracy: {100.0 * cum_accuracy / 9.0}%") # Running Time print2("--- %s seconds ---" % (time.time() - start_time)) # TO DO Add EWC Training # Some plots over time from pathlib import Path Path('continuum/output').mkdir(parents=True, exist_ok=True) plt.plot([1, 2, 3, 4, 5, 6, 7, 8, 9], accuracies, '-o', label="Naive") #plt.plot([1, 2, 3, 4, 5, 6, 7, 8, 9], rehe_accs, '-o', label="Rehearsal") #plt.plot([1, 2, 3, 4, 5, 6, 7, 8, 9], ewc_accs, '-o', label="EWC") plt.xlabel('Tasks Encountered', fontsize=14) plt.ylabel('Average Accuracy', fontsize=14) plt.title('Rehersal Strategy on Core50 w/ResNet18', fontsize=14) plt.xticks([1, 2, 3, 4, 5, 6, 7, 8, 9]) plt.legend(prop={'size': 16}) plt.show() filenames = dt.datetime.now().strftime("%Y%m%d-%H%M%S") plt.savefig('continuum/output/run_'+filenames+'.png')
def train(root: str, results_dir: str, batch_size: int, first_layer: int, second_layer: int, lr: float, momentum: float, decay: float, epochs: int): """Performs training on the network. Args: root: path to the MNIST data root. results_dir: Logging path to use. batch_size: Batch size for training and validation. first_layer: Number of nodes in the first layer. second_layer: Number of nodes in the second layer. lr: Learning rate for the optimizer momentum: Momentum of the optimizer decay: Decay of the optimizer epochs: Number of epochs to train for. """ epochs = 150 if epochs is None else epochs # Create results directory first r_dir = join(results_dir, dt.now().strftime('%y-%m-%d__%H-%M-%S')) while exists(r_dir): # To make sure that the directory doesn't exist. If it does, try # again. r_dir = join(results_dir, dt.now().strftime('%y-%m-%d__%H-%M-%S')) Path(r_dir).mkdir(parents=True, exist_ok=True) # Then load data in train_data = MNIST(root, transform=ToTensor()) train_loader = DataLoader(train_data, batch_size, shuffle=True) test_data = MNIST(root, train=False, transform=ToTensor()) test_loader = DataLoader(test_data, batch_size, shuffle=False) steps_per_epoch = len(train_loader) # Load model model = FCNetwork(784, 10, first_layer, second_layer, (False, False)) layer_crit = (first_layer + second_layer) / 80 # Optimizer and loss function optimizer = SGD(model.parameters(), lr, momentum, weight_decay=decay) loss_criterion = CrossEntropyLoss() for epoch in range(epochs): steps_done = steps_per_epoch * epoch for i, data in enumerate(train_loader): model.train() optimizer.zero_grad() img, cls = data _, _, out = model(img) loss = loss_criterion(out, cls) # Print outs at certain intervals if i % 100 == 0: print("Iteration {:<8}epoch: {:<3} Loss: {:<2.4f}, " "accuracy: {:.4f}".format(str(i + 1) + ":", str(epoch + 1) + ",", loss.item(), calc_batch_accuracy(out, cls))) # Send metrics wandb.log({'loss': loss.item()}, step=steps_done + i + 1) # Do backprop loss.backward() # Do grad clip torch.nn.utils.clip_grad_norm_(model.parameters(), 2.0) optimizer.step() # At the end of the epoch, do validation validation_acc = 0 with torch.no_grad(): for i, data in enumerate(test_loader): model.eval() img, cls = data _, _, out = model(img) validation_acc += calc_batch_accuracy(out, cls) validation_acc /= len(test_loader) print("Epoch{} validation accuracy: {}".format(epoch, validation_acc)) wandb.log({'accuracy': validation_acc, 'maximization_criterion': validation_acc - layer_crit}, step=steps_per_epoch * (epoch + 1)) # + 1 since end of epoch torch.save({ 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict()}, join(r_dir, 'epoch_{}.pth'.format(epoch)) )
def __init__(self, policy, totensor=True): self.totensor = ToTensor() if totensor else None self.sub_policies = [ self._set_transform_fn(sub_policy) for sub_policy in policy ]
), pytest.param( "transforms.transforms", "RandomAffine", {"degrees": 0}, [], {}, transforms.transforms.RandomAffine(degrees=0), id="RandomAffineConf", ), pytest.param( "transforms.transforms", "RandomApply", {}, [], {"transforms": [ToTensor()]}, transforms.transforms.RandomApply([ToTensor()]), id="RandomApplyConf", ), pytest.param( "transforms.transforms", "RandomChoice", {}, [], {"transforms": [[ToTensor()]]}, transforms.transforms.RandomChoice([ToTensor()]), id="RandomChoiceConf", ), pytest.param( "transforms.transforms", "RandomCrop",
def train(config: dict) -> None: if config['device'].startswith('cuda'): if torch.cuda.is_available(): print( f"Using CUDA{torch.version.cuda} with cuDNN{torch.backends.cudnn.version()}" ) else: raise ValueError( "You specified to use cuda device, but cuda is not available.") if config['pretrained'] is not None: model = pretrained_nfnet(path=config['pretrained'], stochdepth_rate=config['stochdepth_rate'], alpha=config['alpha'], activation=config['activation']) else: model = NFNet(num_classes=config['num_classes'], variant=config['variant'], stochdepth_rate=config['stochdepth_rate'], alpha=config['alpha'], se_ratio=config['se_ratio'], activation=config['activation']) transforms = Compose([ RandomHorizontalFlip(), Resize((model.train_imsize, model.train_imsize), PIL.Image.BICUBIC), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) device = config['device'] dataset = get_dataset(path=config['dataset'], transforms=transforms) if config['overfit']: dataset = Subset(dataset, [i * 50 for i in range(0, 1000)]) dataloader = DataLoader(dataset=dataset, batch_size=config['batch_size'], shuffle=True, num_workers=config['num_workers'], pin_memory=config['pin_memory']) if config['scale_lr']: learning_rate = config['learning_rate'] * config['batch_size'] / 256 else: learning_rate = config['learning_rate'] if not config['do_clip']: config['clipping'] = None if config['use_fp16']: model.half() model.to(device) # "memory_format=torch.channels_last" TBD optimizer = SGD_AGC( # The optimizer needs all parameter names # to filter them by hand later named_params=model.named_parameters(), lr=learning_rate, momentum=config['momentum'], clipping=config['clipping'], weight_decay=config['weight_decay'], nesterov=config['nesterov']) # Find desired parameters and exclude them # from weight decay and clipping for group in optimizer.param_groups: name = group['name'] if model.exclude_from_weight_decay(name): group['weight_decay'] = 0 if model.exclude_from_clipping(name): group['clipping'] = None criterion = nn.CrossEntropyLoss() runs_dir = Path('runs') run_index = 0 while (runs_dir / ('run' + str(run_index))).exists(): run_index += 1 runs_dir = runs_dir / ('run' + str(run_index)) runs_dir.mkdir(exist_ok=False, parents=True) checkpoints_dir = runs_dir / 'checkpoints' checkpoints_dir.mkdir() writer = SummaryWriter(str(runs_dir)) scaler = amp.GradScaler() for epoch in range(config['epochs']): model.train() running_loss = 0.0 processed_imgs = 0 correct_labels = 0 epoch_time = time.time() for step, data in enumerate(dataloader): inputs = data[0].half().to( device) if config['use_fp16'] else data[0].to(device) targets = data[1].to(device) optimizer.zero_grad() with amp.autocast(enabled=config['amp']): output = model(inputs) loss = criterion(output, targets) # Gradient scaling # https://www.youtube.com/watch?v=OqCrNkjN_PM scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() running_loss += loss.item() processed_imgs += targets.size(0) _, predicted = torch.max(output, 1) correct_labels += (predicted == targets).sum().item() epoch_padding = int(math.log10(config['epochs']) + 1) batch_padding = int(math.log10(len(dataloader.dataset)) + 1) print( f"\rEpoch {epoch+1:0{epoch_padding}d}/{config['epochs']}" f"\tImg {processed_imgs:{batch_padding}d}/{len(dataloader.dataset)}" f"\tLoss {running_loss / (step+1):6.4f}" f"\tAcc {100.0*correct_labels/processed_imgs:5.3f}%\t", sep=' ', end='', flush=True) elapsed = time.time() - epoch_time print( f"({elapsed:.3f}s, {elapsed/len(dataloader):.3}s/step, {elapsed/len(dataset):.3}s/img)" ) global_step = epoch * len(dataloader) + step writer.add_scalar('training/loss', running_loss / (step + 1), global_step) writer.add_scalar('training/accuracy', 100.0 * correct_labels / processed_imgs, global_step) #if not config['overfit']: if epoch % 10 == 0 and epoch != 0: cp_path = checkpoints_dir / ("checkpoint_epoch" + str(epoch + 1) + ".pth") torch.save( { 'epoch': epoch, 'model': model.state_dict(), 'optim': optimizer.state_dict(), 'loss': loss }, str(cp_path)) print(f"Saved checkpoint to {str(cp_path)}")
from collections.abc import Iterable from torchvision import datasets, models, transforms from torchvision.transforms.transforms import Compose, Resize, RandomRotation, RandomHorizontalFlip, RandomVerticalFlip, ToTensor from tensorboardX import SummaryWriter data_path = './COVID19_dataset' metadata = './metadata.csv' PATH = 'X:/covid19/CBAM_model_pkls' device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(device) train_aug = Compose([Resize((224, 224)), RandomRotation(180), RandomHorizontalFlip(), RandomVerticalFlip(), ToTensor() ]) val_aug = Compose([Resize((224, 224)), ToTensor() ]) BS = 24 pre_epoch = 0 EPOCH = 50 writer = SummaryWriter(comment = 'Linear') trainset = XRayDataSet(os.path.join(data_path, 'train'), metadata, transforms = train_aug) testset = XRayDataSet(os.path.join(data_path, 'test'), metadata, transforms = val_aug) trainloader = DataLoader(trainset, batch_size = BS, shuffle = True, num_workers = 0) testloader = DataLoader(testset, batch_size = BS, shuffle = True, num_workers = 0)
for m in Net.modules(): if isinstance(m, Linear) or isinstance(m, Conv2d): m.weight.data.normal_(0, 0.01) m.bias.data.zero_() if YOLOv1Config["GPU_NUMS"] > 0: Net = Net.cuda() if YOLOv1Config["GPU_NUMS"] > 1: Net = DataParallel(Net) train_dataset = yoloDataset(root=os.path.join(YOLOv1Config["DATA_PATH"], "VOC2012", "JPEGImages"), list_file='utils/voc2012train.txt', train=True, transform=[ToTensor()]) train_loader = DataLoader(train_dataset, batch_size=YOLOv1Config["BATCH_SIZE"], shuffle=True) criterion = YOLOv1Loss() # 优化器 optimizer = SGD(Net.parameters(), lr=YOLOv1Config["LEARNING_RATE"], momentum=0.95, weight_decay=5e-4) bar = ProgressBar(YOLOv1Config["EPOCHS"], len(train_loader), "Loss:%.3f", current_epoch=FROM_TRAIN_ITER)
# Read csv (video_name, label) df = pd.read_json(args.json_file, orient='records') total_videos = int(df['video_name'].count()) # Add video index column (to be utilized by json) df['video_idx'] = range(total_videos) # Compute the sequence length (no. of frames) for each video (row) df['video_length'] = df['video_name'].apply(lambda x: _count_frames(x, args.frames_dir)) # Image Mean & Std-Dev for Normalization mean = np.array([0.485, 0.456, 0.406]) std = np.array([0.229, 0.224, 0.225]) dataset = VideoFramesDataset(args.frames_dir, df, Compose([Resize((224, 224)), ToTensor(), Normalize(mean, std)])) # dataset = VideoFramesDataset(args.frames_dir, df, Compose([Resize((224, 224)), ToTensor()])) # for sanity check # Compute the max sequence length, needed for embedding array - [N, F, D] max_video_len = compute_max_frames_len(args.frames_dir) total_frames = dataset.__len__() print('Total Videos: {} | Total Frames: {} | Max Video length: {}'. format(total_videos, total_frames, max_video_len)) dataloader = DataLoader(dataset, args.batch_size, num_workers=args.num_workers) # Load model model, emb_dim = load_cnn(args.model) model.to(device)
losses = [] accuracies = [] n_epochs = 100 learning_rate = 0.1 lr_decay = 5 # every 10 epochs, the learning rate is divided by 10 batch_size = 4 use_cuda = False # use True to switch to GPU mydata = load_dataset() device = torch.device("cuda" if use_cuda else "cpu") model = GymnModel().to(device) print('The model has {0} parameters'.format( sum([len(i.reshape(-1)) for i in model.parameters()]))) data_transformers = Compose([ToTensor()]) train_loader, test_loader = getDataLoaders(mydata, batch_size, data_transformers, test_ratio=0.1) print('Number of train examples: {0}, number of test examles: {1}'.format( len(train_loader.dataset), len(test_loader.dataset))) optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) lr_scheduler = StepLR(optimizer, step_size=1, gamma=0.96) best_acc = 0 for epoch in range(1, n_epochs + 1): tic = time.time() epoch_loss = train(model, device, train_loader, optimizer, epoch) print('Training loss for epoch {0} is {1:.5f}. LR={2}'.format(
import PIL from PIL import Image import torch import torch.nn as nn from torch.nn.utils.rnn import pad_sequence from torchvision.transforms.transforms import Compose, Normalize, Resize, ToTensor, RandomHorizontalFlip, RandomCrop # IO transform = Compose([ #RandomHorizontalFlip(), Resize((256,256), PIL.Image.BICUBIC), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) def get_train_file_path(image_ids): # print(image_id) # return "../input/bms-molecular-translation/train/{}/{}/{}/{}.png".format( # image_id[0], image_id[1], image_id[2], image_id # ) return [ "./input/train/{}/{}/{}/{}.png".format( image_id[0], image_id[1], image_id[2], image_id) for image_id in image_ids ] def get_test_file_path(image_ids): return [ "./input/test/{}/{}/{}/{}.png".format(
def get_transform(self): tfms = [] tfms.append(ToTensor()) #tfms.append(Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])) return Compose(tfms)
def get_transforms(): # transform = Compose([random_rotation, ToPILImage(), RandomCrop(46), Resize((48,48)), # RandomHorizontalFlip(0.5), ToTensor()]) transform = Compose([ToPILImage(), RandomHorizontalFlip(0.5), ToTensor()]) return transform
from sklearn.decomposition import PCA from sklearn.metrics import classification_report duration = 2000 freq = 440 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') data_path = './COVID19_dataset' metadata = './metadata.csv' PATH = './' model = resnet18(pretrained=True).to(device) model.load_state_dict( torch.load('./CBAM_model_pkls/CBAM(freezemore)_model_epoch_48.pkl')) train_aug = Compose([Resize((224, 224)), ToTensor()]) val_aug = Compose([Resize((224, 224)), ToTensor()]) BS = 1 Train_features = [] Train_classes = [] Test_features = [] Test_classes = [] trainset = XRayDataSet(os.path.join(data_path, 'train'), metadata, transforms=train_aug) testset = XRayDataSet(os.path.join(data_path, 'test'), metadata, transforms=val_aug) trainloader = DataLoader(trainset, batch_size=BS, shuffle=True, num_workers=0) testloader = DataLoader(testset, batch_size=BS, shuffle=True, num_workers=0)