I have a matrix A and its a 2 x n tensor and it represents a collection of n points with coordinates (x, y).  I have a separate tensor B that is also 2 x m, (n>m) and all points in B is in A, I want a tensor C that is the collection of points in A that is not in B (set difference).
in regular python, if we have a list of points and if we want to find the difference we do the following:
C = set(A) - set(B)
I want to know if there’s a method of doing this on the GPU, I know how to do a one dimensional tensor with a bool tensor and a mask ( non-intersection of 1d tensor ).  but if I put in a two dimensional tensor, then the output gets flatten and loses the dimensionality of the points
My code so far:
def set_differ(a, b):                                                                                                                                                                                                    
     A = torch.tensor(a, device = 'cuda')                                                                                                                                                                            
     B = torch.tensor(b, device = 'cuda')                                                                                                                                                                                                                                                                                                                           
     size = A.size()                                                                                                                                                                                         
     # bool_vec is a 1d mask that tells if the point stored at that index is included in the difference or not
     bool_vec = torch.ones(1, size[0], dtype = torch.bool, device="cuda")                                                                                                                                         
     for point in B: 
            # update bool_vec if the point (x, y) is in A, change the value at that index to False                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
            bool_vec = bool_vec & (A != point).any(1)                                                                                                                                                                             
     # stack the bool_vec so that it is the same size as A
     bool_vec = torch.cat([bool_vec]*size[1], 0)                                                                                                                                                                 
     set_difference = A[torch.t(bool_vec)] 

inputs and outputs:
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')

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