Optimización automatizada de la multiplicación de vectores de matriz 0-1

22

Pregunta:

¿Existe algún procedimiento o teoría establecida para generar código que aplique eficientemente una multiplicación matriz-vector, cuando la matriz es densa y está llena de ceros y unos? Idealmente, el código optimizado haría un uso sistemático de la información previamente calculada para reducir el trabajo duplicado.

En otras palabras, tengo una matriz y quiero hacer una precomputación basada en , que hará que calcular más eficiente posible cuando más tarde reciba el vector . $M$ $M$ $Mv$ $v$

$M$ es una matriz binaria densa rectangular que se conoce en "tiempo de compilación", mientras que $v$ es un vector real desconocido que solo se conoce en "tiempo de ejecución".

Ejemplo 1: (ventana deslizante)

Permítanme usar un pequeño ejemplo fácil para ilustrar mi punto. Considere la matriz,

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \end{matrix}] .

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1\\ & 1 & 1 & 1 & 1 & 1 \\ & & 1 & 1 & 1 & 1 & 1\\ & & & 1 & 1 & 1 & 1 & 1\end{bmatrix}.$ Supongamos que aplicamos esta matriz a un vector

v

$v$ para obtener

w = M v

$w = Mv$ . Entonces las entradas del resultado son,

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{3} & = v_{3} + v_{4} + v_{5} + v_{6} + v_{7} \\ w_{4} & = v_{4} + v_{5} + v_{6} + v_{7} + v_{8} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5\\ w_2 &= v_2 + v_3 + v_4 + v_5 + v_6\\ w_3 &= v_3 + v_4 + v_5 + v_6 + v_7\\ w_4 &= v_4 + v_5 + v_6 + v_7 + v_8 \end{align}$

Hacer una multiplicación estándar de matriz-vector se calculará exactamente de esta manera. Sin embargo, mucho de este trabajo es redundante. Podríamos hacer el mismo cálculo matricial a menor costo haciendo un seguimiento de un "total " y sumando / restando para obtener el siguiente número:

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = w_{1} + v_{6} - v_{1} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5\\ w_2 &= w_1 + v_6 - v_1\\ w_3 &= w_2 + v_7 - v_2\\ w_4 &= w_3 + v_8 - v_3 \end{align}$

Ejemplo 2: (estructura jerárquica)

En el ejemplo anterior, podríamos hacer un seguimiento de un total acumulado. Sin embargo, generalmente uno necesitaría crear y almacenar un árbol de resultados intermedios. Por ejemplo, considere

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 \\ 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{matrix}]

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\ 1 & 1 & 1 & 1 \\ & & & & 1 & 1 & 1 & 1\\ 1 & 1 \\ & & & & 1 & 1 \\ & & 1 & 1 \\ & & & & & & 1 & 1\end{bmatrix}$ Se podría calcular

w = M v

$w = Mv$ eficiente utilizando un árbol de resultados intermedios:

Calcule $w_5$ y $w_7$ , y agréguelos para obtener $w_3$ .
Calcule $w_4$ y $w_6$ , y agréguelos para obtener $w_2$ .
Agregue y para obtener $w_2$ $w_3$ $w_1$

La estructura en los ejemplos anteriores es fácil de ver, pero para las matrices reales que me interesan, la estructura no es tan simple.

Ejemplo 3: (rango bajo)

Para aclarar alguna confusión, las matrices generalmente no son escasas. Específicamente, un método para resolver este problema debe ser capaz de encontrar métodos eficientes para aplicar matrices donde los bloques grandes estén llenos de unos. Por ejemplo, considere

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \end{matrix}] .

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & & \\ 1 & 1 & 1 & 1 & & \\ 1 & 1 & 1 & 1 & & \end{bmatrix}.$

