Julia atau Python, yang manakah lebih pantas?

Julia ialah bahasa pengaturcaraan dinamik yang sangat abstrak. Walaupun ia adalah bahasa tujuan umum yang mampu membangunkan semua program, ia mempunyai beberapa ciri yang menjadikannya sangat sesuai untuk pengkomputeran saintifik dan pengiraan berangka. Python muncul sebagai bahasa pengaturcaraan berorientasikan objek mudah pada awal 1990-an dan telah berkembang dengan ketara hari ini. Artikel ini akan membincangkan prestasi mereka dalam rangkaian saraf dan pembelajaran mesin.

Seni bina Julia terutamanya dicirikan oleh polimorfisme parametrik dalam bahasa dinamik dan paradigma pengaturcaraan pelbagai penghantaran. Ia membenarkan pengkomputeran serentak, selari dan teragih dengan atau tanpa antara muka penghantaran mesej (MPI) atau benang "gaya OpenMP" terbina dalam, serta panggilan terus ke perpustakaan C dan FORTRAN tanpa kod tambahan. Julia menggunakan pengkompil just-in-time (JIT), yang komuniti Julia panggil "just-ahead-of-time (JAOT)" kerana ia menyusun semua kod kepada kod mesin secara lalai sebelum dijalankan.

Tidak seperti Python, Julia direka untuk statistik dan pembelajaran mesin. Julia boleh melakukan operasi algebra linear dengan cepat, tetapi Python sangat perlahan. Ini kerana Python tidak pernah direka bentuk untuk menampung matriks dan persamaan yang digunakan dalam pembelajaran mesin. Python itu sendiri tidak buruk, terutamanya Numpy, tetapi tanpa menggunakan pakej, Julia berasa lebih sesuai untuk matematik. Pengendali Julia lebih seperti R daripada Python, yang merupakan kelebihan yang ketara. Kebanyakan operasi algebra linear boleh dilakukan dengan sedikit masa dan usaha.

Seperti yang kita sedia maklum, Python telah mendominasi bidang pembelajaran mesin dan sains data sejak beberapa tahun kebelakangan ini. Kerana dalam Python kami boleh menggunakan pelbagai perpustakaan pihak ketiga untuk membantu kami menulis kod pembelajaran mesin. Walaupun Python mempunyai banyak kelebihan, ia masih mempunyai satu kelemahan utama - ia adalah bahasa yang ditafsirkan dan sangat perlahan. Sekarang adalah zaman data Semakin banyak data yang kita ada, semakin lama masa yang diperlukan untuk memprosesnya, itulah sebabnya Julia muncul.

Setakat ini, kerja penyelidikan tentang Julia memfokuskan pada topik seperti prestasi tinggi atau keupayaan pengkomputeran saintifik Julia. Tetapi di sini, kita akan membincangkan tentang keupayaan Julia untuk mengendalikan dengan cekap bukan sahaja pengiraan saintifik yang kompleks tetapi juga masalah berasaskan perniagaan, serta pembelajaran mesin dan rangkaian saraf seperti Python.

Matlamat percubaan dan reka bentuk percubaan

Julia semudah Python, tetapi bahasa yang dihimpun seperti C. Mula-mula mari kita uji sejauh mana Julia lebih pantas daripada Python. Untuk melakukan ini, kami mula-mula menguji mereka pada beberapa program mudah dan kemudian datang ke fokus percubaan kami, menguji pembelajaran mesin dan keupayaan pembelajaran mendalam mereka.

Kedua-dua Julia dan Python menyediakan banyak perpustakaan dan alat penanda aras sumber terbuka. Untuk penandaarasan dan masa pengkomputeran dalam Julia, kami menggunakan perpustakaan ​​CPUTime​​ dan ​​time​​; untuk Python, kami juga menggunakan modul ​​time​​.

Pendaraban Matriks

Pada mulanya kami mencuba operasi aritmetik mudah, tetapi memandangkan operasi ini tidak membuat banyak perbezaan masa, kami memutuskan untuk membandingkan perbezaan masa pendaraban matriks. Kami mencipta dua ​​(10 * 10)​​ matriks nombor titik terapung rawak dan melakukan hasil darab titik padanya. Seperti yang kita sedia maklum, Python mempunyai perpustakaan ​​Numpy​​, yang sering digunakan untuk mengira matriks dan vektor. Julia juga mempunyai perpustakaan ​​LinearAlgebra​​, yang sering digunakan untuk mengira matriks dan vektor. Oleh itu, kami membandingkan penggunaan masa pendaraban matriks dengan dan tanpa perpustakaan masing-masing. Semua kod sumber yang digunakan dalam artikel ini telah diletakkan dalam ​​repositori GitHub ​​. Diberikan di bawah ialah atur cara pendaraban matriks 10×10 yang ditulis dalam Julia:

