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)
