Ottimizzazione automatizzata della moltiplicazione vettoriale a matrice 0-1

22

Domanda:

Esiste una procedura o teoria consolidata per la generazione di codice che applica efficacemente una moltiplicazione matrice-vettore, quando la matrice è densa e piena solo di zeri e di quelli? Idealmente, il codice ottimizzato farebbe un uso sistematico delle informazioni precedentemente calcolate per ridurre il lavoro duplicato.

In altre parole, ho una matrice e voglio fare un pre-calcolo basato su , che renderà il calcolo più efficiente possibile quando in seguito riceverò il vettore . $M$ $M$ $Mv$ $v$

$M$ è una matrice binaria densa rettangolare conosciuta al "tempo di compilazione", mentre è un vettore reale sconosciuto che è noto solo al "tempo di esecuzione". $v$

Esempio 1: (finestra scorrevole)

Consentitemi di usare un semplice esempio per illustrare il mio punto. Considera la matrice, Supponendo di applicare questa matrice a un vettore per ottenere . Quindi le voci del risultato sono,

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

Fare una moltiplicazione matrice-vettore standard calcolerà esattamente in questo modo. Tuttavia, molto di questo lavoro è ridondante. Potremmo fare lo stesso calcolo di matrice a costi inferiori tenendo traccia di un "totale parziale" e aggiungendo / sottraendo per ottenere il numero successivo:

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

Esempio 2: (struttura gerarchica)

Nell'esempio precedente, potremmo semplicemente tenere traccia di un totale parziale. Tuttavia, in genere è necessario creare e memorizzare un albero di risultati intermedi. Ad esempio, considera Si potrebbe calcolareefficiente usando un albero di risultati intermedi:

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$

Calcola e e aggiungili per ottenere . $w_5$ $w_7$ $w_3$
Calcola e e aggiungili per ottenere . $w_4$ $w_6$ $w_2$
Aggiungi e per ottenere $w_2$ $w_3$ $w_1$

La struttura negli esempi sopra è facile da vedere, ma per le matrici attuali a cui sono interessato, la struttura non è così semplice.

Esempio 3: (livello basso)

Per chiarire un po 'di confusione, le matrici non sono generalmente sparse. In particolare, un metodo per risolvere questo problema deve essere in grado di trovare metodi efficienti per applicare matrici in cui blocchi di grandi dimensioni sono riempiti con quelli. Ad esempio, considera

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

Questa matrice può essere scomposta come differenza di due matrici di 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}$

quindi la sua azione su un vettore può essere calcolata in modo efficiente da, $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}$

Motivazione:

Sto lavorando a un metodo numerico per l'elaborazione di alcune immagini e ci sono diverse matrici dense di grandi dimensioni con strutture diverse che sono fisse per sempre. Successivamente dovranno queste matrici essere applicato a molti vettori sconosciuti che dipenderà input dell'utente. In questo momento sto usando carta e penna per elaborare un codice efficiente su una base per matrice, ma mi chiedo se il processo possa essere automatizzato. $0-1$ $v_i$

Modifica: (poscritto)

Tutte le risposte qui finora (al 9/5/15) sono interessanti, ma nessuna risponde alla domanda in modo soddisfacente come avevo sperato. Probabilmente si scopre che questa è una domanda di ricerca difficile e nessuno conosce una buona risposta.

Da quando il tempo è scaduto, sto assegnando la generosità alla risposta di EvilJS poiché si rivolge alla domanda giusta. Tuttavia, vorrei che la risposta contenesse spiegazioni più chiare e dettagliate.

La risposta di tranisstor stabilisce una connessione tra questa domanda e il problema della moltiplicazione della matrice vettoriale booleana in linea (OMv), ma la connessione non è esattamente ciò che questa domanda sta ponendo. In particolare, il seguente presupposto non si adatta davvero (mio accento enfatizzato),

Supponiamo ora che per tutti gli e tutti i matrici $n \leq n_0$ $n \times n$ $M$ sappiamo un algoritmo , che per tutti i vettori calcola nel tempo veramente subquadratic, cioè in tempo per un po ' . $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$

L'esistenza o meno di algoritmi subquadratici per tutte le matrici è ortogonale alla questione di trovare un algoritmo per una matrice specifica che sia il più veloce possibile. La maggior parte delle matrici 0-1 sembrano rumore casuale e (se dovessi indovinare) probabilmente non hanno algoritmi subquadratici. Tuttavia, il fatto che ci siano matrici davvero cattive là fuori non mi impedisce di trovare un algoritmo veloce su una matrice buona, ad esempio una matrice "finestra scorrevole".

Le risposte di vzn, la prima risposta , la seconda risposta sono interessanti (e secondo me non meritano così tanti voti negativi), ma non si applicano alla domanda per i motivi discussi nei commenti lì.

linear-algebra matrices program-optimization

— Nick Alger
fonte

1

Se la tua matrice è di questa forma, TDMA è una matrice di bande, algoritmo Thomas. Non ancora 0-1, ma questa funzione dovrebbe essere sfruttata.

