def main():
model = se_resnet50(num_classes=1000)
optimizer = optim.SGD(lr=0.6 / 1024 * args.batch_size, momentum=0.9, weight_decay=1e-4)
scheduler = lr_scheduler.MultiStepLR([50, 70])
c = [callbacks.AccuracyCallback(), callbacks.LossCallback()]
r = reporter.TQDMReporter(range(args.epochs), callbacks=c)
tb = reporter.TensorboardReporter(c)
rep = callbacks.CallbackList(r, tb, callbacks.WeightSave("checkpoints"))
if args.distributed:
# DistributedSupervisedTrainer sets up torch.distributed
if args.local_rank == 0:
print("\nuse DistributedDataParallel")
trainer = DistributedSupervisedTrainer(model, optimizer, F.cross_entropy, callbacks=rep, scheduler=scheduler,
init_method=args.init_method, backend=args.backend)
else:
multi_gpus = torch.cuda.device_count() > 1
if multi_gpus:
print("\nuse DataParallel")
trainer = SupervisedTrainer(model, optimizer, F.cross_entropy, callbacks=rep,
scheduler=scheduler, data_parallel=multi_gpus)
# if distributed, need to setup loaders after DistributedSupervisedTrainer
train_loader, test_loader = imagenet_loaders(args.root, args.batch_size, distributed=args.distributed,
num_train_samples=args.batch_size * 10 if args.debug else None,
num_test_samples=args.batch_size * 10 if args.debug else None)
for _ in r:
trainer.train(train_loader)
trainer.test(test_loader)
def main():
if args.distributed:
init_distributed()
model = se_resnet50(num_classes=1000)
optimizer = optim.SGD(lr=0.6 / 1024 * args.batch_size,
momentum=0.9, weight_decay=1e-4)
scheduler = lr_scheduler.MultiStepLR([50, 70])
train_loader, test_loader = imagenet_loaders(args.root, args.batch_size, distributed=args.distributed,
num_train_samples=args.batch_size * 10 if args.debug else None,
num_test_samples=args.batch_size * 10 if args.debug else None)
c = [callbacks.AccuracyCallback(), callbacks.AccuracyCallback(k=5),
callbacks.LossCallback(),
callbacks.WeightSave('.'),
reporters.TensorboardReporter('.'),
reporters.TQDMReporter(range(args.epochs))]
with SupervisedTrainer(model, optimizer, F.cross_entropy,
callbacks=c,
scheduler=scheduler,
) as trainer:
for _ in c[-1]:
trainer.train(train_loader)
trainer.test(test_loader)
def __init__(self,
arch='resnet18',
with_se=False,
with_rpp=False,
use_cbam=False,
class_num=395,
reduction=16):
super(visible_net_resnet, self).__init__()
if arch == 'resnet18':
print("visible_net with resenet18 architecture setting.....")
model_ft = models.resnet18(pretrained=True)
elif arch == 'resnet50':
print("visible_net with resenet50 architecture setting.....")
# model_ft = resnet.resnet50(pretrained=True,with_se=with_se)
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
#add by zc
elif arch == 'se_resnet50':
print("visible_net with se_resnet50 architecture setting.....")
model_ft = se_resnet50(pretrained=True)
elif arch == 'pcb_rpp':
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
elif arch == 'pcb_pyramid':
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
elif arch == 'cbam':
model_ft = resnet.resnet50(pretrained=True, use_cbam=use_cbam)
elif arch == 'scpnet':
model_ft = get_scp_model(pretrained=True, nr_class=class_num)
##end by zc
# avg pooling to global pooling
# if arch == 'pcb_rpp':
# if with_rpp:
# model_ft.avgpool = resnet.RPP()
# print("-------RPP module in visible starting------")
# else:
# model_ft.avgpool = nn.AdaptiveAvgPool2d((6, 1))
# print("-------No RPP module in visible------")
# else:
# model_ft.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.visible = model_ft
self.backbone = model_ft.backbone
self.dropout = nn.Dropout(p=0.5)
#add by zc
self.with_se = with_se
self.arch = arch
self.feature = FeatureBlock(2048, 512, dropout=0.5)
'''
def main():
if is_distributed():
init_distributed()
model = se_resnet50(num_classes=1000)
optimizer = optim.SGD(lr=0.6 / 1024 * args.batch_size,
momentum=0.9,
weight_decay=1e-4)
scheduler = lr_scheduler.MultiStepLR([50, 70])
train_loader, test_loader = DATASET_REGISTRY("imagenet")(args.batch_size)
c = [
callbacks.AccuracyCallback(),
callbacks.AccuracyCallback(k=5),
callbacks.LossCallback(),
callbacks.WeightSave("."),
reporters.TensorboardReporter("."),
reporters.TQDMReporter(range(args.epochs)),
]
with SupervisedTrainer(
model,
optimizer,
F.cross_entropy,
callbacks=c,
scheduler=scheduler,
) as trainer:
for _ in c[-1]:
trainer.train(train_loader)
trainer.test(test_loader)
def main():
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transform = transforms.Compose([
transforms.Resize(256),
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
])
valid_transform = transforms.Compose(
[transforms.Resize(224),
transforms.ToTensor(), normalize])
train_dataset = ImageFolder(args.data, train_transform)
valid_dataset = ImageFolder(args.data, valid_transform)
num_samples = int(len(train_dataset) / 10)
indices = list(range(num_samples))
split = int(np.floor(0.1 * num_samples))
np.random.shuffle(indices)
train_idx, valid_idx = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(valid_idx)
train_loader = DataLoader(train_dataset,
args.batch_size,
sampler=train_sampler,
num_workers=4)
valid_loader = DataLoader(valid_dataset,
args.batch_size,
sampler=valid_sampler,
num_workers=4)
print("num data:", num_samples)
print("num train batches:", len(train_loader))
print("num test batches:", len(valid_loader))
# return
# train_loader, test_loader = cifar10_loaders(args.batch_size)
model = se_resnet50(num_classes=42)
# model.load_state_dict(torch.load("seresnet50-60a8950a85b2b.pkl"))
optimizer = optim.SGD(lr=1e-1, momentum=0.9, weight_decay=1e-4)
scheduler = lr_scheduler.StepLR(80, 0.1)
tqdm_rep = reporters.TQDMReporter(range(args.epochs),
callbacks.AccuracyCallback())
_callbacks = [tqdm_rep, callbacks.AccuracyCallback()]
with Trainer(model,
optimizer,
F.cross_entropy,
scheduler=scheduler,
callbacks=_callbacks) as trainer:
for _ in tqdm_rep:
trainer.train(train_loader)
trainer.test(valid_loader)
torch.save(trainer.model.state_dict(), "se_resnet50.pkl")
def main():
global args
conf = configparser.ConfigParser()
args = parser.parse_args()
conf.read(args.config)
DATA_DIR = conf.get("subject_level", "data")
LABEL_DIR = conf.get("subject_level", "label")
create_dir_not_exist(LABEL_DIR)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
if not args.model:
print("Usage: --model -m\n\tpath to the model")
sys.exit()
model = se_resnet50(num_classes=3)
model = DataParallel(model)
trained_net = torch.load(args.model)
model.load_state_dict(trained_net['state_dict'])
model = model.cuda()
result_list = []
for class_index, class_name in enumerate(CLASSES_NAME):
class_dir = os.path.join(DATA_DIR, class_name)
patient_list = os.listdir(class_dir)
patient_list = [
os.path.join(class_dir, patient) for patient in patient_list
if os.path.isdir(os.path.join(class_dir, patient))
]
print('---------- {} ----------'.format(class_name))
for i, patient_dir in enumerate(patient_list):
slice_list = os.listdir(patient_dir)
if len(slice_list) < 10:
continue
checkSuffix(slice_list)
slice_list = [s for s in slice_list if s[:2] != "._"]
slice_list = [os.path.join(patient_dir, s) for s in slice_list]
scorelist = test(slice_list, class_index, model)
result = np.insert(scorelist, 0, class_index)
print('{} ----- {}'.format(i, len(patient_list)))
result_list.append(list(result))
with open(os.path.join(LABEL_DIR, 'result.csv'), 'w') as f:
f_csv = csv.writer(f)
f_csv.writerows(result_list)
def __init__(self,
arch='resnet18',
with_se=False,
with_rpp=False,
use_cbam=False,
class_num=395,
reduction=16):
super(thermal_net_resnet, self).__init__()
if arch == 'resnet18':
print("thermal_net with resenet18 architecture setting.....")
model_ft = models.resnet18(pretrained=True)
elif arch == 'resnet50':
print("thermal_net with resenet50 architecture setting.....")
# model_ft = resnet.resnet50(pretrained=True,with_se=with_se)
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
#add by zc
elif arch == 'se_resnet50':
print("thermal_net with se_resnet50 architecture setting.....")
model_ft = se_resnet50(pretrained=True)
elif arch == 'pcb_rpp':
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
elif arch == 'pcb_pyramid':
model_ft = resnet.pcb_rpp(pretrained=True,
with_rpp=with_rpp,
use_cbam=use_cbam,
class_num=class_num)
elif arch == 'cbam':
model_ft = resnet.resnet50(pretrained=True, use_cbam=use_cbam)
elif arch == 'scpnet':
model_ft = get_scp_model(pretrained=True, nr_class=class_num)
# avg pooling to global pooling
self.thermal = model_ft
self.backbone = model_ft.backbone
self.dropout = nn.Dropout(p=0.5)
#add by zc
self.with_se = with_se
self.arch = arch
self.feature = FeatureBlock(2048, 512, dropout=0.5)
def main():
train_loader, test_loader = get_dataloader(args.batch_size, args.root)
gpus = list(range(torch.cuda.device_count()))
se_resnet = nn.DataParallel(se_resnet50(num_classes=1000),
device_ids=gpus)
optimizer = optim.SGD(lr=0.6 / 1024 * args.batch_size, momentum=0.9, weight_decay=1e-4)
scheduler = lr_scheduler.StepLR(30, gamma=0.1)
weight_saver = callbacks.WeightSave("checkpoints")
tqdm_rep = reporter.TQDMReporter(range(args.epochs), callbacks=[callbacks.AccuracyCallback()])
trainer = Trainer(se_resnet, optimizer, F.cross_entropy, scheduler=scheduler,
callbacks=callbacks.CallbackList(weight_saver, tqdm_rep))
for _ in tqdm_rep:
trainer.train(train_loader)
trainer.test(test_loader)
def __init__(self):
super(SE_Resnet_feat, self).__init__()
self.model = se_resnet50()
load = torch.load(path_pth)
self.model.load_state_dict(load)
print('SEResNet50 models loaded!')
# using Grad-CAM with softmax weight
params = list(self.model.parameters())
self.weight_softmax = np.squeeze(params[-2].data.numpy())
self.test = True
self.model.eval()
if use_gpu:
self.model = self.model.cuda()
def main():
global args
conf = configparser.ConfigParser()
args = parser.parse_args()
conf.read(args.config)
TEST_DIR = conf.get("senet", "test")
LOG_DIR = conf.get("senet", "log")
create_dir_not_exist(LOG_DIR)
test_list = [os.path.join(TEST_DIR, item) for item in os.listdir(TEST_DIR)]
test_list = checkSuffix(test_list)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
if not args.model:
print("Usage: --model -m\n\tpath to the model")
sys.exit()
model = se_resnet50(num_classes=3)
criterion = nn.CrossEntropyLoss().cuda()
model = DataParallel_withLoss(model, criterion)
trained_net = torch.load(args.model)
model.load_state_dict(trained_net['state_dict'])
model = model.cuda()
vote_pred = np.zeros(len(test_list))
vote_score = np.zeros(len(test_list))
targetlist, scorelist, predlist = test(test_list, model, criterion)
report = classification_report(y_true=targetlist,
y_pred=predlist,
target_names=["Normal", "CAP", "COVID-19"])
print(report)
def get_model(model_name=None):
if not model_name:
model_name = args.model
if model_name == 'resnet18':
model = torchvision.models.resnet18(pretrained=True)
elif model_name == 'alexnet':
model = torchvision.models.alexnet(pretrained=True)
elif model_name == 'squeezenet':
model = torchvision.models.squeezenet1_0(pretrained=True)
elif model_name == 'vgg16':
model = torchvision.models.vgg16(pretrained=True)
elif model_name == 'densenet':
model = torchvision.models.densenet161(pretrained=True)
elif model_name == 'inception':
model = torchvision.models.inception_v3(pretrained=True)
elif model_name == 'googlenet':
model = torchvision.models.googlenet(pretrained=True)
elif model_name == 'shufflenet':
model = torchvision.models.shufflenet_v2_x1_0(pretrained=True)
elif model_name == 'mobilenet':
model = torchvision.models.mobilenet_v2(pretrained=True)
elif model_name == 'resnet50_32x4d':
model = torchvision.models.resnext50_32x4d(pretrained=True)
elif model_name == 'wide_resnet50_2':
model = torchvision.models.wide_resnet50_2(pretrained=True)
elif model_name == 'mnasnet':
model = torchvision.models.mnasnet1_0(pretrained=True)
elif model_name == 'resnext50_32x4d_ssl':
model = torch.hub.load(
'facebookresearch/semi-supervised-ImageNet1K-models',
'resnext50_32x4d_ssl')
elif model_name == 'resnext50_32x4d_swsl':
model = torch.hub.load(
'facebookresearch/semi-supervised-ImageNet1K-models',
'resnext50_32x4d_swsl')
elif model_name == 'resnet50_swsl':
model = torch.hub.load(
'facebookresearch/semi-supervised-ImageNet1K-models',
'resnet50_swsl')
elif 'seresnet50' in model_name:
model = se_resnet50(num_classes=1000)
model.load_state_dict(
torch.load("../checkpoint/seresnet50-60a8950a85b2b.pkl"))
elif model_name == 'T2t_vit_t_14' or model_name == 'T2t_vit_t_24':
model = create_model(
model_name,
pretrained=False,
num_classes=args.num_classes,
in_chans=3,
)
load_checkpoint(model, checkpoint_paths[model_name], True)
else:
model = create_model(
model_name,
pretrained=args.pretrained,
num_classes=args.num_classes,
in_chans=3,
)
if not args.pretrained:
if not args.set_temperature:
load_checkpoint(model, checkpoint_paths[model_name], True)
else:
load_checkpoint(
model, checkpoint_paths[
f"{model_name}_tem{args.set_temperature}"], True)
for i in range(len(model.blocks)):
model.blocks[i].attn.scale = 768**(-1 /
args.set_temperature)
print("Set temperature to: ", model.blocks[0].attn.scale)
return model.eval().to(device)
def preprocess(cls, pil_img):
img_nd = np.array(pil_img)
if len(img_nd.shape) == 2:
img_nd = np.expand_dims(img_nd, axis=2)
# HWC to CHW
img_trans = img_nd.transpose((2, 0, 1))
if img_trans.max() > 1:
img_trans = img_trans / 255
return img_trans
if __name__ == '__main__':
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = se_resnet50(num_classes=1)
model = model.to(device)
model = torch.nn.DataParallel(model)
model.load_state_dict(torch.load(checkpoints))
filename = os.listdir(img_path)
img_path_list = []
for i in filename:
img_path_list.append(os.path.join(img_path, i))
dataset = Xinguan(img_path_list)
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=len(dataset),
shuffle=False,
num_workers=0
)
images = next(iter(dataloader))['image'].to(device)
val_dataset = MyDataset(image_path_list,
label_list,
transform=val_transform)
val_loader = DataLoader(val_dataset,
batch_size=opt.BATCHSIZE,
shuffle=False,
num_workers=opt.NUMWORKER,
pin_memory=True)
if opt.NETWORK == 'resnet':
net = resnet50(pretrained=True)
fc_features = net.fc.in_features
net.fc = torch.nn.Linear(fc_features, 230)
elif opt.NETWORK == 'senet':
net = se_resnet50(num_classes=230)
elif opt.NETWORK == 'repvgg':
net = create_RepVGG_B1g2(num_classes=230)
else:
net = resnet50(num_classes=230)
net = net.to(DEVICE)
# freezing conv features
# for k, v in net.named_parameters():
# if k not in ['fc.weight', 'fc.bias']:
# v.requires_grad = False
loss_func = CrossEntropyLoss(weight=weight_list).to(DEVICE)
optimizer = Adam(net.parameters(), lr=opt.LR, weight_decay=0.0001)
# optimizer = AdamW(net.parameters())
dataloders = get_brats_train_loaders(path, test_path)
# dataset_sizes = {'train': 26778, 'val': 6695}
dataset_sizes = {'train': 16736, 'val': 16736, 'test': 4247}
# dataset_sizes = {'train': 26777, 'val': 6695, 'test': 3791}
# use gpu or not
use_gpu = torch.cuda.is_available()
logger.info("use_gpu:{}".format(use_gpu))
# get model
script_name = '_'.join([
args.network.strip().split('_')[0],
args.network.strip().split('_')[1]
])
if script_name == "se_resnet50":
model = se_resnet50(num_classes=args.num_class)
else:
raise Exception(
"Please give correct network name such as se_resnet_xx or se_rexnext_xx"
)
# define loss function
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=0.00004)
# Decay LR by a factor of 0.1 every 7 epochs
def main():
global args, best_prec1
best_prec1 = 1e6
args = parser.parse_args()
args.original_lr = 1e-6
args.lr = 1e-6
args.momentum = 0.95
args.decay = 5*1e-4
args.start_epoch = 0
args.epochs = 50
args.steps = [-1,1,20,40]
args.scales = [1,1,0.5,0.5]
args.workers = 0
args.seed = time.time()
args.print_freq = 30
wandb.config.update(args)
wandb.run.name = f"Default_{wandb.run.name}" if (args.task == wandb.run.name) else f"{args.task}_{wandb.run.name}"
conf= configparser.ConfigParser()
conf.read(args.config)
TRAIN_DIR = conf.get("senet", "train")
VALID_DIR = conf.get("senet", "valid")
TEST_DIR = conf.get("senet", "test")
LOG_DIR = conf.get("senet", "log")
create_dir_not_exist(LOG_DIR)
train_list = [os.path.join(TRAIN_DIR, item) for item in os.listdir(TRAIN_DIR)]
train_list=checkSuffix(train_list)
val_list = [os.path.join(VALID_DIR, item) for item in os.listdir(VALID_DIR)]
val_list=checkSuffix(val_list)
data_list= train_list+val_list
random.shuffle(data_list)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
torch.cuda.manual_seed(args.seed)
model = se_resnet50(num_classes=3)
model = model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
model = DataParallel_withLoss(model, criterion)
for i in range(args.k_fold):
train_list,val_list=get_k_fold_data(i,data_list)
args.lr=args.original_lr
best_prec1 = 1e6
optimizer = torch.optim.Adam(model.parameters(), args.lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=args.decay)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
train_loss = train(train_list, model, criterion, optimizer, epoch)
prec1 = validate(val_list, model, criterion, epoch)
with open(os.path.join(LOG_DIR, args.task + ".txt"), "a") as f:
f.write("K "+str(i) +" epoch " + str(epoch) + " TrainLoss: " +str(float(train_loss))+
" ValLoss: " +str(float(prec1)))
f.write("\n")
wandb.log({'K':i,'epoch': epoch, 'TrainCEloss': train_loss,'ValCEloss':prec1})
wandb.save(os.path.join(LOG_DIR, args.task + ".txt"))
is_best = prec1 < best_prec1
best_prec1 = min(prec1, best_prec1)
print(' * best CELoss {CELoss:.3f} '.format(CELoss=best_prec1))
save_checkpoint({
'k':i,
'epoch': epoch + 1,
'arch': args.pre,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer' : optimizer.state_dict(),
}, is_best,args.task, epoch = epoch,path=os.path.join(LOG_DIR, args.task))
# creative logger
logger = get_logger('SENetTesting', file_name='output')
# read data
path = args.data_path
test_path = args.test_path
dataloders = get_brats_train_loaders(path, test_path)
dataset_sizes = {'train': 16736, 'val': 16736, 'test': 3791}
# define loss function
criterion = nn.CrossEntropyLoss()
use_gpu = torch.cuda.is_available()
logger.info("use_gpu:{}".format(use_gpu))
model1 = se_resnet50(num_classes=args.num_class)
model2 = se_resnet50(num_classes=args.num_class)
if os.path.isfile(args.resume1):
logger.info(("=> loading checkpoint '{}'".format(args.resume1)))
state = torch.load(args.resume1)
try:
model1.load_state_dict(state['model_state_dict'])
except BaseException as e:
print('Failed to do something: ' + str(e))
else:
logger.info(("=> no checkpoint found at '{}'".format(args.resume1)))
if os.path.isfile(args.resume2):
logger.info(("=> loading checkpoint '{}'".format(args.resume2)))
state = torch.load(args.resume2)
try:
import torch.nn.functional as F
from listfile import listfile
from DataLoader import Trainloader
from senet.se_resnet import se_resnet50
train_imgs, train_labels, val_imgs, val_labels = listfile('./dataset')
TrainImgLoader = torch.utils.data.DataLoader(
Trainloader(train_imgs, train_labels),
batch_size=32, shuffle= True, num_workers= 8, drop_last=False)
TestImgLoader = torch.utils.data.DataLoader(
Trainloader(val_imgs, val_labels),
batch_size=16, shuffle= False, num_workers= 8, drop_last=False)
model = se_resnet50(num_classes=29, pretrained=False)
model.cuda()
optimizer = optim.SGD(model.parameters(), lr=0.1)
loss_func = F.cross_entropy
def train(img, label):
model.train()
img = Variable(torch.FloatTensor(img))
label = Variable(torch.LongTensor(label))
img = img.cuda()
label = label.cuda()
optimizer.zero_grad()
predict = model(img)
predict = F.softmax(predict, dim=1)
