def __init__(self, stage, configs, tta=False, tta_size=48):
self._stage = stage
self._configs = configs
self._tta = tta
self._tta_size = tta_size
self._image_size = (configs['image_size'], configs['image_size'])
self._data = list(paths.list_images(
configs['data_path']))
random.shuffle(self._data)
self._transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
])
def __init__(self, configs: Configs):
self.device = configs.device
self.path = configs.datasetPath
self.size = (configs.image_size, configs.image_size)
self.data = torch.load(self.path)
self.length = len(self.data)
print(self.length, 'images in', self.path)
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(self.size),
transforms.ToTensor(),
])
def get_transform(args):
if args.dataset == 'celeba':
crop_size = 108
re_size = 64
offset_height = (218 - crop_size) // 2
offset_width = (178 - crop_size) // 2
crop = lambda x: x[:, offset_height:offset_height + crop_size,
offset_width:offset_width + crop_size]
preprocess = transforms.Compose(
[transforms.ToTensor(),
transforms.Lambda(crop),
transforms.ToPILImage(),
transforms.Scale(size=(re_size, re_size), interpolation=Image.BICUBIC),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5] * 3, std=[0.5] * 3)])
return preprocess
def eval():
model = Network(True).cuda()
model.load_state_dict(load_checkpoint('./noise_models', best_or_latest='best'))
model.eval()
from torchvision.transforms import transforms
from PIL import Image
img = Image.open('./003/1.jpg')
trans_tensor = transforms.ToTensor()
trans_srgb = transforms.ToPILImage()
img = trans_tensor(img).unsqueeze(0).cuda()
pred = model(img).squeeze()
print('min:', torch.min(pred), 'max:', torch.max(pred))
pred = pred / torch.max(pred)
pred = pred.cpu()
trans_srgb(pred).save('./003/1_pred.png', quality=100)
print('OK!')
def predict():
image_size = 64
channels_img = 3
channels_noise = 128
features_g = 64
fixed_noise = torch.randn(image_size, channels_noise, 1, 1)
netG = Generator(channels_noise, channels_img, features_g)
netG.load_state_dict(torch.load('g.pth', map_location=device))
fake = netG(fixed_noise)
newFake = transforms.Compose([
transforms.Normalize((-1, -1, -1), (2, 2, 2)),
transforms.ToPILImage(),
transforms.Resize(512)
])(fake[0])
print(newFake)
return serve_pil_image(newFake)
def visualize_model(model):
model.eval()
with torch.no_grad():
for i, data in enumerate(data_loaders['val']):
inputs = data['image']
labels_classes = data['classes'].to(device)
x_classes = model(inputs.to(device))
x_classes = x_classes.view(-1, 2)
_, preds_classes = torch.max(x_classes, 1)
print(inputs.shape)
plt.imshow(transforms.ToPILImage()(inputs.squeeze(0)))
plt.title('predicted classes: {}\n ground-truth classes:{}'.format(
CLASSES[preds_classes], CLASSES[labels_classes]))
plt.show()
def run_model(model_path, discrim_path):
model = Deblurrer()
model.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
model.eval()
discriminator = Discriminator(3, 64)
discriminator.load_state_dict(
torch.load(discrim_path, map_location=torch.device('cpu')))
discriminator.eval()
dataset = LFWC(["../data/train/faces_blurred"], "../data/train/faces")
#dataset = FakeData(size=1000, image_size=(3, 128, 128), transform=transforms.ToTensor())
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=True)
for data in data_loader:
blurred_img = Variable(data['blurred'])
nonblurred = Variable(data['nonblurred'])
# Should be near zero
discrim_output_blurred = discriminator(blurred_img).view(
-1).data.item()
# Should be naer one
discrim_output_nonblurred = discriminator(nonblurred).view(
-1).data.item()
#im = Image.open(image_path)
#transform = transforms.ToTensor()
transformback = transforms.ToPILImage()
plt.imshow(transformback(blurred_img[0]))
plt.title('Blurred, Discrim value: ' + str(discrim_output_blurred))
plt.show()
plt.imshow(transformback(nonblurred[0]))
plt.title('Non Blurred, Discrim value: ' +
str(discrim_output_nonblurred))
plt.show()
out = model(blurred_img)
discrim_output_model = discriminator(out).view(-1).data.item()
#print(out.shape)
outIm = transformback(out[0])
plt.imshow(outIm)
plt.title('Model out, Discrim value: ' + str(discrim_output_model))
plt.show()
def visualize_model(model):
model.eval()
with torch.no_grad():
for i, data in enumerate(data_loaders['val']):
inputs = data['image']
labels_species = data['species'].to(device)
x_species = model(inputs.to(device))
x_species = x_species.view(-1, 3) #numpy = resize
_, preds_species = torch.max(
x_species, 1) #(tensor, dim) return tensor, indices
print(inputs.shape)
plt.imshow(transforms.ToPILImage()(inputs.squeeze(0)))
plt.title('predicted species: {}\n ground-truth species:{}'.format(
SPECIES[preds_species], SPECIES[labels_species]))
plt.show()
def __init__(self, stage, configs, tta=False, tta_size=48):
self._stage = stage
self._tta = tta
self._tta_size = tta_size
self._configs = configs
self._image_size = (224, 224)
self._data = pd.read_csv(
os.path.join(configs['data_path'], '{}.csv'.format(stage)))
self._path_list = self._data['filepath'].tolist()
self._emotions = pd.get_dummies(self._data['emotions'])
self._transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
])
def augmentation(self, data, gr_ids, policy):
aug_imgs = []
if "cifar" in C.get()["dataset"]:
mean, std = _CIFAR_MEAN, _CIFAR_STD
elif "svhn" in C.get()["dataset"]:
mean, std = _SVHN_MEAN, _SVHN_STD
# applied_policies = []
for gr_id, img in zip(gr_ids, data):
pil_img = transforms.ToPILImage()(UnNormalize()(img.cpu()))
_aug = Augmentation(policy[int(gr_id)])
aug_img = _aug(pil_img)
aug_img = self.transform(aug_img)
aug_imgs.append(aug_img)
# applied_policy = _aug.policy # Todo
# applied_policies.append(applied_policy)
aug_imgs = torch.stack(aug_imgs)
return aug_imgs.cuda() #, applied_policies
def prediction_to_img(pred):
_, C, H, W = pred.shape
pred = torch.reshape(pred, (C, H, W))
_, indices = torch.max(pred, dim=0)
indices = torch.reshape(indices, (1, H, W))
output = torch.cat((indices, indices, indices))
output_img = torch.zeros(3, H, W)
for i in range(C):
R, G, B = color_dict[i]
color_mask = torch.cat((R*torch.ones((1, H, W)), G*torch.ones((1, H, W)), B*torch.ones((1, H, W))))
output_img = torch.where(output == i, color_mask, output_img)
return transforms.ToPILImage()(output_img/255).convert('RGB')
def parse_augmentation(augmentation_spec, image_size):
""" Loads the data augmentation configuration
Args:
augmentation_spec: DataAugmentation instance
image_size: the output image size
Returns: torchvision.transforms object with the corresponding augmentation
"""
def gaussian_noise(x, std):
""" Helper function to add gaussian noise
Args:
x: input
std: standard deviation for the normal distribution
Returns: perturbed image
"""
x += torch.randn(x.size()) * std
return x
def rescale(x):
""" Rescales the image between -1 and 1
Args:
x: image
Returns: rescaled image
"""
return (x * 2) - 1
_transforms = []
if augmentation_spec.enable_gaussian_noise and \
augmentation_spec.gaussian_noise_std > 0:
f = partial(gaussian_noise, std=augmentation_spec.gaussian_noise_std)
_transforms.append(transforms.Lambda(f))
if augmentation_spec.enable_jitter and \
augmentation_spec.jitter_amount > 0:
_transforms.append(transforms.ToPILImage())
amount = augmentation_spec.jitter_amount
_transforms.append(transforms.RandomCrop(image_size, padding=amount))
return _transforms
def get_random_test_samples_dataloader(
parameters: dict,
nb_sample: int = 10,
transform: Optional[Callable] = None,
classes: Optional[List[int]] = None,
) -> Tuple[Dataset, DataLoader]:
""" Return a random set of test samples """
dataset_test_image = dataset_from_config(
parameters, "test",
transforms.Compose([
transform,
transforms.Normalize([-1], [2]),
transforms.ToPILImage()
]))
dataset_test_tensors = dataset_from_config(parameters, "test", transform)
if classes is not None:
y = dataset_test_image.y()
y = torch.tensor(y)
# Find number of sample to choose for each class ((nb_sample / len(classes) +/- 1)
split = (
torch.arange(nb_sample + len(classes) - 1, nb_sample - 1, -1) //
len(classes)).tolist()
subset_indices = []
for i, class_ in enumerate(classes):
# Indices in the dataset corresponding to this class
indices_for_class = torch.where(y == class_)[0]
# Add random indices corresponding to this class
subset_indices += indices_for_class[torch.randint(
len(indices_for_class), (split[i], ))].tolist()
else:
subset_indices = [
random.randrange(len(dataset_test_image)) for _ in range(nb_sample)
]
subset_images = Subset(dataset_test_image, subset_indices)
subset_tensors = Subset(dataset_test_tensors, subset_indices)
dataloader_tensors = DataLoader(subset_tensors,
batch_size=nb_sample,
num_workers=0,
shuffle=False)
return subset_images, dataloader_tensors
def __init__(self):
self.net = cv2.dnn.readNetFromCaffe(
os.path.join(FACE_ROOT_DIR, "deploy.prototxt.txt"),
os.path.join(FACE_ROOT_DIR, "res10_300x300_ssd_iter_140000.caffemodel")
)
self.transform = transforms.Compose([transforms.ToPILImage(), transforms.ToTensor()])
# load configs and set random seed
self.configs = json.load(open(os.path.join(FACE_ROOT_DIR, "configs", "fer2013_config.json")))
self.image_size = (self.configs["image_size"], self.configs["image_size"])
self.model = resmasking_dropout1(in_channels=3, num_classes=7)
self.model.cuda()
self.state = torch.load(
os.path.join(FACE_ROOT_DIR, "Z_resmasking_dropout1_rot30_2019Nov30_13.32")
)
self.model.load_state_dict(self.state["net"])
self.model.eval()
def get_image_dataloader(path_to_data, batch_size=16):
my_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.ToPILImage(),
transforms.RandomHorizontalFlip(),
transforms.RandomGrayscale(),
transforms.RandomRotation([-30, 30]),
# transforms.Normalize([],[]) # get mean and std
transforms.ToTensor(),
])
dataset = ImageFolder(root=path_to_data,
transform=my_transforms,
is_valid_file=check_valid)
print(len(dataset.classes))
dataloader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True)
return dataloader, dataset
def prepare_data(images, color_mode='BGR', new_shape=416, color=(127.5, 127.5, 127.5), mode='square'):
images_ok = np.zeros((images.shape[0], new_shape, new_shape, 3), dtype=images[0].dtype)
images_tensor = torch.zeros((images.shape[0], 3, new_shape, new_shape), dtype=torch.float32)
for i in range(len(images)):
if color_mode == 'BGR':
images[i] = cv2.cvtColor(images[i], cv2.COLOR_BGR2RGB)
elif color_mode == 'RGB':
pass
else:
raise NotImplementedError
images_ok[i], _, _, _ = letterbox(images[i], new_shape, color, mode)
images_tensor[i] = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
])(images_ok[i])
return images_tensor
def tensors_to_images(tensors, filenames, valid_data_path):
quality_val = 90
transform = transforms.ToPILImage()
for i in range(len(tensors)):
for volume in tensors[i]:
volume = volume.cpu().numpy().transpose((1, 2, 0))
for j in range(volume.shape[2]):
channel = volume[:, :, j]
minimum = np.min(channel)
maximum = np.max(channel)
volume[:, :,
j] = 255 * (channel - minimum) / (maximum - minimum)
image = transform(np.uint8(volume))
file_name = filenames[i][0].split('.')
image.save(os.path.join(valid_data_path,
file_name[0] + '_valid.jpg'),
'JPEG',
quality=quality_val)
def __init__(self, stage, configs, tta=False, tta_size=48):
self._stage = stage
self._configs = configs
self._tta = tta
self._tta_size = tta_size
self._image_size = (configs["image_size"], configs["image_size"])
self._data = pd.read_csv(
os.path.join(configs["data_path"], "{}.csv".format(stage)))
self._pixels = self._data["pixels"].tolist()
self._emotions = pd.get_dummies(self._data["emotion"])
self._transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
])
def test(args):
model = model_type(num_classes)
model.load_state_dict(torch.load(args.ckpt, map_location='cpu'))
dataset = image_dataset(False, x_transforms, y_transforms)
dataloaders = DataLoader(dataset, batch_size=1)
model.eval()
import matplotlib.pyplot as plt
plt.ion()
with torch.no_grad():
for x, label_y in dataloaders:
predict_y = model(x)
predict_y = utils.get_predict_image(predict_y[0])
plt.subplot(1, 2, 1)
plt.imshow(predict_y)
plt.subplot(1, 2, 2)
plt.imshow(transforms.ToPILImage()(label_y[0]))
plt.pause(0.01)
plt.show()
def evaluate_metrics(model_path):
model = Deblurrer()
model.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
model.eval()
dataset = LFWC(["../data/test/faces_blurred"], "../data/test/faces")
#dataset = FakeData(size=1000, image_size=(3, 128, 128), transform=transforms.ToTensor())
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=True)
count = 0
avg0 = 0
avg1 = 0
avgs = 0
avgs1 = 0
for data in data_loader:
blurred_img = Variable(data['blurred'])
nonblurred = Variable(data['nonblurred'])
#im = Image.open(image_path)
#transform = transforms.ToTensor()
transformback = transforms.ToPILImage()
out = model(blurred_img)
#print(out.shape)
outIm = transformback(out[0])
nonblurred = transformback(nonblurred[0])
blurred = transformback(blurred_img[0])
ps = psnr(outIm, nonblurred)
avg0 += ps
ps1 = psnr(blurred, nonblurred)
avg1 += ps1
similarity = ssim1(outIm, nonblurred)
avgs += similarity
sim1 = ssim1(blurred, nonblurred)
avgs1 += sim1
count += 1
avg0 /= count
avg1 /= count
avgs /= count
avgs1 /= count
print(avg0)
print(avg1)
print(avgs)
print(avgs1)
def test_image():
#model = Unet(3, 3)
model = Unet(1, 1)
model.load_state_dict(
torch.load('ckp_xin/fd3model.pth', map_location='cpu'))
model.eval()
'''
img = Image.open("data/aug/24.bmp")
img = x_transforms(img)
img = torch.unsqueeze(img,0)
'''
#img_x = pydicom.dcmread("data/aug/32.dcm")
#img_x = WL(img_x,150,300)
#img_x = Image.fromarray(img_x)
img_x = Image.open("data/aug/76.bmp")
img_x = img_x.convert('L')
#img_x.save('data/aug/32dtp.bmp')
#img_x.show()
img_x = x_transforms(img_x)
img_x = torch.unsqueeze(img_x, 0)
labels = Image.open("data/aug/76_mask.bmp")
labels = labels.convert('L')
labels = y_transforms(labels)
labels = torch.unsqueeze(labels, 0)
out = model(img_x)
print(IOU(out.to("cpu"), labels.to("cpu")).item())
'''
img_mask = Image.open("data/aug/166_mask.png")
img_mask = y_transforms(img_mask)
img_mask = torch.unsqueeze(img_mask,0)
out = model(img)
dice = dice_coeff(out,img_mask)
print(dice.detach().numpy())
'''
trann = transforms.ToPILImage()
out = torch.squeeze(out)
out = trann(out)
out.save("data/aug/76_maskfd3.bmp")
def test():
model = Unet(3, 1).to(device)
model.load_state_dict(torch.load(args.ckp))
liver_dataset = LiverDataset("data/test",
transform=x_transforms,
target_transform=y_transforms)
dataloaders = DataLoader(liver_dataset, batch_size=1)
model.eval()
with torch.no_grad():
for x, _, x_path in tqdm(dataloaders):
x_path = str(x_path).split("/")
x = x.to(device)
y = model(x)
img_numpy = y[0].cpu().float().numpy()
img_numpy = (np.transpose(img_numpy, (1, 2, 0)))
img_numpy = (img_numpy >= 0.5) * 255
img_out = img_numpy.astype(np.uint8)
imgs = transforms.ToPILImage()(img_out)
imgs.save('result/' + x_path[2][:-3])
def __init__(self, stage, fold_idx, configs):
""" fold_idx: test fold """
self._configs = configs
self._stage = stage
self._fold_idx = fold_idx
self._data = []
for fold_path in glob.glob("./saved/data/CK+/npy_folds/*.npy"):
fold_name = os.path.basename(fold_path)
if str(fold_idx) == fold_name[5:-4] and stage == "test":
self._data = np.load(fold_path, allow_pickle=True).tolist()
if str(fold_idx) != fold_name[5:-4] and stage == "train":
self._data.extend(
np.load(fold_path, allow_pickle=True).tolist())
self._image_size = (configs["image_size"], configs["image_size"])
self._transform = transforms.Compose(
[transforms.ToPILImage(),
transforms.ToTensor()])
def _test_process(model,
te_loader,
length,
save_pre: bool = False,
save_path: str = "") -> dict:
cal_total_metrics = CalTotalMetric(num=length, beta_for_wfm=1)
to_pil = transforms.ToPILImage()
tqdm_iter = tqdm(enumerate(te_loader), total=len(te_loader), leave=False)
for test_batch_id, test_data in tqdm_iter:
tqdm_iter.set_description(f"{exp_name}: te=>{test_batch_id + 1}")
with torch.no_grad():
in_imgs, in_names, in_mask_paths = test_data
in_imgs = in_imgs.cuda(non_blocking=True)
outputs = model(in_imgs)
outputs_np = outputs.sigmoid().cpu().detach()
for item_id, out_item in enumerate(outputs_np):
gimg_path = os.path.join(in_mask_paths[item_id])
gt_img = Image.open(gimg_path).convert("L")
out_img = to_pil(out_item).resize(gt_img.size)
if save_pre:
oimg_path = os.path.join(save_path, in_names[item_id] + ".png")
out_img.save(oimg_path)
gt_img = np.asarray(gt_img)
out_img = np.asarray(out_img)
# 归一化
gt_img = gt_img / (gt_img.max() + 1e-8)
gt_img = np.where(gt_img > 0.5, 1, 0)
out_img_max = out_img.max()
out_img_min = out_img.min()
if out_img_max == out_img_min:
out_img = out_img / 255
else:
out_img = (out_img - out_img_min) / (out_img_max - out_img_min)
# 更新指标记录
cal_total_metrics.update(out_img, gt_img)
results = cal_total_metrics.show()
return results
def decode(x, bottleneck):
decoder = Decoder(int(bottleneck / 512))
if torch.cuda.is_available():
decoder = Decoder(int(bottleneck / 512)).cuda()
decoder.load_state_dict(
torch.load('./project/models/model_LSTM_' + str(bottleneck) +
'/decoder'))
else:
decoder.load_state_dict(
torch.load('./project/models/model_LSTM_' + str(bottleneck) +
'/decoder',
map_location=torch.device('cpu')))
decoder.eval()
if torch.cuda.is_available():
d_1 = (torch.zeros(1, 512, 16, 16).cuda(), torch.zeros(1, 512, 16,
16).cuda())
d_2 = (torch.zeros(1, 512, 32, 32).cuda(), torch.zeros(1, 512, 32,
32).cuda())
d_3 = (torch.zeros(1, 256, 64, 64).cuda(), torch.zeros(1, 256, 64,
64).cuda())
d_4 = (torch.zeros(1, 128, 128,
128).cuda(), torch.zeros(1, 128, 128, 128).cuda())
else:
d_1 = (torch.zeros(1, 512, 16, 16), torch.zeros(1, 512, 16, 16))
d_2 = (torch.zeros(1, 512, 32, 32), torch.zeros(1, 512, 32, 32))
d_3 = (torch.zeros(1, 256, 64, 64), torch.zeros(1, 256, 64, 64))
d_4 = (torch.zeros(1, 128, 128, 128), torch.zeros(1, 128, 128, 128))
binary = np.unpackbits(x, axis=-1)
binary = torch.from_numpy(binary).float() * 2 - 1
result = torch.zeros(1, 3, 256, 256)
for t in range(rnn_num):
outputs, d_1, d_2, d_3, d_4 = decoder(binary[t], d_1, d_2, d_3, d_4)
result = result + outputs
toImage = transforms.ToPILImage()
image = toImage(result.squeeze())
return image
def show_batch(self, rows=3, imgsize=(20, 20), figsize=(10, 10)):
with plt_inline():
old_backend = matplotlib.get_backend()
Xs, ys = next(iter(self.train_dl))
Xs = Xs[:rows * rows]
ys = ys[:rows * rows]
axs = subplots(rows, rows, imgsize=imgsize, figsize=figsize)
invnormalize = self.inv_normalize()
for x, y, ax in zip(Xs, ys, axs.flatten()):
x = x.cpu()
x = invnormalize(x)
#x = (1/(2*2.25)) * x / 0.25 + 0.5
im = transforms.ToPILImage()(x).convert("RGB")
im = transforms.Resize([100, 100])(im)
ax.imshow(im)
ax.set_title(f'y={y}')
for ax in axs.flatten()[len(Xs):]:
ax.axis('off')
plt.tight_layout()
plt.show()
def superresolve(img, seed=2019):
transform = transforms.Compose([transforms.ToTensor()])
inputs = transform(img)
if torch.cuda.is_available():
inputs = inputs.cuda()
outputs = net(inputs.unsqueeze(0)).squeeze()
if torch.cuda.is_available():
outputs = outputs.cuda()
torch.manual_seed(seed)
noise = tdist.Normal(torch.tensor([0.0]), torch.tensor([0.1]))
tmp = noise.sample(outputs.size()).squeeze(3)
for i in range(3):
for j in range(128):
for k in range(128):
tmp[i][2*j][2*k] = 0.0
outputs += tmp
toImage = transforms.ToPILImage()
res = toImage(outputs)
return res
def _predict_phase_(self):
dataset, indices = self.get_predict_dataset()
self.model.eval()
with torch.no_grad():
for idx in indices:
if idx < 0 or idx >= len(dataset):
continue
sample = dataset[idx]
inputs = sample['image']
inputs = inputs.expand(1, *inputs.size()).to(self.device)
ground_truth = sample['classes']
outputs = self.model(inputs)
_, predicted = torch.max(outputs, 1)
plt.imshow(transforms.ToPILImage()(inputs.squeeze(0)))
plt.title('predicted classes: {}\nground-truth classes: {}'.format(
CLASSES[predicted.item()], CLASSES[ground_truth]))
plt.show()
def __getitem__(self, idx):
img_path = os.path.join('./data', self.dataframe.iloc[idx, 2])
img = sio.imread(img_path, mode='RGB')
img = transforms.ToPILImage()(img)
if self.LAP:
age, std = self.dataframe.iloc[idx, 0].astype(
'float'), self.dataframe.iloc[idx, 3].astype('float')
else:
age = self.dataframe.iloc[idx, 0].astype('float')
if age not in range(0, 100):
age = 0
if not self.transform == None:
img = self.transform(
img) # ndarray => torch.Tensor + Normalization
if self.LAP:
return img, age, std
else:
return img, age
def __init__(self, stage, configs, tta=False, tta_size=48):
self._stage = stage
self._configs = configs
self._tta = tta
self._tta_size = tta_size
self._image_size = (configs['image_size'], configs['image_size'])
if stage == 'train':
self._data = pd.read_csv(
os.path.join(configs['data_path'], 'train.npy'))
elif stage == 'val':
self._data = pd.read_csv(
os.path.join(configs['data_path'], 'val.npy'))
else:
raise Exception("just train or val")
self._transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
])
