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)

gc.collect()

start = process_time()

LogReg()

end = process_time()

print(end-start)


Accuracy : 0.8068

0.34901400000000005

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

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

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!