Julia oder Python, welches ist schneller?

Julia ist eine hochabstrakte dynamische Programmiersprache. Obwohl es sich um eine Allzwecksprache handelt, die alle Programme entwickeln kann, verfügt sie über mehrere Merkmale, die sie gut für wissenschaftliche Berechnungen und numerische Berechnungen geeignet machen. Python entstand Anfang der 1990er Jahre als einfache objektorientierte Programmiersprache und hat sich heute erheblich weiterentwickelt. In diesem Artikel wird ihre Leistung in neuronalen Netzen und maschinellem Lernen erörtert.

Julias Architektur zeichnet sich hauptsächlich durch parametrischen Polymorphismus in dynamischen Sprachen und das Programmierparadigma des Mehrfachversands aus. Es ermöglicht gleichzeitiges, paralleles und verteiltes Rechnen mit oder ohne Message Passing Interface (MPI) oder integrierten Threads im „OpenMP-Stil“ sowie direkte Aufrufe von C- und FORTRAN-Bibliotheken ohne zusätzlichen Code. Julia verwendet einen Just-in-Time-Compiler (JIT), den die Julia-Community „Just-in-Time (JAOT)“ nennt, da er vor der Ausführung standardmäßig den gesamten Code in Maschinencode kompiliert.

Im Gegensatz zu Python ist Julia für Statistik und maschinelles Lernen konzipiert. Julia kann lineare Algebraoperationen schnell ausführen, Python ist jedoch sehr langsam. Dies liegt daran, dass Python nie dafür konzipiert wurde, die beim maschinellen Lernen verwendeten Matrizen und Gleichungen zu berücksichtigen. Python selbst ist nicht schlecht, insbesondere Numpy, aber ohne die Verwendung von Paketen fühlt sich Julia besser auf Mathematik zugeschnitten. Julias Operatoren ähneln eher R als denen von Python, was einen erheblichen Vorteil darstellt. Die meisten Operationen der linearen Algebra können mit weniger Zeit und Aufwand durchgeführt werden.

Wie wir alle wissen, hat Python in den letzten Jahren die Bereiche maschinelles Lernen und Datenwissenschaft dominiert. Denn in Python können wir eine Vielzahl von Bibliotheken von Drittanbietern verwenden, die uns beim Schreiben von Code für maschinelles Lernen helfen. Obwohl Python so viele Vorteile hat, hat es dennoch einen großen Nachteil: Es ist eine interpretierte Sprache und sehr langsam. Jetzt ist das Zeitalter der Daten gekommen. Je mehr Daten wir haben, desto länger dauert es, sie zu verarbeiten. Deshalb erscheint Julia.

Bisher konzentrierten sich die Forschungsarbeiten zu Julia auf Themen wie hohe Leistung oder Julias wissenschaftliche Rechenfähigkeiten. Aber hier werden wir über Julias Fähigkeit diskutieren, nicht nur komplexe wissenschaftliche Berechnungen, sondern auch betriebswirtschaftliche Probleme sowie maschinelles Lernen und neuronale Netze wie Python effizient zu bewältigen.

Experimentelle Ziele und experimentelles Design

Julia ist so einfach wie Python, aber es ist eine kompilierte Sprache wie C. Testen wir zunächst, wie viel schneller Julia als Python ist. Dazu testen wir sie zunächst mit einigen einfachen Programmen und kommen dann zum Schwerpunkt unserer Experimente, indem wir ihre maschinellen Lern- und Deep-Learning-Fähigkeiten testen.

Sowohl Julia als auch Python bieten viele Bibliotheken und Open-Source-Benchmarking-Tools. Für Benchmarking und Rechenzeiten haben wir in Julia das Modul ​​CPUTime​​ 和 ​​time​​ 库；对于 Python，我们同样使用了 ​​time​​ verwendet.

Matrixmultiplikation

