sfondo

Mi sono autodidatta con l'apprendimento automatico e recentemente ho iniziato ad approfondire l'ecosistema Julia Machine Learning.

---

Provenendo da un background di Python e avendo un po 'di esperienza su Tensorflow e OpenCV / skimage, voglio confrontare le librerie Julia ML (Flux / JuliaImages) con le sue controparti per vedere quanto velocemente o lentamente esegue attività CV (qualsiasi) e decidere se Dovrei passare a usare Julia.

So come ottenere il tempo impiegato per eseguire una funzione in Python usando un timeitmodulo come questo:

#Loading an Image using OpenCV

s = """\
img = cv2.imread('sample_image.png', 1)
"""
setup = """\
import timeit
"""
print(str(round((timeit.timeit(stmt = s, setup = setup, number = 1))*1000, 2)) + " ms")
#printing the time taken in ms rounded to 2 digits

Come si confronta il tempo di esecuzione di una funzione che esegue la stessa attività in Julia usando la libreria appropriata (in questo caso JuliaImages).

Julia fornisce qualche funzione / macro al tempo / benchmark?

using BenchmarkToolsè il modo consigliato per confrontare le funzioni di Julia. A meno che tu non stia programmando qualcosa che impiega un po 'di tempo, usa una @benchmarko le @btimemacro meno dettagliate esportate da esso. Poiché il macchinario alla base di queste macro valuta molte volte la funzione target, @timeè utile per il benchmarking di cose che funzionano lentamente (ad es. Dove sono coinvolti l'accesso al disco o calcoli che richiedono molto tempo).

È importante utilizzare @btimeo @benchmarkcorrettamente, questo evita risultati fuorvianti. Di solito, stai confrontando una funzione che accetta uno o più argomenti. Nel benchmarking, tutti gli argomenti dovrebbero essere variabili esterne: (senza la macro benchmark)

x = 1
f(x)
# do not use f(1)

La funzione verrà valutata più volte. Per evitare che gli argomenti della funzione vengano rivalutati ogni volta che la funzione viene valutata, è necessario contrassegnare ciascun argomento anteponendo $a al nome di ciascuna variabile utilizzata come argomento. Le macro di benchmarking usano questo per indicare che la variabile deve essere valutata (risolta) una volta, all'inizio del processo di benchmarking e quindi il risultato deve essere riutilizzato direttamente così com'è:

julia> using BenchmarkTools
julia> a = 1/2;
julia> b = 1/4;
julia> c = 1/8;
julia> a, b, c
(0.5, 0.25, 0.125)

julia> function sum_cosines(x, y, z)
         return cos(x) + cos(y) + cos(z)
       end;

julia> @btime sum_cosines($a, $b, $c);  # the `;` suppresses printing the returned value
  11.899 ns (0 allocations: 0 bytes)    # calling the function takes ~12 ns (nanoseconds)
                                        # the function does not allocate any memory

# if we omit the '$', what we see is misleading
julia> @btime sum_cosines(a, b, c);    # the function appears more than twice slower 
 28.441 ns (1 allocation: 16 bytes)    # the function appears to be allocating memory

# @benchmark can be used the same way that @btime is used
julia> @benchmark sum_cosines($a,$b,$c) # do not use a ';' here
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     12.111 ns (0.00% GC)
  median time:      12.213 ns (0.00% GC)
  mean time:        12.500 ns (0.00% GC)
  maximum time:     39.741 ns (0.00% GC)
  --------------
  samples:          1500
  evals/sample:     999

Mentre ci sono parametri che possono essere modificati, i valori predefiniti di solito funzionano bene. Per ulteriori informazioni su BenchmarkTools per operatori esperti, consultare il manuale .

Julia fornisce due macro per il runtime del codice di temporizzazione / benchmarking. Questi sono :

• @tempo
• @benchmark : esterno, installato daPkg.add("BenchmarkTools")

L'uso di @benchmark di BenchmarkTools è molto semplice e ti sarebbe utile nel confrontare la velocità delle due lingue. Esempio di utilizzo @bencharkcontro la panchina in pitone fornita.

using Images, FileIO, BenchmarkTools

@benchmark img = load("sample_image.png")

Produzione :

BenchmarkTools.Trial: 
  memory estimate:  3.39 MiB
  allocs estimate:  322
  --------------
  minimum time:     76.631 ms (0.00% GC)
  median time:      105.579 ms (0.00% GC)
  mean time:        110.319 ms (0.41% GC)
  maximum time:     209.470 ms (0.00% GC)
  --------------
  samples:          46
  evals/sample:     1

Ora per fare un confronto per il tempo medio, dovresti inserire samples(46) come numero nel tuo codice python timeit e dividerlo per lo stesso numero per ottenere il tempo medio di esecuzione.

print(str(round((timeit.timeit(stmt = s, setup = setup, number = 46)/46)*1000, 2)) + " ms")

È possibile seguire questo processo per eseguire il benchmark di qualsiasi funzione sia in Julia che in Python. Spero che il tuo dubbio sia stato chiarito.

---

Nota : da un punto di vista statistico, @benchmark è molto meglio di @time.