Które jest szybsze w Pythonie: x **. 5 lub math.sqrt (x)?

Zastanawiam się nad tym od jakiegoś czasu. Jak mówi tytuł, która jest szybsza, rzeczywista funkcja lub po prostu podniesienie do połowy mocy?

AKTUALIZACJA

Nie jest to kwestia przedwczesnej optymalizacji. Jest to po prostu pytanie o to, jak faktycznie działa podstawowy kod. Jaka jest teoria działania kodu Python?

Wysłałem Guido van Rossumowi wiadomość e-mail, ponieważ naprawdę chciałem poznać różnice w tych metodach.

Mój e-mail:

Istnieją co najmniej 3 sposoby wykonania pierwiastka kwadratowego w Pythonie: math.sqrt, operator „**” i pow (x, .5). Jestem ciekawy różnic we wdrażaniu każdego z nich. Jeśli chodzi o wydajność, która jest lepsza?

Jego odpowiedź:

pow i ** są równoważne; math.sqrt nie działa dla liczb zespolonych i łączy z funkcją C sqrt (). Co do tego, który jest szybszy, nie mam pojęcia ...

math.sqrt(x)jest znacznie szybszy niż x**0.5.

import math
N = 1000000

%%timeit
for i in range(N):
    z=i**.5

10 pętli, najlepiej 3: 156 ms na pętlę

%%timeit
for i in range(N):
    z=math.sqrt(i)

10 pętli, najlepiej 3: 91,1 ms na pętlę

Korzystanie z Python 3.6.9 ( notebook ).

• pierwsza zasada optymalizacji: nie rób tego
• Druga zasada: nie rób tego , jeszcze

Oto niektóre czasy (Python 2.5.2, Windows):

$ python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
1000000 loops, best of 3: 0.445 usec per loop

$ python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
1000000 loops, best of 3: 0.574 usec per loop

$ python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
1000000 loops, best of 3: 0.727 usec per loop

Ten test pokazuje, że x**.5jest nieco szybszy niż sqrt(x).

W przypadku Python 3.0 wynik jest odwrotny:

$ \Python30\python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
1000000 loops, best of 3: 0.803 usec per loop

$ \Python30\python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
1000000 loops, best of 3: 0.695 usec per loop

$ \Python30\python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
1000000 loops, best of 3: 0.761 usec per loop

math.sqrt(x)jest zawsze szybszy niż x**.5na innym komputerze (Ubuntu, Python 2.6 i 3.1):

$ python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
10000000 loops, best of 3: 0.173 usec per loop
$ python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
10000000 loops, best of 3: 0.115 usec per loop
$ python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
10000000 loops, best of 3: 0.158 usec per loop
$ python3.1 -mtimeit -s"from math import sqrt; x = 123" "x**.5"
10000000 loops, best of 3: 0.194 usec per loop
$ python3.1 -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
10000000 loops, best of 3: 0.123 usec per loop
$ python3.1 -mtimeit -s"import math; x = 123" "math.sqrt(x)"
10000000 loops, best of 3: 0.157 usec per loop

Ile pierwiastków kwadratowych faktycznie wykonujesz? Czy próbujesz napisać silnik graficzny 3D w Pythonie? Jeśli nie, to po co stosować kod, który jest tajemniczy, a nie łatwy do odczytania? Różnica czasu byłaby mniejsza niż ktokolwiek mógłby zauważyć w prawie każdej aplikacji, którą mogłem przewidzieć. Naprawdę nie zamierzam stawiać pytania, ale wydaje się, że posuwasz się trochę za daleko z przedwczesną optymalizacją.

W tych mikro-testach math.sqrtbędzie wolniejszy, ze względu na krótki czas potrzebny na wyszukiwanie sqrtw przestrzeni nazw matematyki. Możesz to nieco poprawić za pomocą

 from math import sqrt

Nawet wtedy, uruchamiając kilka odmian w czasie, wykazują niewielką (4-5%) przewagę wydajności x**.5

Co ciekawe, robi

 import math
 sqrt = math.sqrt

przyspieszyłem to jeszcze bardziej, do różnicy prędkości w granicach 1%, z bardzo małym znaczeniem statystycznym.