Esta matriz se puede descomponer como una diferencia de dos matrices de rango 1,

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \end{matrix}] - [\begin{matrix} 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{matrix}]

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1\end{bmatrix} - \begin{bmatrix}& & & & & \\ & & & & & \\ & & & & 1 & 1 \\ & & & & 1 & 1 \\ & & & & 1 & 1\end{bmatrix}$

por lo tanto, su acción en un vector se puede calcular de manera eficiente, $w := Mv$

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - v_{5} - v_{6} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 + v_6 \\ w_2 &= w_1 \\ w_3 &= w_2 - v_5 - v_6 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

Motivación:

Estoy trabajando en un método numérico para el procesamiento de algunas imágenes, y hay varias matrices grandes y densas con diferentes estructuras que se arreglan para siempre. Más tarde, estas matrices deberán aplicarse a muchos vectores desconocidos que dependerán de la entrada del usuario. En este momento estoy usando lápiz y papel para crear un código eficiente por matriz, pero me pregunto si el proceso puede automatizarse. $0-1$ $v_i$

Editar: (postdata)

Todas las respuestas aquí hasta ahora (hasta el 5/9/15) son interesantes, pero ninguna responde a la pregunta tan satisfactoriamente como esperaba. Probablemente resulta que esta es una pregunta de investigación difícil, y nadie sabe una buena respuesta.

Desde que se acabó el tiempo, estoy otorgando la recompensa a la respuesta de EvilJS, ya que aborda la pregunta correcta. Sin embargo, deseo que la respuesta contenga explicaciones más claras y detalladas.

La respuesta de tranisstor establece una conexión entre esta pregunta y el problema de la Boolean Matrix-Vector Multiplication (OMv) en línea, pero la conexión no es exactamente lo que esta pregunta hace. En particular, la siguiente suposición realmente no encaja (el énfasis es mío),

Ahora suponga que para todas las y todas las matrices $n \leq n_0$ $n \times n$ $M$ conocemos un algoritmo , que para todos los vectores calcula en un tiempo verdaderamente subcuadrático, es decir, en el tiempo para algunos . $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$

Que existan o no algoritmos subcuadráticos para todas las matrices es ortogonal a la cuestión de encontrar un algoritmo para una matriz específica que sea lo más rápido posible. La mayoría de las matrices 0-1 parecen ruido aleatorio y (si tuviera que adivinar) probablemente no tienen algoritmos subcuadráticos. Sin embargo, el hecho de que haya matrices realmente malas no me impide encontrar un algoritmo rápido en una buena matriz, por ejemplo, una matriz de "ventana deslizante".

Las respuestas de vzn, primera respuesta , segunda respuesta son interesantes (y en mi opinión no merecen tantos votos negativos), pero no se aplican a la pregunta por las razones discutidas en los comentarios allí.

linear-algebra matrices program-optimization

— Nick Alger
fuente

1

Si su matriz es de esta forma, TDMA es matriz de banda, algoritmo de Thomas. Todavía no 0-1, pero esta característica debe explotarse.

— Mal

@EvilJS resulta que la matriz está agrupada para el ejemplo particular. En general no será en bandas. He agregado otro ejemplo que no está en bandas.

— Nick Alger

¿Tiene muchas matrices constantes N x M que son binarios, vectores reales y desea calcular previamente la ruta de ejecución óptima durante la etapa de preprocesamiento por instancia? El resultado de dicha operación es código con operaciones codificadas por matriz y ¿desea un método para hacerlo? Por instancia quiero decir por matriz. Solo revisando.

— Mal

@EvilJS Esta pregunta es sobre la situación en la que hay una matriz binaria conocida , que se aplicará a muchos vectores reales desconocidos más adelante. Basados solo en , deseamos calcular previamente un código que aplicará más eficiente posible, para que luego, cuando recibamos , podamos calcular más rápido posible. En la aplicación particular que motiva esta pregunta, tengo un puñado de matrices binarias como esta (12 en realidad) que están fijas todo el tiempo, mientras que los vectores son impredecibles y dependen de la entrada del usuario del programa.

