def cw_local_softmax_filter_sl1(seg_logit,Teacher_seg_logit, n, alpha):
B, C, H, W = seg_logit.shape
# H_new = H // n * n
# W_new = W // n * n
T_logit = Teacher_seg_logit.detach()
S_logit = seg_logit * 1
kernel = torch.ones([1,n,n])
with torch.no_grad():
Teacher_seg_logit_exp = T_logit.exp()
T_filter = kornia.filter2D(Teacher_seg_logit_exp, kernel)
T_filter = Teacher_seg_logit_exp / T_filter *n*n
seg_logit_exp = S_logit.exp()
S_filter = kornia.filter2D(seg_logit_exp, kernel)
S_filter = seg_logit_exp / S_filter *n*n
# smooth_l1_loss
loss_kd = F.smooth_l1_loss(S_filter, T_filter)
# alpha = 66666 / (4*4) * (n*n)
# alpha = 33333 / (4*4) * (n*n)
# alpha = 22222 / (4*4) * (n*n)
# alpha = 42666 # 66666/25*16
return loss_kd * alpha
def gaussian_blur2d(input: torch.Tensor,
kernel_size: Tuple[int, int],
sigma: Tuple[float, float],
border_type: str = 'reflect') -> torch.Tensor:
r"""Creates an operator that blurs a tensor using a Gaussian filter.
The operator smooths the given tensor with a gaussian kernel by convolving
it to each channel. It supports batched operation.
Arguments:
input (torch.Tensor): the input tensor with shape :math:`(B,C,H,W)`.
kernel_size (Tuple[int, int]): the size of the kernel.
sigma (Tuple[float, float]): the standard deviation of the kernel.
border_type (str): the padding mode to be applied before convolving.
The expected modes are: ``'constant'``, ``'reflect'``,
``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
Returns:
torch.Tensor: the blurred tensor with shape :math:`(B, C, H, W)`.
Examples:
>>> input = torch.rand(2, 4, 5, 5)
>>> output = gaussian_blur2d(input, (3, 3), (1.5, 1.5))
>>> output.shape
torch.Size([2, 4, 5, 5])
"""
kernel: torch.Tensor = torch.unsqueeze(get_gaussian_kernel2d(
kernel_size, sigma),
dim=0)
return kornia.filter2D(input, kernel, border_type)
def test_normalized_mean_filter(self, device, dtype):
kernel = torch.ones(1, 3, 3).to(device)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype).expand(2, 2, -1, -1)
nv: float = 5. / 9 # normalization value
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., nv, nv, nv, 0.],
[0., nv, nv, nv, 0.],
[0., nv, nv, nv, 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype)
actual = kornia.filter2D(input, kernel, normalized=True)
assert_allclose(actual, expected)
def test_normalized_mean_filter(self, device, dtype):
kernel = torch.ones(1, 3, 3).to(device)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype).expand(2, 2, -1, -1)
nv: float = 5. / 9 # normalization value
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., nv, nv, nv, 0.],
[0., nv, nv, nv, 0.],
[0., nv, nv, nv, 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype).expand(2, 2, -1, -1)
actual = kornia.filter2D(input, kernel, normalized=True)
tol_val: float = utils._get_precision_by_name(device, 'xla', 1e-1,
1e-4)
assert_allclose(actual, expected, rtol=tol_val, atol=tol_val)
def laplacian(input: torch.Tensor,
kernel_size: int,
border_type: str = 'reflect',
normalized: bool = True) -> torch.Tensor:
r"""Creates an operator that returns a tensor using a Laplacian filter.
The operator smooths the given tensor with a laplacian kernel by convolving
it to each channel. It supports batched operation.
Arguments:
input (torch.Tensor): the input image tensor with shape :math:`(B, C, H, W)`.
kernel_size (int): the size of the kernel.
border_type (str): the padding mode to be applied before convolving.
The expected modes are: ``'constant'``, ``'reflect'``,
``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
normalized (bool): if True, L1 norm of the kernel is set to 1.
Return:
torch.Tensor: the blurred image with shape :math:`(B, C, H, W)`.
Examples:
>>> input = torch.rand(2, 4, 5, 5)
>>> output = laplacian(input, 3)
>>> output.shape
torch.Size([2, 4, 5, 5])
"""
kernel: torch.Tensor = torch.unsqueeze(get_laplacian_kernel2d(kernel_size),
dim=0)
if normalized:
kernel = normalize_kernel2d(kernel)
return kornia.filter2D(input, kernel, border_type)
def test_noncontiguous(self, device):
batch_size = 3
inp = torch.rand(3, 5, 5).expand(batch_size, -1, -1, -1).to(device)
kernel = torch.ones(1, 2, 2).to(device)
actual = kornia.filter2D(inp, kernel)
expected = actual
assert_allclose(actual, actual)
def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
if not torch.is_tensor(input):
raise TypeError("Input type is not a torch.Tensor. Got {}".format(
type(input)))
if not len(input.shape) == 4:
raise ValueError(
"Invalid input shape, we expect BxCxHxW. Got: {}".format(
input.shape))
# blur image
x_blur: torch.Tensor = kornia.filter2D(input, self.kernel,
self.border_type)
# reject even rows and columns.
out: torch.Tensor = x_blur[..., ::2, ::2]
return out
def test_normalized_mean_filter(self):
kernel = torch.ones(1, 3, 3)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]]).expand(2, 2, -1, -1)
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 5. / 9., 5. / 9., 5. / 9., 0.],
[0., 5. / 9., 5. / 9., 5. / 9., 0.],
[0., 5. / 9., 5. / 9., 5. / 9., 0.],
[0., 0., 0., 0., 0.],
]]])
actual = kornia.filter2D(input, kernel, normalized=True)
assert_allclose(actual, expected)
def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
if not torch.is_tensor(input):
raise TypeError("Input type is not a torch.Tensor. Got {}".format(
type(input)))
if not len(input.shape) == 4:
raise ValueError(
"Invalid input shape, we expect BxCxHxW. Got: {}".format(
input.shape))
# upsample tensor
b, c, height, width = input.shape
x_up: torch.Tensor = F.interpolate(input,
size=(height * 2, width * 2),
mode='bilinear',
align_corners=True)
# blurs upsampled tensor
x_blur: torch.Tensor = kornia.filter2D(x_up, self.kernel,
self.border_type)
return x_blur
def test_mean_filter_2batch_2ch(self):
kernel = torch.ones(1, 3, 3)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]]).expand(2, 2, -1, -1)
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 0., 0., 0., 0.],
]]])
actual = kornia.filter2D(input, kernel)
assert_allclose(actual, expected)
def test_even_sized_filter(self, device):
kernel = torch.ones(1, 2, 2).to(device)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]]).to(device)
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 5., 5., 0., 0.],
[0., 5., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]]).to(device)
actual = kornia.filter2D(input, kernel)
assert_allclose(actual, expected)
def motion_blur(input: torch.Tensor,
kernel_size: int,
angle: Union[float, torch.Tensor],
direction: Union[float, torch.Tensor],
border_type: str = 'constant',
mode: str = 'nearest') -> torch.Tensor:
r"""Perform motion blur on 2D images (4D tensor).
Args:
input (torch.Tensor): the input tensor with shape :math:`(B, C, H, W)`.
kernel_size (int): motion kernel width and height. It should be odd and positive.
angle (Union[torch.Tensor, float]): angle of the motion blur in degrees (anti-clockwise rotation).
If tensor, it must be :math:`(B,)`.
direction (tensor or float): forward/backward direction of the motion blur.
Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
uniformly (but still angled) motion blur.
If tensor, it must be :math:`(B,)`.
border_type (str): the padding mode to be applied before convolving. The expected modes are:
``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. Default: ``'constant'``.
mode (str): interpolation mode for rotating the kernel. ``'bilinear'`` or ``'nearest'``.
Default: ``'nearest'``
Return:
torch.Tensor: the blurred image with shape :math:`(B, C, H, W)`.
Example:
>>> input = torch.randn(1, 3, 80, 90).repeat(2, 1, 1, 1)
>>> # perform exact motion blur across the batch
>>> out_1 = motion_blur(input, 5, 90., 1)
>>> torch.allclose(out_1[0], out_1[1])
True
>>> # perform element-wise motion blur across the batch
>>> out_1 = motion_blur(input, 5, torch.tensor([90., 180,]), torch.tensor([1., -1.]))
>>> torch.allclose(out_1[0], out_1[1])
False
"""
assert border_type in ["constant", "reflect", "replicate", "circular"]
kernel: torch.Tensor = get_motion_kernel2d(kernel_size, angle, direction,
mode)
return kornia.filter2D(input, kernel, border_type)
def test_mean_filter(self, device, dtype):
kernel = torch.ones(1, 3, 3, device=device, dtype=dtype)
input = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 5., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype)
expected = torch.tensor([[[
[0., 0., 0., 0., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 0., 0., 0., 0.],
]]],
device=device,
dtype=dtype)
actual = kornia.filter2D(input, kernel)
assert_allclose(actual, expected)
def test_smoke(self, device, dtype):
kernel = torch.rand(1, 3, 3, device=device, dtype=dtype)
input = torch.ones(1, 1, 7, 8, device=device, dtype=dtype)
assert kornia.filter2D(input, kernel).shape == input.shape
def forward(self, x: torch.Tensor): # type: ignore
return kornia.filter2D(x, self.kernel, self.border_type)
def test_smoke(self):
kernel = torch.rand(1, 3, 3)
input = torch.ones(1, 1, 7, 8)
assert kornia.filter2D(input, kernel).shape == input.shape
def forward(self, x):
return kornia.filter2D(x, self.f, normalized=True)
def forward(self, x):
f = self.f
f = f[None, None, :] * f[None, :, None]
return filter2D(x, f, normalized=True)
def test_batch(self, batch_size, device, dtype):
B: int = batch_size
kernel = torch.rand(1, 3, 3, device=device, dtype=dtype)
input = torch.ones(B, 3, 7, 8, device=device, dtype=dtype)
assert kornia.filter2D(input, kernel).shape == input.shape
