Una comparazione tra software di analisi numerica

[PietroBaima]

Provato ora, viene 1.8 s circa.

Che strano, ti viene di più! Ho la stessa configurazione di processore della tua e a me viene 0.7s. Boh...
Devo investigare! Sono sempre a caccia di ottimizzazioni!

Però mi sembra che così si misuri anche il tempo di generazione dei numeri casuali,

Sì, però risparmi nella memorizzazione. Inoltre se compatti il codice l'ottimizzatore di Mathematica può fare meglio.

Codice: Seleziona tutto

In[1]:= Timing[RandomVariate[NormalDistribution[0.0, 1.0], {20.0, 10^6}];]
Out[1]= {0.781, Null}
In[2]:= Timing[Median[RandomVariate[NormalDistribution[0.0, 1.0], {20.0, 10^6}];];]
Out[2]= {0.703, Null}
In[3]:= Y = RandomVariate[NormalDistribution[0, 1], {20, 1000000}];
           Timing[Median[Y];]
Out[4]= {1.781, Null}
In[5]:= Y = RandomVariate[NormalDistribution[0.0, 1.0], {20.0, 10^6}];
           Timing[Median[Y];]
Out[6]= {1.703, Null}


mentre negli altri misuro solo il tempo di calcolo della mediana che, visti i risultati di Scilab

In effetti c'è uscito un po' con le ossa rotte, purtroppo!

Ciao,
Pietro.

mathsshot.jpg (69.75 KiB) Osservato 3627 volte

[cronos80]

Però mi sembra che così si misuri anche il tempo di generazione dei numeri casuali,

Anche in python la generazione dei numeri casuali viene conteggiata...

Modifico il codice:

Codice: Seleziona tutto

import numpy
import time

def test_ey(m,n):
    a=numpy.array(numpy.random.random_sample(size=(m,n)))
    starttime=time.time()*1000
    b=numpy.median(a, axis=1)
    stoptime=time.time()*1000
    print("%dms"%(stoptime-starttime))

test_ey(20,1000000)

Ottengo ~2100 ms
Testato su un Intel Core 2 Duo E8500 3.16GHz, 2GB di RAM 1.99GHz, Windows XP Sp3.

[angus]

la riga sopra non va messa nel computo del test

ovviamente si, hai ragione.
Ho scritto quelle 2 righe e poi le ho "trasformate" velocemente in funzione e mi è scappato import dentro
Grazie

[simo85]

1) Octave
(...)
Il tempo di calcolo della mediana è circa 0.3 s.

Non ho letto il PDF intero (ho appena finito di costruire un prototipo con un PIC32 ) ma se ne risulta che Octave è il più veloce tra tutti in tutto, questo è un notizione.

Come si dice da queste parti, "de pxxa madre".

[DirtyDeeds]

Che strano, ti viene di più! Ho la stessa configurazione di processore della tua e a me viene 0.7s. Boh...

L'ho provata di corsa, magari nel copiaincolla non ho fatto caso a qualche particolare.

Sì, però risparmi nella memorizzazione. Inoltre se compatti il codice l'ottimizzatore di Mathematica può fare meglio.

Eh, Mathematica è proprio nuovo per me. Sto facendo queste prove anche per impratichirmi un po'. Quindi quando posterò altro codice, fai tutte le correzioni che ti vengono in mente. Mi era sembrato di capire che l'ottimizzatore lavorasse sul blocco di input, e che quindi non ci dovessero essere differenze tra le mie istruzioni (scritte in uno stesso blocco) e la tua. Comunque, se da un lato trovo che la sintassi non sia sempre di immediata comprensione, dall'altro sono rimasto veramente impressionato dalla potenza di calcolo. Sebbene il tempo di calcolo qui sia un po' maggiore di quello di Octave, mi sarei aspettato molto di più da un programma che può fare anche calcoli simbolici.

In effetti c'è uscito un po' con le ossa rotte, purtroppo!

