Julia ou Python, lequel est le plus rapide ?

Julia est un langage de programmation dynamique hautement abstrait. Bien qu'il s'agisse d'un langage généraliste capable de développer tous les programmes, il possède plusieurs fonctionnalités qui le rendent bien adapté au calcul scientifique et aux calculs numériques. Python est apparu comme un langage de programmation simple orienté objet au début des années 1990 et a considérablement évolué aujourd'hui. Cet article discutera de leurs performances dans les réseaux de neurones et l'apprentissage automatique.

L'architecture de Julia est principalement caractérisée par le polymorphisme paramétrique dans les langages dynamiques et le paradigme de programmation de répartition multiple. Il permet le calcul simultané, parallèle et distribué avec ou sans l'interface de transmission de messages (MPI) ou les threads intégrés de « style OpenMP », ainsi que les appels directs aux bibliothèques C et FORTRAN sans code supplémentaire. Julia utilise un compilateur juste à temps (JIT), que la communauté Julia appelle « juste à l'avance (JAOT) » car il compile par défaut tout le code en code machine avant de l'exécuter.

Contrairement à Python, Julia est conçue pour les statistiques et l'apprentissage automatique. Julia peut effectuer des opérations d'algèbre linéaire rapidement, mais Python est très lent. En effet, Python n’a jamais été conçu pour s’adapter aux matrices et aux équations utilisées dans l’apprentissage automatique. Python en lui-même n'est pas mauvais, en particulier Numpy, mais sans utiliser de packages, Julia se sent plus adaptée aux mathématiques. Les opérateurs de Julia ressemblent davantage à R que ceux de Python, ce qui constitue un avantage significatif. La plupart des opérations d'algèbre linéaire peuvent être effectuées avec moins de temps et d'efforts.

Comme nous le savons tous, Python a dominé les domaines de l'apprentissage automatique et de la science des données ces dernières années. Parce qu'en Python, nous pouvons utiliser une variété de bibliothèques tierces pour nous aider à écrire du code d'apprentissage automatique. Bien que Python présente de nombreux avantages, il présente néanmoins un inconvénient majeur : il s’agit d’un langage interprété et très lent. C’est maintenant l’ère des données. Plus nous avons de données, plus il nous faut du temps pour les traiter. C’est pourquoi Julia apparaît.

Jusqu’à présent, les travaux de recherche sur Julia se sont concentrés sur des sujets tels que la haute performance ou les capacités de calcul scientifique de Julia. Mais ici, nous discuterons de la capacité de Julia à gérer efficacement non seulement des calculs scientifiques complexes, mais également des problèmes commerciaux, ainsi que l'apprentissage automatique et les réseaux de neurones comme Python.

Objectifs expérimentaux et conception expérimentale

Julia est aussi simple que Python, mais c'est un langage compilé comme C. Testons d'abord à quel point Julia est plus rapide que Python. Pour ce faire, nous les testons d’abord sur quelques programmes simples, puis nous nous concentrons sur nos expériences en testant leurs capacités d’apprentissage automatique et d’apprentissage profond.

Julia et Python fournissent tous deux de nombreuses bibliothèques et outils d'analyse comparative open source. Pour le benchmarking et les temps de calcul dans Julia, nous avons utilisé le module ​​CPUTime​​ 和 ​​time​​ 库；对于 Python，我们同样使用了 ​​time​​.

Multiplication matricielle

Au début, nous avons essayé des opérations arithmétiques simples, mais comme ces opérations ne faisaient pas beaucoup de différence de temps, nous avons décidé de comparer la différence de temps de la multiplication matricielle. Nous avons créé deux ​​(10 * 10)​​ et les produire par points. Comme nous le savons tous, Python a un ​Bibliothèque Numpy​​, souvent utilisée pour calculer des matrices et des vecteurs. Et Julia a également un ​​Bibliothèque d'algèbre linéaire​​, couramment utilisée pour calculer des matrices et des vecteurs. Par conséquent, nous avons comparé le temps nécessaire à la multiplication matricielle avec et sans la bibliothèque, respectivement. Tout le code source utilisé dans cet article a été placé dans le ​​dépôt GitHub​​. Vous trouverez ci-dessous un programme de multiplication matricielle 10×10 écrit en Julia : ​(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 a pris 0,000017 secondes en utilisant la bibliothèque et 0,000001 secondes en utilisant une boucle.

