Otimização automatizada da multiplicação de vetores de matriz 0-1

22

Questão:

Existe procedimento ou teoria estabelecida para gerar código que aplique eficientemente uma multiplicação de vetor de matriz, quando a matriz é densa e preenchida apenas com zeros e uns? Idealmente, o código otimizado faria uso sistemático de informações previamente calculadas para reduzir o trabalho duplicado.

Em outras palavras, eu tenho uma matriz e quero fazer alguma pré-computação baseada em , que tornará a computação mais eficiente possível quando eu receber o vetor mais tarde . $M$ $M$ $Mv$ $v$

é uma matriz binária densa retangular que é conhecida em "tempo de compilação", enquanto é um vetor real desconhecido que é conhecido apenas em "tempo de execução". $M$ $v$

Exemplo 1: (janela deslizante)

Deixe-me usar um pequeno exemplo fácil para ilustrar meu argumento. Considere a matriz, Supondo que aplicamos essa matriz a um vetorpara obter. Então as entradas do resultado são,

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}.$

v

$v$

w = M v

$w = Mv$

\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}$

Fazer uma multiplicação de vetor de matriz padrão calculará exatamente dessa maneira. No entanto, muito deste trabalho é redundante. Poderíamos fazer a mesma computação de matriz a um custo menor, acompanhando um "total de execução" e adicionando / subtraindo para obter o próximo 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}$

Exemplo 2: (estrutura hierárquica)

No exemplo anterior, poderíamos acompanhar um total em execução. No entanto, geralmente é necessário criar e armazenar uma árvore de resultados intermediários. Por exemplo, considere Pode-se calculareficientemente usando uma árvore de resultados intermediários:

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}$

w = M v

$w = Mv$

Calcule e , e adicioná-los para obter . $w_5$ $w_7$ $w_3$
Calcule e , e adicioná-los para obter . $w_4$ $w_6$ $w_2$
Adicione e para obter $w_2$ $w_3$ $w_1$

A estrutura nos exemplos acima é fácil de ver, mas para as matrizes reais em que estou interessado, a estrutura não é tão simples.

Exemplo 3: (classificação baixa)

Para esclarecer alguma confusão, as matrizes geralmente não são escassas. Especificamente, um método para resolver esse problema precisa ser capaz de encontrar métodos eficientes para aplicar matrizes onde grandes blocos são preenchidos por outros. Por exemplo, 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}.$

Essa matriz pode ser decomposta como uma diferença de duas matrizes de classificação 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}$

portanto, sua ação em um vetor pode ser computada eficientemente por, $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}$

Motivação:

Eu estou trabalhando em um método numérico para algum processamento de imagem, e existem vários grandes densas matrizes com estruturas diferentes que são fixados para todos os tempos. Mais tarde, essas matrizes terão de ser aplicadas a muitos vetores desconhecidos que vai depender a entrada do usuário. No momento, estou usando lápis e papel para criar código eficiente por matriz, mas estou imaginando se o processo pode ser automatizado. $0-1$ $v_i$

Editar: (pós-escrito)

Todas as respostas aqui até agora (até 15/5/15) são interessantes, mas nenhuma responde à pergunta de maneira tão satisfatória quanto eu esperava. Provavelmente, essa é uma pergunta de pesquisa difícil e ninguém sabe uma boa resposta.

Como o tempo acabou, concedo a recompensa à resposta do EvilJS, pois ela aborda a pergunta certa. No entanto, desejo que a resposta contenha explicações mais claras e detalhadas.

A resposta do tranisstor faz uma conexão entre esta pergunta e o problema OMv (Online Boolean Matrix-Vector Multiplication), mas a conexão não é exatamente o que esta pergunta está perguntando. Em particular, a seguinte suposição realmente não se encaixa (ênfase em negrito):

Agora assuma que, para todas as e todas as matrizes $n \leq n_0$ $n \times n$ $M$ , conhecemos um algoritmo , que para todos os vetores calcula em tempo verdadeiramente subquadrático, ou seja, no tempo para alguns . $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$