M

$M$

v_{i}

$v_i$

M

$M$

M

$M$

v_{i}

$v_i$

M v_{i}

$M v_i$

v_{i}

$v_i$

— Nick Alger

1

En el campo de dos elementos, el problema de calcular el circuito mínimo de puerta XOR que simula una transformación lineal dada es NP-hard. Ver cstheory.stackexchange.com/a/32272/225

— Ryan Williams

5

Si es posible, trate de explotar la naturaleza tridiagonal en bandas de la matriz.
De lo contrario, si la matriz contiene solo un número constante de valores distintos (que seguramente es binario), debe probar el algoritmo Mailman (por Edo Liberty, Steven W. Zucker en el informe técnico de la Universidad de Yale # 1402): optimizado en un diccionario finito
Common Subexpression Elimination se conoce desde hace algún tiempo como Multiplicación constante constante, pero bajar al nivel de puerta es una opción: los patrones utilizados aquí podrían usarse por separado como solución o fusionarse con otros métodos, el documento para este "Mejora de la eliminación de subexpresión común Algoritmo con un nuevo método de cálculo de retardo a nivel de puerta "por Ning Wu, Xiaoqiang Zhang, Yunfei Ye y Lidong Lan publicado en" Actas del Congreso Mundial sobre Ingeniería y Ciencias de la Computación 2013 Vol II WCECS 2013, 23-25 de octubre de 2013, San Francisco, EE. UU. " Gate level CSE

También hay un método tosco pero de trabajo, para generar una matriz simbólica con constantes, un vector con variables y conectarlo a una evaluación estática simple (SSA) desde compiladores, que automatiza el proceso de escribir matrices a mano.

nuevo prototipo de algoritmo
Lo que hizo con la suma de ejecución: Da 10 operaciones , y con mi idea inicial de usar Thomas es equivalente. Por ahora todavía estoy escribiendo y probando un nuevo algoritmo, también los tiempos de ejecución son desagradables , pero el primer resultado de la prueba me dio una respuesta sorprendente:

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = w_{1} + v_{6} - v_{1} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 \\ w_2 &= w_1 + v_6 - v_1 \\ w_3 &= w_2 + v_7 - v_2 \\ w_4 &= w_3 + v_8 - v_3 \end{align}$

\begin{aligned} t m p_{1} & = v_{2} + v_{3} + v_{4} + v_{5} \\ w_{1} & = v_{1} + t m p_{1} \\ w_{2} & = t m p_{1} + v_{6} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} tmp_1 &= v_2 + v_3 + v_4 + v_5 \\ w_1 &= v_1 + tmp_1 \\ w_2 &= tmp_1 + v_6 \\ w_3 &= w_2 + v_7 - v_2 \\ w_4 &= w_3 + v_8 - v_3 \end{align}$
que proporciona 9 operaciones , definiéndolas como + o - es 1 y = es 0.

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - v_{5} - v_{6} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 + v_6 \\ w_2 &= w_1 \\ w_3 &= w_2 - v_5 - v_6 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

Esto da 7 operaciones , el resultado de mi algoritmo dio: Lo que da 6 operaciones Por ahora puedo decir que estoy usando la distancia de Hamming, & y | operaciones bit a bit, contando usos y haciendo algo como Cocke – Younger – Kasami (CYK) - "un algoritmo de análisis para gramáticas libres de contexto, llamado así por sus inventores, John Cocke, Daniel Younger y Tadao Kasami. Emplea análisis dinámico y de abajo hacia arriba programación." - de Wikipedia Esta es la misma técnica que uso para construir bloques de variables.

\begin{aligned} t m p_{1} & = v_{1} + v_{2} + v_{3} + v_{4} \\ t m p_{2} & = v_{5} + v_{6} \\ w_{1} & = t m p_{1} + t m p_{2} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - t m p_{2} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} tmp_1 &= v_1 + v_2 + v_3 + v_4 \\ tmp_2 &= v_5 + v_6 \\ w_1 &= tmp_1 + tmp_2 \\ w_2 &= w_1 \\ w_3 &= w_2 - tmp_2 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