Zuerst haben wir einfache arithmetische Operationen ausprobiert, aber da diese Operationen keinen großen Zeitunterschied machten, entschieden wir uns, den Zeitunterschied der Matrixmultiplikation zu vergleichen. Wir haben zwei ​​(10 * 10)​​ und Punktprodukt. Wie wir alle wissen, hat Python einen ​Numpy​​ Bibliothek, wird häufig zur Berechnung von Matrizen und Vektoren verwendet. Und Julia hat auch eine ​​LinearAlgebra​​ Bibliothek, die häufig zur Berechnung von Matrizen und Vektoren verwendet wird. Daher haben wir den Zeitaufwand der Matrixmultiplikation mit bzw. ohne Bibliothek verglichen. Der gesamte in diesem Artikel verwendete Quellcode wurde im ​​GitHub-Repository​​ abgelegt. Nachfolgend finden Sie ein in Julia geschriebenes 10×10-Matrixmultiplikationsprogramm: ​(10 * 10)​​ 的随机浮点数矩阵，并对它们施以点积。众所周知，Python 有一个 ​​Numpy​​ 库，常被用于计算矩阵和向量。而 Julia 也有一个 ​​LinearAlgebra​​ 库，常用于计算矩阵和向量。因此我们分别比较了各自使用和不使用库的矩阵乘法的耗时。本文用到的所有源码已经放在了 ​​GitHub 存储库​​。下面给出了用 Julia 编写的 10×10 矩阵乘法程序：

@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 使用库耗时 0.000017 秒，使用循环耗时 0.000001 秒。

使用 Python 编写相同的矩阵乘法程序如下。 从结果可以发现，与不使用库相比，使用库的程序花费的时间更少：

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 使用库耗时 0.0013 秒，使用循环耗时 0.0015 秒。

线性搜索

我们进行的下一个实验是对十万个随机生成的数字进行线性搜索。这里使用了两种方法，一种是使用 ​​for​​ 循环，另一种是使用运算符。我们使用 1 到 1000 的整数执行了 1000 次搜索，正如你在下面的输出中看到的那样，我们还打印了我们在数据集中找到了多少个整数。下面给出了使用循环和使用 ​​IN​​ 运算符的时间。这里我们使用了 CPU 3 次运行时间的中位数。

使用 Julia 编写的程序和运行结果如下：

（LCTT 译注：此处原文缺失 Julia 代码）

使用 Python 编写的程序和运行结果如下：

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

从以上结果来看，在 Julia 中使用循环和运算符并不会产生显著的时间差异。但是在 Python 中循环几乎比运算符 IN 多花了三倍的时间。有趣的是，在这两种情况下，Julia 都比 Python 快得多。

线性回归

下一个实验是测试机器学习算法。我们选择了以一种最常见和最简单的机器学习算法，使用简单数据集的线性回归。我们使用了一个包含 237 条数据的数据集 “Head Brain”，数据集的两列分别为 “HeadSize” 和 “BrainWeight”。接下来，我们使用 “head size” 数据去计算 “brain weight”。在 Python 和 Julia 中我们都没有使用第三方库，而是从零实现了线性回归算法。

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

上面给出了 Julia 和 Python 所花费的时间。

逻辑回归

接下来，我们使用两种语言的库对最常见的机器学习算法（即逻辑回归）进行了实验。对于 Python 我们使用最常见的库 ​​sklearn​​；对于 Julia，我们使用 ​​GLM​

@time log_rec()

0.027746 seconds (3.32 k allocations: 10.947 MiB)

Julia Mit der Bibliothek dauerte es 0,000017 Sekunden und mit der Schleife 0,000001 Sekunden.

Schreiben Sie dasselbe Matrixmultiplikationsprogramm mit Python wie folgt. Aus den Ergebnissen geht hervor, dass das Programm, das die Bibliothek verwendet, weniger Zeit benötigt als das Programm, das die Bibliothek nicht verwendet:

gc.collect()

start = process_time()

LogReg()

end = process_time()

print(end-start)


Accuracy : 0.8068

0.34901400000000005