A existência ou não de algoritmos subquadráticos para todas as matrizes é ortogonal à questão de encontrar um algoritmo para uma matriz específica o mais rápido possível. A maioria das matrizes 0-1 se parece com ruído aleatório e (se eu fosse adivinhar) provavelmente não possui algoritmos subquadráticos. No entanto, o fato de haver matrizes realmente ruins por aí não me impede de encontrar um algoritmo rápido em uma boa matriz, por exemplo, uma matriz de "janela deslizante".

As respostas do vzn, primeira resposta e segunda resposta são interessantes (e, na minha opinião, não merecem tantos votos negativos), mas elas não se aplicam à pergunta pelas razões discutidas nos comentários.

linear-algebra matrices program-optimization

— Nick Alger
fonte

1

Se sua matriz é desta forma, TDMA é matriz de banda, algoritmo Thomas. Ainda não é 0-1, mas esse recurso deve ser explorado.

— Mal

@EvilJS a matriz acaba de ser agrupada para o exemplo em particular. Em geral, não será em faixas. Eu adicionei outro exemplo que não está em faixas.

— Nick Alger

Você tem muitas matrizes N x M constantes que são vetores binários e reais e deseja pré-calcular o caminho de execução ideal durante o estágio de pré-processamento por instância? A saída dessa operação é um código com operações codificadas por matriz e você deseja que o método seja feito? Por exemplo, quero dizer por matriz. Apenas checando.

— Mal

@EvilJS Esta pergunta é sobre a situação em que existe uma matriz binária conhecida

, que será aplicada a muitos vetores reais desconhecidos

posteriormente. Baseado no

somente, queremos precompute um código que será aplicada

tão eficientemente quanto possível, para que mais tarde, quando recebemos o

, podemos calcular

o mais rápido possível. Na aplicação particular que motiva esta pergunta eu tenho um punhado de matrizes binárias como este (12 na verdade) que são fixos por todo o tempo enquanto os vetores

são imprevisíveis e dependem de entrada do usuário do 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

No campo de dois elementos, o problema de calcular o circuito XOR-gate mínimo que simula uma determinada transformação linear é NP-difícil. Veja cstheory.stackexchange.com/a/32272/225

— Ryan Williams,

5

Se for possível, tente explorar a natureza tridiagonal em faixas da matriz.
Caso contrário, se a matriz contiver apenas um número constante de valores distintos (o que certamente está sendo binário), tente o algoritmo Mailman (de Edo Liberty, Steven W. Zucker No relatório técnico da universidade de Yale # 1402): otimizado em dicionário finito
A eliminação de subexpressão comum é conhecida há algum tempo, como a Multiplicação de Múltiplas Constantes, mas descer para o nível de porta é uma opção - os padrões usados aqui podem ser usados separadamente como solução ou mesclados com outros métodos, o documento para esta seção Algoritmo com um novo método de computação de atraso no nível de porta "por Ning Wu, Xiaoqiang Zhang, Yunfei Ye e Lidong Lan publicado em" Anais do Congresso Mundial de Engenharia e Ciência da Computação 2013 Vol II WCECS 2013, 23-25 de outubro de 2013, São Francisco, EUA " CSE no nível do portão

Também existe um método bruto, mas funcional, para gerar matriz simbólica com constantes, vetor com variáveis e conectá-la à Static Single Assingment (SSA) dos compiladores, que automatiza o processo de escrever matrizes manualmente.

novo protótipo de algoritmo
O que você fez com a soma de execução: Dá 10operaçõese, com a minha ideia inicial de usar Thomas, é equivalente. Por enquanto ainda estou escrevendo e testando novo algoritmo, também os tempos de execução sãodesagradáveis, mas o primeiro resultado do teste me deu uma resposta surpreendente:

\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}$

\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}$

\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
fonte

(re rev5) plz dá ref em "evergreen method". Além disso, o que é SSA? Algoritmo dinâmico CYK?

— vzn 5/09/2015

Concedi a recompensa a esta resposta e expliquei o motivo de uma edição da minha pergunta original.

— Nick Alger

8

