Discussion :

[Panthère Bleue]

Bonjour bonjour,

Voilà l'histoire : je suis en cours de finalisation d'un prog Python, et j'essaie entre autres de gagner du temps sur l'exécution.
Or une fonction particulière de mon programme prend beaucoup de temps, et j'ose suputer qu'il existe un moyen détourné plus rapide d'arriver à mes fins!

Voilà la bête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
import numarray as n

def miseEchelle(entree, long, moy):
sortie = list()
for i in range(0, long, moy):
    sortie.append ( n.average ( entree[i:i + moy - 1] ) )     
return n.array(sortie, 'Float32')

Comme c'est écrit, le but de la fonction est de mettre à l'échelle une image. La fonction s'applique à une ligne de 15000, 20000, 40000 pixels, le pas de moyennage est en général de 30, et l'image compte 800 lignes... ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for i in range(800):
    # lecture d'une ligne
    ligne_moy = miseEchelle(ligne, 20000, 30)
    # ecriture de ligne_moy

Tout est simplifié bien sûr. La boucle prend chez moi environ 100 s (j'utilise déjà psyco, et oui l'ordi est vieux!! ) et a priori à cause de average.

Bon... quelqu'un est inspiré?

[Guigui_]

Quelques optimisations rapides:
Toujours penser au variable locale quand on utilise une boucle for

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
import numarray as n
 
def miseEchelle(entree, long, moy):
    sortie = list()
    sortieappend = sortie.append
    naverage = n.average
    moy1 = moy-1
    for i in range(0, long, moy):
        sortieappend ( naverage ( entree[i:i + moy1] ) )     
    return n.array(sortie, 'Float32')

[Panthère Bleue]

Oki
J'teste ça demain, je donnerai les résultats en direct live.

Mais je pensais que l'économie de variables était souvent importante... ça gêne pas d'en déclarer plein comme ça?

------
Note : oui, ouiiiii, je ne suis pas très fort en prog... mais 'm'en sors quand même!

[Guigui_]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for i in range(800):
    # lecture d'une ligne
    ligne_moy = miseEchelle(ligne, 20000, 30)
    # ecriture de ligne_moy

Est-ce que ligne est modifié dans la boulce for parce que sinon, tu fais 800 fois la même chose (donc autant le sortir de la boucle) ?

L'économie de variable peut être intéressante lorsque tu utilises des objets d'une même classe en grandes quantité (donc moins il possède d'attribut moins la place en mémoire sera importante). Sinon, cela n'a pas trop d'importance.

[Panthère Bleue]

Oui, oui... mais toutes ces réflexions me font penser que mon code est peut etre bien plus maladroit que je n'le pensais.

La boucle ressemble plus à ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
flu = open('c:/fichier_a', 'rb')
fecrit = open('c:/fichier_b', 'ab')

for i in range(800):
    ecritureLigne( fecrit, miseEchelle( lectureLigne(flu), 20000, 30 ) )

# fermeture de flu et fecrit.

Pendant toute la boucle, les fichiers restent ouverts. Les lignes sont prises une à une, mises à l'échelle (en réalité, il y a 2 autres opérations avant la mise à l'échelle mais je simplifie...) puis écrites les unes à la suite des autres dans le fichier de sortie.

Comme toutes les lignes de l'image sont distinctes, ligne est différent à chaque itération. C'est bien ça que tu demandais?... sinon, j'vais attendre demain, j'aurais les idées plus claires.

Merci en tout cas de réfléchir avec moi là dessus, c'est instructif!

[Panthère Bleue]

Alors j'ai fait plusieurs essais :
a - en appliquant tes conseils,
b - en utilisant psyco,
c - en remplaçant average par un moyennage bidouillé

Je calcule le temps d'exécution en enregistrant time.localtime() au début et à la fin et en soustrayant les 2. Les essais sont réalisés dans les mêmes conditions : aucune autre fenêtre ouverte que la console windows où le programme tourne.

1. a : 162s
2. a + b : 115s
3. b : 121s
4. a+c : 116s
5. c: 115s
6. b+c : 94s

Bon, voilà. Ce n'est pas d'une précision folle, mais suffisante pour se rendre compte que average prend énormément de temps...
En remplaçant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

numarray.average(a)

par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sum(a) / float(len(a))

le résultat est identique. Mais le temps d'exécution est moins long dans le 2e cas... hum. Je vais aller étudier la méthode average, c'est vraiment bizarre.

[pop_up]

bonjour,

trés interressante cette discussion.
et sinon, a tu essayer de stocker tes lignes dans une variable et de ne faire que l'ouverture du fichier une fois le calcul terminé ?

juste pour savoir car je ne suis pas sur que tu y gagnes du temps.

[Guigui_]

le résultat est identique. Mais le temps d'exécution est moins long dans le 2e cas... hum. Je vais aller étudier la méthode average, c'est vraiment bizarre.

Attention, average n'a pas été conçue pour faire des moyennes simples mais des moyennes quantifiées

average(x, axis=0, weights=None, returned=0)

Donc forcément, ce n'est pas optimisée pour ce que tu veux faire (et surtout si tu l'exécute beaucoup de fois)
préfère alors la fonction mean() qui fait une moyenne simple et qui devrait être beaucoup plus rapide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
import numarray as n
 
def miseEchelle(entree, long, moy):
    sortie = list()
    sortieappend = sortie.append
    moy1 = moy-1
    for i in range(0, long, moy):
        sortieappend (entree[i:i + moy1].mean() )     
    return n.array(sortie, 'Float32')

[Panthère Bleue]

pop_up, je n'ai pas essayé de stocker les données traitées avant d'ouvrir le fichier en écriture. Je ne suis pas sûr que ce soit vraiment bénéfique... mais là pour aujourd'hui j'ai un peu la flemme d'essayer.

Guigui, j'ai tenté le coup avec mean() mais... les calculs sont plus lents qu'avec average!
Pour des conditions identiques :

1. mean : 130s
2. average : 113s
3. sum: 97s

C'est vrai que average est prévu pour des moyennes pondérées, sur des tableaux multidimensionnels en plus, alors que je n'ai que des lignes.
Pour mean, j'ai du mal à comprendre... la méthode se résume à prendre sum et à diviser par nelements.
En prenant sum et en divisant par float(len()), comme je fais, c'est carrément plus rapide.
Bah...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
import numarray as n
 
def miseEchelle(entree, long, moy):
    sortie = list()
    for i in range(0, long, moy):
        sortie.append (sum(entree[i:i + moy - 1]) / float(moy) )     
    return n.array(sortie, 'Float32')

Note : la déclaration des variables locales sortieappend et moy1 n'accélère pas toujours le calcul, parfois ça prend même 1s de plus...