— Evil

@EvilJS la matrice sembra essere appena fasciata per il particolare esempio. In generale non sarà fasciato. Ho aggiunto un altro esempio che non è legato.

— Nick Alger,

Hai molte matrici costanti N x M che sono binari, vettori reali e vuoi precompilare il percorso di esecuzione ottimale durante la fase di preelaborazione per istanza? L'output di tale operazione è il codice con operazioni hardcoded per matrice e vuoi che il metodo lo faccia? Per istanza intendo per matrice. Solo controllando.

— Evil

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

Nel campo di due elementi, il problema di calcolare il circuito di gate XOR minimo che simula una data trasformazione lineare è NP-difficile. Vedi cstheory.stackexchange.com/a/32272/225

— Ryan Williams

5

Se è possibile, prova a sfruttare la natura tridiagonale fasciata della matrice.
Altrimenti se la matrice contiene solo un numero costante di valori distinti (che sicuramente è binario), dovresti provare l'algoritmo Mailman (di Edo Liberty, Steven W. Zucker nel rapporto tecnico n. 1402 dell'università di Yale): ottimizzato su dizionario finito
L'eliminazione della sottoespressione comune è nota da tempo come la moltiplicazione della costante multipla, ma scendere al livello di gate è un'opzione - i modelli utilizzati qui potrebbero essere usati separatamente come soluzione o uniti con altri metodi, il documento per questo "Migliorare l'eliminazione delle sottoespressioni comuni Algorithm with A New Gate-Level Delay Computing Method "di Ning Wu, Xiaoqiang Zhang, Yunfei Ye e Lidong Lan pubblicato in" Atti del Congresso mondiale di ingegneria e informatica 2013 Vol II WCECS 2013, 23-25 ottobre 2013, San Francisco, USA " CSE a livello di gate

Esiste anche un metodo grezzo ma funzionante, per generare una matrice simbolica con costanti, vettore con variabili e collegarlo a Static Single Assingment (SSA) dai compilatori, che automatizza il processo di scrittura manuale delle matrici.

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

— il male
fonte

(re rev5) per favore fai riferimento a "metodo sempreverde". inoltre, cos'è SSA? Algoritmo dinamico CYK?

— vzn,

Ho assegnato la grazia a questa risposta e ho spiegato perché in una modifica alla mia domanda originale.

— 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)$

Sarebbe una svolta nel campo dei limiti inferiori condizionali, se si potesse provare o confutare la congettura di cui sopra.

