sugerencia para gestionar ejecuciones de simulación?

Estas preguntas pueden estar un poco fuera de tema en comp-sci. si es necesario, sugiera dónde encaja.

La pregunta es sobre cómo administrar todas las ejecuciones de simulación de manera eficiente.

digamos, por ejemplo, una simulación requiere la fijación de 2 parámetros que deben definirse en un cierto rango de valores sugeridos.

Para encontrar un mejor resultado producido por un par de los dos parámetros (al comparar el resultado de la simulación con datos experimentales, por ejemplo), se puede hacer un análisis de sensibilidad definiendo tres valores para cada parámetro y luego formulando 9 corridas.

anteriormente utilizo sed para cambiar las entradas para cada ejecución, y etiqueto cada ejecución escribiendo el valor y el nombre del parámetro en la carpeta que almacena las entradas y los resultados de esta ejecución. pero descubrí que esto es muy ineficiente una vez que aumenta el número de parámetros (por ejemplo, acceda al nombre de las carpetas en los scripts para trazar).

Luego decidí usar números simples como nombres de carpetas y almacenar el detalle en otras hojas de cálculo. esta manera está bien hasta ahora pero requiere un trabajo laborioso. También con el crecimiento de las carreras, se vuelve común cometer errores, como realizar otra carrera que ya se hizo hace un par de días.

¿Tienes alguna buena idea sobre la gestión de estas carreras? ¿Creo que sería extremadamente importante para alguien que realiza el análisis de Monte Carlo?

¡Gracias por adelantado!

TLDR
Use Python para administrar / modificar su entrada y coral su salida, y use HDF5 para organizar / almacenar sus datos. Por complejo que parezca al principio, aún será más simple que SQL-cualquier cosa.

Respuesta más larga + Ejemplo
Yo personalmente uso una combinación de secuencias de comandos Python y el formato de archivo HDF5 para tratar este tipo de situaciones. La secuencia de comandos de Python puede manejar las sustituciones de texto necesarias para alterar sus archivos de ejecución (y puede verificar si hay ejecuciones duplicadas), y con algunas secuencias de comandos más puede tomar los datos de salida de su programa y ponerlos en un archivo HDF5.

Es más fácil pensar que HDF5 es más o menos exactamente como un sistema de archivos normal (es decir, el conjunto de directorios y subdirectorios en su computadora), pero que se adapta fácilmente a grandes conjuntos de datos. Cada directorio / subdirectorio se puede etiquetar con metadatos (en su caso, ya sea solo los parámetros que está variando o el conjunto completo de parámetros). Cuando llegue el momento de analizar sus datos, puede buscarlos en función de los metadatos.

Aquí hay un breve ejemplo de cómo funcionaría esto basado en algunos de mis datos de simulación (ya en formato HDF5) que se ve así:

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.hdf5es el archivo HDF5, y cada uno de Runxx es un subdirectorio que contiene los datos de salida de una simulación dada, y que está etiquetado con los metadatos asociados. Un script de Python que busca en las ejecuciones y devuelve una lista de aquellos con los metadatos deseados se vería así:

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

Entonces, si estaba en una línea de comando en un directorio que contiene mydata.hdf5, podría ejecutar el script anterior de la siguiente manera:

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

lo que le indicaría al script que encuentre cualquier ejecución con metadatos que coincidan parcial o totalmente {'maxSteps':'1e7', 'size':'13'}. El script podría manipular esos datos como quisiera (en la sección "hacer algo aquí"), y luego imprimiría una lista que se vería así:

["Run01", "Run03"]

Sin embargo, una nota es que HDF5 presentará una asignación totalmente natural para sus datos solo si es posible representar sus datos como un conjunto de matrices n-dimensionales. Es bastante común que la salida de las simulaciones esté en algún tipo de matriz, por lo que probablemente esto no sea un problema.

Buenos puntos de partida
Python: http://www.openbookproject.net/thinkcs/python/english2e/
HDF5: http://www.h5py.org/docs/

Creo que necesitaríamos saber un poco más sobre su flujo de trabajo para hacer recomendaciones serias.

Sugeriría tratar sus carreras como una tienda de valores clave. Cree una base de datos simple para todos sus metadatos para cada ejecución, y luego agregue cualquier información relevante de su ejecución en una clave que asigne a cada salida.

En la situación más simple, usaría un archivo de texto para su almacén de metadatos y agregaría líneas de metadatos de manera segura sobre cada ejecución a su archivo de texto. Luego puede almacenar sus ejecuciones de salida como desee (un único directorio, copias de seguridad con una lista de los contenidos, etc.)

Puede implementar esta estrategia en cualquier idioma que desee, pero esto sería trivial en Python. También podría aprovechar algunas características interesantes como la capacidad de Python para leer y escribir datos JSON o interactuar con bases de datos SQL.

Este enfoque implementa una base de datos liviana muy simple. Existen estrategias más pesadas que brindan más garantías de seguridad, una nueva que podría interesarle es SciDB . Las bases de datos proporcionan garantías más sólidas sobre sus datos y lo ayudan a escalar su enfoque para conjuntos de datos más grandes.