2. 程式人生 > >python numpy numba 計算速度對比

python numpy numba 計算速度對比

阿新 • • 發佈：2019-01-07 
#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-05 17:59
# Author : DARREN
# Describe : not set
# Email : [email protected]
#####################################
from __future__ import division
from
 
 __future__ import print_function

import numpy as np
from timeit import Timer
from numba import jit

def python_list(n):
    a = range(n)
    b = range(n)
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])
    return c

@jit
def python_list_with_numba
 
(n):
#   a = range(n)
#   b = range(n)
#   c = []
#   for i in range(len(a)):
#       a[i] = i ** 2
#       b[i] = i ** 3
#       c.append(a[i] + b[i])
#   return c
    return python_list(n)

def numpy_vector(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@jit
def numpy_vector_with_numba
 
(n):
#   x = np.arange(n)
#   y = np.arange(n)
#   z = x**2 + y**3
#   return z
    return numpy_vector(n)


if __name__ == '__main__':
    t1 = Timer('python_list(1000000)','from __main__ import python_list')
    t2 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t3 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t4 = Timer('numpy_vector(1000000)','from __main__ import numpy_vector')
    t5 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')
    t6 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')

    take_time1 = t1.timeit(50)
    take_time2 = t2.timeit(50)
    take_time3 = t3.timeit(50)
    take_time4 = t4.timeit(50)
    take_time5 = t5.timeit(50)
    take_time6 = t6.timeit(50)

    print("python list:%s" % take_time1)
    print("python list with numba comp:%s" % take_time2)
    print("python list with numba after comp:%s" % take_time3)
    print("numpy vector:%s" % take_time4)
    print("numpy vector with numba comp:%s" % take_time5)
    print("numpy vector with numba after comp:%s" % take_time6)

output

python list:8.37137699127
python list with numba comp:8.26541399956
python list with numba after comp:8.33281493187
numpy vector:0.529839992523
numpy vector with numba comp:0.539204835892
numpy vector with numba after comp:0.524770021439

好像呼叫函式對與 numba來說是有有影響的.呼叫函式的話numba 就起不到加速的效果了.下面去掉函式呼叫

#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-05 18:05
# Author : DARREN
# Describe : not set
# Email : [email protected]
#####################################
from __future__ import division
from __future__ import print_function

import numpy as np
from timeit import Timer
from numba import jit

def python_list(n):
    a = range(n)
    b = range(n)
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])
    return c

@jit
def python_list_with_numba(n):
    a = range(n)
    b = range(n)
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])
    return c

def numpy_vector(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@jit
def numpy_vector_with_numba(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z


if __name__ == '__main__':
    t1 = Timer('python_list(1000000)','from __main__ import python_list')
    t2 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t3 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t4 = Timer('numpy_vector(1000000)','from __main__ import numpy_vector')
    t5 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')
    t6 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')

    take_time1 = t1.timeit(50)
    take_time2 = t2.timeit(50)
    take_time3 = t3.timeit(50)
    take_time4 = t4.timeit(50)
    take_time5 = t5.timeit(50)
    take_time6 = t6.timeit(50)

    print("python list:%s" % take_time1)
    print("python list with numba comp:%s" % take_time2)
    print("python list with numba after comp:%s" % take_time3)
    print("numpy vector:%s" % take_time4)
    print("numpy vector with numba comp:%s" % take_time5)
    print("numpy vector with numba after comp:%s" % take_time6)

output

python list:8.16710710526
python list with numba comp:9.53106093407
python list with numba after comp:9.40612602234
numpy vector:0.188210964203
numpy vector with numba comp:0.314162015915
numpy vector with numba after comp:0.0830471515656

numpy在計算上比python 要快.加上numba後numpy似乎可以提高1倍的速度.
numba編譯的那次速度是比較慢的.

#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-05 21:27
# Author : DARREN
# Describe : not set
# Email : [email protected]
#####################################
from __future__ import division
from __future__ import print_function

import numpy as np
from timeit import Timer
from numba import jit
from numba import njit

def python_list(n):
    a = range(n)
    b = range(n)
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])
    return c