@time LinearAlgebra.mul!(c,x,y)


function MM()

x = rand(Float64,(10,10))

y = rand(Float64,(10,10))

c = zeros(10,10)


for i in range(1,10)

for j in range(1,10)

for k in range(1,10)

c[i,j] += x[i,k]*y[k,j]

end

end

end

end

@time MM


0.000001 seconds

MM (generic function with 1 method)

Julia mengambil masa 0.000017 saat menggunakan perpustakaan dan 0.000001 saat menggunakan gelung.

Tulis atur cara pendaraban matriks yang sama dalam Python seperti berikut. Daripada keputusan, didapati bahawa program menggunakan perpustakaan mengambil masa yang lebih singkat daripada tidak menggunakan perpustakaan:

import numpy as np

import time as t

x = np.random.rand(10,10)

y = np.random.rand(10,10)

start = t.time()

z = np.dot(x, y)

print(“Time = “,t.time()-start)

Time = 0.001316070556640625


import random

import time as t

l = 0

h= 10

cols = 10

rows= 10


choices = list (map(float, range(l,h)))

x = [random.choices (choices , k=cols) for _ in range(rows)]

y = [random.choices (choices , k=cols) for _ in range(rows)]


result = [([0]*cols) for i in range (rows)]


start = t.time()


for i in range(len(x)):

for j in range(len(y[0])):

for k in range(len(result)):

result[i][j] += x[i][k] * y[k][j]


print(result)

print(“Time = “, t.time()-start)


Time = 0.0015912055969238281

Python mengambil masa 0.0013 saat menggunakan perpustakaan dan 0.0015 saat menggunakan gelung.

Carian Linear

Percubaan seterusnya yang kami lakukan ialah carian linear pada seratus ribu nombor yang dijana secara rawak. Dua kaedah digunakan di sini, satu ialah menggunakan gelung ​​for​​, dan satu lagi ialah menggunakan operator. Kami melakukan 1000 carian menggunakan integer daripada 1 hingga 1000 dan seperti yang anda boleh lihat dalam output di bawah, kami juga mencetak bilangan integer yang kami temui dalam set data. Diberikan di bawah adalah masa apabila menggunakan gelung dan menggunakan pengendali ​​IN​​. Di sini kita menggunakan median 3 masa larian CPU.

Atur cara yang ditulis dalam Julia dan keputusan berjalan adalah seperti berikut:

(terjemahan LCTT: Kod Julia tiada dalam teks asal di sini)

Atur cara yang ditulis dalam Python dan keputusan berjalan adalah seperti berikut:

import numpy as np

import time as t

x = np.random.rand(10,10)

y = np.random.rand(10,10)

start = t.time()

z = np.dot(x, y)

print(“Time = “,t.time()-start)

Time = 0.001316070556640625


import random

import time as t

l = 0

h= 10

cols = 10

rows= 10


choices = list (map(float, range(l,h)))

x = [random.choices (choices , k=cols) for _ in range(rows)]

y = [random.choices (choices , k=cols) for _ in range(rows)]


result = [([0]*cols) for i in range (rows)]


start = t.time()


for i in range(len(x)):

for j in range(len(y[0])):

for k in range(len(result)):

result[i][j] += x[i][k] * y[k][j]


print(result)

print(“Time = “, t.time()-start)


Time = 0.0015912055969238281

FOR_SEARCH:

Elapsed CPU time: 16.420260511 seconds

matches: 550

Elapsed CPU time: 16.140975079 seconds

matches: 550

Elapsed CPU time: 16.49639576 seconds

matches: 550


IN:

Elapsed CPU time: 6.446583343 seconds

matches: 550

Elapsed CPU time: 6.216615487 seconds

matches: 550

Elapsed CPU time: 6.296716556 seconds

matches: 550

Daripada keputusan di atas, menggunakan gelung dan operator dalam Julia tidak menghasilkan perbezaan masa yang ketara. Tetapi gelung dalam Python mengambil masa hampir tiga kali lebih lama daripada operator IN. Menariknya, dalam kedua-dua kes, Julia jauh lebih pantas daripada Python.

Regression Linear