Powtórzę Kibbee i powiem, że jest to prawdopodobnie przedwczesna optymalizacja.

W Pythonie 2.6 (float).__pow__() funkcja używa funkcji C, pow()a math.sqrt()funkcje używają sqrt()funkcji C.

W kompilatorze glibc implementacja pow(x,y)jest dość złożona i jest dobrze zoptymalizowana dla różnych wyjątkowych przypadków. Na przykład wywołanie C pow(x,0.5)po prostu wywołuje sqrt()funkcję.

Różnica w prędkości używania .**lub math.sqrtjest spowodowana przez owijarki używane wokół funkcji C, a prędkość silnie zależy od flag optymalizacji / kompilatora C używanych w systemie.

Edytować:

Oto wyniki algorytmu Claudiu na mojej maszynie. Mam inne wyniki:

zoltan@host:~$ python2.4 p.py 
Took 0.173994 seconds
Took 0.158991 seconds
zoltan@host:~$ python2.5 p.py 
Took 0.182321 seconds
Took 0.155394 seconds
zoltan@host:~$ python2.6 p.py 
Took 0.166766 seconds
Took 0.097018 seconds

Za to, co jest warte (patrz odpowiedź Jima). Na moim komputerze działającym w Pythonie 2.5:

PS C:\> python -m timeit -n 100000 10000**.5
100000 loops, best of 3: 0.0543 usec per loop
PS C:\> python -m timeit -n 100000 -s "import math" math.sqrt(10000)
100000 loops, best of 3: 0.162 usec per loop
PS C:\> python -m timeit -n 100000 -s "from math import sqrt" sqrt(10000)
100000 loops, best of 3: 0.0541 usec per loop

używając kodu Claudiu, na mojej maszynie nawet z „z matematyki import sqrt” x **. 5 jest szybszy, ale użycie psyco.full () sqrt (x) staje się znacznie szybszy, przynajmniej o 200%

Najprawdopodobniej math.sqrt (x), ponieważ jest zoptymalizowany pod kątem kwadratowego rootowania.

Benchmarki zapewnią odpowiedź, której szukasz.

Ktoś skomentował „szybki pierwiastek kwadratowy Newtona-Raphsona” z Quake 3 ... Zaimplementowałem go z ctypami, ale jest on bardzo wolny w porównaniu z wersjami natywnymi. Wypróbuję kilka optymalizacji i alternatywnych implementacji.

from ctypes import c_float, c_long, byref, POINTER, cast

def sqrt(num):
 xhalf = 0.5*num
 x = c_float(num)
 i = cast(byref(x), POINTER(c_long)).contents.value
 i = c_long(0x5f375a86 - (i>>1))
 x = cast(byref(i), POINTER(c_float)).contents.value

 x = x*(1.5-xhalf*x*x)
 x = x*(1.5-xhalf*x*x)
 return x * num

Oto inna metoda wykorzystująca struct, wychodzi około 3,6x szybciej niż wersja ctypes, ale nadal 1/10 prędkości C.

from struct import pack, unpack

def sqrt_struct(num):
 xhalf = 0.5*num
 i = unpack('L', pack('f', 28.0))[0]
 i = 0x5f375a86 - (i>>1)
 x = unpack('f', pack('L', i))[0]

 x = x*(1.5-xhalf*x*x)
 x = x*(1.5-xhalf*x*x)
 return x * num

Wyniki Claudiu różnią się od moich. Używam Python 2.6 na Ubuntu na starej maszynie P4 2.4Ghz ... Oto moje wyniki:

>>> timeit1()
Took 0.564911 seconds
>>> timeit2()
Took 0.403087 seconds
>>> timeit1()
Took 0.604713 seconds
>>> timeit2()
Took 0.387749 seconds
>>> timeit1()
Took 0.587829 seconds
>>> timeit2()
Took 0.379381 seconds