Python benötigt 0,0013 Sekunden mit der Bibliothek und 0,0015 Sekunden mit der Schleife. #🎜🎜##🎜🎜#lineare Suche#🎜🎜##🎜🎜#Das nächste Experiment, das wir durchführten, bestand darin, eine lineare Suche anhand von einhunderttausend zufällig generierten Zahlen durchzuführen. Hier werden zwei Methoden verwendet: Eine davon ist die Verwendung von ​​for​​ Schleife, die andere ist die Verwendung von Operatoren. Wir haben 1000 Suchvorgänge mit Ganzzahlen von 1 bis 1000 durchgeführt und wie Sie in der Ausgabe unten sehen können, haben wir auch gedruckt, wie viele Ganzzahlen wir im Datensatz gefunden haben. Unten ist die Verwendung einer Schleife und die Verwendung von ​IN​​ Operatorzeit. Hier verwenden wir den Median von 3 CPU-Laufzeiten. #🎜🎜##🎜🎜#Das mit Julia geschriebene Programm und die laufenden Ergebnisse lauten wie folgt: #🎜🎜##🎜🎜# (LCTT-Übersetzung: Julia-Code fehlt hier im Originaltext) #🎜🎜##🎜🎜 #Das mit Python geschriebene Programm Und die laufenden Ergebnisse sind wie folgt: #🎜🎜#

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

rrreee#🎜🎜#Aus den obigen Ergebnissen führt die Verwendung von Schleifen und Operatoren in Julia zu keinem signifikanten Zeitunterschied. Aber das Schleifen in Python dauert fast dreimal länger als der Operator IN. Interessanterweise ist Julia in beiden Fällen viel schneller als Python. #🎜🎜##🎜🎜#lineare Regression#🎜🎜##🎜🎜#Das nächste Experiment besteht darin, den Algorithmus für maschinelles Lernen zu testen. Wir haben uns für die lineare Regression entschieden, einen der gebräuchlichsten und einfachsten Algorithmen für maschinelles Lernen, unter Verwendung eines einfachen Datensatzes. Wir haben einen Datensatz „Head Brain“ verwendet, der 237 Daten enthält. Die beiden Spalten des Datensatzes sind „HeadSize“ und „BrainWeight“. Als nächstes verwenden wir die Daten zur „Kopfgröße“, um das „Gehirngewicht“ zu berechnen. Sowohl in Python als auch in Julia haben wir keine Bibliotheken von Drittanbietern verwendet, sondern den linearen Regressionsalgorithmus von Grund auf implementiert. #🎜🎜##🎜🎜#Julia: #🎜🎜#rrreee#🎜🎜#Python: #🎜🎜#rrreee#🎜🎜#Die für Julia und Python benötigte Zeit ist oben angegeben. #🎜🎜##🎜🎜#logistische Regression#🎜🎜##🎜🎜#Als nächstes führten wir Experimente mit dem gebräuchlichsten Algorithmus für maschinelles Lernen durch, nämlich der logistischen Regression, wobei wir Bibliotheken in beiden Sprachen verwendeten. Für Python verwenden wir die gängigsten Bibliotheken ​​sklearn​​; Für Julia verwenden wir ​​GLM​​-Bibliothek. Der hier verwendete Datensatz handelt von Bankkunden und enthält 10.000 Dateneinträge. Die Zielvariable ist eine binäre Variable, die unterscheidet, ob ein Verbraucher weiterhin ein Bankkonto nutzt. #🎜🎜##🎜🎜#Die Zeit, die Julia benötigt, um eine logistische Regression durchzuführen, ist unten angegeben: #🎜🎜#rrreee#🎜🎜#Die Zeit, die Python benötigt, um eine logistische Regression durchzuführen, ist unten angegeben: #🎜🎜#

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 时间差异的百分比。

# 🎜🎜# 0,001398,69Lineare Suche (mit Schleife) 0,43lineare Regression0,000718

实验	Julia（秒）	Python（秒）	时间差（%）
矩阵乘法（不使用库）	0.000001	0,0015	99,9
Matrixmultiplikation (mit Bibliothek)	0,000017 #🎜 🎜 #		# 🎜🎜 #
0,42	#🎜 🎜# 16.4	97.43	#🎜 🎜##🎜 🎜# Lineare Suche (mit IN-Operator)
#🎜🎜 # 6.2	93.06	# 🎜🎜 #
0,00718 # 🎜🎜#	90	# Logistik Rückschritt	0,025 .76	110,3	94,77
Alle von uns durchgeführten Experimente zeigten, dass der Unterschied in der Ausführungszeit zwischen Julia und Python mit zunehmender Komplexität des Programms und der Größe des Datensatzes zunimmt. Aus diesem Ergebnis können wir schließen, dass Julia eine Programmiersprache ist, die sich besser für maschinelles Lernen und neuronale Netze eignet.

Das obige ist der detaillierte Inhalt vonJulia oder Python, welches ist schneller?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!