Optimisation automatisée de la multiplication vectorielle matricielle 0-1

22

Question:

Existe-t-il une procédure ou une théorie établie pour générer du code qui applique efficacement une multiplication matrice-vecteur, lorsque la matrice est dense et remplie uniquement de zéros et de uns? Idéalement, le code optimisé utiliserait systématiquement les informations précédemment calculées pour réduire le travail en double.

En d'autres termes, j'ai une matrice et je veux faire un pré-calcul basé sur , qui rendra le calcul de aussi efficace que possible lorsque je recevrai plus tard le vecteur . $M$ $M$ $Mv$ $v$

$M$ est une matrice binaire dense rectangulaire qui est connue au "moment de la compilation", alors que est un vecteur réel inconnu qui n'est connu qu'au "temps d'exécution". $v$

Exemple 1: (fenêtre coulissante)

Permettez-moi d'utiliser un petit exemple simple pour illustrer mon propos. Considérons la matrice, Supposons que nous appliquons cette matrice à un vecteur pour obtenir . Les entrées du résultat sont alors,

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

Faire une multiplication matrice-vecteur standard calculera exactement de cette façon. Cependant, une grande partie de ce travail est redondante. Nous pourrions faire le même calcul matriciel à moindre coût en gardant une trace d'un "total cumulé" et en ajoutant / soustrayant pour obtenir le nombre suivant:

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

Exemple 2: (structure hiérarchique)

Dans l'exemple précédent, nous pourrions simplement garder une trace d'un total cumulé. Cependant, il faudrait généralement créer et stocker un arbre de résultats intermédiaires. Par exemple, considérons On pourrait calculer efficacement en utilisant un arbre de résultats intermédiaires:

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$

Calculez $w_5$ et $w_7$ et ajoutez-les pour obtenir $w_3$ .
Calculez $w_4$ et $w_6$ et ajoutez-les pour obtenir $w_2$ .
Ajoutez et pour obtenir $w_2$ $w_3$ $w_1$

La structure dans les exemples ci-dessus est facile à voir, mais pour les matrices réelles qui m'intéressent, la structure n'est pas si simple.

Exemple 3: (bas rang)

Pour dissiper une certaine confusion, les matrices ne sont généralement pas clairsemées. Plus précisément, une méthode résolvant ce problème doit être en mesure de trouver des méthodes efficaces pour appliquer des matrices lorsque de grands blocs en sont remplis. Par exemple, considérez

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

Cette matrice peut être décomposée en une différence de deux matrices de rang 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}$

donc son action sur un vecteur peut être calculée efficacement par, $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}$

Motivation:

Je travaille sur une méthode numérique pour certains traitements d'image, et il existe plusieurs grandes matrices denses avec des structures différentes qui sont fixes pour toujours. Plus tard, ces matrices devront être appliquées à de nombreux vecteurs inconnus qui dépendront de l'entrée de l'utilisateur. À l'heure actuelle, j'utilise du papier et du crayon pour trouver du code efficace sur une base matricielle, mais je me demande si le processus peut être automatisé. $0-1$ $v_i$

Modifier: (postscript)

Jusqu'à présent, toutes les réponses (au 9/5/15) sont intéressantes, mais aucune ne répond à la question de manière aussi satisfaisante que je l'espérais. Il s'avère probablement que c'est une question de recherche difficile, et personne ne connaît une bonne réponse.

Depuis que le temps est écoulé, j'accorde la prime à la réponse d' EvilJS car elle répond à la bonne question. Cependant, je souhaite que la réponse contienne des explications plus claires et détaillées.

La réponse de tranisstor établit un lien entre cette question et le problème de multiplication matricielle-vectorielle en ligne (OMv), mais la connexion n'est pas exactement ce que cette question pose. En particulier, l'hypothèse suivante ne correspond pas vraiment (je souligne en gras),

Supposons maintenant que pour tout et toutes matrices $n \leq n_0$ $n \times n$ $M$ nous savons un algorithme , que pour tous les vecteurs calcule dans le temps vraiment subquadratic, soit en temps pour certains . $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$

Qu'il existe ou non des algorithmes sous-quadratiques pour toutes les matrices est orthogonal à la question de trouver un algorithme pour une matrice spécifique aussi rapide que possible. La plupart des matrices 0-1 ressemblent à du bruit aléatoire et (si je devais deviner) n'ont probablement pas d'algorithmes sous-quadratiques. Cependant, le fait qu'il y ait vraiment de mauvaises matrices là-bas ne m'empêche pas de trouver un algorithme rapide sur une bonne matrice, par exemple, une matrice de "fenêtre coulissante".

Les réponses de vzn, première réponse , deuxième réponse sont intéressantes (et à mon avis ne méritent pas autant de downvotes), mais elles ne s'appliquent pas à la question pour les raisons évoquées dans les commentaires.

linear-algebra matrices program-optimization

— Nick Alger
source

1

Si votre matrice est de cette forme, TDMA c'est la matrice de bande, algorithme de Thomas. Pas encore 0-1 mais cette fonctionnalité devrait être exploitée.

— Evil

@EvilJS la matrice se trouve juste être baguée pour l'exemple particulier. En général, il ne sera pas bagué. J'ai ajouté un autre exemple qui n'est pas bagué.

— Nick Alger

Vous avez beaucoup de matrices constantes N x M qui sont des vecteurs réels et binaires, et vous souhaitez précalculer le chemin d'exécution optimal pendant la phase de prétraitement par instance? La sortie d'une telle opération est du code avec des opérations codées en dur par matrice et vous voulez que la méthode le fasse? Par instance, je veux dire par matrice. Je vérifie.

— Evil

@EvilJS Cette question concerne la situation où il existe une matrice binaire connue , qui sera appliquée à de nombreux vecteurs réels inconnus ultérieurement. Sur la base de uniquement, nous souhaitons précalculer un code qui appliquera plus efficacement possible, afin que plus tard, lorsque nous recevrons le , nous puissions calculer plus rapidement possible. Dans l'application particulière qui motive cette question, j'ai une poignée de matrices binaires comme celle-ci (12 en fait) qui sont fixes pour toujours tandis que les vecteurs sont imprévisibles et dépendent de l'entrée de l'utilisateur du programme.

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

Sur le champ de deux éléments, le problème du calcul du circuit de porte XOR minimum qui simule une transformation linéaire donnée est NP-difficile. Voir cstheory.stackexchange.com/a/32272/225

— Ryan Williams

5

Si cela est possible, essayez d'exploiter la nature tridiagonale en bande de la matrice.
Sinon, si la matrice ne contient qu'un nombre constant de valeurs distinctes (ce qui est sûrement binaire), vous devriez essayer l'algorithme Mailman (par Edo Liberty, Steven W. Zucker dans le rapport technique de l'université de Yale # 1402): optimisé sur un dictionnaire fini
L'élimination de la sous-expression commune est connue depuis un certain temps comme la multiplication de constantes multiples, mais descendre au niveau de la porte est une option - les modèles utilisés ici peuvent être utilisés séparément comme solution ou fusionnés avec d'autres méthodes, le document pour cette "Amélioration de l'élimination de la sous-expression commune" Algorithm with A New Gate-Level Delay Computing Method "par Ning Wu, Xiaoqiang Zhang, Yunfei Ye et Lidong Lan publié dans" Actes du Congrès mondial d'ingénierie et d'informatique 2013 Vol II WCECS 2013, 23-25 octobre 2013, San Francisco, États-Unis " CSE au niveau de la porte

Il existe également une méthode brute mais fonctionnelle, pour générer une matrice symbolique avec des constantes, un vecteur avec des variables et le connecter à Static Single Assingment (SSA) à partir de compilateurs, qui automatise le processus d'écriture des matrices à la main.

nouveau prototype d'algorithme
Ce que vous avez fait avec l'exécution de la somme: Donne 10 opérations , et avec mon idée initiale d'utiliser Thomas, c'est équivalent. Pour l'instant, j'écris et teste toujours un nouvel algorithme, les temps d'exécution sont également méchants , mais le premier résultat du test m'a donné une réponse surprenante:

\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}$
Ce qui donne 9 opérations , en les définissant comme + ou - est 1, et = est 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}$

Cela donne 7 opérations , mon résultat d'algorithme a donné: Ce qui donne 6 opérations Pour l'instant je peux dire que j'utilise la distance de Hamming, & et | opérations au niveau du bit, comptage des utilisations et création de quelque chose comme Cocke – Younger – Kasami (CYK) - "un algorithme d'analyse pour les grammaires sans contexte, du nom de ses inventeurs, John Cocke, Daniel Younger et Tadao Kasami. Il utilise l'analyse ascendante et la dynamique programmation." - de Wikipedia C'est la même technique que j'utilise pour construire des blocs 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
source

(re rev5) plz donne ref sur "evergreen method". aussi, qu'est-ce que l'ASS? Algorithme dynamique CYK?

— vzn

J'ai attribué la prime à cette réponse et expliqué pourquoi dans une modification de ma question d'origine.

— Nick Alger

8

Ceci est lié à une question de recherche ouverte, connue sous le nom de «problème de multiplication matricielle booléenne en ligne (OMv)». Ce problème se lit comme suit (voir [1]): Étant donné une matrice binaire et vecteurs de colonnes binaires , nous devons calculer avant l'arrivée de . $n \times n$ $M$ $n$ $v_1, \dots, v_n$ $M v_i$ $v_{i+1}$

Notez que le problème de la question est un peu plus général: il autorise matrices et vecteurs à valeur réelle. Observez que le problème avec matrices et vecteurs booléens est "plus facile", car il présente un cas particulier. $m \times n$ $n \times n$

De toute évidence, l'algorithme naïf pour le problème de multiplication booléenne matricielle-vectorielle (qui utilise uniquement la multiplication matricielle-vecteur standard) prend le temps . Il y a une conjecture (voir par exemple [1]) que cela ne peut pas être fait vraiment plus rapidement que . (Plus en détail, cette conjecture est la suivante: il n'existe pas d'algorithme vraiment sous-cubique, qui résout le problème de multiplication matricielle-booléenne en ligne, c'est-à-dire qu'il n'y a pas d'algorithme avec le temps d'exécution pour ). $O(n^3)$ $O(n^3)$ $O(n^{3 - \varepsilon})$ $\varepsilon > 0$

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

Ce serait une percée dans le domaine des limites inférieures conditionnelles, si l'on pouvait prouver ou infirmer la conjecture ci-dessus.

[1] Unification et renforcement de la dureté pour les problèmes dynamiques via une conjecture de multiplication matrice-vecteur en ligne. par Henzinger, Krinninger, Nanongkai et Saranurak
[ http://eprints.cs.univie.ac.at/4351/1/OMv_conjecture.pdf ]

[2] Multiplication matrice-vecteur en temps sub-quadratique: (certains prétraitements sont nécessaires). par Williams
[ http://dl.acm.org/citation.cfm?id=1283383.1283490 ]

Mise à jour

$M$ $M$

L'idée de preuve est simple: supposons que nous pourrions donner des algorithmes rapides pour toutes les matrices jusqu'à une certaine taille (par exemple en distinguant tous les cas possibles). Après cette certaine taille, nous utilisons la division et la conquête.

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

Conclusion: Si vous pouviez utiliser des distinctions de casse sur les matrices d'entrée pour dériver des algorithmes rapides, alors vous pourriez améliorer la conjecture OMv.

— tranisstor
source

Comme l'ont souligné l'auteur et vzn, ce n'est pas le cas, le vecteur n'est pas binaire, la matrice n'est pas nécessaire N x N, et l'auteur veut précalculer les opérations, et il n'y a pas besoin de traitement en ligne. La conjecture ne suffit pas. Les deux documents ne sont pas pertinents pour questionner. Le cas ici est de précalculer une matrice constante pour fournir un nombre minimal d'opérations. Il y aura différentes approches possibles pour les cas symétriques complets et en bandes.

— Evil

@EvilJS: Si vous autorisez n'importe quelle matrice M x N et des vecteurs à valeur réelle, alors le problème devient juste plus difficile que celui que j'ai donné dans la réponse (c'est-à-dire que la multiplication matricielle-vectorielle booléenne en ligne sera un cas spécial). Si vous pouviez résoudre le problème plus général vraiment plus rapidement que O (n ^ 3), alors vous amélioreriez également la conjecture (ce qui serait une grande nouvelle!). De plus, l'auteur dit dans un commentaire à la question que les vecteurs sont initialement inconnus. Si vous connaissiez tous les vecteurs à l'avance, vous pouvez simplement utiliser une multiplication matricielle rapide (par exemple une version de l'algorithme de Strassen).

— tranisstor

Je viens de pointer le cas des auteurs "vrai vecteur". Regardez la matrice de Thomas - seul cas spécial de matrices dans O (n). Je n'implique pas de cas général. Et si la matrice est constante et que les vecteurs sont connus, vous répondez en code dur et n'implémentez pas Strassen; (

— Evil

@EvilJS: Je ne suis pas sûr de bien comprendre ce que vous essayez de dire. Bien sûr, pour des types spéciaux de matrices comme la matrice de Thomas, vous pouvez obtenir une accélération significative, mais en général, c'est plus difficile. Peut-être devrais-je également souligner que le problème que j'ai introduit considère une étape de prétraitement (avant l'arrivée de tout vecteur). Si vous pouviez me dire comment «coder en dur» systématiquement votre algorithme pour n'importe quelle matrice que je vous donne, vous pourriez également améliorer la conjecture (puisque vous pourriez implémenter cette étape de codage en dur comme étape de prétraitement d'un algorithme).

— tranisstor

convenu que cela fonctionne; cependant la 2ème référence par williams ne semble pas du tout considérer les matrices binaires en particulier. fyi il a des diapositives ici

— vzn

-2

il s'agit essentiellement d'un CS de niveau recherche, le problème est étudié sous au moins deux aspects, l'un de la multiplication de matrices clairsemées (document d'exemple qui vient d'être cité), et le cas particulier des "matrices binaires clairsemées" est également étudié. le 2 ^ème cas est connu pour être lié à l'optimisation des programmes en ligne droite. les programmes minimaux peuvent également être comme des DAG avec deux types de «portes», l'addition et la multiplication, de sorte que certains documents de minimisation des circuits peuvent s'y connecter, et éventuellement un logiciel «standard» pourrait être adapté à cet effet. voici une référence spécifique sur le 2 ^e cas et aussi la même question sur la théorie avec une étude empirique initiale de base.

— vzn
source

1

O (n)

$O(n)$

O (n^{2})

$O(n^2)$

les références sont, comme l'indiquent les titres, des matrices clairsemées . peut-être avez-vous une définition différente de celle des journaux? si vous êtes sensible à une définition exacte de la rareté (la plupart sont à peu près corrélés / presque interchangeables), cela devrait être indiqué dans la question.

— vzn

1

Les matrices qui m'intéressent sont des matrices denses. Soit dit en passant, même si je ne pense pas que cela réponde pleinement à ma question, j'apprécie la réponse.

— Nick Alger

D'accord désolé! s'est mélangé, n'a pas réalisé la question exacte. à première vue, votre exemple n ° 2 a moins de ½ remplissage et m'a paru "clairsemé" et s'est dit qu'une partie de la théorie clairsemée serait au moins assez applicable. fondamentalement, plus la matrice est dense, moins l'opération peut être optimisée, donc la plupart des théories sur ce type d'optimisation sont probablement orientées autour de matrices clairsemées.

— vzn

-3

Je ne sais pas si ce problème a été étudié exactement, mais cette recherche est liée et semble une piste / un début raisonnable. il examine la décomposition hypergraphe pour la multiplication matricielle clairsemée. les matrices binaires sont un cas particulier de cette approche. cette approche trouvera des stratégies plus optimales que la méthode de multiplication "droite". d'autres optimisations (dans ce cadre) pourraient être possibles sur la base de la propriété de matrice binaire.

Décomposition basée sur le partitionnement hypergraphique pour la multiplication vectorielle parallèle à matrice creuse / Umit Catalyurek et Cevdet Aykanat

— vzn
source

2

Je ne vois pas ce que cela a à voir avec la question. Cet article traite de la multiplication de la matrice de partitionnement dans un système distribué, pour le calcul parallèle, afin de minimiser la quantité de communication entre processeurs. Qu'est-ce que cela a à voir avec cette question? La question ne semble rien mentionner du calcul parallèle ou de la communication interprocesseur. Je vous encourage à modifier votre réponse pour rendre la connexion plus explicite.

— DW

afaik c'est le même problème et minimiser le calcul parallèle minimise également une implémentation de processeur unique des mêmes calculs. au moins, le questionneur n'a pas exclu les implémentations parallèles.

— vzn

1

Merci pour le lien. Cependant, je suis sceptique quant à la méthode utilisée pour résoudre ce problème car elle ne tire pas parti du fait que les entrées de matrice ne contiennent que des zéros et des uns, alors que cette propriété est très importante, pour autant que je sache. Par exemple, l'algorithme "total cumulé" du premier exemple ne fonctionnera que si toutes les entrées non nulles d'une colonne donnée de la matrice ont la même valeur.

— Nick Alger

NA votre observation / objection est traitée dans la réponse. une optimisation plus poussée est probablement possible en utilisant la propriété 0/1; cette méthode semble minimiser le nombre total d'opérations d'addition / multiplication sous couvert de parallélisation. les opérations d'addition / multiplication peuvent également être considérées comme des "portes" dans un DAG et la technique minimise les portes. la complexité substantielle du papier révèle une partie de la complexité intrinsèque plus profonde / substantielle de ce processus d'optimisation. car la réponse indiquée n'est pas destinée à être définitive sur ce problème difficile, juste "mieux que rien".

— vzn