Python 在numpy.array中查找唯一行

我需要在numpy.array中找到唯一的行

例如：

>>> a # I have
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])
>>> new_a # I want to get to
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 0]])

---

我知道我可以在阵列上创建一个集合和循环，但我正在寻找一个高效的纯numpy解决方案。我相信有一种方法可以将数据类型设置为void，然后我可以只使用numpy.unique，但我不知道如何使其工作。

np.unique在给定元组列表的情况下工作：

>>> np.unique([(1, 1), (2, 2), (3, 3), (4, 4), (2, 2)])
Out[9]: 
array([[1, 1],
       [2, 2],
       [3, 3],
       [4, 4]])

对于列表列表，它会引发一个TypeError:Unshable type:“list”

np.unique，当我在np.random.random100.Reforme10,10上运行它时，它会返回所有唯一的单个元素，但您需要唯一的行，因此首先需要将它们放入元组：

array = #your numpy array of lists
new_array = [tuple(row) for row in array]
uniques = np.unique(new_array)

---

这是我看到您更改类型以执行所需操作的唯一方法，我不确定更改为元组的列表迭代是否适合您不循环执行

如果您希望避免转换为一系列元组或其他类似数据结构的内存开销，您可以利用numpy的结构化数组

诀窍是将原始数组视为结构化数组，其中每个项对应于原始数组的一行。这不会复制，而且效率很高

举个简单的例子：

import numpy as np

data = np.array([[1, 1, 1, 0, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [1, 1, 1, 0, 0, 0],
                 [1, 1, 1, 1, 1, 0]])

ncols = data.shape[1]
dtype = data.dtype.descr * ncols
struct = data.view(dtype)

uniq = np.unique(struct)
uniq = uniq.view(data.dtype).reshape(-1, ncols)
print uniq

要了解发生了什么，请查看中间结果

一旦我们将事物视为结构化数组，数组中的每个元素就是原始数组中的一行。基本上，它是一个类似于元组列表的数据结构

In [71]: struct
Out[71]:
array([[(1, 1, 1, 0, 0, 0)],
       [(0, 1, 1, 1, 0, 0)],
       [(0, 1, 1, 1, 0, 0)],
       [(1, 1, 1, 0, 0, 0)],
       [(1, 1, 1, 1, 1, 0)]],
      dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])

In [72]: struct[0]
Out[72]:
array([(1, 1, 1, 0, 0, 0)],
      dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])

然后我们需要将其视为普通数组uu将上一次计算的结果存储在ipython中，这就是为什么您会看到uu.view…：

然后重新整形为二维数组-1是一个占位符，告诉numpy计算正确的行数，给出列数：

In [75]: _.reshape(-1, ncols)
Out[75]:
array([[0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

显然，如果你想更简洁，你可以这样写：

import numpy as np

def unique_rows(data):
    uniq = np.unique(data.view(data.dtype.descr * data.shape[1]))
    return uniq.view(data.dtype).reshape(-1, data.shape[1])

data = np.array([[1, 1, 1, 0, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [1, 1, 1, 0, 0, 0],
                 [1, 1, 1, 1, 1, 0]])
print unique_rows(data)

其结果是：

[[0 1 1 1 0 0]
 [1 1 1 0 0 0]
 [1 1 1 1 1 0]]

[[0 1 1 1 0 0]
 [1 1 1 0 0 0]
 [1 1 1 1 1 0]]

---

np.unique的工作原理是对扁平数组进行排序，然后查看每个项是否与前一项相等。这可以在不展平的情况下手动完成：

ind = np.lexsort(a.T)
a[ind[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]]

这个方法不使用元组，应该比这里给出的其他方法更快、更简单

注意：此版本的早期版本在A[]之后没有ind，这意味着使用了错误的索引。此外，Joe Kington很好地指出，这确实会生成多种中间副本。以下方法通过生成排序副本，然后使用其视图来减少索引的数量：

b = a[np.lexsort(a.T)]
b[np.concatenate(([True], np.any(b[1:] != b[:-1],axis=1)))]

这样速度更快，占用的内存更少

此外，如果希望在数据数组中查找唯一的行，而不管数组中有多少个维度，则以下操作将起作用：

b = a[lexsort(a.reshape((a.shape[0],-1)).T)];
b[np.concatenate(([True], np.any(b[1:]!=b[:-1],axis=tuple(range(1,a.ndim)))))]

另一个有趣的问题是，如果您想沿着任意维数组的任意轴进行排序/唯一，这将更加困难

编辑：

为了演示速度差异，我在ipython中对答案中描述的三种不同方法进行了一些测试。使用精确的a，没有太大的差异，尽管此版本速度稍快：

In [87]: %timeit unique(a.view(dtype)).view('<i8')
10000 loops, best of 3: 48.4 us per loop

In [88]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True], np.any(a[ind[1:]]!= a[ind[:-1]], axis=1)))]
10000 loops, best of 3: 37.6 us per loop

