def dfield_to_torch_position(dfield, spacing=[1., 1., 1.]):
"""
Input displacement must be in physical coordinates
specified by the given spacing parameter.
input dfield is shape [nz ny nx 3]
dfield[:,:,:,0] holds z displacements
dfield[:,:,:,1] holds y displacements
dfield[:,:,:,2] holds x displacements
spacing is size [3] holding [z y x] spacings
:param dfield:
:param spacing:
:return:
"""
# the last dimension must hold the displacement vector
np.flip(dfield)
# copies may be necessary to avoid negative stride
dfield_copy = dfield.astype('=f4')
# IMPORTANT: The flipping below is because
# the torch call:
# F.grid_sample( im, grid )
#
# for an image of size [1, 1, z, y, x]
# grid must be of size [1, z, y, x, 3]
# where
# grid[:,:,:,:0] holds x displacements
# grid[:,:,:,:1] holds y displacements
# grid[:,:,:,:2] holds z displacements
dfield_t = torch.flip(torch.from_numpy(dfield_copy), [3])
spacing_t = torch.as_tensor(
spacing.copy()) # spacing may be a numpy or python array
spacing_t = torch.flipud(spacing_t)
mtmp = 2.0 / (torch.as_tensor(dfield_t.size()[:3]).float() - 1.0)
# mtmp is in z y x order, but it needs to be x y z so:
mtmp = torch.flipud(mtmp)
mul = mtmp / spacing_t
# displacements to pixel coordinates
dfield_t *= mul
# the grid torch needs for grid_sample
identity_grid = torch.meshgrid(torch.linspace(-1, 1, dfield_t.size(2)),
torch.linspace(-1, 1, dfield_t.size(1)),
torch.linspace(-1, 1, dfield_t.size(0)))
id_grid_stack = torch.stack(identity_grid).permute(3, 2, 1, 0)
position_grid = (id_grid_stack + dfield_t)
return position_grid
def augment_data(x, y, n=None):
"""
Generate an augmented training dataset with random reflections
and 90 degree rotations
x, y : Image sets of shape (Samples, Width, Height, Channels)
training images and next images
n : number of training examples
"""
n_data = x.shape[0]
if not n:
n = n_data
x_out, y_out = list(), list()
for i in range(n):
r = random.randint(0, n_data)
x_r, y_r = x[r], y[r]
if random.random() < 0.5:
x_r = torch.fliplr(x_r)
y_r = torch.fliplr(y_r)
if random.random() < 0.5:
x_r = torch.flipud(x_r)
y_r = torch.flipud(y_r)
num_rots = random.randint(0, 4)
x_r = torch.rot90(x_r, k=num_rots)
y_r = torch.rot90(y_r, k=num_rots)
x_out.append(x_r), y_out.append(y_r)
return torch.stack(x_out), torch.stack(y_out)
def __call__(self, sample):
train, truth = sample['train'], sample['truth']
if np.random.rand() >= self.probability:
train = torch.flipud(train)
truth = torch.flipud(truth)
return {'train': train, 'truth': truth}
def data_augmentation(image, mask):
image = torch.Tensor(image)
mask = torch.Tensor(mask)
mask = mask.unsqueeze(0)
if random.random() < 0.5:
# flip left right
image = torch.fliplr(image)
mask = torch.fliplr(mask)
rot = np.random.choice([0, 1, 2, 3])
image = torch.rot90(image, rot, [1, 2])
mask = torch.rot90(mask, rot, [1, 2])
if random.random() < 0.5:
# flip up-down
image = torch.flipud(image)
mask = torch.flipud(mask)
if intensity >= 1:
# random crop
cropsize = image.shape[2] // 2
image, mask = random_crop(image, mask, cropsize=cropsize)
std_noise = 1 * image.std()
if random.random() < 0.5:
# add noise per pixel and per channel
pixel_noise = torch.rand(image.shape[1], image.shape[2])
pixel_noise = torch.repeat_interleave(pixel_noise.unsqueeze(0),
image.size(0),
dim=0)
image = image + pixel_noise * std_noise
if random.random() < 0.5:
channel_noise = torch.rand(
image.shape[0]).unsqueeze(1).unsqueeze(2)
channel_noise = torch.repeat_interleave(
torch.repeat_interleave(channel_noise, image.shape[1], 1),
image.shape[2], 2)
image = image + channel_noise * std_noise
if random.random() < 0.5:
# add noise
noise = torch.rand(image.shape[0], image.shape[1],
image.shape[2]) * std_noise
image = image + noise
if intensity >= 2:
# channel shuffle
if random.random() < 0.5:
idxs = np.arange(image.shape[0])
np.random.shuffle(idxs) # random band indixes
image = image[idxs]
mask = mask.squeeze(0)
return image, mask
def __call__(self, img, mask):
# def __call__(self, img, mask):
# if random.random() < self.p:
# return (
# (np.flipud(img)).copy(), (np.flipud(mask)).copy()
# )
# return img, mask
if random.random() < self.p:
return ((torch.flipud(img)).copy(), (torch.flipud(mask)).copy())
return img, mask
def __call__(self, img, mask):
if random.random() < self.p:
# img = cv2.flip(img, 1)
# mask = cv2.flip(mask, 1)
img = torch.flipud(img)
mask = torch.flipud(mask)
return (
# img.transpose(Image.FLIP_TOP_BOTTOM),
# mask.transpose(Image.FLIP_TOP_BOTTOM),
img,
mask,
)
return img, mask
def cosine2by2(representation1, representation2,device = 'cpu'):
loss_func = nn.CosineEmbeddingLoss()
x1 = torch.cat([representation1,representation1])
x2 = torch.cat([representation2,torch.flipud(representation2)])
y = torch.tensor([1,1,-1,-1],)
idx = np.random.choice(len(y),len(y),replace = False)
return loss_func(x1[idx].to(device),x2[idx].to(device),y[idx].to(device))
def prepare_first_frame(curr_video,
save_prediction,
annotation,
sigma1=8,
sigma2=21,
inference_strategy='single',
probability_propagation=False,
scale=None):
first_annotation = Image.open(annotation)
(H, W) = np.asarray(first_annotation).shape
H_d = int(np.ceil(H * Config.SCALE))
W_d = int(np.ceil(W * Config.SCALE))
palette = first_annotation.getpalette()
label = np.asarray(first_annotation)
d = np.max(label) + 1
label = torch.Tensor(label).long().to(Config.DEVICE) # (1, H, W)
label_1hot = get_labels(label, d, H, W, H_d, W_d)
weight_dense = get_spatial_weight((H_d, W_d), sigma1) if not probability_propagation else None
weight_sparse = get_spatial_weight((H_d, W_d), sigma2) if not probability_propagation else None
if save_prediction is not None:
if not os.path.exists(save_prediction):
os.makedirs(save_prediction)
save_path = os.path.join(save_prediction, curr_video)
if not os.path.exists(save_path):
os.makedirs(save_path)
first_annotation.save(os.path.join(save_path, '00000.png'))
if inference_strategy == 'single':
return label_1hot, d, palette, weight_dense, weight_sparse
elif inference_strategy == 'hor-flip':
label_1hot_flipped = get_labels(torch.fliplr(label), d, H, W, H_d, W_d)
return label_1hot, label_1hot_flipped, d, palette, weight_dense, weight_sparse
elif inference_strategy == 'ver-flip':
label_1hot_flipped = get_labels(torch.flipud(label), d, H, W, H_d, W_d)
return label_1hot, label_1hot_flipped, d, palette, weight_dense, weight_sparse
elif inference_strategy == '2-scale' or inference_strategy == 'hor-2-scale':
H_d_2 = int(np.ceil(H * Config.SCALE * scale))
W_d_2 = int(np.ceil(W * Config.SCALE * scale))
weight_dense_2 = get_spatial_weight((H_d_2, W_d_2), sigma1) if not probability_propagation else None
weight_sparse_2 = get_spatial_weight((H_d_2, W_d_2), sigma2) if not probability_propagation else None
label_1hot_2 = get_labels(label, d, H, W, H_d_2, W_d_2)
return (label_1hot, label_1hot_2), d, palette, (weight_dense, weight_dense_2), (weight_sparse, weight_sparse_2)
elif inference_strategy == 'multimodel':
# that's right, do nothing
pass
elif inference_strategy == '3-scale':
del weight_dense, weight_sparse
H_d = int(np.ceil(H * Config.SCALE * scale))
W_d = int(np.ceil(W * Config.SCALE * scale))
weight_dense = get_spatial_weight((H_d, W_d), sigma1) if not probability_propagation else None
weight_sparse = get_spatial_weight((H_d, W_d), sigma2) if not probability_propagation else None
label_1hot = get_labels(label, d, H, W, H_d, W_d)
return label_1hot, d, palette, weight_dense, weight_sparse
return label_1hot, d, palette, weight_dense, weight_sparse
def test_flipud_invalid(self, device, dtype):
with self.assertRaisesRegex(RuntimeError, "Input must be >= 1-d."):
torch.flipud(torch.tensor(42, device=device, dtype=dtype))
def other_ops(self):
a = torch.randn(4)
b = torch.randn(4)
c = torch.randint(0, 8, (5, ), dtype=torch.int64)
e = torch.randn(4, 3)
f = torch.randn(4, 4, 4)
size = [0, 1]
dims = [0, 1]
return (
torch.atleast_1d(a),
torch.atleast_2d(a),
torch.atleast_3d(a),
torch.bincount(c),
torch.block_diag(a),
torch.broadcast_tensors(a),
torch.broadcast_to(a, (4)),
# torch.broadcast_shapes(a),
torch.bucketize(a, b),
torch.cartesian_prod(a),
torch.cdist(e, e),
torch.clone(a),
torch.combinations(a),
torch.corrcoef(a),
# torch.cov(a),
torch.cross(e, e),
torch.cummax(a, 0),
torch.cummin(a, 0),
torch.cumprod(a, 0),
torch.cumsum(a, 0),
torch.diag(a),
torch.diag_embed(a),
torch.diagflat(a),
torch.diagonal(e),
torch.diff(a),
torch.einsum("iii", f),
torch.flatten(a),
torch.flip(e, dims),
torch.fliplr(e),
torch.flipud(e),
torch.kron(a, b),
torch.rot90(e),
torch.gcd(c, c),
torch.histc(a),
torch.histogram(a),
torch.meshgrid(a),
torch.lcm(c, c),
torch.logcumsumexp(a, 0),
torch.ravel(a),
torch.renorm(e, 1, 0, 5),
torch.repeat_interleave(c),
torch.roll(a, 1, 0),
torch.searchsorted(a, b),
torch.tensordot(e, e),
torch.trace(e),
torch.tril(e),
torch.tril_indices(3, 3),
torch.triu(e),
torch.triu_indices(3, 3),
torch.vander(a),
torch.view_as_real(torch.randn(4, dtype=torch.cfloat)),
torch.view_as_complex(torch.randn(4, 2)),
torch.resolve_conj(a),
torch.resolve_neg(a),
)
def camera_rgb(obs_cache):
# Switch to correct camera
if self is not None and self.camera_name != cam_name:
self._switch_camera(cam_name)
rendered_imgs = self.renderer.render(modes=self.modes)
rendered_mapping = {
k: val
for k, val in zip(self.modes, rendered_imgs)
}
# in np array image received is of correct orientation
# in torch tensor image is flipped upside down
# adjusting the np image in a way so that return statement stays same
# flipping torch tensor when opencv coordinate system is required.
# using torch.flipud because negative strides do not work in torch.
if 'rgb' in self.modes:
img = rendered_mapping['rgb'][:, :, :3]
if isinstance(img, np.ndarray):
# np array is in range 0-1
img = (img * 255).astype(np.uint8)
img = adjust_convention(img, convention)
elif convention == -1:
img = torch.flipud(img)
else:
img = np.zeros((cam_h, cam_w), np.uint8)
if 'seg' in self.modes:
# 0th channel contains segmentation
seg_map = rendered_mapping['seg'][:, :, 0]
if isinstance(seg_map, np.ndarray):
# np array is in range 0-1
# round function is important here otherwise trippy looking segmaps
seg_map = (seg_map * MAX_CLASS_COUNT).round().astype(
np.int64)
# flip the image upside down if required
seg_map = adjust_convention(seg_map, convention)
elif convention == -1:
# flip in Y direction if torch tensor
seg_map = torch.flipud(seg_map)
obs_cache[seg_sensor_name] = seg_map
if '3d' in self.modes:
# 2nd channel contains correct depth map
depth_map = rendered_mapping['3d'][:, :, 2]
if isinstance(depth_map, np.ndarray):
depth_map = adjust_convention(depth_map, convention)
elif convention == -1:
# flip in Y direction if torch tensor
depth_map = torch.flipud(depth_map)
obs_cache[depth_sensor_name] = depth_map
if 'normal' in self.modes:
normal_map = rendered_mapping['normal'][:, :, :3]
if isinstance(normal_map, np.ndarray):
# np array is in range 0-1
normal_map = (normal_map * 255).astype(np.uint8)
normal_map = adjust_convention(normal_map, convention)
elif convention == -1:
normal_map = torch.flipud(normal_map)
obs_cache[normal_sensor_name] = normal_map
return img
def predict(self, path, predpath):
with rasterio.open(path, "r") as src:
meta = src.meta
self.model.eval()
# for prediction
predimage = os.path.join(predpath, os.path.basename(path))
os.makedirs(predpath, exist_ok=True)
meta["count"] = 1
meta["dtype"] = "uint8" # storing as uint8 saves a lot of storage space
#Window(col_off, row_off, width, height)
H, W = self.image_size
rows = np.arange(0, meta["height"], H)
cols = np.arange(0, meta["width"], W)
image_window = Window(0, 0, meta["width"], meta["height"])
with rasterio.open(predimage, "w+", **meta) as dst:
for r, c in tqdm(product(rows, cols), total=len(rows) * len(cols), leave=False):
window = image_window.intersection(
Window(c-self.offset, r-self.offset, W+self.offset, H+self.offset))
with rasterio.open(path) as src:
image = src.read(window=window)
# if L1C image (13 bands). read only the 12 bands compatible with L2A data
if (image.shape[0] == 13):
image = image[[l1cbands.index(b) for b in l2abands]]
# to torch + normalize
image = self.transform(torch.from_numpy(image.astype(np.float32)), [])[0].to(self.device)
# predict
with torch.no_grad():
x = image.unsqueeze(0)
#import pdb; pdb.set_trace()
y_logits = torch.sigmoid(self.model(x).squeeze(0))
if self.use_test_aug > 0:
y_logits += torch.sigmoid(torch.fliplr(self.model(torch.fliplr(x)))).squeeze(0) # fliplr)
y_logits += torch.sigmoid(torch.flipud(self.model(torch.flipud(x)))).squeeze(0) # flipud
if self.use_test_aug > 1:
for rot in [1, 2, 3]: # 90, 180, 270 degrees
y_logits += torch.sigmoid(torch.rot90(self.model(torch.rot90(x, rot, [2, 3])),-rot,[2,3]).squeeze(0))
y_logits /= 6
else:
y_logits /= 3
y_score = y_logits.cpu().detach().numpy()[0]
#y_score = y_score[:,self.offset:-self.offset, self.offset:-self.offset]
data = dst.read(window=window)[0] / 255
overlap = data > 0
if overlap.any():
# smooth transition in overlapping regions
dx, dy = np.gradient(overlap.astype(float)) # get border
g = np.abs(dx) + np.abs(dy)
transition = gaussian_filter(g, sigma=self.offset / 2)
transition /= transition.max()
transition[~overlap] = 1.# normalize to 1
y_score = transition * y_score + (1-transition) * data
# write
writedata = (np.expand_dims(y_score, 0).astype(np.float32) * 255).astype(np.uint8)
dst.write(writedata, window=window)
d = torch.tensor([1.7, 1.2, 3.1, 2])
print(torch.maximum(a, b))
print(torch.minimum(a, b))
print(torch.fmod(a, 2))
print(torch.dist(c, d, 1)) # p-norm
print(torch.norm(c))
print(torch.div(c, d))
print(torch.true_divide(c, d)) # rounding_mode=None
print(torch.sub(c, d, alpha=2.))
print(c.add(d))
print(torch.dot(c, d))
print(torch.sigmoid(c))
# print(torch.inner(c, d))
"""flip"""
x = torch.arange(4).view(2, 2)
print(torch.flipud(x))
print(torch.fliplr(x))
# logical
print("logical function:")
print(torch.eq(c, d))
print(torch.ne(c, d))
print(torch.gt(c, d))
print(torch.logical_and(c, d))
print(torch.logical_or(c, d))
print(torch.logical_xor(c, d))
print(torch.logical_not(c))
print(torch.equal(c, d)) # if all equal
a = torch.rand(2, 2).bool()
print(a)
print(torch.all(a))
masked_random_actions[i] = sample_action(rand_policy * legal_mask, 0)
print("RANDOM policy selected the following illegal actions:")
print(set(random_actions) - set(legal_moves))
print("RANDOM policy selected the following legal actions:")
print(set(random_actions) & set(legal_moves))
print("MASKED RANDOM policy selected the following illegal actions:")
print(set(masked_random_actions) - set(legal_moves))
print("MASKED RANDOM policy selected the following legal actions:")
print(set(masked_random_actions) & set(legal_moves))
q.exec_move('a4')
q.exec_move('h5')
q.exec_move('a1v')
q.exec_move('d4h')
q.exec_move('h3v')
q.exec_move('h8v')
planes0 = encode_state_to_planes(q)
q.current_player = 1
planes1 = encode_state_to_planes(q)
print(planes0)
print(planes1)
# Test that plane 0 is 'current' player and flipped direction from perspective of other player
assert torch.all(planes0[0] == torch.flipud(planes1[2]))
assert torch.all(planes0[2] == torch.flipud(planes1[0]))
# Test that walls are vertically flipped between two players' perspectives
assert torch.all(planes0[4] == torch.flipud(planes1[4]))
assert torch.all(planes0[5] == torch.flipud(planes1[5]))
def main():
parser = argparse.ArgumentParser(
description='Feature (log-spec) Extraction')
parser.add_argument('--data-dir',
required=True,
help='data directory contains wave files')
parser.add_argument('--label-file',
required=True,
help='protocol file that contains utt2label mapping')
parser.add_argument('--feat-dir',
required=True,
help='feature saving directory')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA for feature extraction')
parser.add_argument('--logging-dir',
required=True,
help='log save directory')
parser.add_argument('--segment',
action='store_true',
default=False,
help='whether to segment the logsepc by energy')
parser.add_argument(
'--seg-win',
type=int,
help='the window size to be used for segment: 64, 128..')
parser.add_argument('--seg-method',
help='the method to be used for segment: h, l, hl, lh')
args = parser.parse_args()
os.makedirs(args.logging_dir, exist_ok=True)
os.makedirs(args.feat_dir, exist_ok=True)
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
if args.segment and (args.seg_method is None or args.seg_win is None):
raise ValueError("segment method or win_size is missing")
# Setup logs
basename = DATA_NAME + os.path.basename(args.data_dir)
run_name = "logspec-" + basename + time.strftime("-%Y-%m-%d")
if os.path.exists(run_name + ".log"):
os.remove(run_name + ".log")
logger = setup_logs(args.logging_dir, run_name)
logger.info("===> Start logspec extraction for dataset: " + args.data_dir)
# global timer starts
global_start = timer()
utt2label_path = os.path.join(
os.path.dirname(args.label_file),
os.path.basename(args.label_file) + '.utt2label')
f_utt2label = open(utt2label_path, 'w')
f_label = open(args.label_file, 'r')
for line in f_label:
item = line.strip().split(' ')
if item[1] == 'genuine':
label = 1
elif item[1] == 'spoof':
label = 0
else:
raise ValueError("Invalid label: " + item[1])
f_utt2label.write(item[0][:-4] + ' ' + str(label) + '\n')
audio_path = os.path.join(args.data_dir, item[0])
t_start = timer()
logspec = get_logspec(audio_path, device)
if args.segment:
if args.seg_method == DEFAULT_SEG:
feat = expand_logspec(logspec, M=args.seg_win)
elif args.seg_method == TAIL_SEG:
feat = torch.flipud(
expand_logspec(torch.flipud(logspec), M=args.seg_win))
else:
feat = segment_logspec(logspec, args.seg_win, args.seg_method)
else:
feat = expand_logspec(logspec)
t_end = timer()
logger.info(item[0] + "\tfeature extraction time: %s" %
(t_end - t_start))
f_feat_path = os.path.join(args.feat_dir, item[0][:-4] + '.pt')
torch.save(feat, f_feat_path)
f_label.close()
f_utt2label.close()
global_end = timer()
logger.info("#### Done logspec extraction for dataset: " + args.data_dir +
"####")
logger.info("Total elapsed time: %s" % (global_end - global_start))
def compute(self, s: torch.Tensor) -> torch.Tensor:
if s.shape != self.pre.shape:
raise Exception('Spikes shape is diffrent from pre shape!')
return convolve(s, torch.flipud(torch.fliplr(self.kernel)))
