Hello, I want to implement smooth Loss function for image by following the ImageDenoisingGAN paper (in this paper, they calculate the smooth loss by slide a copy of the generated image one unit to the left and one unit down and then take an Euclidean distance between the shifted images). so far their tensorflow coding like this :
batch_count = tf.shape(image)
image_height = tf.shape(image)
image_width = tf.shape(image)
horizontal_normal = tf.slice(image, [0, 0, 0,0], [batch_count, image_height, image_width-1,3])
horizontal_one_right = tf.slice(image, [0, 0, 1,0], [batch_count, image_height, image_width-1,3])
vertical_normal = tf.slice(image, [0, 0, 0,0], [batch_count, image_height-1, image_width,3])
vertical_one_right = tf.slice(image, [0, 1, 0,0], [batch_count, image_height-1, image_width,3])
smooth_loss = tf.nn.l2_loss(horizontal_normal-horizontal_one_right)+tf.nn.l2_loss(vertical_normal-vertical_one_right)
I want to convert this Tensorflow code to Pytorch but still can’t figure it out. Could someone help to convert it to Pytorch or any suggestion?
You can just use indices to get your slice:
b, c, h, w = image.size()
horizontal_normal = image[:, :, :, w-1]
horizontal_one_right = image[:, :, :, 1:w-1]
I’m not sure, if I just don’t understand the
tf.slice operation, but it looks like both horizontal* images have a different width. Shouldn’t
horizontal_one_right be sliced as
[:, :, :, 1:w]?
If not, you won’t be able to calculate the difference between both sliced images due to different sizes.
Assuming it’s a typo, you could calculate the loss as:
loss = torch.pow(horizontal_normal-horizontal_one_right, 2).sum() / 2. + torch.pow(ver...
Hi, Thanks for your reply. Because the
tf.slice operation is " This operation extracts a slice of size
size from a tensor
input starting at the location specified by
begin . The slice
size is represented as a tensor shape, where
size[i] is the number of elements of the 'i’th dimension of
input that you want to slice. The starting location (
begin ) for the slice is represented as an offset in each dimension of
input". So I dont think their coding wrong.
But for Pytorch, you are right. we need to give the same width. So i changed it following your guide like this:
def get_loss(self, image):
b, c, h, w = image.size()
horizontal_normal = image[:, :, :, 0:w-1]
horizontal_one_right = image[:, :, :, 1:w]
vertical_normal = image[:, :, 0:h-1, :]
vertical_one_right = image[:, :, 1:h, :]
loss = torch.pow(horizontal_normal-horizontal_one_right, 2).sum() / \
2. + torch.pow(vertical_normal - vertical_one_right, 2).sum()/2.0
I hope it get same operation with tf.slice in this case ^^
Use python directly
tf.slice(x, begin=[a1, a2, a3, a4], size=[b1, b2, b3, b4]) -> x[a1:a1+b1, a2:a2+b2, a3:a3+b3, a4:a4+b4]
What if you don’t know begin and size explicitly? Let’s say begin is an list a and size is a list b. And I need something for tensor t of sort, t[ a:b,…a[len(a)]:b[len(b)]. But I can’t iterate in index and can’t have colon in any data structure.