Sì, anche perché per ciò che riguarda l'usabilità e l'interfaccia grafica è molto meglio di Octave. Dovrei farlo recuperare un po' nel prossimo paio di test, sulla facilità di leggere file con una certa struttura.

Anche in python la generazione dei numeri casuali viene conteggiata...

Modifico il codice:

Grazie cronos80, mercoledì riprovo le diverse versioni sulla stessa macchina.

[DirtyDeeds]

ma se ne risulta che Octave è il più veloce tra tutti in tutto, questo è un notizione.

Le comparazioni vanno sempre prese con le molle, purtroppo non c'è modo di provare tutte le situazioni. Magari un programma è più veloce in un certo calcolo che serve a me, mentre è più lento in un calcolo che serve a qualcun altro.

Poi, la velocità non è tutto. Per esempio, nel caso che ho provato sopra, la differenza tra Octave e Mathematica è trascurabile for all practical purposes, per cui se devo scegliere, valuto anche altri criteri.

[DirtyDeeds]

Non ho resistito alla tentazione di giocare ancora un po' le differenze di velocità tra Octave e Mathematica anche sul PC portatile. I tempi sono un po' più lunghi, ma andando a contare anche il tempo di generazione dei numeri casuali, e utilizzando l'ottimizzazione suggerita da PietroBaima, Mathematica ne esce vincente.

Ho semplificato la funzione per Octave, togliendo la memorizzazione delle variabili:

Codice: Seleziona tutto

function [t] = test_median(m,n)
    tic();
    median(normrnd (0, 1, m, n),1);
    t = toc();
end

Aumentando le dimensioni della matrice,

Codice: Seleziona tutto

test_median(50,1000000)

Ottengo circa 4,5 s su un i3 @ 2,13 GHz

Con Mathematica,

Codice: Seleziona tutto

Timing[Median[RandomVariate[NormalDistribution[0.0, 1.0], {50, 10^6}];];]

ottengo circa 3,4 s.

E se aumento ancora la dimensione, non c'è storia, vince Mathematica a mani basse:

Codice: Seleziona tutto

In[3]:= Timing[Median[RandomVariate[NormalDistribution[0.0, 1.0], {200, 10^6}];];]

Out[3]= {13.696888, Null}

Octave:

Codice: Seleziona tutto

octave:10> test_median(200,1000000)
error: memory exhausted or requested size too large for range of Octave's index type -- trying to return to prompt

Per ovviare a questo problema sembra che si debba ricompilare Octave con l'opzione --enable-64, per avere un indirizzamento a 64 bit, ma non ho voglia di provare

Notare che su questo versante Scilab si comporta bene, la memoria viene sfruttata meglio:

Codice: Seleziona tutto

stacksize('max');
tic(); grand(200, 1000000, "nor", 0, 1); toc()

Su matrici così grandi, diventa dominante il tempo di generazione dei numeri casuali:

Codice: Seleziona tutto

In[5]:= Timing[RandomVariate[NormalDistribution[0.0, 1.0], {200, 10^6}];]

Out[5]= {13.119684, Null}

In[6]:= Timing[Median[RandomVariate[NormalDistribution[0.0, 1.0], {200, 10^6}];];]

Out[6]= {13.618887, Null}

Peccato che Scilab impieghi così tanto nel calcolo della mediana, perché i tempi di generazione dei numeri casuali sono comparabili a quelli di Mathematica.

Nota: la determinazione della mediana di un vettore è un parametro che, in linea di principio, richiede l'ordinamento del vettore. Nel caso di una matrice , per calcolare le mediane lungo le colonne, sarebbero richiesti ordinamenti di elementi. In pratica, ci sono algoritmi che evitano l'ordinamento (v. qui).

[DirtyDeeds]

Nei prossimi due esempi confronto i software sulle possibilità di leggere file con formati personalizzati. Come ho già accennato non è un'analisi sistematica: sono casi che mi sono capitati tra le mani e che ho voluto provare a risolvere con i tre software.

