\n1) Existence of a REPL console, to be able to run tests.
\n2) Performance, because if it is slow, we won’t be able to execute anything.
\n3) Number of lines to execute, because trial and error are the parents of science and each experiment cannot take too much time.
\nThere are more than three languages that meet these conditions, such as Ruby or Kotlin, but we will focus on Python, R, and Julia.
\nPython<\/strong> is a multi-purpose object-oriented language on which packages for data analysis have been developed, such as pandas for tables, scikit for Machine Learning, and Numpy for matrices, among others. Its main strength is that since any development can be done in Python, it greatly facilitates integrating models into production applications.
\nR<\/strong> is a functional language invented for data analysis. Its main data structure is DataFrames (in-memory tables) and the entire language revolves around them. Although R is focused on manipulating tables, thanks to its huge community, today you can do completely different and unexpected things with it, such as web pages (in Shiny) or REST APIs (Plumber).
\nJulia<\/strong> is another functional language, very new, similar to R but not so centered on DataFrames. Its focus is on being fast and distributed, achieving performance close to C++. The interesting thing is that while the efficient libraries of R and Python are programmed in another language, Julia is mainly written in Julia.
\nThe three languages above are high-level and have a REPL console<\/strong>, so through 4 experiments we will focus on dimensions 2) Performance<\/strong> and 3) Number of lines<\/strong>; on the other hand, since Julia is very new, we will have results for Julia current and 6 months ago.<\/p>\n
Experiment 1 <\/h3>\n
Aggregation on a DataFrame of 10 million records<\/strong>. Some languages have more than one library to do this, so there will be more than one result for each. Clearly Julia is not the fastest; Python, which has recently optimized pandas a lot<\/strong>, was. But it is worth noting that in the last 6 months it has improved a lot, catching up with data.tables (data.tables + setkey only considers the aggregation time, not the index creation time, so it cannot be considered the winner). It should also be noted that since Julia is written in Julia, these aggregations can be programmed in a loop without losing speed<\/strong>. An example will be shown at the end in the code section. Recursion <\/strong>, specifically Fibonacci<\/strong> series programmed in a recursive function. A recursive function is one that calls itself several times to obtain a result, so this experiment measures efficiency in explicit code, without libraries. Now if we look at the results on a logarithmic scale (log10), we see that all three languages have improved in the last 6 months and Julia is the clear winner by more than 2 orders of magnitude. On the other hand, Python 3.8 improved a lot compared to the previous version, managing to be on par with R.<\/p>\n Frankly, the times for each language were small, so I would only recommend Julia if your model requires calling a user-defined function many times, for example in Optimization using the gradient method.<\/p>\n Performance on Matrices<\/strong> We see that Julia is the fastest, but very close to R. Python, on the other hand, lags behind. Time to modify elements of a matrix inside a loop. Python is by far the slowest, although it has improved in Python 3.8. On the other hand, since R objects are immutable, I expected worse results. I did this analysis because I remembered that the last time I tried to use Julia, it was very annoying that importing libraries took a long time. This has improved, but they still take a while, especially for large libraries like Queryverse. Still, it is an interesting project.
\nIn the following graph we see the times for different libraries to execute the same aggregation, where:
\ndata.table<\/strong> is a library for manipulating tables programmed in C and focused mainly on being fast.
\ndata.table + setkey<\/strong> – data.tables allow creating indexes; in this case, an index was created on the column that was aggregated.
\nDataFrames<\/strong> is one of the libraries for manipulating tables in Julia.
\nJuliaDB<\/strong> is one of the libraries for manipulating tables in Julia.
\npandas<\/strong> is the library for manipulating tables in Python, based on Numpy.
\nQueryverse<\/strong> is one of the libraries for manipulating tables in Julia and aims to imitate Tidyverse.
\ntidyverse<\/strong> is actually dplyr, which, due to its easy notation, is the most popular library for manipulating tables in R.
\nBar Plot of Execution Times<\/strong><\/p>\n![\"\"](\"https:\/\/i0.wp.com\/www.geekosas.com\/wp-content\/uploads\/2020\/04\/agregacion-1024x636.png?resize=810%2C503&ssl=1\")
<\/p>\n
\nThe codes to perform each of these aggregations are as follows:
\ndata.table<\/strong>
\n dt[,list(valor = mean(valor)),by='categoria'] <\/code>
\ndata.table + setkey<\/strong>
\n setkey(dt,categoria)
\ndt[,list(valor = mean(valor)),by='categoria'] <\/code>
\nDataFrames<\/strong>
\n aggregate(datos,:categoria,[mean]) <\/code>
\nor by(datos,:categoria,x->(promedio = mean(x.valor))) <\/code>
\nJuliaDB<\/strong>
\n JuliaDB.groupby(mean, indexed, :categoria, select =:valor) <\/code>
\npandas<\/strong>
\n datos.groupby(['categoria']).aggregate(np.mean) <\/code>
\nQueryverse<\/strong>
\n datos |> @groupby(.categoria) |> @map({categoria = key(<\/em>),promedio = mean(_.valor)}) |> DataFrame <\/code>
\ntidyverse<\/strong>
\n datos %>% group_by(categoria) %>% summarise(valor = mean(valor)) <\/code>
\nJulia using a Loop<\/strong>
\n results = []
\nfor slice in groupby(datos,:categoria)
\npush!(results,(promedio = slice.categoria[1], valor = mean(slice.valor)))
\nend
\nDataFrame(results)<\/code>
\nAll are similar in length, but the syntax of Queryverse and Tidyverse are the clearest and most flexible. On the other hand, the last example with Julia has the performance of DataFrames, with maximum flexibility, but not efficiency in the number of lines.<\/p>\n Experiment 2 <\/h3>\n
\nIn particular, we compute Fibonacci(100), which forces us to call the function 100 times.
\nAll codes are very similar, so I will only show the code in Python:
\ndef fico(n,contador = 2, ant = 1, antant = 0):
\nif(n <= 1):
\nreturn n
\nif(n == contador):
\nreturn ant + antant
\nelse:
\nreturn fico(n,contador+1,ant + antant,ant)<\/code>
\nWhat is not so similar is the execution time. Below are the execution times for each language at two different dates. The clear loser is Python from 2020\/08\/01, which corresponded to Python 3.7.<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/www.geekosas.com\/wp-content\/uploads\/2019\/09\/fibonacci-1024x636.png?resize=810%2C503&ssl=1\")
<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/www.geekosas.com\/wp-content\/uploads\/2019\/09\/fibonacci_log-1-1024x636.png?resize=810%2C503&ssl=1\")
<\/p>\n Experiment 3 <\/h3>\n
\nAll three languages are very powerful in matrix handling; many operations can be performed on matrices, but I chose eigenvalue decomposition to run the test. This is a relatively heavy operation.
\nBar Plot of Times to Compute Eigenvalues<\/strong><\/p>\n![\"\"](\"https:\/\/i0.wp.com\/www.geekosas.com\/wp-content\/uploads\/2019\/09\/svd-1024x717.png?resize=810%2C567&ssl=1\")
<\/p>\n
\nOn the other hand, the notation for all three cases is very similar, but I will show it both ways.
\nR<\/strong>
\nmat = matrix(runif(1000*1000),nrow=1000)
\nsvd(mat)<\/code>
\nJulia<\/strong>
\nmat = rand(1000,1000)
\nsvd(mat)<\/code>
\nPython<\/strong> is a bit different because it is object-oriented:
\nmat = np.random.rand(1000,1000)
\nnp.linalg.svd(mat)<\/code><\/p>\nExperiment 4<\/h1>\n
\nIn this case, in a loop we will fill the previous matrix with mat[i,j] = i + j. The times are shown in the following graph:<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/www.geekosas.com\/wp-content\/uploads\/2019\/09\/fill-1024x717.png?resize=810%2C567&ssl=1\")
<\/p>\n
\nAgain the codes are similar, but I want to share an honorable mention in Python that allows iterating over two variables with a for loop:
\nimport itertools
\nfor i,j in itertools.product(range(1000),range(1000)):
\nmat[i,j] = i+j<\/code><\/p>\nFootnote<\/h1>\n
\nOn the other hand, in general the languages are similar, but I think the main difference is Python’s object orientation, which is very evident in how Pandas DataFrames are manipulated.
\nFinally, although the performance differences may seem large, when compared to Excel, all three alternatives are fast and efficient.
\nGreetings!<\/p>\n","protected":false},"excerpt":{"rendered":"