In [89]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10000 loops, best of 3: 41.6 us per loop

但是，使用更大的a，此版本的速度要快得多：

In [96]: a = np.random.randint(0,2,size=(10000,6))

In [97]: %timeit unique(a.view(dtype)).view('<i8')
10 loops, best of 3: 24.4 ms per loop

In [98]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10 loops, best of 3: 28.2 ms per loop

In [99]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!= a[ind[:-1]],axis=1)))]
100 loops, best of 3: 3.25 ms per loop

---

使用结构化数组的另一个选项是使用void类型的视图，该视图将整行连接到单个项中：

a = np.array([[1, 1, 1, 0, 0, 0],
              [0, 1, 1, 1, 0, 0],
              [0, 1, 1, 1, 0, 0],
              [1, 1, 1, 0, 0, 0],
              [1, 1, 1, 1, 1, 0]])

b = np.ascontiguousarray(a).view(np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
_, idx = np.unique(b, return_index=True)

unique_a = a[idx]

>>> unique_a
array([[0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

编辑 根据@seberg的建议添加了np.ASCONTIGOUUSARRAY。如果该数组尚未连续，则会降低该方法的速度

编辑 通过执行以下操作，可以稍微加快上述速度，但可能会以清晰度为代价：

unique_a = np.unique(b).view(a.dtype).reshape(-1, a.shape[1])

此外，至少在我的系统中，性能比BLASTRAY方法更合适，甚至更好：

a = np.random.randint(2, size=(10000, 6))

%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
100 loops, best of 3: 3.17 ms per loop

%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
100 loops, best of 3: 5.93 ms per loop

a = np.random.randint(2, size=(10000, 100))

%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
10 loops, best of 3: 29.9 ms per loop

%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
10 loops, best of 3: 116 ms per loop

---

另一种可能的解决办法

np.vstack({tuple(row) for row in a})

---

根据本页中的答案，我编写了一个函数，该函数复制了MATLAB的uniqueinput“rows”函数的功能，具有接受唯一性检查公差的附加功能。它还返回索引，例如c=data[ia，：]和data=c[ic，：]。如果发现任何差异或错误，请报告

def unique_rows(data, prec=5):
    import numpy as np
    d_r = np.fix(data * 10 ** prec) / 10 ** prec + 0.0
    b = np.ascontiguousarray(d_r).view(np.dtype((np.void, d_r.dtype.itemsize * d_r.shape[1])))
    _, ia = np.unique(b, return_index=True)
    _, ic = np.unique(b, return_inverse=True)
    return np.unique(b).view(d_r.dtype).reshape(-1, d_r.shape[1]), ia, ic

---

这里是@Greg pythonic答案的另一个变体

np.vstack(set(map(tuple, a)))

为什么不使用熊猫的drop_副本：

>>> timeit pd.DataFrame(image.reshape(-1,3)).drop_duplicates().values
1 loops, best of 3: 3.08 s per loop

>>> timeit np.vstack({tuple(r) for r in image.reshape(-1,3)})
1 loops, best of 3: 51 s per loop

软件包免责声明：我是它的作者，将Jaime发布的解决方案包装在一个漂亮且经过测试的界面中，并添加了许多其他功能：

import numpy_indexed as npi
new_a = npi.unique(a)  # unique elements over axis=0 (rows) by default

---

对于一般用途（如三维或更高的多维嵌套数组），请尝试以下操作：

import numpy as np

def unique_nested_arrays(ar):
    origin_shape = ar.shape
    origin_dtype = ar.dtype
    ar = ar.reshape(origin_shape[0], np.prod(origin_shape[1:]))
    ar = np.ascontiguousarray(ar)
    unique_ar = np.unique(ar.view([('', origin_dtype)]*np.prod(origin_shape[1:])))
    return unique_ar.view(origin_dtype).reshape((unique_ar.shape[0], ) + origin_shape[1:])

满足您的2D数据集的：

a = np.array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])
unique_nested_arrays(a)

给出：

array([[0, 1, 1, 1, 0, 0],
   [1, 1, 1, 0, 0, 0],
   [1, 1, 1, 1, 1, 0]])

array([[[0, 1, 1], [1, 1, 1]],
   [[1, 1, 1], [0, 1, 1]],
   [[1, 1, 1], [1, 1, 1]]])

还有3D阵列，如：

b = np.array([[[1, 1, 1], [0, 1, 1]],
              [[0, 1, 1], [1, 1, 1]],
              [[1, 1, 1], [0, 1, 1]],
              [[1, 1, 1], [1, 1, 1]]])
unique_nested_arrays(b)

给出：

array([[0, 1, 1, 1, 0, 0],
   [1, 1, 1, 0, 0, 0],
   [1, 1, 1, 1, 1, 0]])

array([[[0, 1, 1], [1, 1, 1]],
   [[1, 1, 1], [0, 1, 1]],
   [[1, 1, 1], [1, 1, 1]]])

---

我不喜欢这些答案中的任何一个，因为它们都不能处理线性代数或向量空间意义上的浮点数组，其中两行“相等”意味着“在某些中，最简单的解决方案是通过将行设置为字符串将行设置为单个项目。然后，可以使用numpy将每行作为一个整体进行比较，以确定其唯一性。此解决方案是通用的，您只需重新设置数组的形状并将其转换为其他组合。以下是针对所提供问题的解决方案

import numpy as np

original = np.array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

uniques, index = np.unique([str(i) for i in original], return_index=True)
cleaned = original[index]
print(cleaned)    

将提供：

 array([[0, 1, 1, 1, 0, 0],
        [1, 1, 1, 0, 0, 0],
        [1, 1, 1, 1, 1, 0]])

---

通过邮件发送我的诺贝尔奖

这些答案对我都不起作用。我假设 s我的唯一行包含字符串而不是数字。但是，另一个线程的回答确实有效：

资料来源：

您可以使用.count和.index列表的方法

coor = np.array([[10, 10], [12, 9], [10, 5], [12, 9]])
coor_tuple = [tuple(x) for x in coor]
unique_coor = sorted(set(coor_tuple), key=lambda x: coor_tuple.index(x))
unique_count = [coor_tuple.count(x) for x in unique_coor]
unique_index = [coor_tuple.index(x) for x in unique_coor]

---

除了@Jaime极好的答案之外，另一种折叠行的方法是使用a.strips[0]，假设a是C-连续的，它等于a.dtype.itemsize*a.shape[0]。此外，voidn是dtypevoid，n的快捷方式。我们最终得出了这个最短的版本：

a[unique(a.view(void(a.strides[0])),1)[1]]

为了

---

从NumPy 1.13开始，您可以简单地选择轴以在任何N-dim数组中选择唯一值。要获得唯一行，可以执行以下操作：

---

unique_rows=np.uniqueoriginal_array，axis=0

我们实际上可以将m x n数字numpy数组转换为m x 1 numpy字符串数组，请尝试使用以下函数，它提供计数、逆\u idx等，就像numpy.unique一样：

import numpy as np

def uniqueRow(a):
    #This function turn m x n numpy array into m x 1 numpy array storing 
    #string, and so the np.unique can be used

    #Input: an m x n numpy array (a)
    #Output unique m' x n numpy array (unique), inverse_indx, and counts 

    s = np.chararray((a.shape[0],1))
    s[:] = '-'

    b = (a).astype(np.str)

    s2 = np.expand_dims(b[:,0],axis=1) + s + np.expand_dims(b[:,1],axis=1)

    n = a.shape[1] - 2    

    for i in range(0,n):
         s2 = s2 + s + np.expand_dims(b[:,i+2],axis=1)

    s3, idx, inv_, c = np.unique(s2,return_index = True,  return_inverse = True, return_counts = True)

    return a[idx], inv_, c

例如：

A = np.array([[ 3.17   9.502  3.291],
  [ 9.984  2.773  6.852],
  [ 1.172  8.885  4.258],
  [ 9.73   7.518  3.227],
  [ 8.113  9.563  9.117],
  [ 9.984  2.773  6.852],
  [ 9.73   7.518  3.227]])

B, inv_, c = uniqueRow(A)

Results:

B:
[[ 1.172  8.885  4.258]
[ 3.17   9.502  3.291]
[ 8.113  9.563  9.117]
[ 9.73   7.518  3.227]
[ 9.984  2.773  6.852]]

inv_:
[3 4 1 0 2 4 0]

c:
[2 1 1 1 2]

---

我比较了建议的速度替代方案，发现令人惊讶的是，void view unique解决方案甚至比numpy的原生unique with axis参数快一点。如果你在追求速度，你会想要

独特的 a、 viewnumpy.dtypenumpy.void，a.dtype.itemsize*a.shape[1] .viewa.dtype.REFORMATE-1，a.shape[1] 这也是一个很好的例子

复制绘图的代码：

进口numpy 导入性能图 def唯一_无效_视图a： 回来 numpy.uniquea.viewnumpy.dtypenumpy.void，a.dtype.itemsize*a.shape[1] .viewa.dtype .重塑-1，a.形状[1] def lexsorta： ind=numpy.lexsorta.T 归还[ ind[numpy.concatenate[True]，numpy.anya[ind[1:]！=a[ind[：-1]]，axis=1] ] def vstacka： return numpy.vstack[a行的tuplerow] def unique_axisa： 返回numpy.uniquea，轴=0 perfplot.show setup=lambda n:numpy.random.randint2，size=n，20， 内核=[unique\u void\u视图、lexsort、vstack、unique\u轴]， n_范围=[2**k代表范围15中的k]， xlabel=lena， 相等性检查=无，

---

让我们以列表的形式获取整个numpy矩阵，然后从该列表中删除重复项，最后将唯一列表返回到numpy矩阵中：

matrix_as_list=data.tolist() 
matrix_as_list:
[[1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]]

uniq_list=list()
uniq_list.append(matrix_as_list[0])

[uniq_list.append(item) for item in matrix_as_list if item not in uniq_list]

unique_matrix=np.array(uniq_list)
unique_matrix:
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 0]])

