def main():
config = yaml.load(open("./config/config.yaml", "r"),
Loader=yaml.FullLoader)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Training with: {device}")
data_transform = get_simclr_data_transforms(**config['data_transforms'])
train_dataset = datasets.STL10('/home/thalles/Downloads/',
split='train+unlabeled',
download=True,
transform=MultiViewDataInjector(
[data_transform, data_transform]))
# online network
online_network = ResNet18(**config['network']).to(device)
pretrained_folder = config['network']['fine_tune_from']
# load pre-trained model if defined
if pretrained_folder:
try:
checkpoints_folder = os.path.join('./runs', pretrained_folder,
'checkpoints')
# load pre-trained parameters
load_params = torch.load(
os.path.join(os.path.join(checkpoints_folder, 'model.pth')),
map_location=torch.device(torch.device(device)))
if 'online_network_state_dict' in load_params:
online_network.load_state_dict(
load_params['online_network_state_dict'])
print("Parameters successfully loaded.")
except FileNotFoundError:
print("Pre-trained weights not found. Training from scratch.")
# predictor network
predictor = MLPHead(
in_channels=online_network.projetion.net[-1].out_features,
**config['network']['projection_head']).to(device)
# target encoder
target_network = ResNet18(**config['network']).to(device)
optimizer = torch.optim.SGD(
list(online_network.parameters()) + list(predictor.parameters()),
**config['optimizer']['params'])
trainer = BYOLTrainer(online_network=online_network,
target_network=target_network,
optimizer=optimizer,
predictor=predictor,
device=device,
**config['trainer'])
trainer.train(train_dataset)
def main():
config = yaml.load(open("./config/config.yaml", "r"),
Loader=yaml.FullLoader)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Training with: {device}")
data_transform = get_simclr_data_transforms(**config['data_transforms'])
data_transform2 = get_simclr_data_transforms(**config['data_transforms'],
blur=1.)
# get_simclr_data_transforms_onlyglobal
# data_transform = get_simclr_data_transforms_randAugment(config['data_transforms']['input_shape'])
# data_transform2 = get_simclr_data_transforms_randAugment(config['data_transforms']['input_shape'])
train_dataset = datasets.STL10('/media/snowflake/Data/',
split='train+unlabeled',
download=True,
transform=MultiViewDataInjector(
[data_transform, data_transform2]))
# train_dataset = STL(["/home/snowflake/Descargas/STL_data/unlabeled_images",
# "/home/snowflake/Descargas/STL_data/train_images"],
# transform=MultiViewDataInjector([data_transform, data_transform2]))
# online network (the one that is trained)
online_network = ResNet(**config['network']).to(device)
# online_network = MLPmixer(**config['network']).to(device)
# target encoder
# target_network = ResNet_BN_mom(**config['network']).to(device)
target_network = ResNet(**config['network']).to(device)
# target_network = MLPmixer(**config['network']).to(device)
pretrained_folder = config['network']['fine_tune_from']
# load pre-trained model if defined
if pretrained_folder:
try:
checkpoints_folder = os.path.join('./runs', pretrained_folder,
'checkpoints')
# load pre-trained parameters
load_params = torch.load(
os.path.join(os.path.join(checkpoints_folder, 'model.pth')),
map_location=torch.device(torch.device(device)))
online_network.load_state_dict(
load_params['online_network_state_dict'])
target_network.load_state_dict(
load_params['target_network_state_dict'])
except FileNotFoundError:
print("Pre-trained weights not found. Training from scratch.")
# predictor network
predictor = MLPHead_DINO(
in_channels=online_network.projetion.net[-1].out_features,
**config['network']['projection_head']).to(device)
optimizer = torch.optim.SGD(
list(online_network.parameters()) + list(predictor.parameters()),
**config['optimizer']['params'])
trainer = BYOLTrainer(online_network=online_network,
target_network=target_network,
optimizer=optimizer,
predictor=predictor,
device=device,
**config['trainer'])
trainer.train(train_dataset)
def main():
parser = ArgumentParser()
parser.add_argument('--incr', action='store_true', help='train representation incrementally')
parser.add_argument('--id', type=str, default='', dest='experiment_id',
help='experiment id appended to saved files')
args = parser.parse_args()
config = yaml.load(open("./config/config.yaml", "r"), Loader=yaml.FullLoader)
n_class_epochs = config['other']['n_class_epochs']
eval_step = config['other']['eval_step']
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Training with: {device}")
data_transform = get_simclr_data_transforms(**config['data_transforms'])
#train_dataset = datasets.STL10('../../data', split='train+unlabeled', download=False,
# transform=MultiViewDataInjector([data_transform, data_transform]))
# online network
online_network = ResNet18(**config['network']).to(device)
pretrained_folder = config['network']['fine_tune_from']
# load pre-trained model if defined
if pretrained_folder:
try:
checkpoints_folder = os.path.join('./runs', pretrained_folder, 'checkpoints')
# load pre-trained parameters
load_params = torch.load(os.path.join(os.path.join(checkpoints_folder, 'model.pth')),
map_location=torch.device(torch.device(device)))
online_network.load_state_dict(load_params['online_network_state_dict'])
except FileNotFoundError:
print("Pre-trained weights not found. Training from scratch.")
# predictor network
predictor = MLPHead(in_channels=online_network.projection.net[-1].out_features,
**config['network']['projection_head']).to(device)
# target encoder
target_network = ResNet18(**config['network']).to(device)
optimizer = torch.optim.SGD(list(online_network.parameters()) + list(predictor.parameters()),
**config['optimizer']['params'])
trainer = BYOLTrainer(online_network=online_network,
target_network=target_network,
optimizer=optimizer,
predictor=predictor,
device=device,
**config['trainer'])
num_workers = config['trainer']['num_workers']
batch_size_train = 100
batch_size_test = 200
if args.incr:
incr_train_loaders, incr_val_loaders = get_dataloader_incr(data_dir='../../data', base='CIFAR10', num_classes=10,
img_size=224, classes_per_exposure=2, train=True,
num_workers=num_workers, batch_size_train=batch_size_train,
batch_size_test=batch_size_test,
transform=MultiViewDataInjector([data_transform, data_transform]))
# get train and val indices sampled
train_indices = np.concatenate([ldr.sampler.indices for ldr in incr_train_loaders])
train_class_dataloader = DataLoader(incr_train_loaders[0].dataset, sampler=SubsetRandomSampler(train_indices),
batch_size=batch_size_train, num_workers=num_workers)
#trainer.train(train_dataset)
trainer.train_incr(incr_train_loaders, incr_val_loaders,
n_class_epochs=n_class_epochs,
train_class_dataloader=train_class_dataloader,
experiment_id=args.experiment_id,
eval_step=eval_step)
else:
train_loader, val_loader = get_dataloader(data_dir='../../data', base='CIFAR10', num_classes=10,
img_size=224, train=True, num_workers=num_workers,
batch_size_train=batch_size_train, batch_size_test=batch_size_test,
transform=MultiViewDataInjector([data_transform, data_transform]))
trainer.train(train_loader, val_loader, n_class_epochs=n_class_epochs, experiment_id=args.experiment_id,
eval_step=eval_step)
def main(args):
config = yaml.load(open("./config/config.yaml", "r"),
Loader=yaml.FullLoader)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Training with: {device}")
data_transform = get_simclr_data_transforms(**config['data_transforms'])
train_dataset_1 = datasets.CIFAR10(root='../STL_model/data',
train=True,
download=True,
transform=MultiViewDataInjector(
[data_transform, data_transform]))
data_transforms = torchvision.transforms.Compose(
[transforms.Resize(96), transforms.ToTensor()])
train_dataset_2 = datasets.CIFAR10(root='../STL_model/data',
train=True,
download=True,
transform=MultiViewDataInjector(
[data_transforms, data_transforms]))
# online network
online_network = Multi_ResNet18(args.flag_ova,
**config['network']).to(device)
pretrained_folder = config['network']['fine_tune_from']
# load pre-trained model if defined
if pretrained_folder:
try:
checkpoints_folder = os.path.join('./runs', pretrained_folder,
'checkpoints')
# load pre-trained parameters
load_params = torch.load(
os.path.join(os.path.join(checkpoints_folder, 'model.pth')),
map_location=torch.device(torch.device(device)))
online_network.load_state_dict(
load_params['online_network_state_dict'])
except FileNotFoundError:
print("Pre-trained weights not found. Training from scratch.")
# predictor network
predictor = MLPHead(
in_channels=online_network.projetion.net[-1].out_features,
**config['network']['projection_head']).to(device)
# target encoder
target_network = Multi_ResNet18(args.flag_ova,
**config['network']).to(device)
optimizer = torch.optim.SGD(
list(online_network.parameters()) + list(predictor.parameters()),
**config['optimizer']['params'])
trainer = BYOLTrainer(online_network=online_network,
target_network=target_network,
optimizer=optimizer,
predictor=predictor,
device=device,
model_path=args.model_path,
**config['trainer'])
trainer.train((train_dataset_1, train_dataset_2), args.flag_ova)
def get_acc():
batch_size = 8
data_transforms = torchvision.transforms.Compose([transforms.ToTensor()])
config = yaml.load(open("/content/BYOL-UCMerced/config/config.yaml", "r"), Loader=yaml.FullLoader)
data_transform = get_simclr_data_transforms(**config['data_transforms'])
train_dataset = MyDataset(txt='/content/BYOL-UCMerced/data/UCMerced_LandUse/Images/train.txt', transform=MultiViewDataInjector([data_transform, data_transform]))
test_dataset = MyDataset(txt='/content/BYOL-UCMerced/data/UCMerced_LandUse/Images/test.txt', transform=MultiViewDataInjector([data_transform, data_transform]))
print("Input shape:", len(train_dataset))
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size,
num_workers=0, drop_last=False, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size,
num_workers=0, drop_last=False, shuffle=True)
print(type(train_loader))
device = 'cuda' if torch.cuda.is_available() else 'cpu' #'cuda' if torch.cuda.is_available() else 'cpu'
encoder = ResNet18(**config['network'])
output_feature_dim = encoder.projetion.net[0].in_features
#load pre-trained parameters
load_params = torch.load(os.path.join('/content/BYOL-UCMerced/checkpoints/model.pth'),
map_location=torch.device(torch.device(device)))
if 'online_network_state_dict' in load_params:
encoder.load_state_dict(load_params['online_network_state_dict'])
print("Parameters successfully loaded.")
# remove the projection head
encoder = torch.nn.Sequential(*list(encoder.children())[:-1])
encoder = encoder.to(device)
encoder.eval()
logreg = LogisticRegression(output_feature_dim, 21)
logreg = logreg.to(device)
x_train, y_train = get_features_from_encoder(encoder, train_loader)
x_test, y_test = get_features_from_encoder(encoder, test_loader)
if len(x_train.shape) > 2:
x_train = torch.mean(x_train, dim=[2, 3])
x_test = torch.mean(x_test, dim=[2, 3])
print("Training data shape:", x_train.shape, y_train.shape)
print("Testing data shape:", x_test.shape, y_test.shape)
scaler = preprocessing.StandardScaler()
scaler.fit(x_train.cpu())
x_train = scaler.transform(x_train.cpu()).astype(np.float32)
x_test = scaler.transform(x_test.cpu()).astype(np.float32)
train_loader, test_loader = create_data_loaders_from_arrays(torch.from_numpy(x_train), y_train, torch.from_numpy(x_test), y_test)
optimizer = torch.optim.Adam(logreg.parameters(), lr=3e-4)
criterion = torch.nn.CrossEntropyLoss()
eval_every_n_epochs = 10
for epoch in range(200):
# train_acc = []
for x, y in train_loader:
x = x.to(device)
y = y.to(device)
# zero the parameter gradients
optimizer.zero_grad()
logits = logreg(x)
predictions = torch.argmax(logits, dim=1)
loss = criterion(logits, y)
loss.backward()
optimizer.step()
if epoch % eval_every_n_epochs == 0:
train_total,total = 0,0
train_correct,correct = 0,0
for x, y in train_loader:
x = x.to(device)
y = y.to(device)
logits = logreg(x)
predictions = torch.argmax(logits, dim=1)
train_total += y.size(0)
train_correct += (predictions == y).sum().item()
for x, y in test_loader:
x = x.to(device)
y = y.to(device)
logits = logreg(x)
predictions = torch.argmax(logits, dim=1)
total += y.size(0)
correct += (predictions == y).sum().item()
train_acc= train_correct / train_total
acc = correct / total
print(f"Training accuracy: {np.mean(train_acc)}")
print(f"Testing accuracy: {np.mean(acc)}")
def main(args):
log.info("Command line: \n\n" + common_utils.pretty_print_cmd(sys.argv))
log.info(f"Working dir: {os.getcwd()}")
log.info("\n" + common_utils.get_git_hash())
log.info("\n" + common_utils.get_git_diffs())
os.environ["CUDA_VISIBLE_DEVICES"] = f"{args.gpu}"
torch.manual_seed(args.seed)
log.info(args.pretty())
device = 'cuda' if torch.cuda.is_available() else 'cpu'
log.info(f"Training with: {device}")
data_transform = get_simclr_data_transforms_train(args['dataset'])
data_transform_identity = get_simclr_data_transforms_test(args['dataset'])
if args["dataset"] == "stl10":
train_dataset = datasets.STL10(args.dataset_path, split='train+unlabeled', download=True,
transform=MultiViewDataInjector([data_transform, data_transform, data_transform_identity]))
elif args["dataset"] == "cifar10":
train_dataset = datasets.CIFAR10(args.dataset_path, train=True, download=True,
transform=MultiViewDataInjector([data_transform, data_transform, data_transform_identity]))
else:
raise RuntimeError(f"Unknown dataset! {args['dataset']}")
args = hydra2dict(args)
train_params = args["trainer"]
if train_params["projector_same_as_predictor"]:
train_params["projector_params"] = train_params["predictor_params"]
# online network
online_network = ResNet18(dataset=args["dataset"], options=train_params["projector_params"], **args['network']).to(device)
if torch.cuda.device_count() > 1:
online_network = torch.nn.parallel.DataParallel(online_network)
pretrained_path = args['network']['pretrained_path']
if pretrained_path:
try:
load_params = torch.load(pretrained_path, map_location=torch.device(device))
online_network.load_state_dict(load_params['online_network_state_dict'])
online_network.load_state_dict(load_params)
log.info("Load from {}.".format(pretrained_path))
except FileNotFoundError:
log.info("Pre-trained weights not found. Training from scratch.")
# predictor network
if train_params["has_predictor"] and args["method"] == "byol":
predictor = MLPHead(in_channels=args['network']['projection_head']['projection_size'],
**args['network']['predictor_head'], options=train_params["predictor_params"]).to(device)
if torch.cuda.device_count() > 1:
predictor = torch.nn.parallel.DataParallel(predictor)
else:
predictor = None
# target encoder
target_network = ResNet18(dataset=args["dataset"], options=train_params["projector_params"], **args['network']).to(device)
if torch.cuda.device_count() > 1:
target_network = torch.nn.parallel.DataParallel(target_network)
params = online_network.parameters()
# Save network and parameters.
torch.save(args, "args.pt")
if args["eval_after_each_epoch"]:
evaluator = Evaluator(args["dataset"], args["dataset_path"], args["test"]["batch_size"])
else:
evaluator = None
if args["use_optimizer"] == "adam":
optimizer = torch.optim.Adam(params, lr=args['optimizer']['params']["lr"], weight_decay=args["optimizer"]["params"]['weight_decay'])
elif args["use_optimizer"] == "sgd":
optimizer = torch.optim.SGD(params, **args['optimizer']['params'])
else:
raise RuntimeError(f"Unknown optimizer! {args['use_optimizer']}")
if args["predictor_optimizer_same"]:
args["predictor_optimizer"] = args["optimizer"]
if predictor and train_params["train_predictor"]:
predictor_optimizer = torch.optim.SGD(predictor.parameters(), **args['predictor_optimizer']['params'])
## SimCLR scheduler
if args["method"] == "simclr":
trainer = SimCLRTrainer(log_dir="./", model=online_network, optimizer=optimizer, evaluator=evaluator, device=device, params=args["trainer"])
elif args["method"] == "byol":
trainer = BYOLTrainer(log_dir="./",
online_network=online_network,
target_network=target_network,
optimizer=optimizer,
predictor_optimizer=predictor_optimizer,
predictor=predictor,
device=device,
evaluator=evaluator,
**args['trainer'])
else:
raise RuntimeError(f'Unknown method {args["method"]}')
trainer.train(train_dataset)
if not args["eval_after_each_epoch"]:
result_eval = linear_eval(args["dataset"], args["dataset_path"], args["test"]["batch_size"], ["./"], [])
torch.save(result_eval, "eval.pth")