Percubaan seterusnya adalah untuk menguji algoritma pembelajaran mesin. Kami memilih regresi linear, salah satu algoritma pembelajaran mesin yang paling biasa dan paling mudah, menggunakan set data ringkas. Kami menggunakan set data "Otak Kepala" yang mengandungi 237 keping data. Dua lajur set data ialah "Saiz Kepala" dan "Berat Otak". Seterusnya, kami menggunakan data "saiz kepala" untuk mengira "berat otak". Dalam kedua-dua Python dan Julia, kami tidak menggunakan perpustakaan pihak ketiga, tetapi melaksanakan algoritma regresi linear dari awal.

Julia:

GC.gc()

@CPUtime begin

linear_reg()

end

elapsed CPU time: 0.000718 seconds

Python:

gc.collect()

start = process_time()

linear_reg()

end = process_time()


print(end-start)

elapsed time: 0.007180344000000005

Masa yang diambil untuk Julia dan Python diberikan di atas.

Regression Logistik

Seterusnya, kami menjalankan eksperimen pada algoritma pembelajaran mesin yang paling biasa, iaitu regresi logistik, menggunakan perpustakaan dalam kedua-dua bahasa. Untuk Python kami menggunakan perpustakaan yang paling biasa ​​sklearn​​; untuk Julia kami menggunakan ​​GLM​​ perpustakaan. Set data yang kami gunakan di sini adalah mengenai pelanggan bank dan mengandungi 10,000 entri data. Pembolehubah sasaran ialah pembolehubah binari yang membezakan sama ada pengguna terus menggunakan akaun bank.

Masa yang diperlukan untuk melakukan regresi logistik dalam Julia diberikan di bawah:

@time log_rec()

0.027746 seconds (3.32 k allocations: 10.947 MiB)

Masa yang diperlukan untuk melakukan regresi logistik dalam Python diberikan di bawah:

gc.collect()

start = process_time()

LogReg()

end = process_time()

print(end-start)


Accuracy : 0.8068

0.34901400000000005

神经网络

在各种程序和数据集上测试这两种语言后，我们在神经网络上使用 MNIST 数据集继续测试它们。该数据集包含从零到九的手绘数字的灰度图像。每张图像为 28×28 像素。每个像素值表示该像素的亮度或暗度，该值是包含 0 到 255 之间的整数。该数据还包含一个标签列，该列表示在相关图像中绘制的数字。

Figure 1: Example of MNIST data set

图 1 是 MNIST 数据集的示例。

对两种语言我们都建立了一个简单的神经网络来测试它们耗费的时间。神经网络的结构如下：

Input ---> Hidden layer ---> Output

该神经网络包含了一个输入层、隐层还有输出层。为了避免神经网络的复杂度过高，我们对数据集没有进行任何的预处理工作。在 Julia 和 Python 中我们都进行了40次训练并比较它们的时间差异。

Figure 2: Julia takes 5.76 seconds in a neural network

在 Julia 中，​​Flux​​ 库通常被用于建立神经网络；在 Python 中我们常使用 ​​Keras​​ 库。图 2 展示了 Julia 在神经网络上的耗时。图 3 展示了 Python 的神经网络经过了若干次训练的耗时。

Figure 3: Python takes 110.3 seconds in a neural network

这个结果展示了 Julia 和 Python 在处理神经网络时存在巨大的时间差异。

表 1 总结了此次实验的测试结果并计算了 Julia 和 Python 时间差异的百分比。

实验	Julia（秒）	Python（秒）	时间差（%）
矩阵乘法（不使用库）	0.000001	0.0015	99.9
Pendaraban Matriks ( Menggunakan perpustakaan)	0.000017	0.0013	98.69
Carian linear (menggunakan gelung)	0.42	16.4	97.43
Carian linear ( Menggunakan operator IN)	0.43	6.2	93.06
Regression Linear	0.000718	0.00718	90
Regression Logistik	0.025	0.34901	92.83
Rangkaian Neural	5.76	110.3	94.77

Semua eksperimen yang kami jalankan menunjukkan bahawa Apabila saiz bertambah, masa pelaksanaan perbezaan antara Julia dan Python juga meningkat. Daripada keputusan ini, kita boleh membuat kesimpulan bahawa Julia ialah bahasa pengaturcaraan yang lebih sesuai untuk pembelajaran mesin dan rangkaian saraf.

Atas ialah kandungan terperinci Julia atau Python, yang manakah lebih pantas?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!