def input_transform(self, crop_size):
return Compose([
CenterCrop(crop_size),
Resize(crop_size // self.upscale_factor),
ToTensor(),
])
def main():
import argparse
import json
import os
params = {}
params['num_workers'] = 6
params['learning_rate'] = 1e-6
params['momentum'] = 0.9
params['weight_decay'] = 0.0005
params['gamma'] = 0.1
params['step_size'] = 3
params['num_classes'] = 2
params['epochs'] = 50
params['batch_size'] = 4
params['patience'] = 20
params['test_size'] = 0.2
params['image_dir'] = '/home/ktdiedrich/data/lung-xray/CXR_pngs'
params['mask_dir'] = '/home/ktdiedrich/data/lung-xray/masks'
params['output_dir'] = '/home/ktdiedrich/output/lung-xray/models2'
params['checkpoint_epochs'] = 5
parser = argparse.ArgumentParser(description='Detect objects')
parser.add_argument("--output_dir",
"-o",
type=str,
help="output directory [{}]".format(
params['output_dir']),
default=params['output_dir'])
parser.add_argument('--image_dir',
"-i",
type=str,
help='images [{}]'.format(params['image_dir']),
default=params['image_dir'])
parser.add_argument('--mask_dir',
"-M",
type=str,
help='masks of training objects [{}]'.format(
params['mask_dir']),
default=params['mask_dir'])
parser.add_argument("--num_workers",
'-w',
type=int,
action='store',
default=params['num_workers'],
help="worker threads, default {}".format(
params['num_workers']))
parser.add_argument("--num_classes",
'-c',
type=int,
action='store',
default=params['num_classes'],
help="classes [{}]".format(params['num_classes']))
args = parser.parse_args()
params['image_dir'] = args.image_dir
params['mask_dir'] = args.mask_dir
params['output_dir'] = args.output_dir
params['num_workers'] = args.num_workers
params['num_classes'] = args.num_classes
if not os.path.exists(params['output_dir']):
os.makedirs(params['output_dir'])
with open(os.path.join(params['output_dir'], 'params.json'), 'w') as fp:
json.dump(params, fp)
transform_train = Compose(
[Resize([h, w]),
ToTensor(), Normalize(mean=mean, std=std)])
transform_val = Compose(
[Resize([h, w]),
ToTensor(), Normalize(mean=mean, std=std)])
mask_transform = Compose([Resize([h, w]), ToTensor()])
train_ds_full = SegmentationDataset(path2img=params['image_dir'],
path2masks=params['mask_dir'],
transform=transform_train,
mask_transform=mask_transform)
val_ds_full = SegmentationDataset(path2img=params['image_dir'],
path2masks=params['mask_dir'],
transform=transform_val,
mask_transform=mask_transform)
sss = ShuffleSplit(n_splits=1,
test_size=params['test_size'],
random_state=0)
indices = range(len(train_ds_full))
for train_index, val_index in sss.split(indices):
print("train = {}".format(len(train_index)))
print("-" * 10)
print("valid = {}".format(len(val_index)))
train_ds = Subset(train_ds_full, train_index)
print("Train data subset = {}".format(len(train_ds)))
val_ds = Subset(val_ds_full, val_index)
print("Valid data subset = {}".format(len(val_ds)))
train_dl = DataLoader(train_ds,
batch_size=params['batch_size'],
shuffle=True,
collate_fn=collate_fn,
num_workers=params['num_workers'])
val_dl = DataLoader(val_ds,
batch_size=params['batch_size'],
shuffle=False,
collate_fn=collate_fn,
num_workers=params['num_workers'])
model = deeplabv3_resnet50(pretrained=False,
num_classes=params['num_classes'])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
# ## Define Loss Function
criterion = nn.CrossEntropyLoss(reduction="sum")
# ## Optimizer
opt = optim.Adam(model.parameters(), lr=params['learning_rate'])
lr_scheduler = ReduceLROnPlateau(opt,
mode='min',
factor=0.5,
patience=params['patience'],
verbose=1)
current_lr = get_lr(opt)
print('current lr={}'.format(current_lr))
path2models = os.path.join(params['output_dir'])
if not os.path.exists(path2models):
os.makedirs(path2models)
params_train = {
"num_epochs": params['epochs'],
"optimizer": opt,
"loss_func": criterion,
"train_dl": train_dl,
"val_dl": val_dl,
"output_dir": params['output_dir'],
"checkpoint_epochs": params['checkpoint_epochs'],
"lr_scheduler": lr_scheduler,
"path2weights": os.path.join(path2models, "weights.pt")
}
model, loss_hist, _ = train_val(model, params_train, device)
num_epochs = params_train["num_epochs"]
plot_loss(loss_hist=loss_hist,
num_epochs=num_epochs,
output_dir=params['output_dir'])
from folder2lmdb import ImageFolderLMDB
from torch.utils.data import DataLoader
from torchvision.transforms import Resize
if __name__ == "__main__":
transform = Resize((224, 224))
path = "/home/jiang/share/dataset/imagenet/train.lmdb"
dataset = ImageFolderLMDB(path, transform)
data_loader = DataLoader(dataset, batch_size=256, num_workers=10)
for img, label in data_loader:
# pass
print(img.shape)
print(label.shape)
import random
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision.datasets.mnist import MNIST
from torchvision.transforms import Compose, Resize, ToTensor, CenterCrop
from einops import rearrange
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
MNIST_TRANSFORM = Compose((CenterCrop((16, 16)), Resize(4, 4), ToTensor()))
X, y = next(
iter(
DataLoader(
MNIST(
"/mnt/hdd_1tb/datasets/mnist/dataset_source",
train=True,
download=False,
transform=MNIST_TRANSFORM,
),
shuffle=True,
batch_size=60000,
)))
X = rearrange(X, "b () h w -> b (h w)").numpy()
train_size = 50000
X_train = X[:train_size]
y_train = y[:train_size]
if args.model == 'resnet':
model = model.segmentNetwork().cuda()
resize_dim = (400, 400)
convert_to = 'L'
elif args.model == 'unet11':
model = unet11(out_filters=3).cuda()
resize_dim = (224, 224)
convert_to = 'RGB'
elif args.model == 'unet16':
model = unet16(out_filters=3).cuda()
resize_dim = (224, 224)
convert_to = 'RGB'
if args.no_normalize:
transforms = Compose([Resize(resize_dim),ToTensor()])
else:
transforms = Compose([Resize(resize_dim),ToTensor(),normalize])
convert_to = 'RGB'
if args.input_type == 'dicom':
dataset = iap.DicomSegment(args.img_path, transforms, convert_to)
elif args.input_type == 'png' and args.non_montgomery:
dataset = iap.LungTest(args.img_path, transforms, convert_to)
elif args.input_type == 'png':
dataset = iap.lungSegmentDataset(
os.path.join(args.img_path, "CXR_png"),
os.path.join(args.img_path, "ManualMask/leftMask/"),
os.path.join(args.img_path, "ManualMask/rightMask/"),
imagetransform=transforms,
labeltransform=Compose([Resize((224, 224)),ToTensor()]),
def __init__(self, mode, roidb_file=VG_SGG_FN, dict_file=VG_SGG_DICT_FN,
image_file=IM_DATA_FN, filter_empty_rels=True, num_im=-1, num_val_im=5000,
filter_duplicate_rels=True, filter_non_overlap=True,
use_proposals=False):
"""
Torch dataset for VisualGenome
:param mode: Must be train, test, or val
:param roidb_file: HDF5 containing the GT boxes, classes, and relationships
:param dict_file: JSON Contains mapping of classes/relationships to words
:param image_file: HDF5 containing image filenames
:param filter_empty_rels: True if we filter out images without relationships between
boxes. One might want to set this to false if training a detector.
:param filter_duplicate_rels: Whenever we see a duplicate relationship we'll sample instead
:param num_im: Number of images in the entire dataset. -1 for all images.
:param num_val_im: Number of images in the validation set (must be less than num_im
unless num_im is -1.)
:param proposal_file: If None, we don't provide proposals. Otherwise file for where we get RPN
proposals
"""
if mode not in ('test', 'train', 'val'):
raise ValueError("Mode must be in test, train, or val. Supplied {}".format(mode))
self.mode = mode
# Initialize
self.roidb_file = roidb_file
self.dict_file = dict_file
self.image_file = image_file
self.filter_non_overlap = filter_non_overlap
self.filter_duplicate_rels = filter_duplicate_rels and self.mode == 'train'
self.split_mask, self.gt_boxes, self.gt_classes, self.relationships = load_graphs_one_shot(
self.roidb_file, self.mode, num_im, num_val_im=num_val_im,
filter_empty_rels=filter_empty_rels,
filter_non_overlap=self.filter_non_overlap and self.is_train,
)
self.filenames = load_image_filenames(image_file)
self.filenames = [self.filenames[i] for i in np.where(self.split_mask)[0]]
self.ind_to_classes, self.ind_to_predicates = load_info(dict_file)
if use_proposals:
print("Loading proposals", flush=True)
p_h5 = h5py.File(PROPOSAL_FN, 'r')
rpn_rois = p_h5['rpn_rois']
rpn_scores = p_h5['rpn_scores']
rpn_im_to_roi_idx = np.array(p_h5['im_to_roi_idx'][self.split_mask])
rpn_num_rois = np.array(p_h5['num_rois'][self.split_mask])
self.rpn_rois = []
for i in range(len(self.filenames)):
rpn_i = np.column_stack((
rpn_scores[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]],
rpn_rois[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]],
))
self.rpn_rois.append(rpn_i)
else:
self.rpn_rois = None
# You could add data augmentation here. But we didn't.
# tform = []
# if self.is_train:
# tform.append(RandomOrder([
# Grayscale(),
# Brightness(),
# Contrast(),
# Sharpness(),
# Hue(),
# ]))
tform = [
SquarePad(),
Resize(IM_SCALE),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]
self.transform_pipeline = Compose(tform)
'normal', 'calcified densities', 'nodule', 'fibrotic band',
'volume loss', 'pneumothorax', 'infiltrates', 'atelectasis',
'pleural thickening', 'pleural effusion',
'costophrenic angle blunting', 'cardiomegaly', 'aortic elongation',
'mediastinal enlargement', 'mass', 'thoracic cage deformation',
'fracture', 'hemidiaphragm elevation'
]
radiographic_findings_opacity = ['opacity']
locations_labels = [
'loc left', 'loc right', 'loc upper', 'loc middle', 'loc lower',
'loc pleural', 'loc mediastinum'
]
# Transforms
transforms_train = transforms.Compose([
Resize(512),
RandomHorizontalFlip(),
RandomRotation(10),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
transforms_train_loc = transforms.Compose([
Resize_loc(512),
RandomHorizontalFlip_loc(),
RandomRotation_loc(10),
ToTensor_loc(),
Normalize_loc(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
transforms_test = transforms.Compose([
Resize(512),
# Construct dataset variables
image_resolution = (300, 300)
# Construct training dataset and loader
train_transform = Compose([
Lambda(maybe_blur),
Lambda(maybe_darken_a_lot),
Lambda(maybe_rotate),
Lambda(maybe_random_perspective),
Lambda(maybe_random_crop),
Lambda(maybe_random_erase),
ColorJitter(brightness=(.1, .8),
contrast=.05,
saturation=.05,
hue=.005),
Resize(image_resolution),
Grayscale(num_output_channels=3),
ToTensor(),
Normalize((.5, .5, .5), (.5, .5, .5))
])
train_dataset = UsageBasedDataset(train_root,
usage=150,
transform=train_transform)
train_loader = DataLoader(train_dataset,
batch_size=8,
shuffle=True,
pin_memory=True,
drop_last=True,
num_workers=4)
# Construct evaluation transformation
plt.plot(trainErrsTotal, '-', label="train total", color=(0.5, 0, 0.8))
#plt.plot( testErrsTotal, '-', label = "test total", color = (0.5,0.8,0) )
plt.yscale('log')
plt.grid(True)
plt.legend()
plt.savefig("./errors")
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
img_size = (224, 224)
composed = Compose([
ToPILImage(),
Resize(img_size),
RandomHorizontalFlip(),
RandomGrayscale(p=0.5),
RandomRotation(degrees=30, center=None),
ToTensor(), normalize
])
train_dataset = HumpbackWhaleDataset(csv_file='./train.csv',
root_dir="./train",
transform=composed)
#test_dataset = TitanicDataset(csvFile = 'test.csv')
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=100,
shuffle=True,
num_workers=4)
def observation(self, observation):
transforms = Compose([Resize(self.shape), Normalize(0, 255)])
observation = transforms(observation).squeeze(0)
return observation
def main():
# batch_size = 100
batch_size = 1
print("here")
sk_root = '../256x256/sketch/tx_000000000000'
sk_root = '../256x256/photo/tx_000000000000'
sk_root ='../test_pair/sketch'
in_size = 225
in_size = 224
train_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()]))
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(),
shuffle=True, drop_last=True)
test_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()]),train=False)
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(),
shuffle=True, drop_last=True)
num_class = len(train_dataset.classes)
embed_size = -1
model = getResnet(num_class=num_class, pretrain=True)
model.train()
if torch.cuda.is_available():
model = model.cuda()
crit = torch.nn.CrossEntropyLoss()
optim = torch.optim.Adam(model.parameters())
# optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# Tensorboard stuff
# writer = tb.SummaryWriter('./logs')
count = 0
epochs = 2
prints_interval = 1
max_chpt = 3
max_acu = -1
chpt_num = 0
activation = {}
def get_activation(name):
def hook(model, input, output):
activation[name] = output
return hook
model.avgpool.register_forward_hook(get_activation('avgpool'))
for e in range(epochs):
print('epoch',e,'started')
avg_loss = 0
for i, (X, Y) in enumerate(train_dataloader):
activation = {}
if torch.cuda.is_available():
X, Y = X.cuda(), Y.cuda()
optim.zero_grad()
to_image = transforms.ToPILImage()
output = model(X)
print(activation['avgpool'].shape)
loss = crit(output, Y)
avg_loss += loss.item()
if i == 0:
print(loss)
if i % prints_interval == 0:
print(f'[Training] {i}/{e}/{epochs} -> Loss: {avg_loss/(i+1)}')
# writer.add_scalar('train-loss', loss.item(), count)
loss.backward()
optim.step()
count += 1
print('epoch',e,'loss',avg_loss/len(train_dataloader))
correct, total, accuracy= 0, 0, 0
# model.eval()
for i, (X, Y) in enumerate(test_dataloader):
if torch.cuda.is_available():
X, Y = X.cuda(), Y.cuda()
output = model(X)
_, predicted = torch.max(output, 1)
total += Y.size(0)
correct += (predicted == Y).sum().item()
accuracy = (correct / total) * 100
print(f'[Testing] -/{e}/{epochs} -> Accuracy: {accuracy} %',total,correct)
# model.train()
if accuracy >= max_acu:
path = 'checkpoint'+str(chpt_num)+'.pt'
max_acu = accuracy
chpt_num= (chpt_num+1)%max_chpt
set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path)
path = 'best.pt'
set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path)
#64*4,8,8 => 64*8,4,4
Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 4, config.DISCRIMINATOR_FEATURES_NUM * 8,
kernel_size=4, stride=2, padding=1, bias=False),
BatchNorm2d(config.DISCRIMINATOR_FEATURES_NUM * 8),
LeakyReLU(0.2, inplace=True),
Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 8, 1, kernel_size=4, stride=1, padding=0, bias=False),
Sigmoid()
)
def forward(self, input):
return self.mainNetwork(input).view(-1)
if PHRASE == "TRAIN":
transforms = Compose([
Resize(config.IMAGE_SIZE),
CenterCrop(config.IMAGE_SIZE),
ToTensor(),
Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))
])
dataset = ImageFolder(config.DATA_PATH, transform=transforms)
dataLoader = DataLoader(dataset=dataset, batch_size=config.BATCH_SIZE,
shuffle=True,num_workers=config.NUM_WORKERS_LOAD_IMAGE,
drop_last=True)
netG, netD = DataParallel(GeneratorNet()), DataParallel(DiscriminatorNet())
map_location = lambda storage, loc: storage
optimizer_generator = Adam(netG.parameters(), config.LR_GENERATOR, betas=(config.BETA1, 0.999))
optimizer_discriminator = Adam(netD.parameters(), config.LR_DISCRIMINATOR,betas=(config.BETA1, 0.999))
criterion = BCELoss()
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, CenterCrop, Normalize, Resize
from torchvision.transforms import ToTensor, ToPILImage
from dataset import cityscapes
from erfnet import ERFNet
from transform import Relabel, ToLabel, Colorize
from iouEval import iouEval, getColorEntry
NUM_CHANNELS = 3
NUM_CLASSES = 20
image_transform = ToPILImage()
input_transform_cityscapes = Compose([
Resize(512, Image.BILINEAR),
ToTensor(),
])
target_transform_cityscapes = Compose([
Resize(512, Image.NEAREST),
ToLabel(),
Relabel(255, 19), #ignore label to 19
])
def main(args):
modelpath = args.loadDir + args.loadModel
weightspath = args.loadDir + args.loadWeights
print("Loading model: " + modelpath)
def input_transform(crop_size, upscale_factor):
return Compose([
CenterCrop(crop_size),
Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC)
])
test_dataset=test_set,
n_experiences=n_experiences,
task_labels=False,
per_exp_classes=per_exp_classes,
seed=seed,
fixed_class_order=fixed_class_order,
shuffle=shuffle,
train_transform=train_transform,
eval_transform=eval_transform,
)
def _get_cub200_dataset(root):
train_set = CUB200(root, train=True)
test_set = CUB200(root, train=False)
return train_set, test_set
__all__ = ["SplitCUB200"]
if __name__ == "__main__":
import sys
benchmark_instance = SplitCUB200(5,
train_transform=Compose(
[ToTensor(),
Resize((128, 128))]))
check_vision_benchmark(benchmark_instance, show_without_transforms=False)
sys.exit(0)
NetD = Discriminator()
BCE_LOSS = BCELoss()
G_optimizer = Adam(NetG.parameters(),
lr=CONFIG["LEARNING_RATE"],
betas=(0.5, 0.999))
D_optimizer = Adam(NetD.parameters(),
lr=CONFIG["LEARNING_RATE"],
betas=(0.5, 0.999))
if CONFIG["GPU_NUMS"] > 0:
NetG = NetG.cuda()
NetD = NetD.cuda()
BCE_LOSS = BCE_LOSS.cuda()
transform = Compose([
Resize((CONFIG["IMAGE_SIZE"], CONFIG["IMAGE_SIZE"])),
ToTensor(),
Normalize(mean=[0.5] * 3, std=[0.5] * 3)
])
train_loader = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
root=CONFIG["DATA_PATH"], transform=transform),
batch_size=CONFIG["BATCH_SIZE"],
shuffle=True)
def one_hot(target):
y = torch.zeros(target.size()[0], 10)
for i in range(target.size()[0]):
y[i, target[i]] = 1
import os
import inspect
from functools import partial
from hyperseg.datasets.cityscapes import CityscapesDataset
from torchvision.transforms import Resize
from hyperseg.test import main
if __name__ == '__main__':
project_dir = os.path.dirname(inspect.getabsfile(main))
exp_name = os.path.splitext(os.path.basename(__file__))[
0] # Make sure the config and model have the same base name
exp_dir = os.path.join('tests', exp_name)
model = os.path.join('weights', exp_name + '.pth')
data_dir = 'data/cityscapes' # Download from: https://www.cityscapes-dataset.com
test_dataset = partial(CityscapesDataset, data_dir, 'val', 'fine',
'semantic')
img_transforms = [Resize([768, 1536])]
os.chdir(project_dir)
os.makedirs(exp_dir, exist_ok=True)
main(exp_dir,
model=model,
test_dataset=test_dataset,
img_transforms=img_transforms,
forced=True)
siamese_net = SiameseNet(emb_net)
clsf_net = ResidualNetwork(emb_net=emb_net, nb_classes=15)
assert id(emb_net) == id(siamese_net.emb_net)
assert id(emb_net) == id(clsf_net.emb_net)
# Dataset
from utils.datasets import DeepFashionDataset
from torchvision.transforms import Compose
from torchvision.transforms import Resize
from torchvision.transforms import ToTensor
from torchvision.transforms import Normalize
from config.deep_fashion import DeepFashionConfig as cfg
from torch.utils.data import DataLoader
from utils.datasets import Siamesize
trans = Compose([
Resize(cfg.sizes),
ToTensor(),
Normalize(cfg.mean, cfg.std),
])
# dataset
train_ds = DeepFashionDataset(cfg.root_dir, 'train', transform=trans)
val_ds = DeepFashionDataset(cfg.root_dir, 'val', transform=trans)
siamese_train_ds = Siamesize(train_ds)
# loader
loader_kwargs = {
'pin_memory': True,
'batch_size': 100,
'num_workers': 4,
}
s_train_loader = DataLoader(siamese_train_ds, **loader_kwargs)
train_loader = DataLoader(val_ds, **loader_kwargs)
def create_image_dataloader(batch_size, target_image_size, data_location):
target_dimensions = (target_image_size, target_image_size)
transformations = Compose([Resize(target_dimensions), ToTensor()])
image_folder = ImageFolder(root=data_location, transform=transformations)
return DataLoader(image_folder, batch_size=batch_size, shuffle=True)
def get_transform(target_size=224):
return Compose([
Resize((target_size, target_size)),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
def train_lr_transform(crop_size, upscale_factor):
return Compose([
ToPILImage(),
Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC),
ToTensor()
])
def display_transform():
return Compose([ToPILImage(), Resize(448), CenterCrop(448), ToTensor()])
def __init__(self, opt, val=False):
super(CustomImageNet1K, self).__init__()
dir_dataset = os.path.join(opt.path_ImageNet, "Val" if val else "Train")
#list_dir = sorted(glob(os.path.join(dir_dataset, '*')))
#self.list_input = [] #sorted(glob(os.path.join(dir_dataset, 'val' if val else 'train', '*'))) #.JPEG')))
#for dir in list_dir:
# self.list_input.extend(glob(os.path.join(dir_dataset, dir, "*.JPEG")))
self.list_input = sorted(glob(os.path.join(dir_dataset, "*.JPEG")))
assert len(self.list_input) > 0, "Please check the path of dataset. Current path is set as {}".format(dir_dataset)
if val:
# path_label = "/mnt/home/gishin/training_WNID2class.txt"
path_label = opt.path_label_val
dict_WNID2label = dict()
# with open(path_label, 'r') as txt_file:
# csv_file = reader(txt_file, delimiter=',')
# print(csv_file)
# for i, row in enumerate(csv_file):
# if i != 0:
# if int(row[1]) - 1 == 1000:
# break
# dict_WNID2label.update({row[0]: int(row[1]) - 1}) # -1 is for making the label start from 0.
# else:
# pass
# self.label = dict_WNID2label
# print(len(self.list_input))
# path_label = os.path.join("/mnt/home/gishin/ILSVRC2012_validation_ground_truth.txt")
label = list()
with open(path_label, 'r') as txt_file:
for i, row in enumerate(txt_file):
dict_WNID2label.update({i: int(row) - 1})
# label.append(int(row) - 1)
self.label = dict_WNID2label
self.transform = Compose([Resize(256),
CenterCrop(224),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
else:
# path_label = "/mnt/home/gishin/training_WNID2class.txt"
path_label = opt.path_label_train
dict_WNID2label = dict()
with open(path_label, 'r') as txt_file:
csv_file = reader(txt_file, delimiter=',')
for i, row in enumerate(csv_file):
if i != 0:
if int(row[1]) - 1 == 1000:
break
dict_WNID2label.update({row[0]: int(row[1]) - 1}) # -1 is for making the label start from 0.
else:
pass
self.label = dict_WNID2label
self.transform = Compose([RandomResizedCrop(224),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
self.val = val
def load(name: str,
device: Union[str, torch.device] = "cuda"
if torch.cuda.is_available() else "cpu",
jit=True,
pretrained=True,
model_path=None):
if name not in _MODELS:
raise RuntimeError(
f"Model {name} not found; available models = {available_models()}")
if not model_path:
model_path = _download(_MODELS[name])
model = torch.jit.load(model_path,
map_location=device if jit else "cpu").eval()
n_px = model.input_resolution.item()
transform = Compose([
Resize(n_px, interpolation=Image.BICUBIC),
CenterCrop(n_px),
lambda image: image.convert("RGB"),
ToTensor(),
Normalize((0.48145466, 0.4578275, 0.40821073),
(0.26862954, 0.26130258, 0.27577711)),
])
if not jit:
model = build_model(model.state_dict(), pretrained).to(device)
return model, transform
# patch the device names
device_holder = torch.jit.trace(
lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
device_node = [
n for n in device_holder.graph.findAllNodes("prim::Constant")
if "Device" in repr(n)
][-1]
def patch_device(module):
graphs = [module.graph] if hasattr(module, "graph") else []
if hasattr(module, "forward1"):
graphs.append(module.forward1.graph)
for graph in graphs:
for node in graph.findAllNodes("prim::Constant"):
if "value" in node.attributeNames() and str(
node["value"]).startswith("cuda"):
node.copyAttributes(device_node)
model.apply(patch_device)
patch_device(model.encode_image)
patch_device(model.encode_text)
# patch dtype to float32 on CPU
if device == "cpu":
float_holder = torch.jit.trace(lambda: torch.ones([]).float(),
example_inputs=[])
float_input = list(float_holder.graph.findNode("aten::to").inputs())[1]
float_node = float_input.node()
def patch_float(module):
graphs = [module.graph] if hasattr(module, "graph") else []
if hasattr(module, "forward1"):
graphs.append(module.forward1.graph)
for graph in graphs:
for node in graph.findAllNodes("aten::to"):
inputs = list(node.inputs())
for i in [
1, 2
]: # dtype can be the second or third argument to aten::to()
if inputs[i].node()["value"] == 5:
inputs[i].node().copyAttributes(float_node)
model.apply(patch_float)
patch_float(model.encode_image)
patch_float(model.encode_text)
model.float()
return model, transform
self.sigma = sigma
def forward(self, tensor):
kernel_size = int(
randrange(self.kernel_size[0] - 1, self.kernel_size[1])) * 2 + 1
return gaussian_blur(
tensor, (kernel_size, kernel_size),
[torch.empty(1).uniform_(self.sigma[0], self.sigma[1]).item()])
def __repr__(self):
return self.__class__.__name__ + f"(kernel_size={self.kernel_size}, sigma={self.sigma})"
clean_transform = Compose(
[Grayscale(),
Resize((90, 90)),
ToTensor(),
Normalize((0.5), (0.5))])
noise_transform = Compose([
Grayscale(),
Resize((90, 90)),
RandomApply(RandomAffine(degrees=(-20, 20), fillcolor=255)),
RandomApply(RandomAffine(degrees=0, scale=(0.85, 1.15), fillcolor=255)),
RandomApply(RandomAffine(degrees=0, translate=(0.1, 0.1), fillcolor=255)),
RandomApply(ColorJitter(brightness=0.1, )),
ToTensor(),
RandomApply(RandomGaussianNoise()),
RandomApply(RandomGaussianBlur(kernel_size=(1, 5))),
Normalize((0.5), (0.5))
])
def forward_hook(module, inputs, outputs):
print('%s input shape: %s, output shape: %s' %
(module.name, repr(inputs[0].shape), repr(outputs[0].shape)))
def backward_hook(module, grad_in, grad_out):
print('in %s backward hook' % module.name)
if __name__ == '__main__':
model = resnet18()
model.cuda()
dataset = CIFAR100('../../data/',
train=True,
transform=Compose([Resize((224, 224)),
ToTensor()]))
loader = DataLoader(dataset)
x, y = next(iter(loader))
x = x.to(0)
from tacklebox.hook_management import HookManager
hookmngr = HookManager()
hookmngr.register_forward_hook(forward_hook,
conv=model.conv1,
activate=False)
hookmngr.register_forward_pre_hook(pre_hook, model.conv1, activate=False)
hookmngr.register_backward_hook(backward_hook, model.conv1)
from utils.common import load_yaml
Modular = False
###
if Modular:
# Modularity and Abstract
from PIL import Image
from torchvision.transforms import Compose, CenterCrop, Normalize, Resize
from torchvision.transforms import ToTensor, ToPILImage
from eval.erfnet import ERFNet
from eval.transform import Relabel, Colorize
NUM_CLASSES = 20
image_transform = ToPILImage()
input_transform_cityscapes = Compose([
Resize((160, 384), Image.BILINEAR),
ToTensor(),
#Normalize([.485, .456, .406], [.229, .224, .225]),
])
cityscapes_trainIds2labelIds = Compose([
Relabel(19, 255),
Relabel(18, 33),
Relabel(17, 32),
Relabel(16, 31),
Relabel(15, 28),
Relabel(14, 27),
Relabel(13, 26),
Relabel(12, 25),
Relabel(11, 24),
Relabel(10, 23),
HR = 'E:/pngs_cut20/gt' # (3840, 2160) 3840/960 = 2160/540 = 4
L_files = glob.glob(os.path.join(LR, "*"))
H_files = glob.glob(os.path.join(HR, "*"))
# L_files = L_files[0:100] #####################
# H_files = H_files[0:100] #####################
L_files = np.array(L_files)
H_files = np.array(H_files)
train_val_scale = 0.95
train_L = L_files[0:int(len(L_files) * train_val_scale)]
train_H = H_files[0:int(len(H_files) * train_val_scale)]
val_L = L_files[int(len(L_files) * train_val_scale):]
val_H = H_files[int(len(H_files) * train_val_scale):]
print(len(train_L),len(val_L))
train_set = DatasetFromFolder(train_L, train_H, input_transform=Compose(
[Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]),
target_transform=transforms.ToTensor())
val_set = DatasetFromFolder(val_L, val_H, input_transform=Compose(
[Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]),
target_transform=transforms.ToTensor())
train_loader = DataLoader(dataset=train_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=True)
val_loader = DataLoader(dataset=val_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=False)
#准备模型
seed = random.randint(1, 10000)
torch.manual_seed(seed)
if cuda:
torch.cuda.manual_seed(seed)
cudnn.benchmark = True
model = VDSR()
def main(args):
normalize = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
transform = Compose([Resize(256), CenterCrop(224), ToTensor(), normalize])
dataset = ImageDataset(args.image_folder,
transform=transform,
return_paths=True)
# n_images = len(dataset)
dataloader = DataLoader(dataset,
shuffle=False,
batch_size=args.batch_size,
pin_memory=True,
num_workers=0)
model = models.resnet50(pretrained=True).to(args.device)
model.eval()
config = tf.ConfigProto(intra_op_parallelism_threads=1,
inter_op_parallelism_threads=1,
allow_soft_placement=True,
device_count={'CPU': 1})
sess = tf.Session(config=config)
x_op = tf.placeholder(tf.float32, shape=(
None,
3,
224,
224,
))
tf_model = convert_pytorch_model_to_tf(model, args.device)
cleverhans_model = CallableModelWrapper(tf_model, output_layer='logits')
# compute clip_min and clip_max suing a full black and a full white image
clip_min = normalize(torch.zeros(3, 1, 1)).min().item()
clip_max = normalize(torch.ones(3, 1, 1)).max().item()
eps = args.eps / 255.
eps_iter = 20
nb_iter = 10
args.ord = np.inf if args.ord < 0 else args.ord
grad_params = {'eps': eps, 'ord': args.ord}
common_params = {'clip_min': clip_min, 'clip_max': clip_max}
iter_params = {'eps_iter': eps_iter / 255., 'nb_iter': nb_iter}
attack_name = ''
if args.attack == 'fgsm':
attack_name = '_L{}_eps{}'.format(args.ord, args.eps)
attack_op = FastGradientMethod(cleverhans_model, sess=sess)
attack_params = {**common_params, **grad_params}
elif args.attack == 'iter':
attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
eps_iter, nb_iter)
attack_op = BasicIterativeMethod(cleverhans_model, sess=sess)
attack_params = {**common_params, **grad_params, **iter_params}
elif args.attack == 'm-iter':
attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
eps_iter, nb_iter)
attack_op = MomentumIterativeMethod(cleverhans_model, sess=sess)
attack_params = {**common_params, **grad_params, **iter_params}
elif args.attack == 'pgd':
attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps,
eps_iter, nb_iter)
attack_op = MadryEtAl(cleverhans_model, sess=sess)
attack_params = {**common_params, **grad_params, **iter_params}
elif args.attack == 'jsma':
attack_op = SaliencyMapMethod(cleverhans_model, sess=sess)
attack_params = {'theta': eps, 'symbolic_impl': False, **common_params}
elif args.attack == 'deepfool':
attack_op = DeepFool(cleverhans_model, sess=sess)
attack_params = common_params
elif args.attack == 'cw':
attack_op = CarliniWagnerL2(cleverhans_model, sess=sess)
attack_params = common_params
elif args.attack == 'lbfgs':
attack_op = LBFGS(cleverhans_model, sess=sess)
target = np.zeros((1, 1000))
target[0, np.random.randint(1000)] = 1
y = tf.placeholder(tf.float32, target.shape)
attack_params = {'y_target': y, **common_params}
attack_name = args.attack + attack_name
print('Running [{}]. Params: {}'.format(args.attack.upper(),
attack_params))
adv_x_op = attack_op.generate(x_op, **attack_params)
adv_preds_op = tf_model(adv_x_op)
preds_op = tf_model(x_op)
n_success = 0
n_processed = 0
progress = tqdm(dataloader)
for paths, x in progress:
progress.set_description('ATTACK')
z, adv_x, adv_z = sess.run([preds_op, adv_x_op, adv_preds_op],
feed_dict={
x_op: x,
y: target
})
src, dst = np.argmax(z, axis=1), np.argmax(adv_z, axis=1)
success = src != dst
success_paths = np.array(paths)[success]
success_adv_x = adv_x[success]
success_src = src[success]
success_dst = dst[success]
n_success += success_adv_x.shape[0]
n_processed += x.shape[0]
progress.set_postfix(
{'Success': '{:3.2%}'.format(n_success / n_processed)})
progress.set_description('SAVING')
for p, a, s, d in zip(success_paths, success_adv_x, success_src,
success_dst):
path = '{}_{}_src{}_dst{}.npz'.format(p, attack_name, s, d)
path = os.path.join(args.out_folder, path)
np.savez_compressed(path, img=a)
BCE_LOSS = BCELoss()
if CONFIG["GPU_NUMS"] > 0:
Net_D.cuda()
Net_G.cuda()
BCE_LOSS = BCE_LOSS.cuda()
G_optimizer = Adam(Net_G.parameters(),
lr=CONFIG["LEARNING_RATE"],
betas=CONFIG["BETAS"])
D_optimizer = Adam(Net_D.parameters(),
lr=CONFIG["LEARNING_RATE"],
betas=CONFIG["BETAS"])
'''
数据读入与预处理
'''
transforms = Compose([
Resize(CONFIG["IMAGE_SIZE"]),
CenterCrop(CONFIG["IMAGE_SIZE"]),
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
dataset = ImageFolder(root='/input/Faces/Eyeglasses', transform=transforms)
train_loader = torch.utils.data.DataLoader(dataset,
batch_size=CONFIG["BATCH_SIZE"],
shuffle=True)
def one_hot(target):
y = torch.zeros(target.size()[0], 10)
for i in range(target.size()[0]):