$n \times n$ $M$ $n$ $v_1, \dots, v_n$ $M v_i$ $v_{i+1}$

$m \times n$ $n \times n$

$O(n^3)$ $O(n^3)$ $O(n^{3 - \varepsilon})$ $\varepsilon > 0$

$O(n^3 / \log^2 n)$

Seria um avanço na área de limites inferiores condicionais, se alguém pudesse provar ou refutar a conjectura acima.

[1] Unificando e fortalecendo a dureza para problemas dinâmicos por meio de uma conjectura de multiplicação de vetores matriciais on-line. por Henzinger, Krinninger, Nanongkai e Saranurak
[ http://eprints.cs.univie.ac.at/4351/1/OMv_conjecture.pdf ]

[2] Multiplicação de vetores matriciais em tempo sub-quadrático: (é necessário algum pré-processamento). por Williams
[ http://dl.acm.org/citation.cfm?id=1283383.1283490 ]

Atualizar

$M$ $M$

A ideia da prova é simples: suponha que poderíamos fornecer algoritmos rápidos para todas as matrizes até certo tamanho (por exemplo, distinguindo todos os casos possíveis). Após esse tamanho, usamos dividir e conquistar.

$n_0 \in \mathbb{N}$ $n \leq n_0$ $n \times n$ $M$ $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$ $n_0 \times n_0$

$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}$ $2^{k-1} \leq n_0$ $A_{2^{k-1},M_i}$ $n_0$

$O(\log n)$ $n$ $v_1, \dots, v_n$ $n$ $O(n^{3 - \varepsilon} \log n)$

$\tilde \varepsilon > 0$ $\tilde \varepsilon < \varepsilon$ $O(n^{3 - \tilde \varepsilon})$

$M$ $m \times n$ $m$ $n$ $n$ $m$

Conclusão: Se você pudesse fazer uso de distinções de caso nas matrizes de entrada para derivar algoritmos rápidos, poderia melhorar a conjectura de OMv.

— tranisstor
fonte

Conforme apontado pelo autor e pelo vzn, esse não é o caso, o vetor não é binário, o Matrix não é necessário N x N e o autor deseja pré-calcular as operações, e não há necessidade de processamento on-line. Baseado em conjecturas não é suficiente. Ambos os documentos são irrelevantes para questionar. O caso aqui é pré-calcular a matriz constante para fornecer um número mínimo de operações. Haverá possíveis abordagens diferentes para casos completos, com faixas e simétricos.

— Mal

@EvilJS: Se você permitir qualquer matriz M x N e vetores de valor real, o problema ficará mais difícil do que o que eu dei na resposta (por exemplo, a Multiplicação de vetores de matrizes booleanas on-line será um caso especial). Se você pudesse resolver o problema mais geral verdadeiramente mais rápido que O (n ^ 3), também faria uma melhoria na conjectura (o que seria uma grande notícia!). Além disso, o autor diz em um comentário à pergunta que os vetores são inicialmente desconhecidos. Se você conhecesse todos os vetores de antemão, poderia simplesmente usar a multiplicação rápida de matrizes (por exemplo, uma versão do algoritmo de Strassen).

— tranisstor 02/09/2015

Eu apenas apontei o caso dos autores "vetor real". Veja a matriz de Thomas - apenas o caso especial de matrizes em O (n). Eu não implica caso geral. E se Matrix for constante e vetores forem conhecidos, a resposta do código fixo não implementa o Strassen; (

— Evil

@EvilJS: Não sei se entendi completamente o que você está tentando dizer. Obviamente, para tipos especiais de matrizes como a matriz Thomas, você pode obter uma velocidade significativa, mas em geral isso é mais difícil. Talvez eu deva também salientar que o problema que introduzi considera uma etapa de pré-processamento (antes que qualquer vetor chegue). Se você pudesse me dizer como "codificar" sistematicamente seu algoritmo para qualquer matriz que eu forneça, também poderá melhorar a conjectura (já que você pode implementar essa etapa de codificação codificada como uma etapa de pré-processamento de um algoritmo).

— Travisstor 02/09/2015

concordou que funciona; no entanto, o segundo árbitro de williams não parece considerar matrizes binárias em particular. fyi ele tem slides aqui

— vzn 02/09

-2

trata-se essencialmente de CS no nível de pesquisa, o problema é estudado em pelo menos duas formas, uma de multiplicação de matrizes esparsas (exemplo de trabalho que acabamos de citar) e também o caso especial de "matrizes esparsas binárias". o 2 ^nd caso é conhecida por estar relacionada com optimizar programas em linha recta. programas mínimos também podem ser como DAGs com dois tipos de "portas", adição e multiplicação; portanto, alguma literatura de minimização de circuitos pode se conectar com isso e, possivelmente, o software "pronto para uso" pode ser adaptado para essa finalidade. aqui está uma referência específica no ^2º caso e também a mesma pergunta sobre a história com algum estudo empírico inicial básico.

— vzn
fonte

1

O (n)

$O(n)$

O (n^{2})

$O(n^2)$

os árbitros estão, como os títulos indicam, matrizes esparsas . talvez você tenha alguma definição diferente da dos jornais? se você é sensível a uma definição exata de esparsidade (a maioria é aproximadamente correlacionada / quase intercambiável), isso deve ser indicado na pergunta.

— vzn

1

As matrizes nas quais estou interessado são matrizes densas. A propósito, mesmo que eu não ache que isso atenda totalmente à minha pergunta, agradeço a resposta.

— Nick Alger

ok desculpa se confundiu, não percebeu a pergunta exata. em uma análise superficial, seu exemplo nº 2 tem menos de ½ preenchimento e me pareceu "escasso" e percebi que parte da teoria esparsa seria pelo menos um pouco aplicável. basicamente, quanto mais densa a matriz, menos a operação pode ser otimizada; portanto, provavelmente a maior parte da teoria sobre esse tipo de otimização é orientada em torno de matrizes esparsas.

— vzn 31/08/2015

-3

não tenho certeza se esse problema foi estudado exatamente, mas esta pesquisa está relacionada e parece um avanço / começo razoável. olha a decomposição do hipergrafo para multiplicação esparsa da matriz. matrizes binárias são um caso especial dessa abordagem. essa abordagem encontrará estratégias mais ideais do que o método de multiplicação "direta". otimizações adicionais (dentro dessa estrutura) podem ser possíveis com base na propriedade da matriz binária.

Decomposição baseada em particionamento de hipergráficos para multiplicação vetorial de matriz esparsa paralela / Umit Catalyurek e Cevdet Aykanat

— vzn
fonte

2

Não vejo o que isso tem a ver com a questão. Esse artigo trata da particionamento da multiplicação de matrizes entre um sistema distribuído, para computação paralela, para minimizar a quantidade de comunicação entre processadores. O que isso tem a ver com esta questão? A questão não parece mencionar nada sobre computação paralela ou comunicação entre processadores. Convido você a editar sua resposta para tornar a conexão mais explícita.

— DW

Afaik é o mesmo problema e minimizar a computação paralela também minimiza uma implementação de processador único dos mesmos cálculos. pelo menos, o questionador não descartou implementações paralelas.

— vzn

1

Obrigado pelo link. No entanto, sou cético em relação ao método para esse problema, pois ele não tira proveito do fato de que as entradas da matriz contêm apenas zeros e uns, enquanto essa propriedade é muito importante, pelo que sei. Por exemplo, o algoritmo "total em execução" no primeiro exemplo funcionará apenas se todas as entradas diferentes de zero em uma determinada coluna da matriz tiverem o mesmo valor.

— Nick Alger

NA sua observação / objeção é abordada na resposta. provavelmente é possível uma otimização adicional usando a propriedade 0/1; esse método parece minimizar o número total de operações de adição / multiplicação sob o pretexto de paralelização. as operações de adição / multiplicação também podem ser vistas como "portões" em um DAG e a técnica é minimizar portões. a complexidade substancial do artigo revela parte da complexidade mais profunda / substancial inerente a esse processo de otimização. como a resposta declarada não pretende ser definitiva nesse problema difícil, apenas "melhor que nada".

— vzn