suggerimenti per la gestione delle corse di simulazione?

Questa domanda potrebbe essere un po 'fuori tema in comp-sci. se necessario, suggerisci dove si adatta.

La domanda riguarda come gestire in modo efficiente tutte le simulazioni.

diciamo, ad esempio, che una simulazione richiede la correzione di 2 parametri che devono essere definiti in un determinato intervallo di valori suggerito.

Per trovare un risultato migliore prodotto da una coppia di due parametri (confrontando il risultato della simulazione con i dati sperimentali, per esempio), si può fare un'analisi di sensibilità definendo tre valori per ciascun parametro, quindi formando 9 esecuzioni.

in precedenza ho usato sed per modificare gli input per ogni corsa e taggare ogni corsa scrivendo il valore e il nome del parametro nella cartella che memorizza gli input e i risultati di questa corsa. ma ho scoperto che questo è molto inefficiente una volta aumentato il numero di parametri (ad es. accedere al nome delle cartelle negli script per la stampa).

poi ho deciso di utilizzare numeri semplici come nomi di cartelle e di archiviare i dettagli con altri fogli di calcolo. in questo modo è ok finora ma richiede un lavoro faticoso. anche con la crescita delle piste, diventa comune fare errori, come condurre un'altra corsa che è già stata fatta un paio di giorni fa.

Hai qualche idea su come gestire queste corse? Penso che sarebbe estremamente importante per qualcuno che fa analisi Monte Carlo?

Grazie in anticipo!

TLDR
Usa Python per gestire / modificare i tuoi input e corri i tuoi output, e usa HDF5 per organizzare / archiviare i tuoi dati. Per quanto complesso possa sembrare all'inizio, sarà ancora più semplice di SQL-niente.

Risposta più lunga + Esempio
Uso personalmente una combinazione di script Python e il formato di file HDF5 per gestire questo tipo di situazioni. Gli script Python sono in grado di gestire le sostituzioni di testo necessarie per alterare i tuoi file di esecuzione (e possono verificare la presenza di esecuzioni duplicate), e con alcuni altri script puoi prendere i dati di output dal tuo programma e metterli in un file HDF5.

È più facile pensare a HDF5 come più o meno esattamente come un normale file system (cioè l'insieme di directory e sottodirectory sul tuo computer), ma che si ridimensiona facilmente a grandi set di dati. Ogni directory / sottodirectory può essere taggata con metadati (nel tuo caso o solo i parametri che stai variando o l'intero set di parametri). Quando arriva il momento di analizzare i tuoi dati, puoi cercarli in base ai metadati.

Ecco un breve esempio di come funzionerebbe sulla base di alcuni dei miei dati di simulazione (già in formato HDF5) che assomiglia a questo:

mydata.hdf5
|___Run01(metadata: {size:13, maxSteps:1e7, maxTime:inf})
|___Run02(metadata: {size:10, maxSteps:1e6, maxTime:inf})
|___Run03(metadata: {size:13, maxSteps:1e7, maxTime:inf})
|___Run04(metadata: {size:9, maxSteps:1e7, maxTime:inf})

mydata.hdf5è il file HDF5 e ciascuno di Runxx è una sottodirectory che contiene i dati di output di una determinata simulazione e che è taggato con i metadati associati. Uno script Python che cerca tra le esecuzioni e restituisce un elenco di quelli con i metadati desiderati sarebbe simile al seguente:

import sys
import h5py    #the python module that interfaces with HDF5

def GetRuns(hdfRoot, attributeValuePairs):
    return [subdir for subdir in hdfRoot.values() if not(attributeValuePairs.viewitems() - dict(subdir.attrs).viewitems())]

if __name__=="__main__":
    attributeValuePairs = dict(zip(sys.argv[2::2], sys.argv[3::2]))
    with h5py.File(sys.argv[1]) as hdfRoot:
        runs = GetRuns(hdfRoot, attributeValuePairs)

        #do something here with runs...

        print runs

Quindi, se fossi su una riga di comando in una directory contenente, mydata.hdf5potrei eseguire lo script sopra in questo modo:

python myscript.py mydata.hdf5 maxSteps 1e7 size 13

che direbbe allo script di trovare eventuali esecuzioni con metadati parzialmente o totalmente corrispondenti {'maxSteps':'1e7', 'size':'13'}. Lo script potrebbe quindi manipolare quei dati come preferisci (nella sezione "fai qualcosa qui"), e quindi stamperebbe un elenco che assomiglierebbe a questo:

["Run01", "Run03"]

Una nota però è che HDF5 presenterà una mappatura totalmente naturale per i tuoi dati solo se è possibile rappresentare i tuoi dati come un insieme di matrici n-dimensionali. È abbastanza comune che l'output delle simulazioni si trovi in ​​una sorta di array, quindi probabilmente questo non sarà un problema.

Buoni punti di partenza
Python: http://www.openbookproject.net/thinkcs/python/english2e/
HDF5: http://www.h5py.org/docs/

Penso che dovremmo sapere qualcosa in più sul tuo flusso di lavoro per formulare raccomandazioni serie.

Suggerirei di trattare le tue corse come un archivio di valori-chiave. Crea un semplice database per tutti i metadati per ciascuna corsa, quindi esegui l'hash delle informazioni pertinenti della corsa in una chiave che assegni a ciascun output.

Nella situazione più semplice, useresti un file di testo per il tuo archivio di metadati e aggiungeresti in sicurezza linee di metadati su ogni corsa al tuo file di testo. È quindi possibile archiviare le esecuzioni di output nel modo desiderato (una singola directory, backup con un elenco dei contenuti, ecc ...)

Puoi implementare questa strategia in qualsiasi lingua ti piaccia, ma sarebbe banale in Python. Potresti anche trarre vantaggio da alcune belle funzionalità come la capacità di Python di leggere e scrivere dati JSON o interagire con database SQL.

Questo approccio implementa un database molto semplice e leggero. Esistono strategie più pesanti che offrono maggiori garanzie di sicurezza, una nuova che potrebbe interessarti è SciDB . I database offrono maggiori garanzie sui tuoi dati e ti aiutano a scalare il tuo approccio per set di dati più grandi.