---

pandas有一个dataframe.drop\u duplicates方法。看到了，谢谢你，但我不能使用pandas.maybile复制的@Andy Hayden，尽管标题是一样的，但它不是这个问题的复制品。但是codeape的链接是重复的。这个特性在1.13版本中就已经出现了：它实际上看起来非常慢，几乎和使用元组一样慢。显然，像这样对结构化数组进行排序很慢。@cge-用较大的数组进行排序。是的，对numpy数组排序比对列表排序慢。不过，在大多数使用Ndarray的情况下，速度并不是主要考虑因素。这是内存使用。元组列表将使用比此解决方案多得多的内存。即使您有足够的内存，并且数组相当大，将其转换为元组列表的开销也比速度优势大。@cge-Ah，我没有注意到您使用的是lexsort。我以为你指的是使用元组列表。是的，在这种情况下，lexsort可能是更好的选择。我已经忘了它，然后跳转到一个过于复杂的解决方案。非常好！不过，另一方面，它确实制作了一些中间副本。e、 g.a[ind[1:]是一个副本，等等。另一方面，在内存耗尽之前，你的解决方案通常比我的快2-3倍。这一点很好。事实证明，我尝试仅使用索引获取中间副本，这使得我的方法使用了更多内存，并且最终比仅创建数组的已排序副本慢，因为a_sorted[1:]不是a_sorted的副本。您的计时中的数据类型是什么？我想你弄错了。在我的系统中，如我的回答中所述调用np.unique比使用两种np.lexsort中的任何一种都要快一些。如果数组的形状为10000、100，则查找uniques的速度大约快5倍。即使您决定重新实现np.unique所做的工作来缩短一些较小的执行时间，将每一行折叠成一个对象也比在列的比较中调用np.any运行得更快，特别是对于更高的列计数。@cge:您可能是指“np.any”而不是标准的“any”，因为它不带关键字参数。@Jaime-我相信dtype只是一个.dtype，即所查看数据的数据类型，正如Joe Kington在回答中所做的那样。如果有很多列，另一个不完美！使用lexsort保持快速的方法是只对少数列进行排序。这是特定于数据的，因为您需要知道哪些列提供了足够的差异，以便进行完美排序。例如，a.shape=60000500-在前3列上排序：ind=np.lexsorta[：，2]，a[：，1]，a[：，0]。节省的时间相当可观，但免责声明：它可能不会涵盖所有情况-这取决于数据。非常感谢。这就是我一直在寻找的答案，你能解释一下这一步是怎么回事吗：b=a.viewnp.dtypenp.void，a.dtype.itemsize*a.shape[1]？@Akavall它正在创建一个数据视图，其中np.void数据类型的大小是整行的字节数。信息技术

---

---

如果你有一个np.uint8s数组，并将其视为np.uint16s，它将每两列合并为一列，但更灵活。@Jaime，你能添加一个np.ASCONTIGOUUSARRAY或类似的数组以保证总体安全吗？我知道这比必要的限制要严格一些，但是。。。。行必须是连续的，视图才能按预期工作。@ConstantineEvans这是最近添加的：在numpy 1.6中，尝试在np.void数组上运行np.unique会返回一个与该类型未实现mergesort相关的错误。不过，在1.7中它工作得很好。值得注意的是，如果将此方法用于浮点数，则会出现一个-0的捕获。将不会进行等于+0的比较，而逐个元素的比较将具有-0。=+0。按照ieee浮动标准的规定。请参见+1，这是一个清晰、简短、通灵的句子。除非速度是一个真正的问题，否则这些类型的解决方案应该优先于这个问题的复杂的、投票率较高的答案。太好了！花括号或set函数就可以了。@Greg von Winckel你能建议一些不改变顺序的东西吗？是的，但不是在一个命令中：x=[]；[x.appendtupler for r in a if tupler not in x]；a_unique=arrayx；要避免FutureWarning，请将集合转换为如下列表：np.vstacklist{tuplerow for row in AIPbiased[i，：，：]}FutureWarning:要堆栈的数组必须作为序列类型（如list或tuple）传递。从NumPy 1.16开始，不推荐对生成器等非序列可重用项的支持，这将在将来引发错误。+1这是明确的、简短的和python式的。除非速度是一个真正的问题，否则这些类型的解决方案应该优先于这个问题的复杂的、投票率较高的答案。我更喜欢这个，而不是公认的解决方案。速度对我来说不是问题，因为每次调用的行数可能小于100行。这正好描述了如何对行执行unique。这实际上不适用于我的数据，uniques包含unique元素。可能我误解了数组的预期形状-您能在这里更精确一些吗？@ryan saxe我喜欢这是pythonic，但这不是一个好的解决方案，因为返回到uniques的行是经过排序的，因此与数组中的行不同。B=np.数组[[1,2]，[2,1]；A=np.unique[B中的行的元组]；printA=array[[1,2]，[1,2]]最佳答案。谢谢这是迄今为止所写的数学上最概括的答案。它将矩阵视为N维空间中的一组数据点或样本，并通过欧氏距离或任何其他方法确定相同或相似点的相似性集合。这些点可以是重叠的数据点或非常接近的邻域。最后，相同或类似点的集合被上述答案中的任何点替换为属于同一集合的第一个点。这有助于减少点云的冗余。@Sanchit aha，这是一个很好的点，它不是拾取“第一个”点，实际上它可能是随机的，因为它取决于Python如何将点存储在集合中，作为每个阈值大小邻域的代表，该函数允许用户指定如何拾取该点，例如，使用“中间带”或最接近质心的点等。毫无疑问我刚才提到了第一点，因为这是你的程序正在做的，这是完全正确的。只是一个更正——我在上面错误地说，由于集合的无序性，每个thresh集群将拾取的行是随机的。当然，这对我来说是一个愚蠢的想法，集合存储了thresh邻域中的索引元组，因此这个findRows实际上会返回每个thresh集群中的第一行。使用Jaime所做的唯一return_索引应该会使最后的返回行更简单。只需在右轴上索引原始ar。非常低效且容易出错，例如使用不同的打印选项。其他选择显然更可取。对我来说似乎不起作用。每个元组是两个字符串，而不是两个浮点数不起作用，它返回的元素列表不是元组，我真的很喜欢这个答案。当然，它不直接使用numpy，但对我来说，它是最容易理解的，而且速度很快。非常好的答案，一个小点：vstack_dict，从不使用dict，花括号是一个集合理解，因此它的行为与vstatck_集合几乎相同。因为fro图中缺少vstack_dict性能线，看起来它只是被vstack_集性能图所覆盖，因为它们非常相似！谢谢你的回复。我已经改进了绘图，使其只包含一个vstack变量。请小心使用此函数。np.uniquelist_cor，axis=0获取移除重复行的数组；它不会将数组过滤为原始数组中唯一的元素。请参阅，例如..请注意，如果希望唯一的行忽略行中值的顺序，则可以在列中对原始数组进行排序 umns直接优先：原始数组。sortaxis=1

matrix_as_list=data.tolist() 
matrix_as_list:
[[1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]]

uniq_list=list()
uniq_list.append(matrix_as_list[0])

[uniq_list.append(item) for item in matrix_as_list if item not in uniq_list]

unique_matrix=np.array(uniq_list)
unique_matrix:
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 0]])