l primo esempio è il seguente. Ho un file di testo che contiene dei valori esadecimali che rappresentano dei campioni di forme d'onda da inviare a due DAC, N campioni per ciascun DAC. Devo fare dei controlli su questi valori per cui li voglio caricare su uno qualunque dei programmi che ho a disposizione e convertirli in formato numerico.

Il formato del file, di cui vi allego un esempio, è il seguente: il file è organizzato per linee di 64 caratteri; ogni codice è rappresentato da 4 cifre esadecimali e i campioni per i due DAC sono alternati; l'ultima linea contiene degli zeri che devono essere ignorati, ciò che conta è il numero totale di campioni per canale. I valori dei campioni di ciascun DAC devono venire memorizzati in due vettori separati.

Per la lettura da file, sia Octave che Scilab hanno delle funzioni C-like e la scrittura del codice è piuttosto semplice. I codici risultanti sono praticamente identici a parte i nomi delle funzioni.

Octave:

Codice: Seleziona tutto

N = 628;
fd = fopen('samples.txt', 'r');
D = fscanf(fd, '%4x', 2*N);
fclose(fd);
D1 = D(1:2:end);
D2 = D(2:2:end);

Scilab:

Codice: Seleziona tutto

N = 628;
fd = mopen('samples.txt', 'r');
D = mfscanf(2*N, fd, '%4x');
mclose(fd);
D1 = D(1:2:$);
D2 = D(2:2:$);

Mathematica mi ha dato più filo da torcere: è un mostro per ricchezza di funzioni, ma per chi è abituato ad un certo tipo di linguaggi, non è sempre intuitivo. Non sono quindi sicuro che il risultato ottenuto sia il migliore possibile, ma conto su PietroBaima per le rifiniture

Codice: Seleziona tutto

Chunk[s_, n_] := StringCases[s, Repeated[_, {n}]];

nSamples = 628;
hexData =  Flatten[Chunk[ReadList["samples.txt", String], 4]];
intData = Map[FromDigits[#, 16] &, hexData];
Subscript[samples, 1] = Take[intData, {1, 2*nSamples - 1, 2}];
Subscript[samples, 2] = Take[intData, {2, 2*nSamples, 2}];

Questo codice richiede forse qualche commento in più. La funzione Chunks suddivide una stringa in blocchi di n caratteri. Non è mia, ma l'ho presa da StackExchange. Viene usata nella riga

Codice: Seleziona tutto

hexData =  Flatten[Chunk[ReadList["samples.txt", String], 4]];

per suddividere ogni riga letta (attraverso ReadList) in blocchi di 4 caratteri. Poiché per ogni riga Chunk genera una sottolista, c'è bisogno della funzione Flatten per generare un'unica lista contenente le stringhe di codici esadecimali.

La riga

Codice: Seleziona tutto

intData = Map[FromDigits[#, 16] &, hexData];

applica ad ogni elemento della lista generata precedentemente la funzione FromDigits che converte da stringa, interpretata come sequenza di cifre esadecimali, a numero. I numeri così ottenuti sono immagazzinati nella lista intData. Le due istruzioni successive suddividono tale lista in due sottoliste, contenenti i codici pari e dispari.

Insomma, in questo caso, per immediatezza d'uso, giudicherei vincenti Octave e Scilab. Se poi qualcuno dei valenti pythonisti volesse cimentarsi anche con questo esercizio...

[angus]

Codice: Seleziona tutto

import numpy as np
d = np.genfromtxt('samples.txt', dtype=None, delimiter=4).flatten()[:-8]
d1 = d[0::2]
d2 = d[1::2]

[PietroBaima]

DirtyDeeds, ho buttato l'occhio sul tuo codice.
Non è affatto scritto male, anzi. Forse avrei usato Import, invece di ReadList, che è un pochino più efficiente, ma è solo una finezza pseudoinutile, specialmente se non inserita in un ciclo.

Purtroppo su una cosa conconderò sempre: Mathematica è fenomenale per la complicazione della sintassi (sigh...)
Per contro ti renderai conto che è molto potente.

Vantaggi e svantaggi...

Ciao,
Pietro.