Cómo contar la cantidad de elementos verdaderos en una matriz bool NumPy

4 minutos de lectura

avatar de usuario
norio

Tengo una matriz NumPy ‘boolarr’ de tipo booleano. Quiero contar el número de elementos cuyos valores son True. ¿Hay una rutina NumPy o Python dedicada a esta tarea? ¿O necesito iterar sobre los elementos en mi script?

  • Para pandas: stackoverflow.com/questions/26053849/…

    – Privado

    3 de abril de 2017 a las 8:16

avatar de usuario
david alber

Tienes múltiples opciones. Dos opciones son las siguientes.

boolarr.sum()
numpy.count_nonzero(boolarr)

Aquí hay un ejemplo:

>>> import numpy as np
>>> boolarr = np.array([[0, 0, 1], [1, 0, 1], [1, 0, 1]], dtype=np.bool)
>>> boolarr
array([[False, False,  True],
       [ True, False,  True],
       [ True, False,  True]], dtype=bool)

>>> boolarr.sum()
5

Por supuesto, eso es un bool-respuesta específica. De manera más general, puede utilizar numpy.count_nonzero.

>>> np.count_nonzero(boolarr)
5

  • Gracias, David. Se ven limpios. Sobre el método con sum(..), ¿True siempre es igual a 1 en python (o al menos en numpy)? Si no está garantizado, agregaré una verificación, ‘if True==1:’ de antemano. Acerca de count_nonzero(..), desafortunadamente, parece que no está implementado en mi módulo numpy en la versión 1.5.1, pero es posible que tenga la oportunidad de usarlo en el futuro.

    – norio

    3 de diciembre de 2011 a las 1:52

  • @norio en cuanto a bool: los valores booleanos se tratan como 1 y 0 en las operaciones aritméticas. Ver “Valores booleanos” en la documentación de la biblioteca estándar de Python. Tenga en cuenta que NumPy’s bool y pitón bool no son lo mismo, pero son compatibles (ver aquí para más información).

    – David Alberto

    3 de diciembre de 2011 a las 4:39

  • @norio en cuanto a numpy.count_nonzero no estar en NumPy v1.5.1: tienes razón. De acuerdo a esto anuncio de lanzamientose agregó en NumPy v1.6.0.

    – David Alberto

    3 de diciembre de 2011 a las 4:41

  • por favor, numpy.count_nonzero es unas mil veces más rápido, al menos en mi intérprete de Python. python -m timeit -s "import numpy as np; bools = np.random.uniform(size=1000) >= 0.5" "np.count_nonzero(bools)" contra python -m timeit -s "import numpy as np; bools = np.random.uniform(size=1000) >= 0.5" "sum(bools)"

    – chbrown

    19 noviembre 2013 a las 21:10


  • @chbrown tienes razón. Pero deberías comparar con np.sum(bools) ¡en cambio! Sin embargo, np.count_nonzero(bools) sigue siendo ~ 12 veces más rápido.

    – mab

    23 de noviembre de 2015 a las 18:15


avatar de usuario
Guillaume Género

Esa pregunta resolvió una pregunta bastante similar para mí y pensé que debería compartir:

En Python sin procesar puedes usar sum() para contar True valores en un list :

>>> sum([True,True,True,False,False])
3

Pero esto no funcionará:

>>> sum([[False, False, True], [True, False, True]])
TypeError...

  • Primero debe “aplanar” la matriz de matrices. desafortunadamente, no hay un método incorporado, consulte stackoverflow.com/questions/2158395/…

    – tommy cheng

    7 dic 2012 a las 23:32

  • Gracias Guillaume! También funciona con marcos de datos de Pandas.

    – JJFord3

    1 de diciembre de 2016 a las 19:11

En términos de comparar dos matrices numpy y contar el número de coincidencias (por ejemplo, predicción de clase correcta en aprendizaje automático), encontré útil el siguiente ejemplo para dos dimensiones:

import numpy as np
result = np.random.randint(3,size=(5,2)) # 5x2 random integer array
target = np.random.randint(3,size=(5,2)) # 5x2 random integer array

res = np.equal(result,target)
print result
print target
print np.sum(res[:,0])
print np.sum(res[:,1])

que se puede extender a las dimensiones D.

Los resultados son:

Predicción:

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

Objetivo:

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

Recuento de predicción correcta para D=1: 1

Recuento de predicción correcta para D=2: 2

boolarr.sum(axis=1 or axis=0)

El eje = 1 generará el número de verdaderos en una fila y el eje = 0 contará el número de verdaderos en las columnas, por lo que

boolarr[[true,true,true],[false,false,true]]
print(boolarr.sum(axis=1))

será (3,1)

b[b].size

dónde b es el ndarray booleano en cuestión. filtra b por Truey luego cuente la longitud de la matriz filtrada.

Esto probablemente no sea tan eficiente np.count_nonzero() mencionado anteriormente, pero es útil si olvida la otra sintaxis. Además, esta sintaxis más corta ahorra tiempo al programador.

Manifestación:

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

In [2]: a
Out[2]: array([0, 1, 3])

In [3]: a[a>=1].size
Out[3]: 2

In [5]: b=a>=1

In [6]: b
Out[6]: array([False,  True,  True])

In [7]: b[b].size
Out[7]: 2

avatar de usuario
jose pablo solano

Para la matriz 1D, esto es lo que funcionó para mí:

import numpy as np
numbers= np.array([3, 1, 5, 2, 5, 1, 1, 5, 1, 4, 2, 1, 4, 5, 3, 4, 
                  5, 2, 4, 2, 6, 6, 3, 6, 2, 3, 5, 6, 5])

numbersGreaterThan2= np.count_nonzero(numbers> 2)

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad