Multiplications matricielles multiples avec Numpy

1. Variante: joli code mais lit toutes les matrices en même temps

matrixFileCount = 3
matrices = [np.loadtxt(open("matrix%s.txt" % i ), delimiter=",", skiprows=1) for i in range(1,matrixFileCount+1)]
allC = itertools.combinations([x for x in range(matrixFileCount)], 2)
allCMultiply = [np.dot(matrices[c[0]], matrices[c[1]]) for c in allC]
print  allCMultiply

2. Variante: ne chargez que 2 fichiers à la fois, beau code mais beaucoup de rechargement

allCMulitply = []
fileList = ["matrix%s.txt" % x for x in range(1,matrixFileCount+1)]
allC = itertools.combinations(fileList, 2)
for c in allC:
    m = [np.loadtxt(open(file), delimiter=",", skiprows=1) for file in c]
    allCMulitply.append(np.dot(m[0], m[1]))
print allCMulitply

3. Variante: comme la seconde mais évitez de charger à chaque fois. Mais seulement 2 matrices à un moment donné dans la mémoire

Parce que les permutations créées avec itertools sont comme (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), vous pouvez éviter parfois de charger les deux matrices.

matrixFileCount = 3
allCMulitply = []
mLoaded = {'file' : None, 'matrix' : None}
fileList = ["matrix%s.txt" % x for x in range(1,matrixFileCount+1)]
allC = itertools.combinations(fileList, 2)
for c in allC:
    if c[0] is mLoaded['file']:
        m = [mLoaded['matrix'], np.loadtxt(open(c[1]), delimiter=",", skiprows=1)]
    else:
        mLoaded = {'file' : None, 'matrix' : None}
        m = [np.loadtxt(open(file), delimiter=",", skiprows=1) for file in c]
    mLoaded = {'file' : c[0], 'matrix' : m[0]}
    allCMulitply.append(np.dot(m[0], m[1]))
print allCMulitply

Performances

Si vous pouvez charger toutes les matrices en même temps dans la mémoire, la première partie est plus rapide que la seconde, car dans la seconde, vous rechargez beaucoup les matrices. La troisième partie est plus lente que la première, mais plus rapide que la seconde, car elle évite parfois de recharger les matrices.

0.943613052368 (Part 1: 10 Matrices a 2,2 with 1000 executions)
7.75622487068  (Part 2: 10 Matrices a 2,2 with 1000 executions)
4.83783197403  (Part 3: 10 Matrices a 2,2 with 1000 executions)

La réponse de Kordi charge toutes les matrices avant de faire la multiplication. Et c'est très bien si vous savez que les matrices vont être petites. Si vous souhaitez conserver la mémoire, cependant, je ferais ce qui suit:

import numpy as np

def get_dot_product(fnames):
    assert len(fnames) > 0
    accum_val = np.loadtxt(fnames[0], delimiter=',', skiprows=1)
    return reduce(_product_from_file, fnames[1:], initializer=accum_val)

def _product_from_file(running_product, fname):
    return running_product.dot(np.loadtxt(fname, delimiter=',', skiprows=1))

Si les matrices sont grandes et de forme irrégulière (non carrées), il existe également des algorithmes d'optimisation pour déterminer les groupements associatifs optimaux (c'est-à-dire où placer les parenthèses), mais dans la plupart des cas, je doute que cela en vaille la peine. décharger chaque fichier deux fois, une fois pour comprendre les regroupements associatifs, puis une fois pour le réaliser. NumPy est étonnamment rapide même sur de très grandes matrices.

Que diriez-vous d'une solution vraiment simple en évitant map, reduce et autres? L'objet tableau numpy par défaut effectue une multiplication par élément par défaut.

size = (197, 11)

result = numpy.ones(size)
for i in range(1, 651):
    result *= numpy.loadtext(open("matrix{}.txt".format(i), "rb"),
                             delimiter=",", skiprows=1)