Discussion :

[preliator]

Bonjour,

Ayant acheté récemment un pc fixe relativement puissant (Processeur : Ryzen 3950x), je me rend compte que les programmes python que je lance n'utilisent que 5 à 10% du processeur.

Par exemple, avec ce code où je calcule toute les possibilité de combinaisons :

Code :

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

1
2
3
4
5
6
7
8
 
from itertools import combinations, combinations_with_replacement
 
 
comb = combinations(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'], 5)
 
for i in list(comb): 
    print(i)

Le temps d'attente est de 5 secondes. Je me demandais s'il existait un moyen d’utiliser plus de processus lors du lancement du programme ?

Merci.

[wiztricks]

Salut,

je me rend compte que les programmes python que je lance n'utilisent que 5 à 10% du processeur.

Avec 16 CPU disponibles, Python n'en utilisant qu'un seul, çà consomme environ 6% de la capacité.
Pour utiliser plus de CPU, il faut "paralléliser".
Ce qui passe par re-penser l'algorithme (et le code) pour exécuter une fraction des opérations sur chaque CPU.
Quand on a l'algo., côté Python, c'est assez facile a mettre en oeuvre avec les modules concurrent.futures et multiprocessing.

- W

[Invité]

Et sinon juste au passage, l'outil itertools.product produit toutes les combinaisons contrairement aux autres:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>>product('ABCD', repeat=2)
AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
 
>>>permutations('ABCD', 2)
AB AC AD BA BC BD CA CB CD DA DB DC
 
>>>combinations('ABCD', 2)
AB AC AD BC BD CD
 
>>>combinations_with_replacement('ABCD', 2)
AA AB AC AD BB BC BD CC CD DD

Tu veux calculer le nombre de combinaisons ou les obtenir ?

Et aussi je suis surpris par le temps nécessaire car moi avec product j'obtiens la liste des combinaisons en 0.068 secondes.

Code :

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

1
2
3
0.068  seconds
>>> r[0:10]
[['A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'B'], ['A', 'A', 'A', 'A', 'C'], ['A', 'A', 'A', 'A', 'D'], ['A', 'A', 'A', 'A', 'E'], ['A', 'A', 'A', 'A', 'F'], ['A', 'A', 'A', 'A', 'G'], ['A', 'A', 'A', 'A', 'H'], ['A', 'A', 'A', 'A', 'I'], ['A', 'A', 'A', 'A', 'J']]

Sinon voici la fonction que j'utilise:

Code :

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

1
2
3
4
5
def product(liste, repeat=1):
    pools = [liste] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]

Et qui peut-être décomposé comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
def product2(liste, repeat=1):
    pools = [liste] * repeat
    result = [[]]
    for pool in pools:
        nresult = []
        for x in result:
            for y in pool:
                nresult.append(x+[y])
        result = nresult

Par contre pour multiprocesser cette fonction, je n'ai aucune idée, jamais essayé... Et en réfléchissant ça me paraît compliqué car la fonction ci dessus créé déjà toutes les listes de [['A'],['B'],...['Z']] jusqu'à [['A','A','A','A','A'],...,['Z','Z','Z','Z','Z']] avant de retenir la dernière liste ci-avant.

[VinsS]

Salut,
5 secondes est pour le moins étonnant, je viens de tester sur une vielle machine cadencée à 2.3 GHz et qui rame parce que je lui impose deux écrans or le résultat est instantané.

[tyrtamos]

Bonjour,

Si on cherche le temps de calcul de la combinaison avec le 1er code, en utilisant "perf_counter" du module time:

Code :

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

1
2
3
4
5
6
7
8
9
10
from time import perf_counter
from itertools import combinations, combinations_with_replacement
 
t = perf_counter() 
comb = list(combinations(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'], 5))
t = perf_counter()-t
 
for i in comb: 
    print(i)
print(t)

On trouve environ... 3*10-5 secondes, soit 30 microsecondes. Ceci avec un PC Core i7 déjà ancien (plus de 5 ans).

Pour gagner en rapidité avec tous les cœurs du CPU, et pour autant que ça vaille encore le coup (!), il faudrait qu'on puisse modifier l'algorithme pour obtenir une liste de calculs ne dépendant pas les uns des autres, ce qui me parait difficile. Et il faut tenir compte du temps de gestion de ces calculs parallèles qui diminue un peu l'avantage théorique.

[Sve@r]

Bonjour

On trouve environ... 3*10-5 secondes, soit 30 microsecondes. Ceci avec un PC Core i7 déjà ancien (plus de 5 ans).

Moi ça me donne 100µs sur un portable datant d'à peu près la même période tournant sous xubuntu. Je l'avais pas pris foudre de guerre mais plutôt minimaliste juste pour mater des films quand je suis dans le train (là où je suis en ce moment) 1 processeur 1,6Ghz et 2Go de ram.
C'est pour ça que 5 secondes pour ce truc moi aussi ça m'étonne. Il faudrait en savoir plus sur l'OS du PC. Je subodore un W10 bien cafit de processus en tous sens d'autant plus gourmands qu'ils sont inutiles (et vas-y que je te mets cortana pour que dalle avec le service d'indexation qui te balaye tout les disques toutes les 15 secondes au cas où t'aurais besoin de chercher un fichier entre deux...)

[Invité]

@Sve@r

150µsec avec Windows 10 et IDLE

Rien à voir : Je trouve la recherche de fichier extrêmement longue sous Windows 10, faudrait que je programme un explorateur de fichiers en python tiens !