sugestão para gerenciar simulações?

Essas perguntas podem ser um pouco fora de tópico no comp-sci. se necessário, sugira onde ele se encaixa.

A questão é sobre como gerenciar todas as simulações executadas com eficiência.

digamos, por exemplo, uma simulação requer a fixação de 2 parâmetros que devem ser definidos em um determinado intervalo de valores sugerido.

Para encontrar um resultado melhor produzido por um par dos dois parâmetros (comparando o resultado da simulação com dados experimentais, por exemplo), pode-se fazer uma análise de sensibilidade definindo três valores para cada parâmetro e depois formulando 9 execuções.

anteriormente, uso o sed para alterar as entradas de cada execução e identificá-las, escrevendo o valor e o nome do parâmetro na pasta que armazena as entradas e os resultados dessa execução. mas achei que isso é muito ineficiente quando o número de parâmetros aumenta (por exemplo, acesse o nome das pastas nos scripts para plotagem).

Decidi usar números simples como nomes de pastas e armazenar os detalhes em outras planilhas. dessa forma, está tudo bem até agora, mas requer um trabalho trabalhoso. também com o crescimento das corridas, torna-se comum cometer erros, como realizar outra corrida que já foi realizada há alguns dias.

Você tem alguma ideia de como gerenciar essas execuções? Eu acho que seria extremamente importante para alguém fazer uma análise de Monte Carlo?

Desde já, obrigado!

TLDR
Use Python para gerenciar / modificar sua entrada e converter sua saída em coral, e use HDF5 para organizar / armazenar seus dados. Por mais complexo que possa parecer à primeira vista, ainda será mais simples do que o SQL - qualquer coisa.

Resposta mais longa + Exemplo
Eu pessoalmente uso uma combinação de scripts Python e o formato de arquivo HDF5 para lidar com esse tipo de situação. Os scripts Python podem lidar com as substituições de texto necessárias para alterar seus arquivos de execução (e podem verificar execuções duplicadas) e, com mais scripts, você pode pegar os dados de saída do seu programa e colocá-los em um arquivo HDF5.

É mais fácil pensar no HDF5 como mais ou menos exatamente como um sistema de arquivos normal (ou seja, o conjunto de diretórios e subdiretórios do seu computador), mas que pode ser facilmente escalado para grandes conjuntos de dados. Cada diretório / subdiretório pode ser marcado com metadados (no seu caso, apenas os parâmetros que você está variando ou todo o conjunto de parâmetros). Quando chegar a hora de analisar seus dados, você poderá pesquisá-los com base nos metadados.

Aqui está um pequeno exemplo de como isso funcionaria com base em alguns dos meus dados de simulação (já no formato HDF5) que se parecem com isso:

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é o arquivo HDF5 e cada um dos Runxx é um subdiretório que mantém os dados de saída de uma determinada simulação e que é identificado com os metadados associados. Um script python que pesquisa as execuções e retorna uma lista daqueles com os metadados desejados se pareceria com o seguinte:

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

Portanto, se eu estivesse em uma linha de comando em um diretório contendo, mydata.hdf5eu poderia executar o script acima da seguinte maneira:

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

que instruiria o script a encontrar quaisquer execuções com metadados que correspondam parcial ou totalmente {'maxSteps':'1e7', 'size':'13'}. O script poderia manipular esses dados da maneira que você quisesse (na seção "faça algo aqui") e, em seguida, imprimiria uma lista com a seguinte aparência:

["Run01", "Run03"]

Uma observação é que o HDF5 apresentará um mapeamento totalmente natural para seus dados apenas se for possível representá-los como um conjunto de matrizes n-dimensionais. É bastante comum que a saída das simulações esteja em algum tipo de matriz, portanto isso provavelmente não será um problema.

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

Acho que precisamos saber um pouco mais sobre o seu fluxo de trabalho para fazer recomendações sérias.

Sugiro tratar suas execuções como um armazenamento de valores-chave. Crie um banco de dados simples para todos os seus metadados para cada execução e, em seguida, adicione todas as informações relevantes da sua execução em uma chave que você atribui a cada saída.

Na situação mais simples, você usaria um arquivo de texto para seu armazenamento de metadados e anexaria com segurança linhas de metadados sobre cada execução ao seu arquivo de texto. Você pode armazenar suas execuções de saída da maneira que desejar (um único diretório, backups com uma lista do conteúdo, etc ...)

Você pode implementar essa estratégia em qualquer idioma que desejar, mas isso seria trivial no Python. Você também pode tirar proveito de alguns recursos interessantes, como a capacidade do Python de ler e gravar dados JSON ou interagir com bancos de dados SQL.

Essa abordagem implementa um banco de dados leve muito simples. Existem estratégias mais pesadas que fornecem mais garantias de segurança, uma nova que você pode estar interessado é o SciDB . Os bancos de dados fornecem garantias mais fortes sobre seus dados e ajudam a escalar sua abordagem para conjuntos de dados maiores.