Discussion :

[Peter57]

Salut à tous !
J'ai testé un petit programme test (somme d'un cos + sin dans une boucle de 1 000 000 d'itérations) en Python, en Cython et enfin en 'C'.
le résultat est surprenant !
Quelque soit la fonction (j'ai testé un calcul de suite de Fibonacci), Python 3.13 est plus rapide que Cython ! le C quand à lui écrase tout le monde !
Avec n itérations = 1 000 000
fonction testée :

Code :

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

s+= cos(i) + sin(i)

Somme cython: -0.06
Durée : 0.209480 sec

Somme python: -0.06
Durée : 0.159361 sec

Somme C : -0.06
Duree: 0.011000 sec

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !
Bien cordialement.
Peter

[Peter57]

Personne n'a un avis sur l'utilisation de Cython ?

[wiztricks]

Personne n'a un avis sur l'utilisation de Cython ?

C'est un outil pour optimiser l'utilisation CPU/mémoire d'un code où on a déjà fait le nécessaire côté algorithme.
Si vous pensez que ça devrait apporter quelque chose et que le résultat n'est pas là, c'est que vous vous êtes planté quelque part sur la pertinence à utiliser cet outil dans ce cas particulier (et on attends toujours les détails de ce que vous avez fait).

note: cython ne date pas d'hier et ceux qui l'utilisent à bon escient en sont généralement satisfait.

- W

[Peter57]

voila le programme python -cython

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#
#   fichier main.py
#
 
from pyximport import install ; install()
import cython_fn
import time
import python_fn
 
#iterations
n = 1000000
 
# cal cython version
t0 = time.time()
sum_cython = cython_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme cython: {sum_cython:.2f}")
print(f"Durée : {t:.6f}")
 
# calc python version
t0 = time.time()
sum_python = python_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme python: {sum_python:.2f}")
print(f"Durée : {t:.6f}")
 
#
#   fichier cython_fn.pyx
#
# cython : language_Level = 3
 
import math
 
def cy_fibo(int n):
    cdef int a,b,i
 
    a , b = 1, 1
 
    for i in range(n):
        a, b = a+b, a
    return a
 
# version cython
def cos_calc(int n):
    cdef double s = 0.0
    cdef int i=0
 
    for i in range(n):
        s += (math.cos(i) + math.sin(i))
 
    return s
 
#
#   fichier python_fn.py
#
 
import math
 
def cos_calc(n : int):
    s = 0.0
    for i in range(n):
        s += math.cos(i) + math.sin(i)
    return s

[Peter57]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
// Cython vs Python
// C version
 
#include <stdio.h>
#include <time.h>
#include <math.h>
 
double cos_calc(int n) {
	double s = 0.0;
	for (int i = 0; i < n; i++) {
		s += (cos(i) + sin(i));
	}
	return s;
}
 
int main(){
	int n = 1000000;
	double s = 0.0;
 
	clock_t start = clock();
	s = cos_calc(n);
	clock_t end = clock();
 
	double duration = (double)(end - start) / CLOCKS_PER_SEC;
 
	printf("Somme: %.2f\n", s);
	printf("Duree: %.6f secondes\n", duration);
 
	return 0;
}

[Peter57]

Je concois que la bibliothèque 'Math' de Python 3.13 soit sans doute mieux optimisée que celle de Cython pour le calcul de cos() et sin').
Mais j'obtiens des résultats similaires avec le calcul d'une suite de Fibonacci avec l'algorithme non recursif.

[wiztricks]

Salut,

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !

Pour sortir ce genre d'affirmation, il faudrait un exemple plus significatif, un code montrant comment ont été obtenus ces résultats permettant de les reproduire au besoin.

- W

[fred1599]

Bonjour,

Peut-être aussi que vous comparez le temps d'exécution d'un code cpython (python déjà optimisé avec wrapper C) avec votre code cython (code C fait maison).
Ce temps pourrait être logique, mais pour vérifier, il nous faudra comme dit précédemment par mon VDD, le code !

[fred1599]

Hello,


Pour ce genre de problématique (hors le cas de la suite de Fibonacci qui est un problème itératif), la vectorisation est à mon sens une meilleure solution. Je vous recommande de regarder du côté de numpy.
Le souci principal vient du fait que votre code Cython n'est pas optimisé. Vous effectuez de nombreux allers-retours entre les types C et les objets Python, ce qui a forcément un coût en performance. La solution est de rester le plus possible dans les types C au sein de votre fonction Cython.
Pour cela, il faut utiliser les fonctions C de cosinus et sinus directement depuis la librairie mathématique C :

Code :

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

from libc.math cimport cos, sin

Ensuite, le code Cython peut être encore optimisé à l'aide de décorateurs (ou directives du compilateur) bien choisis qui évitent certaines vérifications de sécurité de Python (coûteuses en temps) :

Code :

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

1
2
3
4
5
6
7
import cython
 
 
@cython.boundscheck(False) # Désactive la vérification des bornes (utile si vous accédiez à un tableau)
@cython.wraparound(False)  # Désactive la gestion de l'indexation négative (ex: liste[-1])
def cos_calc(int n):
    # ... suite du code

Même après cette optimisation, le C pur sera probablement toujours un peu plus rapide. C'est normal, il n'y a aucune surcouche liée à l'interpréteur Python.

Pour conclure, au niveau des performances pour votre fonction cos_calc, numpy reste le meilleur choix. Avec Cython, vous écrivez une boucle for qui, bien que compilée en C, traite les éléments un par un. À l'inverse, numpy transforme cette boucle en une série d'appels à des fonctions C vectorisées, qui sont bien plus performantes pour les calculs sur de grands tableaux de données.