— Mal
fuente

(re rev5) por favor dar ref en "método de hoja perenne". Además, ¿qué es SSA? Algoritmo dinámico CYK?

— vzn

Le otorgué la recompensa a esta respuesta y expliqué por qué en una edición de mi pregunta original.

— Nick Alger el

8

Esto está relacionado con una pregunta de investigación abierta, que se conoce como el "problema de la matriz de vectores booleanos en línea (OMv)". Este problema es el siguiente (ver [1]): Dado un binario matriz y vectores columna binarios , tenemos que calcular antes de llega. $n \times n$ $M$ $n$ $v_1, \dots, v_n$ $M v_i$ $v_{i+1}$

Observe que el problema de la pregunta es algo más general: permite matrices y vectores con valores reales. Observe que el problema con matrices y vectores booleanos es "más fácil", ya que presenta un caso especial. $m \times n$ $n \times n$

Claramente, el algoritmo ingenuo para el problema en línea de la matriz de vectores de matriz booleana (que solo usa la matriz de multiplicación de vectores estándar) lleva tiempo . Hay una conjetura (ver, por ejemplo, [1]) que esto no puede hacerse realmente más rápido que . (Con más detalle, esta conjetura es la siguiente: no existe un algoritmo realmente subcúbico, que resuelva el problema de multiplicación de matrices booleanas en línea, es decir, no existe un algoritmo con tiempo de ejecución para ). $O(n^3)$ $O(n^3)$ $O(n^{3 - \varepsilon})$ $\varepsilon > 0$

Se sabe que el algoritmo de Williams resuelve este problema en el tiempo . Ver [2] para más detalles. $O(n^3 / \log^2 n)$

Sería un gran avance en el área de los límites inferiores condicionales, si se pudiera probar o refutar la conjetura anterior.