@jit
def python_list_with_numba(n):
    a = range(n)
    b = range(n)
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])
    return c

def numpy_vector(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@jit
def numpy_vector_with_numba(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@njit(fastmath=True)
def numpy_vector_with_numba_fast(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@njit(parallel=True)
def numpy_vector_with_numba_parallel(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z

@njit(fastmath=True, parallel=True)
def numpy_vector_with_numba_fast_parallel(n):
    x = np.arange(n)
    y = np.arange(n)
    z = x**2 + y**3
    return z


if __name__ == '__main__':
    t1 = Timer('python_list(1000000)','from __main__ import python_list')
    t2 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t3 = Timer('python_list_with_numba(1000000)','from __main__ import python_list_with_numba')
    t4 = Timer('numpy_vector(1000000)','from __main__ import numpy_vector')
    t5 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')
    t6 = Timer('numpy_vector_with_numba(1000000)','from __main__ import numpy_vector_with_numba')
    t7 = Timer('numpy_vector_with_numba_fast(1000000)','from __main__ import numpy_vector_with_numba_fast')
    t8 = Timer('numpy_vector_with_numba_fast(1000000)','from __main__ import numpy_vector_with_numba_fast')

    t9 = Timer('numpy_vector_with_numba_parallel(1000000)','from __main__ import numpy_vector_with_numba_parallel')
    t10 = Timer('numpy_vector_with_numba_parallel(1000000)','from __main__ import numpy_vector_with_numba_parallel')

    t11 = Timer('numpy_vector_with_numba_fast_parallel(1000000)','from __main__ import numpy_vector_with_numba_fast_parallel')
    t12 = Timer('numpy_vector_with_numba_fast_parallel(1000000)','from __main__ import numpy_vector_with_numba_fast_parallel')

    take_time1 = t1.timeit(50)
    take_time2 = t2.timeit(50)
    take_time3 = t3.timeit(50)
    take_time4 = t4.timeit(50)
    take_time5 = t5.timeit(50)
    take_time6 = t6.timeit(50)
    take_time7 = t7.timeit(50)
    take_time8 = t8.timeit(50)
    take_time9 = t9.timeit(50)
    take_time10 = t10.timeit(50)
    take_time11 = t11.timeit(50)
    take_time12 = t12.timeit(50)

    print("python_list:%s" % take_time1)
    print("python_list_with_numba compile:%s" % take_time2)
    print("python_list_with_numba after compile:%s" % take_time3)
    print("numpy_vector:%s" % take_time4)
    print("numpy_vector_with_numba compile:%s" % take_time5)
    print("numpy_vector_with_numba after compile:%s" % take_time6)
    print("numpy_vector_with_numba_fast compile:%s" % take_time7)
    print("numpy_vector_with_numba_fast after compile:%s" % take_time8)
    print("numpy_vector_with_numba_parallel compile:%s" % take_time9)
    print("numpy_vector_with_numba_parallel after compile:%s" % take_time10)
    print("numpy_vector_with_numba_fast_parallel compile:%s" % take_time11)
    print("numpy_vector_with_numba_fast_parallel after compile:%s" % take_time12)

output

python_list:8.22160506248
python_list_with_numba compile:9.52428817749
python_list_with_numba after compile:9.4302740097
numpy_vector:0.18684220314
numpy_vector_with_numba compile:0.313122034073
numpy_vector_with_numba after compile:0.0834867954254
numpy_vector_with_numba_fast compile:0.166754961014
numpy_vector_with_numba_fast after compile:0.0827031135559
numpy_vector_with_numba_parallel compile:0.353137016296
numpy_vector_with_numba_parallel after compile:0.0367288589478
numpy_vector_with_numba_fast_parallel compile:0.359938144684
numpy_vector_with_numba_fast_parallel after compile:0.0356090068817

加上parallel 能夠提速6倍.看起來確實加速了.

下面測試下矩陣相乘 是否能被加速

#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-05 22:22
# Author : DARREN
# Describe : not set
# Email : [email protected]
#####################################
from __future__ import division
from __future__ import print_function

import numpy as np
from timeit import Timer
from numba import jit
from numba import njit

def dot(x,y):
    z = np.dot(x,y)
    return z

@jit
def dot_numba(x,y):
    z = np.dot(x,y)
    return z

@njit(fastmath=True)
def dot_numba_fast(x,y):
    z = np.dot(x,y)
    return z

@njit(parallel=True)
def dot_numba_parallel(x,y):
    z = np.dot(x,y)
    return z

@njit(fastmath=True, parallel=True)
def dot_numba_fast_parallel(x,y):
    z = np.dot(x,y)
    return z

if __name__ == '__main__':

    x = np.random.randn(100,100)
    y = np.random.randn(100,100)

    t1 = Timer('dot(x,y)','from __main__ import dot,x,y')
    t2 = Timer('dot_numba(x,y)','from __main__ import dot_numba,x,y')
    t3 = Timer('dot_numba(x,y)','from __main__ import dot_numba,x,y')
    t4 = Timer('dot_numba_fast(x,y)','from __main__ import dot_numba_fast,x,y')
    t5 = Timer('dot_numba_fast(x,y)','from __main__ import dot_numba_fast,x,y')

    t6 = Timer('dot_numba_parallel(x,y)','from __main__ import dot_numba_parallel,x,y')
    t7 = Timer('dot_numba_parallel(x,y)','from __main__ import dot_numba_parallel,x,y')

    t8 = Timer('dot_numba_fast_parallel(x,y)','from __main__ import dot_numba_fast_parallel,x,y')
    t9 = Timer('dot_numba_fast_parallel(x,y)','from __main__ import dot_numba_fast_parallel,x,y')

    take_time1 = t1.timeit(90)
    take_time2 = t2.timeit(90)
    take_time3 = t3.timeit(90)
    take_time4 = t4.timeit(90)
    take_time5 = t5.timeit(90)
    take_time6 = t6.timeit(90)
    take_time7 = t7.timeit(90)
    take_time8 = t8.timeit(90)
    take_time9 = t9.timeit(90)

    print("dot:%s" % take_time1)
    print("dot_numba compilation:%s" % take_time2)
    print("dot_numba after compilation:%s" % take_time3)
    print("dot_numba_fast compilation:%s" % take_time4)
    print("dot_numba_fast after compilation:%s" % take_time5)
    print("dot_numba_parallel compilation:%s" % take_time6)
    print("dot_numba_parallel after compilation:%s" % take_time7)
    print("dot_numba_fast_parallel compilation:%s" % take_time8)
    print("dot_numba_fast_parallel after compilation:%s" % take_time9)

output

dot:0.0045690536499
dot_numba compilation:0.161776065826
dot_numba after compilation:0.00354194641113
dot_numba_fast compilation:0.0609059333801
dot_numba_fast after compilation:0.00446605682373
dot_numba_parallel compilation:0.0760118961334
dot_numba_parallel after compilation:0.00450396537781
dot_numba_fast_parallel compilation:0.0754170417786
dot_numba_fast_parallel after compilation:0.00403594970703

能夠看到編譯的時候會更慢,編譯後的numba也不比numpy快.
下面把矩陣變大看下效果

#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-05 22:26
# Author : DARREN
# Describe : not set
# Email : [email protected]
#####################################
from __future__ import division
from __future__ import print_function

import numpy as np
from timeit import Timer
from numba import jit
from numba import njit

def dot(x,y):
    z = np.dot(x,y)
    return z

@jit
def dot_numba(x,y):
    z = np.dot(x,y)
    return z

@njit(fastmath=True)
def dot_numba_fast(x,y):
    z = np.dot(x,y)
    return z

@njit(parallel=True)
def dot_numba_parallel(x,y):
    z = np.dot(x,y)
    return z

@njit(fastmath=True, parallel=True)
def dot_numba_fast_parallel(x,y):
    z = np.dot(x,y)
    return z

if __name__ == '__main__':

    x = np.random.randn(1000,1000)
    y = np.random.randn(1000,1000)

    t1 = Timer('dot(x,y)','from __main__ import dot,x,y')
    t2 = Timer('dot_numba(x,y)','from __main__ import dot_numba,x,y')
    t3 = Timer('dot_numba(x,y)','from __main__ import dot_numba,x,y')
    t4 = Timer('dot_numba_fast(x,y)','from __main__ import dot_numba_fast,x,y')
    t5 = Timer('dot_numba_fast(x,y)','from __main__ import dot_numba_fast,x,y')

    t6 = Timer('dot_numba_parallel(x,y)','from __main__ import dot_numba_parallel,x,y')
    t7 = Timer('dot_numba_parallel(x,y)','from __main__ import dot_numba_parallel,x,y')

    t8 = Timer('dot_numba_fast_parallel(x,y)','from __main__ import dot_numba_fast_parallel,x,y')
    t9 = Timer('dot_numba_fast_parallel(x,y)','from __main__ import dot_numba_fast_parallel,x,y')

    take_time1 = t1.timeit(90)
    take_time2 = t2.timeit(90)
    take_time3 = t3.timeit(90)
    take_time4 = t4.timeit(90)
    take_time5 = t5.timeit(90)
    take_time6 = t6.timeit(90)
    take_time7 = t7.timeit(90)
    take_time8 = 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
python numpy numba 計算速度對比

     
  
 
  
  
 #!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : test.py
# Create date : 2019-01-05 17:11
# Modifie 



  
 

    


    
    
python.numpy.std()計算矩陣標準差

     
 numpy   array   pos   spa   axis   gpo   std   arr   log   
1 >>> a = np.array([[1, 2], [3, 4]])  
2 >>> np.std(a) # 計算全局標準差  
3 1.118033 



  
 

    


    
    
python不同開根號速度對比

     
 import time
import math
import numpy as np

def timeit1():
    s = time.time()
    for i in range(750000):
        z=i**.5
    print ("Took %f seconds" % ( 



  
 

    


    
    
Python---Numpy科學計算庫的使用

     
 
							
							
							一、簡介

NumPy是一個開源的Python科學計算基礎庫，包含: 
- 一個強大的N維陣列物件 ndarray 
- 廣播功能函式 
- 整合C/C++/Fortran程式碼的工具 
- 線性代數、傅立葉變換、隨機數生成等功能

NumPy的引用:



i 



  
 

    


    
    
python-Numpy科學計算工具包，pickle模組

     
 
							
							
							
  正如標題所言，Numpy是用於科學計算的，其中陣列物件對影象處理意義重大，還有線性代數函式等。在後面的所有機器學習中對影象的處理，都是基於這個庫的，介紹幾個簡單的例項。




影象陣列表示

呼叫array()方法：



im=array(Iamge. 



  
 

    


    
    
比較一下numpy.math和Python標準庫的math.sin的計算速度

     
 
                
我用下面這個小程式，比較了一下numpy.math和Python標準庫的math.sin的計算速度：


import time
import math
import numpy as np
x = [i * 0.001 for i in xrange(1000000)]
 



  
 

    


    
    
Python內建函式與numPy運算速度對比

     
 
                
Python自己帶了幾個函式，主要是sum,max,min，同時numPy中也有幾個類似的函式，今天對比了一下幾個函式的運算速度，發現了還是numpy的array計算速度最快。
思路，通過產生1萬個隨機數，對其用四種方法求和，以及求最大值，求均值的方式與求和相同，求最小值的 



  
 

    


    
    
python 歸併排序 與 快速排序 速度對比

     
  
 
  
  
 import time


def merge(list,first,mid,last):
    left = list[first:mid+1]
    right = list[mid+1:last+1]
    while left != [] and right !=[]:
  



  
 

    


    
    
Python三種排序演算法的執行速度對比(快速排序、氣泡排序、選擇排序)

     
  
 
 最近看了一下快速排序演算法，據說速度比其他的排序演算法快，於是寫了三個排序演算法對比一下，分別是氣泡排序，快速排序，選擇排序，以下是三個排序演算法的程式碼： 
 氣泡排序   BubbleSort.py 
 # -*- coding:utf8 -*-

def Sort(list 



  
 

    


    
    
python中5個json庫的速度對比

     
 
								
								            
							
							
							python中json的序列化與反序列化有很多庫，具體選擇使用哪一個，或者哪一個速度更快呢？
先上結果
json序列化與反序列化速度對比（按總時間排序：測試資料100 * 10000）

ujson   



  
 

    


    
    
深度學習之Python的科學計算包 – Numpy

     
 
                

umpy(Numerical Python extensions)是一個第三方的Python包，用於科學計算。這個庫的前身是1995年就開始開發的一個用於陣列運算的庫。經過了長時間的發展，基本上成了絕大部分Python科學計算的基礎包，當然也包括所有提供Python介 



  
 

    


    
    
python numpy基礎 陣列和向量計算

     
 

        
		在python 中有時候我們用陣列操作資料可以極大的提升資料的處理效率，
類似於R的向量化操作，使得資料的操作趨於簡單化，在python 中是使用numpy模組可以進行陣列和向量計算。
下面來看下簡單的例子



		
		
			
			
			
import n 



  
 

    


    
    
Python五種迭代方式 for迴圈，列表推導式，內建函式map()，生成器推導式，生成器函式  速度對比

     
 
								
								            
							
							
							對比了Python3的五種迭代方式進行函式簡單計算的花費時間
五種迭代分別是，for迴圈，列表推導式，內建函式map()，生成器推導式，生成器函式
簡單計算以add()加10操作和abs()絕對值舉例
 



  
 

    


    
    
Python  Numpy計算各類距離

     
 
                

詳細:

1.閔可夫斯基距離(Minkowski Distance)

2.歐氏距離(Euclidean Distance)

3.曼哈頓距離(Manhattan Distance)

4.切比雪夫距離(Chebyshev Distance)

5.夾角餘弦(Cosine 



  
 

    


    
    
Python Numpy的一些操作可以極大的加快你的code執行速度

     
 
							
							
							如果你在進行大矩陣運算的時候，想必大家最想用的肯定是python的numpy資料格式把。但是以前的我，只會用for迴圈（反正只要達到目的），但是當你有個幾十w行的feature，每個有幾千維的時候，那真是要處理無數無數無數無數天啊！！！於是，經導師的一番“刺激” 



  
 

    


    
    
python和php的文字處理速度對比

     
 
                
執行環境：
PHP 5.4.17
Python 2.6.6
linux 64位

一、逐行讀取資料檔案，用tab鍵做分隔處理
split.py #!/usr/bin/python
#coding=utf-8

import sys

if len(sys.argv) !=  



  
 

    


    
    
select *  和 select 所有字段寫出來 ，速度對比！

     
 bsp   第一次   blog   師說   sel   lec   意見   -1   tab   從很早時候，聽老師說 select * from table  比 select a,b,c,d from table 要慢很多。3年來從未測試。  今天沒事測一測， 不測不知道，一測嚇一跳。
當然 以下純 



  
 

    


    
    
『python』科學計算專項_科學繪圖庫matplotlib學習之繪制動畫（待續）

     
 同時   func   動作   .com   block   save   init   []   first   示例代碼
簡單調用繪圖

from matplotlib import pyplot as plt
import matplotlib.animation as animation
impor 



  
 

    


    
    
『python』科學計算專項_科學繪圖庫matplotlib學習(下)

     
 時序   nco   字符   color   由於   enc   --   angle   fig   基本的讀取csv文件並繪制餅圖
由於之前沒有過實際處理的經驗，所以這個程序還是值得一看，涉及了處理表格數據的基本方法：

import matplotlib.pyplot as plt
import p 



  
 

    


    
    
Python--Numpy安裝

     
 安裝   ads   ges   自己的   col   上網   style   3.6   什麽   1.Numpy簡介
NumPy系統是Python的一種開源的數值計算擴展，一個用python實現的科學計算包。
2.下載
下載地址：https://pypi.python.org/pypi/numpy#d