def forward(self, x):
unnormalized_heatmaps = self.heatmap_conv(x)
# Softmax converts values in (0,1) range, so no ReLu needed to remove negative values.
normalized_heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps) # make it a prob distribution
coords = dsntnn.dsnt(normalized_heatmaps)
return coords, normalized_heatmaps, unnormalized_heatmaps
def test_forward(self):
in_var = torch.Tensor([[[[10, 1], [5, 2]]]])
expected = torch.Tensor([[
[[0.99285460, 0.00012253],
[0.00668980, 0.00033307]],
]])
self.assertEqual(flat_softmax(in_var), expected)
def forward(self, sag_x, cor_x):
#* Output are features at every spatial resolution
sag_out = self.encoder.forward(sag_x)
cor_out = self.encoder.forward(cor_x)
if self.classifier is not None:
sag_class = self.classifier(sag_out[-1])
cor_class = self.classifier(cor_out[-1])
# print(sag_class.shape, cor_class.shape)
mean_class = (sag_class + cor_class) / 2
#* Combine Sagittal + coronal at each resolution
output = [
torch.cat([sag, cor], dim=1) for sag, cor in zip(sag_out, cor_out)
]
#output = [sag*cor for sag, cor in zip(sag_out, cor_out)]
#* Upscale to match input spatial resolution
decoder_output = self.decoder.forward(*output)
#* Get correct number of channels
seg_out = self.segmentation_head.forward(decoder_output)
#* Convert to 1D heatmap
unnorm_heatmap = self.hm_conv(seg_out)
heatmap = dsntnn.flat_softmax(unnorm_heatmap[..., 0])
coords = dsntnn.dsnt(heatmap, normalized_coordinates=True)
return seg_out, heatmap, coords[..., 0], mean_class
def test_flat_softmax_preserves_ranking(data):
inp = torch.from_numpy(data)
res = flat_softmax(inp)
inp_flat = inp.view(inp.size(0) * inp.size(1), -1)
res_flat = res.view(res.size(0) * res.size(1), -1)
assert_allclose(np.argsort(res_flat, kind='mergesort'),
np.argsort(inp_flat, kind='mergesort'))
def forward(self, *inputs):
t = inputs[0]
t = self.in_cnn(t)
self.xy_heatmaps = [flat_softmax(self.xy_hm_cnn(t))]
self.zy_heatmaps = [flat_softmax(self.zy_hm_cnn(t))]
self.xz_heatmaps = [flat_softmax(self.xz_hm_cnn(t))]
xy = dsnt(self.xy_heatmaps[-1])
zy = dsnt(self.zy_heatmaps[-1])
xz = dsnt(self.xz_heatmaps[-1])
x = xy.narrow(-1, 0, 1)
y = xy.narrow(-1, 1, 1)
z = 0.5 * (zy.narrow(-1, 0, 1) + xz.narrow(-1, 1, 1))
return torch.cat([x, y, z], -1)
def test_forward(self):
in_var = Variable(torch.Tensor([[[[10, 1], [5, 2]]]]),
requires_grad=False)
expected = torch.Tensor([[
[[0.99285460, 0.00012253], [0.00668980, 0.00033307]],
]])
actual = flat_softmax(in_var)
self.assertEqual(actual.data, expected)
def test_flat_softmax_gives_valid_distribution(data):
inp = torch.from_numpy(data)
res = flat_softmax(inp)
# 1. Check that all probabilities are greater than zero.
assert np.all(res >= 0)
# 2. Check that probabilities sum to one.
res_flat = res.view(res.size(0) * res.size(1), -1)
res_sum = res_flat.sum(-1)
assert_allclose(res_sum, np.ones_like(res_sum))
def forward(self, x, b_prev, h_prev, c_prev, centers):
f = self.encode(x)
f = torch.cat([f, b_prev, centers], dim=1)
h, c = self.lstm(f, h_prev, c_prev)
b = self.generate(h)
b = dsntnn.flat_softmax(b)
coords = dsntnn.dsnt(b)
return b, h, c, coords
def forward(self, images):
# 1. Run the images through our Resnet
resnet_out = self.resnet(images)
# 2. Use a 1x1 conv to get one unnormalized heatmap per location
unnormalized_heatmaps = self.hm_conv(resnet_out)
# 3. Normalize the heatmaps
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
# 4. Calculate the coordinates
coords = dsntnn.dsnt(heatmaps)
return coords, heatmaps
def forward(self, images):
# run images trough FCN
fcn_out = self.fcn(images)
# use a 1x1 conv to get one unnormalized heatmap per location
unnormalized_heatmaps = self.hm_conv(fcn_out)
# normalize the heatmaps
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
# calculate the coordinates
coords = dsntnn.dsnt(heatmaps)
return coords, heatmaps
def forward(self, images):
# Run a frame through our network
out = self.resnet(images)
# Use a 1x1 conv to get one unnormalized heatmap
# per location
unnormalized_heatmaps = self.hm_conv(out)
# Normalize the heatmaps
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
# Perform coordinate regression
coords = dsntnn.dsnt(heatmaps)
return coords, heatmaps
def forward(self, *inputs):
features = self.in_cnn(inputs[0])
# These lists will store the outputs from each stage
xy_heatmaps = []
zy_heatmaps = []
xz_heatmaps = []
inp = features
for t in range(self.n_stages):
if t > 0:
combined_hm_features = self.hm_combiners[t - 1](
xy_heatmaps[t - 1],
zy_heatmaps[t - 1],
xz_heatmaps[t - 1],
)
inp = inp + combined_hm_features
xy_heatmaps.append(flat_softmax(self.xy_hm_cnns[t](inp)))
zy_heatmaps.append(flat_softmax(self.zy_hm_cnns[t](inp)))
xz_heatmaps.append(flat_softmax(self.xz_hm_cnns[t](inp)))
return xy_heatmaps, zy_heatmaps, xz_heatmaps
def forward(self, x):
x = self.features(x)
self.feature_output = x
#x = x.mean(3).mean(2)
x = self.conv_compress(x)
x = self.duc1(x)
x = self.duc2(x)
x = self.duc3(x)
#x = self.classifier(x)
#print(feature.size())
x = self.hm_conv(x)
x = dsntnn.flat_softmax(x)
#print(x.size())
return self.feature_output, x
def forward(self, h):
# 1. Use a 1x1 conv to get one unnormalized heatmap per location
unnormalized_heatmaps = self.hm_conv(h)
# 2. Transpose the heatmap volume to keep the temporal dimension in the volume
unnormalized_heatmaps.transpose_(2, 1).transpose_(1, 0)
# 3. Normalize the heatmaps
heatmaps = [dsntnn.flat_softmax(uhm) for uhm in unnormalized_heatmaps]
# heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
# 4. Calculate the coordinates
# coords = dsntnn.dsnt(heatmaps)
coords = [dsntnn.dsnt(hm) for hm in heatmaps]
heatmaps = torch.stack(heatmaps, 1)
coords = torch.stack(coords, 1)
return coords, heatmaps
def forward(self, images):
images = images.cuda()
# 1. Run the images through our FCN
fcn_out = self.fcn(images)
# 2. Use a 1x1 conv to get one unnormalized heatmap per location
unnormalized_heatmaps = self.hm_conv(fcn_out)
# 3. Normalize the heatmaps
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
# 4. Calculate the coordinates
coords = dsntnn.dsnt(heatmaps)
return coords, heatmaps
#
# import traf_data
# import os
# import cv2
# import numpy as np
# import torch
# from tensorboardX import SummaryWriter
#
# image_size = [800, 400]
#
# train_path = "/home/asprohy/data/traffic"
# train_data,_,_ = traf_data.get_data2(train_path)
#
# img = cv2.imread(os.path.join(train_path, train_data[0]['filepath']))
# print(os.path.join(train_path, train_data[0]['filepath']))
# h, w = img.shape[:2]
# print('h[],w[]', h, w)
# print('filepath',train_data[0]['filepath'])
# # print(img)
# img = cv2.resize(img, (image_size[0],image_size[1]))
# img = np.array(img)
# tmpc = train_data[0]['bboxes'][0]
# print('lab', tmpc)
# label_all = [int((tmpc['x1'] + tmpc['x2'])/2 / w * image_size[0]),int((tmpc['y1'] + tmpc['y2'])/2 / h * image_size[1])]
# print('lab', label_all)
# raccoon_face_tensor = torch.from_numpy(img).permute(2, 0, 1).float()
# input_tensor = raccoon_face_tensor.div(255).unsqueeze(0)
# input_var = input_tensor
#
# model = CoordRegressionNetwork(n_locations=1)
#
# with SummaryWriter(comment='Net1')as w:
#
# w.add_graph(model, (input_var,))
def forward(self, sag_x, cor_x):
sag_out = self.encoder(sag_x)
cor_out = self.encoder(cor_x)
print(len(sag_out))
print(sag_out[0].shape)
seg_out = self.head(self.decoder(torch.mul(sag_out['out'], cor_out['out'])))
print(seg_out.shape)
# 2. Use a 1x1 conv to get one unnormalized heatmap per location
unnorm_heatmap = self.hm_conv(seg_out) # 1-Dim Heatmap (BxCxHx1)
print(unnorm_heatmap.shape)
# 3. Softmax across HxW
heatmap = dsntnn.flat_softmax(unnorm_heatmap)
# Coordinate from heatmap (Return )
coords= dsntnn.dsnt(heatmap, normalized_coordinates=False)
#Global Average pooling
pred = F.avg_pool2d(seg_out, kernel_size=seg_out.size()[2:])
return unnorm_heatmap, seg_out, coords[..., 1], pred
def forward(self, h):
probabilities = torch.zeros(
0, device=h.device
) # torch.nn.ReLU(self.probability(torch.squeeze(h)))
# 1. Use a 1x1 conv to get one unnormalized heatmap per location
if self.temporal_interpolate > 1:
h = F.interpolate(h,
scale_factor=(self.temporal_interpolate, 1, 1),
mode='trilinear')
unnormalized_heatmaps = self.hm_conv(h)
# 2. Transpose the heatmap volume to keep the temporal dimension in the volume
unnormalized_heatmaps.transpose_(2, 1).transpose_(1, 0)
# 3. Normalize the heatmaps
heatmaps = [dsntnn.flat_softmax(uhm) for uhm in unnormalized_heatmaps]
# 4. Calculate the coordinates
coords = [dsntnn.dsnt(hm) for hm in heatmaps]
heatmaps = torch.stack(heatmaps, 1)
coords = torch.stack(coords, 1)
return coords, heatmaps, probabilities
def forward(self, images, sample=False):
if sample:
xs = self.fcn(images, sample=sample)
return xs
else:
fcn_out, dec_out, xhist = self.fcn(images)
unnormalized_heatmaps = self.hm_conv(fcn_out)
clean_output = self.hm_conv2(dec_out)
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
coords = dsntnn.dsnt(heatmaps)
# input_edges=self.relu(nn.functional.conv2d(images,self.f))
# input_edges=torch.add(torch.add(input_edges[:,0:1,:,:],input_edges[:,1:2,:,:]),torch.add(input_edges[:,2:3,:,:],input_edges[:,3:4,:,:]))
# clean_edges=self.relu(nn.functional.conv2d(clean_output,self.f))
# clean_edges=torch.add(torch.add(clean_edges[:,0:1,:,:],clean_edges[:,1:2,:,:]),torch.add(clean_edges[:,2:3,:,:],clean_edges[:,3:4,:,:]))
# mult=torch.mul(clean_edges,input_edges)
# out_noise=(torch.cat([self.noise(mult),nn.functional.conv2d(mult,self.f2)],dim=1))
# out_ridge=(torch.cat([self.ridge(mult),nn.functional.conv2d(mult,self.f1)],dim=1))
# ridge=self.maxpool1(out_ridge)
# noise=self.maxpool2(out_noise)
return coords, heatmaps, clean_output, xhist
def forward(self, x):
b = self.process(x)
b = dsntnn.flat_softmax(b)
c = dsntnn.dsnt(b)
return b, c
def forward(self, x):
x = flat_softmax(x)
x = dsnt(x, normalized_coordinates=True)
return x
def test_flat_softmax_example():
in_var = torch.Tensor([[[[10, 1], [5, 2]]]])
expected = torch.Tensor([[
[[0.99285460, 0.00012253], [0.00668980, 0.00033307]],
]])
assert_allclose(flat_softmax(in_var), expected)
def forward(self, images):
fcn_out, xhist = self.fcn(images)
unnormalized_heatmaps = self.hm_conv(fcn_out)
heatmaps = dsntnn.flat_softmax(unnormalized_heatmaps)
coords = dsntnn.dsnt(heatmaps)
return coords, heatmaps, xhist