[1] Unificación y fortalecimiento de la dureza para problemas dinámicos a través de una conjetura de matriz de vectores en línea. por Henzinger, Krinninger, Nanongkai y Saranurak
[ http://eprints.cs.univie.ac.at/4351/1/OMv_conjecture.pdf ]

[2] Multiplicación matricial-vectorial en tiempo subcuadrático: (se requiere preprocesamiento). por Williams
[ http://dl.acm.org/citation.cfm?id=1283383.1283490 ]

Actualizar

Una de las preguntas en los comentarios fue la siguiente: Conocemos en tiempo de compilación. ¿No podemos ajustar nuestro algoritmo para adaptarlo a , por lo que el problema OMV (conjetura) no se aplica? Veremos que este no es el caso, a menos que la conjetura de OMv falle. $M$ $M$

La idea de la prueba es simple: suponga que podríamos dar algoritmos rápidos para todas las matrices de hasta cierto tamaño (por ejemplo, distinguir todos los casos posibles). Después de este cierto tamaño usamos divide y vencerás.

Aquí están los detalles:
Arregle algunos , que (sin pérdida de generalidad) es una potencia de 2 y mayor que 2. Ahora suponga que para todas las matrices y todas las conocemos un algoritmo , que para todos los vectores calcula en un tiempo verdaderamente subcuadrático, es decir, en el tiempo para algunos $n_0 \in \mathbb{N}$ $n \leq n_0$ $n \times n$ $M$ $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$ . (Tenga en cuenta que esto permite un algoritmo individual para cada matriz hasta un tamaño ). $n_0 \times n_0$

Ahora resolveremos OMv en un tiempo verdaderamente subcúbico:
dada una matriz binaria de tamaño , donde para algunos y , usamos una estrategia de dividir y conquistar. Dividimos en cuatro submatrices de tamaños . Si $M$ $n \times n$ $n = 2^k$ $k$ $n > n_0$ $M$ $M_1, M_2, M_3, M_4$ $2^{k-1} \times 2^{k-1}$ , entonces usamos el algoritmo , de lo contrario, recurrimos. (Como es un número fijo, podemos elegir el algoritmo correcto en tiempo constante). $2^{k-1} \leq n_0$ $A_{2^{k-1},M_i}$ $n_0$

Tenga en cuenta que necesitaremos como máximo pasos de recursión. Además, para vectores , haremos cálculos. Por lo tanto, para procesar todas las multiplicaciones de vectores de matriz necesitaremos un tiempo de cálculo total de . $O(\log n)$ $n$ $v_1, \dots, v_n$ $n$ $O(n^{3 - \varepsilon} \log n)$

Es bien sabido que el logaritmo crece más lentamente que cualquier polinomio (en particular, más lento que cualquier raíz). Al fijar algunos con , vemos que nuestro cálculo total se está ejecutando en un tiempo verdaderamente subcúbico (en particular, en el tiempo ). Por lo tanto, la conjetura de OMv estaría mal. $\tilde \varepsilon > 0$ $\tilde \varepsilon < \varepsilon$ $O(n^{3 - \tilde \varepsilon})$

(Si tiene el tamaño y y no son potencias de 2, entonces los límites en los tiempos de funcionamiento siguen siendo válidas, ya que podíamos aumentar y a las próximas potencias de 2.) $M$ $m \times n$ $m$ $n$ $n$ $m$

Conclusión: Si pudiera hacer uso de distinciones de casos en las matrices de entrada para derivar algoritmos rápidos, entonces podría mejorar la conjetura de OMv.

— tranisstor
fuente

Como señalaron el autor y vzn, este no es el caso, el vector no es binario, Matrix no es necesario N x N, y el autor quiere calcular previamente las operaciones, y no hay necesidad de procesamiento en línea. Basado en conjeturas no es suficiente. Ambos documentos son irrelevantes para cuestionar. El caso aquí es calcular previamente la matriz constante para proporcionar un número mínimo de operaciones. Habrá diferentes enfoques posibles para casos simétricos completos, con bandas.

— Mal

@EvilJS: Si permite cualquier matriz M x N y vectores con valores reales, entonces el problema se vuelve más difícil que el que di en la respuesta (es decir, la Multiplicación de matrices booleanas en línea será un caso especial). Si pudieras resolver el problema más general realmente más rápido que O (n ^ 3), entonces también harías una mejora en la conjetura (¡lo cual sería una gran noticia!). Además, el autor dice en un comentario a la pregunta que los vectores son inicialmente desconocidos. Si conocía todos los vectores de antemano, podría usar la multiplicación de matriz rápida (por ejemplo, una versión del algoritmo de Strassen).

— tranisstor

Acabo de señalar el caso de los autores "vector real". Mire la matriz de Thomas, solo un caso especial de matrices en O (n). No me refiero a un caso general. Y si Matrix es constante y se conocen vectores, la respuesta del código no implementará Strassen; (

— Evil

@EvilJS: No estoy seguro de entender completamente lo que estás tratando de decir. Por supuesto, para tipos especiales de matrices como la matriz de Thomas, puede obtener una velocidad significativa, pero en general esto es más difícil. Tal vez también debería señalar que el problema que presenté considera un paso de preprocesamiento (antes de que llegue cualquier vector). Si pudiera decirme cómo "codificar" sistemáticamente su algoritmo para cualquier matriz que le proporcione, también podría mejorar la conjetura (ya que podría implementar este paso de codificación como un paso de preprocesamiento de un algoritmo).

— tranisstor

acordó que funciona; sin embargo, la segunda referencia de williams no parece considerar las matrices binarias en particular. digo tiene diapositivas aquí

— vzn 02 de

-2

esto es esencialmente CS a nivel de investigación, el problema se estudia al menos en dos formas, una de multiplicación de matrices dispersas (ejemplo de papel recién citado), y también se estudia el caso especial de "matrices dispersas binarias". el 2 ^nd caso se sabe que está relacionada con la optimización de programas de línea recta. los programas mínimos también pueden ser como DAG con dos tipos de "compuertas", suma y multiplicación, por lo que parte de la literatura sobre minimización de circuitos puede conectarse con esto, y posiblemente el software "listo para usar" podría adaptarse para este propósito. aquí es una referencia específica en el 2 ^nd caso y también la misma pregunta en cstheory con algún estudio empírico inicial básica.

— vzn
fuente

1

O (n)

$O(n)$

O (n^{2})

$O(n^2)$

las referencias están activadas, como lo indican los títulos, matrices dispersas . tal vez tienes alguna definición diferente a la de los periódicos? si es sensible a una definición exacta de escasez (la mayoría está más o menos correlacionada / casi intercambiable), debe indicarse en la pregunta.

— vzn

1

Las matrices que me interesan son matrices densas. Por cierto, aunque no creo que esto aborde completamente mi pregunta, agradezco la respuesta.

— Nick Alger el

¡OK lo siento! se confundió, no se dio cuenta de la pregunta exacta. a simple vista, su ejemplo # 2 tiene menos de ½ relleno y me pareció "escaso" y pensé que parte de la teoría escasa sería al menos algo aplicable. básicamente, cuanto más densa es la matriz, menos se puede optimizar la operación, por lo que probablemente la mayor parte de la teoría sobre este tipo de optimización esté orientada en torno a matrices dispersas.

— vzn

-3

No estoy seguro si este problema se ha estudiado exactamente, pero esta investigación está relacionada y parece una ventaja / inicio razonable. observa la descomposición de la hipergrafía para una multiplicación de matriz dispersa. Las matrices binarias son un caso especial de este enfoque. Este enfoque encontrará estrategias más óptimas que el método de multiplicación "directa". Es posible que se realicen más optimizaciones (dentro de este marco) en función de la propiedad de matriz binaria.

Descomposición basada en particiones hipergráficas para multiplicación vectorial de matriz dispersa paralela / Umit Catalyurek y Cevdet Aykanat

— vzn
fuente

2

No veo qué tiene que ver esto con la pregunta. Ese documento trata sobre la partición de la multiplicación de matrices entre un sistema distribuido, para computación paralela, para minimizar la cantidad de comunicación entre procesadores. ¿Qué tiene eso que ver con esta pregunta? La pregunta no parece mencionar nada sobre computación paralela o comunicación entre procesadores. Te animo a editar tu respuesta para que la conexión sea más explícita.

— DW

afaik es el mismo problema y minimizar el cálculo paralelo también minimiza la implementación de un solo procesador de los mismos cálculos. al menos, el interrogador no descartó implementaciones paralelas.

— vzn

1

Gracias por el enlace. Sin embargo, soy escéptico sobre el método para este problema, ya que no aprovecha el hecho de que las entradas de la matriz contienen solo ceros y unos, mientras que esta propiedad es muy importante, por lo que puedo decir. Por ejemplo, el algoritmo de "total acumulado" en el primer ejemplo solo funcionará si todas las entradas distintas de cero en una columna dada de la matriz tienen el mismo valor.

— Nick Alger el

NA su observación / objeción se aborda en la respuesta. probablemente sea posible una mayor optimización utilizando la propiedad 0/1; Este método parece minimizar el número total de operaciones de suma / multiplicación bajo la apariencia de paralelización. las operaciones de suma / multiplicación también pueden verse como "puertas" en un DAG y la técnica es minimizar las puertas. La complejidad sustancial del artículo revela parte de la complejidad inherente más profunda / sustancial de este proceso de optimización. como se indicó, la respuesta no pretende ser definitiva en este difícil problema, simplemente "mejor que nada".

— vzn