[1] Unificazione e rafforzamento della durezza per problemi dinamici tramite una congettura di moltiplicazione matrice-vettore online. di Henzinger, Krinninger, Nanongkai e Saranurak
[ http://eprints.cs.univie.ac.at/4351/1/OMv_conjecture.pdf ]

[2] Moltiplicazione matrice-vettore in tempo sub-quadratico: (è richiesta una certa preelaborazione). di Williams
[ http://dl.acm.org/citation.cfm?id=1283383.1283490 ]

Aggiornare

$M$ $M$

L'idea di prova è semplice: supponiamo che potremmo fornire algoritmi veloci per tutte le matrici fino a una certa dimensione (ad esempio, distinguendo tutti i casi possibili). Dopo questa certa dimensione usiamo dividere e conquistare.

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

Conclusione: se è possibile utilizzare distinzioni di caso sulle matrici di input per derivare algoritmi veloci, è possibile migliorare la congettura di OMv.

— tranisstor
fonte

Come sottolineato da autore e vzn, questo non è il caso, il vettore non è binario, Matrix non è necessario N x N e l'autore vuole precalcolare le operazioni e non è necessario l'elaborazione online. Sulla base di congetture non è sufficiente. Entrambi i documenti sono irrilevanti da mettere in discussione. Il caso qui è quello di pre-calcolare la matrice costante per fornire un numero minimo di operazioni. Ci saranno possibili approcci diversi per casi completi, a bande e simmetrici.

— Evil

@EvilJS: se consenti qualsiasi matrice M x N e vettori a valore reale, allora il problema diventa più difficile di quello che ho dato nella risposta (ad esempio, la moltiplicazione booleana-matrice online vettoriale sarà un caso speciale). Se potessi risolvere il problema più generale veramente più velocemente di O (n ^ 3), allora miglioreresti anche la congettura (che sarebbe una grande novità!). Inoltre, l'autore afferma in un commento alla domanda che i vettori sono inizialmente sconosciuti. Se conoscessi in anticipo tutti i vettori, potresti semplicemente usare la moltiplicazione a matrice veloce (ad esempio una versione dell'algoritmo di Strassen).

— tranisstor,

Ho appena indicato il caso degli autori "vettore reale". Guarda la matrice di Thomas - solo caso speciale di matrici in O (n). Non implica un caso generale. E se Matrix è costante e si conoscono i vettori, la risposta hardcode non implementa Strassen; (

— Evil

@EvilJS: Non sono sicuro di aver capito completamente cosa stai cercando di dire. Certo, per tipi speciali di matrici come la matrice Thomas è possibile ottenere una notevole velocità, ma in generale è più difficile. Forse dovrei anche sottolineare che il problema che ho introdotto considera una fase di preelaborazione (prima che arrivi un vettore). Se potessi dirmi come "sistemare" sistematicamente il tuo algoritmo per qualsiasi matrice che ti do, potresti anche migliorare la congettura (dal momento che potresti implementare questa fase di hardcoding come fase di preelaborazione di un algoritmo).

— tranisstor,

concordato che funziona; tuttavia, il secondo riferimento di William non sembra prendere in considerazione le matrici binarie in particolare. a proposito, ha delle diapositive qui

— vzn,

-2

si tratta essenzialmente di CS a livello di ricerca, il problema è studiato in almeno due forme, una di moltiplicazione delle matrici sparse (esempio di carta appena citato) e anche il caso speciale delle "matrici binarie di sparse". 2 ^° caso è noto essere correlato all'ottimizzazione programmi rettilinei. programmi minimi possono anche essere come DAG con due tipi di "gate", addizione e moltiplicazione, quindi alcune pubblicazioni sulla minimizzazione dei circuiti potrebbero collegarsi a questo, e possibilmente il software "standard" potrebbe essere adattato allo scopo. ecco un ref specifica sul 2 ^° caso e anche la stessa domanda sul cstheory con qualche studio empirico di base iniziale.

— VZN
fonte

1

O (n)

$O(n)$

O (n^{2})

$O(n^2)$

i riferimenti sono attivi, come indicano i titoli, matrici sparse . forse hai una definizione diversa da quella sui giornali? se sei sensibile a una definizione esatta di scarsità (la maggior parte è approssimativamente correlata / quasi intercambiabile), dovrebbe essere indicato nella domanda.

— vzn,

1

Le matrici che mi interessano sono matrici dense. A proposito, anche se non penso che questo affronti completamente la mia domanda, apprezzo la risposta.

— Nick Alger,

ok scusa! si è confuso, non ha realizzato la domanda esatta. a prima vista il tuo esempio n. 2 ha meno di ½ riempimento e mi è sembrato "scarso" e ho pensato che parte della teoria sparsa sarebbe almeno in qualche modo applicabile. fondamentalmente più densa è la matrice, meno l'operazione può essere ottimizzata, quindi probabilmente la maggior parte della teoria su questo tipo di ottimizzazione è orientata attorno a matrici sparse.

— vzn,

-3

non sono sicuro che questo problema sia stato studiato esattamente ma questa ricerca è correlata e sembra un vantaggio ragionevole. esamina la decomposizione dell'ipergrafo per la moltiplicazione di matrici sparse. le matrici binarie sono un caso speciale di questo approccio. questo approccio troverà strategie più ottimali rispetto al metodo di moltiplicazione "diretto". ulteriori ottimizzazioni (all'interno di questo framework) potrebbero essere possibili in base alla proprietà della matrice binaria.

Decomposizione basata su hypergraph-Partitioning per moltiplicazione parallela a matrice sparsa / Umit Catalyurek e Cevdet Aykanat

— VZN
fonte

2

Non vedo cosa abbia a che fare con la domanda. Quel documento riguarda la partizione della moltiplicazione della matrice tra un sistema distribuito, per il calcolo parallelo, per ridurre al minimo la quantità di comunicazione tra processori. Cosa c'entra questo con questa domanda? La domanda non sembra menzionare nulla sul calcolo parallelo o sulla comunicazione tra processori. Ti incoraggio a modificare la tua risposta per rendere più esplicita la connessione.

— DW

afaik è lo stesso problema e minimizzare il calcolo parallelo minimizza anche l'implementazione di un singolo processore degli stessi calcoli. almeno, l'interrogante non ha escluso implementazioni parallele.

— vzn,

1

Grazie per il link. Tuttavia, sono scettico sul metodo per questo problema poiché non sfrutta il fatto che le voci della matrice contengono solo zeri e uno, mentre questa proprietà è molto importante, per quanto posso dire. Ad esempio, l'algoritmo "totale parziale" nel primo esempio funzionerà solo se tutte le voci diverse da zero in una determinata colonna della matrice hanno lo stesso valore.

— Nick Alger,

NA la tua osservazione / obiezione è indirizzata nella risposta. è probabilmente possibile un'ulteriore ottimizzazione usando la proprietà 0/1; questo metodo sembra minimizzare il numero totale di operazioni di addizione / moltiplicazione con il pretesto della parallelizzazione. le operazioni di addizione / moltiplicazione possono anche essere viste come "gate" in un DAG e la tecnica sta minimizzando i gate. la sostanziale complessità del documento rivela parte della complessità intrinseca più profonda / sostanziale di questo processo di ottimizzazione. come dichiarato, la risposta non intende essere definitiva su questo difficile problema, semplicemente "meglio di niente".

— vzn,