sqrt jest dla mnie konsekwentnie szybszy ... Nawet Codepad.org NOW wydaje się zgadzać, że sqrt, w kontekście lokalnym, jest szybszy ( http://codepad.org/6trzcM3j ). Wygląda na to, że Codepad obecnie działa w Pythonie 2.5. Być może używali wersji 2.4 lub starszej, kiedy Claudiu po raz pierwszy odpowiedział?

W rzeczywistości, nawet używając math.sqrt (i) zamiast arg (i), wciąż mam lepsze czasy dla sqrt. W tym przypadku timeit2 () zajął na mojej maszynie od 0,53 do 0,55 sekundy, co wciąż jest lepsze niż 0,56-0,60 z timeit1.

Powiedziałbym, że we współczesnym Pythonie użyj math.sqrt i zdecydowanie przenieś go do lokalnego kontekstu, albo somevar = math.sqrt, albo z matematycznego importu sqrt.

Pythoniczną rzeczą, którą należy zoptymalizować, jest czytelność. W tym celu uważam, że sqrtnajlepiej jest użyć tej funkcji. To powiedziawszy, i tak zbadajmy wydajność.

Zaktualizowałem kod Claudiu dla Pythona 3, a także uniemożliwiłem optymalizację obliczeń (coś, co dobry kompilator Pythona może zrobić w przyszłości):

from sys import version
from time import time
from math import sqrt, pi, e

print(version)

N = 1_000_000

def timeit1():
  z = N * e
  s = time()
  for n in range(N):
    z += (n * pi) ** .5 - z ** .5
  print (f"Took {(time() - s):.4f} seconds to calculate {z}")

def timeit2():
  z = N * e
  s = time()
  for n in range(N):
    z += sqrt(n * pi) - sqrt(z)
  print (f"Took {(time() - s):.4f} seconds to calculate {z}")

def timeit3(arg=sqrt):
  z = N * e
  s = time()
  for n in range(N):
    z += arg(n * pi) - arg(z)
  print (f"Took {(time() - s):.4f} seconds to calculate {z}")

timeit1()
timeit2()
timeit3()

Wyniki są różne, ale przykładowy wynik to:

3.6.6 (default, Jul 19 2018, 14:25:17) 
[GCC 8.1.1 20180712 (Red Hat 8.1.1-5)]
Took 0.3747 seconds to calculate 3130485.5713865166
Took 0.2899 seconds to calculate 3130485.5713865166
Took 0.2635 seconds to calculate 3130485.5713865166

Spróbuj sam.

Problem , który ostatnio rozwiązałem SQRMINSUM , wymaga wielokrotnego obliczania pierwiastka kwadratowego w dużym zbiorze danych. Najstarsze 2 zgłoszenia w mojej historii , zanim dokonałem innych optymalizacji, różnią się jedynie zastąpieniem ** 0,5 sqrt (), zmniejszając w ten sposób czas działania z 3,74 s do 0,51 s w PyPy. Jest to prawie dwukrotność już i tak ogromnej 400% poprawy, którą zmierzył Claudiu.

Oczywiście, jeśli mamy do czynienia z literałami i potrzebujemy stałej wartości, środowisko wykonawcze Python może wstępnie obliczyć wartość w czasie kompilacji, jeśli jest napisana z operatorami - w tym przypadku nie trzeba profilować każdej wersji:

In [77]: dis.dis(a)                                                                                                                       
  2           0 LOAD_CONST               1 (1.4142135623730951)
              2 RETURN_VALUE

In [78]: def a(): 
    ...:     return 2 ** 0.5 
    ...:                                                                                                                                  

In [79]: import dis                                                                                                                       

In [80]: dis.dis(a)                                                                                                                       
  2           0 LOAD_CONST               1 (1.4142135623730951)
              2 RETURN_VALUE

Byłoby jeszcze szybciej, gdybyś wszedł na math.py i skopiował funkcję „sqrt” do swojego programu. Twój program potrzebuje czasu na znalezienie pliku math.py, a następnie jego otwarcie, znalezienie funkcji, której szukasz, a następnie przywrócenie jej do programu. Jeśli ta funkcja jest szybsza nawet po wykonaniu kroków „wyszukiwania”, to sama funkcja musi być strasznie szybka. Prawdopodobnie skrócisz czas o połowę. W podsumowaniu:

1. Przejdź do math.py
2. Znajdź funkcję „sqrt”
3. Skopiuj to
4. Wklej funkcję do swojego programu jako wyszukiwarkę sqrt.
5. Czas to.