I think that the easiest solution is to use list comprehensions to compute a mask. The following piece of code seems to do what you want:
import torch

A = torch.tensor([1,1,10,6,4,5,9,8,0,6,7,1,17,16]).view(-1,2).cuda()
B = torch.tensor([1,1,7,1]).view(-1,2).cuda()

print('A:\n', A)
print('B:\n', B)

def set_differ(A, B):
  r"""Returns the elements of A without the elements of B"""
  mask = torch.as_tensor([elem not in B for elem in A])
  return A[mask]

print('out:')
set_differ(A, B)

returns
A:
 tensor([[ 1,  1],
        [10,  6],
        [ 4,  5],
        [ 9,  8],
        [ 0,  6],
        [ 7,  1],
        [17, 16]], device='cuda:0')
B:
 tensor([[1, 1],
        [7, 1]], device='cuda:0')
out:

tensor([[10,  6],
        [ 4,  5],
        [ 9,  8],
        [ 0,  6],
        [17, 16]], device='cuda:0')

EDIT:
Another solution would be to use the fact that a point x from A also belongs to B iff its closest point in B is at distance 0. Then you can compute the pointwise distance between points from A and B to filter them.
def set_differ2(A, B):
  cdist = torch.cdist(A.float(), B.float())
  min_dist = torch.min(cdist, dim=1).values
  return A[min_dist>0]

In an algorithmic point of view, that second solution should be slower, however thanks to some CUDA magic it seems to be faster with your example:
%timeit set_differ(A, B)
%timeit set_differ2(A, B)

returns
1000 loops, best of 3: 752 µs per loop
1000 loops, best of 3: 259 µs per loop

I don’t know which solution is faster for larger point clouds, so I suggest you to try both methods with bigger values for m and n.