project_dilemma

Dilema do projeto

O dilema do projeto é uma ferramenta de simulação para testar algoritmos no dilema do prisioneiro. Ele fornece uma interface padrão para definir as classes de algoritmo e simulação para que possam ser facilmente testadas. Inspirado neste vídeo Veritasium.

Índice

• Instalação
  • Pypi
  • Manual
• Configuração
  • Localização do arquivo de configuração
  • Formato de configuração
  • Importações dinâmicas
• Algoritmos
• Simulações
• Simulações geracionais

Instalação

Pypi

1. pip install project-dilemma

Manual

1. Baixe o Repo Git
2. Mudar para o diretório raiz do repo
3. pip install .

Configuração

Localização do arquivo de configuração

O dilema do projeto tentará automaticamente carregar a configuração dos diretórios de configuração do usuário e do sistema, geralmente definidos por $XDG_CONFIG_DIRS . Para a maioria dos usuários do Linux, isso verificará ~/.config/project_dilemma e eles em algum lugar em /etc .

Esse comportamento pode ser substituído especificando o sinalizador --config para o arquivo de configuração que você deseja usar.

Formato de configuração

O dilema do projeto usa o formato TOML para arquivos de configuração. Este é um formato legível por humanos que é fácil de escrever. O esquema foi fornecido abaixo:

 simulation_id = " name of simulation "
algorithms_directory = " /path/to/algorithms/ "
nodes = [ { node_id = " node_1 " , algorithm = { file = " foo.py " , object = " Foo " }, quantity = 11 },
          { node_id = " node_2 " , algorithm = { file = " bar/baz.py " , object = " Baz " } } ]
simulation = { file = " foobar.py " , object = " GenerationalFooBar " }
generational_simulation = { file = " foobar.py " , object = " FooBar " }
simulation_arguments = { foo = " bar " }
simulation_data = " path/to/round.json "
simulation_data_output = " path/to/round.json "
simulation_results_output = " path/to/results.json "
simulations_directory = " /path/to/simulations/ "

• algoritmos_directory
  • Um caminho para o diretório que contém os arquivos de algoritmos
• Geracional_simulação
  • A simulação para executar para cada geração em uma simulação geracional como uma importação dinâmica
• nós
  • Uma variedade de tabelas que especificam:
    • ID do nó
    • algoritmo, conforme definido nas importações dinâmicas
    • Quantidade, se não for especificada, então 1 nó é assumido
      • Nota: O índice do nó será anexado à seção Node_Id
• simulação
  • A simulação para ser executada como uma importação dinâmica
• simulation_id
  • O nome da simulação
• simulation_argudes
  • Argumentos para passar para a simulação
• Simulation_data
  • Caminho para um arquivo JSON contendo dados de simulação anteriores
• simulation_data_output
  • Caminho para escrever os dados de simulação como um JSON
• simulation_results_output
  • Caminho para escrever os resultados da simulação
• Simulações_directory
  • Um caminho para o diretório que contém arquivos de simulação adicionais
  • Necessário para simulações fornecidas pelo usuário

Importações dinâmicas

Como muitos dos objetos, como os algoritmos e simulações, podem ou devem ser fornecidos pelo usuário, esses dados devem ser importados dinamicamente. Para importar facilmente esses objetos sem importar todas as simulações e algoritmo, o formato a seguir pode ser usado para informar ao programa onde procurar as importações:

 { file = " path/to/file " , object = " ObjectToImport " }

• arquivo
  • Um caminho para o arquivo que contém o objeto em relação ao diretório associado na configuração
  • Necessário para algoritmos e simulações fornecidas pelo usuário
• objeto
  • O objeto para importar
    • Para simulações construídas, especifique o nome da classe de simulação aqui

Algoritmos

Os algoritmos podem ser definidos com muita facilidade. Apenas quatro coisas devem ser feitas para subclasse a interface do algoritmo:

1. Definir nome da classe
2. Definir algorithm_id
3. Passe as mutações para o init da interface (consulte o modelo, por exemplo)
4. Implementar a função decide
5. Definir mutações (opcional)

A função decide é o que a simulação usa para executar o algoritmo. Ele aceita um objeto project_dilemma.interfaces.base.Rounds que pode ser usado para obter os resultados das rodadas anteriores. A função deve retornar True para cooperação e False para deserção.

Se você deseja adicionar mutações, defina a lista de mutações estáticas após definir a classe para evitar importações circulares.

Um modelo foi fornecido em templates/algorithm_template.py para facilitar o uso.

Simulações

Simulações mais complicadas de configurar em comparação com os algoritmos. Você só precisa substituir os métodos run_simulation e process_simulation , mas estes são incrivelmente importantes.

run_simulation retorna um objeto project_dilemma.interfaces.base.Simulations que serão usadas pelo process_simulation para obter os resultados.

Por exemplo, as simulações padrão fornecidas processam os dados de rodadas para calcular pontuações para cada nó Um modelo pode ser encontrado em templates/simulation_template.py .

Simulações geracionais

Simulações geracionais são enganosamente simples. Existe apenas uma função para substituir: generational_hook . No entanto, isso significa que todo o processamento geracional deve ser feito nesta função.

Um modelo foi fornecido em templates/generational_simulation_template.py .

Licença

Copyright 2023 Gabriele Ron

Licenciado sob a licença Apache, versão 2.0 (a "licença"); Você não pode usar esse arquivo, exceto em conformidade com a licença. Você pode obter uma cópia da licença em

 http://www.apache.org/licenses/LICENSE-2.0

A menos que exigido pela lei aplicável ou acordada por escrito, o software distribuído pela licença é distribuído "como está", sem garantias ou condições de qualquer tipo, expressa ou implícita. Consulte a licença para o idioma específico que rege as permissões e limitações sob a licença.

Este projeto utiliza o projeto PlatformDirs, licenciado sob a licença do MIT. Copyright (C) 2010-202X Os desenvolvedores de plataformas