Écrivez le même programme de multiplication matricielle en utilisant Python comme suit. D'après les résultats, on peut constater que le programme utilisant la bibliothèque prend moins de temps que ne pas utiliser la bibliothèque :

gc.collect()

start = process_time()

LogReg()

end = process_time()

print(end-start)


Accuracy : 0.8068

0.34901400000000005

Python prend 0,0013 seconde en utilisant la bibliothèque et 0,0015 seconde en utilisant la boucle. 🎜🎜Recherche linéaire🎜🎜L'expérience suivante que nous avons réalisée était une recherche linéaire sur cent mille nombres générés aléatoirement. Deux méthodes sont utilisées ici, l'une consiste à utiliser ​​for​​ boucle, l'autre consiste à utiliser des opérateurs. Nous avons effectué 1 000 recherches en utilisant des entiers de 1 à 1 000 et, comme vous pouvez le voir dans le résultat ci-dessous, nous avons également imprimé le nombre d'entiers que nous avons trouvés dans l'ensemble de données. Vous trouverez ci-dessous l'utilisation de la boucle et l'utilisation de ​IN​​ temps de l'opérateur. Ici, nous utilisons la médiane de 3 temps d'exécution du processeur. 🎜🎜Le programme écrit en utilisant Julia et les résultats en cours d'exécution sont les suivants : 🎜🎜 (Traduction LCTT : le code Julia est manquant dans le texte original ici) 🎜🎜Le programme écrit en utilisant Python et les résultats en cours d'exécution sont les suivants : 🎜

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

rrreee🎜De les résultats ci-dessus, utilisés dans Julia Loops et les opérateurs, ne font pas de différence de temps significative. Mais le bouclage en Python prend presque trois fois plus de temps que l'opérateur IN. Fait intéressant, dans les deux cas, Julia est nettement plus rapide que Python. 🎜🎜Régression linéaire🎜🎜La prochaine expérience consiste à tester l'algorithme d'apprentissage automatique. Nous avons choisi la régression linéaire, l'un des algorithmes d'apprentissage automatique les plus courants et les plus simples, utilisant un ensemble de données simple. Nous avons utilisé un ensemble de données « Head Brain » contenant 237 éléments de données. Les deux colonnes de l'ensemble de données sont « HeadSize » et « BrainWeight ». Ensuite, nous utilisons les données « taille de la tête » pour calculer le « poids du cerveau ». Dans Python et Julia, nous n'avons pas utilisé de bibliothèques tierces, mais avons implémenté l'algorithme de régression linéaire à partir de zéro. 🎜🎜Julia:🎜rrreee🎜Python:🎜rrreee🎜Le temps pris pour Julia et Python est indiqué ci-dessus. 🎜🎜Régression logistique🎜🎜 Ensuite, nous avons mené des expériences sur l'algorithme d'apprentissage automatique le plus courant, à savoir la régression logistique, en utilisant des bibliothèques dans les deux langages. Pour Python, nous utilisons les bibliothèques les plus courantes ​​sklearn​​; Pour Julia, nous utilisons ​​Bibliothèque GLM​​. L'ensemble de données que nous utilisons ici concerne les clients des banques et contient 10 000 entrées de données. La variable cible est une variable binaire qui permet de distinguer si un consommateur continue d'utiliser un compte bancaire. 🎜🎜Le temps qu'il a fallu pour effectuer une régression logistique dans Julia est indiqué ci-dessous : 🎜rrreee 🎜Le temps qu'il a fallu pour effectuer une régression logistique dans Python est indiqué ci-dessous : 🎜

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

90Régression logistique

实验	Julia（秒）	Python（秒）	时间差（%）
矩阵乘法（不使用库）	0.000001	0.0015	99.9
Multiplication matricielle (à l'aide de la bibliothèque)	0.000017	0.0013	98.69
Recherche linéaire (En utilisant des boucles)	0.42	16.4	97.43
Recherche linéaire (en utilisant l'opérateur IN	0.43	6.2 93.06
	0.025	0.34901	92.83
Réseau Neuronal	5 .76	110.3	94.77

Toutes les expériences que nous avons menées ont montré que la différence de temps d'exécution entre Julia et Python augmente à mesure que la complexité du programme augmente ainsi que la taille de l'ensemble de données. De ce résultat, nous pouvons déduire que Julia est un langage de programmation plus adapté à l'apprentissage automatique et aux réseaux de neurones.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!