def set_model(input_dims_, model_type_, classes_):
input_shape = input_dims_ + (3, )
if model_type_ == 'ResNet50':
model_ = ResNet50(input_shape=input_shape,
classes=classes_,
name='ResNet50')
elif model_type_ == 'ResNet50_seq':
model_ = ResNet50_seq(input_shape=input_shape,
classes=classes_,
name='ResNet50_seq')
elif model_type_ == 'ResNet34':
model_ = ResNet34(input_shape=input_shape,
classes=classes_,
name='ResNet34')
elif model_type_ == 'ResNetXX':
model_ = ResNetXX(input_shape=input_shape,
classes=classes_,
name='ResNetXX')
elif model_type_ == 'DG':
model_ = DG(input_shape=input_shape, classes=classes_, name='DG')
model_name_ = '_'.join([
model_.name, 'x'.join(map(str, input_dims_)),
'_'.join(Faker().name().split(' '))
])
return model_, model_name_
def train_resnet50_cifar(self, epochs=200, device="cuda:1", n_models=8):
# Based off: https://github.com/kuangliu/pytorch-cifar
PATH = Path('/media/rene/data/')
save_path = PATH / 'cifar-10-batches-py/models'
save_path.mkdir(parents=True, exist_ok=True)
epochs = int(epochs)
num_workers = 4
batch_size = 256
for i in range(n_models):
dataloaders, dataset_sizes = make_batch_gen_cifar(
str(PATH), batch_size, num_workers, valid_name='valid')
model_name = 'ResNet50_' + str(i)
model = ResNet50()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=.05,
momentum=0.9,
weight_decay=5e-4)
scheduler = lr_scheduler.StepLR(optimizer,
step_size=int(epochs / 3),
gamma=0.1)
best_acc, model = train_model(model, criterion, optimizer,
scheduler, epochs, dataloaders,
dataset_sizes, device)
torch.save(model.state_dict(), str(save_path / model_name))
def get_model(name: str):
name = name.lower()
if name == 'vgg11':
return VGG('VGG11')
elif name == 'resnet18':
return ResNet18()
elif name == 'resnet34':
return ResNet34()
elif name == 'resnet50':
return ResNet50()
def _choose_model(dict_config):
support_list = ('vgg16', 'resnet50')
if dict_config['model_name'] not in support_list:
print(f'Not supported {dict_config["model_name"]}')
print(f'Only support {support_list}')
exit()
if dict_config['model_name'] == 'vgg16':
dict_config['model'] = VGG16(len(dict_config['class_list']), pretrain=dict_config['pretrain'])
elif dict_config['model_name'] == 'resnet50':
dict_config['model'] = ResNet50(len(dict_config['class_list']), pretrain=dict_config['pretrain'])
return dict_config
def load_model(model_name):
if model_name == 'deepyeast':
from models import DeepYeast
model = DeepYeast()
elif model_name == 'resnet':
from models import ResNet50
model = ResNet50()
elif model_name == 'mobilenet':
from models import MobileNet
model = MobileNet()
elif model_name == 'densenet':
from models import DenseNet40_BC
model = DenseNet40_BC()
return model
def get_backbone(args, pretrained=True):
from models import VGG16, VGG19, ResNet50, SEResNet50
if args.backbone == 'resnet':
output_shape = 2048
backbone = ResNet50(pretrained=pretrained, kp=args.kp)
elif args.backbone == 'vgg16':
output_shape = 4096
backbone = VGG16(pretrained=pretrained)
elif args.backbone == 'vgg19':
output_shape = 4096
backbone = VGG19(pretrained=pretrained)
elif args.backbone == 'seresnet':
output_shape = 2048
backbone = SEResNet50(pretrained=pretrained)
return output_shape, backbone
def __init__(self, desc='resnet50'):
super(VGGFace, self).__init__()
self.desc = desc
# init descriptor, by default - ResNet50, which produces 8631-dim embedding vector
if desc == "resnet50":
self.descriptor = ResNet50()
self.desc_out_shape = 2048
# TODO: replace this path somewhere, possibly as class attribute, or some config
# weights_path = "weights/resnet50_ft_dag.pth"
weights_path = "weights/resnet50_scratch_dag.pth"
# load weights, pretrained on VGGFace2 dataset
state_dict = torch.load(weights_path)
self.descriptor.load_state_dict(state_dict)
# freeze pretrained descriptor, as it should not be updated during further training
for param in self.descriptor.parameters():
param.requires_grad = False
# change last layer of the model, so it will return not 8631d embiddings, but 512d
# num_ftrs = self.descriptor.classifier.in_channels
# self.descriptor.classifier = nn.Linear(num_ftrs, 512)
elif desc == "resnet_vggface":
self.descriptor = ResNet50VGGFace()
self.desc_out_shape = 2622
weights_path = "weights/vgg_face_dag.pth"
# load weights, pretrained on VGGFace2 dataset
state_dict = torch.load(weights_path)
self.descriptor.load_state_dict(state_dict)
# freeze pretrained descriptor, as it should not be updated during further training
for param in self.descriptor.parameters():
param.requires_grad = False
# create two FC layers and dropout
# TODO: incapsulate number of combinations (3) into variable
self.fc1 = nn.Linear(self.desc_out_shape * 3, 256)
self.fc2 = nn.Linear(256, 128)
self.fc3 = nn.Linear(128, 1)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
def test_voting(args):
with fluid.dygraph.guard(place):
model1 = ResNet50()
model2 = ano_model()
model_dict1, _ = fluid.load_dygraph('ResNet50' + '_best')
model_dict2, _ = fluid.load_dygraph('ano_model' + '_best')
model1.load_dict(model_dict1)
model2.load_dict(model_dict2)
model1.eval()
model2.eval()
test_loader = load_data('eval')
data_loader = fluid.io.DataLoader.from_generator(capacity=5,
return_list=True)
data_loader.set_batch_generator(test_loader, places=place)
acc_set = []
avg_loss_set = []
for batch_id, data in enumerate(data_loader):
x_data, y_data = data
img = fluid.dygraph.to_variable(x_data)
label = fluid.dygraph.to_variable(y_data)
out1 = model1(img) # [b, 10]
out2 = model2(img)
out = out1 + out2
out = fluid.layers.softmax(input=out)
acc = fluid.layers.accuracy(input=out, label=label)
loss = fluid.layers.cross_entropy(input=out, label=label)
avg_loss = fluid.layers.mean(loss)
acc_set.append(float(acc.numpy()))
avg_loss_set.append(float(avg_loss.numpy()))
#计算多个batch的平均损失和准确率
acc_val_mean = np.array(acc_set).mean()
avg_loss_val_mean = np.array(avg_loss_set).mean()
print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))
batch_size=batch_size, # mini batch 덩어리 크기 설정
shuffle=True, # 데이터 순서를 뒤섞어라
num_workers=4, # Broken Pipe 에러 뜨면 지우기
)
test_dataset = datasets.CIFAR10(root='dataset/', train=False, transform=transform_test, download=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
# ================================================================= #
# 5. Initialize the network #
# ================================================================= #
# %% 05. 모델 초기화
model = ResNet50(img_channel=3, num_classes=10).to(device)
print(model)
model = torch.nn.DataParallel(model)# 데이터 병렬처리 # (ref) https://tutorials.pytorch.kr/beginner/blitz/data_parallel_tutorial.html
# 속도가 더 빨라지진 않음 # (ref) https://tutorials.pytorch.kr/beginner/former_torchies/parallelism_tutorial.html
# 오히려 느려질 수 있음 # (ref) https://medium.com/daangn/pytorch-multi-gpu-%ED%95%99%EC%8A%B5-%EC%A0%9C%EB%8C%80%EB%A1%9C-%ED%95%98%EA%B8%B0-27270617936b
cudnn.benchmark = True
# %%
# ================================================================= #
# 6. Loss and optimizer #
# ================================================================= #
# %% 06. 손실 함수와 최적화 알고리즘 정의
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate) # 네트워크의 모든 파라미터를 전달한다
'data_dir':'wriitng dataset directory',
'nClass':'writing class number',
'nEpochs':'writing epoch number',
'patchsize':'writing patchsize',
'lr':'writing learning rate',
'wd':'writing weight decay'
}
print(args)
device = torch.device('cuda')
print('===Loading Datasets===')
train_dataloader = make_dataloader(os.path.join(args['data_dir'], 'train'), args['batchsize'], args['patchsize'])
val_dataloader = make_dataloader(os.path.join(args['data_dir'], 'val'), args['batchsize'], args['patchsize'], val=True)
print('===Building Model===')
model = ResNet50(args['patchsize'], args['nClass']).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=args['lr'], momentum=0.9, weight_decay=args['wd'])
print('======Networks Initialized======')
print(model)
print('================================')
# train
def train(epoch):
model.train()
train_loss = 0
correct = 0
for iteration, batch in tqdm(enumerate(train_dataloader, 1)):
# forward
def evaluation(eval_dataset,
pretrained_model_path,
batch_size=16,
num_of_workers=0,
num_of_classes=1200):
r"""Evaluation a Model
Args:
:param eval_dataset: (RGBD_Dataset)
:param pretrained_model_path: (str) The path
:param batch_size: (int) The size of each step. Large batch_size might cause segmentation fault
:param num_of_workers: (int) Number of subprocesses to use for data loading.
:param num_of_classes: (int) how many subprocesses to use for data loading.
``0`` means that the data will be loaded in the main process.
:return: the model of the best accuracy on validation dataset
"""
# If you get such a RuntimeError, change the `num_workers=0` instead.
# RuntimeError: DataLoader worker (pid 83641) is killed by signal: Unknown signal: 0
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
eval_dataloader = DataLoader(eval_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_of_workers,
drop_last=True)
model = ResNet50(eval_dataset.input_channels,
num_of_classes,
pretrained=False)
# if os.path.exists(pretrained_model_path):
if (pretrained_model_path
is not None) and os.path.exists(pretrained_model_path):
model.load_state_dict(
torch.load(pretrained_model_path, map_location=device))
print(
"Model parameters is loaded from {}".format(pretrained_model_path))
model = model.to(device)
criterion = torch.nn.CrossEntropyLoss()
since = time.time()
model.eval()
running_loss, running_corrects, total = 0, 0, 0
p_bar = tqdm(total=len(eval_dataloader))
for step, (inputs, labels) in enumerate(eval_dataloader):
inputs, labels = inputs.to(device), labels.to(device)
with torch.set_grad_enabled(False):
outputs = model(inputs)
loss = criterion(outputs, labels)
# statistics
_, preds = torch.max(outputs, 1)
total += inputs.size(0)
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
loss = float(running_loss) / total
accu = float(running_corrects) / total * 100
p_bar.set_description('[Evaluation Loss: {:.4f} Acc: {:.2f}%]'.format(
loss, accu))
p_bar.update(1)
p_bar.close()
acc = float(running_corrects) / total * 100
loss = float(running_loss) / total
time_elapsed = time.time() - since # in seconds
print('Evaluation complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Inference Speed: {:2f} fps'.format(total / time_elapsed))
print('Val Acc: {:4f}, Val loss: {:4f}'.format(acc, loss))
return acc, loss
'/lab/vislab/DATA/{}/classification/test.csv'.format(PARAMS['dataset']),
get_transforms(data_transforms['validation']))
train_loader = DataLoader(trainset,
batch_size=PARAMS['batch_size'],
shuffle=True,
num_workers=4,
drop_last=True)
val_loader = DataLoader(validset,
batch_size=PARAMS['batch_size'],
num_workers=4,
drop_last=True)
device = torch.device("cuda")
model = ResNet50(pretrained=True,
num_classes=len(set(trainset.targets)),
max_epochs=PARAMS['epochs'],
dropout=0.0).to(device)
if PARAMS['parallel']:
model = nn.DataParallel(model, [0, 1, 2])
optimizer = torch.optim.SGD(model.parameters(),
lr=PARAMS['learning_rate'],
momentum=PARAMS['momentum'])
criterion = torch.nn.CrossEntropyLoss()
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=PARAMS['step_size'],
gamma=0.5)
def train(model, epoch, pooling='outlier'):
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset = torchvision.datasets.CIFAR10(root='/media/mu/NewVolume/Programs/waterquality/pytorch-cifar', train=True, download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='/media/mu/NewVolume/Programs/waterquality/pytorch-cifar', train=False, download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# Model
print('==> Building model..')
# net = VGG('VGG19')
net = ResNet50(10)
# net = PreActResNet18()
# net = GoogLeNet()
# net = DenseNet121()
# net = ResNeXt29_2x64d()
# net = MobileNet()
# net = MobileNetV2()
# net = DPN92()
# net = ShuffleNetG2()
# net = SENet18()
# net = ShuffleNetV2(1)
# net = EfficientNetB0()
print(net)
net = net.to(device)
images, labels = next(iter(trainloader))
def train_fusion_IDC_morefc(self, epochs1=2, epochs2=3, device="cuda:0"):
epochs1, epochs2 = int(epochs1), int(epochs2)
num_workers = 4
device = "cuda:0"
PATH = Path('/home/rene/data/')
save_path = PATH / models
save_path.mkdir(parents=True, exist_ok=True)
model_name_list = [
'ResNet50_2', 'ResNet50_7', 'ResNet50_1', 'ResNet50_0'
]
batch_size = 128
dataloaders, dataset_sizes = make_batch_gen_cifar(str(PATH),
batch_size,
num_workers,
valid_name='valid')
# get all the models
pretrained_model_list = []
for i, model_name in enumerate(model_name_list):
model = ResNet50()
model = model.to(device)
model.load_state_dict(
torch.load(os.path.join(save_path, model_name)))
pretrained_model_list.append(model)
model = TriFusionMoreFC(pretrained_model_list,
num_input=40,
num_output=10)
###################### TRAIN LAST FEW LAYERS
print('training last few layers')
model_name = 'Fusion2_2s1'
for p in model.parameters():
p.requires_grad = True
for p in model.model1.parameters():
p.requires_grad = False
for p in model.model2.parameters():
p.requires_grad = False
for p in model.model3.parameters():
p.requires_grad = False
for p in model.model4.parameters():
p.requires_grad = False
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=.05,
momentum=0.9,
weight_decay=5e-4)
scheduler = lr_scheduler.StepLR(optimizer,
step_size=int(epochs1 / 3),
gamma=0.1)
best_acc, model = train_model(model,
criterion,
optimizer,
scheduler,
epochs1,
dataloaders,
dataset_sizes,
device=device)
torch.save(model.state_dict(), str(save_path / model_name + '_morefc'))
######################## TRAIN ALL LAYERS
model_name = 'Fusion2_2s2'
batch_size = 6
dataloaders, dataset_sizes = make_batch_gen_cifar(str(PATH),
batch_size,
num_workers,
valid_name='valid')
for p in model.parameters():
p.requires_grad = True
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=.005,
momentum=0.9,
weight_decay=5e-4)
scheduler = lr_scheduler.StepLR(optimizer,
step_size=int(epochs2 / 3),
gamma=0.1)
best_acc, model = train_model(model,
criterion,
optimizer,
scheduler,
epochs1,
dataloaders,
dataset_sizes,
device=device)
torch.save(model.state_dict(), str(save_path / model_name + '_morefc'))
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=False,
transform=transform)
trainloader = torch.utils.data.DataLoader(testset,
batch_size=16,
shuffle=True,
num_workers=0)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
config = {"mb": 0, "mbr": 2}
# config = {"mb":0,"mbr":0}
net = ResNet50(config)
net = net.to(device)
print(torch.cuda.is_available())
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
step_per_epoch = len(trainloader)
total_epoch = 1000
loss_list = []
for epoch in range(total_epoch): # loop over the dataset multiple times
net.train()
running_loss = 0.0
return prediction
if __name__ == "__main__":
height = 224
width = 224
file_list, X_test, X_angle_test, _ = read_data('data/test.json',
height=height,
width=width)
print X_test.shape
file_path = "./model_weights_1.hdf5"
prediction_1 = predict_test(
file_path,
ResNet50.get_model(input_shape1=[height, width, 3], input_shape2=[1]),
X_test)
# file_path = "./model_weights_2.hdf5"
# prediction_2 = predict_test(file_path,
# model.get_model(input_shape1=[height, width, 3],
# input_shape2=[1]),
# X_test)
# prediction = (prediction_1 + prediction_2) / 2
prediction = prediction_1
submission = pd.DataFrame({
'id':
file_list,
'is_iceberg':
prediction.reshape((prediction.shape[0]))
})
def main():
# create the experiments dirs
create_dirs([Config.summary_dir, Config.checkpoint_dir, "logs"])
handlers = [
logging.FileHandler(
datetime.now().strftime(f"./logs/%Y-%m-%d_%H-%M-%S-Log.log")),
logging.StreamHandler()
]
logging.basicConfig(format='%(asctime)s - %(message)s',
level=logging.INFO,
handlers=handlers)
logging.info("Started Logging")
logging.info(
f"Number of cores: {pprint.pformat(Config.num_parallel_cores)}")
logging.info(
f"Address of GPU used for training: {pprint.pformat(Config.gpu_address)}"
)
logging.info(
f"Type of DataLoader: {pprint.pformat(Config.dataloader_type)}")
logging.info(f"Type of Model: {pprint.pformat(Config.model_type)}")
logging.info(f"Number of Epochs: {pprint.pformat(Config.num_epochs)}")
logging.info(f"Optimizer Type: {pprint.pformat(Config.optimizer_type)}")
logging.info(
f"Optimizer parameters: {pprint.pformat(Config.optim_params)}")
logging.info(
f"Train/Validation split ratio: {pprint.pformat(Config.train_val_split)}"
)
logging.info(f"Batch size: {pprint.pformat(Config.batch_size)}")
logging.info(
f"Training on Subset of the data: {pprint.pformat(Config.train_on_subset)}"
)
logging.info(
f"Training on Subset of size: {pprint.pformat(Config.subset_size)}")
logging.info(
f"Generating Patches: {pprint.pformat(Config.train_on_patches)}")
logging.info(f"Patch size (square): {pprint.pformat(Config.patch_size)}")
# create your data generator
with tf.device("/cpu:0"):
if (Config.dataloader_type.lower() == 'onlinedatasetloader'):
data_loader = OnlineDatasetLoader.OnlineDatasetLoader(Config)
if (Config.dataloader_type.lower() == 'datasetfileloader'):
data_loader = DatasetFileLoader.DatasetFileLoader(Config)
else:
data_loader = DatasetLoader.DatasetLoader(Config)
# create tensorflow session
with tf.Session() as sess:
# create instance of the model you want
if (Config.model_type.lower() == 'lenet'):
model = LeNet.LeNet(data_loader, Config)
elif (Config.model_type.lower() == 'resnet50'):
model = ResNet50.ResNet50(data_loader, Config)
elif (Config.model_type.lower() == 'alexnet'):
model = AlexNet.AlexNet(data_loader, Config)
elif (Config.model_type.lower() == 'inception'):
model = Inception.Inception(data_loader, Config)
else:
model = LeNet.LeNet(data_loader, Config)
# create tensorboard logger
logger = DefinedSummarizer(sess,
summary_dir=Config.summary_dir,
scalar_tags=[
'train/loss_per_epoch',
'train/acc_per_epoch',
'test/loss_per_epoch',
'test/acc_per_epoch'
])
# create trainer and path all previous components to it
trainer = MTrainer(sess, model, Config, logger, data_loader)
# here you train your model
trainer.train()
def train(**kwargs):
opt.parse(kwargs)
# log file
ps = PlotSaver("FrozenCNN_ResNet50_RGB_"+time.strftime("%m_%d_%H:%M:%S")+".log.txt")
# step1: Model
compression_model = getattr(models, opt.model)(use_imp = opt.use_imp, model_name="CWCNN_limu_ImageNet_imp_r={r}_γ={w}_for_resnet50".format(
r=opt.rate_loss_threshold,
w=opt.rate_loss_weight)
if opt.use_imp else None)
compression_model.load(None, opt.compression_model_ckpt)
compression_model.eval()
if use_original_RGB:
resnet_50 = resnet50() # Official ResNet
else:
resnet_50 = ResNet50() # My ResNet
if opt.use_gpu:
# compression_model.cuda()
# resnet_50.cuda()
compression_model = multiple_gpu_process(compression_model)
resnet_50 = multiple_gpu_process(resnet_50)
# freeze the compression network
for param in compression_model.parameters():
# print (param.requires_grad)
param.requires_grad = False
cudnn.benchmark = True
# pdb.set_trace()
# step2: Data
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
train_data_transforms = transforms.Compose(
[
transforms.Resize(256),
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize
]
)
val_data_transforms = transforms.Compose(
[
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize
]
)
train_data = datasets.ImageFolder(
opt.train_data_root,
train_data_transforms
)
val_data = datasets.ImageFolder(
opt.val_data_root,
val_data_transforms
)
train_dataloader = DataLoader(train_data, opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True)
val_dataloader = DataLoader(val_data, opt.batch_size, shuffle=False, num_workers=opt.num_workers, pin_memory=True)
# step3: criterion and optimizer
class_loss = t.nn.CrossEntropyLoss()
lr = opt.lr
# optimizer = t.optim.Adam(resnet_50.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=opt.weight_decay)
optimizer = t.optim.SGD(resnet_50.parameters(), lr=lr, momentum=opt.momentum, weight_decay=opt.weight_decay)
start_epoch = 0
if opt.resume:
start_epoch = resnet_50.module.load(None if opt.finetune else optimizer, opt.resume, opt.finetune)
if opt.finetune:
print ('Finetune from model checkpoint file', opt.resume)
else:
print ('Resume training from checkpoint file', opt.resume)
print ('Continue training at epoch %d.' % start_epoch)
# step4: meters
class_loss_meter = AverageValueMeter()
class_acc_top5_meter = AverageValueMeter()
class_acc_top1_meter = AverageValueMeter()
# class_loss_meter = AverageMeter()
# class_acc_top5_meter = AverageMeter()
# class_acc_top1_meter = AverageMeter()
# ps init
ps.new_plot('train class loss', opt.print_freq, xlabel="iteration", ylabel="train_CE_loss")
ps.new_plot('val class loss', 1, xlabel="epoch", ylabel="val_CE_loss")
ps.new_plot('train top_5 acc', opt.print_freq, xlabel="iteration", ylabel="train_top5_acc")
ps.new_plot('train top_1 acc', opt.print_freq, xlabel="iteration", ylabel="train_top1_acc")
ps.new_plot('val top_5 acc', 1, xlabel="iteration", ylabel="val_top_5_acc")
ps.new_plot('val top_1 acc', 1, xlabel="iteration", ylabel="val_top_1_acc")
for epoch in range(start_epoch+1, opt.max_epoch+1):
# per epoch avg loss meter
class_loss_meter.reset()
class_acc_top1_meter.reset()
class_acc_top5_meter.reset()
# cur_epoch_loss refresh every epoch
ps.new_plot("cur epoch train class loss", opt.print_freq, xlabel="iteration in cur epoch", ylabel="cur_train_CE_loss")
resnet_50.train()
for idx, (data, label) in enumerate(train_dataloader):
ipt = Variable(data)
label = Variable(label)
if opt.use_gpu:
ipt = ipt.cuda()
label = label.cuda()
optimizer.zero_grad()
if not use_original_RGB:
compressed_RGB = compression_model(ipt)
else:
compressed_RGB = ipt
# print ('RGB', compressed_RGB.requires_grad)
predicted = resnet_50(compressed_RGB)
class_loss_ = class_loss(predicted, label)
class_loss_.backward()
optimizer.step()
class_loss_meter.add(class_loss_.data[0])
# class_loss_meter.update(class_loss_.data[0], ipt.size(0))
acc1, acc5 = accuracy(predicted.data, label.data, topk=(1, 5))
# pdb.set_trace()
class_acc_top1_meter.add(acc1[0])
class_acc_top5_meter.add(acc5[0])
# class_acc_top1_meter.update(acc1[0], ipt.size(0))
# class_acc_top5_meter.update(acc5[0], ipt.size(0))
if idx % opt.print_freq == opt.print_freq - 1:
ps.add_point('train class loss', class_loss_meter.value()[0] if opt.print_smooth else class_loss_.data[0])
ps.add_point('cur epoch train class loss', class_loss_meter.value()[0] if opt.print_smooth else class_loss_.data[0])
ps.add_point('train top_5 acc', class_acc_top5_meter.value()[0] if opt.print_smooth else acc5[0])
ps.add_point('train top_1 acc', class_acc_top1_meter.value()[0] if opt.print_smooth else acc1[0])
ps.log('Epoch %d/%d, Iter %d/%d, class loss = %.4f, top 5 acc = %.2f %%, top 1 acc = %.2f %%, lr = %.8f' % (epoch, opt.max_epoch, idx, len(train_dataloader), class_loss_meter.value()[0], class_acc_top5_meter.value()[0], class_acc_top1_meter.value()[0], lr))
# 进入debug模式
if os.path.exists(opt.debug_file):
pdb.set_trace()
if use_data_parallel:
resnet_50.module.save(optimizer, epoch)
# plot before val can ease me
ps.make_plot('train class loss') # all epoch share a same img, so give ""(default) to epoch
ps.make_plot('cur epoch train class loss',epoch)
ps.make_plot("train top_5 acc")
ps.make_plot("train top_1 acc")
val_class_loss, val_top5_acc, val_top1_acc = val(compression_model, resnet_50, val_dataloader, class_loss, None, ps)
ps.add_point('val class loss', val_class_loss)
ps.add_point('val top_5 acc', val_top5_acc)
ps.add_point('val top_1 acc', val_top1_acc)
ps.make_plot('val class loss')
ps.make_plot('val top_5 acc')
ps.make_plot('val top_1 acc')
ps.log('Epoch:{epoch}, lr:{lr}, train_class_loss: {train_class_loss}, train_top5_acc: {train_top5_acc} %, train_top1_acc: {train_top1_acc} %, \
val_class_loss: {val_class_loss}, val_top5_acc: {val_top5_acc} %, val_top1_acc: {val_top1_acc} %'.format(
epoch = epoch,
lr = lr,
train_class_loss = class_loss_meter.value()[0],
train_top5_acc = class_acc_top5_meter.value()[0],
train_top1_acc = class_acc_top1_meter.value()[0],
val_class_loss = val_class_loss,
val_top5_acc = val_top5_acc,
val_top1_acc = val_top1_acc
))
# adjust lr
if (epoch in opt.lr_decay_step_list) or (opt.use_file_signal_to_adjust_lr and os.path.exists(opt.signal_file)):
lr = lr * opt.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr
x = F.relu(x)
x = self.pool(x)
x = self.conv2(x)
x = F.relu(x)
x = self.pool(x)
x = x.view(-1, 16 * 5 * 5)
x = self.fc1(x)
x = F.relu(x)
x = self.mb(x)
x = self.fc2(x)
x = F.relu(x)
x = self.fc3(x)
return x
net = ResNet50()
net = net.to(device)
print(torch.cuda.is_available())
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
step_per_epoch = len(trainloader)
total_epoch = 100
for epoch in range(total_epoch): # loop over the dataset multiple times
net.train()
running_loss = 0.0
def main(_):
print("FLAGS values:", tf.app.flags.FLAGS.flag_values_dict())
tf.logging.set_verbosity(tf.logging.INFO)
config = tf.ConfigProto()
if FLAGS.model == 'denoiser':
config.gpu_options.per_process_gpu_memory_fraction = 0.2
else:
config.gpu_options.allow_growth = True
if FLAGS.model == 'denoiser':
from models import Denoiser
model = Denoiser()
with tf.Graph().as_default():
# Prepare graph
with tf.Session(config=config).as_default():
if FLAGS.model == 'inception-v3':
from models import InceptionV3
model = InceptionV3()
elif FLAGS.model == 'vgg-16':
from models import VGG16
model = VGG16()
elif FLAGS.model == 'resnet-50':
from models import ResNet50
model = ResNet50()
elif FLAGS.model == 'jpeg':
from models import JPEG
model = JPEG()
elif FLAGS.model == 'random':
from models import Random
model = Random()
if FLAGS.method != 'uniform':
from surrogate_model import ResNet152
model_s = ResNet152(source_image_size=model.image_size,
use_smoothed_grad=model.use_smoothed_grad)
image_size = model.image_size
# ---Setting hyperparameters---
if FLAGS.norm == 'l2':
epsilon = 1e-3
eps = np.sqrt(epsilon * image_size * image_size * 3)
learning_rate = 2.0 / np.sqrt(image_size * image_size * 3)
else:
epsilon = 0.05
eps = epsilon
learning_rate = 0.005
if model.use_larger_step_size:
ini_sigma = 1e-3
else:
ini_sigma = 1e-4
# -----------------------------
if not model.predictions_is_correct:
l = open(os.path.join(FLAGS.input_dir, 'labels')).readlines()
gts = {}
for i in l:
i = i.strip().split(' ')
gts[i[0]] = int(i[1]) + (model.num_classes - 1000)
success = 0
queries = []
correct = 0
names_images = load_images(FLAGS.input_dir, model.image_size)
for filename, image in names_images:
output_logging = open(os.path.join(FLAGS.output_dir, 'logging'), 'a')
sigma = ini_sigma
np.random.seed(0)
tf.set_random_seed(0)
adv_image = image.copy()
label = model.get_pred(image)
l = model.get_loss(image, label)
print(filename, 'original prediction:', label, 'loss:', l)
if not model.predictions_is_correct:
correct += (label[0] == gts[filename])
if label[0] != gts[filename]:
output_logging.write(filename + ' original misclassified.\n')
output_logging.close()
continue
lr = learning_rate
last_loss = []
total_q = 0
ite = 0
while total_q <= FLAGS.max_queries:
total_q += 1
if FLAGS.show_true and hasattr(model, 'get_grad'):
true = np.squeeze(model.get_grad(adv_image, label))
print("Grad norm", np.sqrt(np.sum(true * true)))
if ite % 2 == 0 and sigma != ini_sigma:
print(
"sigma has been increased before; checking if sigma could be set back to ini_sigma"
)
rand = np.random.normal(size=adv_image.shape)
rand = rand / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(rand))))
rand_loss = model.get_loss(adv_image + ini_sigma * rand, label)
total_q += 1
rand = np.random.normal(size=adv_image.shape)
rand = rand / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(rand))))
rand_loss2 = model.get_loss(adv_image + ini_sigma * rand,
label)
total_q += 1
if (rand_loss - l)[0] != 0 and (rand_loss2 - l)[0] != 0:
print("set sigma back to ini_sigma")
sigma = ini_sigma
if FLAGS.method != 'uniform':
if model.num_classes < model_s.num_classes:
s_label = label + 1
elif model.num_classes > model_s.num_classes:
s_label = label - 1
else:
s_label = label
prior = np.squeeze(model_s.get_grad(adv_image, s_label))
if FLAGS.show_true and hasattr(model, 'get_grad'):
alpha = np.sum(true * prior) / np.maximum(
1e-12,
np.sqrt(np.sum(true * true) * np.sum(prior * prior)))
print("alpha =", alpha)
prior = prior / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(prior))))
if FLAGS.method in ['biased', 'average']:
start_iter = 3
if ite % 10 == 0 or ite == start_iter:
# Estimate norm of true gradient periodically when ite == 0/10/20...;
# since gradient norm may change fast in the early iterations, we also
# estimate the gradient norm when ite == 3.
s = 10
pert = np.random.normal(size=(s, ) + adv_image.shape)
for i in range(s):
pert[i] = pert[i] / \
np.maximum(
1e-12, np.sqrt(np.mean(np.square(pert[i]))))
eval_points = adv_image + sigma * pert
losses = model.get_loss(eval_points, np.repeat(label, s))
total_q += s
norm_square = np.average(((losses - l) / sigma)**2)
while True:
prior_loss = model.get_loss(adv_image + sigma * prior,
label)
total_q += 1
diff_prior = (prior_loss - l)[0]
if diff_prior == 0:
# Avoid the numerical issue in finite difference
sigma *= 2
print("multiply sigma by 2")
else:
break
est_alpha = diff_prior / sigma / \
np.maximum(
np.sqrt(np.sum(np.square(prior)) * norm_square), 1e-12)
print("Estimated alpha =", est_alpha)
alpha = est_alpha
if alpha < 0:
prior = -prior
alpha = -alpha
q = FLAGS.samples_per_draw
n = image_size * image_size * 3
d = 50 * 50 * 3
gamma = 3.5
A_square = d / n * gamma
return_prior = False
if FLAGS.method == 'average':
if FLAGS.dataprior:
alpha_nes = np.sqrt(A_square * q / (d + q - 1))
else:
alpha_nes = np.sqrt(q / (n + q - 1))
if alpha >= 1.414 * alpha_nes:
return_prior = True
elif FLAGS.method == 'biased':
if FLAGS.dataprior:
best_lambda = A_square * (
A_square - alpha**2 *
(d + 2 * q - 2)) / (A_square**2 + alpha**4 * d**2 -
2 * A_square * alpha**2 *
(q + d * q - 1))
else:
best_lambda = (1 - alpha**2) * (
1 - alpha**2 *
(n + 2 * q - 2)) / (alpha**4 * n * (n + 2 * q - 2) -
2 * alpha**2 * n * q + 1)
print('best_lambda = ', best_lambda)
if best_lambda < 1 and best_lambda > 0:
lmda = best_lambda
else:
if alpha**2 * (n + 2 * q - 2) < 1:
lmda = 0
else:
lmda = 1
if np.abs(alpha) >= 1:
lmda = 1
print('lambda = ', lmda)
if lmda == 1:
return_prior = True
elif FLAGS.method == 'fixed_biased':
lmda = FLAGS.fixed_const
if not return_prior:
if FLAGS.dataprior:
pert = np.random.normal(size=(q, 50, 50, 3))
pert = np.array([
cv2.resize(pert[i],
adv_image.shape[:2],
interpolation=cv2.INTER_NEAREST)
for i in range(q)
])
else:
pert = np.random.normal(size=(q, ) + adv_image.shape)
for i in range(q):
if FLAGS.method in ['biased', 'fixed_biased']:
pert[i] = pert[i] - np.sum(
pert[i] * prior) * prior / np.maximum(
1e-12, np.sum(prior * prior))
pert[i] = pert[i] / \
np.maximum(
1e-12, np.sqrt(np.mean(np.square(pert[i]))))
pert[i] = np.sqrt(1 - lmda) * \
pert[i] + np.sqrt(lmda) * prior
else:
pert[i] = pert[i] / \
np.maximum(
1e-12, np.sqrt(np.mean(np.square(pert[i]))))
while True:
eval_points = adv_image + sigma * pert
losses = model.get_loss(eval_points, np.repeat(label, q))
total_q += q
grad = (losses - l).reshape(-1, 1, 1, 1) * pert
grad = np.mean(grad, axis=0)
norm_grad = np.sqrt(np.mean(np.square(grad)))
if norm_grad == 0:
# Avoid the numerical issue in finite difference
sigma *= 5
print("estimated grad == 0, multiply sigma by 5")
else:
break
grad = grad / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(grad))))
if FLAGS.method == 'average':
while True:
diff_prior = (
model.get_loss(adv_image + sigma * prior, label) -
l)[0]
total_q += 1
diff_nes = (
model.get_loss(adv_image + sigma * grad, label) -
l)[0]
total_q += 1
diff_prior = max(0, diff_prior)
if diff_prior == 0 and diff_nes == 0:
sigma *= 2
print("multiply sigma by 2")
else:
break
final = prior * diff_prior + grad * diff_nes
final = final / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(final))))
print("diff_prior = {}, diff_nes = {}".format(
diff_prior, diff_nes))
elif FLAGS.method == 'fixed_average':
diff_prior = (
model.get_loss(adv_image + sigma * prior, label) -
l)[0]
total_q += 1
if diff_prior < 0:
prior = -prior
final = FLAGS.fixed_const * prior + \
(1 - FLAGS.fixed_const) * grad
final = final / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(final))))
else:
final = grad
def print_loss(model, direction):
length = [1e-4, 1e-3]
les = []
for ss in length:
les.append((
model.get_loss(adv_image + ss * direction, label) -
l)[0])
print("losses", les)
if FLAGS.show_loss:
if FLAGS.method in ['average', 'fixed_average']:
lprior = model.get_loss(adv_image + lr * prior,
label) - l
print_loss(model, prior)
lgrad = model.get_loss(adv_image + lr * grad,
label) - l
print_loss(model, grad)
lfinal = model.get_loss(adv_image + lr * final,
label) - l
print_loss(model, final)
print(lprior, lgrad, lfinal)
elif FLAGS.method in ['biased', 'fixed_biased']:
lprior = model.get_loss(adv_image + lr * prior,
label) - l
print_loss(model, prior)
lgrad = model.get_loss(adv_image + lr * grad,
label) - l
print_loss(model, grad)
print(lprior, lgrad)
else:
final = prior
if FLAGS.show_true and hasattr(model, 'get_grad'):
if FLAGS.method in ['average', 'fixed_average'
] and not return_prior:
print(
"NES angle =",
np.sum(true * grad) / np.maximum(
1e-12,
np.sqrt(
np.sum(true * true) * np.sum(grad * grad))))
print(
"angle =",
np.sum(true * final) / np.maximum(
1e-12,
np.sqrt(np.sum(true * true) * np.sum(final * final))))
if FLAGS.norm == 'l2':
adv_image = adv_image + lr * final / \
np.maximum(1e-12, np.sqrt(np.mean(np.square(final))))
norm = max(1e-12, np.linalg.norm(adv_image - image))
factor = min(1, eps / norm)
adv_image = image + (adv_image - image) * factor
else:
adv_image = adv_image + lr * np.sign(final)
adv_image = np.clip(adv_image, image - eps, image + eps)
adv_image = np.clip(adv_image, 0, 1)
adv_label = model.get_pred(adv_image)
l = model.get_loss(adv_image, label)
print('queries:', total_q, 'loss:', l, 'learning rate:', lr,
'sigma:', sigma, 'prediction:', adv_label, 'distortion:',
np.max(np.abs(adv_image - image)),
np.linalg.norm(adv_image - image))
ite += 1
if adv_label != label:
print('Stop at queries:', total_q)
success += 1
queries.append(total_q)
imsave(os.path.join(FLAGS.output_dir, filename), adv_image)
output_logging.write(filename + ' succeed; queries: ' +
str(total_q) + '\n')
break
else:
imsave(os.path.join(FLAGS.output_dir, filename), adv_image)
output_logging.write(filename + ' fail.\n')
output_logging.close()
if model.predictions_is_correct:
total = FLAGS.number_images
else:
total = correct
print('Success rate:', success / total, 'Queries', queries)
output_logging = open(os.path.join(FLAGS.output_dir, 'logging'), 'a')
output_logging.write('Success rate: ' + str(success / total) +
', Queries on success: ' + str(np.mean(queries)))
output_logging.close()
else:
labels.append(int(label))
camera_id.append(int(camera[0]))
return camera_id, labels
gallery_path = image_datasets['gallery'].imgs
query_path = image_datasets['query'].imgs
gallery_cam, gallery_label = get_id(gallery_path)
query_cam, query_label = get_id(query_path)
######################################################################
# Load Collected data Trained model
print('----------test-----------')
model_structure = ResNet50(751, feat_size, metric, margin, scalar)
model = load_network(model_structure).model
# Change to test mode
model = model.eval()
model = model.cuda()
# Extract feature
gallery_feature = extract_feature(model, dataloaders['gallery'])
query_feature = extract_feature(model, dataloaders['query'])
# Save to Matlab for check
result = {
'gallery_f': gallery_feature.numpy(),
'gallery_label': gallery_label,
def main(args):
# Parsing command line arguments
print("========================================================")
print("Process %s, running on %s: starting (%s)" % (
os.getpid(), os.name, time.asctime()))
print("========================================================")
if args.cnn_model == 'vgg':
image_model = VGG19(pretrained=True)
else:
image_model = ResNet50(pretrained = True)
caption_model = LSTMBranch()
if torch.cuda.is_available() and args.use_gpu == True:
image_model = image_model.cuda()
caption_model = caption_model.cuda()
# Get the learnable parameters
image_trainables = [p for p in image_model.parameters() if p.requires_grad]
caption_trainables = [p for p in caption_model.parameters() if p.requires_grad]
params = image_trainables + caption_trainables
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225))])
# Obtain the data loader (from file). Note that it runs much faster than before!
print("Dataset being used: ", args.dataset)
if args.dataset == 'flickr':
data_loader_train = get_loader_flickr(transform=transform,
mode='train',
batch_size=args.batch_size,
parse_mode=args.parse_mode)
data_loader_val = get_loader_flickr(transform=transform,
mode='val',
batch_size=args.batch_size,
parse_mode=args.parse_mode)
elif args.dataset == 'coco':
data_loader_train = get_loader_coco(transform=transform,
mode='train',
batch_size=args.batch_size)
data_loader_val = get_loader_coco(transform=transform,
mode='val',
batch_size=args.batch_size)
else:
data_loader_train = get_loader_genome(transform=transform,
mode='train',
batch_size=args.batch_size)
data_loader_val = get_loader_genome(transform=transform,
mode='train',
batch_size=args.batch_size)
# Load saved model
start_epoch, best_loss = load_checkpoint(image_model, caption_model, args.resume)
# optimizer = torch.optim.Adam(params=params, lr=0.01)
optimizer = torch.optim.SGD(params=params, lr=args.lr, momentum=0.9)
total_train_step = math.ceil(
len(data_loader_train.dataset.caption_lengths) / data_loader_train.batch_sampler.batch_size)
# print("Total number of training steps are :", total_train_step)
print("========================================================")
print("Total number of epochs to train: ", args.n_epochs)
print("Loss Type: ", args.loss_type)
if args.loss_type == 'triplet':
print("Sampling strategy: ", args.sampler)
print("Margin for triplet loss: ", args.margin)
print("Learning Rate: ", args.lr)
print("Score Type for similarity: ", args.score_type)
print("========================================================")
epoch = start_epoch
best_epoch = start_epoch
# while (epoch - best_epoch) < args.no_gain_stop and (epoch <= args.n_epochs):
while epoch <= args.n_epochs:
adjust_learning_rate(args.lr, args.lr_decay, optimizer, epoch)
print("========================================================")
print("Epoch: %d Training starting" % epoch)
print("Learning rate : ", get_lr(optimizer))
train_loss = train(data_loader_train, data_loader_val, image_model,
caption_model, args.loss_type, optimizer, epoch,
args.score_type, args.sampler, args.margin,
total_train_step, args.batch_size, args.use_gpu)
print('---------------------------------------------------------')
print("Epoch: %d Validation starting" % epoch)
val_loss = validate(caption_model, image_model, data_loader_val,
epoch, args.loss_type, args.score_type, args.sampler,
args.margin, args.use_gpu)
print("Epoch: ", epoch)
print("Training Loss: ", float(train_loss.data))
print("Validation Loss: ", float(val_loss.data))
print("========================================================")
save_checkpoint({
'epoch': epoch,
'best_loss': min(best_loss, val_loss),
'image_model': image_model.state_dict(),
'caption_model': caption_model.state_dict()
}, val_loss < best_loss)
if (val_loss) < best_loss:
best_epoch = epoch
best_loss = val_loss
epoch += 1
print("Back to main")
resume_filename = 'runs/%s/' % (args.name) + 'model_best.pth.tar'
if os.path.exists(resume_filename):
epoch, best_loss1 = load_checkpoint(image_model, caption_model, args.resume)
val_loss1 = validate(caption_model, image_model, data_loader_val,
epoch, args.loss_type, args.score_type, args.sampler,
args.margin, args.use_gpu)
print("========================================================")
print("========================================================")
print("Final Loss : ", float(val_loss1.data))
print("========================================================")
print("========================================================")
else:
resume_filename = 'runs/%s/' % (args.name) + 'checkpoint.pth.tar'
print("Using last run epoch.")
epoch, best_loss1 = load_checkpoint(image_model, caption_model, args.resume)
val_loss1 = validate(caption_model, image_model, data_loader_val,
epoch, args.loss_type, args.score_type, args.sampler,
args.margin, args.use_gpu)
print("========================================================")
print("========================================================")
print("Final Loss : ", float(val_loss1.data))
print("========================================================")
print("========================================================")
def root_path():
return os.path.dirname(sys.argv[0])
def quantize_model(model_, path):
converter = tf.lite.TFLiteConverter.from_keras_model(model_)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()
quantized_path = path + '.optimized'
open(quantized_path, "wb").write(quantized_model)
print(f'\nQuantized model saved as {quantized_path}\n')
return
if __name__ == '__main__':
model_name = 'ResNet50_256x256_Wayne_Reilly'
weights_name = 'weights.cat_acc_best.hdf5'
input_shape = (256, 256, 3)
classes = 24
model = ResNet50(input_shape=input_shape, classes=classes, name='ResNet50')
model.load_weights(
os.path.join(root_path(), 'models', model_name, weights_name))
quantize_model(model, os.path.join(root_path(), 'models', model_name))
sys.exit(0)
time_elapsed // 60, time_elapsed % 60))
return model
def save_network(network, epoch_label):
save_filename = 'net_%s.pth' % epoch_label
save_path = os.path.join('./logs', name, save_filename)
torch.save(network.cpu().state_dict(), save_path)
if torch.cuda.is_available:
network.cuda()
if __name__ == '__main__':
model = ResNet50(len(class_names), feat_size, metric, margin, scalar,
dropout).cuda()
xent_criterion = nn.CrossEntropyLoss()
tri_criterion = TripletLoss()
criterion = [xent_criterion, tri_criterion]
# SGD_Step
if optim_type == 'SGD_Step':
optimizer = optim.SGD(params=model.parameters(),
lr=0.01,
weight_decay=5e-4,
momentum=0.9,
nesterov=True)
lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=40, gamma=0.1)
#lr_scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[20, 60, 70, 80], gamma=0.1)
# SGD_Warmup
"target_update_frequency":target_update_frequency,
"replay_buffer_capacity":replay_buffer_capacity,
"replay_buffer_minimum_number_samples": replay_buffer_minimum_number_samples,
"object_detection_threshold": object_detection_threshold,
"maximum_num_entities_per_image": maximum_num_entities_per_image,
"maximum_adaptive_action_space_size": maximum_adaptive_action_space_size}
# create semantic action graph
print("Loading graph.pickle...")
semantic_action_graph = pickle.load(open("graph.pickle", "rb"))
print("Done!")
# create VGG model for state featurization
print("Loading image embedding model...")
if args.image_embedding_model_type == "resnet":
im_emb_model = ResNet50()
elif args.image_embedding_model_type == "vgg":
im_emb_model = VGG16()
else:
print("--image_embedding_model_type must be either resnet or vgg")
sys.exit(0)
print("Done!")
# create Faster-RCNN model for state featurization
print("Loading Fast-RCNN...")
model_file = 'VGGnet_fast_rcnn_iter_70000.h5'
model_frcnn = FasterRCNN()
network.load_net(model_file, model_frcnn)
model_frcnn.cuda()
model_frcnn.eval()
print("Done!")
model_path, map_location=torch.device("cpu")))
model_state_dict = {}
for name, module in state_dict.items():
fields = name.split(".")
if "mask" in name:
continue
if "weight_orig" in name:
orig_weight = module
mask = state_dict[".".join(fields[:-1] + ["weight_mask"])]
m = orig_weight * mask
k = ".".join(fields[1:-1] + ["weight"])
else:
m = module
k = ".".join(fields[1:])
model_state_dict[k] = m
model = ResNet50()
conv_runtime_dict = {}
orig_pointer = nn.Module.__call__
def _get_sparsity(m):
return float(torch.sum(m == 0)) / float(m.numel())
def _instrument(*args, **kwargs):
global ctr
print("instrumented! len(args) = {}".format(len(args)))
if len(args) != 2:
raise ValueError("Not sure what to do with args != 2...")
begin = time.time()
def train(**kwargs):
config.parse(kwargs)
# ============================================ Visualization =============================================
vis = Visualizer(port=2333, env=config.env)
vis.log('Use config:')
for k, v in config.__class__.__dict__.items():
if not k.startswith('__'):
vis.log(f"{k}: {getattr(config, k)}")
# ============================================= Prepare Data =============================================
train_data = SlideWindowDataset(config.train_paths,
phase='train',
useRGB=config.useRGB,
usetrans=config.usetrans,
balance=config.data_balance)
val_data = SlideWindowDataset(config.test_paths,
phase='val',
useRGB=config.useRGB,
usetrans=config.usetrans,
balance=False)
print('Training Images:', train_data.__len__(), 'Validation Images:',
val_data.__len__())
dist = train_data.dist()
print('Train Data Distribution:', dist)
train_dataloader = DataLoader(train_data,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers)
val_dataloader = DataLoader(val_data,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.num_workers)
# ============================================= Prepare Model ============================================
# model = AlexNet(num_classes=config.num_classes)
# model = Vgg16(num_classes=config.num_classes)
# model = Modified_Vgg16(num_classes=config.num_classes)
# model = ResNet18(num_classes=config.num_classes)
model = ResNet50(num_classes=config.num_classes)
# model = DenseNet121(num_classes=config.num_classes)
# model = ShallowNet(num_classes=config.num_classes)
# model = Customed_ShallowNet(num_classes=config.num_classes)
# model = Modified_AGVgg16(num_classes=2)
# model = AGResNet18(num_classes=2)
print(model)
if config.load_model_path:
model.load(config.load_model_path)
if config.use_gpu:
model.cuda()
if config.parallel:
model = torch.nn.DataParallel(
model, device_ids=[x for x in range(config.num_of_gpu)])
# =========================================== Criterion and Optimizer =====================================
# weight = torch.Tensor([1, 1])
# weight = torch.Tensor([dist['1']/(dist['0']+dist['1']), dist['0']/(dist['0']+dist['1'])]) # weight需要将二者反过来，多于二分类可以取倒数
# weight = torch.Tensor([1, 3.5])
# weight = torch.Tensor([1, 5])
weight = torch.Tensor([1, 7])
vis.log(f'loss weight: {weight}')
print('loss weight:', weight)
weight = weight.cuda()
criterion = torch.nn.CrossEntropyLoss(weight=weight)
lr = config.lr
optimizer = torch.optim.Adam(model.parameters(),
lr=lr,
weight_decay=config.weight_decay)
# ================================================== Metrics ===============================================
softmax = functional.softmax
loss_meter = meter.AverageValueMeter()
epoch_loss = meter.AverageValueMeter()
train_cm = meter.ConfusionMeter(config.num_classes)
# ====================================== Saving and Recording Configuration =================================
previous_auc = 0
if config.parallel:
save_model_dir = config.save_model_dir if config.save_model_dir else model.module.model_name
save_model_name = config.save_model_name if config.save_model_name else model.module.model_name + '_best_model.pth'
else:
save_model_dir = config.save_model_dir if config.save_model_dir else model.model_name
save_model_name = config.save_model_name if config.save_model_name else model.model_name + '_best_model.pth'
save_epoch = 1 # 用于记录验证集上效果最好模型对应的epoch
process_record = {
'epoch_loss': [],
'train_avg_se': [],
'train_se_0': [],
'train_se_1': [],
'val_avg_se': [],
'val_se_0': [],
'val_se_1': [],
'AUC': []
} # 用于记录实验过程中的曲线，便于画曲线图
# ================================================== Training ===============================================
for epoch in range(config.max_epoch):
print(
f"epoch: [{epoch+1}/{config.max_epoch}] {config.save_model_name[:-4]} =================================="
)
train_cm.reset()
epoch_loss.reset()
# ****************************************** train ****************************************
model.train()
for i, (image, label, image_path) in tqdm(enumerate(train_dataloader)):
loss_meter.reset()
# ------------------------------------ prepare input ------------------------------------
if config.use_gpu:
image = image.cuda()
label = label.cuda()
# ---------------------------------- go through the model --------------------------------
score = model(image)
# ----------------------------------- backpropagate -------------------------------------
optimizer.zero_grad()
loss = criterion(score, label)
loss.backward()
optimizer.step()
# ------------------------------------ record loss ------------------------------------
loss_meter.add(loss.item())
epoch_loss.add(loss.item())
train_cm.add(softmax(score, dim=1).detach(), label.detach())
if (i + 1) % config.print_freq == 0:
vis.plot('loss', loss_meter.value()[0])
train_se = [
100. * train_cm.value()[0][0] /
(train_cm.value()[0][0] + train_cm.value()[0][1]),
100. * train_cm.value()[1][1] /
(train_cm.value()[1][0] + train_cm.value()[1][1])
]
# *************************************** validate ***************************************
model.eval()
if (epoch + 1) % 1 == 0:
Best_T, val_cm, val_spse, val_accuracy, AUC = val(
model, val_dataloader)
# ------------------------------------ save model ------------------------------------
if AUC > previous_auc and epoch + 1 > 5:
if config.parallel:
if not os.path.exists(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0])):
os.makedirs(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0]))
model.module.save(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0],
save_model_name))
else:
if not os.path.exists(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0])):
os.makedirs(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0]))
model.save(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0],
save_model_name))
previous_auc = AUC
save_epoch = epoch + 1
# ---------------------------------- recond and print ---------------------------------
process_record['epoch_loss'].append(epoch_loss.value()[0])
process_record['train_avg_se'].append(np.average(train_se))
process_record['train_se_0'].append(train_se[0])
process_record['train_se_1'].append(train_se[1])
process_record['val_avg_se'].append(np.average(val_spse))
process_record['val_se_0'].append(val_spse[0])
process_record['val_se_1'].append(val_spse[1])
process_record['AUC'].append(AUC)
vis.plot_many({
'epoch_loss': epoch_loss.value()[0],
'train_avg_se': np.average(train_se),
'train_se_0': train_se[0],
'train_se_1': train_se[1],
'val_avg_se': np.average(val_spse),
'val_se_0': val_spse[0],
'val_se_1': val_spse[1],
'AUC': AUC
})
vis.log(
f"epoch: [{epoch+1}/{config.max_epoch}] ========================================="
)
vis.log(
f"lr: {optimizer.param_groups[0]['lr']}, loss: {round(loss_meter.value()[0], 5)}"
)
vis.log(
f"train_avg_se: {round(np.average(train_se), 4)}, train_se_0: {round(train_se[0], 4)}, train_se_1: {round(train_se[1], 4)}"
)
vis.log(
f"val_avg_se: {round(sum(val_spse)/len(val_spse), 4)}, val_se_0: {round(val_spse[0], 4)}, val_se_1: {round(val_spse[1], 4)}"
)
vis.log(f"AUC: {AUC}")
vis.log(f'train_cm: {train_cm.value()}')
vis.log(f'Best Threshold: {Best_T}')
vis.log(f'val_cm: {val_cm}')
print("lr:", optimizer.param_groups[0]['lr'], "loss:",
round(epoch_loss.value()[0], 5))
print('train_avg_se:', round(np.average(train_se), 4),
'train_se_0:', round(train_se[0], 4), 'train_se_1:',
round(train_se[1], 4))
print('val_avg_se:', round(np.average(val_spse), 4), 'val_se_0:',
round(val_spse[0], 4), 'val_se_1:', round(val_spse[1], 4))
print('AUC:', AUC)
print('train_cm:')
print(train_cm.value())
print('Best Threshold:', Best_T, 'val_cm:')
print(val_cm)
# ------------------------------------ save record ------------------------------------
if os.path.exists(
os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0])):
write_json(file=os.path.join('checkpoints', save_model_dir,
save_model_name.split('.')[0],
'process_record.json'),
content=process_record)
# if (epoch+1) % 5 == 0:
# lr = lr * config.lr_decay
# for param_group in optimizer.param_groups:
# param_group['lr'] = lr
vis.log(f"Best Epoch: {save_epoch}")
print("Best Epoch:", save_epoch)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=False,
transform=transform)
trainloader = torch.utils.data.DataLoader(testset,
batch_size=16,
shuffle=True,
num_workers=0)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
import torch.nn as nn
import torch.nn.functional as F
net = ResNet50(RCV_CONFIG)
net = net.to(device)
print(torch.cuda.is_available())
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
step_per_epoch = len(trainloader)
total_epoch = 100
best_acc = 0.0
for epoch in range(total_epoch): # loop over the dataset multiple times
net.train()
import torch from models import ResNet50 file = "save/models/ResNet50_vanilla/ckpt_epoch_240.pth" ff = torch.load(file, map_location="cpu") model = ResNet50(num_classes=10) model.load_state_dict(ff["model"])
